type-challenges 学習録

type MyPick<T, K> = any

function changeBackgroundColor<T>(element: T) {
  element.style.backgroundColor = 'red'
  // Property 'style' dose not exist on type 'T'
  return element
}

function changeBackgroundColor<T>(element: T) {
  // any型だとコンパイルエラーは回避できる
  // 型チェックされないためバグの可能性
  (element as any).style.backgroundColor = 'red'
  return element
}

function changeBackgroundColor<T extends HTMLElement>(element: T) {
  element.style.backgroundColor = 'red'
  return element
}

interface ValueObject<T> {
  value: T;
  toString(): string;
}

class UserId implements ValueObject<number> {
  publick value: number;

  publick constructor(value: number) {
    this.value = value
  }

  public toString(): string {
    return `${this.value}`
  }
}

class Entity<ID extends ValueObject<unknown>> {
  private id: ID;

  public constructor(id: ID) {
    this.id = id;
  }
}

type IsString<T> = T extends string ? true : false;
const a: IsString<'a'> = true

type If<C extends boolean, T, F> = C extends true ? T : F;

type Language = 'en' | 'fr' | 'it' | 'es'

type Butterfly = {
  [key in Language]: string;
}

consut butterfly: Butterfly = {
  en: "Butterfly",
  fr: "Papillon",
  it: "Farfalla",
  es: "Mariposa",
}

type Language = 'en' | 'fr' | 'it' | 'es'

type Butterfly = {
  [key in Language]: string;

  // ↓エラー
  name: string
}

type KeyValues = {
  [key in Language]: string;
}
type Name = {
  name: string
}
type KeyValuesAndName = KeyValues & Name

type If<C, T, F> = C extends true ? T : F;

type If<C extends boolean, T, F> = C extends true ? T : F;

type MyPick<T, K extends keyof T> = {
  [key in K]: T[key] 
}

let obj: {
  readonly foo: number;
};

type person = {
  'name': string
  'age': 10
}

type a = person['name'] // string
type b = person['age'] // 10 (numberではない) 

type TupleToObject<T extends readonly any[]> = {
  [P in T[number]] : P
}

type First<T extends ((number | object | undefined)[] | never)> = T extends never ? never : T[0] 

type First<T extends ((number | object | undefined)[])> = T extends never[] ? never : T[0] 

function printLang(ext: Extension): void {
  switch (ext) {
    case "js":
      console.log("JavaScript");
      break;
    case "ts":
      console.log("TypeScript");
      break;
    default:
     // Type 'string' is not assignable to type 'never'.
      const exhaustivenessCheck: never = ext;
      break;
  }
}

type First<T extends any[]> = T extends [] ? never : T[0]

type First<T extends any[]> = T extends [infer P, ...any[]] ? P : never

const hoge = "HOGE";
// type hoge: "HOGE"
let sameHoge = hoge;
// type sameHoge: string

type Id<T> = T extends { id: infer U } ? U : never 

export type Unpacked<T> = T extends { [K in keyof T]: infer U } ? U : never;

type First<T extends any[])> = T extends never[] ? never : T[0] 

type First<T extends any[]> = T extends [infer P, ...any[]] ? P : never

type First<T extends any[]> = T extends [infer P, ...any[]] ? P : never

  type Result = MyExclude<'a' | 'b' | 'c', 'a'> // 'b' | 'c'

type MyExclude<T, U> = T extends U ? never : T 

type X = Promise<string>
MyAwaited<X> // string

type MyAwaited<T> = Promise<U>

type MyAwaited<T extends Promise<any>> = T extends Promise<infer U> ? U : never

Promise<Promise<string | number>>

type MyAwaited<T extends PromiseLike<any>> = T extends PromiseLike<infer U>
  ? U extends PromiseLike<any>
    ? MyAwaited<U>
    : U
  : never;

type Result = Concat<[1], [2]>; // expected to be [1, 2]

type Concat<T extends any[], U extends any[]> = T[number] & U[number]

type Concat<T extends readonly any[], U extends readonly any[]> = [...T, ...U]

type isPillarMen = Includes<['Kars', 'Esidisi', 'Wamuu', 'Santana'], 'Dio'> // expected to be `false`

 T extends U ? true : false

