@ngxsmk/cdk 1.3.2 → 2.0.0

package/esm2022/spreadsheet/plugin/plugin-host.mjs

@@ -0,0 +1,188 @@
+/**
+ * PluginHost manages the lifecycle of all registered plugins.
+ * Plugins are executed in priority order (lower = first).
+ */
+export class PluginHost {
+    constructor() {
+        this._plugins = [];
+        this._engine = null;
+    }
+    /** Register one or more plugins. */
+    register(...plugins) {
+        this._plugins.push(...plugins);
+        this._plugins.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+    }
+    /** Unregister plugins by name. */
+    unregister(...names) {
+        const nameSet = new Set(names);
+        const toRemove = this._plugins.filter((p) => nameSet.has(p.name));
+        toRemove.forEach((p) => p.onDestroy?.());
+        this._plugins = this._plugins.filter((p) => !nameSet.has(p.name));
+    }
+    /** Initialize all plugins with the engine. Called once during engine construction. */
+    init(engine) {
+        this._engine = engine;
+        for (const plugin of this._plugins) {
+            plugin.onInit?.(engine);
+        }
+    }
+    /** Destroy all plugins. */
+    destroy() {
+        for (const plugin of this._plugins) {
+            plugin.onDestroy?.();
+        }
+        this._plugins = [];
+        this._engine = null;
+    }
+    /** Run onBeforeRender on all plugins. Returns false if any plugin cancels. */
+    beforeRender() {
+        for (const plugin of this._plugins) {
+            if (plugin.onBeforeRender?.() === false)
+                return false;
+        }
+        return true;
+    }
+    /** Run onAfterRender on all plugins. */
+    afterRender() {
+        for (const plugin of this._plugins) {
+            plugin.onAfterRender?.();
+        }
+    }
+    /** Run onBeforeEdit on all plugins. Returns false if any cancels. */
+    beforeEdit(rowIndex, colId) {
+        for (const plugin of this._plugins) {
+            if (plugin.onBeforeEdit?.(rowIndex, colId) === false)
+                return false;
+        }
+        return true;
+    }
+    /** Run onAfterEdit on all plugins. */
+    afterEdit(rowIndex, colId, oldValue, newValue) {
+        for (const plugin of this._plugins) {
+            plugin.onAfterEdit?.(rowIndex, colId, oldValue, newValue);
+        }
+    }
+    /** Run onBeforeSort on all plugins. Returns false if any cancels. */
+    beforeSort(colId, direction) {
+        for (const plugin of this._plugins) {
+            if (plugin.onBeforeSort?.(colId, direction) === false)
+                return false;
+        }
+        return true;
+    }
+    /** Run onAfterSort on all plugins. */
+    afterSort() {
+        for (const plugin of this._plugins) {
+            plugin.onAfterSort?.();
+        }
+    }
+    /** Run onBeforeFilter on all plugins. Returns false if any cancels. */
+    beforeFilter() {
+        for (const plugin of this._plugins) {
+            if (plugin.onBeforeFilter?.() === false)
+                return false;
+        }
+        return true;
+    }
+    /** Run onAfterFilter on all plugins. */
+    afterFilter() {
+        for (const plugin of this._plugins) {
+            plugin.onAfterFilter?.();
+        }
+    }
+    /** Run onBeforeInsertRows on all plugins. Returns false if any cancels. */
+    beforeInsertRows(count, atIndex) {
+        for (const plugin of this._plugins) {
+            if (plugin.onBeforeInsertRows?.(count, atIndex) === false)
+                return false;
+        }
+        return true;
+    }
+    /** Run onAfterInsertRows on all plugins. */
+    afterInsertRows(indices) {
+        for (const plugin of this._plugins) {
+            plugin.onAfterInsertRows?.(indices);
+        }
+    }
+    /** Run onBeforeDeleteRows on all plugins. Returns false if any cancels. */
+    beforeDeleteRows(indices) {
+        for (const plugin of this._plugins) {
+            if (plugin.onBeforeDeleteRows?.(indices) === false)
+                return false;
+        }
+        return true;
+    }
+    /** Run onAfterDeleteRows on all plugins. */
+    afterDeleteRows(indices) {
+        for (const plugin of this._plugins) {
+            plugin.onAfterDeleteRows?.(indices);
+        }
+    }
+    /** Run onBeforeInsertColumns on all plugins. Returns false if any cancels. */
+    beforeInsertColumns(count, atIndex) {
+        for (const plugin of this._plugins) {
+            if (plugin.onBeforeInsertColumns?.(count, atIndex) === false)
+                return false;
+        }
+        return true;
+    }
+    /** Run onAfterInsertColumns on all plugins. */
+    afterInsertColumns(indices) {
+        for (const plugin of this._plugins) {
+            plugin.onAfterInsertColumns?.(indices);
+        }
+    }
+    /** Run onBeforeDeleteColumns on all plugins. Returns false if any cancels. */
+    beforeDeleteColumns(indices) {
+        for (const plugin of this._plugins) {
+            if (plugin.onBeforeDeleteColumns?.(indices) === false)
+                return false;
+        }
+        return true;
+    }
+    /** Run onAfterDeleteColumns on all plugins. */
+    afterDeleteColumns(indices) {
+        for (const plugin of this._plugins) {
+            plugin.onAfterDeleteColumns?.(indices);
+        }
+    }
+    /** Run onBeforePaste on all plugins. Returns false if any cancels. */
+    beforePaste(data, startCell) {
+        for (const plugin of this._plugins) {
+            if (plugin.onBeforePaste?.(data, startCell) === false)
+                return false;
+        }
+        return true;
+    }
+    /** Run onAfterPaste on all plugins. */
+    afterPaste() {
+        for (const plugin of this._plugins) {
+            plugin.onAfterPaste?.();
+        }
+    }
+    /** Run onBeforeCopy on all plugins. Returns false if any cancels. */
+    beforeCopy() {
+        for (const plugin of this._plugins) {
+            if (plugin.onBeforeCopy?.() === false)
+                return false;
+        }
+        return true;
+    }
+    /** Run onAfterCopy on all plugins. */
+    afterCopy() {
+        for (const plugin of this._plugins) {
+            plugin.onAfterCopy?.();
+        }
+    }
+    /** Fire a custom event to all plugins. */
+    fireEvent(eventType, payload) {
+        for (const plugin of this._plugins) {
+            plugin.onEvent?.(eventType, payload);
+        }
+    }
+    /** Get all registered plugins. */
+    get plugins() {
+        return this._plugins;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-host.js","sourceRoot":"","sources":["../../../../../../packages/cdk/spreadsheet/plugin/plugin-host.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SpreadsheetPlugin } from './plugin.types';\nimport type { SpreadsheetEngine } from '../spreadsheet-engine';\n\n/**\n * PluginHost manages the lifecycle of all registered plugins.\n * Plugins are executed in priority order (lower = first).\n */\nexport class PluginHost {\n  private _plugins: SpreadsheetPlugin[] = [];\n  private _engine: SpreadsheetEngine | null = null;\n\n  /** Register one or more plugins. */\n  register(...plugins: SpreadsheetPlugin[]): void {\n    this._plugins.push(...plugins);\n    this._plugins.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));\n  }\n\n  /** Unregister plugins by name. */\n  unregister(...names: string[]): void {\n    const nameSet = new Set(names);\n    const toRemove = this._plugins.filter((p) => nameSet.has(p.name));\n    toRemove.forEach((p) => p.onDestroy?.());\n    this._plugins = this._plugins.filter((p) => !nameSet.has(p.name));\n  }\n\n  /** Initialize all plugins with the engine. Called once during engine construction. */\n  init(engine: SpreadsheetEngine): void {\n    this._engine = engine;\n    for (const plugin of this._plugins) {\n      plugin.onInit?.(engine);\n    }\n  }\n\n  /** Destroy all plugins. */\n  destroy(): void {\n    for (const plugin of this._plugins) {\n      plugin.onDestroy?.();\n    }\n    this._plugins = [];\n    this._engine = null;\n  }\n\n  /** Run onBeforeRender on all plugins. Returns false if any plugin cancels. */\n  beforeRender(): boolean {\n    for (const plugin of this._plugins) {\n      if (plugin.onBeforeRender?.() === false) return false;\n    }\n    return true;\n  }\n\n  /** Run onAfterRender on all plugins. */\n  afterRender(): void {\n    for (const plugin of this._plugins) {\n      plugin.onAfterRender?.();\n    }\n  }\n\n  /** Run onBeforeEdit on all plugins. Returns false if any cancels. */\n  beforeEdit(rowIndex: number, colId: string): boolean {\n    for (const plugin of this._plugins) {\n      if (plugin.onBeforeEdit?.(rowIndex, colId) === false) return false;\n    }\n    return true;\n  }\n\n  /** Run onAfterEdit on all plugins. */\n  afterEdit(rowIndex: number, colId: string, oldValue: unknown, newValue: unknown): void {\n    for (const plugin of this._plugins) {\n      plugin.onAfterEdit?.(rowIndex, colId, oldValue, newValue);\n    }\n  }\n\n  /** Run onBeforeSort on all plugins. Returns false if any cancels. */\n  beforeSort(colId: string, direction: 'asc' | 'desc' | null): boolean {\n    for (const plugin of this._plugins) {\n      if (plugin.onBeforeSort?.(colId, direction) === false) return false;\n    }\n    return true;\n  }\n\n  /** Run onAfterSort on all plugins. */\n  afterSort(): void {\n    for (const plugin of this._plugins) {\n      plugin.onAfterSort?.();\n    }\n  }\n\n  /** Run onBeforeFilter on all plugins. Returns false if any cancels. */\n  beforeFilter(): boolean {\n    for (const plugin of this._plugins) {\n      if (plugin.onBeforeFilter?.() === false) return false;\n    }\n    return true;\n  }\n\n  /** Run onAfterFilter on all plugins. */\n  afterFilter(): void {\n    for (const plugin of this._plugins) {\n      plugin.onAfterFilter?.();\n    }\n  }\n\n  /** Run onBeforeInsertRows on all plugins. Returns false if any cancels. */\n  beforeInsertRows(count: number, atIndex: number): boolean {\n    for (const plugin of this._plugins) {\n      if (plugin.onBeforeInsertRows?.(count, atIndex) === false) return false;\n    }\n    return true;\n  }\n\n  /** Run onAfterInsertRows on all plugins. */\n  afterInsertRows(indices: number[]): void {\n    for (const plugin of this._plugins) {\n      plugin.onAfterInsertRows?.(indices);\n    }\n  }\n\n  /** Run onBeforeDeleteRows on all plugins. Returns false if any cancels. */\n  beforeDeleteRows(indices: number[]): boolean {\n    for (const plugin of this._plugins) {\n      if (plugin.onBeforeDeleteRows?.(indices) === false) return false;\n    }\n    return true;\n  }\n\n  /** Run onAfterDeleteRows on all plugins. */\n  afterDeleteRows(indices: number[]): void {\n    for (const plugin of this._plugins) {\n      plugin.onAfterDeleteRows?.(indices);\n    }\n  }\n\n  /** Run onBeforeInsertColumns on all plugins. Returns false if any cancels. */\n  beforeInsertColumns(count: number, atIndex: number): boolean {\n    for (const plugin of this._plugins) {\n      if (plugin.onBeforeInsertColumns?.(count, atIndex) === false) return false;\n    }\n    return true;\n  }\n\n  /** Run onAfterInsertColumns on all plugins. */\n  afterInsertColumns(indices: number[]): void {\n    for (const plugin of this._plugins) {\n      plugin.onAfterInsertColumns?.(indices);\n    }\n  }\n\n  /** Run onBeforeDeleteColumns on all plugins. Returns false if any cancels. */\n  beforeDeleteColumns(indices: number[]): boolean {\n    for (const plugin of this._plugins) {\n      if (plugin.onBeforeDeleteColumns?.(indices) === false) return false;\n    }\n    return true;\n  }\n\n  /** Run onAfterDeleteColumns on all plugins. */\n  afterDeleteColumns(indices: number[]): void {\n    for (const plugin of this._plugins) {\n      plugin.onAfterDeleteColumns?.(indices);\n    }\n  }\n\n  /** Run onBeforePaste on all plugins. Returns false if any cancels. */\n  beforePaste(data: string, startCell: { row: number; col: number }): boolean {\n    for (const plugin of this._plugins) {\n      if (plugin.onBeforePaste?.(data, startCell) === false) return false;\n    }\n    return true;\n  }\n\n  /** Run onAfterPaste on all plugins. */\n  afterPaste(): void {\n    for (const plugin of this._plugins) {\n      plugin.onAfterPaste?.();\n    }\n  }\n\n  /** Run onBeforeCopy on all plugins. Returns false if any cancels. */\n  beforeCopy(): boolean {\n    for (const plugin of this._plugins) {\n      if (plugin.onBeforeCopy?.() === false) return false;\n    }\n    return true;\n  }\n\n  /** Run onAfterCopy on all plugins. */\n  afterCopy(): void {\n    for (const plugin of this._plugins) {\n      plugin.onAfterCopy?.();\n    }\n  }\n\n  /** Fire a custom event to all plugins. */\n  fireEvent(eventType: string, payload: unknown): void {\n    for (const plugin of this._plugins) {\n      plugin.onEvent?.(eventType, payload);\n    }\n  }\n\n  /** Get all registered plugins. */\n  get plugins(): readonly SpreadsheetPlugin[] {\n    return this._plugins;\n  }\n}\n"]}

