WbICHA

const error = Symbol();
type CheckSubKey<K, SK extends string> = K extends `${string}${SK}${string}`
  ? SK
  : SK & { [error]: '(!) Invalid subkey (!)' };

interface GetValue {
  <T extends object>(obj: T): <K extends keyof T>(key: K) => T[K];
  <T extends object, I extends boolean = false>(
    obj: T,
    isIncludeKey?: I,
  ): I extends true
    ? <K extends string>(key: CheckSubKey<keyof T, K>) => T[`${string}${K}${string}` & keyof T][]
    : <K extends keyof T>(key: K) => T[K];
}

const getValue: GetValue =
  (obj: object, isIncludeKey = false) =>
  (key: unknown): unknown[] => {
    if (!isIncludeKey) {
      return obj[key as keyof typeof obj];
    }

    return Object.entries(obj).reduce((result: unknown[], pair: [key: string, value: unknown]) => {
      const [pairKey, pairValue] = pair;

      if (pairKey.includes(key as string)) {
        return [...result, pairValue];
      }

      return result;
    }, []);
  };

const o = {
  asd: 1 as const,
  asdfg: '2' as const,
  qweg: [3] as const,
};

const v1 = getValue(o)('asd'); // 1
const v2 = getValue(o, true)('a'); // (1 | "2")[]
const v3 = getValue(o, true)('f'); // "2"[]
const v4 = getValue(o, true)('g'); // ("2" | readonly [3])[]
const v5 = getValue(o, true)('uuu'); // error

type JoinKeys<T extends object> = JoinKeysDeep<T> extends infer J extends Record<
  string,
  unknown
>
  ? { [Key in J extends J ? keyof J : never]: J extends J ? J[Key] : never }
  : never;

type JoinKeysDeep<
  T extends object,
  K extends keyof T = JoinKeysDeep.GetKeys<T> & keyof T,
> = K extends K & (string | number)
  ? T[K] extends object
    ? JoinKeysDeep<T[K]> extends infer J extends Record<string, unknown>
      ? J extends J
        ? Record<`${K | '*'}.${keyof J & (string | number)}`, J[keyof J]>
        : never
      : never
    : Record<K | '*', T[K]>
  : never;
namespace JoinKeysDeep {
  export type GetKeys<T> = T extends unknown[]
    ? keyof T &
        (number extends T['length']
          ? // array
            number
          : // tuple
            `${number}`)
    : keyof T;
}

type ButtonType = 'button' | 'a';

interface ButtonTypeProps extends Record<ButtonType, object> {
  button: {};
  a: { href: string };
}

type CommonProps = {
  children: React.ReactNode;
  variant?: 'plain' | 'tonal' | 'filled' | 'outlined';
  justify?: 'start' | 'center' | 'end';
};

type Props<T extends ButtonType> = ButtonTypeProps[T] & CommonProps & ComponentPropsWithoutRef<T>;

type ButtonComponent<T extends ButtonType = ButtonType> = UnionToIntersection<
  T extends T ? ForwardRefExoticComponent<Props<T> & RefAttributes<ComponentRef<T>>> : never
>;

const isLinkProps = (props: Props<ButtonType>): props is Props<'a'> => 'href' in props;

const Button = forwardRef(
  <T extends ButtonType = ButtonType>(props: Props<T>, ref: ForwardedRef<ComponentRef<T>>) => {
    if (isLinkProps(props)) {
      return (
        <a ref={ref as ForwardedRef<ComponentRef<'a'>>} href={props.href} className="button">
          {props.children}
        </a>
      );
    }

    return (
      <button ref={ref as ForwardedRef<ComponentRef<'button'>>} type="button" className="button">
        {props.children}
      </button>
    );
  },
) as ButtonComponent;

Button.displayName = 'Button';

type ExtractValuesFromSubKeys<T extends object, SK extends string, K extends keyof T & string = keyof T & string> = K extends `${string}${SK}${string}` ? T[K] : never

function getValue<T extends object>(obj: T, isIncludeKey?: false): <K extends keyof T>(key: K) => T[K]
function getValue<T extends object>(obj: T, isIncludeKey: true): <SK extends string>(subKey: SK) => ExtractValuesFromSubKeys<T, SK>[]
function getValue<T extends object>(obj: T, isIncludeKey?: boolean) {
  return (keyOrSubKey: string) => {
    if (!isIncludeKey) {
      const key = keyOrSubKey as keyof T

      return obj[key];
    }

    const subKey = keyOrSubKey

    return Object.keys(obj).filter(key => key.includes(subKey)).map(key => obj[key as keyof T])
  }
}

const getter = getValue({ aaa: 1, bbb: '2', ccc: [3], abc: null }, true);

const ttt1 = getter("a") // (number | null)[]
const ttt2 = getter("bb") // string[]
const ttt3 = getter("ccc") // number[][]
const ttt4 = getter("unknown") // never[]

type OverloadProps<TOverload> = Pick<TOverload, keyof TOverload>;

type OverloadUnionRecursive<TOverload, TPartialOverload = unknown> = TOverload extends (
  ...args: infer TArgs
) => infer TReturn
  ? // Prevent infinite recursion by stopping recursion when TPartialOverload
    // has accumulated all of the TOverload signatures.
    TPartialOverload extends TOverload
    ? never
    :
        | OverloadUnionRecursive<
            TPartialOverload & TOverload,
            TPartialOverload & ((...args: TArgs) => TReturn) & OverloadProps<TOverload>
          >
        | ((...args: TArgs) => TReturn)
  : never;

type OverloadUnion<TOverload extends (...args: any[]) => any> = Exclude<
  OverloadUnionRecursive<
    // The "() => never" signature must be hoisted to the "front" of the
    // intersection, for two reasons: a) because recursion stops when it is
    // encountered, and b) it seems to prevent the collapse of subsequent
    // "compatible" signatures (eg. "() => void" into "(a?: 1) => void"),
    // which gives a direct conversion to a union.
    (() => never) & TOverload
  >,
  TOverload extends () => never ? never : () => never
>;

// Inferring a union of parameter tuples or return types is now possible.
type OverloadParameters<T extends (...args: any[]) => any> = Parameters<OverloadUnion<T>>;
type OverloadReturnType<T extends (...args: any[]) => any> = ReturnType<OverloadUnion<T>>;

interface Num <T>{
    resultedType: T extends { valueOf: () => infer P } ? P : never
}

const evgeniy = <T extends string | number>(x: T): Num<T> {