@vincemakes/kiso-tui 0.16.1 → 0.16.2

package/dist/editor.js

@@ -270,6 +270,19 @@ export class Editor {
     #history = [];
     #historyIdx = null;
     #preBrowse = [];
+    // UD-1: minimal draft undo. Two stacks of FROZEN snapshots beside
+    // the one mutable buffer (the KC1 flat-buffer discipline holds —
+    // the stacks are history, never a second projection). A checkpoint
+    // is pushed only by a gesture about to discard ≥1 code point (the
+    // kills, the menu-esc clear, each queue-pop replacement, the
+    // @-apply splice); typing and single backspace push nothing — v1
+    // is loss-recovery, not char-granular edit history. ctrl+z
+    // restores text+cursor exactly; ctrl+y mirrors; undo never
+    // discards (what it replaces always lands on the redo stack).
+    // Both stacks clear on submit/clearLine — a sent turn is in the
+    // durable log and the ↑ history, not a loss.
+    #undoStack = [];
+    #redoStack = [];
     // W22: the pending-turn queue's bound state — the CLI's live slots
     // (chat.ts). ↑ pops the LAST queued message into the buffer and
     // enters the pop-mode (the walk: repeated ↑ pop older ones, each
@@ -355,6 +368,8 @@ export class Editor {
         return this.#sheetOpen;
     }
     clearLine() {
+        this.#undoStack.length = 0; // UD-1
+        this.#redoStack.length = 0;
         this.#chars = [];
         this.#cursor = 0;
         this.#scroll = 0;
@@ -577,6 +592,8 @@ export class Editor {
         if (view === null)
             return;
         const insert = [...`@${view.matches[view.selected].path} `].map((ch) => ch.codePointAt(0));
+        if (this.#cursor - view.start >= 1)
+            this.#checkpoint(); // UD-1
         this.#chars.splice(view.start, this.#cursor - view.start, ...insert);
         this.#cursor = view.start + insert.length;
         this.#atClose();
@@ -1102,6 +1119,8 @@ export class Editor {
                     // v3 §04: Esc closes the menu and clears the buffer.
                     // CA-4: the closing esc consumes its burst (the `i += 1`
                     // convention) — a double-esc can never abort the turn.
+                    if (this.#chars.length > 0)
+                        this.#checkpoint(); // UD-1
                     this.#chars = [];
                     this.#cursor = 0;
                     this.#scroll = 0;
@@ -1201,6 +1220,14 @@ export class Editor {
                 this.#killWord();
                 i += 1;
             }
+            else if (c === "\x1a" || c === "\x1f") {
+                this.#undoOp(); // UD-1: ctrl+z (and the readline ctrl+_)
+                i += 1;
+            }
+            else if (c === "\x19") {
+                this.#redoOp(); // UD-1: ctrl+y
+                i += 1;
+            }
             else if (c === "\x01") {
                 this.#cursor = this.#cursorBounds().start; // A3: line-local (a single line starts at 0 — unchanged)
                 this.#reflow();
@@ -1891,8 +1918,66 @@ export class Editor {
         if (!this.#pasting)
             this.#onRender();
     }
+    // ---- UD-1: the undo machinery ----
+    /** The caps: entries and total code points (a D13-class 260KB paste
+     *  fits with room). Evict oldest; both stacks share the shape. */
+    static #UNDO_CAP = 64;
+    static #UNDO_CP_CAP = 2 * 1024 * 1024;
+    #snap() {
+        return { chars: [...this.#chars], cursor: this.#cursor };
+    }
+    #sameSnap(a, b) {
+        return a.cursor === b.cursor && a.chars.length === b.chars.length && a.chars.every((c, i) => c === b.chars[i]);
+    }
+    #capStack(stack) {
+        while (stack.length > _a.#UNDO_CAP)
+            stack.shift();
+        let total = stack.reduce((n, s) => n + s.chars.length, 0);
+        while (stack.length > 1 && total > _a.#UNDO_CP_CAP)
+            total -= stack.shift().chars.length;
+    }
+    /** Push the CURRENT state before a destructive gesture. Always
+     *  clears the redo stack (a new destruction forks history); the
+     *  push itself is deduped against the top. */
+    #checkpoint() {
+        this.#redoStack.length = 0;
+        const cur = this.#snap();
+        const top = this.#undoStack.at(-1);
+        if (top !== undefined && this.#sameSnap(top, cur))
+            return;
+        this.#undoStack.push(cur);
+        this.#capStack(this.#undoStack);
+    }
+    #restoreSnap(s) {
+        this.#chars = [...s.chars];
+        this.#cursor = s.cursor;
+        this.#scroll = 0;
+        this.#verticalGoalCol = null;
+        this.#reflow();
+        this.#refreshMenu();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #undoOp() {
+        const prev = this.#undoStack.pop();
+        if (prev === undefined)
+            return;
+        this.#redoStack.push(this.#snap());
+        this.#capStack(this.#redoStack);
+        this.#restoreSnap(prev);
+    }
+    #redoOp() {
+        const next = this.#redoStack.pop();
+        if (next === undefined)
+            return;
+        this.#undoStack.push(this.#snap());
+        this.#capStack(this.#undoStack);
+        this.#restoreSnap(next);
+    }
     #killToStart() {
         const { start } = this.#cursorBounds(); // A3: line-local (0 on a single line — unchanged)
+        if (this.#cursor > start)
+            this.#checkpoint(); // UD-1
         this.#chars.splice(start, this.#cursor - start);
         this.#cursor = start;
         this.#reflow();
@@ -1901,6 +1986,8 @@ export class Editor {
     }
     #killToEnd() {
         const { end } = this.#cursorBounds(); // A3: line-local (the buffer's end on a single line — unchanged)
+        if (end > this.#cursor)
+            this.#checkpoint(); // UD-1
         this.#chars.splice(this.#cursor, end - this.#cursor);
         this.#reflow();
         if (!this.#pasting)
@@ -1915,6 +2002,8 @@ export class Editor {
             i -= 1; // trailing spaces
         while (i > 0 && this.#chars[i - 1] !== 0x20)
             i -= 1; // the word
+        if (i < this.#cursor)
+            this.#checkpoint(); // UD-1
         this.#chars.splice(i, this.#cursor - i);
         this.#cursor = i;
         this.#reflow();
@@ -2029,6 +2118,8 @@ export class Editor {
     }
     #takeLine() {
         const line = String.fromCodePoint(...this.#chars);
+        this.#undoStack.length = 0; // UD-1: a sent turn is not a loss
+        this.#redoStack.length = 0;
         this.#chars = [];
         this.#cursor = 0;
         this.#scroll = 0;
@@ -2196,6 +2287,8 @@ export class Editor {
         const line = this.#queuePop();
         if (line === null)
             return;
+        if (this.#chars.length > 0)
+            this.#checkpoint(); // UD-1: a mid-walk edit is recoverable
         this.#chars = [...line].map((ch) => ch.codePointAt(0));
         this.#cursor = this.#chars.length;
         this.#scroll = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui",
-	"version": "0.16.1",
+	"version": "0.16.2",
 	"description": "kiso tui \u2014 the pure terminal layer (cell renderer, dock, raw editor, diff, palette). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",
@@ -35,6 +35,6 @@
 	},
 	"homepage": "https://github.com/vincemakes/kiso/tree/main/packages/tui#readme",
 	"dependencies": {
-		"@vincemakes/kiso-tui-cells": "0.16.1"
+		"@vincemakes/kiso-tui-cells": "0.16.2"
 	}
 }