@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/api/range.js

@@ -0,0 +1,136 @@
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+import { cellToAddress, isNil } from "@rowsncolumns/utils";
+export const iterateCellsInCellRangeWithResults = function* (range, results) {
+    const { from, to } = range;
+    let i = 0;
+    for (let rowIndex = from.row; rowIndex <= to.row; rowIndex++) {
+        let j = 0;
+        for (let colIndex = from.col; colIndex <= to.col; colIndex++) {
+            yield [rowIndex, colIndex, results[i][j]];
+            j++;
+        }
+        i++;
+    }
+};
+export const iterateCellsInCellRange = function* (range) {
+    const { from, to } = range;
+    for (let rowIndex = from.row; rowIndex <= to.row; rowIndex++) {
+        for (let colIndex = from.col; colIndex <= to.col; colIndex++) {
+            yield [rowIndex, colIndex];
+        }
+    }
+};
+export const isEqualPosition = (source, cell) => {
+    return (source.rowIndex === cell.rowIndex && source.columnIndex === cell.columnIndex);
+};
+export const isSelectionRange = (rangeOrCell) => {
+    return !!rangeOrCell.startRowIndex;
+};
+export const collisionDetection = (position, range, getUserEnteredValue) => {
+    if (!range) {
+        return [false, undefined];
+    }
+    // Check if there is a value in position
+    if (isNil(getUserEnteredValue(position.sheetId, position.rowIndex, position.columnIndex))) {
+        return [false, undefined];
+    }
+    for (const [rowIndex, columnIndex] of iterateCellsInCellRange(range)) {
+        if (rowIndex === position.rowIndex &&
+            columnIndex === position.columnIndex) {
+            continue;
+        }
+        const userEnteredValue = getUserEnteredValue(position.sheetId, rowIndex, columnIndex);
+        // If the position is already used by the user
+        if (!isNil(userEnteredValue)) {
+            return [true, { sheetId: position.sheetId, rowIndex, columnIndex }];
+        }
+    }
+    return [false, undefined];
+};
+export const generateCollisionError = ({ rowIndex, columnIndex, }) => new FormulaError("#SPILL!", `Array result was not expanded because it would overwrite data in ${cellToAddress({ rowIndex, columnIndex })}.`);
+// Is the same range
+export const isEqualCellRange = (a, b) => {
+    if (isNil(a) || isNil(b)) {
+        return false;
+    }
+    return (a.sheet === b.sheet &&
+        a.from.col === b.from.col &&
+        a.from.row === b.from.row &&
+        a.to.col === b.to.col &&
+        a.to.row === b.to.row);
+};
+export const isCellWithinCellRange = ({ rowIndex, columnIndex }, a) => {
+    if (isNil(a)) {
+        return false;
+    }
+    return (rowIndex >= a.from.row &&
+        rowIndex <= a.to.row &&
+        columnIndex >= a.from.col &&
+        columnIndex <= a.to.col);
+};
+export const isEqualCellCoordinates = (pos1, pos2) => {
+    return (pos1.sheetId === pos2.sheetId &&
+        pos1.rowIndex === pos2.rowIndex &&
+        pos1.columnIndex === pos2.columnIndex);
+};
+const getRangeDimensionKeys = (dimension) => dimension === "row"
+    ? ["startRowIndex", "endRowIndex"]
+    : ["startColumnIndex", "endColumnIndex"];
+const clampRangeStart = (value) => Math.max(1, value);
+export const updateSheetRangeOnInsert = (range, dimension, index, count, sheetId) => {
+    if (range.sheetId !== sheetId) {
+        return range;
+    }
+    const [startKey, endKey] = getRangeDimensionKeys(dimension);
+    const start = range[startKey];
+    const end = range[endKey];
+    if (index < start) {
+        return {
+            ...range,
+            [startKey]: start + count,
+            [endKey]: end + count,
+        };
+    }
+    if (index >= start && index <= end) {
+        return {
+            ...range,
+            [endKey]: end + count,
+        };
+    }
+    return range;
+};
+export const updateSheetRangeOnDelete = (range, dimension, index, count, sheetId) => {
+    if (range.sheetId !== sheetId) {
+        return range;
+    }
+    const [startKey, endKey] = getRangeDimensionKeys(dimension);
+    const start = range[startKey];
+    const end = range[endKey];
+    const deleteEndIndex = index + count - 1;
+    // Entire deletion happens before the range -> shift up/left
+    if (deleteEndIndex < start) {
+        return {
+            ...range,
+            [startKey]: clampRangeStart(start - count),
+            [endKey]: clampRangeStart(end - count),
+        };
+    }
+    // Deletion happens after the range -> nothing to do
+    if (index > end) {
+        return range;
+    }
+    // Partial or full overlap
+    if (start >= index && end <= deleteEndIndex) {
+        return null;
+    }
+    const nextStart = start < index ? start : index;
+    const nextEnd = end > deleteEndIndex ? end - count : clampRangeStart(index - 1);
+    if (nextEnd < nextStart) {
+        return null;
+    }
+    return {
+        ...range,
+        [startKey]: clampRangeStart(nextStart),
+        [endKey]: clampRangeStart(nextEnd),
+    };
+};

