《TypeScript高级编程》3.3 复杂泛型的重构手法

// 改前：一个类型里塞了四层推导，中间结果全是匿名的
type RouteConfig<T extends string> = T extends `${infer Method} ${infer Path}`
  ? Method extends "get" | "post"
    ? Path extends `${string}:${infer Param}`
      ? { method: Uppercase<Method>; params: Param }
      : { method: Uppercase<Method>; params: never }
    : never
  : never;

// 改后：每层推导有名字，编译器可以复用求值结果
type ParseRoute<T extends string> =
  T extends `${infer Method} ${infer Rest}` ? { method: Method; path: Rest } : never;

type ToUpperMethod<T extends string> = T extends "get" | "post" ? Uppercase<T> : never;

type ExtractParams<P extends string> =
  P extends `${string}:${infer Param}` ? Param : never;

type RouteConfig2<T extends string> =
  ParseRoute<T> extends { method: infer M extends string; path: infer P extends string }
    ? { method: ToUpperMethod<M>; params: ExtractParams<P> }
    : never;

type C1 = RouteConfig2<"get /user/:id">;   // { method: "GET"; params: "id" }

// 改前：五个交叉，每次引用都可能重新归并成员
type UserEntity = Identity & Timestamps & SoftDelete & AuditFields & TenantScope;

// 改后：成员归并只做一次，且可被增量编译复用
interface UserEntity extends Identity, Timestamps, SoftDelete, AuditFields, TenantScope {}

// 需要联合或推导时，再用 type 引用接口
type NullableUser = UserEntity | null;

// 改前：非法输入返回 never，错误信息指向内部实现，用户看不懂
type PickFields<T, K extends string> =
  K extends keyof T ? Pick<T, K> : never;

type Bad1 = PickFields<{ id: number }, "name">;   // never（用户不知道为什么）

// 改后：用约束把校验前置，错误出现在调用处，且约束只检查一次
type PickFields2<T, K extends keyof T> = Pick<T, K>;

type Bad2 = PickFields2<{ id: number }, "name">;
// 类型 '"name"' 不满足约束 'keyof { id: number }'。ts(2344)

// 改前：条件链，每加一种格式就再加一层
type Payload<T extends string> = T extends "json"
  ? { kind: "json"; raw: string }
  : T extends "xml"
    ? { kind: "xml"; raw: string }
    : T extends "csv"
      ? { kind: "csv"; raw: string }
      : never;

// 改后：映射表 + 索引访问，求值退化成一次查表
interface PayloadMap {
  json: { kind: "json"; raw: string };
  xml: { kind: "xml"; raw: string };
  csv: { kind: "csv"; raw: string };
}

type Payload2<T extends keyof PayloadMap> = PayloadMap[T];

// 改前：分发，联合有几个成员就实例化几次
type Wrap<T> = T extends unknown ? { value: T } : never;

type W1 = Wrap<A | B | C>;   // { value: A } | { value: B } | { value: C }

// 改后：用 [T] 关闭分发，整体只算一次
type WrapAll<T> = [T] extends [unknown] ? { value: T } : never;

type W2 = WrapAll<A | B | C>;   // { value: A | B | C }

// 改前：从 zod schema 反推类型，schema 越大实例化越多
const schema = z.object({ /* 300 个字段 */ });
type FormData = z.infer<typeof schema>;   // 每次引用都要重新推导

// 改后：构建期把推导结果落成 .d.ts，运行时只做校验
// scripts/gen-types.ts 里：fs.writeFileSync("src/generated/form-data.d.ts", emit)
import type { FormData } from "./generated/form-data";

declare const data: FormData;

type IsEqual<A, B> =
  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;

type Expect<T extends true> = T;

type A = { a: 1 };
type B = { b: 2 };
type C = { c: 3 };

type _1 = Expect<IsEqual<WrapAll<A | B | C>, { value: A | B | C }>>;
type _2 = Expect<IsEqual<Payload2<"json">, { kind: "json"; raw: string }>>;
type _3 = Expect<IsEqual<RouteConfig2<"get /user/:id">, { method: "GET"; params: "id" }>>;

// 反向断言：确认非法输入确实被拒绝，且错误在预期位置
// @ts-expect-error "name" 不是 keyof { id: number }
type _4 = PickFields2<{ id: number }, "name">;

// @ts-expect-error 未知格式键被约束拦住
type _5 = Payload2<"yaml">;

// 改前（节选）：每层都嵌在上一层里，没有任何中间名字
type FieldValue<
  S extends Record<string, FieldSpec>,
  K extends keyof S,
> = S[K] extends { type: "text" }
  ? S[K] extends { optional: true }
    ? string | undefined
    : string
  : S[K] extends { type: "select" }
    ? S[K] extends { options: readonly (infer O)[] }
      ? O extends string
        ? S[K] extends { optional: true }
          ? O | undefined
          : O
        : never
      : never
    : never;

// 1) 拆出「叶子类型」的映射表，替代最外两层条件链
interface LeafType {
  text: string;
  number: number;
  boolean: boolean;
}

// 2) 拆出「可空化」这一个横切关注点，具名化
type Maybe<T, Opt extends boolean | undefined> = Opt extends true ? T | undefined : T;

// 3) 拆出「select 选项提取」这一层推导，单独具名
type OptionsOf<Spec> = Spec extends { options: readonly (infer O extends string)[] } ? O : never;

// 4) 主类型只剩下三层，且每层都引用具名结果
type FieldValue<
  S extends Record<string, FieldSpec>,
  K extends keyof S,
> = S[K] extends { type: infer T extends keyof LeafType }
  ? Maybe<
      T extends "select" ? OptionsOf<S[K]> : LeafType[T],
      S[K] extends { optional: true } ? true : undefined
    >
  : never;