TypeScript Cheatsheet 07 — Conditional and Mapped Types

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

type A = IsString<"hi">;        // true
type B = IsString<42>;          // false

type Return<T> = T extends (...a: any[]) => infer R ? R : never;
type Arg0<T>   = T extends (a: infer A, ...rest: any[]) => any ? A : never;
type Unwrap<T> = T extends Promise<infer U> ? U : T;
type Elem<T>   = T extends (infer E)[] ? E : never;

type ToArray<T> = T extends any ? T[] : never;
type R = ToArray<string | number>;     // string[] | number[]

type ToArrayWide<T> = [T] extends [any] ? T[] : never;
type R = ToArrayWide<string | number>;  // (string | number)[]

type Filter<T, U> = T extends U ? T : never;

type Nums = Filter<string | number | boolean, number>;   // number

type Partial2<T> = { [K in keyof T]?: T[K] };
type Readonly2<T> = { readonly [K in keyof T]: T[K] };
type Nullable<T> = { [K in keyof T]: T[K] | null };

type Mutable<T> = { -readonly [K in keyof T]: T[K] };
type Required2<T> = { [K in keyof T]-?: T[K] };

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};

type G = Getters<{ id: number; name: string }>;
// { getId: () => number; getName: () => string }

type StringFields<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K]
};

type S = StringFields<{ a: string; b: number; c: string }>;
// { a: string; c: string }

type Promisify<T> = {
  [K in keyof T]: T[K] extends (...a: infer A) => infer R
    ? (...a: A) => Promise<R>
    : T[K]
};

type DeepPartial<T> = T extends object
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;

type Path<T> = T extends object
  ? { [K in keyof T & string]: `${K}` | `${K}.${Path<T[K]> & string}` }[keyof T & string]
  : never;

type P = Path<{ a: { b: { c: number } } }>;
// "a" | "a.b" | "a.b.c"

type ValueAt<T, P extends string> =
  P extends `${infer K}.${infer Rest}`
    ? K extends keyof T ? ValueAt<T[K], Rest> : never
    : P extends keyof T ? T[P] : never;

type SnakeToCamel<S extends string> =
  S extends `${infer L}_${infer R}`
    ? `${L}${Capitalize<SnakeToCamel<R>>}`
    : S;

type X = SnakeToCamel<"hello_world_foo">;     // "helloWorldFoo"

type Len<T extends readonly any[]> = T["length"];
type L = Len<[1, 2, 3]>;        // 3

type Head<T extends any[]> = T extends [infer H, ...any[]] ? H : never;
type Tail<T extends any[]> = T extends [any, ...infer R] ? R : [];

type T2U<T extends readonly any[]> = T[number];
type U = T2U<["a", "b", "c"]>;     // "a" | "b" | "c"

type UnionToIntersection<U> =
  (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;

type LastOf<U> =
  UnionToIntersection<U extends any ? () => U : never> extends () => infer R ? R : never;

type U2T<U, L = LastOf<U>> = [U] extends [never] ? [] : [...U2T<Exclude<U, L>>, L];