package/dist/esm/api/rename-sheet.d.ts

@@ -0,0 +1,22 @@
+import type { CellCoordinate, CellNode, CellRangeNode } from "@rowsncolumns/dag";
+import { StaticNode } from "@rowsncolumns/dag";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { WritableDraft } from "immer";
+import type { SheetData } from "../hooks/use-spreadsheet-state";
+export type UpdateFormulaSheetReferencesOptions<T extends CellData> = {
+    sheetId: number;
+    oldName: string;
+    newName: string;
+    locale?: string;
+    getGraphNodes: () => Map<string, CellNode | CellRangeNode | StaticNode>;
+    getPrecedents: (source: CellCoordinate) => (CellNode | CellRangeNode | StaticNode)[];
+};
+/**
+ * Updates all formula references to a sheet when it's renamed.
+ * This function is designed to be used within an immer produce callback.
+ *
+ * @param draft - The immer draft of sheet data
+ * @param options - Configuration options for the update
+ */
+export declare const updateFormulaSheetReferences: <T extends CellData, S extends Sheet>(draft: WritableDraft<SheetData<T>>, options: UpdateFormulaSheetReferencesOptions<T>) => void;
+//# sourceMappingURL=rename-sheet.d.ts.map

package/dist/esm/api/rename-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-sheet.d.ts","sourceRoot":"","sources":["../../../api/rename-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,QAAQ,EACR,aAAa,EACd,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAkC,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAS,aAAa,EAAE,MAAM,OAAO,CAAC;AAKlD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAEhE,MAAM,MAAM,mCAAmC,CAAC,CAAC,SAAS,QAAQ,IAAI;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,QAAQ,GAAG,aAAa,GAAG,UAAU,CAAC,CAAC;IACxE,aAAa,EAAE,CACb,MAAM,EAAE,cAAc,KACnB,CAAC,QAAQ,GAAG,aAAa,GAAG,UAAU,CAAC,EAAE,CAAC;CAChD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,GACvC,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,KAAK,EAEf,OAAO,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAClC,SAAS,mCAAmC,CAAC,CAAC,CAAC,KAC9C,IAwCF,CAAC"}

package/dist/esm/api/rename-sheet.js

