Advanced types — Generic, Conditional, Mapped, Utility

function identity<T>(x: T): T {
  return x;
}

identity<number>(42);
identity("hello");                   // type inferred

// Generic function với nhiều param
function pair<A, B>(a: A, b: B): [A, B] {
  return [a, b];
}

// Generic class
class Box<T> {
  constructor(public value: T) {}
  map<U>(fn: (x: T) => U): Box<U> {
    return new Box(fn(this.value));
  }
}

// Generic interface
interface Repo<T> {
  findById(id: number): T | undefined;
  add(item: T): void;
}

// T phải có property "length"
function longest<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}

longest("foo", "bars");              // OK — string có length
longest([1, 2], [1, 2, 3]);          // OK — array có length
longest(1, 2);                       // ❌ — number không có length

// keyof constraint — key của object
function get<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const user = { id: 1, name: "Alice" };
get(user, "name");                   // string
get(user, "age");                    // ❌ — "age" không phải key của user

interface ApiResponse<TData = unknown, TError = Error> {
  data: TData;
  error?: TError;
}

const r1: ApiResponse = { data: "x" };           // TData = unknown
const r2: ApiResponse<User> = { data: {...} };

// Cơ bản
type IsString<T> = T extends string ? "yes" : "no";
type A = IsString<"hello">;          // "yes"
type B = IsString<42>;               // "no"

// Distributive — apply cho từng union member
type ToArray<T> = T extends any ? T[] : never;
type C = ToArray<string | number>;   // string[] | number[]  (không phải (string|number)[])

// Non-distributive — wrap trong tuple
type ToArrayBox<T> = [T] extends [any] ? T[] : never;
type D = ToArrayBox<string | number>; // (string | number)[]

// Lấy return type của function
type ReturnTypeOf<F> = F extends (...args: any) => infer R ? R : never;

type T1 = ReturnTypeOf<() => string>;          // string
type T2 = ReturnTypeOf<typeof Math.random>;    // number

// Lấy parameter type
type ParamsOf<F> = F extends (...args: infer P) => any ? P : never;
type T3 = ParamsOf<(a: number, b: string) => void>;   // [number, string]

// Unbox Promise
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
type T4 = UnwrapPromise<Promise<string>>;      // string
type T5 = UnwrapPromise<number>;               // number

// Unbox Array
type Element<T> = T extends (infer E)[] ? E : never;
type T6 = Element<number[]>;                   // number
type T7 = Element<[string, number]>;           // string | number

// Cơ bản — map qua key
type Readonly<T> = { readonly [K in keyof T]: T[K] };
type Partial<T> = { [K in keyof T]?: T[K] };
type Required<T> = { [K in keyof T]-?: T[K] };          // remove ?
type Mutable<T> = { -readonly [K in keyof T]: T[K] };   // remove readonly

// Key remapping (TS 4.1+) — `as`
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};
// Getters<{ name: string; age: number }>
// = { getName: () => string; getAge: () => number }

type Greeting = `Hello, ${string}!`;
const g1: Greeting = "Hello, world!";       // OK
const g2: Greeting = "Bye";                 // ❌

// Combine union
type Color = "red" | "blue";
type Size = "small" | "large";
type Variant = `${Color}-${Size}`;
// "red-small" | "red-large" | "blue-small" | "blue-large"

// Tách string
type SplitFirst<S extends string> =
  S extends `${infer Head}/${infer Tail}` ? Head : never;
type T = SplitFirst<"users/123/profile">;   // "users"

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

type UserPreview = Pick<User, "id" | "name">;      // { id; name }
type UserNoAge = Omit<User, "age">;                // { id; name }
type UserPartial = Partial<User>;                  // tất cả optional
type UserName = User["name"];                      // string  (lookup type)
type UserKeys = keyof User;                        // "id" | "name" | "age"

type Status = "active" | "inactive" | "deleted";
type Live = Exclude<Status, "deleted">;            // "active" | "inactive"
type Dead = Extract<Status, "deleted">;            // "deleted"

async function fetch(): Promise<User> { ... }
type R = Awaited<ReturnType<typeof fetch>>;        // User

interface User { id: number; name: string; address: { city: string } }

type Name = User["name"];                  // string
type Id = User["id"];                      // number
type City = User["address"]["city"];       // string nested

// Combine với keyof — lookup mọi value type
type UserValue = User[keyof User];         // string | number | { city: string }

// Array element
type Items = string[];
type Item = Items[number];                 // string

// Tuple element
type Tup = [string, number, boolean];
type T0 = Tup[0];                          // string
type Any = Tup[number];                    // string | number | boolean

