history.ts · Source

history.tspackages/whiteboard/src/history.tsraw ← src2,289 B← Back to the app
1/**
2 * Bounded undo/redo for the canvas (T-167/T-170). A generic ring over
3 * immutable snapshots — the canvas ops above already return fresh objects,
4 * so the history stores references (no deep copies needed).
5 *
6 * Bounded: at most `capacity` past states. Oldest states are evicted when
7 * the bound is exceeded (the stack then cannot undo further than that — the
8 * renderer should surface "history truncated"). Deterministic; no I/O.
9 */
10 
11export class OpStack<T> {
12  private past: T[] = [];
13  private future: T[] = [];
14  private current: T;
15  readonly capacity: number;
16 
17  constructor(initial: T, capacity = 100) {
18    if (capacity < 1) throw new Error("capacity must be ≥ 1");
19    this.current = initial;
20    this.capacity = capacity;
21  }
22 
23  /** Push a new state as the result of an operation. Clears redo. */
24  push(next: T): void {
25    if (Object.is(next, this.current)) return; // no-op (e.g. same reference)
26    this.past.push(this.current);
27    if (this.past.length > this.capacity) this.past.shift(); // evict oldest
28    this.current = next;
29    this.future = [];
30    this.pushed++;
31  }
32 
33  /** Replace the present state WITHOUT an undo step (seed after a load, or
34   *  after a restore — the previous past/future is discarded). */
35  reset(next: T): void {
36    this.past = [];
37    this.future = [];
38    this.current = next;
39    this.pushed = 0;
40  }
41 
42  get present(): T {
43    return this.current;
44  }
45 
46  canUndo(): boolean {
47    return this.past.length > 0;
48  }
49  canRedo(): boolean {
50    return this.future.length > 0;
51  }
52  /** Number of states available to undo (≤ capacity). */
53  get depth(): number {
54    return this.past.length;
55  }
56  /** True when we have evicted past the bound (renderer shows "truncated"). */
57  get truncated(): boolean {
58    // we can only know truncation happened if we pushed past capacity; track
59    // via a monotonic counter of total pushes.
60    return this.pushed > this.capacity;
61  }
62 
63  undo(): T {
64    if (!this.canUndo()) return this.current;
65    this.future.push(this.current);
66    this.current = this.past.pop()!;
67    return this.current;
68  }
69 
70  redo(): T {
71    if (!this.canRedo()) return this.current;
72    this.past.push(this.current);
73    this.current = this.future.pop()!;
74    return this.current;
75  }
76 
77  private pushed = 0;
78}
79