System Design

// Singleton: Ensure only one instance exists
class Singleton {
  private static instance: Singleton;
  private constructor() {}
  static getInstance() { return this.instance ||= new Singleton(); }
}

// Builder: Step-by-step construction of complex objects
class HouseBuilder {
  private house = new House();
  buildWalls() { /*...*/ return this; }
  buildRoof() { /*...*/ return this; }
  getHouse() { return this.house; }
}

// Factory Method: Delegate instantiation to subclasses
abstract class Creator {
  abstract createProduct(): Product;
  someOperation() { const p = this.createProduct(); p.doStuff(); }
}

// Abstract Factory: Create families of related objects
interface GUIFactory { createButton(): Button; createCheckbox(): Checkbox; }
class WinFactory implements GUIFactory { 
  createButton() { return new WinButton(); } 
  createCheckbox() { return new WinCheckbox(); }
}

// Adapter (Object): Wrap incompatible interface to match expected one
class Adapter implements Target {
  constructor(private adaptee: Adaptee) {}
  request() { this.adaptee.specificRequest(); }
}

// Composite: Tree structure (Parts and Wholes treated same)
interface Node { operation(): void }
class Leaf implements Node { operation() {} }
class Composite implements Node {
  children: Node[] = [];
  operation() { this.children.forEach(c => c.operation()); }
}

// Decorator: Attach new behaviors by wrapping
class Base { op() {} }
class Decorator extends Base {
  constructor(private component: Base) { super() }
  op() { this.component.op(); /* extra logic */ }
}

// Facade: Simple entry point to complex subsystem
class ComputerFacade {
  constructor(private cpu = new CPU(), private ram = new RAM()) {}
  start() { this.cpu.freeze(); this.ram.load(); }
}

// Flyweight: Share common state to save memory
class FlyweightFactory {
  private cache: Record<string, Flyweight> = {};
  getFlyweight(key: string) { return this.cache[key] ||= new Flyweight(key); }
}

// Strategy: Interchangeable algorithms at runtime
class Context {
  setStrategy(s: Strategy) { this.strategy = s; }
  execute() { this.strategy.doWork(); }
}

// Template Method: Skeleton in base, details in subclasses
abstract class DataMiner {
  mine() { this.open(); this.extract(); this.close(); }
  abstract extract(): void;
  open() { /* default behavior */ }
}

// State: Behavior changes based on internal state object
class Document {
  setState(s: State) { this.state = s; }
  publish() { this.state.publish(); }
}

// Observer (PubSub): Notify multiple objects of changes
class Subject {
  subs: Observer[] = [];
  notify() { this.subs.forEach(s => s.update()); }
}

// Iterator: Sequential traversal of collections
class ArrayIterator {
  private index = 0;
  next() { return this.items[this.index++]; }
  hasNext() { return this.index < this.items.length; }
}

// Command: Encapsulate request as object (Supports Undo)
class SaveCommand implements Command {
  constructor(private editor: Editor) {}
  execute() { this.editor.save(); }
}

// Visitor: Add operations without modifying object class
interface Shape { accept(v: Visitor): void }
class Circle implements Shape { accept(v: Visitor) { v.visitCircle(this); } }
class ExportVisitor {
  visitCircle(c: Circle) { /* export logic */ }
}