Strategy and Command

// Strategy — swappable sorting/pricing algorithms
interface SortStrategy<T> { sort(items: T[]): T[];
}

class AlphabeticalSort implements SortStrategy<string> { sort(items: string[]) { return [...items].sort(); }
}

class ReversedSort implements SortStrategy<string> { sort(items: string[]) { return [...items].sort().reverse(); }
}

class Sorter<T> { constructor(private strategy: SortStrategy<T>) {} setStrategy(strategy: SortStrategy<T>) { this.strategy = strategy; } sort(items: T[]) { return this.strategy.sort(items); }
}

const sorter = new Sorter(new AlphabeticalSort());
sorter.sort(['banana', 'apple', 'cherry']); // ['apple', 'banana', 'cherry']
sorter.setStrategy(new ReversedSort());
sorter.sort(['banana', 'apple', 'cherry']); // ['cherry', 'banana', 'apple']

// Command — encapsulate operations with undo
interface Command { execute(): void; undo(): void;
}

class MoveCommand implements Command { private prevX: number; private prevY: number; constructor( private shape: Shape, private dx: number, private dy: number, ) { this.prevX = shape.x; this.prevY = shape.y; } execute() { this.shape.x += this.dx; this.shape.y += this.dy; } undo() { this.shape.x = this.prevX; this.shape.y = this.prevY; }
}

class CommandHistory { private history: Command[] = []; execute(cmd: Command) { cmd.execute(); this.history.push(cmd); } undo() { this.history.pop()?.undo(); }
}

const history = new CommandHistory();
history.execute(new MoveCommand(circle, 10, 0));
history.execute(new MoveCommand(circle, 0, 5));
history.undo(); // circle moves back