TypeScript ở cấp độ wizard — type-level programming

type IsString<T> = T extends string ? true : false;

type A = IsString<'hello'>;   // true
type B = IsString<42>;        // false
type C = IsString<string>;    // true

// Ví dụ thực tế — chọn loại response
type ApiResponse<T> = T extends Error
  ? { ok: false; error: T['message'] }
  : { ok: true; data: T };

type Good = ApiResponse<{ id: number }>;
// { ok: true; data: { id: number } }

type Bad = ApiResponse<Error>;
// { ok: false; error: string }

type ToArray<T> = T extends any ? T[] : never;

type A = ToArray<string>;
// string[]

type B = ToArray<string | number>;
// TS phân phối:
//   ToArray<string> | ToArray<number>
//   = string[] | number[]
// CHỨ KHÔNG PHẢI (string | number)[]

type ToArrayBundled<T> = [T] extends [any] ? T[] : never;

type C = ToArrayBundled<string | number>;
// (string | number)[]   ← gộp lại, không phân phối

// Use case thực tế: check chính xác type, không bị "rớt qua kẽ":
type IsExactlyString<T> = [T] extends [string] ? true : false;

type X = IsExactlyString<string | number>;  // false (vì có number)
type Y = IsExactlyString<string>;           // true

// Trích kiểu trả về của function
type MyReturnType<F> = F extends (...args: any[]) => infer R
  ? R
  : never;

type A = MyReturnType<() => number>;          // number
type B = MyReturnType<(s: string) => boolean>;  // boolean
type C = MyReturnType<string>;               // never (không match)

// Lấy type đầu tiên của tuple
type First<T extends any[]> = T extends [infer F, ...any[]] ? F : never;
type F = First<[string, number, boolean]>;  // string

// Lấy phần còn lại (tail)
type Tail<T extends any[]> = T extends [any, ...infer R] ? R : [];
type T1 = Tail<[string, number, boolean]>;  // [number, boolean]

// Unwrap Promise
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
type U = UnwrapPromise<Promise<number>>;  // number
type V = UnwrapPromise<string>;            // string (không phải Promise → trả nguyên)

// Lấy type element của array
type ElementOf<T> = T extends (infer E)[] ? E : never;
type E = ElementOf<number[]>;  // number

// Định nghĩa:
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

// Bước 1: thay T = Promise<Promise<number>>
//   Promise<Promise<number>> extends Promise<infer U> ?
// Bước 2: match — TS gán U = Promise<number>
// Bước 3: return U = Promise<number>

// Vậy UnwrapPromise một lần CHỈ unwrap 1 tầng.
// Muốn unwrap nhiều tầng → đệ quy (recursive type, xem mục 9).

type Awaited2<T> = T extends Promise<infer U> ? Awaited2<U> : T;
//                                                  ↑ tự gọi lại

type R = Awaited2<Promise<Promise<number>>>;  // number
// Bước 1: match → U = Promise<number>, gọi Awaited2<Promise<number>>
// Bước 2: match → U = number, gọi Awaited2<number>
// Bước 3: không match Promise → trả T = number. DONE.

// Đánh dấu tất cả property là readonly
type MyReadonly<T> = {
  readonly [K in keyof T]: T[K];
};

interface User { id: number; name: string; }
type ReadonlyUser = MyReadonly<User>;
// {
//   readonly id: number;
//   readonly name: string;
// }

// Biến value thành Promise của value
type Asyncify<T> = {
  [K in keyof T]: Promise<T[K]>;
};

type AsyncUser = Asyncify<User>;
// { id: Promise<number>; name: Promise<string>; }

// Bỏ readonly khỏi mọi property
type Mutable<T> = {
  -readonly [K in keyof T]: T[K];
};

type Locked = { readonly a: number; readonly b: string };
type Unlocked = Mutable<Locked>;
// { a: number; b: string }   ← bỏ readonly

// Bỏ optional khỏi mọi property → bắt buộc
type Required2<T> = {
  [K in keyof T]-?: T[K];
};

type Loose = { a?: number; b?: string };
type Strict = Required2<Loose>;
// { a: number; b: string }   ← bỏ ?

// Thêm optional cho mọi property
type Partial2<T> = {
  [K in keyof T]+?: T[K];   // +? cũng chỉ là ?
};

// Sinh getter từ field — name → getName
type Getters<T> = {
  [K in keyof T as `get${Capitalize<K & string>}`]: () => T[K];
};

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

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

// Giữ key của field "string", bỏ field khác
type StringKeys<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K];
};
//                  ↑ remap về never = loại bỏ key đó

interface Mixed {
  name: string;
  age: number;
  email: string;
  active: boolean;
}

type OnlyStrings = StringKeys<Mixed>;
// { name: string; email: string }

type Greeting = `Hello, ${string}!`;
const g1: Greeting = 'Hello, world!';  // ✅
const g2: Greeting = 'Hi';             // ❌ Lỗi

