Advanced

// DISTRIBUTIVE CONDITIONAL TYPE
type ToArray<T> = T extends any ? T[] : never; // => Distributes over union
// => Applied to each union member
 
type StringOrNumber = string | number;
type ArrayTypes = ToArray<StringOrNumber>; // => Type: string[] | number[]
// => NOT (string | number)[]
 
// NON-DISTRIBUTIVE CONDITIONAL TYPE
type ToArrayNonDist<T> = [T] extends [any] ? T[] : never; // => Tuple wrapping prevents distribution
 
type ArrayTypesNonDist = ToArrayNonDist<StringOrNumber>; // => Type: (string | number)[]
 
// FILTERING UNION WITH DISTRIBUTION
type ExtractStrings<T> = T extends string ? T : never; // => Keep only strings
 
type Mixed = string | number | boolean;
type OnlyStrings = ExtractStrings<Mixed>; // => Type: string
 
// EXCLUDE TYPE (BUILT-IN)
type Exclude<T, U> = T extends U ? never : T; // => Remove U from T union
 
type WithoutNumber = Exclude<string | number | boolean, number>; // => Type: string | boolean
 
// EXTRACT TYPE (BUILT-IN)
type Extract<T, U> = T extends U ? T : never; // => Keep only T that extends U
 
type OnlyNumber = Extract<string | number | boolean, number>; // => Type: number
 
// CONDITIONAL TYPE WITH INFER
type UnwrapArray<T> = T extends (infer U)[] ? U : T; // => Extract array element type
 
type Numbers = UnwrapArray<number[]>; // => Type: number
type NotArray = UnwrapArray<string>; // => Type: string
 
// MULTIPLE INFER
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
 
type Nested = Promise<Promise<string>>;
type First = UnwrapPromise<Nested>; // => Type: Promise<string> (one level)
type Second = UnwrapPromise<First>; // => Type: string (recursive application)

// RECURSIVE PROMISE UNWRAPPING
type DeepUnwrapPromise<T> =
  T extends Promise<infer U> // => Check if T is Promise
    ? DeepUnwrapPromise<U> // => Recursive call with unwrapped type
    : T; // => Base case: return T
 
type Nested = Promise<Promise<Promise<string>>>;
type Unwrapped = DeepUnwrapPromise<Nested>; // => Type: string (all layers unwrapped)
 
// RECURSIVE ARRAY FLATTENING
type DeepFlatten<T> =
  T extends Array<infer U> // => Check if T is array
    ? DeepFlatten<U> // => Recursively flatten element type
    : T; // => Base case: return T
 
type NestedArray = number[][][];
type Flat = DeepFlatten<NestedArray>; // => Type: number (fully flattened)
 
// RECURSIVE OBJECT KEY PATHS
type DeepKeyPath<T> = T extends object // => Check if T is object
  ? {
      [K in keyof T]: K extends string // => Iterate over keys
        ? T[K] extends object // => Check if value is object
          ? `${K}` | `${K}.${DeepKeyPath<T[K]>}` // => Recursive path building
          : `${K}` // => Leaf key
        : never;
    }[keyof T]
  : never;
 
type User = {
  name: string;
  address: {
    street: string;
    city: string;
    coordinates: {
      lat: number;
      lng: number;
    };
  };
};
 
type UserPaths = DeepKeyPath<User>; // => Type: "name" | "address" | "address.street" | "address.city" | "address.coordinates" | "address.coordinates.lat" | "address.coordinates.lng"
 
// RECURSIVE JSON TYPE
type JSONValue =
  | string
  | number
  | boolean
  | null
  | JSONValue[] // => Recursive: array of JSONValue
  | { [key: string]: JSONValue }; // => Recursive: object with JSONValue values
 
const data: JSONValue = {
  name: "Alice",
  age: 30,
  tags: ["developer", "typescript"],
  nested: {
    deep: {
      value: 42,
    },
  },
}; // => Valid: matches recursive structure

// EVENT NAME GENERATION
type EventName<T extends string> = `on${Capitalize<T>}Change`; // => Template + built-in utility
 
type UserEvent = EventName<"user">; // => Type: "onUserChange"
type EmailEvent = EventName<"email">; // => Type: "onEmailChange"
 
// GETTER/SETTER GENERATION
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]; // => Mapped type with template literal key
};
 
type Setters<T> = {
  [K in keyof T as `set${Capitalize<string & K>}`]: (value: T[K]) => void;
};
 
type Model = {
  name: string;
  age: number;
};
 
type ModelGetters = Getters<Model>; // => Type: { getName: () => string; getAge: () => number }
type ModelSetters = Setters<Model>; // => Type: { setName: (value: string) => void; setAge: (value: number) => void }
 
// CSS PROPERTY GENERATION
type CSSProperty<T extends string> = T | `${T}-top` | `${T}-right` | `${T}-bottom` | `${T}-left`; // => Union of variants
 
type Margin = CSSProperty<"margin">; // => Type: "margin" | "margin-top" | "margin-right" | "margin-bottom" | "margin-left"
type Padding = CSSProperty<"padding">; // => Type: "padding" | "padding-top" | "padding-right" | "padding-bottom" | "padding-left"
 
// HTTP METHOD + PATH TYPE
type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE";
type Endpoint = `/api/${string}`;
type Request = `${HTTPMethod} ${Endpoint}`; // => Combines method and path
 
const validRequest: Request = "GET /api/users"; // => Valid
const validPost: Request = "POST /api/users/123"; // => Valid
// const invalid: Request = "INVALID /api/users"; // => Error: "INVALID" not in HTTPMethod
 
// EXTRACT ROUTE PARAMETERS
type ExtractParams<T extends string> = T extends `${infer _Start}:${infer Param}/${infer Rest}` // => Match :param/rest
  ? Param | ExtractParams<`/${Rest}`> // => Extract param and recurse
  : T extends `${infer _Start}:${infer Param}` // => Match :param at end
    ? Param // => Extract final param
    : never; // => No params
 
