类型编程综合实战

// Promise.all：返回值类型由参数的 Promise value 类型决定
interface PromiseConstructor {
  all<T extends readonly unknown[] | []>(
    values: T
  ): Promise<{
    -readonly [P in keyof T]: Awaited<T[P]>; // 提取每个 Promise 的 value 类型
  }>;
}

// Promise.race：返回值可能是任一 Promise 的 value 类型
interface PromiseConstructor {
  race<T extends readonly unknown[] | []>(
    values: T
  ): Promise<Awaited<T[number]>>; // T[number] 取出所有元素类型的联合
}

// 柯里化函数：返回值类型由参数类型递归构造
type CurriedFunc<Params, Return> =
  Params extends [infer Arg, ...infer Rest]
    ? (arg: Arg) => CurriedFunc<Rest, Return>
    : never;

declare function currying<Func>(fn: Func):
  Func extends (...args: infer Params) => infer Result
    ? CurriedFunc<Params, Result>
    : never;

// 使用：函数参数被逐个拆分为单参函数
const func = (a: string, b: number, c: boolean) => {};
const curried = currying(func);
// curried: (arg: string) => (arg: number) => (arg: boolean) => never

// 给任意层级的索引类型每层加上可索引签名
type DeepRecord<Obj extends Record<string, any>> = {
  [Key in keyof Obj]:
    Obj[Key] extends Record<string, any>
      ? DeepRecord<Obj[Key]> & Record<string, any>  // 递归处理子层级
      : Obj[Key]
} & Record<string, any>;  // 每层都加上可扩展签名

// 将 "a=1" 解析为 { a: "1" }
type ParseParam<Param extends string> =
  Param extends `${infer Key}=${infer Value}`
    ? { [K in Key]: Value }
    : Record<string, any>;  // 无法提取时返回可索引类型，避免取任何属性都报错

// 同名参数合并：单个值 → 数组
type MergeValues<One, Other> =
  One extends Other
    ? One                                    // 类型相同，直接返回
    : Other extends unknown[]
      ? [One, ...Other]                      // 已有值是数组，追加到数组
      : [One, Other];                        // 已有值不是数组，构造数组

type MergeParams<
  OneParam extends Record<string, any>,
  OtherParam extends Record<string, any>
> = {
  readonly [Key in keyof OneParam | keyof OtherParam]:
    Key extends keyof OneParam
      ? Key extends keyof OtherParam
        ? MergeValues<OneParam[Key], OtherParam[Key]>  // 两者都有，合并值
        : OneParam[Key]                                 // 仅 OneParam 有
      : Key extends keyof OtherParam
        ? OtherParam[Key]                               // 仅 OtherParam 有
        : never
};

type ParseQueryString<Str extends string> =
  Str extends `${infer Param}&${infer Rest}`
    ? MergeParams<ParseParam<Param>, ParseQueryString<Rest>>  // 拆分后递归
    : ParseParam<Str>;                                         // 最后一个参数

// 使用函数重载声明类型，实现精准提示
function parseQueryString<Str extends string>(queryStr: Str): ParseQueryString<Str>;
function parseQueryString(queryStr: string) {
  if (!queryStr || !queryStr.length) return {};
  const queryObj: Record<string, any> = {};
  const items = queryStr.split('&');
  items.forEach(item => {
    const [key, value] = item.split('=');
    if (queryObj[key]) {
      if (Array.isArray(queryObj[key])) {
        queryObj[key].push(value);
      } else {
        queryObj[key] = [queryObj[key], value];
      }
    } else {
      queryObj[key] = value;
    }
  });
  return queryObj;
}

// 验证：返回类型精确提示出每个属性
const res = parseQueryString('a=1&b=2&c=3');
// res 的类型: { a: "1"; b: "2"; c: "3" }

// 中划线风格 → 驼峰风格
type KebabCaseToCamelCase<Str extends string> =
  Str extends `${infer Item}-${infer Rest}`
    ? `${Item}${KebabCaseToCamelCase<Capitalize<Rest>>}`
    // 提取 - 前的部分，后面首字母大写后递归处理
    : Str;

// 验证
type Result1 = KebabCaseToCamelCase<'guang-and-dong'>;
// "guangAndDong"

// 驼峰风格 → 中划线风格
type CamelCaseToKebabCase<Str extends string> =
  Str extends `${infer First}${infer Rest}`
    ? First extends Lowercase<First>        // 当前字符是小写
      ? `${First}${CamelCaseToKebabCase<Rest>}`                  // 不转换，继续递归
      : `-${Lowercase<First>}${CamelCaseToKebabCase<Rest>}`      // 大写字母前加 -，然后转小写
    : Str;

// 验证
type Result2 = CamelCaseToKebabCase<'guangAndDong'>;
// "guang-and-dong"

type Chunk<
  Arr extends unknown[],
  ItemLen extends number,
  CurItem extends unknown[] = [],
  Res extends unknown[] = []
