Утилитные типы с нуля

Семейство mapped-типов

Вы использовали Partial, Required и Readonly сотни раз — но написали бы их с нуля? Как только вы можете, стандартная библиотека перестаёт быть чёрным ящиком и превращается в набор блоков, которые можно прочитать, адаптировать и перерасти. Partial, Required и Readonly — mapped-типы с модификатором; Pick и Record выбирают набор ключей:

type MyPartial<T>  = { [P in keyof T]?: T[P] };          // добавить ? к каждому ключу
type MyRequired<T> = { [P in keyof T]-?: T[P] };          // -? убирает опциональность
type MyReadonly<T> = { readonly [P in keyof T]: T[P] };   // добавить readonly
type MyPick<T, K extends keyof T> = { [P in K]: T[P] };   // отобразить подмножество ключей
type MyRecord<K extends keyof any, V> = { [P in K]: V };  // построить из ключей + значения

Синтаксис модификаторов — это вся суть: ? и readonly добавляют модификатор; -? и -readonly снимают его. keyof any — это string | number | symbol, легальное пространство ключей для Record.

Семейство условных: вывести интересную часть

ReturnType, Parameters, InstanceType и Awaited используют infer, чтобы вытащить кусок из структурной формы:

type MyReturnType<F> = F extends (...args: any) => infer R ? R : any;
type MyParameters<F> = F extends (...args: infer P) => any ? P : never;
type MyInstanceType<C> = C extends new (...args: any) => infer R ? R : any;

type R1 = MyReturnType<() => number>;          // ^? type R1 = number
type P1 = MyParameters<(a: string, b: number) => void>; // ^? type P1 = [a: string, b: number]

Awaited — рекурсивный: он разворачивает вложенные промисы и .then-аблы до итогового значения:

type MyAwaited<T> =
  T extends null | undefined ? T :
  T extends object & { then(onfulfilled: infer F, ...args: any): any }
    ? F extends (value: infer V, ...args: any) => any ? MyAwaited<V> : never
    : T;

type A1 = MyAwaited<Promise<Promise<string>>>;
//   ^? type A1 = string   (рекурсия разворачивает оба слоя)

Композиция: DeepPartial и DeepReadonly

Рекурсируйте mapped-тип во вложенные объекты с условным базовым случаем для не-объектов:

type DeepReadonly<T> = T extends (infer E)[]
  ? ReadonlyArray<DeepReadonly<E>>
  : T extends object
    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
    : T;

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

type Config = { db: { host: string; pool: { max: number } } };
type DC = DeepPartial<Config>;
//   ^? каждый уровень опционален: { db?: { host?: string; pool?: { max?: number } } }

Базовый случай — «не объект — вернуть как есть»; рекурсивный случай заново отображает каждое свойство через то же глубокое преобразование.

Ловушка Omit — и DistributiveOmit

Вот сюрприз дискриминированного объединения из Hook. Omit<T, K> = Pick<T, Exclude<keyof T, K>>. Когда T — объединение, keyof T схлопывается до только тех ключей, что есть в каждом члене:

type Circle = { kind: "circle"; radius: number };
type Square = { kind: "square"; side: number };
type Shape = Circle | Square;

type Bad = Omit<Shape, "kind">;
//   ^? type Bad = {}   (keyof Shape — это только "kind"; убрав его, не остаётся ничего)

// Принудительная дистрибуция, чтобы Omit выполнялся по членам:
type DistributiveOmit<T, K extends keyof any> =
  T extends unknown ? Omit<T, K> : never;

type Good = DistributiveOmit<Shape, "kind">;
//   ^? type Good = { radius: number } | { side: number }

Omit намеренно не-дистрибутивен — он работает с T как с целым, поэтому keyof (Circle | Square) — это лишь "kind" (пересечение наборов ключей). Обёртка в условие с голым параметром (T extends unknown ? Omit<T, K> : never) принуждает дистрибуцию: теперь Omit выполняется раз на вариант, и вы получаете ожидаемый по-вариантный результат. Этот единственный паттерн — самая частая причина, по которой люди думают, что Omit сломан на объединениях.