type Route = "/users/:userId/posts/:postId";
type Params = ExtractParams<Route>; // => Type: "userId" | "postId"

// FUNCTION COMPOSITION WITH VARIADIC TUPLES
type Fn<Args extends any[], Return> = (...args: Args) => Return; // => Generic function type
 
type Compose<F extends Fn<any[], any>, G extends Fn<any[], any>> =
  F extends Fn<infer FArgs, infer FReturn> // => Infer F's signature
    ? G extends Fn<[FReturn], infer GReturn> // => G must accept F's return
      ? Fn<FArgs, GReturn> // => Composed function type
      : never
    : never;
 
const addOne = (x: number): number => x + 1; // => number → number
const toString = (x: number): string => x.toString(); // => number → string
 
type AddToString = Compose<typeof addOne, typeof toString>; // => Type: (x: number) => string
 
// TUPLE CONCATENATION
type Concat<T extends any[], U extends any[]> = [...T, ...U]; // => Spread both tuples
 
type Numbers = [1, 2, 3];
type Strings = ["a", "b"];
type Combined = Concat<Numbers, Strings>; // => Type: [1, 2, 3, "a", "b"]
 
// PARTIAL APPLICATION
type PartialApply<Fn extends (...args: any[]) => any, Applied extends any[]> = Fn extends (
  ...args: [...Applied, ...infer Rest]
) => infer Return // => Match applied + remaining
  ? (...args: Rest) => Return // => Return function with remaining params
  : never;
 
function greet(greeting: string, name: string, punctuation: string): string {
  return `${greeting} ${name}${punctuation}`; // => Combines all arguments
}
 
type GreetWithHello = PartialApply<typeof greet, [string]>; // => Type: (name: string, punctuation: string) => string
type GreetWithHelloAlice = PartialApply<typeof greet, [string, string]>; // => Type: (punctuation: string) => string
 
// CURRY TYPE
type Curry<Fn> = Fn extends (...args: infer Args) => infer Return // => Infer function signature
  ? Args extends [infer First, ...infer Rest] // => Split first argument
    ? (arg: First) => Curry<(...args: Rest) => Return> // => Recursive currying
    : Return // => Base case: no args left
  : never;
 
function add(a: number, b: number, c: number): number {
  return a + b + c; // => Sum three numbers
}
 
type CurriedAdd = Curry<typeof add>; // => Type: (arg: number) => (arg: number) => (arg: number) => number
 
// TUPLE TAIL
type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : []; // => Remove first element
 
type List = [1, 2, 3, 4];
type TailList = Tail<List>; // => Type: [2, 3, 4]
 
// TUPLE HEAD
type Head<T extends any[]> = T extends [infer First, ...any[]] ? First : never; // => Extract first element
 
type FirstElement = Head<List>; // => Type: 1

// FUNCTION RETURN TYPE EXTRACTION
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never; // => Built-in utility
 
function getUser() {
  return { name: "Alice", age: 30 }; // => Returns object
}
 
type UserType = ReturnType<typeof getUser>; // => Type: { name: string; age: number }
 
// FUNCTION PARAMETER EXTRACTION
type Parameters<T> = T extends (...args: infer P) => any ? P : never; // => Built-in utility
 
function createUser(name: string, age: number, active: boolean) {} // => Three parameters
 
type CreateUserParams = Parameters<typeof createUser>; // => Type: [string, number, boolean]
 
// FIRST PARAMETER EXTRACTION
type FirstParam<T> = T extends (first: infer F, ...args: any[]) => any ? F : never; // => Extract first param type
 
type FirstArg = FirstParam<typeof createUser>; // => Type: string
 
// CONSTRUCTOR PARAMETER EXTRACTION
type ConstructorParameters<T> = T extends new (...args: infer P) => any ? P : never; // => Built-in utility
 
class User {
  constructor(
    public name: string,
    public age: number,
  ) {} // => Constructor with two params
}
 
type UserConstructorParams = ConstructorParameters<typeof User>; // => Type: [string, number]
 
// INSTANCE TYPE EXTRACTION
type InstanceType<T> = T extends new (...args: any[]) => infer R ? R : never; // => Built-in utility
 
type UserInstance = InstanceType<typeof User>; // => Type: User
 
// NESTED INFER FOR ARRAY ELEMENT
type UnpackArray<T> = T extends (infer U)[] ? U : T; // => Extract array element
 
type NumberArray = number[];
type NumberElement = UnpackArray<NumberArray>; // => Type: number
 
// MULTIPLE INFER IN CONDITIONAL
type UnpackPromiseArray<T> = T extends Promise<infer U>[] // => Both Promise AND array
  ? U // => Extract Promise payload
  : never;
 
type PromiseNumbers = Promise<number>[];
type NumberFromPromise = UnpackPromiseArray<PromiseNumbers>; // => Type: number
 
// INFER IN OBJECT PROPERTY
type GetPropertyType<T, K extends keyof T> = T extends { [P in K]: infer V } // => Infer property type
  ? V
  : never;
 
type UserObj = { name: string; age: number };
type NameType = GetPropertyType<UserObj, "name">; // => Type: string
 
// CONTRAVARIANT INFER POSITIONS
type FunctionPropertyNames<T> = {
  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never; // => Filter function properties
}[keyof T];
 
type Obj = {
  name: string;
  getName: () => string;
  setName: (name: string) => void;
};
 
type FuncKeys = FunctionPropertyNames<Obj>; // => Type: "getName" | "setName"

// BASIC BRANDED TYPE
type Brand<T, BrandName extends string> = T & { __brand: BrandName }; // => Intersection with phantom property
 
type UserId = Brand<number, "UserId">; // => Branded number
type ProductId = Brand<number, "ProductId">; // => Different brand
 
function getUserById(id: UserId): string {
  return `User ${id}`; // => Accepts only UserId
}
 
