@rowsncolumns/spreadsheet-state 28.0.75 → 29.0.0

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

@@ -89,6 +89,11 @@ export var updateFormulasForStructuralChange = function (params) {
             startColumnIndex: isInsert ? referenceIndex : referenceIndex + count,
             endColumnIndex: columnCount,
         };
+    // The cells a delete removes: any reference into them (that Pass 1 did not
+    // already contract) is broken to `#REF!` instead of sliding onto the cell
+    // that moves into its place.
+    var deletedRange = isInsert ? undefined : pass1Range;
+    var editedSheetName = getSheetName(sheetId);
     // ---- PASS 1 ----
     var pass1Formulas = collectUniqueDependentsForRange({
         draft: draft,
@@ -109,10 +114,15 @@ export var updateFormulasForStructuralChange = function (params) {
                 var formulaValue = sheetCell.formula;
                 if (!formulaValue)
                     continue;
-                var activeSheetName = getSheetName(pos.sheetId);
+                // Scope to the EDITED sheet: a qualified `Sheet1!A1:A3` on another
+                // sheet expands like a local range, while that other sheet's own bare
+                // `A1:A3` (which resolves to ITS sheet) is left alone.
+                var rangeOptions = {
+                    includeUnqualifiedReferences: pos.sheetId === sheetId,
+                };
                 var updatedFormula = isInsert
-                    ? expandRangesInFormula(formulaValue, referenceIndex, count, axis, activeSheetName)
-                    : contractRangesInFormula(formulaValue, referenceIndex, count, axis, activeSheetName);
+                    ? expandRangesInFormula(formulaValue, referenceIndex, count, axis, editedSheetName, rangeOptions)
+                    : contractRangesInFormula(formulaValue, referenceIndex, count, axis, editedSheetName, rangeOptions);
                 if (!updatedFormula || updatedFormula === formulaValue)
                     continue;
                 sheetCell.setFormulaValue(updatedFormula, false);
@@ -180,7 +190,7 @@ export var updateFormulasForStructuralChange = function (params) {
                 shiftExternalDependentFormulaReferences({
                     draft: draft,
                     position: pos,
-                    editedSheetName: getSheetName(sheetId),
+                    editedSheetName: editedSheetName,
                     enqueueCalculation: enqueueCalculation,
                     enqueueGraphOperation: enqueueGraphOperation,
                     recalcCells: recalcCells,
@@ -188,6 +198,7 @@ export var updateFormulasForStructuralChange = function (params) {
                     rowDelta: rowDelta,
                     columnDelta: columnDelta,
                     sourceRange: pass2SourceRange,
+                    deletedRange: deletedRange,
                     locale: locale,
                     rowCount: rowCount,
                     columnCount: columnCount,
@@ -207,6 +218,7 @@ export var updateFormulasForStructuralChange = function (params) {
                 rowDelta: rowDelta,
                 columnDelta: columnDelta,
                 sourceRange: pass2SourceRange,
+                deletedRange: deletedRange,
                 locale: locale,
                 rowCount: rowCount,
                 columnCount: columnCount,
@@ -231,7 +243,7 @@ export var updateFormulasForStructuralChange = function (params) {
             shiftExternalDependentFormulaReferences({
                 draft: draft,
                 position: position,
-                editedSheetName: getSheetName(sheetId),
+                editedSheetName: editedSheetName,
                 enqueueCalculation: enqueueCalculation,
                 enqueueGraphOperation: enqueueGraphOperation,
                 recalcCells: recalcCells,
@@ -239,6 +251,7 @@ export var updateFormulasForStructuralChange = function (params) {
                 rowDelta: rowDelta,
                 columnDelta: columnDelta,
                 sourceRange: pass2SourceRange,
+                deletedRange: deletedRange,
                 locale: locale,
                 rowCount: rowCount,
                 columnCount: columnCount,
@@ -284,6 +297,7 @@ export var updateFormulasForStructuralChange = function (params) {
                         rowIndex: pos.rowIndex,
                         columnIndex: pos.columnIndex,
                     },
+                    activeSheetName: editedSheetName,
                     enqueueCalculation: enqueueCalculation,
                     enqueueGraphOperation: enqueueGraphOperation,
                     recalcCells: recalcCells,
@@ -291,6 +305,7 @@ export var updateFormulasForStructuralChange = function (params) {
                     rowDelta: rowDelta,
                     columnDelta: columnDelta,
                     sourceRange: pass2SourceRange,
+                    deletedRange: deletedRange,
                     locale: locale,
                     rowCount: rowCount,
                     columnCount: columnCount,
@@ -328,6 +343,7 @@ export var updateFormulasForStructuralChange = function (params) {
                 moveFormulaAtPosition({
                     draft: draft,
                     position: { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex },
+                    activeSheetName: editedSheetName,
                     enqueueCalculation: enqueueCalculation,
                     enqueueGraphOperation: enqueueGraphOperation,
                     recalcCells: recalcCells,
@@ -335,6 +351,7 @@ export var updateFormulasForStructuralChange = function (params) {
                     rowDelta: rowDelta,
                     columnDelta: columnDelta,
                     sourceRange: pass2SourceRange,
+                    deletedRange: deletedRange,
                     locale: locale,
                     rowCount: rowCount,
                     columnCount: columnCount,
@@ -347,7 +364,7 @@ export var updateFormulasForStructuralChange = function (params) {
 };
 var shiftExternalDependentFormulaReferences = function (_a) {
     var _b, _c;
-    var draft = _a.draft, position = _a.position, editedSheetName = _a.editedSheetName, enqueueCalculation = _a.enqueueCalculation, enqueueGraphOperation = _a.enqueueGraphOperation, recalcCells = _a.recalcCells, movedKeys = _a.movedKeys, rowDelta = _a.rowDelta, columnDelta = _a.columnDelta, sourceRange = _a.sourceRange, locale = _a.locale, rowCount = _a.rowCount, columnCount = _a.columnCount, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry;
+    var draft = _a.draft, position = _a.position, editedSheetName = _a.editedSheetName, enqueueCalculation = _a.enqueueCalculation, enqueueGraphOperation = _a.enqueueGraphOperation, recalcCells = _a.recalcCells, movedKeys = _a.movedKeys, rowDelta = _a.rowDelta, columnDelta = _a.columnDelta, sourceRange = _a.sourceRange, deletedRange = _a.deletedRange, locale = _a.locale, rowCount = _a.rowCount, columnCount = _a.columnCount, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry;
     var sheetCell = new SheetCell();
     var currentSheet = createSheetDraft(draft, position.sheetId, position.rowIndex);
     var cellData = (_c = (_b = currentSheet[position.rowIndex]) === null || _b === void 0 ? void 0 : _b.values) === null || _c === void 0 ? void 0 : _c[position.columnIndex];
@@ -362,6 +379,7 @@ var shiftExternalDependentFormulaReferences = function (_a) {
         columnIndex: position.columnIndex + columnDelta,
     }, editedSheetName, {
         exclusionRange: sourceRange,
+        deletedRange: deletedRange,
         rowCount: rowCount,
         columnCount: columnCount,
         referenceSheetName: editedSheetName,

package/dist/cjs/api/structural-guards.d.ts

@@ -0,0 +1,78 @@
+import type { CellData, CellInterface, GridRange, SelectionArea } from "@rowsncolumns/common-types";
+import type { SelectionAttributes, TableView } from "@rowsncolumns/spreadsheet";
+import { type StructuralRefusal } from "../constants";
+import type { SheetData } from "../hooks/use-spreadsheet-state";
+/**
+ * Pure predicates behind Excel's structural-edit refusals. The hooks run them BEFORE the interface
+ * function touches any state and `showError` the Excel message on refusal, so a refused edit leaves
+ * sheetData / merges / tables / selection exactly as they were.
+ *
+ * A "band" is the rectangle of cells an edit relocates. Shift cells down at `B2:B3` moves
+ * `B2:B∞` — an open end is expressed with `Number.POSITIVE_INFINITY`.
+ */
+export type StructuralBand = GridRange;
+export type ShiftDirection = "down" | "right" | "up" | "left";
+/** The selection a cell shift operates on — the LAST selection, or the active cell as a 1×1. The
+ * hooks' guards and the interface functions must agree on it, so both resolve it here. */
+export declare const resolveShiftSelection: (activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => SelectionArea<SelectionAttributes>;
+/** The cells a shift relocates: the selection's rows/columns from its leading edge to the sheet edge. */
+export declare const shiftBand: (direction: ShiftDirection, range: GridRange) => StructuralBand;
+export declare const isNonBlankCell: (cell: CellData | null | undefined) => boolean;
+/**
+ * INS-06 / INS-09 / SHF-10 — the first non-blank cell that a shift of `count` rows (axis `row`) or
+ * columns (axis `column`) would push past `limit` (the last valid row/column index). Only cells
+ * inside `band` move. `undefined` when the edit is safe.
+ */
+export declare const findOffSheetPush: <T extends CellData>({ rows, axis, count, limit, band, }: {
+    rows: SheetData<T>[number] | undefined;
+    axis: "row" | "column";
+    count: number;
+    limit: number | undefined;
+    band: StructuralBand;
+}) => CellInterface | undefined;
+/**
+ * A range the band reaches but does not contain whole is TORN by the shift. For a delete, a range
+ * that touches the deleted block must lie wholly inside it (it is removed with the block) — one
+ * straddling the block's edge is torn too.
+ */
+export declare const findTornRange: (ranges: readonly GridRange[] | undefined | null, band: StructuralBand, deletedBlock?: GridRange) => GridRange | undefined;
+/** SHF-05 / MRG-07 — a merge the band covers only partially. */
+export declare const findTornMerge: (merges: readonly GridRange[] | undefined | null, band: StructuralBand, deletedBlock?: GridRange) => GridRange | undefined;
+/** TBL-05 — a table the band covers only partially (a table wholly inside the band moves intact). */
+export declare const findTornTable: (tables: readonly TableView[] | undefined | null, sheetId: number, band: StructuralBand, deletedBlock?: GridRange) => TableView | undefined;
+/** ANC-14 — a CSE / dynamic-array range the band covers only partially. */
+export declare const findTornArray: (arrayRanges: readonly GridRange[] | undefined | null, band: StructuralBand, deletedBlock?: GridRange) => GridRange | undefined;
+/** Ranges (merges / tables) that travel with the band: wholly inside it and, for a delete, not
+ * inside the deleted block. */
+export declare const isRangeInsideBand: (range: GridRange, band: StructuralBand) => boolean;
+export declare const isRangeInsideBlock: (outer: GridRange, inner: GridRange) => boolean;
+/**
+ * The Excel refusal (if any) for an insert/delete-cells shift of `range`. Checks run in Excel's
+ * order: array tear, merge tear, table tear, off-sheet push. `undefined` means the edit may proceed.
+ */
+export declare const getShiftCellsRefusal: <T extends CellData>({ direction, range, sheetId, rows, rowCount, columnCount, merges, tables, arrayRanges, }: {
+    direction: ShiftDirection;
+    range: GridRange;
+    sheetId: number;
+    rows: SheetData<T>[number] | undefined;
+    /** Last valid row index for a vertical shift (the grid does not grow on a cell shift). */
+    rowCount?: number;
+    /** Last valid column index for a horizontal shift. */
+    columnCount?: number;
+    merges?: readonly GridRange[] | null;
+    tables?: readonly TableView[] | null;
+    arrayRanges?: readonly GridRange[] | null;
+}) => StructuralRefusal | undefined;
+/**
+ * INS-06 / INS-09 — the refusal for a whole-row (`axis: "row"`) or whole-column insert of `count`
+ * lines before `referenceIndex`, given the hard grid cap (`maxRowCount` / `maxColumnCount`). Blank
+ * trailing lines may fall off the end; a non-blank one refuses the insert.
+ */
+export declare const getInsertLinesRefusal: <T extends CellData>({ axis, referenceIndex, count, rows, limit, }: {
+    axis: "row" | "column";
+    referenceIndex: number;
+    count: number;
+    rows: SheetData<T>[number] | undefined;
+    limit: number | undefined;
+}) => StructuralRefusal | undefined;
+//# sourceMappingURL=structural-guards.d.ts.map

package/dist/cjs/api/structural-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structural-guards.d.ts","sourceRoot":"","sources":["../../../api/structural-guards.ts"],"names":[],"mappings":"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"}

package/dist/cjs/api/structural-guards.js

@@ -0,0 +1,202 @@
+import { __read } from "tslib";
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { structuralRefusal, } from "../constants";
+/** The selection a cell shift operates on — the LAST selection, or the active cell as a 1×1. The
+ * hooks' guards and the interface functions must agree on it, so both resolve it here. */
+export var resolveShiftSelection = function (activeCell, selections) {
+    var finalSelections = selections.length
+        ? selections
+        : selectionFromActiveCell(activeCell);
+    return finalSelections[finalSelections.length - 1];
+};
+var rangesIntersect = function (a, b) {
+    return a.startRowIndex <= b.endRowIndex &&
+        a.endRowIndex >= b.startRowIndex &&
+        a.startColumnIndex <= b.endColumnIndex &&
+        a.endColumnIndex >= b.startColumnIndex;
+};
+var rangeContains = function (outer, inner) {
+    return inner.startRowIndex >= outer.startRowIndex &&
+        inner.endRowIndex <= outer.endRowIndex &&
+        inner.startColumnIndex >= outer.startColumnIndex &&
+        inner.endColumnIndex <= outer.endColumnIndex;
+};
+/** The cells a shift relocates: the selection's rows/columns from its leading edge to the sheet edge. */
+export var shiftBand = function (direction, range) {
+    switch (direction) {
+        case "down":
+        case "up":
+            return {
+                startRowIndex: range.startRowIndex,
+                endRowIndex: Number.POSITIVE_INFINITY,
+                startColumnIndex: range.startColumnIndex,
+                endColumnIndex: range.endColumnIndex,
+            };
+        case "right":
+        case "left":
+            return {
+                startRowIndex: range.startRowIndex,
+                endRowIndex: range.endRowIndex,
+                startColumnIndex: range.startColumnIndex,
+                endColumnIndex: Number.POSITIVE_INFINITY,
+            };
+    }
+};
+/**
+ * A cell counts as non-blank when it carries a value, a formula, a format, a note, a link or a
+ * citation — Excel's "might appear empty but have blank values, some formatting, or a formula".
+ * Derived render results (CF / DV results) don't count.
+ */
+var DERIVED_CELL_KEYS = new Set([
+    "conditionalFormattingResultById",
+    "dataValidationResult",
+]);
+export var isNonBlankCell = function (cell) {
+    if (!cell)
+        return false;
+    return Object.entries(cell).some(function (_a) {
+        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+        return !DERIVED_CELL_KEYS.has(key) && value !== undefined && value !== null;
+    });
+};
+/**
+ * INS-06 / INS-09 / SHF-10 — the first non-blank cell that a shift of `count` rows (axis `row`) or
+ * columns (axis `column`) would push past `limit` (the last valid row/column index). Only cells
+ * inside `band` move. `undefined` when the edit is safe.
+ */
+export var findOffSheetPush = function (_a) {
+    var _b, _c;
+    var rows = _a.rows, axis = _a.axis, count = _a.count, limit = _a.limit, band = _a.band;
+    if (!rows || limit === undefined || count <= 0)
+        return undefined;
+    var firstPushed = limit - count + 1;
+    if (axis === "row") {
+        var startRow_1 = Math.max(band.startRowIndex, firstPushed, 1);
+        for (var rowIndex = startRow_1; rowIndex < rows.length; rowIndex++) {
+            var values = (_b = rows[rowIndex]) === null || _b === void 0 ? void 0 : _b.values;
+            if (!values)
+                continue;
+            var startCol = Math.max(band.startColumnIndex, 1);
+            var endCol = Math.min(band.endColumnIndex, values.length - 1);
+            for (var columnIndex = startCol; columnIndex <= endCol; columnIndex++) {
+                if (isNonBlankCell(values[columnIndex])) {
+                    return { rowIndex: rowIndex, columnIndex: columnIndex };
+                }
+            }
+        }
+        return undefined;
+    }
+    var startRow = Math.max(band.startRowIndex, 1);
+    var endRow = Math.min(band.endRowIndex, rows.length - 1);
+    for (var rowIndex = startRow; rowIndex <= endRow; rowIndex++) {
+        var values = (_c = rows[rowIndex]) === null || _c === void 0 ? void 0 : _c.values;
+        if (!values)
+            continue;
+        var startCol = Math.max(band.startColumnIndex, firstPushed, 1);
+        for (var columnIndex = startCol; columnIndex < values.length; columnIndex++) {
+            if (isNonBlankCell(values[columnIndex])) {
+                return { rowIndex: rowIndex, columnIndex: columnIndex };
+            }
+        }
+    }
+    return undefined;
+};
+/**
+ * A range the band reaches but does not contain whole is TORN by the shift. For a delete, a range
+ * that touches the deleted block must lie wholly inside it (it is removed with the block) — one
+ * straddling the block's edge is torn too.
+ */
+export var findTornRange = function (ranges, band, deletedBlock) {
+    if (!ranges)
+        return undefined;
+    return ranges.find(function (range) {
+        if (rangesIntersect(range, band) && !rangeContains(band, range)) {
+            return true;
+        }
+        if (deletedBlock &&
+            rangesIntersect(range, deletedBlock) &&
+            !rangeContains(deletedBlock, range)) {
+            return true;
+        }
+        return false;
+    });
+};
+/** SHF-05 / MRG-07 — a merge the band covers only partially. */
+export var findTornMerge = function (merges, band, deletedBlock) { return findTornRange(merges, band, deletedBlock); };
+/** TBL-05 — a table the band covers only partially (a table wholly inside the band moves intact). */
+export var findTornTable = function (tables, sheetId, band, deletedBlock) {
+    if (!tables)
+        return undefined;
+    return tables.find(function (table) {
+        return table.sheetId === sheetId &&
+            !!findTornRange([table.range], band, deletedBlock);
+    });
+};
+/** ANC-14 — a CSE / dynamic-array range the band covers only partially. */
+export var findTornArray = function (arrayRanges, band, deletedBlock) { return findTornRange(arrayRanges, band, deletedBlock); };
+/** Ranges (merges / tables) that travel with the band: wholly inside it and, for a delete, not
+ * inside the deleted block. */
+export var isRangeInsideBand = function (range, band) {
+    return rangeContains(band, range);
+};
+export var isRangeInsideBlock = rangeContains;
+/**
+ * The Excel refusal (if any) for an insert/delete-cells shift of `range`. Checks run in Excel's
+ * order: array tear, merge tear, table tear, off-sheet push. `undefined` means the edit may proceed.
+ */
+export var getShiftCellsRefusal = function (_a) {
+    var direction = _a.direction, range = _a.range, sheetId = _a.sheetId, rows = _a.rows, rowCount = _a.rowCount, columnCount = _a.columnCount, merges = _a.merges, tables = _a.tables, arrayRanges = _a.arrayRanges;
+    var band = shiftBand(direction, range);
+    var isDelete = direction === "up" || direction === "left";
+    var deletedBlock = isDelete ? range : undefined;
+    if (findTornArray(arrayRanges, band, deletedBlock)) {
+        return structuralRefusal("torn-array");
+    }
+    if (findTornMerge(merges, band, deletedBlock)) {
+        return structuralRefusal("torn-merge");
+    }
+    if (findTornTable(tables, sheetId, band, deletedBlock)) {
+        return structuralRefusal("torn-table");
+    }
+    if (!isDelete) {
+        var vertical = direction === "down";
+        var count = vertical
+            ? range.endRowIndex - range.startRowIndex + 1
+            : range.endColumnIndex - range.startColumnIndex + 1;
+        var pushed = findOffSheetPush({
+            rows: rows,
+            axis: vertical ? "row" : "column",
+            count: count,
+            limit: vertical ? rowCount : columnCount,
+            band: band,
+        });
+        if (pushed) {
+            return structuralRefusal("off-sheet-push");
+        }
+    }
+    return undefined;
+};
+/**
+ * INS-06 / INS-09 — the refusal for a whole-row (`axis: "row"`) or whole-column insert of `count`
+ * lines before `referenceIndex`, given the hard grid cap (`maxRowCount` / `maxColumnCount`). Blank
+ * trailing lines may fall off the end; a non-blank one refuses the insert.
+ */
+export var getInsertLinesRefusal = function (_a) {
+    var axis = _a.axis, referenceIndex = _a.referenceIndex, count = _a.count, rows = _a.rows, limit = _a.limit;
+    var band = axis === "row"
+        ? {
+            startRowIndex: referenceIndex,
+            endRowIndex: Number.POSITIVE_INFINITY,
+            startColumnIndex: 1,
+            endColumnIndex: Number.POSITIVE_INFINITY,
+        }
+        : {
+            startRowIndex: 1,
+            endRowIndex: Number.POSITIVE_INFINITY,
+            startColumnIndex: referenceIndex,
+            endColumnIndex: Number.POSITIVE_INFINITY,
+        };
+    return findOffSheetPush({ rows: rows, axis: axis, count: count, limit: limit, band: band })
+        ? structuralRefusal("off-sheet-push")
+        : undefined;
+};

package/dist/cjs/api/structural-table-refs.d.ts

@@ -0,0 +1,94 @@
+import type { GridRange } from "@rowsncolumns/common-types";
+import type { CellData, TableView } 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";
+/**
+ * The table parts a row/column delete takes away, computed from the PRE-edit
+ * table definitions: tables the delete removes entirely, and — for a column
+ * delete — the named columns it drops out of the tables that survive. Excel
+ * breaks the structured references into them: `=SUM(Table1[Price])` →
+ * `=SUM(#REF!)` once Table1 is gone, `=Table1[@Qty]*2` → `=Table1[@#REF!]*2`
+ * once the `Qty` column is deleted, so the cell shows `#REF!` rather than a
+ * stale value, `#NAME?` or `#VALUE!`.
+ */
+export type RemovedTableParts = {
+    tables: string[];
+    columns: Array<{
+        table: string;
+        sheetId: number;
+        /** Pre-edit range, to attribute bare `[@Col]` references to this table. */
+        range: GridRange;
+        columns: string[];
+    }>;
+};
+/**
+ * Which tables / table columns `deleteRow` (a table goes with its header row)
+ * or `deleteColumn` (a table goes when every column is deleted; otherwise the
+ * covered columns are spliced out) removes for the band
+ * `[minIndex, maxIndex]` on `sheetId`. Mirrors the table updates those
+ * interfaces apply to `tables`.
+ */
+export declare const collectRemovedTableParts: (tables: TableView[] | undefined, sheetId: number, axis: StructuralAxis, minIndex: number, maxIndex: number) => RemovedTableParts;
+export type BreakStructuredRefsParams<T extends CellData> = {
+    draft: Draft<SheetData<T>>;
+    /** The edited sheet. */
+    sheetId: number;
+    axis: StructuralAxis;
+    /** Smallest deleted index and the number of deleted rows/columns. */
+    referenceIndex: number;
+    count: number;
+    removed: RemovedTableParts;
+    getGraphNodes?: ReturnType<typeof useCalculation>["getGraphNodes"];
+    enqueueCalculation?: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    enqueueGraphOperation?: ReturnType<typeof useCalculation>["enqueueGraphOperation"];
+    recalcCells: Map<string, RecalcCellCoordinate>;
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+};
+/**
+ * Rewrite, across every sheet, the structured references that point at the
+ * table parts a delete removes (see `RemovedTableParts`). Runs BEFORE the
+ * splice, so bare `[@Col]` references are attributed to the table by the
+ * formula's pre-edit position. Formula cells come from the dependency graph
+ * when it is available (cost O(formula cells)); without one the draft is swept.
+ */
+export declare const breakStructuredRefsForRemovedTableParts: <T extends CellData>({ draft, sheetId, axis, referenceIndex, count, removed, getGraphNodes, enqueueCalculation, enqueueGraphOperation, recalcCells, locale, cellXfsRegistry, sharedStringRegistry, }: BreakStructuredRefsParams<T>) => void;
+/**
+ * Drop the materialised spill cells of every dynamic-array anchor that sits
+ * inside the deleted band `[minIndex, maxIndex]` (rows or columns) of
+ * `sheetId`. Spilled values live in the sheet data as computed-only cells (no
+ * `ue`); once the anchor goes with its row/column they would otherwise slide
+ * into place as orphan plain values (Excel: the whole spill disappears).
+ * Runs BEFORE the splice. The anchor records its spill as an A1 range in `af`.
+ */
+export type SpillRange = {
+    startRowIndex: number;
+    startColumnIndex: number;
+    endRowIndex: number;
+    endColumnIndex: number;
+};
+/** The calculator's live spill rectangle for an anchor cell, if it spills. */
+export type GetArrayRange = (position: {
+    sheetId: number;
+    rowIndex: number;
+    columnIndex: number;
+}) => SpillRange | undefined;
+export declare const removeSpillsOfDeletedAnchors: <T extends CellData>({ draft, sheetId, axis, minIndex, maxIndex, getArrayRange, locale, cellXfsRegistry, sharedStringRegistry, }: {
+    draft: Draft<SheetData<T>>;
+    sheetId: number;
+    axis: StructuralAxis;
+    minIndex: number;
+    maxIndex: number;
+    getArrayRange?: GetArrayRange;
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+}) => void;
+export {};
+//# sourceMappingURL=structural-table-refs.d.ts.map

package/dist/cjs/api/structural-table-refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structural-table-refs.d.ts","sourceRoot":"","sources":["../../../api/structural-table-refs.ts"],"names":[],"mappings":"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"}