type Includes<T extends readonly any[], U> = U extends T[number] ? true : false;

type Includes<T extends readonly any[], U> = T extends [infer L, ...infer R]
  ? [U, L] extends [L, U]
    ? true
    : Includes<R, U>
  : false

type Includes<T extends readonly any[], U> =
  T extends [infer L, ...infer R] ?
    [L, U] extends [U, L] ?
      true : Includes<R, U> :
    false;

type MyEqual<X, Y> = (<T>() => T extends X ? 1 : 2 ) extends (<T>() => T extends Y ? 1 : 2) ? true : false

type Includes<T extends readonly any[], U> = true extends {
  [I in keyof T]: MyEqual<T[I], U>
}[number] ? true : false

高階型（Higher-Order Types）
<T>() => T extends X ? 1 : 2 は型 T を引数として受け取り、T が X に割り当て可能な場合は 1 を、そうでない場合は 2 を返す関数の型を表します。この高階型は、型の割り当て可能性を評価するために使われます。

ジェネリック型の拡張性（Generics and Extensibility）
<T>() => T extends X ? 1 : 2 のような型を使うことで、任意の型 T が X に対してどのように振る舞うかをテストできます。これを Y にも同様に適用し、これら二つの関数型が等価であるかどうかをチェックします。

type Push<T extends unknown[], U> = [...T, U]

type Unshift<T extends unknown[], U> = [U, ...T]

function foo(arg1: string, arg2: number): void {}
// ↓
[string, number]

type MyParameters<T extends (...args: any[]) => any> = T extends infer U => any ? U[number] : []; 

type MyParameters<T extends (...args: any[]) => any> =
  T extends (args: infer U) => any ? U : []; 

type MyParameters<T extends (...args: any[]) => any> =
  T extends (args: infer U) => any ?
    U extends any[]
      ? U[number]
      : []
    : []

type MyParameters<T extends (...args: any[]) => any> = T extends (...args: infer U) => any ? U : never

type ConditionalTypes<T, U> = T extends U ? X : Y;
// Tが a | b となるのが、Distributive Conditional Types

type MyExclude<T, U> = T extends U ? never : T

type MyAwaited<T extends Promise<any>> =
  T extends Promise<infer U>
    ? U extends Promise<any>
      ?
        MyAwaited<U> : U
    : never;

type T = { then: (onfulfilled: (arg: number) => any) => any }

Expect<Equal<MyAwaited<T>, number>>

type MyAwaited<T extends PromiseLike<any>> =
  T extends PromiseLike<infer U>
    ? U extends PromiseLike<any>
      ?
        MyAwaited<U> : U
    : never;

type Includes<T extends readonly any[], U> =
  T extends [infer L,  ...infer R]
    ? [L, U] extends [U, L]
      ? true : Includes<R, U>
    : false

 Expect<Equal<Includes<[{ a: 'A' }], { readonly a: 'A' }>, false>>,
  Expect<Equal<Includes<[{ readonly a: 'A' }], { a: 'A' }>, false>>,

type Includes<T extends readonly any[], U> =
  T extends [infer L,  ...infer R]
    ? Equal<U, L> extends true
      ? true : Includes<R, U>
    : false

type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y
  ? 1
  : 2
  ? true
  : false;

T extends (...args: infer U) => any ? U : []

type MyReturnType<T extends (...args: any[]) => any> = T extends (...args: any[]) => infer U ? U : never;

type MyOmit<T, K extends keyof T> = {
  [key in K]: T[key] extends never ? never : T[key]
}

type Capitalize<S extends string> = intrinsic;

type MyOmit<T, K extends keyof T> = {
  [key in keyof T as key extends K ? never : key]: T[key]
}

key extends K ? never : key

type MyExclude<A, B> = A extends B ? never : A;
type MyOmit<T, K extends keyof T> = { [S in MyExclude<keyof T, K>]: T[S] }

type MyReadonly2<T, K extends keyof T> = {
  readonly [P in keyof T as P extends K ? P : never]: T[P]
} & {
  [P in keyof T as P extends K ? never : P]: T[P]
}

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in keyof T as P extends K ? P : never]: T[P]
} & {
  [P in keyof T as P extends K ? never : P]: T[P]
}

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [P in K]:T[P]
} & {
  [P in keyof T as P extends K ? never : P] : T[P]
}