const userId = 123 as UserId; // => Brand casting
const productId = 456 as ProductId; // => Different brand
 
getUserById(userId); // => Valid
// getUserById(productId); // => Error: ProductId not assignable to UserId
// getUserById(123); // => Error: number not assignable to UserId
 
// BRANDED STRING TYPES
type Email = Brand<string, "Email">;
type Username = Brand<string, "Username">;
 
function sendEmail(to: Email, from: Email): void {
  console.log(`Sending email from ${from} to ${to}`); // => Type-safe email handling
}
 
const email = "alice@example.com" as Email; // => Branded string
const username = "alice" as Username; // => Different brand
 
sendEmail(email, email); // => Valid
// sendEmail(username, email); // => Error: Username not assignable to Email
 
// SMART CONSTRUCTOR PATTERN
function createEmail(raw: string): Email | null {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/; // => Email validation regex
  return emailRegex.test(raw) ? (raw as Email) : null; // => Returns branded type or null
}
 
const validEmail = createEmail("alice@example.com"); // => Email | null
const invalidEmail = createEmail("not-an-email"); // => null
 
if (validEmail) {
  sendEmail(validEmail, validEmail); // => Type-safe after validation
}
 
// NUMERIC BRANDED TYPES WITH UNITS
type Kilometers = Brand<number, "Kilometers">;
type Miles = Brand<number, "Miles">;
 
function addKilometers(a: Kilometers, b: Kilometers): Kilometers {
  return (a + b) as Kilometers; // => Type-safe addition
}
 
function convertMilesToKilometers(miles: Miles): Kilometers {
  return (miles * 1.60934) as Kilometers; // => Explicit conversion
}
 
const km1 = 100 as Kilometers;
const km2 = 50 as Kilometers;
const miles = 10 as Miles;
 
addKilometers(km1, km2); // => Valid: same units
// addKilometers(km1, miles); // => Error: can't mix units
const converted = convertMilesToKilometers(miles); // => Explicit conversion required
addKilometers(km1, converted); // => Valid after conversion
 
// OPAQUE TYPE WITH CLASS
class EmailAddress {
  private __brand!: "Email"; // => Private phantom property
  private constructor(public value: string) {} // => Private constructor
 
  static create(raw: string): EmailAddress | null {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(raw) ? new EmailAddress(raw) : null; // => Factory method
  }
}
 
function sendTypedEmail(to: EmailAddress): void {
  console.log(`Sending to ${to.value}`); // => Access validated value
}
 
const typedEmail = EmailAddress.create("alice@example.com");
if (typedEmail) {
  sendTypedEmail(typedEmail); // => Type-safe with validation
}

// TYPE-LEVEL COUNTER WITH TUPLES
type Length<T extends any[]> = T["length"]; // => Extract tuple length
 
type Three = Length<[1, 2, 3]>; // => Type: 3
type Five = Length<[1, 1, 1, 1, 1]>; // => Type: 5
 
// BUILD TUPLE OF SPECIFIC LENGTH
type BuildTuple<L extends number, T extends any[] = []> = T["length"] extends L // => Check if reached target
  ? T // => Base case: return tuple
  : BuildTuple<L, [...T, any]>; // => Recursive: add element
 
type TupleOfFive = BuildTuple<5>; // => Type: [any, any, any, any, any]
type LengthOfTuple = Length<TupleOfFive>; // => Type: 5
 
// TYPE-LEVEL ADDITION
type Add<A extends number, B extends number> = Length<[...BuildTuple<A>, ...BuildTuple<B>]>; // => Concatenate tuples and get length
 
type TwoPlusThree = Add<2, 3>; // => Type: 5
type FourPlusSix = Add<4, 6>; // => Type: 10
 
// TYPE-LEVEL SUBTRACTION
type Subtract<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, ...infer Rest] // => Remove B elements from A
    ? Length<Rest> // => Return remaining length
    : never;
 
type FiveMinusTwo = Subtract<5, 2>; // => Type: 3
type TenMinusFour = Subtract<10, 4>; // => Type: 6
 
// TYPE-LEVEL COMPARISON
type GreaterThan<A extends number, B extends number> = Subtract<A, B> extends never ? false : true; // => If subtraction valid, A > B
 
type FiveGreaterThree = GreaterThan<5, 3>; // => Type: true
type TwoGreaterFive = GreaterThan<2, 5>; // => Type: false
 
// RANGE TYPE GENERATION
type Range<N extends number, Acc extends number[] = []> = Acc["length"] extends N // => Check if reached N
  ? Acc[number] // => Return union of array indices
  : Range<N, [...Acc, Acc["length"]]>; // => Recursive: add next number
 
type ZeroToFour = Range<5>; // => Type: 0 | 1 | 2 | 3 | 4
type ZeroToNine = Range<10>; // => Type: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

// INTERFACE MERGING (AUTOMATIC)
interface User {
  name: string; // => First declaration
}
 
interface User {
  age: number; // => Second declaration merges
}
 
const user: User = {
  name: "Alice", // => Combined interface
  age: 30, // => Requires both properties
};
 
// NAMESPACE AND FUNCTION MERGING
function createLogger(message: string) {
  console.log(message); // => Function behavior
}
 
namespace createLogger {
  export let version = "1.0.0"; // => Namespace property
  export function debug(message: string) {
    // => Namespace method
    console.log(`[DEBUG] ${message}`);
  }
}
 
createLogger("Info message"); // => Call as function
console.log(createLogger.version); // => Access namespace property: "1.0.0"
createLogger.debug("Debug message"); // => Call namespace method
 
// CLASS AND NAMESPACE MERGING
class Album {
  constructor(public title: string) {} // => Class constructor
}
 
namespace Album {
  export class Track {
    // => Nested class in namespace
    constructor(
      public name: string,
      public duration: number,
    ) {}
  }
  export function create(title: string): Album {
    // => Factory function
    return new Album(title);
  }
}
 
