@kolisachint/hoocode-tui 0.5.66 → 0.5.68

package/dist/undo-stack.d.ts

@@ -1,17 +1,50 @@
 /**
- * Generic undo stack with clone-on-push semantics.
+ * Undo and redo over snapshots of some state.
  *
- * Stores deep clones of state snapshots. Popped snapshots are returned
- * directly (no re-cloning) since they are already detached.
+ * Stores deep clones on the way in; hands snapshots back directly on the way
+ * out, since a popped one is already detached and nobody else holds it.
+ *
+ * ## Why redo is here rather than in the caller
+ *
+ * The invariant that makes redo correct is easy to state and easy to forget:
+ * **a fresh edit invalidates every redo.** Once you undo twice and then type,
+ * the future you undid never happened and offering to restore it would drop the
+ * character you just typed. Keeping `push`, `undo` and `redo` in one object is
+ * what lets `push` clear the redo side itself, so no caller can forget to — and
+ * the caller here is an editor with twenty-odd `pushUndoSnapshot()` sites.
  */
 export declare class UndoStack<S> {
     private stack;
-    /** Push a deep clone of the given state onto the stack. */
+    private redoStack;
+    /**
+     * Record a state that can be returned to, and abandon any undone future.
+     *
+     * The clone is the point: callers hold a live state object and keep mutating
+     * it, so storing the reference would store something that changes underneath
+     * the stack.
+     */
     push(state: S): void;
-    /** Pop and return the most recent snapshot, or undefined if empty. */
+    /**
+     * Step back, given the state to return to if the step is later redone.
+     *
+     * `current` is asked for rather than remembered because the stack never sees
+     * the live state between pushes — the caller mutates it directly. Without it
+     * the first redo would have nothing to restore.
+     */
+    undo(current: S): S | undefined;
+    /** Step forward again, if an undo has left somewhere to go. */
+    redo(current: S): S | undefined;
+    /**
+     * Pop and return the most recent snapshot, or undefined if empty.
+     *
+     * The pre-redo entry point: it steps back without recording anywhere to
+     * step forward to. Prefer `undo`, which keeps redo working.
+     */
     pop(): S | undefined;
-    /** Remove all snapshots. */
+    /** Remove all snapshots, in both directions. */
     clear(): void;
     get length(): number;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
 }
 //# sourceMappingURL=undo-stack.d.ts.map

