深入理解TypeScript递归类型：构建深层可写属性并规避深度限制

// 1. IfEquals: 比较两个类型是否完全相等
type IfEquals<X, Y, A = X, B = never> =
  (<T>() => T extends X ? 1 : 2) extends
  (<T>() => T extends Y ? 1 : 2) ? A : B;

// 2. WritableKeys: 提取类型T中可写的（非函数、非只读）属性键
type WritableKeys<T> = {
  [P in keyof T]: T[P] extends Function ? never : IfEquals<{ [Q in P]: T[P] }, { -readonly [Q in P]: T[P] }, P>
}[keyof T];

// 3. DeepWritablePrimitive: 定义深层可写类型中的基本类型
type DeepWritablePrimitive = undefined | null | boolean | string | number | Function;

// 优化后的 DeepWritable 类型
type DeepWritable<T> =
  | T extends DeepWritablePrimitive ? T // 基本类型直接返回
  : T extends (infer U)[] ? DeepWritable<U>[] // 数组递归处理元素
  : T extends Map<any, any> ? ( // 优先处理 Map 类型
      T extends Map<infer K, infer V> ? Map<K, DeepWritable<V>> : never
    )
  : T extends Set<infer V> ? Set<DeepWritable<V>> // Set 递归处理元素
  : DeepWritableRecord<T>; // 其他对象类型递归处理

// 优化后的 DeepWritableRecord 类型，保留可选性
type DeepWritableRecord<T> = {
  // 使用 Pick 筛选出可写键，并保留其原始的可选性
  [K in keyof Pick<T, WritableKeys<T>>]: DeepWritable<T[K]>
}

// 辅助类型定义 (如上所示)
type IfEquals<X, Y, A=X, B=never> =
  (<T>() => T extends X ? 1 : 2) extends
  (<T>() => T extends Y ? 1 : 2) ? A : B;

type WritableKeys<T> = {
  [P in keyof T]: T[P] extends Function ? never : IfEquals<{ [Q in P]: T[P] }, { -readonly [Q in P]: T[P] }, P>
}[keyof T];

type DeepWritablePrimitive = undefined | null | boolean | string | number | Function;

// 优化后的 DeepWritable 类型定义 (如上所示)
type DeepWritable<T> =
  | T extends DeepWritablePrimitive ? T
  : T extends (infer U)[] ? DeepWritable<U>[]
  : T extends Map<any, any> ? (
      T extends Map<infer K, infer V> ? Map<K, DeepWritable<V>> : never
    )
  : T extends Set<infer V> ? Set<DeepWritable<V>>
  : DeepWritableRecord<T>;

type DeepWritableRecord<T> = {
  [K in keyof Pick<T, WritableKeys<T>>]: DeepWritable<T[K]>
}

// 示例类结构
class Base {
  // set 方法接受一个 Partial<DeepWritable<typeof this>> 类型的参数
  set(data?: Partial<DeepWritable<typeof this>>) {
    Object.assign(this, data);
  }
}

class Parent extends Base {
  name?: string; // 可选属性
  age: number = 0; // 必选属性
  readonly id: string = 'some-id'; // 只读属性，应被排除
  private _secret: string = 'secret'; // 私有属性，类型系统通常不直接处理，但如果通过公共方法暴露则需注意
  someMethod() { return 'hello'; } // 方法，应被排除
  arr?: Parent[]; // 嵌套数组
  dataMap?: Map<string, Parent>; // 嵌套 Map
  dataList?: Set<string>; // 嵌套 Set
}

const record = new Parent();

// 使用 set 方法更新属性
record.set({
  name: 'New Name', // 更新可选属性
  age: 30, // 更新必选属性
  // id: 'new-id', // 错误：'id' 是只读属性，已被 WritableKeys 排除
  // someMethod: () => 'new hello', // 错误：'someMethod' 是函数，已被 WritableKeys 排除
  arr: [{ // 嵌套数组
    name: 'Child 1',
    age: 5
  }, {
    name: 'Child 2',
    arr: [{ name: 'Grandchild 1' }] // 更深层次的嵌套
  }],
  dataMap: new Map([ // 嵌套 Map
    ['key1', { name: 'Map Child 1', age: 10 }],
    ['key2', { name: 'Map Child 2' }]
  ]),
  dataList: new Set(['item1', 'item2']) // 嵌套 Set
});

console.log(record);
console.log(record.arr?.[0]?.name); // Child 1
console.log(record.arr?.[1]?.arr?.[0]?.name); // Grandchild 1
console.log(record.dataMap?.get('key1')?.name); // Map Child 1

// 验证类型检查：尝试设置只读属性或方法会报错
// record.set({ id: 'test' }); // Error: Type '{ id: string; }' has no properties in common with type 'Partial<DeepWritable<Parent>>'.
// record.set({ someMethod: () => {} }); // Error: Type '{ someMethod: () => void; }' has no properties in common with type 'Partial<DeepWritable<Parent>>'.