package/esm2022/spreadsheet/plugin/plugin.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/spreadsheet/plugin/selection-plugin.mjs

@@ -0,0 +1,114 @@
+/**
+ * SelectionPlugin manages cell/row/column/range selection state.
+ * Handles keyboard navigation and selection extension.
+ */
+export class SelectionPlugin {
+    constructor() {
+        this.name = 'selection';
+        this.priority = 5;
+        this._engine = null;
+    }
+    onInit(engine) {
+        this._engine = engine;
+    }
+    /** Select a single cell. */
+    selectCell(row, col) {
+        if (!this._engine)
+            return;
+        this._engine.selection.set({
+            ...this._engine.selection(),
+            activeCell: { row, col },
+            range: { start: { row, col }, end: { row, col } },
+            mode: 'cell',
+        });
+    }
+    /** Select a rectangular range. */
+    selectRange(start, end) {
+        if (!this._engine)
+            return;
+        this._engine.selection.set({
+            ...this._engine.selection(),
+            range: { start, end },
+            mode: 'range',
+        });
+    }
+    /** Select an entire row. */
+    selectRow(rowIndex) {
+        if (!this._engine)
+            return;
+        const rows = new Set(this._engine.selection().selectedRows);
+        if (rows.has(rowIndex)) {
+            rows.delete(rowIndex);
+        }
+        else {
+            rows.add(rowIndex);
+        }
+        this._engine.selection.set({
+            ...this._engine.selection(),
+            selectedRows: rows,
+            mode: 'row',
+        });
+    }
+    /** Select an entire column. */
+    selectColumn(colIndex) {
+        if (!this._engine)
+            return;
+        const cols = new Set(this._engine.selection().selectedCols);
+        if (cols.has(colIndex)) {
+            cols.delete(colIndex);
+        }
+        else {
+            cols.add(colIndex);
+        }
+        this._engine.selection.set({
+            ...this._engine.selection(),
+            selectedCols: cols,
+            mode: 'column',
+        });
+    }
+    /** Extend the range selection to include the given cell. */
+    extendSelection(row, col) {
+        if (!this._engine)
+            return;
+        const sel = this._engine.selection();
+        if (!sel.range) {
+            this.selectRange(sel.activeCell ?? { row, col }, { row, col });
+        }
+        else {
+            this.selectRange(sel.range.start, { row, col });
+        }
+    }
+    /** Clear all selection. */
+    clearSelection() {
+        if (!this._engine)
+            return;
+        this._engine.selection.set({
+            activeCell: null,
+            range: null,
+            selectedRows: new Set(),
+            selectedCols: new Set(),
+            mode: 'cell',
+            dragging: false,
+        });
+    }
+    /** Check if a cell is within the current selection. */
+    isSelected(row, col) {
+        const sel = this._engine?.selection();
+        if (!sel)
+            return false;
+        if (sel.range) {
+            const minRow = Math.min(sel.range.start.row, sel.range.end.row);
+            const maxRow = Math.max(sel.range.start.row, sel.range.end.row);
+            const minCol = Math.min(sel.range.start.col, sel.range.end.col);
+            const maxCol = Math.max(sel.range.start.col, sel.range.end.col);
+            if (row >= minRow && row <= maxRow && col >= minCol && col <= maxCol)
+                return true;
+        }
+        if (sel.selectedRows.has(row))
+            return true;
+        if (sel.selectedCols.has(col))
+            return true;
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selection-plugin.js","sourceRoot":"","sources":["../../../../../../packages/cdk/spreadsheet/plugin/selection-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SpreadsheetPlugin } from './plugin.types';\nimport type { SpreadsheetEngine } from '../spreadsheet-engine';\nimport type { CellAddress } from '../models';\n\n/**\n * SelectionPlugin manages cell/row/column/range selection state.\n * Handles keyboard navigation and selection extension.\n */\nexport class SelectionPlugin implements SpreadsheetPlugin {\n  readonly name = 'selection';\n  readonly priority = 5;\n\n  private _engine: SpreadsheetEngine | null = null;\n\n  onInit(engine: SpreadsheetEngine): void {\n    this._engine = engine;\n  }\n\n  /** Select a single cell. */\n  selectCell(row: number, col: number): void {\n    if (!this._engine) return;\n    this._engine.selection.set({\n      ...this._engine.selection(),\n      activeCell: { row, col },\n      range: { start: { row, col }, end: { row, col } },\n      mode: 'cell',\n    });\n  }\n\n  /** Select a rectangular range. */\n  selectRange(start: CellAddress, end: CellAddress): void {\n    if (!this._engine) return;\n    this._engine.selection.set({\n      ...this._engine.selection(),\n      range: { start, end },\n      mode: 'range',\n    });\n  }\n\n  /** Select an entire row. */\n  selectRow(rowIndex: number): void {\n    if (!this._engine) return;\n    const rows = new Set(this._engine.selection().selectedRows);\n    if (rows.has(rowIndex)) {\n      rows.delete(rowIndex);\n    } else {\n      rows.add(rowIndex);\n    }\n    this._engine.selection.set({\n      ...this._engine.selection(),\n      selectedRows: rows,\n      mode: 'row',\n    });\n  }\n\n  /** Select an entire column. */\n  selectColumn(colIndex: number): void {\n    if (!this._engine) return;\n    const cols = new Set(this._engine.selection().selectedCols);\n    if (cols.has(colIndex)) {\n      cols.delete(colIndex);\n    } else {\n      cols.add(colIndex);\n    }\n    this._engine.selection.set({\n      ...this._engine.selection(),\n      selectedCols: cols,\n      mode: 'column',\n    });\n  }\n\n  /** Extend the range selection to include the given cell. */\n  extendSelection(row: number, col: number): void {\n    if (!this._engine) return;\n    const sel = this._engine.selection();\n    if (!sel.range) {\n      this.selectRange(sel.activeCell ?? { row, col }, { row, col });\n    } else {\n      this.selectRange(sel.range.start, { row, col });\n    }\n  }\n\n  /** Clear all selection. */\n  clearSelection(): void {\n    if (!this._engine) return;\n    this._engine.selection.set({\n      activeCell: null,\n      range: null,\n      selectedRows: new Set(),\n      selectedCols: new Set(),\n      mode: 'cell',\n      dragging: false,\n    });\n  }\n\n  /** Check if a cell is within the current selection. */\n  isSelected(row: number, col: number): boolean {\n    const sel = this._engine?.selection();\n    if (!sel) return false;\n\n    if (sel.range) {\n      const minRow = Math.min(sel.range.start.row, sel.range.end.row);\n      const maxRow = Math.max(sel.range.start.row, sel.range.end.row);\n      const minCol = Math.min(sel.range.start.col, sel.range.end.col);\n      const maxCol = Math.max(sel.range.start.col, sel.range.end.col);\n      if (row >= minRow && row <= maxRow && col >= minCol && col <= maxCol) return true;\n    }\n\n    if (sel.selectedRows.has(row)) return true;\n    if (sel.selectedCols.has(col)) return true;\n\n    return false;\n  }\n}\n"]}

package/esm2022/spreadsheet/plugin/sort-plugin.mjs

@@ -0,0 +1,63 @@
+/**
+ * SortPlugin manages multi-column sorting.
+ * Sorts the engine's rows by the active sort criteria.
+ */
+export class SortPlugin {
+    constructor() {
+        this.name = 'sort';
+        this.priority = 10;
+        this._engine = null;
+    }
+    onInit(engine) {
+        this._engine = engine;
+    }
+    /** Apply all active sort criteria to the engine's row list. */
+    applySort(criteria) {
+        if (!this._engine || criteria.length === 0)
+            return;
+        const defs = this._engine.columnDefs();
+        const sorted = [...this._engine.rowData()];
+        sorted.sort((a, b) => {
+            for (const crit of criteria) {
+                const col = defs.find((d) => d.id === crit.colId);
+                const aVal = a.cells[crit.colId]?.value;
+                const bVal = b.cells[crit.colId]?.value;
+                let cmp;
+                if (col?.comparator) {
+                    cmp = col.comparator(aVal, bVal, crit.direction);
+                }
+                else {
+                    cmp = defaultCompare(aVal, bVal);
+                }
+                if (cmp !== 0) {
+                    return crit.direction === 'desc' ? -cmp : cmp;
+                }
+            }
+            return 0;
+        });
+        this._engine.rowData.set(sorted);
+    }
+    onBeforeSort(_colId, _direction) {
+        return true;
+    }
+    onAfterSort() {
+        const criteria = this._engine?.sortState().criteria;
+        if (criteria && criteria.length > 0) {
+            this.applySort(criteria);
+        }
+    }
+}
+function defaultCompare(a, b) {
+    if (a == null && b == null)
+        return 0;
+    if (a == null)
+        return -1;
+    if (b == null)
+        return 1;
+    if (typeof a === 'number' && typeof b === 'number')
+        return a - b;
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() - b.getTime();
+    return String(a).localeCompare(String(b));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/spreadsheet/plugin/undo-plugin.mjs

@@ -0,0 +1,138 @@
+/**
+ * UndoPlugin provides undo/redo by maintaining a history stack.
+ * Captures snapshots before mutations.
+ */
+export class UndoPlugin {
+    constructor() {
+        this.name = 'undo';
+        this.priority = 100;
+        this._engine = null;
+        this._undoStack = [];
+        this._redoStack = [];
+        this._maxHistory = 100;
+    }
+    onInit(engine) {
+        this._engine = engine;
+    }
+    onDestroy() {
+        this._undoStack = [];
+        this._redoStack = [];
+    }
+    /** Record an edit mutation for undo. */
+    recordEdit(rowIndex, colId, oldValue, newValue) {
+        this._push({
+            type: 'edit',
+            timestamp: Date.now(),
+            edits: [{ rowIndex, colId, oldValue, newValue }],
+        });
+    }
+    /** Record a bulk edit (multiple cells). */
+    recordBulkEdit(edits) {
+        if (edits.length === 0)
+            return;
+        this._push({ type: 'edit', timestamp: Date.now(), edits });
+    }
+    /** Undo the last mutation. */
+    undo() {
+        if (!this._engine || this._undoStack.length === 0)
+            return false;
+        const entry = this._undoStack.pop();
+        this._applyUndo(entry);
+        this._redoStack.push(entry);
+        return true;
+    }
+    /** Redo the last undone mutation. */
+    redo() {
+        if (!this._engine || this._redoStack.length === 0)
+            return false;
+        const entry = this._redoStack.pop();
+        this._applyRedo(entry);
+        this._undoStack.push(entry);
+        return true;
+    }
+    /** Whether undo is available. */
+    get canUndo() {
+        return this._undoStack.length > 0;
+    }
+    /** Whether redo is available. */
+    get canRedo() {
+        return this._redoStack.length > 0;
+    }
+    /** Clear all history. */
+    clearHistory() {
+        this._undoStack = [];
+        this._redoStack = [];
+    }
+    _push(entry) {
+        this._undoStack.push(entry);
+        if (this._undoStack.length > this._maxHistory) {
+            this._undoStack.shift();
+        }
+        this._redoStack = [];
+    }
+    _applyUndo(entry) {
+        if (!this._engine)
+            return;
+        if (entry.type === 'edit' && entry.edits) {
+            const rows = [...this._engine.rowData()];
+            for (const edit of entry.edits) {
+                if (rows[edit.rowIndex]) {
+                    rows[edit.rowIndex] = {
+                        ...rows[edit.rowIndex],
+                        cells: {
+                            ...rows[edit.rowIndex].cells,
+                            [edit.colId]: {
+                                value: edit.oldValue,
+                                meta: rows[edit.rowIndex].cells[edit.colId]?.meta,
+                            },
+                        },
+                    };
+                }
+            }
+            this._engine.rowData.set(rows);
+        }
+        else if (entry.type === 'delete_rows' && entry.rows) {
+            const rows = [...this._engine.rowData()];
+            rows.splice(entry.rowIndex ?? 0, 0, ...entry.rows);
+            this._engine.rowData.set(rows);
+        }
+        else if (entry.type === 'insert_rows' && entry.rowIndex != null) {
+            const rows = [...this._engine.rowData()];
+            rows.splice(entry.rowIndex, entry.rows?.length ?? 0);
+            this._engine.rowData.set(rows);
+        }
+    }
+    _applyRedo(entry) {
+        if (!this._engine)
+            return;
+        if (entry.type === 'edit' && entry.edits) {
+            const rows = [...this._engine.rowData()];
+            for (const edit of entry.edits) {
+                if (rows[edit.rowIndex]) {
+                    rows[edit.rowIndex] = {
+                        ...rows[edit.rowIndex],
+                        cells: {
+                            ...rows[edit.rowIndex].cells,
+                            [edit.colId]: {
+                                value: edit.newValue,
+                                meta: rows[edit.rowIndex].cells[edit.colId]?.meta,
+                            },
+                        },
+                    };
+                }
+            }
+            this._engine.rowData.set(rows);
+        }
+        else if (entry.type === 'insert_rows' && entry.rows) {
+            const rows = [...this._engine.rowData()];
+            rows.splice(entry.rowIndex ?? 0, 0, ...entry.rows);
+            this._engine.rowData.set(rows);
+        }
+        else if (entry.type === 'delete_rows' && entry.rowIndex != null) {
+            const rows = [...this._engine.rowData()];
+            rows.splice(entry.rowIndex, entry.rows?.length ?? 0);
+            this._engine.rowData.set(rows);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"undo-plugin.js","sourceRoot":"","sources":["../../../../../../packages/cdk/spreadsheet/plugin/undo-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SpreadsheetPlugin } from './plugin.types';\nimport type { SpreadsheetEngine } from '../spreadsheet-engine';\nimport type { CellValue, RowDef } from '../models';\n\ninterface UndoEntry {\n  readonly type: 'edit' | 'insert_rows' | 'delete_rows' | 'insert_cols' | 'delete_cols';\n  readonly timestamp: number;\n  /** For edit: row index + col id + old value. */\n  readonly edits?: { rowIndex: number; colId: string; oldValue: CellValue; newValue: CellValue }[];\n  /** For row/col insert/delete: the actual data that was removed or added. */\n  readonly rows?: RowDef[];\n  readonly rowIndex?: number;\n  readonly colIds?: string[];\n  readonly colWidths?: number[];\n}\n\n/**\n * UndoPlugin provides undo/redo by maintaining a history stack.\n * Captures snapshots before mutations.\n */\nexport class UndoPlugin implements SpreadsheetPlugin {\n  readonly name = 'undo';\n  readonly priority = 100;\n\n  private _engine: SpreadsheetEngine | null = null;\n  private _undoStack: UndoEntry[] = [];\n  private _redoStack: UndoEntry[] = [];\n  private _maxHistory = 100;\n\n  onInit(engine: SpreadsheetEngine): void {\n    this._engine = engine;\n  }\n\n  onDestroy(): void {\n    this._undoStack = [];\n    this._redoStack = [];\n  }\n\n  /** Record an edit mutation for undo. */\n  recordEdit(rowIndex: number, colId: string, oldValue: CellValue, newValue: CellValue): void {\n    this._push({\n      type: 'edit',\n      timestamp: Date.now(),\n      edits: [{ rowIndex, colId, oldValue, newValue }],\n    });\n  }\n\n  /** Record a bulk edit (multiple cells). */\n  recordBulkEdit(\n    edits: { rowIndex: number; colId: string; oldValue: CellValue; newValue: CellValue }[],\n  ): void {\n    if (edits.length === 0) return;\n    this._push({ type: 'edit', timestamp: Date.now(), edits });\n  }\n\n  /** Undo the last mutation. */\n  undo(): boolean {\n    if (!this._engine || this._undoStack.length === 0) return false;\n    const entry = this._undoStack.pop()!;\n    this._applyUndo(entry);\n    this._redoStack.push(entry);\n    return true;\n  }\n\n  /** Redo the last undone mutation. */\n  redo(): boolean {\n    if (!this._engine || this._redoStack.length === 0) return false;\n    const entry = this._redoStack.pop()!;\n    this._applyRedo(entry);\n    this._undoStack.push(entry);\n    return true;\n  }\n\n  /** Whether undo is available. */\n  get canUndo(): boolean {\n    return this._undoStack.length > 0;\n  }\n\n  /** Whether redo is available. */\n  get canRedo(): boolean {\n    return this._redoStack.length > 0;\n  }\n\n  /** Clear all history. */\n  clearHistory(): void {\n    this._undoStack = [];\n    this._redoStack = [];\n  }\n\n  private _push(entry: UndoEntry): void {\n    this._undoStack.push(entry);\n    if (this._undoStack.length > this._maxHistory) {\n      this._undoStack.shift();\n    }\n    this._redoStack = [];\n  }\n\n  private _applyUndo(entry: UndoEntry): void {\n    if (!this._engine) return;\n\n    if (entry.type === 'edit' && entry.edits) {\n      const rows = [...this._engine.rowData()];\n      for (const edit of entry.edits) {\n        if (rows[edit.rowIndex]) {\n          rows[edit.rowIndex] = {\n            ...rows[edit.rowIndex],\n            cells: {\n              ...rows[edit.rowIndex].cells,\n              [edit.colId]: {\n                value: edit.oldValue,\n                meta: rows[edit.rowIndex].cells[edit.colId]?.meta,\n              },\n            },\n          };\n        }\n      }\n      this._engine.rowData.set(rows);\n    } else if (entry.type === 'delete_rows' && entry.rows) {\n      const rows = [...this._engine.rowData()];\n      rows.splice(entry.rowIndex ?? 0, 0, ...entry.rows);\n      this._engine.rowData.set(rows);\n    } else if (entry.type === 'insert_rows' && entry.rowIndex != null) {\n      const rows = [...this._engine.rowData()];\n      rows.splice(entry.rowIndex, entry.rows?.length ?? 0);\n      this._engine.rowData.set(rows);\n    }\n  }\n\n  private _applyRedo(entry: UndoEntry): void {\n    if (!this._engine) return;\n\n    if (entry.type === 'edit' && entry.edits) {\n      const rows = [...this._engine.rowData()];\n      for (const edit of entry.edits) {\n        if (rows[edit.rowIndex]) {\n          rows[edit.rowIndex] = {\n            ...rows[edit.rowIndex],\n            cells: {\n              ...rows[edit.rowIndex].cells,\n              [edit.colId]: {\n                value: edit.newValue,\n                meta: rows[edit.rowIndex].cells[edit.colId]?.meta,\n              },\n            },\n          };\n        }\n      }\n      this._engine.rowData.set(rows);\n    } else if (entry.type === 'insert_rows' && entry.rows) {\n      const rows = [...this._engine.rowData()];\n      rows.splice(entry.rowIndex ?? 0, 0, ...entry.rows);\n      this._engine.rowData.set(rows);\n    } else if (entry.type === 'delete_rows' && entry.rowIndex != null) {\n      const rows = [...this._engine.rowData()];\n      rows.splice(entry.rowIndex, entry.rows?.length ?? 0);\n      this._engine.rowData.set(rows);\n    }\n  }\n}\n"]}