class Store {
  static #instance = null;

  #state = {};

  static getInstance() {
    if (!Store.#instance) {
      Store.#instance = new Store();
    }
    return Store.#instance;
  }

  getState() { return this.#state; }
  setState(patch) { Object.assign(this.#state, patch); }
}

const a = Store.getInstance();
const b = Store.getInstance();
console.log(a === b); // true

class Button {
  render() { throw new Error('abstract'); }
}
class PrimaryButton extends Button {
  render() { return `<button class="btn-primary">OK</button>`; }
}
class DangerButton extends Button {
  render() { return `<button class="btn-danger">Delete</button>`; }
}

function createButton(type) {
  const map = { primary: PrimaryButton, danger: DangerButton };
  const Ctor = map[type];
  if (!Ctor) throw new Error(`Unknown type: ${type}`);
  return new Ctor();
}

createButton('primary').render(); // <button class="btn-primary">OK</button>

const lightFactory = {
  createButton: () => ({ type: 'button', theme: 'light' }),
  createInput:  () => ({ type: 'input',  theme: 'light' }),
};
const darkFactory = {
  createButton: () => ({ type: 'button', theme: 'dark' }),
  createInput:  () => ({ type: 'input',  theme: 'dark' }),
};

function buildUI(factory) {
  return {
    button: factory.createButton(),
    input:  factory.createInput(),
  };
}
buildUI(darkFactory); // { button: {theme:'dark'}, input: {theme:'dark'} }

class QueryBuilder {
  #table = '';
  #conditions = [];
  #fields = ['*'];
  #limit = null;

  from(table)     { this.#table = table; return this; }
  select(...f)    { this.#fields = f; return this; }
  where(cond)     { this.#conditions.push(cond); return this; }
  limit(n)        { this.#limit = n; return this; }

  build() {
    let sql = `SELECT ${this.#fields.join(', ')} FROM ${this.#table}`;
    if (this.#conditions.length) sql += ` WHERE ${this.#conditions.join(' AND ')}`;
    if (this.#limit !== null)    sql += ` LIMIT ${this.#limit}`;
    return sql;
  }
}

new QueryBuilder()
  .from('users')
  .select('id', 'name')
  .where('age > 18')
  .where('active = 1')
  .limit(10)
  .build();
// SELECT id, name FROM users WHERE age > 18 AND active = 1 LIMIT 10

const userProto = {
  greet() { return `Hi, I'm ${this.name}`; },
  clone()  { return Object.create(this); },
};

const alice = Object.create(userProto);
alice.name = 'Alice';

const bob = alice.clone();
bob.name  = 'Bob';

alice.greet(); // Hi, I'm Alice
bob.greet();   // Hi, I'm Bob

// 旧日志库，接口为 log(msg)
class OldLogger {
  log(msg) { console.log('[OLD]', msg); }
}

// 新系统要求 info / warn / error 三个方法
class LoggerAdapter {
  constructor(logger) { this.logger = logger; }
  info(msg)  { this.logger.log(`INFO  ${msg}`); }
  warn(msg)  { this.logger.log(`WARN  ${msg}`); }
  error(msg) { this.logger.log(`ERROR ${msg}`); }
}

const logger = new LoggerAdapter(new OldLogger());
logger.info('server started'); // [OLD] INFO  server started

// 实现部分：渲染引擎
const canvasRenderer = { draw: (shape) => `Canvas: draw ${shape}` };
const svgRenderer    = { draw: (shape) => `SVG:    draw ${shape}` };

// 抽象部分：形状
class Shape {
  constructor(renderer) { this.renderer = renderer; }
}
class Circle extends Shape {
  draw() { return this.renderer.draw('circle'); }
}
class Square extends Shape {
  draw() { return this.renderer.draw('square'); }
}

new Circle(svgRenderer).draw();    // SVG:    draw circle
new Square(canvasRenderer).draw(); // Canvas: draw square

class File {
  constructor(name, size) { this.name = name; this.size = size; }
  getSize() { return this.size; }
}
class Folder {
  constructor(name) { this.name = name; this.children = []; }
  add(child) { this.children.push(child); return this; }
  getSize() { return this.children.reduce((s, c) => s + c.getSize(), 0); }
}

const root = new Folder('root')
  .add(new File('a.js', 10))
  .add(
    new Folder('src')
      .add(new File('index.js', 20))
      .add(new File('utils.js', 15))
  );

root.getSize(); // 45

function withLogging(fn) {
  return function (...args) {
    console.log(`[CALL] ${fn.name}(${args})`);
    const result = fn.apply(this, args);
    console.log(`[RET]  ${result}`);
    return result;
  };
}

function add(a, b) { return a + b; }
const loggedAdd = withLogging(add);
loggedAdd(2, 3);
// [CALL] add(2,3)
// [RET]  5

class AuthService   { login(u, p)    { return { token: 'tok_' + u }; } }
class ProfileService { fetch(token)  { return { name: 'Alice' }; } }
class LogService    { record(action) { console.log('[LOG]', action); } }

class AppFacade {
  #auth    = new AuthService();
  #profile = new ProfileService();
  #log     = new LogService();

  async signIn(username, password) {
    const { token } = this.#auth.login(username, password);
    const profile   = this.#profile.fetch(token);
    this.#log.record(`login:${username}`);
    return { token, profile };
  }
}

new AppFacade().signIn('alice', 'pw');

class CharStyle {
  constructor(font, size, color) {
    this.font = font; this.size = size; this.color = color;
  }
}

class CharStylePool {
  #pool = new Map();
  get(font, size, color) {
    const key = `${font}-${size}-${color}`;
    if (!this.#pool.has(key)) this.#pool.set(key, new CharStyle(font, size, color));
    return this.#pool.get(key);
  }
  size() { return this.#pool.size; }
}

const pool = new CharStylePool();
// 渲染 1000 个字符，只需要极少的 CharStyle 对象
const chars = Array.from('Hello World x1000').map(ch => ({
  char: ch,
  style: pool.get('Arial', 14, '#333'),
}));
console.log(pool.size()); // 1（所有字符共享同一样式对象）

function createValidator(target, rules) {
  return new Proxy(target, {
    set(obj, prop, value) {
      if (rules[prop] && !rules[prop](value)) {
        throw new TypeError(`Invalid value for "${prop}": ${value}`);
      }
      obj[prop] = value;
      return true;
    },
  });
}

const user = createValidator({}, {
  age:   v => typeof v === 'number' && v >= 0 && v <= 150,
  email: v => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v),
});

user.age   = 25;             // OK
user.email = 'a@b.com';     // OK
// user.age = -1;            // TypeError: Invalid value for "age": -1

class Handler {
  setNext(handler) { this.next = handler; return handler; }
  handle(req)      { return this.next?.handle(req); }
}

class AuthHandler extends Handler {
  handle(req) {
    if (!req.token) return '401 Unauthorized';
    return super.handle(req);
  }
}
class RoleHandler extends Handler {
  handle(req) {
    if (req.role !== 'admin') return '403 Forbidden';
    return super.handle(req);
  }
}
class BusinessHandler extends Handler {
  handle(req) { return `200 OK: Hello ${req.user}`; }
}

const chain = new AuthHandler();
chain.setNext(new RoleHandler()).setNext(new BusinessHandler());

chain.handle({ token: 'tok', role: 'admin', user: 'Alice' }); // 200 OK
chain.handle({ token: 'tok', role: 'guest' });                 // 403 Forbidden
chain.handle({});                                              // 401 Unauthorized

class TextEditor {
  #text = '';
  #history = [];

  execute(command) {
    this.#text = command.execute(this.#text);
    this.#history.push(command);
    return this;
  }
  undo() {
    const cmd = this.#history.pop();
    if (cmd) this.#text = cmd.undo(this.#text);
    return this;
  }
  value() { return this.#text; }
}

const appendCmd = (str) => ({
  execute: (t) => t + str,
  undo:    (t) => t.slice(0, -str.length),
});

const ed = new TextEditor();
ed.execute(appendCmd('Hello')).execute(appendCmd(', World'));
ed.value(); // Hello, World
ed.undo();
ed.value(); // Hello

// 极简四则运算解释器
function interpret(expr) {
  expr = expr.trim();
  const addIdx = expr.lastIndexOf('+');
  const subIdx = expr.lastIndexOf('-');
  const pivot   = Math.max(addIdx, subIdx);
  if (pivot > 0) {
    const left  = interpret(expr.slice(0, pivot));
    const right = interpret(expr.slice(pivot + 1));
    return expr[pivot] === '+' ? left + right : left - right;
  }
  return parseFloat(expr);
}

interpret('1 + 2 + 3'); // 6
interpret('10 - 3 + 2'); // 9

class Range {
  constructor(start, end, step = 1) {
    this.start = start; this.end = end; this.step = step;
  }
  [Symbol.iterator]() {
    let cur = this.start;
    return {
      next: () => cur <= this.end
        ? { value: cur += this.step, done: false }
        : { done: true },
    };
  }
}

[...new Range(1, 10, 2)]; // [3, 5, 7, 9, 11] — 每步 +2
for (const n of new Range(0, 5)) console.log(n); // 1 2 3 4 5

class EventBus {
  #listeners = new Map();
  on(event, fn)  { (this.#listeners.get(event) ?? this.#listeners.set(event, new Set()).get(event)).add(fn); }
  off(event, fn) { this.#listeners.get(event)?.delete(fn); }
  emit(event, data) { this.#listeners.get(event)?.forEach(fn => fn(data)); }
}

const bus = new EventBus();
bus.on('login', ({ user }) => console.log(`Welcome, ${user}`));
bus.on('login', ({ user }) => console.log(`Log: ${user} logged in`));
bus.emit('login', { user: 'Alice' });
// Welcome, Alice
// Log: Alice logged in

class FormState {
  #snapshots = [];
  #current   = {};

  set(patch)   { this.#current = { ...this.#current, ...patch }; }
  snapshot()   { this.#snapshots.push({ ...this.#current }); }
  restore()    { if (this.#snapshots.length) this.#current = this.#snapshots.pop(); }
  get()        { return { ...this.#current }; }
}

const form = new FormState();
form.set({ name: 'Alice' });
form.snapshot();
form.set({ name: 'Bob', age: 30 });
form.get();    // { name: 'Bob', age: 30 }
form.restore();
form.get();    // { name: 'Alice' }

class Subject {
  #observers = new Set();
  #state;

  subscribe(fn)   { this.#observers.add(fn); }
  unsubscribe(fn) { this.#observers.delete(fn); }

  setState(val) {
    this.#state = val;
    this.#observers.forEach(fn => fn(val));
  }
  getState() { return this.#state; }
}

const counter = new Subject();
counter.subscribe(v => console.log('A sees:', v));
counter.subscribe(v => console.log('B sees:', v));
counter.setState(42);
// A sees: 42
// B sees: 42

const states = {
  idle:    { fetch: (ctx) => ctx.transition('loading') },
  loading: {
    resolve: (ctx, data) => { ctx.data = data; ctx.transition('success'); },
    reject:  (ctx, err)  => { ctx.error = err; ctx.transition('error'); },
  },
  success: { reset: (ctx) => ctx.transition('idle') },
  error:   { reset: (ctx) => ctx.transition('idle') },
};

class AsyncMachine {
  #state = 'idle';
  data  = null;
  error = null;

  transition(s) { this.#state = s; console.log('→', s); }
  dispatch(action, payload) {
    const handler = states[this.#state]?.[action];
    if (!handler) return console.warn(`No "${action}" in state "${this.#state}"`);
    handler(this, payload);
  }
  getState() { return this.#state; }
}

const m = new AsyncMachine();
m.dispatch('fetch');                   // → loading
m.dispatch('resolve', { id: 1 });     // → success
m.dispatch('reset');                   // → idle

const sortStrategies = {
  bubble: (arr) => {
    const a = [...arr];
    for (let i = 0; i < a.length; i++)
      for (let j = 0; j < a.length - i - 1; j++)
        if (a[j] > a[j+1]) [a[j], a[j+1]] = [a[j+1], a[j]];
    return a;
  },
  quick: (arr) => {
    if (arr.length <= 1) return arr;
    const pivot = arr[0];
    const left  = arr.slice(1).filter(x => x <= pivot);
    const right = arr.slice(1).filter(x => x > pivot);
    return [...sortStrategies.quick(left), pivot, ...sortStrategies.quick(right)];
  },
};

class Sorter {
  constructor(strategy = 'quick') { this.strategy = strategy; }
  sort(arr) { return sortStrategies[this.strategy](arr); }
}

new Sorter('bubble').sort([3, 1, 4, 1, 5]); // [1, 1, 3, 4, 5]
new Sorter('quick').sort([3, 1, 4, 1, 5]);  // [1, 1, 3, 4, 5]

class DataExporter {
  // 模板方法：算法骨架
  export(data) {
    const processed = this.process(data);
    const formatted = this.format(processed);
    this.save(formatted);
  }

  process(data)   { return data.filter(Boolean); }   // 默认实现
  format(data)    { throw new Error('abstract'); }   // 子类实现
  save(content)   { console.log('saving:', content.slice(0, 40)); }
}

class CSVExporter extends DataExporter {
  format(data) { return data.map(r => Object.values(r).join(',')).join('\n'); }
}
class JSONExporter extends DataExporter {
  format(data) { return JSON.stringify(data, null, 2); }
}

const rows = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
new CSVExporter().export(rows);  // saving: 1,Alice\n2,Bob
new JSONExporter().export(rows); // saving: [\n  {\n    "id": 1,

class NumberNode  { constructor(v)    { this.value = v; } accept(v) { return v.visitNumber(this); } }
class AddNode     { constructor(l, r) { this.left = l; this.right = r; } accept(v) { return v.visitAdd(this); } }
class MulNode     { constructor(l, r) { this.left = l; this.right = r; } accept(v) { return v.visitMul(this); } }

// 求值访问者
const evalVisitor = {
  visitNumber: (n) => n.value,
  visitAdd:    (n) => n.left.accept(evalVisitor) + n.right.accept(evalVisitor),
  visitMul:    (n) => n.left.accept(evalVisitor) * n.right.accept(evalVisitor),
};

// 打印访问者
const printVisitor = {
  visitNumber: (n) => `${n.value}`,
  visitAdd:    (n) => `(${n.left.accept(printVisitor)} + ${n.right.accept(printVisitor)})`,
  visitMul:    (n) => `(${n.left.accept(printVisitor)} * ${n.right.accept(printVisitor)})`,
};

// (2 + 3) * 4
const ast = new MulNode(new AddNode(new NumberNode(2), new NumberNode(3)), new NumberNode(4));
ast.accept(evalVisitor);  // 20
ast.accept(printVisitor); // ((2 + 3) * 4)