type DeepReadonly<T> = {
  readonly [key in keyof T]: T[key] extends PropertyKey ? T[key]: DeepReadonly<T>
}

type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends Record<string, unknown> ? DeepReadonly<T[P]> : T[P];
}

type DeepReadonly<T> = {
  readonly [P in keyof T]: keyof T[P] extends never ? T[P] : DeepReadonly<T[P]>
}

  readonly [P in keyof T]: T[P] extends Record<string, unknown> ? DeepReadonly<T[P]> : T[P]

      l: [
        'hi',
        {
          m: ['hey']
        },
      ]

type TupleToUnion<T extends any[]> = T[number]

export type TupleToUnion<T> = T extends Array<infer ITEMS> ? ITEMS : never

type TupleToUnion<T extends ArrayLike<any>> = T extends [infer F, ...infer Last] ? TupleToUnion<Last> | F : never

type Chainable = {
  option(key: string, value: any): any
  get(): any
}

type Chainable<Props = {}> = {
  option(key: string, value: any): any
  get(): Props
}

type Chainable<Props = {}> = {
  option(key: string, value: any): Chainable
  get(): Props
}

type Chainable<Props = {}> = {
  option<K extends string, T>(key: K, value: T): Chainable<Props & { [key in K]: T }>;
  get(): Props
}

// name: numberとなってほしいが、なってくれない
const result3 = a
  .option('name', 'another name')
  // @ts-expect-error
  .option('name', 123)
  .get()

type StringNumber = Record<string, number>;
const value: StringNumber = { a: 1, b: 2, c: 3 };

type User = {
  surname: string;
  middleName?: string;
  givenName: string;
  age: number;
  address?: string;
  nationality: string;
  createdAt: string;
  updatedAt: string;
};
type Optional = "age" | "address" | "nationality" | "createdAt" | "updatedAt";
type Person = Omit<User, Optional>;

// res
type Person = {
  surname: string;
  middleName?: string;
  givenName: string;
};

type Chainable<T = {}> = {
  option<K extends string, V>(key: Exclude<K, keyof T>, value: V): Chainable<Omit<T,K> & Record<K, V>>;
  get(): T;
};

// Exclude的実装
type Hoge<T, U extends T> = T extends U ? never : T;

// Hogeにunion型の型引数を渡す場合
type Fuga = Hoge<'a' | 'b' | 'c' | 'd', 'a | b'>

// Conditional Typeのextendsの右側のunionが順番に展開されていく
/*
('a' extends 'a | b' ? never : T) |
('b' extends 'a | b' ? never : T) |
('c' extends 'a | b' ? never : T) |
('d' extends 'a | b' ? never : T) |
*/

type Obj = { [P in Key as `remapped-${P}`]: string };

type MyOmit<T extends {[S: string]: any}, K extends keyof T> = {
  [key in keyof T as key extends K ? never : key]:T[key]
}

type Last<T extends any[]> = T extends [...any, infer L] ? L : never;

type Pop<T extends any[]> = T extends [...infer U, infer L] ? U : [] 

type Pop<T extends any[]> = T extends [...infer U, any] ? U : [] 

type Pop<T extends any[]> = T['length'] extends 0  ? [] : T extends [...infer Arg, infer L] ? Arg : never

  const promise1 = Promise.resolve(3);
  const promise2 = 42;
  const promise3 = new Promise<string>((resolve, reject) => {
    setTimeout(resolve, 100, 'foo');
  });

  const p = PromiseAll([promise1, promise2, promise3] as const)

declare function PromiseAll<T extends any[]>(values: T): Promise<T>

const promiseAllTest2 = PromiseAll([1, 2, Promise.resolve(3)] as const)
const promiseAllTest3 = PromiseAll([1, 2, Promise.resolve(3)])
const promiseAllTest4 = PromiseAll<Array<number | Promise<number>>>([1, 2, 3])

Expect<Equal<typeof promiseAllTest2, Promise<[1, 2, number]>>>,
Expect<Equal<typeof promiseAllTest3, Promise<[number, number, number]>>>,
Expect<Equal<typeof promiseAllTest4, Promise<number[]>>>,