@@ -0,0 +1,41 @@
+import { isCellCoordinate, isStaticNode } from "@rowsncolumns/dag";
+import { createSheetDraft } from "./immer-utils";
+import { truncateSheetTitle } from "../helpers/sheet-title";
+import { SheetCell } from "../sheet-cell";
+/**
+ * Updates all formula references to a sheet when it's renamed.
+ * This function is designed to be used within an immer produce callback.
+ *
+ * @param draft - The immer draft of sheet data
+ * @param options - Configuration options for the update
+ */
+export const updateFormulaSheetReferences = (draft, options) => {
+    const { sheetId, oldName, newName, locale, getGraphNodes, getPrecedents } = options;
+    const truncatedNewName = truncateSheetTitle(newName);
+    const sheetCell = new SheetCell();
+    for (const [_, node] of getGraphNodes()) {
+        if (isStaticNode(node)) {
+            continue;
+        }
+        const { position, inputKeys } = node;
+        if (isCellCoordinate(position) && inputKeys.size > 0) {
+            const precedents = getPrecedents(position);
+            // Check if we have any precedents that point to the renamed sheet
+            const requiresRename = precedents.findIndex((p) => {
+                return !isStaticNode(p) && p.position.sheetId === sheetId;
+            }) !== -1;
+            if (requiresRename) {
+                const { rowIndex, columnIndex, sheetId: nodeSheetId } = position;
+                const currentSheet = createSheetDraft(draft, nodeSheetId, rowIndex);
+                const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                // Create a cell
+                sheetCell.assign(nodeSheetId, { rowIndex, columnIndex }, cellData, {
+                    locale,
+                });
+                sheetCell.changeFormulaSheetName(truncatedNewName, oldName);
+                // Set cell data
+                currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+            }
+        }
+    }
+};

package/dist/esm/api/selection.d.ts

@@ -0,0 +1,36 @@
+import type { CellInterface, GridRange, SelectionArea } from "@rowsncolumns/common-types";
+import { Direction } from "@rowsncolumns/common-types";
+import type { BandedRange, FilterView, SelectionAttributes, SheetRange } from "@rowsncolumns/spreadsheet";
+export declare const getFillDirection: (fillSelection: SelectionArea, selection: SelectionArea) => Direction;
+/**
+ * For autofilling
+ * @param activeCell
+ * @param fillSelection
+ * @param direction
+ * @returns
+ */
+export declare const createFillRangeSelection: (activeCell: CellInterface, fillSelection: SelectionArea, direction: Direction) => {
+    range: {
+        startRowIndex: number;
+        endRowIndex: number;
+        endColumnIndex: number;
+        startColumnIndex: number;
+    };
+}[];
+/**
+ * Move range
+ * @param range
+ * @param from
+ * @param to
+ */
+export declare const moveRange: <T extends GridRange | SheetRange>(range: T, from: GridRange, to: GridRange) => T;
+/**
+ * Shift a tableview
+ * @param view
+ * @param count
+ * @param direction
+ */
+export declare const moveFilterView: <T extends FilterView>(table: T, count: number, direction: Direction) => void;
+export declare const moveBandedRange: (bandedRange: BandedRange, count: number, direction: Direction) => void;
+export declare const createSelectionBetweenCell: (from: CellInterface, to: CellInterface) => SelectionArea<SelectionAttributes>;
+//# sourceMappingURL=selection.d.ts.map

package/dist/esm/api/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../../api/selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,aAAa,EACd,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EACV,mBAAmB,EACnB,UAAU,EACX,MAAM,2BAA2B,CAAC;AAEnC,eAAO,MAAM,gBAAgB,GAC3B,eAAe,aAAa,EAC5B,WAAW,aAAa,cAWzB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACnC,YAAY,aAAa,EACzB,eAAe,aAAa,EAC5B,WAAW,SAAS;;;;;;;GAmCrB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,SAAS,GAAG,UAAU,EACxD,OAAO,CAAC,EACR,MAAM,SAAS,EACf,IAAI,SAAS,KACZ,CAaF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,UAAU,EACjD,OAAO,CAAC,EACR,OAAO,MAAM,EACb,WAAW,SAAS,SAkDrB,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,aAAa,WAAW,EACxB,OAAO,MAAM,EACb,WAAW,SAAS,SAoBrB,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,MAAM,aAAa,EACnB,IAAI,aAAa,KAChB,aAAa,CAAC,mBAAmB,CASnC,CAAC"}

package/dist/esm/api/selection.js

