@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/api/structural-formula-update.js

@@ -0,0 +1,431 @@
+import { isCellNode } from "@rowsncolumns/dag";
+import { getCellUserEnteredValue, getExtendedValueFormula, } from "@rowsncolumns/utils";
+import { SheetCell } from "../sheet-cell";
+import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "./dependency";
+import { contractRangesInFormula, createSheetCellIdentifier, expandRangesInFormula, formulaToRelativeReference, } from "./formula";
+import { createSheetDraft } from "./immer-utils";
+/**
+ * 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 const updateFormulasForStructuralChange = (params) => {
+    const { draft, axis, op, sheetId, referenceIndex, count, rowCount, columnCount, getDependents, getGraphNodes, getGraphNodesInSheet, getSheetName, enqueueCalculation, enqueueGraphOperation, recalcCells, locale, cellXfsRegistry, sharedStringRegistry, } = params;
+    if (count <= 0)
+        return;
+    const isRow = axis === "row";
+    const isInsert = op === "insert";
+    const delta = isInsert ? count : -count;
+    // The set of cells that ARE moving (Pass 3 target region). For both
+    // insert and delete, this is everything from the reference index along
+    // the affected axis; the splice happens after the formula updates.
+    const movedRegion = isRow
+        ? {
+            startRowIndex: referenceIndex,
+            endRowIndex: rowCount,
+            startColumnIndex: 1,
+            endColumnIndex: columnCount,
+        }
+        : {
+            startRowIndex: 1,
+            endRowIndex: rowCount,
+            startColumnIndex: referenceIndex,
+            endColumnIndex: columnCount,
+        };
+    // Pass 1's affected range — the actual cells inserted (insert) or
+    // deleted (delete). For insert the cells don't exist yet, but we use
+    // the bounds to find formulas that reference them.
+    const pass1Range = isRow
+        ? {
+            startRowIndex: referenceIndex,
+            endRowIndex: referenceIndex + count - 1,
+            startColumnIndex: 1,
+            endColumnIndex: columnCount,
+        }
+        : {
+            startRowIndex: 1,
+            endRowIndex: rowCount,
+            startColumnIndex: referenceIndex,
+            endColumnIndex: referenceIndex + count - 1,
+        };
+    // Pass 2's source range — the cells that will move under the splice.
+    // For insert this is everything at-or-after the insertion point; for
+    // delete this is everything strictly after the deleted block.
+    const pass2SourceRange = isRow
+        ? {
+            startRowIndex: isInsert ? referenceIndex : referenceIndex + count,
+            endRowIndex: rowCount,
+            startColumnIndex: 1,
+            endColumnIndex: columnCount,
+        }
+        : {
+            startRowIndex: 1,
+            endRowIndex: rowCount,
+            startColumnIndex: isInsert ? referenceIndex : referenceIndex + count,
+            endColumnIndex: columnCount,
+        };
+    // ---- PASS 1 ----
+    const pass1Formulas = collectUniqueDependentsForRange({
+        draft,
+        sheetId,
+        sourceRange: pass1Range,
+        getDependents,
+    });
+    if (pass1Formulas.size > 0) {
+        const sheetCell = new SheetCell();
+        for (const pos of pass1Formulas.values()) {
+            const currentSheet = createSheetDraft(draft, pos.sheetId, pos.rowIndex);
+            const cellData = currentSheet[pos.rowIndex]?.values?.[pos.columnIndex];
+            if (!cellData)
+                continue;
+            sheetCell.assign(pos.sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData, { locale, cellXfsRegistry, sharedStringRegistry });
+            const formulaValue = sheetCell.formula;
+            if (!formulaValue)
+                continue;
+            const activeSheetName = getSheetName(pos.sheetId);
+            const updatedFormula = isInsert
+                ? expandRangesInFormula(formulaValue, referenceIndex, count, axis, activeSheetName)
+                : contractRangesInFormula(formulaValue, referenceIndex, count, axis, activeSheetName);
+            if (!updatedFormula || updatedFormula === formulaValue)
+                continue;
+            sheetCell.setFormulaValue(updatedFormula, false);
+            currentSheet[pos.rowIndex].values[pos.columnIndex] =
+                sheetCell.getCellData();
+            // Adjust the recalc position for cells that themselves shift in
+            // the splice that follows. For insert: cells AT or after the
+            // reference shift by +count along the axis. For delete: cells
+            // STRICTLY after the deleted block shift by -count.
+            const adjustedRowIndex = isRow
+                ? pos.sheetId === sheetId &&
+                    (isInsert
+                        ? pos.rowIndex >= referenceIndex
+                        : pos.rowIndex >= referenceIndex + count)
+                    ? pos.rowIndex + delta
+                    : pos.rowIndex
+                : pos.rowIndex;
+            const adjustedColumnIndex = !isRow
+                ? pos.sheetId === sheetId &&
+                    (isInsert
+                        ? pos.columnIndex >= referenceIndex
+                        : pos.columnIndex >= referenceIndex + count)
+                    ? pos.columnIndex + delta
+                    : pos.columnIndex
+                : pos.columnIndex;
+            enqueueCalculation?.({
+                type: "add",
+                position: {
+                    sheetId: pos.sheetId,
+                    rowIndex: adjustedRowIndex,
+                    columnIndex: adjustedColumnIndex,
+                },
+                force: true,
+            });
+            recalcCells.set(createSheetCellIdentifier(pos.sheetId, adjustedRowIndex, adjustedColumnIndex), {
+                sheetId: pos.sheetId,
+                rowIndex: adjustedRowIndex,
+                columnIndex: adjustedColumnIndex,
+                force: true,
+            });
+        }
+    }
+    // ---- PASS 2 ----
+    const movedKeys = new Set();
+    const rowDelta = isRow ? delta : 0;
+    const columnDelta = isRow ? 0 : delta;
+    const pass2Dependents = collectUniqueDependentsForRange({
+        draft,
+        sheetId,
+        sourceRange: pass2SourceRange,
+        getDependents,
+    });
+    for (const pos of pass2Dependents.values()) {
+        if (pos.sheetId !== sheetId) {
+            shiftExternalDependentFormulaReferences({
+                draft,
+                position: pos,
+                editedSheetName: getSheetName(sheetId),
+                enqueueCalculation,
+                enqueueGraphOperation,
+                recalcCells,
+                movedKeys,
+                rowDelta,
+                columnDelta,
+                sourceRange: pass2SourceRange,
+                locale,
+                rowCount,
+                columnCount,
+                cellXfsRegistry,
+                sharedStringRegistry,
+            });
+            continue;
+        }
+        moveFormulaAtPosition({
+            draft,
+            position: pos,
+            activeSheetName: getSheetName(pos.sheetId),
+            enqueueCalculation,
+            enqueueGraphOperation,
+            recalcCells,
+            movedKeys,
+            rowDelta,
+            columnDelta,
+            sourceRange: pass2SourceRange,
+            locale,
+            rowCount,
+            columnCount,
+            cellXfsRegistry,
+            sharedStringRegistry,
+        });
+    }
+    // Some graph adapters do not return every direct cross-sheet formula from
+    // getDependents during a structural edit. Sweep the formula-node map as a
+    // fallback; movedKeys keeps dependents already handled above O(1) no-ops.
+    for (const position of collectExternalFormulaPositions(getGraphNodes, sheetId)) {
+        shiftExternalDependentFormulaReferences({
+            draft,
+            position,
+            editedSheetName: getSheetName(sheetId),
+            enqueueCalculation,
+            enqueueGraphOperation,
+            recalcCells,
+            movedKeys,
+            rowDelta,
+            columnDelta,
+            sourceRange: pass2SourceRange,
+            locale,
+            rowCount,
+            columnCount,
+            cellXfsRegistry,
+            sharedStringRegistry,
+        });
+    }
+    // ---- PASS 3 ----
+    // Fast path: ask the calculator's dependency graph for the formula cells
+    // in this *sheet* (not the whole workbook) and filter to the moved
+    // region. With the per-sheet bucket the cost scales with
+    // `nodes_in_sheet`, which on multi-sheet workbooks is dramatically
+    // cheaper than walking every node in the graph.
+    //
+    // Fallback: when no graph (test harnesses) or no per-sheet bucket
+    // (e.g. nodes were added through a path that bypassed `createNode`),
+    // walk the draft directly so we don't silently drop formulas.
+    const graphFormulaPositions = collectGraphFormulaPositions(getGraphNodesInSheet, getGraphNodes, sheetId, movedRegion);
+    if (graphFormulaPositions) {
+        for (const pos of graphFormulaPositions) {
+            if (movedKeys.has(SheetCell.generateCellKey(sheetId, pos.rowIndex, pos.columnIndex))) {
+                continue;
+            }
+            const rowValues = draft[sheetId]?.[pos.rowIndex]?.values;
+            const cellData = rowValues?.[pos.columnIndex];
+            const hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(cellData));
+            if (!hasFormula)
+                continue;
+            moveFormulaAtPosition({
+                draft,
+                position: {
+                    sheetId,
+                    rowIndex: pos.rowIndex,
+                    columnIndex: pos.columnIndex,
+                },
+                enqueueCalculation,
+                enqueueGraphOperation,
+                recalcCells,
+                movedKeys,
+                rowDelta,
+                columnDelta,
+                sourceRange: pass2SourceRange,
+                locale,
+                rowCount,
+                columnCount,
+                cellXfsRegistry,
+                sharedStringRegistry,
+            });
+        }
+    }
+    else {
+        const sheetRows = draft[sheetId];
+        if (!sheetRows)
+            return;
+        const startRow = movedRegion.startRowIndex;
+        const endRow = Math.min(movedRegion.endRowIndex, sheetRows.length - 1);
+        for (let rowIndex = startRow; rowIndex <= endRow; rowIndex++) {
+            const rowValues = sheetRows[rowIndex]?.values;
+            const dataColumnCount = rowValues?.length ?? 0;
+            if (!dataColumnCount)
+                continue;
+            const startCol = Math.min(Math.max(movedRegion.startColumnIndex, 1), dataColumnCount);
+            const endCol = Math.min(movedRegion.endColumnIndex, dataColumnCount - 1);
+            for (let columnIndex = startCol; columnIndex <= endCol; columnIndex++) {
+                const cellData = rowValues?.[columnIndex];
+                const hasFormula = !!getExtendedValueFormula(getCellUserEnteredValue(cellData));
+                if (!hasFormula)
+                    continue;
+                moveFormulaAtPosition({
+                    draft,
+                    position: { sheetId, rowIndex, columnIndex },
+                    enqueueCalculation,
+                    enqueueGraphOperation,
+                    recalcCells,
+                    movedKeys,
+                    rowDelta,
+                    columnDelta,
+                    sourceRange: pass2SourceRange,
+                    locale,
+                    rowCount,
+                    columnCount,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
+            }
+        }
+    }
+};
+const shiftExternalDependentFormulaReferences = ({ draft, position, editedSheetName, enqueueCalculation, enqueueGraphOperation, recalcCells, movedKeys, rowDelta, columnDelta, sourceRange, locale, rowCount, columnCount, cellXfsRegistry, sharedStringRegistry, }) => {
+    const sheetCell = new SheetCell();
+    const currentSheet = createSheetDraft(draft, position.sheetId, position.rowIndex);
+    const cellData = currentSheet[position.rowIndex]?.values?.[position.columnIndex];
+    sheetCell.assign(position.sheetId, { rowIndex: position.rowIndex, columnIndex: position.columnIndex }, cellData, { locale, cellXfsRegistry, sharedStringRegistry });
+    if (movedKeys.has(sheetCell.key) || !sheetCell.isFormula()) {
+        return;
+    }
+    movedKeys.add(sheetCell.key);
+    const previousFormula = sheetCell.formula;
+    const updatedFormula = formulaToRelativeReference(previousFormula, { rowIndex: position.rowIndex, columnIndex: position.columnIndex }, {
+        rowIndex: position.rowIndex + rowDelta,
+        columnIndex: position.columnIndex + columnDelta,
+    }, editedSheetName, {
+        exclusionRange: sourceRange,
+        rowCount,
+        columnCount,
+        referenceSheetName: editedSheetName,
+        includeUnqualifiedReferences: false,
+    });
+    if (!updatedFormula || updatedFormula === previousFormula) {
+        return;
+    }
+    sheetCell.setFormulaValue(updatedFormula, false);
+    currentSheet[position.rowIndex].values[position.columnIndex] =
+        sheetCell.getCellData();
+    const enqueueOperation = sheetCell.ephemeral()
+        ? enqueueCalculation
+        : enqueueGraphOperation;
+    enqueueOperation?.({ type: "remove", position });
+    enqueueOperation?.({ type: "add", position, force: true });
+    recalcCells.set(createSheetCellIdentifier(position.sheetId, position.rowIndex, position.columnIndex), { ...position, force: true });
+};
+const collectExternalFormulaPositions = (getGraphNodes, editedSheetId) => {
+    if (!getGraphNodes)
+        return [];
+    let graphNodes;
+    try {
+        graphNodes = getGraphNodes();
+    }
+    catch {
+        return [];
+    }
+    if (!graphNodes || typeof graphNodes.values !== "function")
+        return [];
+    const positions = [];
+    for (const node of graphNodes.values()) {
+        if (!isCellNode(node) || node.position.sheetId === editedSheetId) {
+            continue;
+        }
+        positions.push(node.position);
+    }
+    return positions;
+};
+/**
+ * Returns formula-cell positions from the dependency graph filtered to a
+ * single sheet and range. Returns `null` when the graph has no nodes for
+ * this sheet — the caller should fall back to a cell sweep.
+ *
+ * Prefers the per-sheet bucket (`getGraphNodesInSheet`) which scales with
+ * `nodes_in_sheet` rather than `nodes_in_workbook`. Falls through to the
+ * workbook-wide map only when the per-sheet API isn't available.
+ */
+const collectGraphFormulaPositions = (getGraphNodesInSheet, getGraphNodes, sheetId, movedRegion) => {
+    // Fast path: per-sheet bucket.
+    if (getGraphNodesInSheet) {
+        let sheetBucket;
+        try {
+            sheetBucket = getGraphNodesInSheet(sheetId);
+        }
+        catch {
+            sheetBucket = undefined;
+        }
+        if (sheetBucket &&
+            typeof sheetBucket.values === "function") {
+            const positions = [];
+            for (const node of sheetBucket.values()) {
+                if (!isCellNode(node))
+                    continue;
+                const pos = node.position;
+                if (pos.rowIndex < movedRegion.startRowIndex ||
+                    pos.rowIndex > movedRegion.endRowIndex ||
+                    pos.columnIndex < movedRegion.startColumnIndex ||
+                    pos.columnIndex > movedRegion.endColumnIndex) {
+                    continue;
+                }
+                positions.push({
+                    rowIndex: pos.rowIndex,
+                    columnIndex: pos.columnIndex,
+                });
+            }
+            return positions;
+        }
+    }
+    // Fallback: workbook-wide map (older calculators or test stubs).
+    if (!getGraphNodes)
+        return null;
+    let graphNodes;
+    try {
+        graphNodes = getGraphNodes();
+    }
+    catch {
+        return null;
+    }
+    if (!graphNodes ||
+        typeof graphNodes.values !== "function") {
+        return null;
+    }
+    const positions = [];
+    let sawSheetNode = false;
+    for (const node of graphNodes.values()) {
+        if (!isCellNode(node))
+            continue;
+        const pos = node.position;
+        if (pos.sheetId !== sheetId)
+            continue;
+        sawSheetNode = true;
+        if (pos.rowIndex < movedRegion.startRowIndex ||
+            pos.rowIndex > movedRegion.endRowIndex ||
+            pos.columnIndex < movedRegion.startColumnIndex ||
+            pos.columnIndex > movedRegion.endColumnIndex) {
+            continue;
+        }
+        positions.push({ rowIndex: pos.rowIndex, columnIndex: pos.columnIndex });
+    }
+    return sawSheetNode ? positions : null;
+};

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

