TypeScript 高级特性与类型体操

// 基础条件类型
type IsString<T> = T extends string ? true : false;
type A = IsString<'hello'>;  // true
type B = IsString<42>;       // false

// 分布式条件类型：作用于联合类型时会"逐个分发"
type ToArray<T> = T extends any ? T[] : never;
type C = ToArray<string | number>; // string[] | number[]

// 用它实现内置的 Exclude
type MyExclude<T, U> = T extends U ? never : T;
type D = MyExclude<'a' | 'b' | 'c', 'a'>; // 'b' | 'c'

// 提取函数返回值类型（内置 ReturnType 的实现）
type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
type R1 = MyReturnType<() => string>; // string

// 提取函数第一个参数类型
type FirstParam<T> = T extends (first: infer P, ...rest: any[]) => any ? P : never;
type R2 = FirstParam<(id: number, name: string) => void>; // number

// 提取数组元素类型
type ElementType<T> = T extends (infer U)[] ? U : never;
type R3 = ElementType<boolean[]>; // boolean

// 解包 Promise（内置 Awaited 的简化版）
type Unwrap<T> = T extends Promise<infer U> ? U : T;
type R4 = Unwrap<Promise<number>>; // number

interface User {
  id: number;
  name: string;
  email: string;
}

// 把所有属性变可选（内置 Partial 的实现）
type MyPartial<T> = { [P in keyof T]?: T[P] };

// 把所有属性变只读（内置 Readonly 的实现）
type MyReadonly<T> = { readonly [P in keyof T]: T[P] };

// 挑选部分属性（内置 Pick 的实现）
type MyPick<T, K extends keyof T> = { [P in K]: T[P] };
type UserPreview = MyPick<User, 'id' | 'name'>;

// 移除只读修饰符
type Mutable<T> = { -readonly [P in keyof T]: T[P] };

// 移除可选修饰符（内置 Required 的实现）
type MyRequired<T> = { [P in keyof T]-?: T[P] };

// 为每个属性生成一个 getter 方法名
type Getters<T> = {
  [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P];
};

type UserGetters = Getters<User>;
// {
//   getId: () => number;
//   getName: () => string;
//   getEmail: () => string;
// }

// 用 never 过滤掉不想要的键
type RemoveField<T, K> = {
  [P in keyof T as P extends K ? never : P]: T[P];
};
type WithoutId = RemoveField<User, 'id'>; // { name: string; email: string }

type World = 'World';
type Greeting = `Hello ${World}`; // 'Hello World'

// 与联合类型组合会做"笛卡尔积"
type Color = 'red' | 'blue';
type Size = 'small' | 'large';
type Variant = `${Size}-${Color}`;
// 'small-red' | 'small-blue' | 'large-red' | 'large-blue'

// 构建类型安全的事件名
type EventName<T extends string> = `on${Capitalize<T>}`;
type ClickHandler = EventName<'click'>; // 'onClick'

// 构建 API 路径类型
type ApiRoute = `/api/${'users' | 'posts'}/${number}`;
const route: ApiRoute = '/api/users/1'; // OK

// 提取路径参数
type ExtractParams<T extends string> =
  T extends `${string}:${infer Param}/${infer Rest}`
    ? Param | ExtractParams<`/${Rest}`>
    : T extends `${string}:${infer Param}`
      ? Param
      : never;

type Params = ExtractParams<'/users/:id/posts/:postId'>;
// 'id' | 'postId'

// 深度只读
type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object
    ? DeepReadonly<T[P]>
    : T[P];
};

// 深度可选
type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object
    ? DeepPartial<T[P]>
    : T[P];
};

interface Config {
  server: { host: string; port: number };
  db: { url: string; pool: { min: number; max: number } };
}

type PartialConfig = DeepPartial<Config>;
// 所有层级的属性都变成可选
const cfg: PartialConfig = { server: { port: 8080 } }; // OK

// 递归定义 JSON 值类型
type JsonValue =
  | string
  | number
  | boolean
  | null
  | JsonValue[]
  | { [key: string]: JsonValue };

// 1. 元组转对象
type TupleToObject<T extends readonly PropertyKey[]> = {
  [K in T[number]]: K;
};
type Obj = TupleToObject<['a', 'b']>; // { a: 'a'; b: 'b' }

// 2. 获取数组第一个元素
type First<T extends any[]> = T extends [infer F, ...any[]] ? F : never;
type F = First<[3, 2, 1]>; // 3

// 3. 获取元组长度
type Length<T extends readonly any[]> = T['length'];
type L = Length<['a', 'b', 'c']>; // 3

// 4. 实现 Concat
type Concat<T extends any[], U extends any[]> = [...T, ...U];
type Merged = Concat<[1, 2], [3, 4]>; // [1, 2, 3, 4]

// 5. 实现 Includes
type Includes<T extends readonly any[], U> =
  T extends [infer First, ...infer Rest]
    ? Equal<First, U> extends true
      ? true
      : Includes<Rest, U>
    : false;

type Equal<X, Y> =
  (<T>() => T extends X ? 1 : 2) extends
  (<T>() => T extends Y ? 1 : 2) ? true : false;