const album = new Album("Greatest Hits"); // => Class constructor
const track = new Album.Track("Song 1", 180); // => Nested class
const album2 = Album.create("Best Of"); // => Factory function
 
// ENUM AND NAMESPACE MERGING
enum Color {
  Red = "RED",
  Green = "GREEN",
  Blue = "BLUE",
}
 
namespace Color {
  export function parse(value: string): Color | undefined {
    // => Parse string to enum
    return Object.values(Color).find((c) => c === value);
  }
  export function values(): Color[] {
    // => Get all enum values
    return Object.values(Color);
  }
}
 
const red = Color.Red; // => Enum member: "RED"
const parsed = Color.parse("GREEN"); // => Namespace function: Color.Green
const allColors = Color.values(); // => ["RED", "GREEN", "BLUE"]
 
// MODULE AUGMENTATION (EXTENDING THIRD-PARTY)
// Extend existing module
declare module "express" {
  interface Request {
    user?: { id: string; name: string }; // => Add user property
  }
}
 
// Now Request type includes user property globally

// EXTENDING ARRAY PROTOTYPE TYPES
interface Array<T> {
  first(): T | undefined; // => Add first method
  last(): T | undefined; // => Add last method
}
 
// Implementation (would be in separate .js file)
Array.prototype.first = function () {
  return this[0]; // => Return first element
};
 
Array.prototype.last = function () {
  return this[this.length - 1]; // => Return last element
};
 
const numbers = [1, 2, 3, 4, 5];
const firstNum = numbers.first(); // => Type: number | undefined, Value: 1
const lastNum = numbers.last(); // => Type: number | undefined, Value: 5
 
// EXTENDING GLOBAL NAMESPACE
declare global {
  interface Window {
    // => Extend Window interface
    myApp: {
      version: string;
      apiUrl: string;
    };
  }
 
  var APP_VERSION: string; // => Global variable type
 
  namespace NodeJS {
    // => Extend NodeJS namespace
    interface ProcessEnv {
      DATABASE_URL: string; // => Type-safe env var
      API_KEY: string;
      NODE_ENV: "development" | "production" | "test";
    }
  }
}
 
// Usage (browser)
window.myApp = {
  // => Typed global object
  version: "1.0.0",
  apiUrl: "https://api.example.com",
};
 
// Usage (Node.js)
const dbUrl = process.env.DATABASE_URL; // => Type: string
const nodeEnv = process.env.NODE_ENV; // => Type: "development" | "production" | "test"
 
// EXTENDING STRING WITH CUSTOM METHODS
interface String {
  truncate(maxLength: number): string; // => Add truncate method
}
 
String.prototype.truncate = function (maxLength: number): string {
  return this.length > maxLength ? this.substring(0, maxLength) + "..." : this.toString(); // => Truncate with ellipsis
};
 
const longText = "This is a very long string";
const truncated = longText.truncate(10); // => "This is a ..."
 
// EXTENDING PROMISE WITH TIMEOUT
interface Promise<T> {
  timeout(ms: number): Promise<T>; // => Add timeout method
}
 
Promise.prototype.timeout = function <T>(this: Promise<T>, ms: number): Promise<T> {
  return Promise.race([
    this, // => Original promise
    new Promise<T>(
      (_, reject) => setTimeout(() => reject(new Error("Timeout")), ms), // => Timeout promise
    ),
  ]);
};
 
const fetchWithTimeout = fetch("https://api.example.com").timeout(5000); // => Fails if >5s

// BASIC ABSTRACT CLASS
abstract class Animal {
  constructor(public name: string) {} // => Concrete property
 
  abstract makeSound(): string; // => Subclasses must implement
 
  move(distance: number): string {
    // => Concrete method
    return `${this.name} moved ${distance} meters`;
  }
 
  describe(): string {
    // => Template method using abstract
    return `${this.name} says ${this.makeSound()}`;
  }
}
 
class Dog extends Animal {
  makeSound(): string {
    // => Required implementation
    return "Woof!";
  }
}
 
const dog = new Dog("Rex");
console.log(dog.makeSound()); // => Output: "Woof!"
console.log(dog.move(10)); // => Output: "Rex moved 10 meters"
console.log(dog.describe()); // => Output: "Rex says Woof!"
 
// const animal = new Animal("Generic"); // => Error: Cannot instantiate abstract class
 
// ABSTRACT CLASS WITH PROTECTED MEMBERS
abstract class Repository<T> {
  protected abstract tableName: string; // => Subclasses define table
 
  protected abstract validate(item: T): boolean; // => Validation logic
 
  async save(item: T): Promise<void> {
    // => Template method
    if (!this.validate(item)) {
      // => Use abstract validation
      throw new Error("Validation failed");
    }
    console.log(`Saving to ${this.tableName}:`, item); // => Use abstract tableName
  }
 
  async findById(id: string): Promise<T | null> {
    // => Concrete shared logic
    console.log(`Finding in ${this.tableName} by id: ${id}`);
    return null; // => Placeholder
  }
}
 
interface User {
  id: string;
  name: string;
  email: string;
}
 
class UserRepository extends Repository<User> {
  protected tableName = "users"; // => Concrete value
 
  protected validate(user: User): boolean {
    // => Concrete validation
    return user.email.includes("@"); // => Simple email check
  }
 
  async findByEmail(email: string): Promise<User | null> {
    // => Additional method
    console.log(`Finding user by email: ${email}`);
    return null;
  }
}
 
const userRepo = new UserRepository();
userRepo.save({ id: "1", name: "Alice", email: "alice@example.com" }); // => Valid
// userRepo.save({ id: "2", name: "Bob", email: "invalid" }); // => Throws: Validation failed
 
// ABSTRACT CLASS WITH FACTORY METHOD
abstract class PaymentProcessor {
  abstract createPayment(amount: number): Payment; // => Factory method
 
  process(amount: number): string {
    // => Template method
    const payment = this.createPayment(amount); // => Use factory
    return payment.execute(); // => Execute payment
  }
}
 
