递归类型与深度操作

1. 递归条件类型

TS 4.5+ 支持尾递归优化，使得深度递归类型成为可能。

// 深度 Readonly
type DeepReadonly<T> = T extends Function
  ? T
  : T extends object
    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
    : T;

// 深度 Partial
type DeepPartial<T> = T extends Function
  ? T
  : T extends object
    ? { [K in keyof T]?: DeepPartial<T[K]> }
    : T;

// 深度 Required
type DeepRequired<T> = T extends Function
  ? T
  : T extends object
    ? { [K in keyof T]-?: DeepRequired<T[K]> }
    : T;

2. 深度 Pick/Omit

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

type User = { profile: { name: string; address: { city: string } }; age: number };
type Result = DeepPick<User, 'profile.address.city'>;
// { profile: { address: { city: string } } }

3. 递归类型展开

// 展开嵌套数组
type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;
type Nested = string[][][];
type Flat = Flatten<Nested>; // string

// 递归键路径
type PathKeys<T, Prefix extends string = ''> = T extends object
  ?
      | {
          [K in keyof T & string]: PathKeys<T[K], Prefix extends '' ? K : `${Prefix}.${K}`>;
        }[keyof T & string]
      | Prefix
  : Prefix;

4. 递归类型限制

// TS 有递归深度限制（约 1000 层）
// 超过会报 "Type instantiation is excessively deep"

// 使用尾递归优化（TS 4.5+）
type Accurate<T, Acc extends any[] = []> = T extends `${Acc['length']}`
  ? Acc['length']
  : Accurate<T, [...Acc, 0]>;