نظام الأنواع في TypeScript — من Generics إلى Conditional Types

// بدون Generics — تكرار ممل
function firstString(arr: string[]): string { return arr[0]; }
function firstNumber(arr: number[]): number { return arr[0]; }
 
// مع Generic — دالة واحدة لكل الأنواع
function first<T>(arr: T[]): T {
  return arr[0];
}
 
const s = first(["a", "b", "c"]); // TypeScript يستنتج T = string
const n = first([1, 2, 3]);       // TypeScript يستنتج T = number

// T يجب أن يكون له خاصية length
function longest<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}
 
longest("hello", "world");   // OK
longest([1, 2], [3]);        // OK
longest(10, 20);             // خطأ! number ليس له length

function zip<A, B>(a: A[], b: B[]): [A, B][] {
  return a.map((item, i) => [item, b[i]]);
}
 
const result = zip(["أحمد", "علي"], [25, 30]);
// النوع: [string, number][]

type IsString<T> = T extends string ? true : false;
 
type A = IsString<string>;  // true
type B = IsString<number>;  // false

type Awaited<T> = T extends Promise<infer R> ? R : T;
 
type A = Awaited<Promise<string>>;  // string
type B = Awaited<string>;           // string (لا promise)
type C = Awaited<Promise<Promise<number>>>; // Promise<number>

type ToArray<T> = T extends any ? T[] : never;
 
// عند تمرير union type، ينتشر على كل عضو
type Arr = ToArray<string | number>;
// النتيجة: string[] | number[]
// وليس: (string | number)[]

// المدمجة في TypeScript
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] };
type Nullable<T>  = { [K in keyof T]: T[K] | null };

type DeepPartial<T> = T extends object
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;
 
type Config = {
  server: { host: string; port: number };
  database: { url: string; name: string };
};
 
// كل المستويات اختيارية الآن
const patch: DeepPartial<Config> = {
  server: { port: 8080 }, // host غير مطلوب
};

type EventName = "click" | "focus" | "blur";
type HandlerName = `on${Capitalize<EventName>}`;
// "onClick" | "onFocus" | "onBlur"
 
type CSSProperty =
  | `margin-${"top" | "right" | "bottom" | "left"}`
  | `padding-${"top" | "right" | "bottom" | "left"}`;

type EventMap = {
  login:  { userId: string; timestamp: number };
  logout: { userId: string };
  error:  { message: string; code: number };
};
 
class TypedEmitter<Events extends Record<string, unknown>> {
  private handlers = new Map<keyof Events, Set<Function>>();
 
  on<K extends keyof Events>(
    event: K,
    handler: (data: Events[K]) => void
  ): void {
    if (!this.handlers.has(event)) {
      this.handlers.set(event, new Set());
    }
    this.handlers.get(event)!.add(handler);
  }
 
  emit<K extends keyof Events>(event: K, data: Events[K]): void {
    this.handlers.get(event)?.forEach((fn) => fn(data));
  }
}
 
const emitter = new TypedEmitter<EventMap>();
 
// TypeScript يعرف بدقة نوع data في كل حالة
emitter.on("login",  (data) => console.log(data.userId));
emitter.on("error",  (data) => console.log(data.code));
emitter.emit("login", { userId: "123", timestamp: Date.now() });