@guiexpert/table 1.1.97 → 1.1.99

package/lib/table/undo/undo-stack.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The undo and redo stacks of steps (DOM-free): a new step clears the redo stack; at most `maxSteps` steps and
+ * `maxCells` cells (over both stacks) are kept – the oldest go first; a single step with more than `maxCells` cells
+ * empties the history and is not kept.
+ *
+ * @example
+ * const stack = new UndoStack<{ cellCount: number; label: string }>(100, 1_000_000);
+ * stack.push({ cellCount: 1, label: "Edit" });
+ * stack.undo()?.label;   // "Edit" – now on the redo stack
+ * stack.canRedo();       // true
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export declare class UndoStack<T extends {
+    readonly cellCount: number;
+}> {
+    private readonly maxSteps;
+    private readonly maxCells;
+    private readonly undoSteps;
+    private readonly redoSteps;
+    private cells;
+    /**
+     * @param {number} maxSteps - steps kept on the undo stack
+     * @param {number} maxCells - cells kept over both stacks
+     */
+    constructor(maxSteps: number, maxCells: number);
+    /**
+     * Adds a step and clears the redo stack.
+     *
+     * @param {T} step - the new step
+     * @returns {boolean} false if the step was too large (the history is empty now)
+     */
+    push(step: T): boolean;
+    /**
+     * Takes the last step for undo (it moves to the redo stack).
+     *
+     * @returns {T | undefined} the step, `undefined` if there is none
+     */
+    undo(): T | undefined;
+    /**
+     * Takes the last undone step for redo (it moves back to the undo stack).
+     *
+     * @returns {T | undefined} the step, `undefined` if there is none
+     */
+    redo(): T | undefined;
+    /** @returns {T | undefined} the step the next undo takes */
+    peekUndo(): T | undefined;
+    /** @returns {T | undefined} the step the next redo takes */
+    peekRedo(): T | undefined;
+    /** @returns {boolean} true if there is a step to undo */
+    canUndo(): boolean;
+    /** @returns {boolean} true if there is a step to redo */
+    canRedo(): boolean;
+    /** @returns {number} steps on the undo stack */
+    size(): number;
+    /** @returns {number} cells kept over both stacks */
+    cellCount(): number;
+    /** Empties both stacks. */
+    clear(): void;
+    private clearRedo;
+}

package/lib/table/undo/undoable.if.d.ts

@@ -0,0 +1,36 @@
+import { CellRange } from '../data/common/cell-range.js';
+import { CellChangeSource } from '../batch-edit/cell-change.if.js';
+import { TableScope } from '../table-scope.js';
+
+/**
+ * What an undo or redo did.
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export interface UndoResultIf {
+    /** Cells written back. */
+    readonly applied: number;
+    /** Cells left out (row gone, no longer editable, changed by something else with `onConflict: "skip"`). */
+    readonly skipped: number;
+    /** The shown cells written back (display rows, model columns) – selected afterwards. */
+    readonly range?: CellRange;
+}
+/**
+ * One step of the undo history (command pattern): what the user did as one action – an edit, a fill, a paste.
+ *
+ * @category Spreadsheet
+ * @since 1.1.99
+ */
+export interface UndoableIf {
+    /** For buttons and announcements: `"Edit"`, `"Paste"`, `"Fill"` … */
+    readonly label: string;
+    /** What started the step. */
+    readonly source: CellChangeSource;
+    /** Cells the step holds (for `UndoOptionsIf.maxCells`). */
+    readonly cellCount: number;
+    /** Writes the old values back. */
+    undo(scope: TableScope): UndoResultIf;
+    /** Writes the new values again. */
+    redo(scope: TableScope): UndoResultIf;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guiexpert/table",
-  "version": "1.1.97",
+  "version": "1.1.99",
   "license": "MIT",
   "author": "Dr. Marc Kronberg <info@gui.expert> (https://gui.expert)",
   "repository": {