@@ -0,0 +1,138 @@
+import { Direction } from "@rowsncolumns/common-types";
+export const getFillDirection = (fillSelection, selection) => {
+    const direction = fillSelection.range.endRowIndex > selection.range.endRowIndex
+        ? Direction.Down
+        : fillSelection.range.startRowIndex < selection.range.startRowIndex
+            ? Direction.Up
+            : fillSelection.range.startColumnIndex < selection.range.startColumnIndex
+                ? Direction.Left
+                : Direction.Right;
+    return direction;
+};
+/**
+ * For autofilling
+ * @param activeCell
+ * @param fillSelection
+ * @param direction
+ * @returns
+ */
+export const createFillRangeSelection = (activeCell, fillSelection, direction) => {
+    return direction === Direction.Down || direction === Direction.Up
+        ? [
+            {
+                range: {
+                    startRowIndex: activeCell.rowIndex,
+                    endRowIndex: activeCell.rowIndex,
+                    endColumnIndex: Math.max(activeCell.columnIndex, fillSelection.range.endColumnIndex),
+                    startColumnIndex: Math.min(activeCell.columnIndex, fillSelection.range.startColumnIndex),
+                },
+            },
+        ]
+        : [
+            {
+                range: {
+                    startColumnIndex: activeCell.columnIndex,
+                    endColumnIndex: activeCell.columnIndex,
+                    startRowIndex: Math.min(activeCell.rowIndex, fillSelection.range.startRowIndex),
+                    endRowIndex: Math.max(activeCell.rowIndex, fillSelection.range.endRowIndex),
+                },
+            },
+        ];
+};
+/**
+ * Move range
+ * @param range
+ * @param from
+ * @param to
+ */
+export const moveRange = (range, from, to) => {
+    const rowDelta = range.startRowIndex - from.startRowIndex;
+    const colDelta = range.startColumnIndex - from.startColumnIndex;
+    const startRowIndex = rowDelta + to.startRowIndex;
+    const startColumnIndex = colDelta + to.startColumnIndex;
+    return {
+        ...range,
+        startRowIndex,
+        startColumnIndex,
+        endRowIndex: startRowIndex + (range.endRowIndex - range.startRowIndex),
+        endColumnIndex: startColumnIndex + (range.endColumnIndex - range.startColumnIndex),
+    };
+};
+/**
+ * Shift a tableview
+ * @param view
+ * @param count
+ * @param direction
+ */
+export const moveFilterView = (table, count, direction) => {
+    if (direction === Direction.Right) {
+        table.range.startColumnIndex += count;
+        table.range.endColumnIndex += count;
+        /**
+         * Update table specs
+         */
+        if (table.sortSpecs) {
+            table.sortSpecs.forEach((spec) => {
+                spec.dimensionIndex += count;
+            });
+        }
+        if (table.filterSpecs) {
+            table.filterSpecs.forEach((spec) => {
+                spec.columnIndex += count;
+            });
+        }
+    }
+    if (direction === Direction.Down) {
+        table.range.startRowIndex += count;
+        table.range.endRowIndex += count;
+    }
+    if (direction === Direction.Up) {
+        table.range.startRowIndex -= count;
+        table.range.endRowIndex -= count;
+    }
+    if (direction === Direction.Left) {
+        table.range.startColumnIndex -= count;
+        table.range.endColumnIndex -= count;
+        /**
+         * Update table specs
+         */
+        if (table.sortSpecs) {
+            table.sortSpecs.forEach((spec) => {
+                spec.dimensionIndex -= count;
+            });
+        }
+        if (table.filterSpecs) {
+            table.filterSpecs.forEach((spec) => {
+                spec.columnIndex -= count;
+            });
+        }
+    }
+};
+export const moveBandedRange = (bandedRange, count, direction) => {
+    if (direction === Direction.Right) {
+        bandedRange.range.startColumnIndex += count;
+        bandedRange.range.endColumnIndex += count;
+    }
+    if (direction === Direction.Down) {
+        bandedRange.range.startRowIndex += count;
+        bandedRange.range.endRowIndex += count;
+    }
+    if (direction === Direction.Up) {
+        bandedRange.range.startRowIndex -= count;
+        bandedRange.range.endRowIndex -= count;
+    }
+    if (direction === Direction.Left) {
+        bandedRange.range.startColumnIndex -= count;
+        bandedRange.range.endColumnIndex -= count;
+    }
+};
+export const createSelectionBetweenCell = (from, to) => {
+    return {
+        range: {
+            startRowIndex: Math.min(from.rowIndex, to.rowIndex),
+            startColumnIndex: Math.min(from.columnIndex, to.columnIndex),
+            endColumnIndex: Math.max(from.columnIndex, to.columnIndex),
+            endRowIndex: Math.max(from.rowIndex, to.rowIndex),
+        },
+    };
+};