interface Payment {
  execute(): string;
}
 
class CreditCardPayment implements Payment {
  constructor(private amount: number) {}
  execute(): string {
    return `Processing credit card payment: $${this.amount}`;
  }
}
 
class PayPalPayment implements Payment {
  constructor(private amount: number) {}
  execute(): string {
    return `Processing PayPal payment: $${this.amount}`;
  }
}
 
class CreditCardProcessor extends PaymentProcessor {
  createPayment(amount: number): Payment {
    // => Factory implementation
    return new CreditCardPayment(amount);
  }
}
 
class PayPalProcessor extends PaymentProcessor {
  createPayment(amount: number): Payment {
    return new PayPalPayment(amount);
  }
}
 
const ccProcessor = new CreditCardProcessor();
console.log(ccProcessor.process(100)); // => "Processing credit card payment: $100"
 
const ppProcessor = new PayPalProcessor();
console.log(ppProcessor.process(50)); // => "Processing PayPal payment: $50"

// BASIC MIXIN TYPE
type Constructor<T = {}> = new (...args: any[]) => T; // => Constructor type
 
// TIMESTAMPED MIXIN
function Timestamped<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    // => Return extended class
    createdAt = new Date(); // => Add timestamp property
 
    getAge(): number {
      // => Add age method
      return Date.now() - this.createdAt.getTime();
    }
  };
}
 
// ACTIVATABLE MIXIN
function Activatable<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    isActive = false; // => Add active state
 
    activate() {
      // => Add activate method
      this.isActive = true;
      console.log("Activated");
    }
 
    deactivate() {
      this.isActive = false;
      console.log("Deactivated");
    }
  };
}
 
// BASE CLASS
class User {
  constructor(public name: string) {}
}
 
// COMPOSE MIXINS
const TimestampedUser = Timestamped(User); // => Apply first mixin
const TimestampedActivatableUser = Activatable(TimestampedUser); // => Apply second mixin
 
const user = new TimestampedActivatableUser("Alice");
console.log(user.name); // => "Alice" (from base class)
console.log(user.createdAt); // => Date (from Timestamped)
console.log(user.isActive); // => false (from Activatable)
user.activate(); // => "Activated"
console.log(user.getAge()); // => Number (milliseconds since creation)
 
// TYPED MIXIN HELPER
function applyMixins(derivedCtor: any, constructors: any[]) {
  constructors.forEach((baseCtor) => {
    // => Iterate mixins
    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
      // => Copy methods
      Object.defineProperty(
        derivedCtor.prototype,
        name,
        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || Object.create(null),
      );
    });
  });
}
 
// MIXIN WITH REQUIREMENTS
interface Named {
  name: string;
}
 
function Loggable<TBase extends Constructor<Named>>(Base: TBase) {
  // => Require 'name' property
  return class extends Base {
    log(message: string) {
      console.log(`[${this.name}] ${message}`); // => Use required property
    }
  };
}
 
class Product {
  constructor(
    public name: string,
    public price: number,
  ) {}
}
 
const LoggableProduct = Loggable(Product);
const product = new LoggableProduct("Widget", 29.99);
product.log("In stock"); // => "[Widget] In stock"
 
// CHAINABLE MIXINS
function Serializable<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    serialize(): string {
      // => Serialize to JSON
      return JSON.stringify(this);
    }
 
    static deserialize<T>(this: Constructor<T>, json: string): T {
      // => Deserialize from JSON
      const obj = JSON.parse(json);
      return new this(obj);
    }
  };
}
 
class Document {
  constructor(
    public title: string,
    public content: string,
  ) {}
}
 
const SerializableDocument = Serializable(Timestamped(Document)); // => Chain mixins
const doc = new SerializableDocument("Report", "Lorem ipsum");
const json = doc.serialize(); // => {"title":"Report","content":"Lorem ipsum","createdAt":"..."}

// ENABLE DECORATORS IN tsconfig.json:
// "experimentalDecorators": true
// "emitDecoratorMetadata": true
 
// CLASS DECORATOR
function Component(options: { selector: string }) {
  return function <T extends { new (...args: any[]): {} }>(constructor: T) {
    // => Decorator factory
    return class extends constructor {
      selector = options.selector; // => Add selector property
    };
  };
}
 
@Component({ selector: "app-user" })
class UserComponent {
  name = "User Component";
}
 
const component = new UserComponent();
console.log((component as any).selector); // => "app-user"
 
// METHOD DECORATOR
function Log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value; // => Store original method
 
  descriptor.value = function (...args: any[]) {
    // => Replace method
    console.log(`Calling ${propertyKey} with`, args); // => Log before
    const result = originalMethod.apply(this, args); // => Call original
    console.log(`Result:`, result); // => Log after
    return result;
  };
 
  return descriptor;
}
 
class Calculator {
  @Log
  add(a: number, b: number): number {
    return a + b; // => Original logic
  }
}
 
const calc = new Calculator();
calc.add(5, 3); // => Logs: "Calling add with [5, 3]" then "Result: 8"
 
// PROPERTY DECORATOR
function ReadOnly(target: any, propertyKey: string) {
  Object.defineProperty(target, propertyKey, {
    writable: false, // => Make read-only
    configurable: false,
  });
}
 
class Config {
  @ReadOnly
  apiUrl = "https://api.example.com"; // => Immutable property
}
 
const config = new Config();
// config.apiUrl = "https://new-url.com"; // => Error: Cannot assign to read-only property
 
// PARAMETER DECORATOR
function Required(target: any, propertyKey: string, parameterIndex: number) {
  const existingRequiredParameters: number[] = Reflect.getOwnMetadata("required", target, propertyKey) || []; // => Get existing metadata
  existingRequiredParameters.push(parameterIndex); // => Add parameter index
  Reflect.defineMetadata("required", existingRequiredParameters, target, propertyKey); // => Store metadata
}
 
