@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/interface/insert-row.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnInsertRowProps } from "../hooks/use-on-insert-row";
+export declare const insertRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, onChangeCitations, onChangePivotTables, }: UseOnInsertRowProps<T, S>) => (sheetId: number, referenceRowIndex: number, numRows?: number) => void;
+//# sourceMappingURL=insert-row.d.ts.map

package/dist/esm/interface/insert-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-row.d.ts","sourceRoot":"","sources":["../../../interface/insert-row.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AASjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAGtE,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,6YAuB5D,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,MAClB,SAAS,MAAM,EAAE,mBAAmB,MAAM,EAAE,gBAAW,SAoNhE,CAAC"}

package/dist/esm/interface/insert-row.js

@@ -0,0 +1,158 @@
+import { Direction } from "@rowsncolumns/common-types";
+import { produceWithPatches } from "immer";
+import { cloneRowWithFormatting, createSheetDraft } from "../api/immer-utils";
+import { expandMergesOnRowInsert } from "../api/merges";
+import { shiftPivotsOnInsert } from "../api/pivot-range";
+import { updateRangedRulesOnStructuralChange } from "../api/range-rule-helpers";
+import { moveFilterView } from "../api/selection";
+import { updateFormulasForStructuralChange } from "../api/structural-formula-update";
+export const insertRow = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, onChangeCitations, onChangePivotTables, }) => {
+    return (sheetId, referenceRowIndex, numRows = 1) => {
+        if (numRows <= 0)
+            return;
+        enqueueStructureChange?.({
+            kind: "insert-row",
+            sheetId,
+            index: referenceRowIndex,
+            count: numRows,
+            rowCount,
+            columnCount,
+        });
+        const saveHistory = createHistory();
+        const recalcCells = new Map();
+        // Update tables: shift filter view if entirely below; extend the
+        // filter range when insertion lands inside.
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (const table of draft) {
+                    if (table.sheetId !== sheetId)
+                        continue;
+                    const { startRowIndex, endRowIndex } = table.range;
+                    if (referenceRowIndex <= startRowIndex) {
+                        moveFilterView(table, numRows, Direction.Down);
+                    }
+                    else if (referenceRowIndex <= endRowIndex) {
+                        table.range.endRowIndex += numRows;
+                    }
+                }
+            });
+            saveHistory({ tables: { patches, inversePatches } });
+            return nextState;
+        });
+        // Update data validations
+        onChangeDataValidations?.((prevValidations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
+                updateRangedRulesOnStructuralChange(draft, "insert", "row", referenceRowIndex, numRows, sheetId);
+            });
+            saveHistory({ dataValidations: { patches, inversePatches } });
+            return nextState;
+        });
+        // Update conditional formats
+        onChangeConditionalFormats?.((prevConditionalFormats) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
+                updateRangedRulesOnStructuralChange(draft, "insert", "row", referenceRowIndex, numRows, sheetId);
+            });
+            saveHistory({ conditionalFormats: { patches, inversePatches } });
+            return nextState;
+        });
+        // Shift pivot tables: source / pivotRange follow the same insert rule as
+        // any other sheet range; targetPosition shifts down if at or after the
+        // insertion point.
+        onChangePivotTables?.((prevPivots) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevPivots, (draft) => {
+                shiftPivotsOnInsert(draft, sheetId, "row", referenceRowIndex, numRows);
+            });
+            saveHistory({ pivotTables: { patches, inversePatches } });
+            return nextState;
+        });
+        // Update citations: shift only when insertion is BEFORE the citation
+        // range. Insertion within the range does NOT extend a citation.
+        onChangeCitations?.((prevCitations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                for (const citation of draft) {
+                    if (citation.range.sheetId !== sheetId)
+                        continue;
+                    if (referenceRowIndex <= citation.range.startRowIndex) {
+                        citation.range.startRowIndex += numRows;
+                        citation.range.endRowIndex += numRows;
+                    }
+                }
+            });
+            saveHistory({ citations: { patches, inversePatches } });
+            return nextState;
+        });
+        // Update sheet metadata (rowMetadata, basicFilter, frozen rows, merges,
+        // rowCount).
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (!sheet)
+                    return;
+                if (sheet.rowMetadata) {
+                    sheet.rowMetadata.splice(referenceRowIndex, 0, ...Array.from({ length: numRows }, () => null));
+                }
+                if (sheet.basicFilter) {
+                    const { startRowIndex, endRowIndex } = sheet.basicFilter.range;
+                    if (startRowIndex >= referenceRowIndex) {
+                        moveFilterView(sheet.basicFilter, numRows, Direction.Down);
+                    }
+                    if (referenceRowIndex > startRowIndex &&
+                        referenceRowIndex <= endRowIndex) {
+                        sheet.basicFilter.range.endRowIndex += numRows;
+                    }
+                }
+                if (sheet.frozenRowCount &&
+                    referenceRowIndex <= sheet.frozenRowCount) {
+                    sheet.frozenRowCount += numRows;
+                }
+                if (sheet.merges) {
+                    sheet.merges = expandMergesOnRowInsert(sheet.merges, referenceRowIndex, numRows);
+                }
+                sheet.rowCount = (sheet.rowCount ?? rowCount) + numRows;
+            });
+            saveHistory({ sheets: { patches, inversePatches } });
+            return nextState;
+        });
+        // Sheet data: run the three-pass formula update helper, then splice
+        // in the new rows.
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                updateFormulasForStructuralChange({
+                    draft,
+                    axis: "row",
+                    op: "insert",
+                    sheetId,
+                    referenceIndex: referenceRowIndex,
+                    count: numRows,
+                    rowCount,
+                    columnCount,
+                    getDependents,
+                    getGraphNodes,
+                    getGraphNodesInSheet,
+                    getSheetName,
+                    enqueueCalculation,
+                    enqueueGraphOperation,
+                    recalcCells,
+                    locale,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
+                const currentSheet = createSheetDraft(draft, sheetId, referenceRowIndex);
+                const formattingSourceRow = currentSheet[referenceRowIndex] ??
+                    currentSheet[referenceRowIndex - 1];
+                const newRows = Array.from({ length: numRows }, () => cloneRowWithFormatting(formattingSourceRow));
+                currentSheet.splice(referenceRowIndex, 0, ...newRows);
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+                selections: {
+                    undo: [...getSelections()],
+                    redo: [...getSelections()],
+                },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/insert-table-row.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import type { UseOnInsertTableRowProps } from "../hooks/use-on-insert-table-row";
+export declare const insertTableRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, }: UseOnInsertTableRowProps<T, S>) => (tableView: TableView, relativeRowIndex?: number, rowData?: Record<string, string | undefined | null>[]) => void;
+//# sourceMappingURL=insert-table-row.d.ts.map