// Class decorator
function logged<T extends { new (...args: any[]): {} }>(target: T) {
  return class extends target {
    constructor(...args: any[]) {
      super(...args);
      console.log(`Created ${target.name}`);
    }
  };
}

@logged
class Service { }

// Method decorator (TC39 stage 3 syntax)
function logTime(originalMethod: any, context: ClassMethodDecoratorContext) {
  return function (this: any, ...args: any[]) {
    console.time(String(context.name));
    const result = originalMethod.apply(this, args);
    console.timeEnd(String(context.name));
    return result;
  };
}

class Calculator {
  @logTime
  sum(a: number, b: number) { return a + b; }
}

// Mở rộng module ngoài
declare module "express" {
  interface Request {
    user?: { id: number; email: string };
  }
}

// Sau đó dùng req.user trong route handler — TS biết kiểu
app.get("/me", (req, res) => {
  res.json(req.user);                       // typed
});

type UserId = number & { __brand: "UserId" };
type OrderId = number & { __brand: "OrderId" };

function getUser(id: UserId) { ... }

const uid = 1 as UserId;
const oid = 2 as OrderId;
getUser(uid);          // OK
getUser(oid);          // ❌ — chống nhầm ID

// Object.keys trả string[] — TS không biết key cụ thể
function typedKeys<T extends object>(obj: T): (keyof T)[] {
  return Object.keys(obj) as (keyof T)[];
}

for (const key of typedKeys(user)) {
  user[key];           // typed correctly
}

class QueryBuilder<T = {}> {
  constructor(private state: T = {} as T) {}
  
  where<K extends string, V>(key: K, value: V): QueryBuilder<T & Record<K, V>> {
    return new QueryBuilder({ ...this.state, [key]: value } as T & Record<K, V>);
  }
  
  build(): T { return this.state; }
}

const q = new QueryBuilder()
  .where("name", "Alice")
  .where("age", 25)
  .build();
// q: { name: string; age: number }

# Type-checking song song
tsgo --checkers 8          # 8 worker thread kiểm tra type (mặc định 4)

# Build song song cho monorepo
tsgo --builders 4          # 4 project reference builder song song

# Chạy đơn luồng (khi debug)
tsgo --singleThreaded

# Kết hợp: --checkers 4 --builders 4 = tối đa 16 type-checker đồng thời

# Build toàn bộ monorepo với project references
tsgo --build tsconfig.json --builders 4

# Chỉ type-check dự án hiện tại (không build dependency)
tsgo --noEmit --checkers 8

# Watch mode — rebuild khi file thay đổi (dùng @parcel/watcher port)
tsgo --watch --incremental

// TS 7.0: union ordering luôn deterministic
type A = "a" | "b" | "c";   // luôn "a" | "b" | "c" (theo thứ tự khai báo)
type B = "c" | "b" | "a";   // luôn "a" | "b" | "c" (TS sắp xếp canonical)

// Conditional distributive qua union — kết quả nhất quán giữa mọi lần build
type Filter<T, U> = T extends U ? T : never;
type R = Filter<"a" | "b" | "c", "b" | "c">;  // "b" | "c" — deterministic

# Watch mode (viết lại bằng Go, dùng @parcel/watcher port)
tsgo --watch

# Build kèm declaration files
tsgo --declaration

# Build incremental
tsgo --incremental

# Project references (hỗ trợ đầy đủ)
tsgo --build tsconfig.json

// tsconfig.json — mặc định bật từ TS 6.0+
{
  "compilerOptions": {
    "noUncheckedSideEffectImports": true
  }
}

// ❌ Bị bắt nếu file import không có type/value export
import "./polyfills";           // side-effect import — phải khai báo rõ

// ✅ OK nếu polyfills.ts có export ít nhất 1 type/value
import "./setup";               // setup.ts export hàm init()

// Temporal API (Stage 3) — có sẵn lib typing trong TS 6.0+
const now = Temporal.Now.plainDateISO();       // Temporal.PlainDate
const zoned = Temporal.Now.zonedDateTimeISO("Asia/Saigon"); // Temporal.ZonedDateTime
const dur = Temporal.Duration.from({ hours: 2, minutes: 30 }); // Temporal.Duration

// Escape string để dùng trong RegExp — có typing sẵn
const escaped = RegExp.escape(".$?*+{}|()[]"); // "\\.\\$\\?\\*\\+\\{\\}\\|\\(\\)\\[\\]"
const re = new RegExp(escaped);                 // RegExp

// DOM collections giờ implement Iterable / AsyncIterable
const nodes = document.querySelectorAll("div");
for (const el of nodes) { }           // ✅ Iterable<HTMLDivElement>

const stream = response.body;         // ReadableStream
for await (const chunk of stream) { } // ✅ AsyncIterable<Uint8Array>