Factory, Builder, Singleton and Command

// The same switch, pasted wherever the channel matters.
export function send(channel, to, text) {
  switch (channel) {
    case 'email': return `email to ${to}: ${text}`;
    case 'sms': return `sms to ${to}: ${text.slice(0, 160)}`;
    default: throw new Error(`unknown channel: ${channel}`);
  }
}

export function costInCents(channel) {
  switch (channel) {
    case 'email': return 0;
    case 'sms': return 4;
    default: throw new Error(`unknown channel: ${channel}`);
  }
}
// Adding 'push' means finding every switch like these, in every file, and editing each one.

class Email {
  send(to, text) { return `email to ${to}: ${text}`; }
  get costInCents() { return 0; }
}

class Sms {
  send(to, text) { return `sms to ${to}: ${text.slice(0, 160)}`; }
  get costInCents() { return 4; }
}

// The one place that knows which kinds exist. A new kind is one register() call.
export class ChannelRegistry {
  #makers = new Map();

  register(kind, make) {
    this.#makers.set(kind, make);
    return this;
  }

  create(kind) {
    const make = this.#makers.get(kind);
    if (!make) throw new Error(`unknown channel: ${kind}`);
    return make();
  }
}

export const defaultChannels = () =>
  new ChannelRegistry().register('email', () => new Email()).register('sms', () => new Sms());

export class EmailBuilder {
  #to = [];
  #cc = [];
  #subject = '';
  #body = '';

  to(address) { this.#to.push(address); return this; }
  cc(address) { this.#cc.push(address); return this; }
  subject(text) { this.#subject = text; return this; }
  body(text) { this.#body = text; return this; }

  // Every rule about a valid combination lives here. The result is frozen, and
  // it holds copies, so changing the builder later cannot change an email already built.
  build() {
    if (this.#to.length === 0) throw new Error('an email needs a recipient');
    if (this.#subject === '') throw new Error('an email needs a subject');
    return Object.freeze({
      to: Object.freeze([...this.#to]),
      cc: Object.freeze([...this.#cc]),
      subject: this.#subject,
      body: this.#body,
    });
  }
}

// One shared instance, reachable from anywhere.
export class TicketNumbers {
  static #instance;
  #last = 0;

  static get() {
    return (TicketNumbers.#instance ??= new TicketNumbers());
  }

  next() { return ++this.#last; }
}

// A hidden dependency: nothing in the signature says this function touches shared state.
export const issueTicket = (vehicle) => ({ vehicle, number: TicketNumbers.get().next() });

export class Doc {
  text = '';
}

// A command knows how to do and undo itself. It keeps what it needs to reverse the change.
export class Type {
  constructor(doc, text) { this.doc = doc; this.text = text; }
  do() { this.doc.text += this.text; }
  undo() { this.doc.text = this.doc.text.slice(0, this.doc.text.length - this.text.length); }
}

export class Erase {
  constructor(doc, count) { this.doc = doc; this.count = count; }
  do() {
    const keep = Math.max(0, this.doc.text.length - this.count);
    this.removed = this.doc.text.slice(keep); // may be fewer than count characters
    this.doc.text = this.doc.text.slice(0, keep);
  }
  undo() { this.doc.text += this.removed; }
}

// Two stacks. History never looks inside a command, so a new kind of edit needs no change here.
export class History {
  #done = [];
  #undone = [];

  run(cmd) {
    cmd.do();
    this.#done.push(cmd);
    this.#undone.length = 0; // a new edit ends the old future
  }

  undo() {
    const cmd = this.#done.pop();
    if (!cmd) return false;
    cmd.undo();
    this.#undone.push(cmd);
    return true;
  }

  redo() {
    const cmd = this.#undone.pop();
    if (!cmd) return false;
    cmd.do();
    this.#done.push(cmd);
    return true;
  }
}

// Several commands that undo as one. It is a command too, so History needs no change.
export class Macro {
  constructor(commands) { this.commands = commands; }

  do() {
    for (const cmd of this.commands) cmd.do();
  }

  // Reverse order matters: the last change sits on top of the earlier ones.
  undo() {
    for (const cmd of [...this.commands].reverse()) cmd.undo();
  }
}