type Route = `/users/${string}`;
const r1: Route = '/users/42';   // ✅
const r2: Route = '/posts/42';   // ❌

// Kết hợp với union → tổ hợp string
type Color = 'red' | 'green' | 'blue';
type Variant = 'light' | 'dark';
type Token = `${Variant}-${Color}`;
// 'light-red' | 'light-green' | 'light-blue' |
// 'dark-red'  | 'dark-green'  | 'dark-blue'

// Convert keys snake_case → camelCase
type CamelCase<S extends string> =
  S extends `${infer Head}_${infer Tail}`
    ? `${Head}${Capitalize<CamelCase<Tail>>}`
    : S;

type A = CamelCase<'first_name'>;       // 'firstName'
type B = CamelCase<'created_at_utc'>;   // 'createdAtUtc'

// Áp dụng cho object
type CamelCaseKeys<T> = {
  [K in keyof T as CamelCase<K & string>]: T[K];
};

type DBRow = { first_name: string; created_at: Date };
type JsRow = CamelCaseKeys<DBRow>;
// { firstName: string; createdAt: Date }

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

// keyof T = union các key
type K = keyof User;  // 'id' | 'name' | 'email'

// T[K] = lookup type của value tại key K
type IdType = User['id'];  // number

// T[keyof T] = union tất cả value type
type AllValues = User[keyof User];  // number | string

// Trên array
type Arr = [number, string, boolean];
type First = Arr[0];   // number
type All = Arr[number];   // number | string | boolean

// Trên union
type Action = { kind: 'add'; n: number } | { kind: 'reset' };
type Kinds = Action['kind'];  // 'add' | 'reset'

type DeepReadonly<T> = {
  readonly [K in keyof T]:
    T[K] extends object
      ? DeepReadonly<T[K]>   // đệ quy nếu là object
      : T[K];                 // primitive — giữ nguyên
};

interface Config {
  api: {
    url: string;
    auth: { token: string; refreshIn: number };
  };
  debug: boolean;
}

type FrozenConfig = DeepReadonly<Config>;
// {
//   readonly api: {
//     readonly url: string;
//     readonly auth: {
//       readonly token: string;
//       readonly refreshIn: number;
//     };
//   };
//   readonly debug: boolean;
// }

type Awaited<T> =
  T extends null | undefined
    ? T                                                      // ① giữ nguyên null/undefined
    : T extends object & { then(onfulfilled: infer F, ...): any }
      ? F extends ((value: infer V, ...) => any)
        ? Awaited<V>                                          // ② nếu thenable, lấy value V và đệ quy
        : never                                                // ③ thenable nhưng then không là function
      : T;                                                     // ④ không phải Promise / thenable → giữ nguyên

# Hiện chi tiết thời gian
$ tsc --extendedDiagnostics

# Hiện file nào chậm nhất
$ tsc --generateTrace ./trace

# Mở Chrome DevTools → Performance → load trace.json
# Tìm "checkTypeRelatedTo" — top vài entry là thủ phạm

# Ngưỡng tham khảo (project medium):
# - Total: <5s OK, 5-20s acceptable, >20s cần optimize
# - Single file check: <100ms OK, >500ms suspicious

type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object
    ? DeepPartial<T[K]>
    : T[K];
};

interface Form {
  user: {
    name: string;
    address: { city: string; zip: string };
  };
  active: boolean;
}

type PartialForm = DeepPartial<Form>;

// Trace cách TS suy ra:
// Bước 1: K duyệt 'user' | 'active'

// Bước 2: K='user' → T[K] = { name, address }
//   { name, address } extends object? YES
//   → DeepPartial<{ name, address }>
//     - K duyệt 'name' | 'address'
//     - K='name' → T[K]=string. string extends object? NO → giữ string
//     - K='address' → T[K]={ city, zip }. YES object → DeepPartial<...>
//       - K='city' → string → giữ
//       - K='zip'  → string → giữ
//       Kết quả: { city?: string; zip?: string }
//     Kết quả: { name?: string; address?: { city?: string; zip?: string } }

// Bước 3: K='active' → T[K]=boolean. boolean extends object? NO → giữ

// Final:
// {
//   user?: {
//     name?: string;
//     address?: { city?: string; zip?: string };
//   };
//   active?: boolean;
// }

// Partial = mapped + modifier ?
type Partial<T> = { [P in keyof T]?: T[P] };

// Required = mapped + remove ?
type Required<T> = { [P in keyof T]-?: T[P] };

// Pick = mapped + giới hạn K
type Pick<T, K extends keyof T> = { [P in K]: T[P] };

// Exclude = distributive conditional
type Exclude<T, U> = T extends U ? never : T;

// ReturnType = infer trong conditional
type ReturnType<F extends (...args: any) => any> =
  F extends (...args: any) => infer R ? R : never;