declare function PromiseAll<T extends any[]>(values: T):
  Promise<T extends Promise<infer U> ? U : T>

    /**
     * Creates a new resolved promise for the provided value.
     * @param value A promise.
     * @returns A promise whose internal state matches the provided promise.
     */
    resolve<T>(value: T | PromiseLike<T>): Promise<T>;

declare function PromiseAll<T extends any[]>(values: readonly [...T]): Promise<{
  [key in keyof T]: Awaited<T[key]>
}>

declare function PromiseAll<T extends any[]>(values: readonly [...T]): Promise<{
  [K in keyof T]: T[K] extends Promise<infer R> ? R : T[K] extends number ? T[K] : number
}>

type LookUp<U, T> = U['type'] extends T ? U : never

type LookUp<U, T> = U extends {type: T} ? U : never;

type LookUp<U, T extends string> = {
  [K in T]: U extends { type: T } ? U : never
}[T]

type TrimLeft<S extends string> = S extends infer ' ' + T ? T : S

type TrimLeft<S extends string> = S extends ` ${infer T}` ? TrimLeft<T> : S

  Expect<Equal<TrimLeft<'   \n\t foo bar '>, 'foo bar '>>,
  Expect<Equal<TrimLeft<' \n\t'>, ''>>,

type P = ' ' | '\n\t'
type TrimLeft<S extends string> = S extends `${P}${infer T}` ? TrimLeft<T> : S

type Whitespace = '\n' | ' ' | '\t';
type TrimLeft<S> = S extends `${Whitespace}${infer U}` ? TrimLeft<U> : S;

type Space = ' ' | '\t' | '\n'

type Trim<S extends string> =
  S extends `${Space}${infer U}`
  ? Trim<U>
  : S extends `${infer O}${Space}`
    ? Trim<O>
    : S

type Space = ' ' | '\t' | '\n';
type Trim<S extends string> = S extends `${Space}${infer T}` | `${infer T}${Space}` ? Trim<T> : S;

type WhiteSpace = ' ' | '\n' | '\t';
type TrimLeft<S extends string> = S extends `${WhiteSpace}${infer T}` ? TrimLeft<T> : S;
type TrimRight<S extends string> = S extends `${infer T}${WhiteSpace}` ? TrimRight<T> : S;
type Trim<S extends string> = TrimRight<TrimLeft<S>>;

`${infer C1}${infer C2}`

type MyCapitalize<S extends string> = S extends `${infer Head}${infer Other}` ? `${Uppercase<Head>}${Other}` : ''

interface ToUpperCase {
    a: "A"
    b: "B"
    c: "C"
    d: "D"
    e: "E"
    f: "F"
    g: "G"
    h: "H"
    i: "I"
    j: "J"
    k: "K"
    l: "L"
    m: "M"
    n: "N"
    o: "O"
    p: "P"
    q: "Q"
    r: "R"
    s: "S"
    t: "T"
    u: "U"
    v: "V"
    w: "W"
    x: "X"
    y: "Y"
    z: "Z"
}

type LowerCase = keyof ToUpperCase
type MyCapitalize<S extends string> = S extends `${infer First extends LowerCase}${infer Rest}` ? `${ToUpperCase[First]}${Rest}` : S

type Capitalize<S extends string> = S extends `${infer x}${infer tail}` ? `${Uppercase<x>}${tail}` : S;

type Replace<S extends string, From extends string, To extends string> =
  From extends ''
    ? S : S extends`${infer First}${From}${infer Last}`
      ? `${First}${To}${Last}` : S

type Replace<S extends string, From extends string, To extends string> =
  S extends `${infer L}${From extends '' ? never : From}${infer R}`
  ? `${L}${To}${R}`
  : S

type Replace<S extends string, From extends string, To extends string> = S extends `${infer U}${From}${infer V}` ?
  From extends '' ?
  `${U}${From}${V}` :
  `${U}${To}${V}` :
  S;