package/dist/undo-stack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"undo-stack.d.ts","sourceRoot":"","sources":["../src/undo-stack.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,SAAS,CAAC,CAAC;IACvB,OAAO,CAAC,KAAK,CAAW;IAExB,2DAA2D;IAC3D,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAEnB;IAED,sEAAsE;IACtE,GAAG,IAAI,CAAC,GAAG,SAAS,CAEnB;IAED,4BAA4B;IAC5B,KAAK,IAAI,IAAI,CAEZ;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;CACD","sourcesContent":["/**\n * Generic undo stack with clone-on-push semantics.\n *\n * Stores deep clones of state snapshots. Popped snapshots are returned\n * directly (no re-cloning) since they are already detached.\n */\nexport class UndoStack<S> {\n\tprivate stack: S[] = [];\n\n\t/** Push a deep clone of the given state onto the stack. */\n\tpush(state: S): void {\n\t\tthis.stack.push(structuredClone(state));\n\t}\n\n\t/** Pop and return the most recent snapshot, or undefined if empty. */\n\tpop(): S | undefined {\n\t\treturn this.stack.pop();\n\t}\n\n\t/** Remove all snapshots. */\n\tclear(): void {\n\t\tthis.stack.length = 0;\n\t}\n\n\tget length(): number {\n\t\treturn this.stack.length;\n\t}\n}\n"]}
+{"version":3,"file":"undo-stack.d.ts","sourceRoot":"","sources":["../src/undo-stack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,qBAAa,SAAS,CAAC,CAAC;IACvB,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,SAAS,CAAW;IAE5B;;;;;;OAMG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAInB;IAED;;;;;;OAMG;IACH,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAK9B;IAED,+DAA+D;IAC/D,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAK9B;IAED;;;;;OAKG;IACH,GAAG,IAAI,CAAC,GAAG,SAAS,CAEnB;IAED,gDAAgD;IAChD,KAAK,IAAI,IAAI,CAGZ;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;CACD","sourcesContent":["/**\n * Undo and redo over snapshots of some state.\n *\n * Stores deep clones on the way in; hands snapshots back directly on the way\n * out, since a popped one is already detached and nobody else holds it.\n *\n * ## Why redo is here rather than in the caller\n *\n * The invariant that makes redo correct is easy to state and easy to forget:\n * **a fresh edit invalidates every redo.** Once you undo twice and then type,\n * the future you undid never happened and offering to restore it would drop the\n * character you just typed. Keeping `push`, `undo` and `redo` in one object is\n * what lets `push` clear the redo side itself, so no caller can forget to — and\n * the caller here is an editor with twenty-odd `pushUndoSnapshot()` sites.\n */\nexport class UndoStack<S> {\n\tprivate stack: S[] = [];\n\tprivate redoStack: S[] = [];\n\n\t/**\n\t * Record a state that can be returned to, and abandon any undone future.\n\t *\n\t * The clone is the point: callers hold a live state object and keep mutating\n\t * it, so storing the reference would store something that changes underneath\n\t * the stack.\n\t */\n\tpush(state: S): void {\n\t\tthis.stack.push(structuredClone(state));\n\t\t// A new edit is a new branch. Whatever was undone is unreachable now.\n\t\tif (this.redoStack.length > 0) this.redoStack.length = 0;\n\t}\n\n\t/**\n\t * Step back, given the state to return to if the step is later redone.\n\t *\n\t * `current` is asked for rather than remembered because the stack never sees\n\t * the live state between pushes — the caller mutates it directly. Without it\n\t * the first redo would have nothing to restore.\n\t */\n\tundo(current: S): S | undefined {\n\t\tconst snapshot = this.stack.pop();\n\t\tif (snapshot === undefined) return undefined;\n\t\tthis.redoStack.push(structuredClone(current));\n\t\treturn snapshot;\n\t}\n\n\t/** Step forward again, if an undo has left somewhere to go. */\n\tredo(current: S): S | undefined {\n\t\tconst snapshot = this.redoStack.pop();\n\t\tif (snapshot === undefined) return undefined;\n\t\tthis.stack.push(structuredClone(current));\n\t\treturn snapshot;\n\t}\n\n\t/**\n\t * Pop and return the most recent snapshot, or undefined if empty.\n\t *\n\t * The pre-redo entry point: it steps back without recording anywhere to\n\t * step forward to. Prefer `undo`, which keeps redo working.\n\t */\n\tpop(): S | undefined {\n\t\treturn this.stack.pop();\n\t}\n\n\t/** Remove all snapshots, in both directions. */\n\tclear(): void {\n\t\tthis.stack.length = 0;\n\t\tthis.redoStack.length = 0;\n\t}\n\n\tget length(): number {\n\t\treturn this.stack.length;\n\t}\n\n\tget canUndo(): boolean {\n\t\treturn this.stack.length > 0;\n\t}\n\n\tget canRedo(): boolean {\n\t\treturn this.redoStack.length > 0;\n\t}\n}\n"]}

package/dist/undo-stack.js

@@ -1,25 +1,78 @@
 /**
- * Generic undo stack with clone-on-push semantics.
+ * Undo and redo over snapshots of some state.
  *
- * Stores deep clones of state snapshots. Popped snapshots are returned
- * directly (no re-cloning) since they are already detached.
+ * Stores deep clones on the way in; hands snapshots back directly on the way
+ * out, since a popped one is already detached and nobody else holds it.
+ *
+ * ## Why redo is here rather than in the caller
+ *
+ * The invariant that makes redo correct is easy to state and easy to forget:
+ * **a fresh edit invalidates every redo.** Once you undo twice and then type,
+ * the future you undid never happened and offering to restore it would drop the
+ * character you just typed. Keeping `push`, `undo` and `redo` in one object is
+ * what lets `push` clear the redo side itself, so no caller can forget to — and
+ * the caller here is an editor with twenty-odd `pushUndoSnapshot()` sites.
  */
 export class UndoStack {
     stack = [];
-    /** Push a deep clone of the given state onto the stack. */
+    redoStack = [];
+    /**
+     * Record a state that can be returned to, and abandon any undone future.
+     *
+     * The clone is the point: callers hold a live state object and keep mutating
+     * it, so storing the reference would store something that changes underneath
+     * the stack.
+     */
     push(state) {
         this.stack.push(structuredClone(state));
+        // A new edit is a new branch. Whatever was undone is unreachable now.
+        if (this.redoStack.length > 0)
+            this.redoStack.length = 0;
+    }
+    /**
+     * Step back, given the state to return to if the step is later redone.
+     *
+     * `current` is asked for rather than remembered because the stack never sees
+     * the live state between pushes — the caller mutates it directly. Without it
+     * the first redo would have nothing to restore.
+     */
+    undo(current) {
+        const snapshot = this.stack.pop();
+        if (snapshot === undefined)
+            return undefined;
+        this.redoStack.push(structuredClone(current));
+        return snapshot;
     }
-    /** Pop and return the most recent snapshot, or undefined if empty. */
+    /** Step forward again, if an undo has left somewhere to go. */
+    redo(current) {
+        const snapshot = this.redoStack.pop();
+        if (snapshot === undefined)
+            return undefined;
+        this.stack.push(structuredClone(current));
+        return snapshot;
+    }
+    /**
+     * Pop and return the most recent snapshot, or undefined if empty.
+     *
+     * The pre-redo entry point: it steps back without recording anywhere to
+     * step forward to. Prefer `undo`, which keeps redo working.
+     */
     pop() {
         return this.stack.pop();
     }
-    /** Remove all snapshots. */
+    /** Remove all snapshots, in both directions. */
     clear() {
         this.stack.length = 0;
+        this.redoStack.length = 0;
     }
     get length() {
         return this.stack.length;
     }
+    get canUndo() {
+        return this.stack.length > 0;
+    }
+    get canRedo() {
+        return this.redoStack.length > 0;
+    }
 }
 //# sourceMappingURL=undo-stack.js.map

package/dist/undo-stack.js.map

@@ -1 +1 @@
-{"version":3,"file":"undo-stack.js","sourceRoot":"","sources":["../src/undo-stack.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,OAAO,SAAS;IACb,KAAK,GAAQ,EAAE,CAAC;IAExB,2DAA2D;IAC3D,IAAI,CAAC,KAAQ,EAAQ;QACpB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;IAAA,CACxC;IAED,sEAAsE;IACtE,GAAG,GAAkB;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;IAAA,CACxB;IAED,4BAA4B;IAC5B,KAAK,GAAS;QACb,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;IAAA,CACtB;IAED,IAAI,MAAM,GAAW;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IAAA,CACzB;CACD","sourcesContent":["/**\n * Generic undo stack with clone-on-push semantics.\n *\n * Stores deep clones of state snapshots. Popped snapshots are returned\n * directly (no re-cloning) since they are already detached.\n */\nexport class UndoStack<S> {\n\tprivate stack: S[] = [];\n\n\t/** Push a deep clone of the given state onto the stack. */\n\tpush(state: S): void {\n\t\tthis.stack.push(structuredClone(state));\n\t}\n\n\t/** Pop and return the most recent snapshot, or undefined if empty. */\n\tpop(): S | undefined {\n\t\treturn this.stack.pop();\n\t}\n\n\t/** Remove all snapshots. */\n\tclear(): void {\n\t\tthis.stack.length = 0;\n\t}\n\n\tget length(): number {\n\t\treturn this.stack.length;\n\t}\n}\n"]}
+{"version":3,"file":"undo-stack.js","sourceRoot":"","sources":["../src/undo-stack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,SAAS;IACb,KAAK,GAAQ,EAAE,CAAC;IAChB,SAAS,GAAQ,EAAE,CAAC;IAE5B;;;;;;OAMG;IACH,IAAI,CAAC,KAAQ,EAAQ;QACpB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;QACxC,sEAAsE;QACtE,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC;YAAE,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;IAAA,CACzD;IAED;;;;;;OAMG;IACH,IAAI,CAAC,OAAU,EAAiB;QAC/B,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;QAClC,IAAI,QAAQ,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QAC7C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;QAC9C,OAAO,QAAQ,CAAC;IAAA,CAChB;IAED,+DAA+D;IAC/D,IAAI,CAAC,OAAU,EAAiB;QAC/B,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC;QACtC,IAAI,QAAQ,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QAC7C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;QAC1C,OAAO,QAAQ,CAAC;IAAA,CAChB;IAED;;;;;OAKG;IACH,GAAG,GAAkB;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;IAAA,CACxB;IAED,gDAAgD;IAChD,KAAK,GAAS;QACb,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QACtB,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;IAAA,CAC1B;IAED,IAAI,MAAM,GAAW;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IAAA,CACzB;IAED,IAAI,OAAO,GAAY;QACtB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;IAAA,CAC7B;IAED,IAAI,OAAO,GAAY;QACtB,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;IAAA,CACjC;CACD","sourcesContent":["/**\n * Undo and redo over snapshots of some state.\n *\n * Stores deep clones on the way in; hands snapshots back directly on the way\n * out, since a popped one is already detached and nobody else holds it.\n *\n * ## Why redo is here rather than in the caller\n *\n * The invariant that makes redo correct is easy to state and easy to forget:\n * **a fresh edit invalidates every redo.** Once you undo twice and then type,\n * the future you undid never happened and offering to restore it would drop the\n * character you just typed. Keeping `push`, `undo` and `redo` in one object is\n * what lets `push` clear the redo side itself, so no caller can forget to — and\n * the caller here is an editor with twenty-odd `pushUndoSnapshot()` sites.\n */\nexport class UndoStack<S> {\n\tprivate stack: S[] = [];\n\tprivate redoStack: S[] = [];\n\n\t/**\n\t * Record a state that can be returned to, and abandon any undone future.\n\t *\n\t * The clone is the point: callers hold a live state object and keep mutating\n\t * it, so storing the reference would store something that changes underneath\n\t * the stack.\n\t */\n\tpush(state: S): void {\n\t\tthis.stack.push(structuredClone(state));\n\t\t// A new edit is a new branch. Whatever was undone is unreachable now.\n\t\tif (this.redoStack.length > 0) this.redoStack.length = 0;\n\t}\n\n\t/**\n\t * Step back, given the state to return to if the step is later redone.\n\t *\n\t * `current` is asked for rather than remembered because the stack never sees\n\t * the live state between pushes — the caller mutates it directly. Without it\n\t * the first redo would have nothing to restore.\n\t */\n\tundo(current: S): S | undefined {\n\t\tconst snapshot = this.stack.pop();\n\t\tif (snapshot === undefined) return undefined;\n\t\tthis.redoStack.push(structuredClone(current));\n\t\treturn snapshot;\n\t}\n\n\t/** Step forward again, if an undo has left somewhere to go. */\n\tredo(current: S): S | undefined {\n\t\tconst snapshot = this.redoStack.pop();\n\t\tif (snapshot === undefined) return undefined;\n\t\tthis.stack.push(structuredClone(current));\n\t\treturn snapshot;\n\t}\n\n\t/**\n\t * Pop and return the most recent snapshot, or undefined if empty.\n\t *\n\t * The pre-redo entry point: it steps back without recording anywhere to\n\t * step forward to. Prefer `undo`, which keeps redo working.\n\t */\n\tpop(): S | undefined {\n\t\treturn this.stack.pop();\n\t}\n\n\t/** Remove all snapshots, in both directions. */\n\tclear(): void {\n\t\tthis.stack.length = 0;\n\t\tthis.redoStack.length = 0;\n\t}\n\n\tget length(): number {\n\t\treturn this.stack.length;\n\t}\n\n\tget canUndo(): boolean {\n\t\treturn this.stack.length > 0;\n\t}\n\n\tget canRedo(): boolean {\n\t\treturn this.redoStack.length > 0;\n\t}\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kolisachint/hoocode-tui",
-	"version": "0.5.66",
+	"version": "0.5.68",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "dist/index.js",