function Validate(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
 
  descriptor.value = function (...args: any[]) {
    const requiredParameters: number[] = Reflect.getOwnMetadata("required", target, propertyKey) || []; // => Get required params
 
    for (const index of requiredParameters) {
      if (args[index] === undefined || args[index] === null) {
        // => Check required params
        throw new Error(`Parameter at index ${index} is required`);
      }
    }
 
    return originalMethod.apply(this, args);
  };
}
 
class UserService {
  @Validate
  createUser(@Required name: string, @Required email: string, age?: number) {
    return { name, email, age }; // => Create user object
  }
}
 
const service = new UserService();
service.createUser("Alice", "alice@example.com"); // => Valid
// service.createUser("Bob", null as any); // => Throws: Parameter at index 1 is required
 
// DECORATOR COMPOSITION
function Retry(attempts: number) {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
 
    descriptor.value = async function (...args: any[]) {
      for (let i = 0; i < attempts; i++) {
        // => Retry loop
        try {
          return await originalMethod.apply(this, args); // => Try original method
        } catch (error) {
          if (i === attempts - 1) throw error; // => Rethrow on last attempt
          console.log(`Retry ${i + 1}/${attempts}`);
        }
      }
    };
  };
}
 
class ApiClient {
  @Log
  @Retry(3)
  async fetchData(url: string): Promise<string> {
    // => Multiple decorators
    console.log(`Fetching ${url}`);
    if (Math.random() > 0.7) throw new Error("Network error"); // => Simulate failure
    return "data";
  }
}

// BASIC SYMBOL
const id = Symbol("id"); // => Create unique symbol
const id2 = Symbol("id"); // => Different symbol (same description)
 
console.log(id === id2); // => false (symbols always unique)
 
const user = {
  name: "Alice",
  [id]: 123, // => Symbol as property key
};
 
console.log(user[id]); // => 123
console.log(user.name); // => "Alice"
 
// SYMBOLS DON'T APPEAR IN NORMAL ITERATION
console.log(Object.keys(user)); // => ["name"] (symbol key omitted)
console.log(Object.getOwnPropertyNames(user)); // => ["name"]
console.log(Object.getOwnPropertySymbols(user)); // => [Symbol(id)] (only way to get symbols)
 
// WELL-KNOWN SYMBOLS - ITERATOR
class NumberRange {
  constructor(
    private start: number,
    private end: number,
  ) {}
 
  [Symbol.iterator]() {
    // => Make iterable
    let current = this.start;
    const end = this.end;
 
    return {
      next() {
        if (current <= end) {
          return { value: current++, done: false }; // => Yield value
        }
        return { value: undefined, done: true }; // => Iteration complete
      },
    };
  }
}
 
const range = new NumberRange(1, 5);
for (const num of range) {
  // => Uses Symbol.iterator
  console.log(num); // => 1, 2, 3, 4, 5
}
 
// WELL-KNOWN SYMBOLS - TO PRIMITIVE
class Money {
  constructor(private amount: number) {}
 
  [Symbol.toPrimitive](hint: string) {
    // => Custom type coercion
    if (hint === "number") {
      return this.amount; // => Return number
    }
    if (hint === "string") {
      return `$${this.amount}`; // => Return string
    }
    return this.amount; // => Default
  }
}
 
const money = new Money(100);
console.log(+money); // => 100 (number coercion)
console.log(`Total: ${money}`); // => "Total: $100" (string coercion)
console.log(money + 50); // => 150 (default coercion)
 
// SYMBOL AS METADATA KEY
const metadataKey = Symbol("metadata");
 
function addMetadata(target: any, data: any) {
  target[metadataKey] = data; // => Store metadata
}
 
class Product {
  name: string;
}
 
addMetadata(Product, { version: "1.0", author: "Alice" });
console.log((Product as any)[metadataKey]); // => { version: "1.0", author: "Alice" }
 
// GLOBAL SYMBOL REGISTRY
const globalId = Symbol.for("app.userId"); // => Create/retrieve global symbol
const sameGlobalId = Symbol.for("app.userId"); // => Retrieves same symbol
 
console.log(globalId === sameGlobalId); // => true (shared global symbol)
console.log(Symbol.keyFor(globalId)); // => "app.userId" (get key from symbol)
 
// SYMBOL-BASED PRIVATE PROPERTIES
const _balance = Symbol("balance");
 
class BankAccount {
  [_balance]: number; // => Symbol property
 
  constructor(initialBalance: number) {
    this[_balance] = initialBalance; // => Initialize private-like property
  }
 
  deposit(amount: number) {
    this[_balance] += amount; // => Modify private-like property
  }
 
  getBalance(): number {
    return this[_balance]; // => Access private-like property
  }
}
 
const account = new BankAccount(1000);
account.deposit(500);
console.log(account.getBalance()); // => 1500
console.log(Object.keys(account)); // => [] (symbol property hidden)

// ASYNC ITERATOR INTERFACE
interface AsyncIterator<T> {
  next(): Promise<IteratorResult<T>>; // => Returns promise of result
}
 
interface AsyncIterable<T> {
  [Symbol.asyncIterator](): AsyncIterator<T>; // => Returns async iterator
}
 
// MANUAL ASYNC ITERATOR
class AsyncNumberRange implements AsyncIterable<number> {
  constructor(
    private start: number,
    private end: number,
    private delay: number,
  ) {}
 
  [Symbol.asyncIterator](): AsyncIterator<number> {
    let current = this.start;
    const end = this.end;
    const delay = this.delay;
 
    return {
      async next(): Promise<IteratorResult<number>> {
        // => Async next method
        if (current <= end) {
          await new Promise((resolve) => setTimeout(resolve, delay)); // => Simulate async operation
          return { value: current++, done: false }; // => Yield value
        }
        return { value: undefined, done: true }; // => Complete
      },
    };
  }
}
 