type ReplaceAll<S extends string, From extends string, To extends string> = From extends ''
    ? S : S extends`${infer First}${From}${infer Last}` ? ReplaceAll<`${First}${To}${Last}`, From, To> : S

  Expect<Equal<ReplaceAll<'foobarfoobar', 'ob', 'b'>, 'fobarfobar'>>,
  Expect<Equal<ReplaceAll<'foboorfoboar', 'bo', 'b'>, 'foborfobar'>>,

type ReplaceAll<S extends string, From extends string, To extends string> = From extends ''
  ? S
  : S extends `${infer R1}${From}${infer R2}`
  ? `${R1}${To}${ReplaceAll<R2, From, To>}`
  : S

type ReplaceAll<S extends string, From extends string, To extends string> = From extends '' ? S : S extends `${infer R}${From}${infer Q}` ? `${ReplaceAll<R, From, To>}${To}${ReplaceAll<Q, From, To>}` : S;

type AppendArgument<Fn extends (...args: any) => any, A> = Fn extends (...args: infer S) => infer T ? (x: A, ...args: S) => T: never

type AppendArgument<Fn, A> = Fn extends (...args: infer R) => infer T ? (...args: [...R, A]) => T : never

type Permutation<T, U = T> =
  [U] extends [never]
    ?
      []
    :
      T extends U ? [T, ...Permutation<Exclude<U, T>>] : []

Permutation<T, U = T>

type StrToArray<S> = S extends `${infer x}${infer xs}` ? [1, ...StrToArray<xs>] : [];
type LengthOfString<S extends string> = StrToArray<S>['length'];

type LengthOfString<
  S extends string,
  T extends string[] = []
> = S extends `${infer F}${infer R}`
  ? LengthOfString<R, [...T, F]>
  : T['length'];

type Flatten<T extends any[]> = T extends  [infer U] ? Flatten<[U]> : []

type Flatten<T> = T extends []
  ? [] 
  : T extends [infer First, ...infer Rest]
    ? [...Flatten<First>, ...Flatten<Rest>]
    : [T]

type AppendToObject<T, U extends string, V> = {
  [K in keyof T]: T[K]
}  & { U: V }

T & {
  [K in U]: V
}

type AppendToObject<T, U extends keyof any, V> = {
  [K in keyof T | U]: K extends keyof T ? T[K] : V;
};

type Absolute<T extends number | string | bigint> =
  T extends `${infer F}${infer L}` ?
    F extends '-' ?
      L : T
    : T

type Absolute<T extends number | string | bigint> = `${T}` extends `-${infer U}` ? U : `${T}`

type NumToStr<T extends number | bigint> = `${T}`

type StringToUnion<T extends string> = T extends `${infer F}${infer L}` ? F | StringToUnion<L> : never

type StringToUnion<T extends string, R extends string[] = []>
  = T extends `${infer First}${infer Rest}`
      ? StringToUnion<Rest, [...R, First]>
      : R[number]

type Merge<F, S> = {
  [K in keyof F | keyof S]:
    K extends keyof S ?
      S[K] :
      K extends keyof F ? F[K] : never
}

type Merge<F extends Record<string, any>, S extends Record<string, any>> = {
 [k in keyof (F & S)]: k extends keyof S ? S[k] : (F & S)[k]
}

type StringNumber = Record<string, number>;
const value: StringNumber = { a: 1, b: 2, c: 3 };

type Person = Record<"firstName" | "middleName" | "lastName", string>;
const person: Person = {
  firstName: "Robert",
  middleName: "Cecil",
  lastName: "Martin",
};

type Merge<F, S, O = F & S> = { [K in keyof O]: K extends keyof S ? S[K] : O[K] }

type KebabCase<S extends string> =
  S extends `${infer F}${infer L}` ?
    `${F extends Uppercase<F> ? Lowercase<F> : F}${KebabCase<L>}`
  : ''

type KebabCase<S extends string> = S extends `${infer S1}${infer S2}`
  ? S2 extends Uncapitalize<S2>
  ? `${Uncapitalize<S1>}${KebabCase<S2>}`
  : `${Uncapitalize<S1>}-${KebabCase<S2>}`
  : S;

type Diff<
  O extends Record<string, any>,
  O1 extends Record<string, any>,
  KEY extends number | string | symbol = keyof (O & O1) 
