@ngxsmk/cdk 1.3.2 → 3.0.0

package/fesm2022/ngxsmk-cdk-spreadsheet.mjs

@@ -0,0 +1,1969 @@
+import { signal, computed } from '@angular/core';
+
+/**
+ * PluginHost manages the lifecycle of all registered plugins.
+ * Plugins are executed in priority order (lower = first).
+ */
+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;
+    }
+}
+
+/** Convert a column index to an Excel-style column letter (0=A, 25=Z, 26=AA). */
+function colIndexToLetter(index) {
+    let letter = '';
+    let i = index;
+    while (i >= 0) {
+        letter = String.fromCharCode(65 + (i % 26)) + letter;
+        i = Math.floor(i / 26) - 1;
+    }
+    return letter;
+}
+/** Convert an Excel-style column letter to a 0-based index. */
+function colLetterToIndex(letter) {
+    let index = 0;
+    for (let i = 0; i < letter.length; i++) {
+        index = index * 26 + (letter.charCodeAt(i) - 64);
+    }
+    return index - 1;
+}
+/** Build a cell reference string like "A1", "B5". */
+function cellRef(row, col) {
+    return `${colIndexToLetter(col)}${row + 1}`;
+}
+/** Parse a cell reference string like "A1" into a CellAddress. */
+function parseCellRef(ref) {
+    const match = ref.match(/^([A-Z]+)(\d+)$/i);
+    if (!match)
+        return null;
+    return { row: parseInt(match[2], 10) - 1, col: colLetterToIndex(match[1].toUpperCase()) };
+}
+/** Normalize a range so start <= end in both dimensions. */
+function normalizeRange(range) {
+    return {
+        start: {
+            row: Math.min(range.start.row, range.end.row),
+            col: Math.min(range.start.col, range.end.col),
+        },
+        end: {
+            row: Math.max(range.start.row, range.end.row),
+            col: Math.max(range.start.col, range.end.col),
+        },
+    };
+}
+/** Check if a cell address is within a range. */
+function isCellInRange(address, range) {
+    const nr = normalizeRange(range);
+    return (address.row >= nr.start.row &&
+        address.row <= nr.end.row &&
+        address.col >= nr.start.col &&
+        address.col <= nr.end.col);
+}
+/** Get all cell addresses in a range. */
+function cellsInRange(range) {
+    const nr = normalizeRange(range);
+    const cells = [];
+    for (let r = nr.start.row; r <= nr.end.row; r++) {
+        for (let c = nr.start.col; c <= nr.end.col; c++) {
+            cells.push({ row: r, col: c });
+        }
+    }
+    return cells;
+}
+/** Format a cell value for display. */
+function formatCellValue(value, format) {
+    if (value == null || value === '')
+        return '';
+    if (typeof value === 'boolean')
+        return value ? 'TRUE' : 'FALSE';
+    if (value instanceof Date) {
+        return value.toLocaleDateString();
+    }
+    if (typeof value === 'number') {
+        if (format) {
+            return applyNumberFormat(value, format);
+        }
+        return String(value);
+    }
+    return String(value);
+}
+/** Apply a basic number format string. */
+function applyNumberFormat(value, format) {
+    const isNeg = value < 0;
+    const abs = Math.abs(value);
+    // Currency format: $#,##0.00
+    if (format.includes('$')) {
+        const decimals = format.includes('.00') ? 2 : 0;
+        return `${isNeg ? '-' : ''}$${abs.toFixed(decimals).replace(/\B(?=(\d{3})+(?!\d))/g, ',')}`;
+    }
+    // Percentage format
+    if (format.includes('%')) {
+        return `${(abs * 100).toFixed(format.includes('.00') ? 2 : 0)}%`;
+    }
+    // Plain number with commas: #,##0
+    if (format.includes(',')) {
+        return `${isNeg ? '-' : ''}${abs.toFixed(0).replace(/\B(?=(\d{3})+(?!\d))/g, ',')}`;
+    }
+    return String(value);
+}
+/** Create a new RowDef with empty cells for each column. */
+function createEmptyRow(id, columns) {
+    const cells = {};
+    for (const col of columns) {
+        cells[col.id] = {
+            value: (col.defaultValue ?? null),
+            meta: { type: col.cellType ?? 'text' },
+        };
+    }
+    return { id, cells, selectable: true, editable: true };
+}
+/** Generate a unique row ID. */
+function generateRowId() {
+    return `row_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+/** Deep clone a row's cell data (for immutable updates). */
+function cloneRow(row) {
+    return {
+        ...row,
+        cells: Object.fromEntries(Object.entries(row.cells).map(([k, v]) => [
+            k,
+            { ...v, meta: v.meta ? { ...v.meta } : undefined },
+        ])),
+    };
+}
+/** Calculate the total width of pinned columns. */
+function pinnedWidth(columns, states, side) {
+    return columns
+        .filter((c) => c.pinned === side)
+        .reduce((sum, c) => sum + (states.get(c.id) ?? c.width ?? 150), 0);
+}
+
+const DENSITY_ROW_HEIGHT = {
+    compact: 28,
+    comfortable: 36,
+    dense: 24,
+};
+const DENSITY_HEADER_HEIGHT = {
+    compact: 32,
+    comfortable: 40,
+    dense: 28,
+};
+const DENSITY_CELL_PADDING = {
+    compact: '2px 6px',
+    comfortable: '6px 10px',
+    dense: '2px 4px',
+};
+/**
+ * SpreadsheetEngine — headless, signal-based state machine for spreadsheet data.
+ * Zero DOM, zero Angular dependencies beyond signals.
+ *
+ * Supports: columns, rows, sorting, filtering, selection, editing,
+ * undo/redo, clipboard, formulas, tree data, virtual scrolling state.
+ */
+class SpreadsheetEngine {
+    constructor(config = {}) {
+        this._config = config;
+        this.pluginHost = new PluginHost();
+        // Density
+        this.density = signal(config.density ?? 'comfortable');
+        this.editable = signal(config.editable ?? true);
+        this.rtl = signal(config.rtl ?? false);
+        this.frozenRows = signal(config.frozenRows ?? 0);
+        this.frozenColumns = signal(config.frozenColumns ?? 0);
+        // Row/column height computed from density
+        this.rowHeight = computed(() => DENSITY_ROW_HEIGHT[this.density()]);
+        this.headerHeight = computed(() => DENSITY_HEADER_HEIGHT[this.density()]);
+        this.cellPadding = computed(() => DENSITY_CELL_PADDING[this.density()]);
+        // Column definitions
+        this.columnDefs = signal(config.columns ?? []);
+        // Column states (width, visibility, pin, sort)
+        const initialStates = new Map();
+        (config.columns ?? []).forEach((col, idx) => {
+            initialStates.set(col.id, {
+                id: col.id,
+                width: col.width ?? 150,
+                visible: col.visible !== false,
+                pinned: col.pinned ?? false,
+                sort: col.sort ?? null,
+                sortIndex: undefined,
+                order: idx,
+            });
+        });
+        this.columnStates = signal(initialStates);
+        // Row data
+        this.rowData = signal(config.rows ?? []);
+        // Selection
+        this.selection = signal({
+            activeCell: null,
+            range: null,
+            selectedRows: new Set(),
+            selectedCols: new Set(),
+            mode: config.selectionMode ?? 'cell',
+            dragging: false,
+        });
+        // Sort
+        this.sortState = signal({
+            criteria: (config.columns ?? [])
+                .filter((c) => c.sort)
+                .map((c, i) => ({ colId: c.id, direction: c.sort, index: i })),
+            multiSort: config.multiSort ?? false,
+        });
+        // Filter
+        this.filterState = signal({ criteria: [], mode: 'and' });
+        // Editing
+        this.editingCell = signal(null);
+        this.editingValue = signal(null);
+        // Scroll
+        this.scrollTop = signal(0);
+        this.scrollLeft = signal(0);
+        this.viewportHeight = signal(600);
+        this.viewportWidth = signal(800);
+        // Plugins
+        this.plugins = signal(config.plugins ?? []);
+        // Lifecycle hooks
+        this.lifecycle = {
+            beforeEdit: signal(() => true),
+            afterEdit: signal(() => {
+                /* noop */
+            }),
+            beforeSort: signal(() => true),
+            afterSort: signal(() => {
+                /* noop */
+            }),
+            beforeFilter: signal(() => true),
+            afterFilter: signal(() => {
+                /* noop */
+            }),
+            beforeInsertRows: signal(() => true),
+            afterInsertRows: signal(() => {
+                /* noop */
+            }),
+            beforeDeleteRows: signal(() => true),
+            afterDeleteRows: signal(() => {
+                /* noop */
+            }),
+            beforeInsertColumns: signal(() => true),
+            afterInsertColumns: signal(() => {
+                /* noop */
+            }),
+            beforeDeleteColumns: signal(() => true),
+            afterDeleteColumns: signal(() => {
+                /* noop */
+            }),
+            beforeCopy: signal(() => true),
+            afterCopy: signal(() => {
+                /* noop */
+            }),
+            beforePaste: signal(() => true),
+            afterPaste: signal(() => {
+                /* noop */
+            }),
+        };
+        // ── Computed ──
+        this.visibleColumns = computed(() => {
+            const states = this.columnStates();
+            return this.columnDefs().filter((col) => {
+                const st = states.get(col.id);
+                return st?.visible ?? true;
+            });
+        });
+        this.pinnedLeftColumns = computed(() => this.visibleColumns().filter((c) => c.pinned === 'left'));
+        this.pinnedRightColumns = computed(() => this.visibleColumns().filter((c) => c.pinned === 'right'));
+        this.unpinnedColumns = computed(() => this.visibleColumns().filter((c) => !c.pinned));
+        this.columnWidths = computed(() => {
+            const states = this.columnStates();
+            const widths = new Map();
+            for (const col of this.columnDefs()) {
+                widths.set(col.id, states.get(col.id)?.width ?? col.width ?? 150);
+            }
+            return widths;
+        });
+        this.totalColumns = computed(() => this.visibleColumns().length);
+        this.visibleRows = computed(() => {
+            return this.rowData();
+        });
+        this.displayRows = computed(() => {
+            return this.visibleRows();
+        });
+        this.totalRows = computed(() => this.displayRows().length);
+        this.rowHeight = computed(() => DENSITY_ROW_HEIGHT[this.density()]);
+        this.totalHeight = computed(() => this.totalRows() * this.rowHeight());
+        this.totalWidth = computed(() => {
+            const widths = this.columnWidths();
+            let total = 0;
+            for (const col of this.visibleColumns()) {
+                total += widths.get(col.id) ?? 150;
+            }
+            return total;
+        });
+        // Virtual scroll range — which rows are visible
+        this.virtualRowRange = computed(() => {
+            const rh = this.rowHeight();
+            const vh = this.viewportHeight();
+            const st = this.scrollTop();
+            const total = this.totalRows();
+            const buffer = config.bufferRows ?? 5;
+            const start = Math.max(0, Math.floor(st / rh) - buffer);
+            const visibleCount = Math.ceil(vh / rh);
+            const end = Math.min(total, start + visibleCount + buffer * 2);
+            return {
+                start,
+                end,
+                offsetY: start * rh,
+                totalHeight: total * rh,
+            };
+        });
+        // Virtual scroll range — which columns are visible
+        this.virtualColRange = computed(() => {
+            const widths = this.columnWidths();
+            const vw = this.viewportWidth();
+            const sl = this.scrollLeft();
+            const cols = this.unpinnedColumns();
+            const buffer = 3;
+            let start = 0;
+            let end = cols.length;
+            // Find start column
+            let accWidth = 0;
+            for (let i = 0; i < cols.length; i++) {
+                const w = widths.get(cols[i].id) ?? 150;
+                if (accWidth + w > sl) {
+                    start = Math.max(0, i - buffer);
+                    break;
+                }
+                accWidth += w;
+            }
+            // Find end column
+            let accWidth2 = 0;
+            for (let i = start; i < cols.length; i++) {
+                accWidth2 += widths.get(cols[i].id) ?? 150;
+                if (accWidth2 > vw + sl) {
+                    end = Math.min(cols.length, i + buffer + 1);
+                    break;
+                }
+            }
+            // Recalculate offsetX
+            let finalOffsetX = 0;
+            for (let i = 0; i < start; i++) {
+                finalOffsetX += widths.get(cols[i].id) ?? 150;
+            }
+            return {
+                start,
+                end,
+                offsetX: finalOffsetX,
+                totalWidth: cols.reduce((sum, c) => sum + (widths.get(c.id) ?? 150), 0),
+            };
+        });
+        // Initialize plugins
+        this.pluginHost.init(this);
+    }
+    // ── Column Operations ──
+    /** Get column state by ID. */
+    getColumnState(colId) {
+        return this.columnStates().get(colId);
+    }
+    /** Set column width. */
+    setColumnWidth(colId, width) {
+        const states = new Map(this.columnStates());
+        const st = states.get(colId);
+        if (st) {
+            const col = this.columnDefs().find((c) => c.id === colId);
+            const min = col?.minWidth ?? 40;
+            const max = col?.maxWidth ?? 600;
+            states.set(colId, { ...st, width: Math.max(min, Math.min(max, width)) });
+            this.columnStates.set(states);
+        }
+    }
+    /** Toggle column visibility. */
+    toggleColumnVisibility(colId) {
+        const states = new Map(this.columnStates());
+        const st = states.get(colId);
+        if (st) {
+            states.set(colId, { ...st, visible: !st.visible });
+            this.columnStates.set(states);
+        }
+    }
+    /** Set column sort direction. */
+    setColumnSort(colId, direction) {
+        const states = new Map(this.columnStates());
+        const st = states.get(colId);
+        if (st) {
+            states.set(colId, { ...st, sort: direction });
+            this.columnStates.set(states);
+        }
+        // Update sort state
+        const current = this.sortState();
+        let criteria;
+        if (current.multiSort) {
+            const existing = current.criteria.filter((c) => c.colId !== colId);
+            if (direction) {
+                criteria = [...existing, { colId, direction, index: existing.length }];
+            }
+            else {
+                criteria = existing;
+            }
+        }
+        else {
+            // Single sort: clear other sorts
+            for (const [id, s] of states) {
+                if (id !== colId && s.sort) {
+                    states.set(id, { ...s, sort: null });
+                }
+            }
+            this.columnStates.set(states);
+            criteria = direction ? [{ colId, direction, index: 0 }] : [];
+        }
+        this.sortState.set({ ...current, criteria });
+    }
+    /** Reorder columns. */
+    moveColumn(fromIndex, toIndex) {
+        const cols = [...this.columnDefs()];
+        const [moved] = cols.splice(fromIndex, 1);
+        if (moved) {
+            cols.splice(toIndex, 0, moved);
+            this.columnDefs.set(cols);
+        }
+    }
+    // ── Row Operations ──
+    /** Insert rows at the given index. */
+    insertRows(count, atIndex) {
+        const index = atIndex ?? this.rowData().length;
+        const rows = [...this.rowData()];
+        const newIndices = [];
+        for (let i = 0; i < count; i++) {
+            const newRow = createEmptyRow(generateRowId(), this.columnDefs());
+            rows.splice(index + i, 0, newRow);
+            newIndices.push(index + i);
+        }
+        this.rowData.set(rows);
+        return newIndices;
+    }
+    /** Delete rows by index. */
+    deleteRows(indices) {
+        const sorted = [...indices].sort((a, b) => b - a);
+        const rows = [...this.rowData()];
+        const deleted = [];
+        for (const idx of sorted) {
+            if (idx >= 0 && idx < rows.length) {
+                deleted.push(rows[idx]);
+                rows.splice(idx, 1);
+            }
+        }
+        this.rowData.set(rows);
+        return deleted;
+    }
+    // ── Cell Operations ──
+    /** Get a cell value. */
+    getCellValue(rowIndex, colId) {
+        return this.rowData()[rowIndex]?.cells[colId]?.value ?? null;
+    }
+    /** Set a cell value. */
+    setCellValue(rowIndex, colId, value) {
+        const rows = [...this.rowData()];
+        const row = rows[rowIndex];
+        if (!row)
+            return;
+        rows[rowIndex] = {
+            ...row,
+            cells: {
+                ...row.cells,
+                [colId]: { value, meta: row.cells[colId]?.meta },
+            },
+        };
+        this.rowData.set(rows);
+    }
+    /** Get cell metadata. */
+    getCellMeta(rowIndex, colId) {
+        return this.rowData()[rowIndex]?.cells[colId]?.meta;
+    }
+    /** Get a column definition by ID. */
+    getColumnDef(colId) {
+        return this.columnDefs().find((c) => c.id === colId);
+    }
+    /** Get the 0-based column index by ID. */
+    getColIndex(colId) {
+        return this.visibleColumns().findIndex((c) => c.id === colId);
+    }
+    // ── Editing ──
+    /** Begin editing a cell. */
+    startEdit(rowIndex, colId) {
+        if (!this.editable())
+            return false;
+        if (!this.pluginHost.beforeEdit(rowIndex, colId))
+            return false;
+        const value = this.getCellValue(rowIndex, colId);
+        this.editingCell.set({ row: rowIndex, col: this.getColIndex(colId) });
+        this.editingValue.set(value);
+        return true;
+    }
+    /** Commit the current edit. */
+    commitEdit() {
+        const cell = this.editingCell();
+        if (!cell)
+            return;
+        const col = this.visibleColumns()[cell.col];
+        if (!col)
+            return;
+        const oldValue = this.getCellValue(cell.row, col.id);
+        const newValue = this.editingValue();
+        if (oldValue !== newValue) {
+            this.setCellValue(cell.row, col.id, newValue);
+            this.pluginHost.afterEdit(cell.row, col.id, oldValue, newValue);
+        }
+        this.editingCell.set(null);
+    }
+    /** Cancel the current edit. */
+    cancelEdit() {
+        this.editingCell.set(null);
+        this.editingValue.set(null);
+    }
+    // ── Sort ──
+    /** Sort by a column (toggles direction). */
+    sortBy(colId) {
+        const st = this.columnStates().get(colId);
+        if (!st)
+            return;
+        const currentSort = st.sort;
+        let newDirection;
+        if (currentSort === null) {
+            newDirection = 'asc';
+        }
+        else if (currentSort === 'asc') {
+            newDirection = 'desc';
+        }
+        else {
+            newDirection = null;
+        }
+        if (!this.pluginHost.beforeSort(colId, newDirection))
+            return;
+        this.setColumnSort(colId, newDirection);
+        this.pluginHost.afterSort();
+    }
+    /** Clear all sorting. */
+    clearSort() {
+        const states = new Map(this.columnStates());
+        for (const [id, st] of states) {
+            if (st.sort) {
+                states.set(id, { ...st, sort: null, sortIndex: undefined });
+            }
+        }
+        this.columnStates.set(states);
+        this.sortState.set({ criteria: [], multiSort: this.sortState().multiSort });
+    }
+    // ── Filter ──
+    /** Apply a filter. */
+    applyFilter(colId, operator, value, valueTo) {
+        const current = this.filterState();
+        const existing = current.criteria.filter((c) => c.colId !== colId);
+        const criteria = [...existing, { colId, operator, value, valueTo }];
+        this.filterState.set({ ...current, criteria });
+    }
+    /** Clear filter for a column. */
+    clearColumnFilter(colId) {
+        const current = this.filterState();
+        this.filterState.set({
+            ...current,
+            criteria: current.criteria.filter((c) => c.colId !== colId),
+        });
+    }
+    /** Clear all filters. */
+    clearFilters() {
+        this.filterState.set({ criteria: [], mode: 'and' });
+    }
+    // ── Navigation ──
+    /** Move the active cell by delta. */
+    navigate(deltaRow, deltaCol) {
+        const sel = this.selection();
+        const current = sel.activeCell ?? { row: 0, col: 0 };
+        const newRow = Math.max(0, Math.min(this.totalRows() - 1, current.row + deltaRow));
+        const newCol = Math.max(0, Math.min(this.totalColumns() - 1, current.col + deltaCol));
+        this.selection.set({
+            ...sel,
+            activeCell: { row: newRow, col: newCol },
+            range: { start: { row: newRow, col: newCol }, end: { row: newRow, col: newCol } },
+        });
+    }
+    /** Scroll to make a cell visible. */
+    scrollToCell(rowIndex, _colIndex) {
+        const rh = this.rowHeight();
+        const cellTop = rowIndex * rh;
+        const cellBottom = cellTop + rh;
+        const st = this.scrollTop();
+        const vh = this.viewportHeight();
+        if (cellTop < st) {
+            this.scrollTop.set(cellTop);
+        }
+        else if (cellBottom > st + vh) {
+            this.scrollTop.set(cellBottom - vh);
+        }
+    }
+    // ── Selection ──
+    /** Select a cell. */
+    selectCell(row, col) {
+        this.selection.set({
+            ...this.selection(),
+            activeCell: { row, col },
+            range: { start: { row, col }, end: { row, col } },
+            mode: 'cell',
+        });
+    }
+    /** Select a range. */
+    selectRange(start, end) {
+        this.selection.set({
+            ...this.selection(),
+            range: { start, end },
+            mode: 'range',
+        });
+    }
+    /** Select a row. */
+    selectRow(rowIndex) {
+        const rows = new Set(this.selection().selectedRows);
+        if (rows.has(rowIndex)) {
+            rows.delete(rowIndex);
+        }
+        else {
+            rows.add(rowIndex);
+        }
+        this.selection.set({ ...this.selection(), selectedRows: rows, mode: 'row' });
+    }
+    /** Select a column. */
+    selectColumn(colIndex) {
+        const cols = new Set(this.selection().selectedCols);
+        if (cols.has(colIndex)) {
+            cols.delete(colIndex);
+        }
+        else {
+            cols.add(colIndex);
+        }
+        this.selection.set({ ...this.selection(), selectedCols: cols, mode: 'column' });
+    }
+    /** Select all cells. */
+    selectAll() {
+        const allRows = new Set(Array.from({ length: this.totalRows() }, (_, i) => i));
+        const allCols = new Set(Array.from({ length: this.totalColumns() }, (_, i) => i));
+        this.selection.set({
+            activeCell: { row: 0, col: 0 },
+            range: {
+                start: { row: 0, col: 0 },
+                end: { row: this.totalRows() - 1, col: this.totalColumns() - 1 },
+            },
+            selectedRows: allRows,
+            selectedCols: allCols,
+            mode: 'range',
+            dragging: false,
+        });
+    }
+    /** Check if a cell is selected. */
+    isCellSelected(row, col) {
+        const sel = this.selection();
+        if (sel.range) {
+            const minR = Math.min(sel.range.start.row, sel.range.end.row);
+            const maxR = Math.max(sel.range.start.row, sel.range.end.row);
+            const minC = Math.min(sel.range.start.col, sel.range.end.col);
+            const maxC = Math.max(sel.range.start.col, sel.range.end.col);
+            if (row >= minR && row <= maxR && col >= minC && col <= maxC)
+                return true;
+        }
+        return sel.selectedRows.has(row) || sel.selectedCols.has(col);
+    }
+    /** Check if a cell is the active cell. */
+    isCellActive(row, col) {
+        const ac = this.selection().activeCell;
+        return ac?.row === row && ac?.col === col;
+    }
+    // ── Refresh ──
+    /** Force recalculation by re-setting data. */
+    refresh() {
+        this.rowData.update((r) => [...r]);
+        this.columnStates.update((s) => new Map(s));
+    }
+    // ── Destroy ──
+    destroy() {
+        this.pluginHost.destroy();
+    }
+}
+
+/**
+ * SortPlugin manages multi-column sorting.
+ * Sorts the engine's rows by the active sort criteria.
+ */
+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));
+}
+
+/**
+ * FilterPlugin applies column-level filters to the row set.
+ * Stores original rows and restores on clear.
+ */
+class FilterPlugin {
+    constructor() {
+        this.name = 'filter';
+        this.priority = 20;
+        this._engine = null;
+        this._originalRows = [];
+    }
+    onInit(engine) {
+        this._engine = engine;
+        this._originalRows = engine.rowData();
+    }
+    /** Apply filter criteria. */
+    applyFilter(criteria, mode) {
+        if (!this._engine)
+            return;
+        if (criteria.length === 0) {
+            this._engine.rowData.set([...this._originalRows]);
+            return;
+        }
+        this._originalRows = this._engine.rowData();
+        const filtered = this._originalRows.filter((row) => {
+            const results = criteria.map((c) => matchesCriterion(row.cells[c.colId]?.value, c));
+            return mode === 'and' ? results.every(Boolean) : results.some(Boolean);
+        });
+        this._engine.rowData.set(filtered);
+    }
+    /** Clear all filters and restore original rows. */
+    clearFilter() {
+        if (!this._engine)
+            return;
+        this._engine.rowData.set([...this._originalRows]);
+    }
+    onBeforeFilter() {
+        return true;
+    }
+    onAfterFilter() {
+        // Sync original rows when data changes externally
+        if (this._engine) {
+            this._originalRows = this._engine.rowData();
+        }
+    }
+}
+function matchesCriterion(value, criterion) {
+    const v = value == null ? '' : String(value).toLowerCase();
+    const c = criterion.value == null ? '' : String(criterion.value).toLowerCase();
+    switch (criterion.operator) {
+        case 'equals':
+            return v === c;
+        case 'notEquals':
+            return v !== c;
+        case 'contains':
+            return v.includes(c);
+        case 'notContains':
+            return !v.includes(c);
+        case 'startsWith':
+            return v.startsWith(c);
+        case 'endsWith':
+            return v.endsWith(c);
+        case 'gt':
+            return Number(value) > Number(criterion.value);
+        case 'gte':
+            return Number(value) >= Number(criterion.value);
+        case 'lt':
+            return Number(value) < Number(criterion.value);
+        case 'lte':
+            return Number(value) <= Number(criterion.value);
+        case 'between': {
+            const num = Number(value);
+            return num >= Number(criterion.value) && num <= Number(criterion.valueTo);
+        }
+        case 'in': {
+            const arr = Array.isArray(criterion.value) ? criterion.value : [];
+            return arr.some((item) => String(item).toLowerCase() === v);
+        }
+        case 'empty':
+            return v === '';
+        case 'notEmpty':
+            return v !== '';
+        default:
+            return true;
+    }
+}
+
+/**
+ * SelectionPlugin manages cell/row/column/range selection state.
+ * Handles keyboard navigation and selection extension.
+ */
+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;
+    }
+}
+
+/**
+ * FormulaPlugin evaluates formulas in cells.
+ * Maintains a dependency graph for recalculation ordering.
+ */
+class FormulaPlugin {
+    constructor() {
+        this.name = 'formula';
+        this.priority = 50;
+        this._engine = null;
+        this._functions = new Map();
+        this._registerBuiltinFunctions();
+    }
+    onInit(engine) {
+        this._engine = engine;
+    }
+    onDestroy() {
+        this._functions.clear();
+    }
+    /** Register a custom function. */
+    registerFunction(fn) {
+        this._functions.set(fn.name.toUpperCase(), fn);
+    }
+    /** Evaluate a formula string. */
+    evaluate(formula, getCellValue) {
+        try {
+            const ast = this._parse(formula);
+            if (!ast)
+                return { value: null, error: '#PARSE!' };
+            const value = this._evalNode(ast, getCellValue);
+            return { value };
+        }
+        catch (e) {
+            return { value: null, error: e instanceof Error ? e.message : '#ERROR!' };
+        }
+    }
+    /** Build a dependency graph: which cells depend on which. */
+    buildDependencyGraph() {
+        const graph = new Map();
+        if (!this._engine)
+            return graph;
+        const rows = this._engine.rowData();
+        const cols = this._engine.columnDefs();
+        for (let r = 0; r < rows.length; r++) {
+            for (const col of cols) {
+                const val = rows[r].cells[col.id]?.value;
+                if (typeof val === 'string' && val.startsWith('=')) {
+                    const refs = this._extractRefs(val);
+                    graph.set(`${r}:${col.id}`, refs);
+                }
+            }
+        }
+        return graph;
+    }
+    /** Topologically sort cells by their dependencies (recalc order). */
+    getRecalcOrder() {
+        const graph = this.buildDependencyGraph();
+        const visited = new Set();
+        const order = [];
+        const visit = (cell, stack) => {
+            if (visited.has(cell))
+                return;
+            if (stack.has(cell))
+                return;
+            stack.add(cell);
+            const deps = graph.get(cell) ?? [];
+            for (const dep of deps) {
+                visit(dep, stack);
+            }
+            stack.delete(cell);
+            visited.add(cell);
+            order.push(cell);
+        };
+        for (const cell of graph.keys()) {
+            visit(cell, new Set());
+        }
+        return order;
+    }
+    // ── Parser ──
+    _parse(formula) {
+        const expr = formula.startsWith('=') ? formula.slice(1) : formula;
+        try {
+            return this._parseExpression(expr, { pos: 0 });
+        }
+        catch {
+            return null;
+        }
+    }
+    _parseExpression(expr, ctx) {
+        return this._parseComparison(expr, ctx);
+    }
+    _parseComparison(expr, ctx) {
+        let left = this._parseConcat(expr, ctx);
+        this._skipSpaces(expr, ctx);
+        while (ctx.pos < expr.length) {
+            const ch = expr[ctx.pos];
+            if (ch === '=' || ch === '<' || ch === '>') {
+                let op;
+                if (ch === '=' && expr[ctx.pos + 1] !== '=') {
+                    op = '=';
+                    ctx.pos++;
+                }
+                else if (ch === '<' && expr[ctx.pos + 1] === '>') {
+                    op = '<>';
+                    ctx.pos += 2;
+                }
+                else if (ch === '<' && expr[ctx.pos + 1] === '=') {
+                    op = '<=';
+                    ctx.pos += 2;
+                }
+                else if (ch === '>' && expr[ctx.pos + 1] === '=') {
+                    op = '>=';
+                    ctx.pos += 2;
+                }
+                else if (ch === '>') {
+                    op = '>';
+                    ctx.pos++;
+                }
+                else {
+                    break;
+                }
+                const right = this._parseConcat(expr, ctx);
+                left = { type: 'binary_op', op: op, left, right };
+            }
+            else {
+                break;
+            }
+        }
+        return left;
+    }
+    _parseConcat(expr, ctx) {
+        let left = this._parseAddSub(expr, ctx);
+        this._skipSpaces(expr, ctx);
+        while (ctx.pos < expr.length && expr[ctx.pos] === '&') {
+            ctx.pos++;
+            const right = this._parseAddSub(expr, ctx);
+            left = { type: 'binary_op', op: '&', left, right };
+            this._skipSpaces(expr, ctx);
+        }
+        return left;
+    }
+    _parseAddSub(expr, ctx) {
+        let left = this._parseMulDiv(expr, ctx);
+        this._skipSpaces(expr, ctx);
+        while (ctx.pos < expr.length && (expr[ctx.pos] === '+' || expr[ctx.pos] === '-')) {
+            const op = expr[ctx.pos];
+            ctx.pos++;
+            const right = this._parseMulDiv(expr, ctx);
+            left = { type: 'binary_op', op, left, right };
+            this._skipSpaces(expr, ctx);
+        }
+        return left;
+    }
+    _parseMulDiv(expr, ctx) {
+        let left = this._parseUnary(expr, ctx);
+        this._skipSpaces(expr, ctx);
+        while (ctx.pos < expr.length && (expr[ctx.pos] === '*' || expr[ctx.pos] === '/')) {
+            const op = expr[ctx.pos];
+            ctx.pos++;
+            const right = this._parseUnary(expr, ctx);
+            left = { type: 'binary_op', op, left, right };
+            this._skipSpaces(expr, ctx);
+        }
+        return left;
+    }
+    _parseUnary(expr, ctx) {
+        this._skipSpaces(expr, ctx);
+        if (ctx.pos < expr.length && (expr[ctx.pos] === '-' || expr[ctx.pos] === '+')) {
+            const op = expr[ctx.pos];
+            ctx.pos++;
+            const operand = this._parseUnary(expr, ctx);
+            return { type: 'unary_op', op, operand };
+        }
+        return this._parsePrimary(expr, ctx);
+    }
+    _parsePrimary(expr, ctx) {
+        this._skipSpaces(expr, ctx);
+        if (ctx.pos >= expr.length) {
+            throw new Error('Unexpected end of expression');
+        }
+        const ch = expr[ctx.pos];
+        // String literal
+        if (ch === '"') {
+            ctx.pos++;
+            let str = '';
+            while (ctx.pos < expr.length && expr[ctx.pos] !== '"') {
+                str += expr[ctx.pos++];
+            }
+            if (ctx.pos < expr.length)
+                ctx.pos++;
+            return { type: 'string', value: str };
+        }
+        // Parenthesized expression
+        if (ch === '(') {
+            ctx.pos++;
+            const node = this._parseExpression(expr, ctx);
+            this._skipSpaces(expr, ctx);
+            if (ctx.pos < expr.length && expr[ctx.pos] === ')')
+                ctx.pos++;
+            return node;
+        }
+        // Number
+        if ((ch >= '0' && ch <= '9') || ch === '.') {
+            let numStr = '';
+            while (ctx.pos < expr.length &&
+                ((expr[ctx.pos] >= '0' && expr[ctx.pos] <= '9') || expr[ctx.pos] === '.')) {
+                numStr += expr[ctx.pos++];
+            }
+            return { type: 'number', value: parseFloat(numStr) };
+        }
+        // Boolean
+        const upper = expr.slice(ctx.pos).toUpperCase();
+        if (upper.startsWith('TRUE')) {
+            ctx.pos += 4;
+            return { type: 'boolean', value: true };
+        }
+        if (upper.startsWith('FALSE')) {
+            ctx.pos += 5;
+            return { type: 'boolean', value: false };
+        }
+        // Cell reference, range, or function call
+        if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
+            let name = '';
+            while (ctx.pos < expr.length && /[A-Za-z0-9_]/.test(expr[ctx.pos])) {
+                name += expr[ctx.pos++];
+            }
+            this._skipSpaces(expr, ctx);
+            // Range reference (e.g. A1:B5)
+            if (ctx.pos < expr.length && expr[ctx.pos] === ':') {
+                ctx.pos++;
+                const end = this._parseCellRef(expr, ctx);
+                const startParsed = parseCellRefStr(name);
+                return {
+                    type: 'range_ref',
+                    startCol: startParsed.col,
+                    startRow: startParsed.row,
+                    endCol: end.col,
+                    endRow: end.row,
+                };
+            }
+            // Function call
+            if (ctx.pos < expr.length && expr[ctx.pos] === '(') {
+                ctx.pos++;
+                const args = [];
+                while (ctx.pos < expr.length && expr[ctx.pos] !== ')') {
+                    args.push(this._parseExpression(expr, ctx));
+                    this._skipSpaces(expr, ctx);
+                    if (ctx.pos < expr.length && expr[ctx.pos] === ',')
+                        ctx.pos++;
+                    this._skipSpaces(expr, ctx);
+                }
+                if (ctx.pos < expr.length)
+                    ctx.pos++;
+                return { type: 'function_call', name: name.toUpperCase(), args };
+            }
+            // Cell reference
+            const ref = parseCellRefStr(name);
+            return { type: 'cell_ref', col: ref.col, row: ref.row };
+        }
+        throw new Error(`Unexpected character: ${ch}`);
+    }
+    _parseCellRef(expr, ctx) {
+        let name = '';
+        while (ctx.pos < expr.length && /[A-Za-z0-9_]/.test(expr[ctx.pos])) {
+            name += expr[ctx.pos++];
+        }
+        return parseCellRefStr(name);
+    }
+    _skipSpaces(expr, ctx) {
+        while (ctx.pos < expr.length && expr[ctx.pos] === ' ')
+            ctx.pos++;
+    }
+    // ── Evaluator ──
+    _evalNode(node, getCellValue) {
+        switch (node.type) {
+            case 'number':
+                return node.value;
+            case 'string':
+                return node.value;
+            case 'boolean':
+                return node.value;
+            case 'cell_ref': {
+                const refNode = node;
+                const ref = `${refNode.col}${refNode.row}`;
+                const val = getCellValue(ref);
+                if (typeof val === 'string' && val.startsWith('=')) {
+                    const result = this.evaluate(val, getCellValue);
+                    return result.value;
+                }
+                return val;
+            }
+            case 'binary_op': {
+                const binNode = node;
+                const l = this._evalNode(binNode.left, getCellValue);
+                const r = this._evalNode(binNode.right, getCellValue);
+                return this._evalBinaryOp(binNode.op, l, r);
+            }
+            case 'unary_op': {
+                const unaryNode = node;
+                const val = this._evalNode(unaryNode.operand, getCellValue);
+                if (unaryNode.op === '-')
+                    return -val;
+                return val;
+            }
+            case 'function_call': {
+                const fnNode = node;
+                const fn = this._functions.get(fnNode.name);
+                if (!fn)
+                    throw new Error(`Unknown function: ${fnNode.name}`);
+                const args = fnNode.args.map((a) => this._evalNode(a, getCellValue));
+                return fn.fn(args);
+            }
+            case 'range_ref':
+                return 0;
+            default:
+                return null;
+        }
+    }
+    _evalBinaryOp(op, l, r) {
+        const ln = typeof l === 'number' ? l : parseFloat(String(l)) || 0;
+        const rn = typeof r === 'number' ? r : parseFloat(String(r)) || 0;
+        switch (op) {
+            case '+':
+                return ln + rn;
+            case '-':
+                return ln - rn;
+            case '*':
+                return ln * rn;
+            case '/':
+                return rn !== 0 ? ln / rn : null;
+            case '&':
+                return String(l ?? '') + String(r ?? '');
+            case '=':
+                return l === r || ln === rn;
+            case '<>':
+                return l !== r && ln !== rn;
+            case '>':
+                return ln > rn;
+            case '<':
+                return ln < rn;
+            case '>=':
+                return ln >= rn;
+            case '<=':
+                return ln <= rn;
+            default:
+                return 0;
+        }
+    }
+    _extractRefs(formula) {
+        const refs = [];
+        const regex = /([A-Z]+)(\d+)/gi;
+        let match;
+        while ((match = regex.exec(formula)) !== null) {
+            refs.push(`${match[1].toUpperCase()}${match[2]}`);
+        }
+        return refs;
+    }
+    // ── Built-in Functions ──
+    _registerBuiltinFunctions() {
+        const fns = [
+            {
+                name: 'SUM',
+                minArgs: 1,
+                maxArgs: Infinity,
+                fn: (args) => args.reduce((s, v) => s + (Number(v) || 0), 0),
+            },
+            {
+                name: 'AVERAGE',
+                minArgs: 1,
+                maxArgs: Infinity,
+                fn: (args) => {
+                    const nums = args.map(Number).filter((n) => !isNaN(n));
+                    return nums.length ? nums.reduce((s, v) => s + v, 0) / nums.length : 0;
+                },
+            },
+            {
+                name: 'COUNT',
+                minArgs: 1,
+                maxArgs: Infinity,
+                fn: (args) => args.filter((v) => v != null && v !== '').length,
+            },
+            {
+                name: 'MIN',
+                minArgs: 1,
+                maxArgs: Infinity,
+                fn: (args) => Math.min(...args.map(Number).filter((n) => !isNaN(n))),
+            },
+            {
+                name: 'MAX',
+                minArgs: 1,
+                maxArgs: Infinity,
+                fn: (args) => Math.max(...args.map(Number).filter((n) => !isNaN(n))),
+            },
+            {
+                name: 'IF',
+                minArgs: 3,
+                maxArgs: 3,
+                fn: (args) => (args[0] ? args[1] : args[2]),
+            },
+            {
+                name: 'AND',
+                minArgs: 1,
+                maxArgs: Infinity,
+                fn: (args) => args.every(Boolean),
+            },
+            {
+                name: 'OR',
+                minArgs: 1,
+                maxArgs: Infinity,
+                fn: (args) => args.some(Boolean),
+            },
+            {
+                name: 'NOT',
+                minArgs: 1,
+                maxArgs: 1,
+                fn: (args) => !args[0],
+            },
+            {
+                name: 'CONCAT',
+                minArgs: 1,
+                maxArgs: Infinity,
+                fn: (args) => args.join(''),
+            },
+            {
+                name: 'ROUND',
+                minArgs: 1,
+                maxArgs: 2,
+                fn: (args) => {
+                    const decimals = args[1] != null ? Number(args[1]) : 0;
+                    return Math.round(Number(args[0]) * Math.pow(10, decimals)) / Math.pow(10, decimals);
+                },
+            },
+            { name: 'ABS', minArgs: 1, maxArgs: 1, fn: (args) => Math.abs(Number(args[0])) },
+            {
+                name: 'POWER',
+                minArgs: 2,
+                maxArgs: 2,
+                fn: (args) => Math.pow(Number(args[0]), Number(args[1])),
+            },
+            { name: 'SQRT', minArgs: 1, maxArgs: 1, fn: (args) => Math.sqrt(Number(args[0])) },
+            { name: 'LEN', minArgs: 1, maxArgs: 1, fn: (args) => String(args[0]).length },
+            { name: 'UPPER', minArgs: 1, maxArgs: 1, fn: (args) => String(args[0]).toUpperCase() },
+            { name: 'LOWER', minArgs: 1, maxArgs: 1, fn: (args) => String(args[0]).toLowerCase() },
+            { name: 'TRIM', minArgs: 1, maxArgs: 1, fn: (args) => String(args[0]).trim() },
+        ];
+        for (const fn of fns) {
+            this._functions.set(fn.name, fn);
+        }
+    }
+}
+function parseCellRefStr(ref) {
+    const match = ref.match(/^([A-Z]+)(\d+)$/i);
+    if (!match)
+        throw new Error(`Invalid cell reference: ${ref}`);
+    return { col: match[1].toUpperCase(), row: parseInt(match[2], 10) };
+}
+
+/**
+ * ClipboardPlugin handles copy/paste/cut operations.
+ * Reads from and writes to the system clipboard via the Clipboard API.
+ */
+class ClipboardPlugin {
+    constructor() {
+        this.name = 'clipboard';
+        this.priority = 30;
+        this._engine = null;
+        this._cutCells = null;
+    }
+    onInit(engine) {
+        this._engine = engine;
+    }
+    /** Copy the current selection to the clipboard. */
+    async copy() {
+        if (!this._engine)
+            return;
+        const sel = this._engine.selection();
+        if (!sel.range)
+            return;
+        const tsv = this._selectionToTsv(sel.range.start.row, sel.range.start.col, sel.range.end.row, sel.range.end.col);
+        try {
+            await navigator.clipboard.writeText(tsv);
+        }
+        catch {
+            // Fallback: use a temporary textarea
+            this._copyToTextarea(tsv);
+        }
+    }
+    /** Cut the current selection (copy + clear). */
+    async cut() {
+        if (!this._engine)
+            return;
+        const sel = this._engine.selection();
+        if (!sel.range)
+            return;
+        const startRow = Math.min(sel.range.start.row, sel.range.end.row);
+        const startCol = Math.min(sel.range.start.col, sel.range.end.col);
+        const endRow = Math.max(sel.range.start.row, sel.range.end.row);
+        const endCol = Math.max(sel.range.start.col, sel.range.end.col);
+        this._cutCells = [];
+        const rows = [...this._engine.rowData()];
+        const cols = this._engine.columnDefs();
+        for (let r = startRow; r <= endRow; r++) {
+            for (let c = startCol; c <= endCol; c++) {
+                const colId = cols[c]?.id;
+                if (colId) {
+                    this._cutCells.push({ row: r, col: c, value: rows[r]?.cells[colId]?.value ?? null });
+                }
+            }
+        }
+        await this.copy();
+        this.clearSelectionContent();
+    }
+    /** Paste clipboard content starting at the active cell. */
+    async paste() {
+        if (!this._engine)
+            return;
+        const sel = this._engine.selection();
+        const activeCell = sel.activeCell;
+        if (!activeCell)
+            return;
+        let text;
+        try {
+            text = await navigator.clipboard.readText();
+        }
+        catch {
+            return;
+        }
+        if (!text)
+            return;
+        const lines = text.split('\n').filter((l) => l.length > 0);
+        const cols = this._engine.columnDefs();
+        const rows = [...this._engine.rowData()];
+        const startRow = activeCell.row;
+        const startCol = activeCell.col;
+        for (let r = 0; r < lines.length; r++) {
+            const cells = lines[r].split('\t');
+            const targetRow = startRow + r;
+            if (targetRow >= rows.length)
+                break;
+            for (let c = 0; c < cells.length; c++) {
+                const targetCol = startCol + c;
+                if (targetCol >= cols.length)
+                    break;
+                const colId = cols[targetCol].id;
+                const rowData = rows[targetRow];
+                if (rowData) {
+                    const raw = cells[c].trim();
+                    const value = parseClipboardValue(raw);
+                    rows[targetRow] = {
+                        ...rowData,
+                        cells: { ...rowData.cells, [colId]: { value, meta: rowData.cells[colId]?.meta } },
+                    };
+                }
+            }
+        }
+        this._engine.rowData.set(rows);
+    }
+    /** Clear the content of selected cells. */
+    clearSelectionContent() {
+        if (!this._engine)
+            return;
+        const sel = this._engine.selection();
+        if (!sel.range)
+            return;
+        const startRow = Math.min(sel.range.start.row, sel.range.end.row);
+        const startCol = Math.min(sel.range.start.col, sel.range.end.col);
+        const endRow = Math.max(sel.range.start.row, sel.range.end.row);
+        const endCol = Math.max(sel.range.start.col, sel.range.end.col);
+        const rows = [...this._engine.rowData()];
+        const cols = this._engine.columnDefs();
+        for (let r = startRow; r <= endRow; r++) {
+            for (let c = startCol; c <= endCol; c++) {
+                const colId = cols[c]?.id;
+                if (colId && rows[r]) {
+                    rows[r] = {
+                        ...rows[r],
+                        cells: { ...rows[r].cells, [colId]: { value: null, meta: rows[r].cells[colId]?.meta } },
+                    };
+                }
+            }
+        }
+        this._engine.rowData.set(rows);
+    }
+    _selectionToTsv(startRow, startCol, endRow, endCol) {
+        if (!this._engine)
+            return '';
+        const rows = this._engine.rowData();
+        const cols = this._engine.columnDefs();
+        const minRow = Math.min(startRow, endRow);
+        const maxRow = Math.max(startRow, endRow);
+        const minCol = Math.min(startCol, endCol);
+        const maxCol = Math.max(startCol, endCol);
+        const lines = [];
+        for (let r = minRow; r <= maxRow; r++) {
+            const cells = [];
+            for (let c = minCol; c <= maxCol; c++) {
+                const colId = cols[c]?.id;
+                const val = colId ? rows[r]?.cells[colId]?.value : null;
+                cells.push(val == null ? '' : String(val));
+            }
+            lines.push(cells.join('\t'));
+        }
+        return lines.join('\n');
+    }
+    _copyToTextarea(text) {
+        const ta = document.createElement('textarea');
+        ta.value = text;
+        ta.style.position = 'fixed';
+        ta.style.left = '-9999px';
+        document.body.appendChild(ta);
+        ta.select();
+        document.execCommand('copy');
+        document.body.removeChild(ta);
+    }
+}
+function parseClipboardValue(raw) {
+    if (raw === '')
+        return null;
+    if (raw === 'TRUE')
+        return true;
+    if (raw === 'FALSE')
+        return false;
+    const num = Number(raw);
+    if (!isNaN(num) && raw !== '')
+        return num;
+    return raw;
+}
+
+/**
+ * UndoPlugin provides undo/redo by maintaining a history stack.
+ * Captures snapshots before mutations.
+ */
+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);
+        }
+    }
+}
+
+/**
+ * ValidationPlugin validates cell values against registered rules.
+ */
+class ValidationPlugin {
+    constructor() {
+        this.name = 'validation';
+        this.priority = 40;
+        this._engine = null;
+        this._rules = new Map();
+    }
+    onInit(engine) {
+        this._engine = engine;
+    }
+    /** Register a validation rule for a column. */
+    addRule(rule) {
+        this._rules.set(rule.colId, rule.validator);
+    }
+    /** Remove a validation rule. */
+    removeRule(colId) {
+        this._rules.delete(colId);
+    }
+    /** Validate a single cell value. Returns null if valid, error string if not. */
+    validate(colId, value) {
+        const rule = this._rules.get(colId);
+        return rule ? rule(value) : null;
+    }
+    /** Validate all cells and return errors indexed by "row:colId". */
+    validateAll() {
+        const errors = new Map();
+        if (!this._engine)
+            return errors;
+        const rows = this._engine.rowData();
+        const cols = this._engine.columnDefs();
+        for (let r = 0; r < rows.length; r++) {
+            for (const col of cols) {
+                const val = rows[r].cells[col.id]?.value;
+                const err = this.validate(col.id, val);
+                if (err) {
+                    const key = `${r}:${col.id}`;
+                    errors.set(key, [err]);
+                }
+            }
+        }
+        return errors;
+    }
+    onBeforeEdit(_rowIndex, _colId) {
+        return true;
+    }
+    onAfterEdit(rowIndex, colId, _oldValue, newValue) {
+        const err = this.validate(colId, newValue);
+        if (err && this._engine) {
+            const rows = [...this._engine.rowData()];
+            const row = rows[rowIndex];
+            if (row) {
+                const cell = row.cells[colId];
+                rows[rowIndex] = {
+                    ...row,
+                    cells: {
+                        ...row.cells,
+                        [colId]: {
+                            value: newValue,
+                            meta: { ...cell?.meta, errors: [err], type: cell?.meta?.type ?? 'text' },
+                        },
+                    },
+                };
+                this._engine.rowData.set(rows);
+            }
+        }
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ClipboardPlugin, FilterPlugin, FormulaPlugin, PluginHost, SelectionPlugin, SortPlugin, SpreadsheetEngine, UndoPlugin, ValidationPlugin, cellRef, cellsInRange, cloneRow, colIndexToLetter, colLetterToIndex, createEmptyRow, formatCellValue, generateRowId, isCellInRange, normalizeRange, parseCellRef, pinnedWidth };
+//# sourceMappingURL=ngxsmk-cdk-spreadsheet.mjs.map