package/dist/esm/api/sort.d.ts

@@ -0,0 +1,3 @@
+import type { SortOrder } from "@rowsncolumns/spreadsheet";
+export declare const cellValueSorter: (left: string | number | boolean | undefined | null, right: string | number | boolean | undefined | null, sortOrder: SortOrder) => number;
+//# sourceMappingURL=sort.d.ts.map

package/dist/esm/api/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../../api/sort.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAQ3D,eAAO,MAAM,eAAe,GAC1B,MAAM,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI,EAClD,OAAO,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI,EACnD,WAAW,SAAS,WAiCrB,CAAC"}

package/dist/esm/api/sort.js

@@ -0,0 +1,33 @@
+import { isNil } from "@rowsncolumns/utils";
+const { compare: comparator } = new Intl.Collator("en", {
+    numeric: true,
+    sensitivity: "base",
+});
+export const cellValueSorter = (left, right, sortOrder) => {
+    const isEmpty = (value) => {
+        if (isNil(value)) {
+            return true;
+        }
+        return typeof value === "string" && value.trim() === "";
+    };
+    const leftEmpty = isEmpty(left);
+    const rightEmpty = isEmpty(right);
+    // Ignore empty rows
+    if (leftEmpty && rightEmpty) {
+        return 0;
+    }
+    if (leftEmpty) {
+        return 1;
+    }
+    if (rightEmpty) {
+        return -1;
+    }
+    const isNumbers = typeof left === "number" && typeof right === "number";
+    const comparisonResult = isNumbers
+        ? left - right
+        : comparator(String(left), String(right));
+    if (comparisonResult !== 0) {
+        return (sortOrder === "ASCENDING" ? 1 : -1) * Math.sign(comparisonResult);
+    }
+    return 0;
+};

package/dist/esm/api/split-text.d.ts

@@ -0,0 +1,2 @@
+export declare const splitTextToColumns: (values: (string | null | undefined)[], delimiter?: string) => string[][];
+//# sourceMappingURL=split-text.d.ts.map

package/dist/esm/api/split-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-text.d.ts","sourceRoot":"","sources":["../../../api/split-text.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACrC,YAAW,MAAY,KACtB,MAAM,EAAE,EAwBV,CAAC"}

package/dist/esm/api/split-text.js

@@ -0,0 +1,24 @@
+import { isNil } from "@rowsncolumns/utils";
+// Split text to columns - takes a single column and returns 2D array
+export const splitTextToColumns = (values, delimiter = ",") => {
+    return values.map((cell) => {
+        // Handle empty/null cells
+        if (isNil(cell)) {
+            return [""];
+        }
+        // Backward compatibility: older callers passed empty string for "Space"
+        if (delimiter === "" || delimiter === " ") {
+            const normalized = cell.trim();
+            if (!normalized) {
+                return [""];
+            }
+            return normalized.split(/\s+/).map((part) => part.trim());
+        }
+        // Escape special regex characters in delimiter
+        const escapedDelimiter = delimiter.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const parts = cell.split(new RegExp(escapedDelimiter));
+        // Trim whitespace from each part (optional, common in CSV)
+        const trimmedParts = parts.map((part) => part.trim());
+        return trimmedParts;
+    });
+};

package/dist/esm/api/structural-formula-update.d.ts