> = {
  [K in KEY]:
    K extends keyof O
    ?
      K extends keyof O1 ? never : O[K]
    :
      K extends keyof O1 ? O1[K] : never
}

type Diff<
  O extends Record<string, any>,
  O1 extends Record<string, any>,
  O2 extends (O & O1),
  KEY extends number | string | symbol = keyof O2
> = {
  [
    K in KEY as K extends keyof O ?
      K extends keyof O1 ? never : O[K]
    :
      K extends keyof O1 ? O1[K] : never
  ]: O2[K]
}

type Diff<O, O1> = {
  [K in keyof (O & O1) as K extends keyof (O | O1) ? never : K]: (O & O1)[K];
};

type Diff<O, O1> = {
  [K in Exclude<keyof (O & O1), keyof(O | O1)>]: (O & O1)[K]
}

type Diff<O, O1> = Omit<O & O1, keyof (O | O1)>;

type Falsy = false | 0 | '' | [] | {} | null | undefined | never

type Falsy = false | 0 | '' | [] | {} | null | undefined
type AnyOf<T extends readonly any[]> = T[number] extends Falsy ? false : true;

type AnyOf<T extends any[]> = T[number] extends 0 | '' | false | [] | {[key: string]: never} | null | undefined ? false : true;

type IsNever<T> = T extends never ? true : false;

type IsNever<T> = [T] extends [never] ? true : false;

type IsNever<T> = T[] extends never[] ? true : false;
type IsNever<T> = {t: T} extends {t: never} ? true : false;

type IsUnionImpl<T, C = T> = (T extends T ? C extends T ? true : unknown : never) extends true ? false : true;
type IsUnion<T> = IsUnionImpl<T>;

IsUnion<string>
=> IsUnionImpl<string, string>
=> (string extends string ? string extends string ? true : unknown : never) extends true ? false : true
=> (string extends string ? true : unknown) extends true ? false : true
=> (true) extends true ? false : true
=> false

IsUnion<string|number>
=> IsUnionImpl<string|number, string|number>
=> (string|number extends string|number ? string|number extends string|number ? true : unknown : never) extends true ? false : true
=> (
  (string extends string|number ? string|number extends string ? true : unknown : never) |
  (number extends string|number ? string|number extends number ? true : unknown : never)
) extends true ? false : true
=> (
  (string|number extends string ? true : unknown) |
  (string|number extends number ? true : unknown)
) extends true ? false : true
=> (
  (
    (string extends string ? true : unknown) |
    (number extends string ? true : unknown)
  ) |
  (
    (string extends number ? true : unknown) |
    (number extends number ? true : unknown)
  )
) extends true ? false : true
=> (
  (
    (true) |
    (unknown)
  ) |
  (
    (unknown) |
    (true)
  )
) extends true ? false : true
=> (true|unknown) extends true ? false : true
=> (unknown) extends true ? false : true
=> true

=> (string|number extends string|number ? string|number extends string|number ? true : unknown : never) extends true ? false : true
=> (
  (string extends string|number ? string|number extends string ? true : unknown : never) |
  (number extends string|number ? string|number extends number ? true : unknown : never)
) extends true ? false : true

type A<T> = T extends string ? T[] : never;
A<'test1' | 'test2'> // ユニオンが分配され、'test1'[] | 'test2'[] となる。('test1' | 'test2')[] とはならない。

type ReplaceKeys<U, T, Y> =
  U extends Record<string, any> ? {
    Mapped Types
  } : U

type ReplaceKeys<U, T, Y> =
  U extends Record<string, any> ? {
    [K in keyof U]: K extends T ? ここに処理を追加 : U[K]
  } : U

type ReplaceKeys<U, T, Y extends Record<string, any>> =
  U extends Record<string, any> ? {
    [K in keyof U]:
      K extends T ?
        K extends keyof Y ? K[keyof Y]
        : U[K]
  } : U

type ReplaceKeys<U, T, Y> = { [K in keyof U]: K extends T ? K extends keyof Y ? Y[K] : never : U[K] }

type RemoveIndexSignature<T extends {[key: string]: any}> = {
  [K in keyof T]: K extends [key: string | number | symbol] ? never : T[K]
}