// 基础模板字面量类型
type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';

// 模板字面量与联合类型展开
type EventName = 'click' | 'focus' | 'blur';
type HandlerName = 'on-'.Capitalize<EventName>;
// HandlerName = 'on-Click' | 'on-Focus' | 'on-Blur'

// 实际应用：类型安全的 CSS 类名构造
type Size = 'sm' | 'md' | 'lg';
type Variant = 'primary' | 'secondary';
type ClassName = 'btn-'.Capitalize<Size> | 'btn-'.Capitalize<Variant>;
// ClassName = 'btn-Sm' | 'btn-Md' | 'btn-Lg' | 'btn-Primary' | 'btn-Secondary'

// 更复杂的场景：提取路径参数
type Route = '/users/:id' | '/products/:category/:id';

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

type UserParams = ExtractParams<'/users/:id'>;
// UserParams = 'id'

type ProductParams = ExtractParams<'/products/:category/:id'>;
// ProductParams = 'category' | 'id'

// 实际工程应用：类型安全的 API 路径构建
type ApiPaths = {
    '/users': { GET: UserListResponse; POST: CreateUserRequest };
    '/users/:id': { GET: UserResponse; PUT: UpdateUserRequest; DELETE: void };
    '/orders/:orderId/items': { GET: OrderItemsResponse };
};

type ExtractPathParams<T extends string> =
    T extends `${string}:${infer P}(${string}` extends `${infer _}:${infer Rest}`
        ? ExtractPathParams<`${string}:${Rest}`>
        : T extends `${string}:${infer P}`
            ? P
            : never;

type PathParams<T extends keyof ApiPaths> =
    ExtractPathParams<T>;

// 用例
type UserIdParam = PathParams<'/users/:id'>;
// UserIdParam = 'id'

// 自定义类型守卫
interface Cat { meow(): void; }
interface Dog { bark(): void; }

function isCat(animal: Cat | Dog): animal is Cat {
    return (animal as Cat).meow !== undefined;
}

function speak(animal: Cat | Dog) {
    if (isCat(animal)) {
        animal.meow();  // TypeScript 知道这是 Cat，meow() 可访问
    } else {
        animal.bark(); // TypeScript 知道这是 Dog，bark() 可访问
    }
}

// in 守卫
function processValue(value: { kind: 'success'; data: string } | { kind: 'error'; message: string }) {
    if ('data' in value) {
        console.log(value.data);  // success 分支
    } else {
        console.log(value.message); // error 分支
    }
}

// 可辨识联合（Discriminated Union）—— 最推荐的模式
type Result<T, E extends Error> =
    | { status: 'fulfilled'; value: T }
    | { status: 'rejected'; reason: E };

function handleResult<T, E extends Error>(result: Result<T, E>) {
    switch (result.status) {
        case 'fulfilled':
            return result.value;  // T 类型
        case 'rejected':
            throw result.reason;    // E 类型
    }
}

// 分发示例：联合类型的展开
type ToArray<T> = T extends any ? T[] : never;

type StrOrNumArr = ToArray<'a' | number>;
// 展开过程: ToArray<'a'> | ToArray = 'a'[] | number[]
// 最终结果: ('a'[] | number[]) —— 这是联合，不是交叉

// 抑制分发：[T] extends 而不是 T extends
type IsNever<T> = [T] extends [never] ? true : false;

type CheckString = IsNever<'string'>;  // false —— 不分发
type CheckNever = IsNever<never>;     // true  —— never 特殊处理

// 实际应用：类型过滤（Exclude / Extract 原理）
type MyExclude<T, U> = T extends U ? never : T;

type Filtered = MyExclude<'a' | 'b' | 'c', 'b'>;
// 展开: ('a' extends 'b' ? never : 'a') | ('b' extends 'b' ? never : 'b') | ('c' extends 'b' ? never : 'c')
// 结果: 'a' | never | 'c' = 'a' | 'c'

// 嵌套分发：更复杂的场景
type Flatten<T> = T extends Array<infer U> ? U : T;

type Nested = (string[] | number[])[];
type FlatResult = Flatten<Nested>;
// 分发后: Flatten<string[]> | Flatten<number[]> = string | number

// 经典工具类型：ReturnType 实现
type ReturnType<T extends (...args: any) => any> =
    T extends (...args: any) => infer R ? R : never;

type Fn = (name: string, age: number) => Promise<{ id: string }>;
type FnReturn = ReturnType<Fn>;
// FnReturn = Promise<{ id: string }>

// Parameters：提取函数参数类型
type Parameters<T extends (...args: any) => any> =
    T extends (...args: infer P) => any ? P : never;

// 递归 infer：提取嵌套类型
type DeepAwaited<T> = T extends Promise<infer U>
    ? DeepAwaited<U>  // 递归处理嵌套 Promise
    : T;

type DeepResult = DeepAwaited<Promise<Promise<Promise<string>>>>;
// DeepResult = string

// 提取数组元素类型（递归）
type DeepExtract<T> = T extends Array<infer U> ? DeepExtract<U> : T;

type Extracted = DeepExtract<string[][][]>;
// Extracted = string

// 构造函数类型推断
type ConstructorParams<T extends new (...args: any) => any> =
    T extends new (...args: infer P) => any ? P : never;

class User {
    constructor(name: string, age: number) {}
}

type UserCtorParams = ConstructorParams<typeof User>;
// UserCtorParams = [name: string, age: number]

// 基础映射类型：给所有属性添加只读
type Readonly<T> = {
    readonly [K in keyof T]: T[K];
};

// 移除只读（-readonly）
type Mutable<T> = {
    -readonly [K in keyof T]: T[K];
};

// 移除可选（-?）—— 所有属性变为必需
type Required<T> = {
    [K in keyof T -?]: T[K];
};

// 添加可选（+?）—— 所有属性变为可选
type Partial<T> = {
    [K in keyof T +?]: T[K];
};

// 键名重新映射（as 子句）
type Getters<T> = {
    [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

interface User {
    name: string;
    age: number;
}

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

// 键过滤：仅保留 string 类型的属性
type StringOnly<T> = {
    [K in keyof T as T[K] extends string ? K : never]: T[K];
};

// 条件映射：仅处理特定类型的属性
type DeepReadonly<T> = {
    readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
};