@@ -0,0 +1,75 @@
+import type { CellData } from "@rowsncolumns/spreadsheet";
+import type { Draft } from "immer";
+import type { useCalculation } from "../hooks/use-calculation";
+import type { CellXfsRegistry } from "../hooks/use-cellxfs-registry";
+import type { SheetData } from "../hooks/use-spreadsheet-state";
+import type { SharedStringRegistry } from "../hooks/use-ss-registry";
+import type { RecalcCellCoordinate } from "../types";
+type StructuralAxis = "row" | "column";
+type StructuralOp = "insert" | "delete";
+export type StructuralFormulaUpdateParams<T extends CellData> = {
+    draft: Draft<SheetData<T>>;
+    axis: StructuralAxis;
+    op: StructuralOp;
+    sheetId: number;
+    /**
+     * For insert: the index at which rows/columns are being inserted.
+     * For delete: the smallest index in the (assumed contiguous) deleted range.
+     */
+    referenceIndex: number;
+    /** Number of rows/columns being inserted or deleted. */
+    count: number;
+    rowCount: number;
+    columnCount: number;
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    /**
+     * Optional. When present and populated, used to enumerate formula cells
+     * in the moved region (Pass 3 fast path). When absent or empty, falls
+     * back to a per-cell sweep of the draft.
+     */
+    getGraphNodes?: ReturnType<typeof useCalculation>["getGraphNodes"];
+    /**
+     * Optional, preferred over `getGraphNodes` when supplied. Returns only
+     * the nodes registered for the given sheet — cost scales with the
+     * sheet's node count rather than the workbook's, which is the right
+     * shape for structural ops.
+     */
+    getGraphNodesInSheet?: ReturnType<typeof useCalculation>["getGraphNodesInSheet"];
+    getSheetName: (sheetId: number) => string;
+    enqueueCalculation?: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueGraphOperation?: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    recalcCells: Map<string, RecalcCellCoordinate>;
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+};
+/**
+ * Three-pass formula update for row/column insert and delete operations.
+ *
+ * PASS 1 — Range expansion / contraction:
+ *   Formulas that REFERENCE cells in the affected range have their range
+ *   references expanded (insert) or contracted (delete). e.g. inserting
+ *   a row at 2 turns `=SUM(A1:A10)` into `=SUM(A1:A11)`. We use the
+ *   dependency graph to find only the formulas that point INTO the
+ *   affected range, so this is O(dependents).
+ *
+ * PASS 2 — Reference shifting for outside-formulas pointing into the
+ *   moved region: every formula that referenced a cell in the source
+ *   range needs its references rebased by ±count along the axis. Again
+ *   uses the dependency graph, so O(dependents).
+ *
+ * PASS 3 — Reference shifting for formulas WITHIN the moved region:
+ *   formulas that live in the moved cells need their own references
+ *   rebased (with the moved region excluded so internal refs stay
+ *   stable). Replaced the historical O(rows × cols) cell sweep with a
+ *   graph-node lookup — only iterate cells the calculator already
+ *   knows are formula cells. O(formula_cells_in_workbook) with a sheet
+ *   + bounds filter, which on sparse-formula sheets (the common case)
+ *   is orders of magnitude smaller than the dense sweep.
+ *
+ * The `movedKeys` Set passed to `moveFormulaAtPosition` ensures Passes 2
+ * and 3 don't double-process a cell.
+ */
+export declare const updateFormulasForStructuralChange: <T extends CellData>(params: StructuralFormulaUpdateParams<T>) => void;
+export {};
+//# sourceMappingURL=structural-formula-update.d.ts.map

package/dist/esm/api/structural-formula-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structural-formula-update.d.ts","sourceRoot":"","sources":["../../../api/structural-formula-update.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAK1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAEnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAarD,KAAK,cAAc,GAAG,KAAK,GAAG,QAAQ,CAAC;AACvC,KAAK,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAExC,MAAM,MAAM,6BAA6B,CAAC,CAAC,SAAS,QAAQ,IAAI;IAC9D,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,IAAI,EAAE,cAAc,CAAC;IACrB,EAAE,EAAE,YAAY,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IAEpB,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE;;;;OAIG;IACH,aAAa,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IACnE;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,UAAU,CAC/B,OAAO,cAAc,CACtB,CAAC,sBAAsB,CAAC,CAAC;IAC1B,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IAC1C,kBAAkB,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC7E,qBAAqB,CAAC,EAAE,UAAU,CAChC,OAAO,cAAc,CACtB,CAAC,uBAAuB,CAAC,CAAC;IAE3B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAE/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,iCAAiC,GAAI,CAAC,SAAS,QAAQ,EAClE,QAAQ,6BAA6B,CAAC,CAAC,CAAC,SAuVzC,CAAC"}