type Has = Includes<[1, 2, 3], 2>; // true

type FieldConfig =
  | { type: 'text' }
  | { type: 'number' }
  | { type: 'checkbox' };

// 把配置里的 type 字符串映射成真实的值类型
type InferFieldType<T extends FieldConfig> =
  T['type'] extends 'text' ? string :
  T['type'] extends 'number' ? number :
  T['type'] extends 'checkbox' ? boolean :
  never;

// 从整份表单 schema 推导出表单值对象类型
type FormValues<T extends Record<string, FieldConfig>> = {
  [K in keyof T]: InferFieldType<T[K]>;
};

const schema = {
  username: { type: 'text' },
  age: { type: 'number' },
  subscribe: { type: 'checkbox' },
} as const;

type Values = FormValues<typeof schema>;
// {
//   username: string;
//   age: number;
//   subscribe: boolean;
// }

// Omit 的完整实现
type MyOmit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

interface Product {
  id: number;
  name: string;
  price: number;
  internalCost: number;
}
type PublicProduct = MyOmit<Product, 'internalCost'>;
// { id: number; name: string; price: number }

// Record 的实现
type MyRecord<K extends keyof any, V> = { [P in K]: V };
type Flags = MyRecord<'a' | 'b' | 'c', boolean>;
// { a: boolean; b: boolean; c: boolean }

// 1. typeof 守卫
function pad(value: string | number) {
  if (typeof value === 'number') {
    return value.toFixed(2); // 此处 value 被收窄为 number
  }
  return value.trim();       // 此处 value 被收窄为 string
}

// 2. in 操作符守卫
type Cat = { meow: () => void };
type Dog = { bark: () => void };
function speak(animal: Cat | Dog) {
  if ('meow' in animal) animal.meow();
  else animal.bark();
}

// 3. 自定义类型守卫（is 谓词）
interface Fish { swim: () => void }
interface Bird { fly: () => void }
function isFish(pet: Fish | Bird): pet is Fish {
  return (pet as Fish).swim !== undefined;
}
function move(pet: Fish | Bird) {
  if (isFish(pet)) pet.swim();
  else pet.fly();
}

// 4. 断言函数（asserts）
function assertIsDefined<T>(val: T): asserts val is NonNullable<T> {
  if (val === undefined || val === null) {
    throw new Error('值不应为空');
  }
}
function process(input?: string) {
  assertIsDefined(input);
  return input.toUpperCase(); // input 已收窄为 string
}

type State =
  | { status: 'idle' }
  | { status: 'loading' }
  | { status: 'success'; data: string[] }
  | { status: 'error'; message: string };

function render(state: State): string {
  switch (state.status) {
    case 'idle':    return '空闲';
    case 'loading': return '加载中...';
    case 'success': return `共 ${state.data.length} 条`; // data 类型可用
    case 'error':   return `错误：${state.message}`;      // message 类型可用
    default:
      // 穷尽检查：若将来新增了 status 却没在此处处理，此行会编译报错
      const exhaustive: never = state;
      return exhaustive;
  }
}

// 用 extends 约束泛型，keyof 保证键存在
function getProp<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const user = { id: 1, name: 'Alice' };
getProp(user, 'name'); // string，getProp(user, 'xxx') 会报错

// 泛型默认值
interface ApiResponse<T = unknown> {
  code: number;
  data: T;
}
const r: ApiResponse = { code: 0, data: 'anything' };

// 用 const 类型参数保留字面量类型（TS 5.0+）
function tuple<const T extends readonly unknown[]>(...args: T): T {
  return args;
}
const t = tuple('a', 1, true); // 类型为 readonly ['a', 1, true]，而非 (string|number|boolean)[]

// 定义事件到 payload 的映射
interface EventMap {
  login: { userId: number; time: number };
  logout: { userId: number };
  message: { from: string; text: string };
}

class TypedEmitter<T extends Record<string, any>> {
  private handlers: { [K in keyof T]?: Array<(payload: T[K]) => void> } = {};

  on<K extends keyof T>(event: K, handler: (payload: T[K]) => void) {
    (this.handlers[event] ||= []).push(handler);
  }

  emit<K extends keyof T>(event: K, payload: T[K]) {
    this.handlers[event]?.forEach(h => h(payload));
  }
}

const bus = new TypedEmitter<EventMap>();
bus.on('login', p => console.log(p.userId, p.time)); // p 类型精确
bus.emit('login', { userId: 1, time: Date.now() });   // payload 校验
// bus.emit('login', { userId: 1 }); // 报错：缺少 time
// bus.on('unknown', () => {});       // 报错：事件名不存在

class Animal {}
class Dog extends Animal { bark() {} }

// 返回值协变：返回更具体的类型是安全的
type GetAnimal = () => Animal;
const getDog: GetAnimal = () => new Dog(); // OK，Dog 是 Animal

// 参数逆变：接受更宽泛的参数是安全的（strictFunctionTypes 下）
type HandleDog = (d: Dog) => void;
const handleAnimal: HandleDog = (a: Animal) => {}; // OK