@@ -0,0 +1,39 @@
+import { type ParsedToken } from "@rowsncolumns/calculator";
+import type { CellInterface, GridRange } from "@rowsncolumns/common-types";
+import type { BandedRange, FilterView, TableView } from "@rowsncolumns/spreadsheet";
+/**
+ * Get table column index
+ * @param sheetId
+ * @param cell
+ * @param tables
+ */
+export declare const findTableColumnIndex: (sheetId: number, cell: CellInterface, tables: TableView[] | undefined) => number | undefined;
+export declare const findActiveTableWithinCell: (sheetId: number, cell: CellInterface, tables: TableView[] | undefined | null) => TableView | undefined;
+/**
+ * Find table adjacent to a cell
+ * @param sheetId
+ * @param cell
+ * @param tables
+ * @returns
+ */
+export declare const findAdjacentTable: (sheetId: number, cell: CellInterface, tables: TableView[] | undefined, getUserEnteredValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | undefined) => readonly [TableView | undefined, boolean, boolean];
+/**
+ * Find table adjacent to a cell
+ * @param sheetId
+ * @param cell
+ * @param tables
+ * @returns
+ */
+export declare const findAdjacentBandedRange: (sheetId: number, cell: CellInterface, bandedRanges: BandedRange[] | undefined, getUserEnteredValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | undefined) => readonly [BandedRange | undefined, boolean, boolean];
+export declare const isTableColumnCellsFillable: (sheetId: number, range: GridRange, excludeCell: CellInterface, existingColumnFormula: string | undefined, currentValue: string | boolean | undefined, activeSheetName: string, getUserEnteredValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | undefined) => boolean;
+export declare const addTableNameToTokens: (tokens: ParsedToken[], title: string) => string;
+export declare const removeTableName: (tokens: ParsedToken[], title: string) => string;
+/**
+ * Shift tables
+ */
+export declare const shiftTableMovingRows: (table: TableView | FilterView, dims: number[], referenceIndex: number) => void;
+/**
+ * Shift tables
+ */
+export declare const shiftTableMovingColumns: (table: TableView | FilterView, dims: number[], referenceIndex: number) => void;
+//# sourceMappingURL=table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../api/table.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAEjB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACV,MAAM,2BAA2B,CAAC;AAkBnC;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,QAAQ,SAAS,EAAE,GAAG,SAAS,uBAiBhC,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,QAAQ,SAAS,EAAE,GAAG,SAAS,GAAG,IAAI,0BAMvC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,QAAQ,SAAS,EAAE,GAAG,SAAS,EAC/B,qBAAqB,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,SAAS,uDAgDxB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GAClC,SAAS,MAAM,EACf,MAAM,aAAa,EACnB,cAAc,WAAW,EAAE,GAAG,SAAS,EACvC,qBAAqB,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,SAAS,yDA8CxB,CAAC;AAGF,eAAO,MAAM,0BAA0B,GACrC,SAAS,MAAM,EACf,OAAO,SAAS,EAChB,aAAa,aAAa,EAC1B,uBAAuB,MAAM,GAAG,SAAS,EACzC,cAAc,MAAM,GAAG,OAAO,GAAG,SAAS,EAC1C,iBAAiB,MAAM,EACvB,qBAAqB,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,SAAS,YAsExB,CAAC;AAiCF,eAAO,MAAM,oBAAoB,GAAI,QAAQ,WAAW,EAAE,EAAE,OAAO,MAAM,WAyBxE,CAAC;AAcF,eAAO,MAAM,eAAe,GAAI,QAAQ,WAAW,EAAE,EAAE,OAAO,MAAM,WA2BnE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,SAAS,GAAG,UAAU,EAC7B,MAAM,MAAM,EAAE,EACd,gBAAgB,MAAM,SAoDvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,SAAS,GAAG,UAAU,EAC7B,MAAM,MAAM,EAAE,EACd,gBAAgB,MAAM,SAoDvB,CAAC"}