// USAGE WITH FOR-AWAIT-OF
async function consumeAsyncRange() {
  const range = new AsyncNumberRange(1, 5, 100); // => 1-5 with 100ms delay
 
  for await (const num of range) {
    // => Async iteration
    console.log(num); // => 1, 2, 3, 4, 5 (with delays)
  }
}
 
// ASYNC GENERATOR FUNCTION
async function* asyncNumberGenerator(start: number, end: number) {
  for (let i = start; i <= end; i++) {
    await new Promise((resolve) => setTimeout(resolve, 100)); // => Delay
    yield i; // => Yield value asynchronously
  }
}
 
async function useAsyncGenerator() {
  for await (const num of asyncNumberGenerator(1, 5)) {
    console.log(num); // => 1, 2, 3, 4, 5 (with delays)
  }
}
 
// ASYNC GENERATOR WITH API PAGINATION
async function* fetchPages<T>(baseUrl: string, pageSize: number): AsyncGenerator<T[], void, undefined> {
  let page = 1;
  let hasMore = true;
 
  while (hasMore) {
    const response = await fetch(`${baseUrl}?page=${page}&size=${pageSize}`); // => Fetch page
    const data: T[] = await response.json(); // => Parse JSON
 
    if (data.length < pageSize) {
      hasMore = false; // => Last page
    }
 
    yield data; // => Yield page data
    page++;
  }
}
 
async function processAllUsers() {
  for await (const users of fetchPages<{
    id: string;
    name: string;
  }>("https://api.example.com/users", 100)) {
    console.log(`Processing ${users.length} users`); // => Process each page
  }
}
 
// ASYNC ITERATOR HELPERS
async function* map<T, U>(source: AsyncIterable<T>, transform: (item: T) => U): AsyncGenerator<U, void, undefined> {
  for await (const item of source) {
    // => Iterate source
    yield transform(item); // => Transform and yield
  }
}
 
async function* filter<T>(
  source: AsyncIterable<T>,
  predicate: (item: T) => boolean,
): AsyncGenerator<T, void, undefined> {
  for await (const item of source) {
    if (predicate(item)) {
      // => Check predicate
      yield item; // => Yield if passes
    }
  }
}
 
// COMPOSE ASYNC ITERATORS
async function processData() {
  const numbers = asyncNumberGenerator(1, 10);
  const doubled = map(numbers, (n) => n * 2); // => Transform
  const filtered = filter(doubled, (n) => n > 10); // => Filter
 
  for await (const num of filtered) {
    console.log(num); // => 12, 14, 16, 18, 20
  }
}
 
// ASYNC ITERATOR WITH ERROR HANDLING
async function* fetchWithRetry(urls: string[]): AsyncGenerator<string, void, undefined> {
  for (const url of urls) {
    let attempts = 0;
    const maxAttempts = 3;
 
    while (attempts < maxAttempts) {
      try {
        const response = await fetch(url); // => Attempt fetch
        const data = await response.text();
        yield data; // => Yield on success
        break; // => Exit retry loop
      } catch (error) {
        attempts++;
        if (attempts >= maxAttempts) {
          console.error(`Failed to fetch ${url} after ${maxAttempts} attempts`);
          yield `ERROR: ${url}`; // => Yield error marker
        }
      }
    }
  }
}

// WEAKMAP FOR PRIVATE DATA
const privateData = new WeakMap<object, { secret: string }>(); // => WeakMap with typed values
 
class User {
  constructor(name: string) {
    privateData.set(this, { secret: `${name}-secret-key` }); // => Store private data
  }
 
  getSecret(): string {
    const data = privateData.get(this); // => Retrieve private data
    return data ? data.secret : ""; // => Type-safe access
  }
}
 
const user1 = new User("Alice");
console.log(user1.getSecret()); // => "Alice-secret-key"
// No way to access privateData from outside without User instance
 
// WEAKMAP FOR METADATA
const metadata = new WeakMap<Function, { version: string; author: string }>(); // => Function metadata
 
function addMetadata(target: Function, meta: { version: string; author: string }) {
  metadata.set(target, meta); // => Associate metadata with function
}
 
function Component() {}
 
addMetadata(Component, { version: "1.0", author: "Alice" });
console.log(metadata.get(Component)); // => { version: "1.0", author: "Alice" }
 
// WEAKSET FOR OBJECT TRACKING
const processedObjects = new WeakSet<object>(); // => Track processed objects
 
function processOnce<T extends object>(obj: T, processor: (obj: T) => void) {
  if (processedObjects.has(obj)) {
    // => Check if already processed
    console.log("Already processed");
    return;
  }
 
  processor(obj); // => Process object
  processedObjects.add(obj); // => Mark as processed
}
 
const data = { value: 42 };
processOnce(data, (obj) => console.log("Processing", obj)); // => "Processing { value: 42 }"
processOnce(data, (obj) => console.log("Processing", obj)); // => "Already processed"
 
// WEAKMAP FOR DOM ELEMENT DATA
const elementData = new WeakMap<HTMLElement, { clicks: number; lastClick: Date }>(); // => DOM element metadata
 
function trackClicks(element: HTMLElement) {
  const data = elementData.get(element) || { clicks: 0, lastClick: new Date() }; // => Get or initialize
  data.clicks++; // => Increment clicks
  data.lastClick = new Date(); // => Update timestamp
  elementData.set(element, data); // => Update metadata
}
 
// When element removed from DOM, metadata is garbage collected automatically
 
// WEAKMAP FOR MEMOIZATION
const memoCache = new WeakMap<object, any>(); // => Cache for objects
 
function memoize<T extends object, R>(fn: (obj: T) => R): (obj: T) => R {
  return (obj: T): R => {
    if (memoCache.has(obj)) {
      // => Check cache
      return memoCache.get(obj); // => Return cached result
    }
 
    const result = fn(obj); // => Compute result
    memoCache.set(obj, result); // => Cache result
    return result;
  };
}
 
const expensiveComputation = memoize((obj: { value: number }) => {
  console.log("Computing...");
  return obj.value * 2;
});
 
