@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/interface/insert-note.js

@@ -0,0 +1,27 @@
+import { __read } from "tslib";
+import { produceWithPatches } from "immer";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+export var insertNote = function (_a) {
+    var createHistory = _a.createHistory, locale = _a.locale, onChangeSheetData = _a.onChangeSheetData;
+    return function (sheetId, _a, note) {
+        var rowIndex = _a.rowIndex, columnIndex = _a.columnIndex;
+        var saveHistory = createHistory();
+        // Update sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var _a, _b;
+                var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                var cellData = (_b = (_a = currentSheet[rowIndex]) === null || _a === void 0 ? void 0 : _a.values) === null || _b === void 0 ? void 0 : _b[columnIndex];
+                var sheetCell = new SheetCell(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, { locale: locale });
+                sheetCell.updateNote(note);
+                // Set cell data
+                currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/cjs/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/cjs/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/cjs/interface/insert-row.js

@@ -0,0 +1,188 @@
+import { __read, __spreadArray, __values } from "tslib";
+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 var insertRow = function (_a) {
+    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getSheetName = _a.getSheetName, getActiveCell = _a.getActiveCell, getSelections = _a.getSelections, getDependents = _a.getDependents, getGraphNodes = _a.getGraphNodes, getGraphNodesInSheet = _a.getGraphNodesInSheet, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeDataValidations = _a.onChangeDataValidations, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeCitations = _a.onChangeCitations, onChangePivotTables = _a.onChangePivotTables;
+    return function (sheetId, referenceRowIndex, numRows) {
+        if (numRows === void 0) { numRows = 1; }
+        if (numRows <= 0)
+            return;
+        enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+            kind: "insert-row",
+            sheetId: sheetId,
+            index: referenceRowIndex,
+            count: numRows,
+            rowCount: rowCount,
+            columnCount: columnCount,
+        });
+        var saveHistory = createHistory();
+        var recalcCells = new Map();
+        // Update tables: shift filter view if entirely below; extend the
+        // filter range when insertion lands inside.
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                var e_1, _a;
+                try {
+                    for (var draft_1 = __values(draft), draft_1_1 = draft_1.next(); !draft_1_1.done; draft_1_1 = draft_1.next()) {
+                        var table = draft_1_1.value;
+                        if (table.sheetId !== sheetId)
+                            continue;
+                        var _b = table.range, startRowIndex = _b.startRowIndex, endRowIndex = _b.endRowIndex;
+                        if (referenceRowIndex <= startRowIndex) {
+                            moveFilterView(table, numRows, Direction.Down);
+                        }
+                        else if (referenceRowIndex <= endRowIndex) {
+                            table.range.endRowIndex += numRows;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (draft_1_1 && !draft_1_1.done && (_a = draft_1.return)) _a.call(draft_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ tables: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Update data validations
+        onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prevValidations) {
+            var _a = __read(produceWithPatches(prevValidations, function (draft) {
+                updateRangedRulesOnStructuralChange(draft, "insert", "row", referenceRowIndex, numRows, sheetId);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ dataValidations: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Update conditional formats
+        onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prevConditionalFormats) {
+            var _a = __read(produceWithPatches(prevConditionalFormats, function (draft) {
+                updateRangedRulesOnStructuralChange(draft, "insert", "row", referenceRowIndex, numRows, sheetId);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ conditionalFormats: { patches: patches, inversePatches: 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 === null || onChangePivotTables === void 0 ? void 0 : onChangePivotTables(function (prevPivots) {
+            var _a = __read(produceWithPatches(prevPivots, function (draft) {
+                shiftPivotsOnInsert(draft, sheetId, "row", referenceRowIndex, numRows);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ pivotTables: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Update citations: shift only when insertion is BEFORE the citation
+        // range. Insertion within the range does NOT extend a citation.
+        onChangeCitations === null || onChangeCitations === void 0 ? void 0 : onChangeCitations(function (prevCitations) {
+            var _a = __read(produceWithPatches(prevCitations, function (draft) {
+                var e_2, _a;
+                try {
+                    for (var draft_2 = __values(draft), draft_2_1 = draft_2.next(); !draft_2_1.done; draft_2_1 = draft_2.next()) {
+                        var citation = draft_2_1.value;
+                        if (citation.range.sheetId !== sheetId)
+                            continue;
+                        if (referenceRowIndex <= citation.range.startRowIndex) {
+                            citation.range.startRowIndex += numRows;
+                            citation.range.endRowIndex += numRows;
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (draft_2_1 && !draft_2_1.done && (_a = draft_2.return)) _a.call(draft_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ citations: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Update sheet metadata (rowMetadata, basicFilter, frozen rows, merges,
+        // rowCount).
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a;
+                var _b;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (!sheet)
+                    return;
+                if (sheet.rowMetadata) {
+                    (_a = sheet.rowMetadata).splice.apply(_a, __spreadArray([referenceRowIndex,
+                        0], __read(Array.from({ length: numRows }, function () { return null; })), false));
+                }
+                if (sheet.basicFilter) {
+                    var _c = sheet.basicFilter.range, startRowIndex = _c.startRowIndex, endRowIndex = _c.endRowIndex;
+                    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 = ((_b = sheet.rowCount) !== null && _b !== void 0 ? _b : rowCount) + numRows;
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ sheets: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Sheet data: run the three-pass formula update helper, then splice
+        // in the new rows.
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var _a;
+                updateFormulasForStructuralChange({
+                    draft: draft,
+                    axis: "row",
+                    op: "insert",
+                    sheetId: sheetId,
+                    referenceIndex: referenceRowIndex,
+                    count: numRows,
+                    rowCount: rowCount,
+                    columnCount: columnCount,
+                    getDependents: getDependents,
+                    getGraphNodes: getGraphNodes,
+                    getGraphNodesInSheet: getGraphNodesInSheet,
+                    getSheetName: getSheetName,
+                    enqueueCalculation: enqueueCalculation,
+                    enqueueGraphOperation: enqueueGraphOperation,
+                    recalcCells: recalcCells,
+                    locale: locale,
+                    cellXfsRegistry: cellXfsRegistry,
+                    sharedStringRegistry: sharedStringRegistry,
+                });
+                var currentSheet = createSheetDraft(draft, sheetId, referenceRowIndex);
+                var formattingSourceRow = (_a = currentSheet[referenceRowIndex]) !== null && _a !== void 0 ? _a : currentSheet[referenceRowIndex - 1];
+                var newRows = Array.from({ length: numRows }, function () {
+                    return cloneRowWithFormatting(formattingSourceRow);
+                });
+                currentSheet.splice.apply(currentSheet, __spreadArray([referenceRowIndex, 0], __read(newRows), false));
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+                selections: {
+                    undo: __spreadArray([], __read(getSelections()), false),
+                    redo: __spreadArray([], __read(getSelections()), false),
+                },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/cjs/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/cjs/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/cjs/interface/insert-table-row.js

@@ -0,0 +1,348 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+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 var insertTableRow = function (_a) {
+    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getSheetName = _a.getSheetName, getActiveCell = _a.getActiveCell, getDependents = _a.getDependents, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeDataValidations = _a.onChangeDataValidations, onChangeConditionalFormats = _a.onChangeConditionalFormats;
+    return function (tableView, relativeRowIndex, rowData) {
+        var _a;
+        var referenceRowIndex = tableView.range.startRowIndex +
+            (relativeRowIndex !== null && relativeRowIndex !== void 0 ? relativeRowIndex : tableView.range.endRowIndex - tableView.range.startRowIndex + 1);
+        var numRows = (_a = rowData === null || rowData === void 0 ? void 0 : rowData.length) !== null && _a !== void 0 ? _a : 1;
+        var sheetId = tableView.sheetId;
+        enqueueStructureChange === null || enqueueStructureChange === void 0 ? void 0 : enqueueStructureChange({
+            kind: "insert-table-row",
+            sheetId: sheetId,
+            index: referenceRowIndex,
+            count: numRows,
+            rowCount: rowCount,
+            startColumnIndex: tableView.range.startColumnIndex,
+            endColumnIndex: tableView.range.endColumnIndex,
+        });
+        var saveHistory = createHistory();
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        // Update table position
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                var e_1, _a;
+                try {
+                    for (var draft_1 = __values(draft), draft_1_1 = draft_1.next(); !draft_1_1.done; draft_1_1 = draft_1.next()) {
+                        var table = draft_1_1.value;
+                        var startRowIndex = table.range.startRowIndex;
+                        var endRowIndex = table.range.endRowIndex;
+                        if (referenceRowIndex < startRowIndex) {
+                            moveFilterView(table, numRows, Direction.Down);
+                        }
+                        if (referenceRowIndex >= startRowIndex &&
+                            referenceRowIndex <= endRowIndex + 1) {
+                            table.range.endRowIndex += numRows;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (draft_1_1 && !draft_1_1.done && (_a = draft_1.return)) _a.call(draft_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                tables: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update data validations
+        onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prevValidations) {
+            var _a = __read(produceWithPatches(prevValidations, function (draft) {
+                var _a, _b;
+                for (var idx = draft.length - 1; idx >= 0; idx--) {
+                    var rule = draft[idx];
+                    var ranges = (_b = (_a = rule.ranges) === null || _a === void 0 ? void 0 : _a.map(function (range) {
+                        return updateSheetRangeOnInsert(range, "row", referenceRowIndex, numRows, sheetId);
+                    }).filter(function (range) { return !!range; })) !== null && _b !== void 0 ? _b : [];
+                    if (ranges.length) {
+                        rule.ranges = ranges;
+                    }
+                    else {
+                        draft.splice(idx, 1);
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                dataValidations: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update conditional formats
+        onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prevConditionalFormats) {
+            var _a = __read(produceWithPatches(prevConditionalFormats, function (draft) {
+                var _a, _b;
+                for (var idx = draft.length - 1; idx >= 0; idx--) {
+                    var rule = draft[idx];
+                    var ranges = (_b = (_a = rule.ranges) === null || _a === void 0 ? void 0 : _a.map(function (range) {
+                        return updateSheetRangeOnInsert(range, "row", referenceRowIndex, numRows, sheetId);
+                    }).filter(function (range) { return !!range; })) !== null && _b !== void 0 ? _b : [];
+                    if (ranges.length) {
+                        rule.ranges = ranges;
+                    }
+                    else {
+                        draft.splice(idx, 1);
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                conditionalFormats: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheets
+        onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a;
+                var _b;
+                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheet) {
+                    if (sheet.rowMetadata) {
+                        var newRowMetaData = __spreadArray([], __read(Array(numRows)), false).map(function (_, index) { var _a; return (_a = sheet.rowMetadata) === null || _a === void 0 ? void 0 : _a[referenceRowIndex + index]; });
+                        (_a = sheet.rowMetadata).splice.apply(_a, __spreadArray([referenceRowIndex, 0], __read(newRowMetaData), false));
+                    }
+                    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, function (area) {
+                            return (area.startColumnIndex >= tableView.range.startColumnIndex &&
+                                area.endColumnIndex <= tableView.range.endColumnIndex);
+                        });
+                    }
+                    sheet.rowCount = ((_b = sheet.rowCount) !== null && _b !== void 0 ? _b : rowCount) + numRows;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Update sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_2, _a, e_3, _b;
+                var _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+                var totalRows = (_d = (_c = draft[sheetId]) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : rowCount;
+                var sourceRange = __assign(__assign({}, tableView.range), { startRowIndex: referenceRowIndex });
+                var 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
+                var insertionRange = {
+                    startRowIndex: referenceRowIndex,
+                    endRowIndex: referenceRowIndex + numRows - 1,
+                    startColumnIndex: 1,
+                    endColumnIndex: columnCount,
+                };
+                var formulasToExpand = collectUniqueDependentsForRange({
+                    draft: draft,
+                    sheetId: sheetId,
+                    sourceRange: insertionRange,
+                    getDependents: getDependents,
+                });
+                var sheetCell = new SheetCell();
+                try {
+                    for (var _q = __values(formulasToExpand.values()), _r = _q.next(); !_r.done; _r = _q.next()) {
+                        var pos = _r.value;
+                        var currentSheet = createSheetDraft(draft, sheetId, pos.rowIndex);
+                        var cellData = (_f = (_e = currentSheet[pos.rowIndex]) === null || _e === void 0 ? void 0 : _e.values) === null || _f === void 0 ? void 0 : _f[pos.columnIndex];
+                        if (!cellData)
+                            continue;
+                        // Check if cell has a formula
+                        sheetCell.assign(pos.sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData);
+                        var formulaValue = sheetCell.formula;
+                        if (formulaValue) {
+                            var activeSheetName = getSheetName(pos.sheetId);
+                            var 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)
+                                var adjustedRowIndex = pos.sheetId === sheetId && pos.rowIndex >= referenceRowIndex
+                                    ? pos.rowIndex + numRows
+                                    : pos.rowIndex;
+                                enqueueCalculation === null || enqueueCalculation === void 0 ? void 0 : 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,
+                                });
+                            }
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_r && !_r.done && (_a = _q.return)) _a.call(_q);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                // PASS 2: Collect and process formulas that DEPEND ON the moved cells
+                var dependents = collectUniqueDependentsForRange({
+                    draft: draft,
+                    sheetId: sheetId,
+                    sourceRange: sourceRange,
+                    getDependents: getDependents,
+                });
+                try {
+                    for (var _s = __values(dependents.values()), _t = _s.next(); !_t.done; _t = _s.next()) {
+                        var pos = _t.value;
+                        moveFormulaAtPosition({
+                            draft: draft,
+                            position: pos,
+                            activeSheetName: getSheetName(pos.sheetId),
+                            enqueueCalculation: enqueueCalculation,
+                            enqueueGraphOperation: enqueueGraphOperation,
+                            recalcCells: recalcCells,
+                            movedKeys: movedKeys,
+                            rowDelta: numRows,
+                            columnDelta: 0,
+                            sourceRange: sourceRange,
+                            locale: locale,
+                            rowCount: rowCount,
+                            columnCount: columnCount,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_t && !_t.done && (_b = _s.return)) _b.call(_s);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+                // PASS 3: Process formulas WITHIN the moved cells themselves
+                for (var rowIndex = referenceRowIndex; rowIndex < tableView.range.endRowIndex; rowIndex++) {
+                    var rowValues = (_h = (_g = draft[sheetId]) === null || _g === void 0 ? void 0 : _g[rowIndex]) === null || _h === void 0 ? void 0 : _h.values;
+                    if (!rowValues) {
+                        continue;
+                    }
+                    for (var columnIndex = tableView.range.startColumnIndex; columnIndex < tableView.range.endColumnIndex; columnIndex++) {
+                        var cellData = rowValues === null || rowValues === void 0 ? void 0 : rowValues[columnIndex];
+                        var hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(cellData));
+                        if (!hasFormula) {
+                            continue;
+                        }
+                        moveFormulaAtPosition({
+                            draft: draft,
+                            position: { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex },
+                            enqueueCalculation: enqueueCalculation,
+                            enqueueGraphOperation: enqueueGraphOperation,
+                            recalcCells: recalcCells,
+                            movedKeys: movedKeys,
+                            rowDelta: numRows,
+                            columnDelta: 0,
+                            sourceRange: sourceRange,
+                            locale: locale,
+                            rowCount: rowCount,
+                            columnCount: columnCount,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                    }
+                }
+                // Update values
+                for (var rowIndex = totalRows + numRows; rowIndex >= referenceRowIndex; rowIndex--) {
+                    var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    for (var columnIndex = tableView.range.endColumnIndex; columnIndex >= tableView.range.startColumnIndex; columnIndex--) {
+                        var previousValue = (_k = (_j = currentSheet[rowIndex - numRows]) === null || _j === void 0 ? void 0 : _j.values) === null || _k === void 0 ? void 0 : _k[columnIndex];
+                        currentSheet[rowIndex].values[columnIndex] = previousValue;
+                    }
+                }
+                // Inserted rows: clone formatting from the row that shifted down (referenceRowIndex + numRows)
+                for (var r = 0; r < numRows; r++) {
+                    var rowIndex = referenceRowIndex + r;
+                    var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    var input = rowData === null || rowData === void 0 ? void 0 : rowData[r];
+                    // Clone entire row formatting once
+                    var formatSourceRow = createSheetDraft(draft, sheetId, rowIndex + numRows);
+                    var tempCell = new SheetCell();
+                    for (var columnIndex = tableView.range.startColumnIndex; columnIndex <= tableView.range.endColumnIndex; columnIndex++) {
+                        var sourceCell = (_m = (_l = formatSourceRow[rowIndex + numRows]) === null || _l === void 0 ? void 0 : _l.values) === null || _m === void 0 ? void 0 : _m[columnIndex];
+                        var cloned = tempCell
+                            .assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, sourceCell)
+                            .cloneWithFormatting();
+                        var relativeColumnIndex = columnIndex - tableView.range.startColumnIndex;
+                        var columnName = (_p = (_o = tableView.columns) === null || _o === void 0 ? void 0 : _o[relativeColumnIndex]) === null || _p === void 0 ? void 0 : _p.name;
+                        var cellValue = columnName ? input === null || input === void 0 ? void 0 : 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: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
+                        });
+                        recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex });
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+                activeCell: { undo: getActiveCell(), redo: getActiveCell() },
+            });
+            return nextState;
+        });
+    };
+};

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

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

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

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