package/dist/esm/interface/insert-table-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-table-row.d.ts","sourceRoot":"","sources":["../../../interface/insert-table-row.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAa5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAIjF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,iTAkBjE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,MAE7B,WAAW,SAAS,EACpB,mBAAmB,MAAM,EACzB,UAAU,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,SA+axD,CAAC"}

package/dist/esm/interface/insert-table-row.js

@@ -0,0 +1,314 @@
+import { Direction } from "@rowsncolumns/common-types";
+import { getCellUserEnteredValue, getExtendedValueFormula } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
+import { createSheetCellIdentifier, expandRangesInFormula } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { moveMergedCells } from "../api/merges";
+import { updateSheetRangeOnInsert } from "../api/range";
+import { moveFilterView } from "../api/selection";
+import { SheetCell } from "../sheet-cell";
+export const insertTableRow = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, }) => {
+    return (tableView, relativeRowIndex, rowData) => {
+        const referenceRowIndex = tableView.range.startRowIndex +
+            (relativeRowIndex ??
+                tableView.range.endRowIndex - tableView.range.startRowIndex + 1);
+        const numRows = rowData?.length ?? 1;
+        const { sheetId } = tableView;
+        enqueueStructureChange?.({
+            kind: "insert-table-row",
+            sheetId,
+            index: referenceRowIndex,
+            count: numRows,
+            rowCount,
+            startColumnIndex: tableView.range.startColumnIndex,
+            endColumnIndex: tableView.range.endColumnIndex,
+        });
+        const saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        // Update table position
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (const table of draft) {
+                    const startRowIndex = table.range.startRowIndex;
+                    const endRowIndex = table.range.endRowIndex;
+                    if (referenceRowIndex < startRowIndex) {
+                        moveFilterView(table, numRows, Direction.Down);
+                    }
+                    if (referenceRowIndex >= startRowIndex &&
+                        referenceRowIndex <= endRowIndex + 1) {
+                        table.range.endRowIndex += numRows;
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                tables: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update data validations
+        onChangeDataValidations?.((prevValidations) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevValidations, (draft) => {
+                for (let idx = draft.length - 1; idx >= 0; idx--) {
+                    const rule = draft[idx];
+                    const ranges = rule.ranges
+                        ?.map((range) => updateSheetRangeOnInsert(range, "row", referenceRowIndex, numRows, sheetId))
+                        .filter((range) => !!range) ??
+                        [];
+                    if (ranges.length) {
+                        rule.ranges = ranges;
+                    }
+                    else {
+                        draft.splice(idx, 1);
+                    }
+                }
+            });
+            saveHistory({
+                dataValidations: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update conditional formats
+        onChangeConditionalFormats?.((prevConditionalFormats) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevConditionalFormats, (draft) => {
+                for (let idx = draft.length - 1; idx >= 0; idx--) {
+                    const rule = draft[idx];
+                    const ranges = rule.ranges
+                        ?.map((range) => updateSheetRangeOnInsert(range, "row", referenceRowIndex, numRows, sheetId))
+                        .filter((range) => !!range) ??
+                        [];
+                    if (ranges.length) {
+                        rule.ranges = ranges;
+                    }
+                    else {
+                        draft.splice(idx, 1);
+                    }
+                }
+            });
+            saveHistory({
+                conditionalFormats: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheets
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet) {
+                    if (sheet.rowMetadata) {
+                        const newRowMetaData = [...Array(numRows)].map((_, index) => sheet.rowMetadata?.[referenceRowIndex + index]);
+                        sheet.rowMetadata.splice(referenceRowIndex, 0, ...newRowMetaData);
+                    }
+                    if (sheet.basicFilter) {
+                        // Check if basicFilter needs to be moved
+                        if (sheet.basicFilter.range.startRowIndex >= referenceRowIndex) {
+                            moveFilterView(sheet.basicFilter, numRows, Direction.Down);
+                        }
+                        // Check if basicFilter needs to extend
+                        if (referenceRowIndex >= sheet.basicFilter.range.startRowIndex &&
+                            referenceRowIndex <= sheet.basicFilter.range.endRowIndex) {
+                            sheet.basicFilter.range.endRowIndex += numRows;
+                        }
+                    }
+                    if (sheet.merges) {
+                        sheet.merges = moveMergedCells(sheet.merges, "row-insert", referenceRowIndex, numRows, (area) => {
+                            return (area.startColumnIndex >= tableView.range.startColumnIndex &&
+                                area.endColumnIndex <= tableView.range.endColumnIndex);
+                        });
+                    }
+                    sheet.rowCount = (sheet.rowCount ?? rowCount) + numRows;
+                }
+            });
+            // Save history
+            saveHistory({
+                sheets: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const totalRows = draft[sheetId]?.length ?? rowCount;
+                const sourceRange = {
+                    ...tableView.range,
+                    startRowIndex: referenceRowIndex,
+                };
+                const movedKeys = new Set();
+                /**
+                 * THREE-PASS FORMULA UPDATE STRATEGY:
+                 *
+                 * PASS 1 (lines below): Expand ranges when insertion point falls within them
+                 *   Example: Insert table row at 5, =SUM(A1:A10) → =SUM(A1:A11)
+                 *   This scans ALL formulas because any formula anywhere can reference the insertion range
+                 *
+                 * PASS 2 (after this loop): Shift references in formulas that DEPEND ON the moved cells
+                 *   Example: If A10 is moved to A11, formulas referencing A10 must update
+                 *   Uses dependency graph to find only affected formulas (efficient)
+                 *
+                 * PASS 3 (final loop): Shift references in formulas WITHIN the moved cells themselves
+                 *   Example: If A10 contains =A1+A2 and moves to A11, it becomes =A1+A2 (no change)
+                 *   But if it contains =A15, it needs adjustment based on sourceRange exclusion
+                 *
+                 * The 'movedKeys' Set ensures no formula is processed twice across passes 2 & 3.
+                 * Range expansion (Pass 1) doesn't interfere with reference shifting (Pass 2 & 3).
+                 */
+                // PASS 1: Expand ranges using dependency graph (OPTIMIZED!)
+                // Collect formulas that reference cells at the insertion point
+                const insertionRange = {
+                    startRowIndex: referenceRowIndex,
+                    endRowIndex: referenceRowIndex + numRows - 1,
+                    startColumnIndex: 1,
+                    endColumnIndex: columnCount,
+                };
+                const formulasToExpand = collectUniqueDependentsForRange({
+                    draft,
+                    sheetId,
+                    sourceRange: insertionRange,
+                    getDependents,
+                });
+                const sheetCell = new SheetCell();
+                for (const pos of formulasToExpand.values()) {
+                    const currentSheet = createSheetDraft(draft, sheetId, pos.rowIndex);
+                    const cellData = currentSheet[pos.rowIndex]?.values?.[pos.columnIndex];
+                    if (!cellData)
+                        continue;
+                    // Check if cell has a formula
+                    sheetCell.assign(pos.sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData);
+                    const formulaValue = sheetCell.formula;
+                    if (formulaValue) {
+                        const activeSheetName = getSheetName(pos.sheetId);
+                        const expandedFormula = expandRangesInFormula(formulaValue, referenceRowIndex, numRows, "row", activeSheetName);
+                        // Update the formula if it changed
+                        if (expandedFormula && expandedFormula !== formulaValue) {
+                            // Preserve stale effective value until recalculation completes
+                            sheetCell.setFormulaValue(expandedFormula, false);
+                            currentSheet[pos.rowIndex].values[pos.columnIndex] =
+                                sheetCell.getCellData();
+                            // Adjust row index for formulas at or below the insertion point
+                            // (they will shift down by `numRows` after the splice)
+                            const adjustedRowIndex = pos.sheetId === sheetId && pos.rowIndex >= referenceRowIndex
+                                ? pos.rowIndex + numRows
+                                : pos.rowIndex;
+                            enqueueCalculation?.({
+                                type: "add",
+                                position: {
+                                    sheetId: pos.sheetId,
+                                    rowIndex: adjustedRowIndex,
+                                    columnIndex: pos.columnIndex,
+                                },
+                                force: true,
+                            });
+                            recalcCells.set(createSheetCellIdentifier(pos.sheetId, adjustedRowIndex, pos.columnIndex), {
+                                sheetId: pos.sheetId,
+                                rowIndex: adjustedRowIndex,
+                                columnIndex: pos.columnIndex,
+                                force: true,
+                            });
+                        }
+                    }
+                }
+                // PASS 2: Collect and process formulas that DEPEND ON the moved cells
+                const dependents = collectUniqueDependentsForRange({
+                    draft,
+                    sheetId,
+                    sourceRange,
+                    getDependents,
+                });
+                for (const pos of dependents.values()) {
+                    moveFormulaAtPosition({
+                        draft,
+                        position: pos,
+                        activeSheetName: getSheetName(pos.sheetId),
+                        enqueueCalculation,
+                        enqueueGraphOperation,
+                        recalcCells,
+                        movedKeys,
+                        rowDelta: numRows,
+                        columnDelta: 0,
+                        sourceRange,
+                        locale,
+                        rowCount,
+                        columnCount,
+                        cellXfsRegistry,
+                        sharedStringRegistry,
+                    });
+                }
+                // PASS 3: Process formulas WITHIN the moved cells themselves
+                for (let rowIndex = referenceRowIndex; rowIndex < tableView.range.endRowIndex; rowIndex++) {
+                    const rowValues = draft[sheetId]?.[rowIndex]?.values;
+                    if (!rowValues) {
+                        continue;
+                    }
+                    for (let columnIndex = tableView.range.startColumnIndex; columnIndex < tableView.range.endColumnIndex; columnIndex++) {
+                        const cellData = rowValues?.[columnIndex];
+                        const hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(cellData));
+                        if (!hasFormula) {
+                            continue;
+                        }
+                        moveFormulaAtPosition({
+                            draft,
+                            position: { sheetId, rowIndex, columnIndex },
+                            enqueueCalculation,
+                            enqueueGraphOperation,
+                            recalcCells,
+                            movedKeys,
+                            rowDelta: numRows,
+                            columnDelta: 0,
+                            sourceRange,
+                            locale,
+                            rowCount,
+                            columnCount,
+                            cellXfsRegistry,
+                            sharedStringRegistry,
+                        });
+                    }
+                }
+                // Update values
+                for (let rowIndex = totalRows + numRows; rowIndex >= referenceRowIndex; rowIndex--) {
+                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    for (let columnIndex = tableView.range.endColumnIndex; columnIndex >= tableView.range.startColumnIndex; columnIndex--) {
+                        const previousValue = currentSheet[rowIndex - numRows]?.values?.[columnIndex];
+                        currentSheet[rowIndex].values[columnIndex] = previousValue;
+                    }
+                }
+                // Inserted rows: clone formatting from the row that shifted down (referenceRowIndex + numRows)
+                for (let r = 0; r < numRows; r++) {
+                    const rowIndex = referenceRowIndex + r;
+                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    const input = rowData?.[r];
+                    // Clone entire row formatting once
+                    const formatSourceRow = createSheetDraft(draft, sheetId, rowIndex + numRows);
+                    const tempCell = new SheetCell();
+                    for (let columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
+                        const sourceCell = formatSourceRow[rowIndex + numRows]?.values?.[columnIndex];
+                        const cloned = tempCell
+                            .assign(sheetId, { rowIndex, columnIndex }, sourceCell)
+                            .cloneWithFormatting();
+                        const relativeColumnIndex = columnIndex - tableView.range.startColumnIndex;
+                        const columnName = tableView.columns?.[relativeColumnIndex]?.name;
+                        const cellValue = columnName ? input?.[columnName] : undefined;
+                        if (cellValue !== undefined && cellValue !== null) {
+                            cloned.setUserEnteredValue(cellValue);
+                        }
+                        currentSheet[rowIndex].values[columnIndex] = cloned.getCellData();
+                        // Enqueue for calculation
+                        enqueueCalculation({
+                            type: "dirty",
+                            position: { rowIndex, columnIndex, sheetId },
+                        });
+                        recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), { sheetId, rowIndex, columnIndex });
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/interface-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=interface-cli.d.ts.map

package/dist/esm/interface/interface-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface-cli.d.ts","sourceRoot":"","sources":["../../../interface/interface-cli.ts"],"names":[],"mappings":""}

package/dist/esm/interface/interface-cli.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env bun
+import { Spreadsheet } from "./spreadsheet-interface";
+import { attachCalculationWorker, } from "@rowsncolumns/calculation-worker";
+class InlineWorkerScope extends EventTarget {
+    notifyParent;
+    constructor(notifyParent) {
+        super();
+        this.notifyParent = notifyParent;
+    }
+    postMessage(data) {
+        this.notifyParent(data);
+    }
+}
+class InlineWorker extends EventTarget {
+    scope;
+    disposeRuntime;
+    constructor(options) {
+        super();
+        this.scope = new InlineWorkerScope((message) => {
+            queueMicrotask(() => {
+                this.dispatchEvent(new MessageEvent("message", { data: message }));
+            });
+        });
+        this.disposeRuntime = attachCalculationWorker(this.scope, options);
+    }
+    postMessage(message) {
+        queueMicrotask(() => {
+            this.scope.dispatchEvent(new MessageEvent("message", { data: message }));
+        });
+    }
+    terminate() {
+        this.disposeRuntime.dispose();
+    }
+}
+const main = async () => {
+    const spreadsheet = new Spreadsheet({
+        createCalculationWorker: () => new InlineWorker(),
+    });
+    spreadsheet.sheets = [
+        { sheetId: 1, rowCount: 10, columnCount: 10, title: "Sheet1" },
+    ];
+    spreadsheet.sheetData = { 1: [] };
+    spreadsheet.changeBatch(1, {
+        startRowIndex: 1,
+        endRowIndex: 1,
+        startColumnIndex: 1,
+        endColumnIndex: 1,
+    }, [[3]]);
+    spreadsheet.changeBatch(1, {
+        startRowIndex: 1,
+        endRowIndex: 1,
+        startColumnIndex: 2,
+        endColumnIndex: 2,
+    }, [["=A1*4"]]);
+    spreadsheet.enqueueCalculation({
+        type: "add",
+        position: { sheetId: 1, rowIndex: 1, columnIndex: 2 },
+    });
+    const results = await spreadsheet.calculatePending();
+    console.log("calculation results", results);
+};
+void main();

package/dist/esm/interface/named-range-operations.d.ts

@@ -0,0 +1,19 @@
+import type { CellData, NamedRange } from "@rowsncolumns/spreadsheet";
+import type { useCalculation } from "../hooks/use-calculation";
+import type { UseSpreadsheetProps } from "../hooks/use-spreadsheet-state";
+import type { SpreadsheetPatch } from "../hooks/use-undo-redo";
+type UseOnCreateNamedRangeProps<T extends CellData> = {
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    onChangeNamedRanges: UseSpreadsheetProps<T>["onChangeNamedRanges"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+};
+type UseOnDeleteNamedRangeProps<T extends CellData> = {
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    onChangeNamedRanges: UseSpreadsheetProps<T>["onChangeNamedRanges"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+};
+export declare const createNamedRange: <T extends CellData>({ enqueueCalculation, createHistory, onChangeNamedRanges, }: UseOnCreateNamedRangeProps<T>) => (sheetId: number, namedRange: NamedRange) => void;
+export declare const deleteNamedRange: <T extends CellData>({ getDependents, enqueueCalculation, createHistory, onChangeNamedRanges, }: UseOnDeleteNamedRangeProps<T>) => (id: NamedRange["namedRangeId"]) => void;
+export {};
+//# sourceMappingURL=named-range-operations.d.ts.map

package/dist/esm/interface/named-range-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"named-range-operations.d.ts","sourceRoot":"","sources":["../../../interface/named-range-operations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAKtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D,KAAK,0BAA0B,CAAC,CAAC,SAAS,QAAQ,IAAI;IACpD,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,mBAAmB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;IACnE,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACtD,CAAC;AAEF,KAAK,0BAA0B,CAAC,CAAC,SAAS,QAAQ,IAAI;IACpD,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,mBAAmB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;IACnE,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACtD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,6DAIlD,0BAA0B,CAAC,CAAC,CAAC,MACtB,SAAS,MAAM,EAAE,YAAY,UAAU,SAsChD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,4EAKlD,0BAA0B,CAAC,CAAC,CAAC,MACtB,IAAI,UAAU,CAAC,cAAc,CAAC,SAiDvC,CAAC"}

package/dist/esm/interface/named-range-operations.js

@@ -0,0 +1,71 @@
+import { isStaticNode } from "@rowsncolumns/dag";
+import { iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+export const createNamedRange = ({ enqueueCalculation, createHistory, onChangeNamedRanges, }) => {
+    return (sheetId, namedRange) => {
+        const saveHistory = createHistory();
+        onChangeNamedRanges?.((prevNamedRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevNamedRanges, (draft) => {
+                // Check if there is a named range with the same name
+                const exists = draft.find((n) => n.name === namedRange.name);
+                if (!exists) {
+                    draft.push(namedRange);
+                    // Make cells dirty
+                    if (namedRange.range) {
+                        for (const [rowIndex, columnIndex] of iterateCellsInRange(namedRange.range)) {
+                            enqueueCalculation({
+                                position: {
+                                    rowIndex,
+                                    columnIndex,
+                                    sheetId,
+                                },
+                                type: "add",
+                            });
+                        }
+                    }
+                }
+            });
+            saveHistory({
+                namedRanges: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};
+export const deleteNamedRange = ({ getDependents, enqueueCalculation, createHistory, onChangeNamedRanges, }) => {
+    return (id) => {
+        const saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        onChangeNamedRanges?.((prevNamedRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevNamedRanges, (draft) => {
+                // Check if there is a named range with the same name
+                const index = draft.findIndex((n) => n.namedRangeId === id);
+                if (index !== -1) {
+                    const range = draft[index].range;
+                    // Make dependent dirty
+                    if (range) {
+                        for (const dependency of getDependents(range)) {
+                            if (isStaticNode(dependency)) {
+                                continue;
+                            }
+                            const { position } = dependency;
+                            enqueueCalculation({
+                                position,
+                                type: "dirty",
+                            });
+                            recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), position);
+                        }
+                    }
+                    draft.splice(index, 1);
+                }
+            });
+            saveHistory({
+                namedRanges: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+    };
+};