> = Arr extends [infer First, ...infer Rest]
      ? CurItem['length'] extends ItemLen
        ? Chunk<Rest, ItemLen, [First], [...Res, CurItem]>  // 当前分组已满，开启新分组
        : Chunk<Rest, ItemLen, [...CurItem, First], Res>    // 继续构造当前分组
      : [...Res, CurItem];  // 递归结束，将当前分组加入结果

// 验证
type Result = Chunk<[1, 2, 3, 4, 5], 2>;
// [[1, 2], [3, 4], [5]]

{
  a: {
    b: {
      c: 'xxx'
    }
  }
}

type TupleToNestedObject<Tuple extends unknown[], Value> =
  Tuple extends [infer First, ...infer Rest]
    ? {
        [Key in First as Key extends keyof any ? Key : never]:
          Rest extends unknown[]
            ? TupleToNestedObject<Rest, Value>
            : Value
      }
    : Value;

// 验证
type Result = TupleToNestedObject<['a', 'b', 'c'], 'xxx'>;
// { a: { b: { c: 'xxx' } } }

interface Dong {
  name: string;
  age: number;
  address: string;
}

// 把 name 和 age 变为可选后：
interface Dong2 {
  name?: string;
  age?: number;
  address: string;
}

// 交叉类型不会立即计算，需要映射类型触发
type Copy<Obj extends Record<string, any>> = {
  [Key in keyof Obj]: Obj[Key];
};

type PartialObjectPropByKeys<
  Obj extends Record<string, any>,
  Key extends keyof any = keyof Obj
> = Copy<Partial<Pick<Obj, Extract<keyof Obj, Key>>> & Omit<Obj, Key>>;

// 验证
interface Obj {
  name: string;
  age: number;
  address: string;
}

type Result = PartialObjectPropByKeys<Obj, 'name' | 'age'>;
// { name?: string; age?: number; address: string }

// 声明多个同名函数
declare function func(name: string): string;
declare function func(name: number): number;

// 带实现的重载
function add(a: number, b: number): number;
function add(a: string, b: string): string;
function add(a: any, b: any) {
  return a + b;
}

interface Func {
  (name: string): string;
  (name: number): number;
}

declare const func: Func;