const obj = { value: 5 };
console.log(expensiveComputation(obj)); // => "Computing..." then 10
console.log(expensiveComputation(obj)); // => 10 (cached, no "Computing...")
 
// WEAKMAP VS MAP MEMORY BEHAVIOR
const strongMap = new Map<object, string>(); // => Strong references
const weakMap = new WeakMap<object, string>(); // => Weak references
 
let obj1 = { id: 1 };
let obj2 = { id: 2 };
 
strongMap.set(obj1, "value1"); // => Strong reference prevents GC
weakMap.set(obj2, "value2"); // => Weak reference allows GC
 
obj1 = null as any; // => Remove strong reference, but Map still holds it
obj2 = null as any; // => Remove strong reference, WeakMap allows GC
 
// obj1 NOT garbage collected (Map holds reference)
// obj2 IS garbage collected (WeakMap doesn't prevent GC)

// BASIC PROXY WITH TYPED HANDLER
interface User {
  name: string;
  age: number;
}
 
const userHandler: ProxyHandler<User> = {
  get(target: User, prop: string | symbol, receiver: any): any {
    // => Intercept property access
    console.log(`Getting ${String(prop)}`);
    return Reflect.get(target, prop, receiver); // => Forward to target
  },
 
  set(target: User, prop: string | symbol, value: any, receiver: any): boolean {
    // => Intercept property assignment
    console.log(`Setting ${String(prop)} to ${value}`);
    return Reflect.set(target, prop, value, receiver); // => Forward to target
  },
};
 
const user: User = { name: "Alice", age: 30 };
const proxiedUser = new Proxy(user, userHandler);
 
console.log(proxiedUser.name); // => "Getting name" then "Alice"
proxiedUser.age = 31; // => "Setting age to 31"
 
// VALIDATION PROXY
function createValidatedObject<T extends object>(
  obj: T,
  validators: Partial<Record<keyof T, (value: any) => boolean>>,
): T {
  return new Proxy(obj, {
    set(target: T, prop: string | symbol, value: any): boolean {
      const key = prop as keyof T;
      const validator = validators[key]; // => Get validator for property
 
      if (validator && !validator(value)) {
        // => Validate if validator exists
        throw new Error(`Invalid value for ${String(prop)}: ${value}`);
      }
 
      return Reflect.set(target, prop, value); // => Set if valid
    },
  });
}
 
const validatedUser = createValidatedObject(
  { name: "Alice", age: 30 },
  {
    age: (value) => typeof value === "number" && value > 0, // => Age validator
    name: (value) => typeof value === "string" && value.length > 0, // => Name validator
  },
);
 
validatedUser.age = 25; // => Valid
// validatedUser.age = -5; // => Throws: Invalid value for age: -5
 
// OBSERVABLE PROXY
type Observer<T> = (prop: keyof T, oldValue: any, newValue: any) => void;
 
function observable<T extends object>(obj: T, observer: Observer<T>): T {
  return new Proxy(obj, {
    set(target: T, prop: string | symbol, value: any): boolean {
      const key = prop as keyof T;
      const oldValue = target[key]; // => Store old value
 
      const result = Reflect.set(target, prop, value); // => Set new value
 
      if (oldValue !== value) {
        // => Notify only if changed
        observer(key, oldValue, value); // => Call observer
      }
 
      return result;
    },
  });
}
 
const observableUser = observable({ name: "Alice", age: 30 }, (prop, oldVal, newVal) => {
  console.log(`${String(prop)} changed from ${oldVal} to ${newVal}`);
});
 
observableUser.age = 31; // => "age changed from 30 to 31"
 
// DEFAULT VALUE PROXY
function withDefaults<T extends object>(obj: T, defaults: Partial<T>): T {
  return new Proxy(obj, {
    get(target: T, prop: string | symbol): any {
      const key = prop as keyof T;
      return target[key] !== undefined ? target[key] : defaults[key]; // => Use default if undefined
    },
  });
}
 
const config = withDefaults({ port: 3000 }, { host: "localhost", port: 8080, debug: false });
 
console.log(config.port); // => 3000 (from object)
console.log((config as any).host); // => "localhost" (from defaults)
console.log((config as any).debug); // => false (from defaults)
 
// METHOD CALL TRACKING PROXY
function trackMethodCalls<T extends object>(obj: T): T {
  const callCounts = new Map<string, number>(); // => Track call counts
 
  return new Proxy(obj, {
    get(target: T, prop: string | symbol): any {
      const value = Reflect.get(target, prop);
 
      if (typeof value === "function") {
        // => Intercept methods only
        return function (...args: any[]) {
          const key = String(prop);
          callCounts.set(key, (callCounts.get(key) || 0) + 1); // => Increment count
          console.log(`${key} called ${callCounts.get(key)} times`);
          return value.apply(target, args); // => Call original method
        };
      }
 
      return value;
    },
  });
}
 
class Calculator {
  add(a: number, b: number): number {
    return a + b;
  }
  multiply(a: number, b: number): number {
    return a * b;
  }
}
 
const trackedCalc = trackMethodCalls(new Calculator());
trackedCalc.add(1, 2); // => "add called 1 times"
trackedCalc.add(3, 4); // => "add called 2 times"
trackedCalc.multiply(2, 3); // => "multiply called 1 times"
 
// NEGATIVE ARRAY INDEXING PROXY
function createArrayProxy<T>(arr: T[]): T[] {
  return new Proxy(arr, {
    get(target: T[], prop: string | symbol): any {
      if (typeof prop === "string") {
        const index = parseInt(prop, 10);
        if (!isNaN(index) && index < 0) {
          // => Negative index
          return target[target.length + index]; // => Convert to positive
        }
      }
      return Reflect.get(target, prop);
    },
  });
}
 
const arr = createArrayProxy([1, 2, 3, 4, 5]);
console.log(arr[-1]); // => 5 (last element)
console.log(arr[-2]); // => 4 (second to last)