@ngxsmk/cdk 1.3.1 → 2.0.0

package/esm2022/spreadsheet/spreadsheet-engine.mjs

@@ -0,0 +1,547 @@
+import { computed, signal } from '@angular/core';
+import { PluginHost } from './plugin/plugin-host';
+import { generateRowId, createEmptyRow } from './utils/cell-utils';
+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.
+ */
+export 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();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spreadsheet-engine.js","sourceRoot":"","sources":["../../../../../packages/cdk/spreadsheet/spreadsheet-engine.ts"],"names":[],"mappings":"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","sourcesContent":["import { computed, signal, type WritableSignal, type Signal } from '@angular/core';\nimport type {\n  CellValue,\n  CellAddress,\n  CellMeta,\n  ColumnDef,\n  ColumnState,\n  RowDef,\n  SelectionState,\n  SortState,\n  SortCriterion,\n  FilterState,\n  FilterCriterion,\n} from './models';\nimport type { SpreadsheetPlugin } from './plugin/plugin.types';\nimport { PluginHost } from './plugin/plugin-host';\nimport { generateRowId, createEmptyRow } from './utils/cell-utils';\n\n/** Density presets controlling row height and cell padding. */\nexport type SpreadsheetDensity = 'compact' | 'comfortable' | 'dense';\n\nexport interface SpreadsheetConfig {\n  /** Column definitions. */\n  columns?: ColumnDef[];\n  /** Initial row data. */\n  rows?: RowDef[];\n  /** Enable multi-column sorting. */\n  multiSort?: boolean;\n  /** Selection mode. */\n  selectionMode?: 'cell' | 'range' | 'row' | 'column' | 'none';\n  /** Density preset. */\n  density?: SpreadsheetDensity;\n  /** Enable inline editing. */\n  editable?: boolean;\n  /** Enable formula evaluation. */\n  formulas?: boolean;\n  /** Number of rows to render in the viewport buffer. */\n  bufferRows?: number;\n  /** Row height in px (used for virtual scroll calculations). */\n  rowHeight?: number;\n  /** Header height in px. */\n  headerHeight?: number;\n  /** Plugins to register. */\n  plugins?: SpreadsheetPlugin[];\n  /** Enable tree / hierarchical data. */\n  treeData?: boolean;\n  /** RTL layout. */\n  rtl?: boolean;\n  /** Frozen row count. */\n  frozenRows?: number;\n  /** Frozen column count. */\n  frozenColumns?: number;\n}\n\n/** Lifecycle hooks for before/after operations. */\nexport interface SpreadsheetLifecycleHooks {\n  beforeEdit: Signal<(rowIndex: number, colId: string) => boolean>;\n  afterEdit: Signal<\n    (rowIndex: number, colId: string, oldValue: CellValue, newValue: CellValue) => void\n  >;\n  beforeSort: Signal<(colId: string, direction: 'asc' | 'desc' | null) => boolean>;\n  afterSort: Signal<() => void>;\n  beforeFilter: Signal<() => boolean>;\n  afterFilter: Signal<() => void>;\n  beforeInsertRows: Signal<(count: number, atIndex: number) => boolean>;\n  afterInsertRows: Signal<(indices: number[]) => void>;\n  beforeDeleteRows: Signal<(indices: number[]) => boolean>;\n  afterDeleteRows: Signal<(indices: number[]) => void>;\n  beforeInsertColumns: Signal<(count: number, atIndex: number) => boolean>;\n  afterInsertColumns: Signal<(indices: number[]) => void>;\n  beforeDeleteColumns: Signal<(indices: number[]) => boolean>;\n  afterDeleteColumns: Signal<(indices: number[]) => void>;\n  beforeCopy: Signal<() => boolean>;\n  afterCopy: Signal<() => void>;\n  beforePaste: Signal<(data: string, startCell: CellAddress) => boolean>;\n  afterPaste: Signal<() => void>;\n}\n\nconst DENSITY_ROW_HEIGHT: Record<SpreadsheetDensity, number> = {\n  compact: 28,\n  comfortable: 36,\n  dense: 24,\n};\n\nconst DENSITY_HEADER_HEIGHT: Record<SpreadsheetDensity, number> = {\n  compact: 32,\n  comfortable: 40,\n  dense: 28,\n};\n\nconst DENSITY_CELL_PADDING: Record<SpreadsheetDensity, string> = {\n  compact: '2px 6px',\n  comfortable: '6px 10px',\n  dense: '2px 4px',\n};\n\n/**\n * SpreadsheetEngine — headless, signal-based state machine for spreadsheet data.\n * Zero DOM, zero Angular dependencies beyond signals.\n *\n * Supports: columns, rows, sorting, filtering, selection, editing,\n * undo/redo, clipboard, formulas, tree data, virtual scrolling state.\n */\nexport class SpreadsheetEngine {\n  // ── Core Data ──\n  readonly columnDefs: WritableSignal<ColumnDef[]>;\n  readonly rowData: WritableSignal<RowDef[]>;\n  readonly columnStates: WritableSignal<Map<string, ColumnState>>;\n\n  // ── State ──\n  readonly selection: WritableSignal<SelectionState>;\n  readonly sortState: WritableSignal<SortState>;\n  readonly filterState: WritableSignal<FilterState>;\n  readonly plugins: WritableSignal<SpreadsheetPlugin[]>;\n\n  // ── Editing ──\n  readonly editingCell: WritableSignal<CellAddress | null>;\n  readonly editingValue: WritableSignal<CellValue>;\n\n  // ── Config ──\n  readonly density: WritableSignal<SpreadsheetDensity>;\n  readonly editable: WritableSignal<boolean>;\n  readonly rtl: WritableSignal<boolean>;\n  readonly frozenRows: WritableSignal<number>;\n  readonly frozenColumns: WritableSignal<number>;\n\n  // ── Scroll State ──\n  readonly scrollTop: WritableSignal<number>;\n  readonly scrollLeft: WritableSignal<number>;\n  readonly viewportHeight: WritableSignal<number>;\n  readonly viewportWidth: WritableSignal<number>;\n\n  // ── Plugin Host ──\n  readonly pluginHost: PluginHost;\n\n  // ── Computed ──\n\n  /** Visible rows after filtering. */\n  readonly visibleRows: Signal<RowDef[]>;\n\n  /** Sorted + filtered rows. */\n  readonly displayRows: Signal<RowDef[]>;\n\n  /** Visible row range for virtual scrolling (startIndex, endIndex). */\n  readonly virtualRowRange: Signal<{\n    start: number;\n    end: number;\n    offsetY: number;\n    totalHeight: number;\n  }>;\n\n  /** Visible column range for horizontal virtual scrolling. */\n  readonly virtualColRange: Signal<{\n    start: number;\n    end: number;\n    offsetX: number;\n    totalWidth: number;\n  }>;\n\n  /** Row height for current density. */\n  readonly rowHeight: Signal<number>;\n\n  /** Header height for current density. */\n  readonly headerHeight: Signal<number>;\n\n  /** Cell padding for current density. */\n  readonly cellPadding: Signal<string>;\n\n  /** Total number of rows. */\n  readonly totalRows: Signal<number>;\n\n  /** Total number of columns. */\n  readonly totalColumns: Signal<number>;\n\n  /** Total scrollable height. */\n  readonly totalHeight: Signal<number>;\n\n  /** Total scrollable width. */\n  readonly totalWidth: Signal<number>;\n\n  /** Visible (non-hidden) columns. */\n  readonly visibleColumns: Signal<ColumnDef[]>;\n\n  /** Pinned left columns. */\n  readonly pinnedLeftColumns: Signal<ColumnDef[]>;\n\n  /** Pinned right columns. */\n  readonly pinnedRightColumns: Signal<ColumnDef[]>;\n\n  /** Unpinned (scrollable) columns. */\n  readonly unpinnedColumns: Signal<ColumnDef[]>;\n\n  /** Column width map for computed widths. */\n  readonly columnWidths: Signal<Map<string, number>>;\n\n  // ── Lifecycle ──\n  readonly lifecycle: SpreadsheetLifecycleHooks;\n\n  private _config: SpreadsheetConfig;\n\n  constructor(config: SpreadsheetConfig = {}) {\n    this._config = config;\n    this.pluginHost = new PluginHost();\n\n    // Density\n    this.density = signal(config.density ?? 'comfortable');\n    this.editable = signal(config.editable ?? true);\n    this.rtl = signal(config.rtl ?? false);\n    this.frozenRows = signal(config.frozenRows ?? 0);\n    this.frozenColumns = signal(config.frozenColumns ?? 0);\n\n    // Row/column height computed from density\n    this.rowHeight = computed(() => DENSITY_ROW_HEIGHT[this.density()]);\n    this.headerHeight = computed(() => DENSITY_HEADER_HEIGHT[this.density()]);\n    this.cellPadding = computed(() => DENSITY_CELL_PADDING[this.density()]);\n\n    // Column definitions\n    this.columnDefs = signal(config.columns ?? []);\n\n    // Column states (width, visibility, pin, sort)\n    const initialStates = new Map<string, ColumnState>();\n    (config.columns ?? []).forEach((col, idx) => {\n      initialStates.set(col.id, {\n        id: col.id,\n        width: col.width ?? 150,\n        visible: col.visible !== false,\n        pinned: col.pinned ?? false,\n        sort: col.sort ?? null,\n        sortIndex: undefined,\n        order: idx,\n      });\n    });\n    this.columnStates = signal(initialStates);\n\n    // Row data\n    this.rowData = signal(config.rows ?? []);\n\n    // Selection\n    this.selection = signal<SelectionState>({\n      activeCell: null,\n      range: null,\n      selectedRows: new Set(),\n      selectedCols: new Set(),\n      mode: config.selectionMode ?? 'cell',\n      dragging: false,\n    });\n\n    // Sort\n    this.sortState = signal<SortState>({\n      criteria: (config.columns ?? [])\n        .filter((c) => c.sort)\n        .map((c, i) => ({ colId: c.id, direction: c.sort!, index: i })),\n      multiSort: config.multiSort ?? false,\n    });\n\n    // Filter\n    this.filterState = signal<FilterState>({ criteria: [], mode: 'and' });\n\n    // Editing\n    this.editingCell = signal(null);\n    this.editingValue = signal(null);\n\n    // Scroll\n    this.scrollTop = signal(0);\n    this.scrollLeft = signal(0);\n    this.viewportHeight = signal(600);\n    this.viewportWidth = signal(800);\n\n    // Plugins\n    this.plugins = signal(config.plugins ?? []);\n\n    // Lifecycle hooks\n    this.lifecycle = {\n      beforeEdit: signal(() => true),\n      afterEdit: signal(() => {\n        /* noop */\n      }),\n      beforeSort: signal(() => true),\n      afterSort: signal(() => {\n        /* noop */\n      }),\n      beforeFilter: signal(() => true),\n      afterFilter: signal(() => {\n        /* noop */\n      }),\n      beforeInsertRows: signal(() => true),\n      afterInsertRows: signal(() => {\n        /* noop */\n      }),\n      beforeDeleteRows: signal(() => true),\n      afterDeleteRows: signal(() => {\n        /* noop */\n      }),\n      beforeInsertColumns: signal(() => true),\n      afterInsertColumns: signal(() => {\n        /* noop */\n      }),\n      beforeDeleteColumns: signal(() => true),\n      afterDeleteColumns: signal(() => {\n        /* noop */\n      }),\n      beforeCopy: signal(() => true),\n      afterCopy: signal(() => {\n        /* noop */\n      }),\n      beforePaste: signal(() => true),\n      afterPaste: signal(() => {\n        /* noop */\n      }),\n    };\n\n    // ── Computed ──\n\n    this.visibleColumns = computed(() => {\n      const states = this.columnStates();\n      return this.columnDefs().filter((col) => {\n        const st = states.get(col.id);\n        return st?.visible ?? true;\n      });\n    });\n\n    this.pinnedLeftColumns = computed(() =>\n      this.visibleColumns().filter((c) => c.pinned === 'left'),\n    );\n\n    this.pinnedRightColumns = computed(() =>\n      this.visibleColumns().filter((c) => c.pinned === 'right'),\n    );\n\n    this.unpinnedColumns = computed(() => this.visibleColumns().filter((c) => !c.pinned));\n\n    this.columnWidths = computed(() => {\n      const states = this.columnStates();\n      const widths = new Map<string, number>();\n      for (const col of this.columnDefs()) {\n        widths.set(col.id, states.get(col.id)?.width ?? col.width ?? 150);\n      }\n      return widths;\n    });\n\n    this.totalColumns = computed(() => this.visibleColumns().length);\n\n    this.visibleRows = computed(() => {\n      return this.rowData();\n    });\n\n    this.displayRows = computed(() => {\n      return this.visibleRows();\n    });\n\n    this.totalRows = computed(() => this.displayRows().length);\n\n    this.rowHeight = computed(() => DENSITY_ROW_HEIGHT[this.density()]);\n\n    this.totalHeight = computed(() => this.totalRows() * this.rowHeight());\n\n    this.totalWidth = computed(() => {\n      const widths = this.columnWidths();\n      let total = 0;\n      for (const col of this.visibleColumns()) {\n        total += widths.get(col.id) ?? 150;\n      }\n      return total;\n    });\n\n    // Virtual scroll range — which rows are visible\n    this.virtualRowRange = computed(() => {\n      const rh = this.rowHeight();\n      const vh = this.viewportHeight();\n      const st = this.scrollTop();\n      const total = this.totalRows();\n      const buffer = config.bufferRows ?? 5;\n\n      const start = Math.max(0, Math.floor(st / rh) - buffer);\n      const visibleCount = Math.ceil(vh / rh);\n      const end = Math.min(total, start + visibleCount + buffer * 2);\n\n      return {\n        start,\n        end,\n        offsetY: start * rh,\n        totalHeight: total * rh,\n      };\n    });\n\n    // Virtual scroll range — which columns are visible\n    this.virtualColRange = computed(() => {\n      const widths = this.columnWidths();\n      const vw = this.viewportWidth();\n      const sl = this.scrollLeft();\n      const cols = this.unpinnedColumns();\n      const buffer = 3;\n\n      let start = 0;\n      let end = cols.length;\n\n      // Find start column\n      let accWidth = 0;\n      for (let i = 0; i < cols.length; i++) {\n        const w = widths.get(cols[i].id) ?? 150;\n        if (accWidth + w > sl) {\n          start = Math.max(0, i - buffer);\n          break;\n        }\n        accWidth += w;\n      }\n\n      // Find end column\n      let accWidth2 = 0;\n      for (let i = start; i < cols.length; i++) {\n        accWidth2 += widths.get(cols[i].id) ?? 150;\n        if (accWidth2 > vw + sl) {\n          end = Math.min(cols.length, i + buffer + 1);\n          break;\n        }\n      }\n\n      // Recalculate offsetX\n      let finalOffsetX = 0;\n      for (let i = 0; i < start; i++) {\n        finalOffsetX += widths.get(cols[i].id) ?? 150;\n      }\n\n      return {\n        start,\n        end,\n        offsetX: finalOffsetX,\n        totalWidth: cols.reduce((sum, c) => sum + (widths.get(c.id) ?? 150), 0),\n      };\n    });\n\n    // Initialize plugins\n    this.pluginHost.init(this);\n  }\n\n  // ── Column Operations ──\n\n  /** Get column state by ID. */\n  getColumnState(colId: string): ColumnState | undefined {\n    return this.columnStates().get(colId);\n  }\n\n  /** Set column width. */\n  setColumnWidth(colId: string, width: number): void {\n    const states = new Map(this.columnStates());\n    const st = states.get(colId);\n    if (st) {\n      const col = this.columnDefs().find((c) => c.id === colId);\n      const min = col?.minWidth ?? 40;\n      const max = col?.maxWidth ?? 600;\n      states.set(colId, { ...st, width: Math.max(min, Math.min(max, width)) });\n      this.columnStates.set(states);\n    }\n  }\n\n  /** Toggle column visibility. */\n  toggleColumnVisibility(colId: string): void {\n    const states = new Map(this.columnStates());\n    const st = states.get(colId);\n    if (st) {\n      states.set(colId, { ...st, visible: !st.visible });\n      this.columnStates.set(states);\n    }\n  }\n\n  /** Set column sort direction. */\n  setColumnSort(colId: string, direction: 'asc' | 'desc' | null): void {\n    const states = new Map(this.columnStates());\n    const st = states.get(colId);\n    if (st) {\n      states.set(colId, { ...st, sort: direction });\n      this.columnStates.set(states);\n    }\n\n    // Update sort state\n    const current = this.sortState();\n    let criteria: SortCriterion[];\n\n    if (current.multiSort) {\n      const existing = current.criteria.filter((c) => c.colId !== colId);\n      if (direction) {\n        criteria = [...existing, { colId, direction, index: existing.length }];\n      } else {\n        criteria = existing;\n      }\n    } else {\n      // Single sort: clear other sorts\n      for (const [id, s] of states) {\n        if (id !== colId && s.sort) {\n          states.set(id, { ...s, sort: null });\n        }\n      }\n      this.columnStates.set(states);\n      criteria = direction ? [{ colId, direction, index: 0 }] : [];\n    }\n\n    this.sortState.set({ ...current, criteria });\n  }\n\n  /** Reorder columns. */\n  moveColumn(fromIndex: number, toIndex: number): void {\n    const cols = [...this.columnDefs()];\n    const [moved] = cols.splice(fromIndex, 1);\n    if (moved) {\n      cols.splice(toIndex, 0, moved);\n      this.columnDefs.set(cols);\n    }\n  }\n\n  // ── Row Operations ──\n\n  /** Insert rows at the given index. */\n  insertRows(count: number, atIndex?: number): number[] {\n    const index = atIndex ?? this.rowData().length;\n    const rows = [...this.rowData()];\n    const newIndices: number[] = [];\n\n    for (let i = 0; i < count; i++) {\n      const newRow = createEmptyRow(generateRowId(), this.columnDefs());\n      rows.splice(index + i, 0, newRow);\n      newIndices.push(index + i);\n    }\n\n    this.rowData.set(rows);\n    return newIndices;\n  }\n\n  /** Delete rows by index. */\n  deleteRows(indices: number[]): RowDef[] {\n    const sorted = [...indices].sort((a, b) => b - a);\n    const rows = [...this.rowData()];\n    const deleted: RowDef[] = [];\n\n    for (const idx of sorted) {\n      if (idx >= 0 && idx < rows.length) {\n        deleted.push(rows[idx]);\n        rows.splice(idx, 1);\n      }\n    }\n\n    this.rowData.set(rows);\n    return deleted;\n  }\n\n  // ── Cell Operations ──\n\n  /** Get a cell value. */\n  getCellValue(rowIndex: number, colId: string): CellValue {\n    return this.rowData()[rowIndex]?.cells[colId]?.value ?? null;\n  }\n\n  /** Set a cell value. */\n  setCellValue(rowIndex: number, colId: string, value: CellValue): void {\n    const rows = [...this.rowData()];\n    const row = rows[rowIndex];\n    if (!row) return;\n\n    rows[rowIndex] = {\n      ...row,\n      cells: {\n        ...row.cells,\n        [colId]: { value, meta: row.cells[colId]?.meta },\n      },\n    };\n\n    this.rowData.set(rows);\n  }\n\n  /** Get cell metadata. */\n  getCellMeta(rowIndex: number, colId: string): CellMeta | undefined {\n    return this.rowData()[rowIndex]?.cells[colId]?.meta;\n  }\n\n  /** Get a column definition by ID. */\n  getColumnDef(colId: string): ColumnDef | undefined {\n    return this.columnDefs().find((c) => c.id === colId);\n  }\n\n  /** Get the 0-based column index by ID. */\n  getColIndex(colId: string): number {\n    return this.visibleColumns().findIndex((c) => c.id === colId);\n  }\n\n  // ── Editing ──\n\n  /** Begin editing a cell. */\n  startEdit(rowIndex: number, colId: string): boolean {\n    if (!this.editable()) return false;\n    if (!this.pluginHost.beforeEdit(rowIndex, colId)) return false;\n\n    const value = this.getCellValue(rowIndex, colId);\n    this.editingCell.set({ row: rowIndex, col: this.getColIndex(colId) });\n    this.editingValue.set(value);\n    return true;\n  }\n\n  /** Commit the current edit. */\n  commitEdit(): void {\n    const cell = this.editingCell();\n    if (!cell) return;\n\n    const col = this.visibleColumns()[cell.col];\n    if (!col) return;\n\n    const oldValue = this.getCellValue(cell.row, col.id);\n    const newValue = this.editingValue();\n\n    if (oldValue !== newValue) {\n      this.setCellValue(cell.row, col.id, newValue);\n      this.pluginHost.afterEdit(cell.row, col.id, oldValue, newValue);\n    }\n\n    this.editingCell.set(null);\n  }\n\n  /** Cancel the current edit. */\n  cancelEdit(): void {\n    this.editingCell.set(null);\n    this.editingValue.set(null);\n  }\n\n  // ── Sort ──\n\n  /** Sort by a column (toggles direction). */\n  sortBy(colId: string): void {\n    const st = this.columnStates().get(colId);\n    if (!st) return;\n\n    const currentSort = st.sort;\n    let newDirection: 'asc' | 'desc' | null;\n\n    if (currentSort === null) {\n      newDirection = 'asc';\n    } else if (currentSort === 'asc') {\n      newDirection = 'desc';\n    } else {\n      newDirection = null;\n    }\n\n    if (!this.pluginHost.beforeSort(colId, newDirection)) return;\n\n    this.setColumnSort(colId, newDirection);\n    this.pluginHost.afterSort();\n  }\n\n  /** Clear all sorting. */\n  clearSort(): void {\n    const states = new Map(this.columnStates());\n    for (const [id, st] of states) {\n      if (st.sort) {\n        states.set(id, { ...st, sort: null, sortIndex: undefined });\n      }\n    }\n    this.columnStates.set(states);\n    this.sortState.set({ criteria: [], multiSort: this.sortState().multiSort });\n  }\n\n  // ── Filter ──\n\n  /** Apply a filter. */\n  applyFilter(\n    colId: string,\n    operator: FilterCriterion['operator'],\n    value: unknown,\n    valueTo?: unknown,\n  ): void {\n    const current = this.filterState();\n    const existing = current.criteria.filter((c) => c.colId !== colId);\n    const criteria = [...existing, { colId, operator, value, valueTo }];\n    this.filterState.set({ ...current, criteria });\n  }\n\n  /** Clear filter for a column. */\n  clearColumnFilter(colId: string): void {\n    const current = this.filterState();\n    this.filterState.set({\n      ...current,\n      criteria: current.criteria.filter((c) => c.colId !== colId),\n    });\n  }\n\n  /** Clear all filters. */\n  clearFilters(): void {\n    this.filterState.set({ criteria: [], mode: 'and' });\n  }\n\n  // ── Navigation ──\n\n  /** Move the active cell by delta. */\n  navigate(deltaRow: number, deltaCol: number): void {\n    const sel = this.selection();\n    const current = sel.activeCell ?? { row: 0, col: 0 };\n    const newRow = Math.max(0, Math.min(this.totalRows() - 1, current.row + deltaRow));\n    const newCol = Math.max(0, Math.min(this.totalColumns() - 1, current.col + deltaCol));\n\n    this.selection.set({\n      ...sel,\n      activeCell: { row: newRow, col: newCol },\n      range: { start: { row: newRow, col: newCol }, end: { row: newRow, col: newCol } },\n    });\n  }\n\n  /** Scroll to make a cell visible. */\n  scrollToCell(rowIndex: number, _colIndex: number): void {\n    const rh = this.rowHeight();\n    const cellTop = rowIndex * rh;\n    const cellBottom = cellTop + rh;\n\n    const st = this.scrollTop();\n    const vh = this.viewportHeight();\n\n    if (cellTop < st) {\n      this.scrollTop.set(cellTop);\n    } else if (cellBottom > st + vh) {\n      this.scrollTop.set(cellBottom - vh);\n    }\n  }\n\n  // ── Selection ──\n\n  /** Select a cell. */\n  selectCell(row: number, col: number): void {\n    this.selection.set({\n      ...this.selection(),\n      activeCell: { row, col },\n      range: { start: { row, col }, end: { row, col } },\n      mode: 'cell',\n    });\n  }\n\n  /** Select a range. */\n  selectRange(start: CellAddress, end: CellAddress): void {\n    this.selection.set({\n      ...this.selection(),\n      range: { start, end },\n      mode: 'range',\n    });\n  }\n\n  /** Select a row. */\n  selectRow(rowIndex: number): void {\n    const rows = new Set(this.selection().selectedRows);\n    if (rows.has(rowIndex)) {\n      rows.delete(rowIndex);\n    } else {\n      rows.add(rowIndex);\n    }\n    this.selection.set({ ...this.selection(), selectedRows: rows, mode: 'row' });\n  }\n\n  /** Select a column. */\n  selectColumn(colIndex: number): void {\n    const cols = new Set(this.selection().selectedCols);\n    if (cols.has(colIndex)) {\n      cols.delete(colIndex);\n    } else {\n      cols.add(colIndex);\n    }\n    this.selection.set({ ...this.selection(), selectedCols: cols, mode: 'column' });\n  }\n\n  /** Select all cells. */\n  selectAll(): void {\n    const allRows = new Set(Array.from({ length: this.totalRows() }, (_, i) => i));\n    const allCols = new Set(Array.from({ length: this.totalColumns() }, (_, i) => i));\n    this.selection.set({\n      activeCell: { row: 0, col: 0 },\n      range: {\n        start: { row: 0, col: 0 },\n        end: { row: this.totalRows() - 1, col: this.totalColumns() - 1 },\n      },\n      selectedRows: allRows,\n      selectedCols: allCols,\n      mode: 'range',\n      dragging: false,\n    });\n  }\n\n  /** Check if a cell is selected. */\n  isCellSelected(row: number, col: number): boolean {\n    const sel = this.selection();\n    if (sel.range) {\n      const minR = Math.min(sel.range.start.row, sel.range.end.row);\n      const maxR = Math.max(sel.range.start.row, sel.range.end.row);\n      const minC = Math.min(sel.range.start.col, sel.range.end.col);\n      const maxC = Math.max(sel.range.start.col, sel.range.end.col);\n      if (row >= minR && row <= maxR && col >= minC && col <= maxC) return true;\n    }\n    return sel.selectedRows.has(row) || sel.selectedCols.has(col);\n  }\n\n  /** Check if a cell is the active cell. */\n  isCellActive(row: number, col: number): boolean {\n    const ac = this.selection().activeCell;\n    return ac?.row === row && ac?.col === col;\n  }\n\n  // ── Refresh ──\n\n  /** Force recalculation by re-setting data. */\n  refresh(): void {\n    this.rowData.update((r) => [...r]);\n    this.columnStates.update((s) => new Map(s));\n  }\n\n  // ── Destroy ──\n\n  destroy(): void {\n    this.pluginHost.destroy();\n  }\n}\n"]}