type Func = ((name: string) => string) & ((name: number) => number;

declare const func: Func;

// 利用函数参数的逆变特性实现联合转交叉
type UnionToIntersection<U> =
  (U extends U ? (x: U) => unknown : never) extends (x: infer R) => unknown
    ? R
    : never;

// 第一步：联合转交叉 + 构造函数重载
type UnionToFuncIntersection<T> =
  UnionToIntersection<T extends any ? () => T : never>;

// 第二步：递归提取，构造元组
type UnionToTuple<T> =
  UnionToFuncIntersection<T> extends () => infer ReturnType
    ? [...UnionToTuple<Exclude<T, ReturnType>>, ReturnType]
    : [];

// 验证
type Result = UnionToTuple<'a' | 'b' | 'c'>;
// ['a', 'b', 'c']

// 1. T = 'a' | 'b' | 'c'
// 2. T extends any 触发分布式条件类型，每个类型单独计算
//    → (() => 'a') | (() => 'b') | (() => 'c')
// 3. UnionToIntersection 转为交叉类型
//    → (() => 'a') & (() => 'b') & (() => 'c')
//    等效于函数重载
// 4. ReturnType 取最后一个重载的返回值 → 'c'
// 5. Exclude<'a' | 'b' | 'c', 'c'> → 'a' | 'b'
// 6. 递归处理 'a' | 'b'，最终构造 ['a', 'b', 'c']

const res = join('-')('guang', 'and', 'dong');
// res: "guang-and-dong"

// 去掉开头多余的分隔符
type RemoveFirstDelimiter<Str extends string> =
  Str extends `${infer _}${infer Rest}` ? Rest : Str;

// 递归构造 join 后的字符串
type JoinType<
  Items extends any[],
  Delimiter extends string,
  Result extends string = ''
> = Items extends [infer Cur, ...infer Rest]
      ? JoinType<Rest, Delimiter, `${Result}${Delimiter}${Cur & string}`>
      : RemoveFirstDelimiter<Result>;

// 高阶函数类型声明
declare function join<Delimiter extends string>(
  delimiter: Delimiter
): <Items extends string[]>(
  ...parts: Items
) => JoinType<Items, Delimiter>;

// 验证
const res = join('-')('guang', 'and', 'dong');
// res 的类型: "guang-and-dong"

// 输入
type Obj = {
  aaa_bbb: string;
  bbb_ccc: [
    { ccc_ddd: string; },
    { ddd_eee: string; eee_fff: { fff_ggg: string; } }
  ]
};

// 输出
type DeepCamelizeRes = {
  aaaBbb: string;
  bbbCcc: [{ cccDdd: string; }, { dddEee: string; eeeFff: { fffGgg: string; }; }];
};

// 处理数组类型：递归处理每个元素
type CamelizeArr<Arr> = Arr extends [infer First, ...infer Rest]
  ? [DeepCamelize<First>, ...CamelizeArr<Rest>]
  : [];

// 递归处理索引类型的 Key 转换
type DeepCamelize<Obj extends Record<string, any>> =
  Obj extends unknown[]
    ? CamelizeArr<Obj>
    : {
        [Key in keyof Obj
          as Key extends `${infer First}_${infer Rest}`
            ? `${First}${Capitalize<Rest>}`
            : Key
        ]: DeepCamelize<Obj[Key]>
      };

// 验证
type Obj = {
  aaa_bbb: string;
  bbb_ccc: [
    { ccc_ddd: string; },
    { ddd_eee: string; eee_fff: { fff_ggg: string; } }
  ]
};

type Result = DeepCamelize<Obj>;
// Key 全部转为 CamelCase，嵌套层级递归处理

// 输入
type Obj = {
  a: {
    b: { b1: string; b2: string; }
    c: { c1: string; c2: string; }
  }
};

// 期望输出
// 'a' | 'a.b' | 'a.b.b1' | 'a.b.b2' | 'a.c' | 'a.c.c1' | 'a.c.c2'

type AllKeyPath<Obj extends Record<string, any>> = {
  [Key in keyof Obj]:
    Key extends string
      ? Obj[Key] extends Record<string, any>
        ? Key | `${Key}.${AllKeyPath<Obj[Key]>}`
        : Key
      : never
}[keyof Obj];

// 验证
type Obj = {
  a: {
    b: { b1: string; b2: string; }
    c: { c1: string; c2: string; }
  }
};

type Result = AllKeyPath<Obj>;
// 'a' | 'a.b' | 'a.b.b1' | 'a.b.b2' | 'a.c' | 'a.c.c1' | 'a.c.c2'

// A = { aaa: string; bbb: number }
// B = { bbb: number; ccc: boolean }
// 结果 = { aaa: string; bbb?: number; ccc?: boolean }

type Defaultize<A, B> =
  & Pick<A, Exclude<keyof A, keyof B>>           // 只有 A 有的，不变
  & Partial<Pick<A, Extract<keyof A, keyof B>>>   // A、B 都有的，变可选
  & Partial<Pick<B, Exclude<keyof B, keyof A>>>;  // 只有 B 有的，变可选

// 验证
type A = { aaa: string; bbb: number };
type B = { bbb: number; ccc: boolean };

type Result = Defaultize<A, B>;
// { aaa: string; bbb?: number; ccc?: boolean }

// 原始类型：不允许添加额外属性
interface Response {
  name: string;
  age: number;
  address: {
    city: string;
    street: string;
  };
}

// 添加可索引签名，允许扩展
interface ResponseExt {
  name: string;
  age: number;
  address: {
    city: string;
    street: string;
  };
  [key: string]: any;  // 可索引签名，允许添加任意 string key 的属性
}

// 或用交叉类型：与 Record<string, any> 取交叉
type ResponseExt2 = Response & Record<string, any>;

// 递归为每一层都加上 Record<string, any>
type DeepRecord<Obj extends Record<string, any>> = {
  [Key in keyof Obj]:
    Obj[Key] extends Record<string, any>
      ? DeepRecord<Obj[Key]> & Record<string, any>  // 子层级递归 + 加签名
      : Obj[Key]                                     // 非索引类型直接返回
} & Record<string, any>;  // 当前层加签名

// 验证
type Original = {
  name: string;
  address: {
    city: string;
    detail: {
      street: string;
    };
  };
};

type Extensible = DeepRecord<Original>;
// 每层都可以添加额外属性，且已有属性仍保留类型检查

// 手动枚举：属性越多，组合爆炸
type SortType1 = { a: 'desc' | 'asc'; b: false; c: false }
               | { a: false; b: 'desc' | 'asc'; c: false }
               | { a: false; b: false; c: 'desc' | 'asc' };

// 动态生成：任意数量的属性都能自动处理
type GenerateType<Keys extends keyof any> = {
  [Key in Keys]: {
    [Key2 in Key]: 'desc' | 'asc'        // 当前 key 为排序值
  } & {
    [Key3 in Exclude<Keys, Key>]: false   // 其余 key 为 false
  }
}[Keys];  // 取所有 value 的联合类型

// 验证
type SortType = GenerateType<'a' | 'b' | 'c'>;
// { a: 'desc' | 'asc'; b: false; c: false }
// | { a: false; b: 'desc' | 'asc'; c: false }
// | { a: false; b: false; c: 'desc' | 'asc' }

// 更多的属性也自动生成
type SortType4 = GenerateType<'a' | 'b' | 'c' | 'd'>;
// 自动生成 4 种组合

// 内置的 Readonly 只能加修饰，没有提供去除的工具类型
type Mutable<Obj> = {
  -readonly [Key in keyof Obj]: Obj[Key];  // -readonly 去除只读修饰
};

// 交叉类型不会被立即计算，需要映射类型触发
type Copy<Obj extends Record<string, any>> = {
  [Key in keyof Obj]: Obj[Key];
};

// 示例：Partial + Omit 的交叉类型需要 Copy 才能展开
type PartialObjectPropByKeys<
  Obj extends Record<string, any>,
  Key extends keyof any = keyof Obj
> = Copy<Partial<Pick<Obj, Extract<keyof Obj, Key>>> & Omit<Obj, Key>>;