Command: requests as objects for undo, redo and queued jobs

// seats.tsexport type Seats = Map<string, string>;export interface Command { execute(): void; undo(): void }export class Hold implements Command {  constructor(private seats: Seats, private seat: string, private buyer: string) {}  execute() {    const holder = this.seats.get(this.seat);    if (holder) throw new Error(`${this.seat} is held by ${holder}`);    this.seats.set(this.seat, this.buyer);  }  undo() { this.seats.delete(this.seat); }}export class Console {  private done: Command[] = [];  run(c: Command) { this.done.push(c); c.execute(); }  undo() { this.done.pop()?.undo(); }} // main.tsimport { Seats, Hold, Console } from './seats';const seats: Seats = new Map([['C7', 'bea']]);const agent = new Console();agent.run(new Hold(seats, 'C5', 'ana'));try { agent.run(new Hold(seats, 'C7', 'ana')); } catch { /* the screen says "C7 taken" */ }agent.undo();console.log(`C5 ${seats.get('C5') ?? 'free'} · C7 ${seats.get('C7') ?? 'free'}`);

// limits.tsexport type Limits = Map<string, number>;export class SetLimit {  private before: number;  constructor(private limits: Limits, private account: string, private next: number) {    this.before = limits.get(account) ?? 0;  }  execute() { this.limits.set(this.account, this.next); }  undo() { this.limits.set(this.account, this.before); }}export class Batch {  private done: SetLimit[] = [];  runAll(cs: SetLimit[]) { for (const c of cs) { c.execute(); this.done.push(c); } }  undo() { this.done.pop()?.undo(); }} // main.tsimport { Limits, SetLimit, Batch } from './limits';const limits: Limits = new Map([['acc-4', 500]]);const batch = new Batch();batch.runAll([new SetLimit(limits, 'acc-4', 800), new SetLimit(limits, 'acc-4', 1000)]);batch.undo();console.log(`acc-4 limit ${limits.get('acc-4')}`);

// player.tsimport { legacy_createStore as createStore } from 'redux';export interface PlayerState { at: number; playing: boolean }type PlayerAction = { type: 'seek'; to: number } | { type: 'pause' };function player(state: PlayerState = { at: 0, playing: true }, action: PlayerAction): PlayerState {  switch (action.type) {    case 'seek': return { ...state, at: action.to };    case 'pause': return { ...state, playing: false };    default: return state;  }}export const store = createStore(player); // actions.tsexport function pauseAfterAd(): any {  return (dispatch: (a: { type: 'pause' }) => void) => dispatch({ type: 'pause' });} // main.tsimport { store } from './player';import { pauseAfterAd } from './actions';const log: string[] = [];store.subscribe(() => { const s = store.getState(); log.push(`${s.at}s ${s.playing ? 'playing' : 'paused'}`); });store.dispatch({ type: 'seek', to: 90 });try { store.dispatch(pauseAfterAd()); } catch { /* the player shows an error banner */ }store.dispatch({ type: 'seek', to: 120 });console.log(log.join(' · '));

// room.tsexport interface Msg { id: string; text: string }export class Room {  messages: Msg[] = [];  pinned: string | null = null;  private seq = 0;  nextId() { this.seq += 1; return `m${this.seq}`; }}export interface Command { execute(): void; undo(): void }export class Send implements Command {  id = '';  constructor(private room: Room, private text: string) {}  execute() { this.id = this.room.nextId(); this.room.messages.push({ id: this.id, text: this.text }); }  undo() { this.room.messages = this.room.messages.filter((m) => m.id !== this.id); }}export class Pin implements Command {  private before: string | null = null;  constructor(private room: Room, private target: string) {}  execute() {    this.before = this.room.pinned;    this.room.pinned = this.room.messages.some((m) => m.id === this.target) ? this.target : null;  }  undo() { this.room.pinned = this.before; }}export class History {  private done: Command[] = [];  private undone: Command[] = [];  run(c: Command) { c.execute(); this.done.push(c); this.undone = []; }  undo() { const c = this.done.pop(); if (c) { c.undo(); this.undone.push(c); } }  redo() { const c = this.undone.pop(); if (c) { c.execute(); this.done.push(c); } }} // main.tsimport { Room, Send, Pin, History } from './room';const room = new Room();const history = new History();const notice = new Send(room, 'standup moves to 10:30');history.run(notice);history.run(new Pin(room, notice.id));history.undo();history.undo();history.redo();history.redo();console.log(`messages ${room.messages.map((m) => m.id).join(', ')} · pinned ${room.pinned ?? 'none'}`);

// playlist.tslet made = 0;const newId = () => `c${++made}`;export type Clip = { id: string; title: string };export type Rec = { type: 'add'; title: string; id?: string } | { type: 'rename'; id: string; title: string };export class Playlist {  clips: Clip[] = [];  private log: Rec[] = [];  run(r: Rec) { this.apply(r); this.log.push(r); }  apply(r: Rec) {    if (r.type === 'add') this.clips.push({ id: r.id ?? newId(), title: r.title });    else for (const c of this.clips) if (c.id === r.id) c.title = r.title;  }  records(): Rec[] { return JSON.parse(JSON.stringify(this.log)); }} // main.tsimport { Playlist } from './playlist';const mirror = new Playlist();mirror.run({ type: 'add', title: 'intro' });const editor = new Playlist();editor.run({ type: 'add', title: 'trailer' });editor.run({ type: 'add', title: 'interview' });editor.run({ type: 'rename', id: editor.clips[0].id, title: 'teaser' });for (const r of editor.records()) mirror.apply(r);console.log(`mirror ${mirror.clips.map((c) => c.title).join(', ')}`);

// seats.tsexport type Seats = Map<string, string>;export class Hold { constructor(readonly seat: string, readonly agent: string) {} } // main.tsimport { Seats, Hold } from './seats';import { AnaHistory } from './ana-history';const seats: Seats = new Map();const ana = new AnaHistory(seats);ana.run(new Hold('A1', 'ana'));ana.run(new Hold('A2', 'ana'));seats.set('B5', 'ben');ana.undo();console.log(['A1', 'A2', 'B5'].map((s) => `${s} ${seats.get(s) ?? 'free'}`).join(' · '));