@rowsncolumns/spreadsheet-state 28.0.75 → 28.0.76

package/dist/esm/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/esm/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/esm/api/structural-guards.js

@@ -0,0 +1,186 @@
+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 const resolveShiftSelection = (activeCell, selections) => {
+    const finalSelections = selections.length
+        ? selections
+        : selectionFromActiveCell(activeCell);
+    return finalSelections[finalSelections.length - 1];
+};
+const rangesIntersect = (a, b) => a.startRowIndex <= b.endRowIndex &&
+    a.endRowIndex >= b.startRowIndex &&
+    a.startColumnIndex <= b.endColumnIndex &&
+    a.endColumnIndex >= b.startColumnIndex;
+const rangeContains = (outer, inner) => 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 const shiftBand = (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.
+ */
+const DERIVED_CELL_KEYS = new Set([
+    "conditionalFormattingResultById",
+    "dataValidationResult",
+]);
+export const isNonBlankCell = (cell) => {
+    if (!cell)
+        return false;
+    return Object.entries(cell).some(([key, value]) => !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 const findOffSheetPush = ({ rows, axis, count, limit, band, }) => {
+    if (!rows || limit === undefined || count <= 0)
+        return undefined;
+    const firstPushed = limit - count + 1;
+    if (axis === "row") {
+        const startRow = Math.max(band.startRowIndex, firstPushed, 1);
+        for (let rowIndex = startRow; rowIndex < rows.length; rowIndex++) {
+            const values = rows[rowIndex]?.values;
+            if (!values)
+                continue;
+            const startCol = Math.max(band.startColumnIndex, 1);
+            const endCol = Math.min(band.endColumnIndex, values.length - 1);
+            for (let columnIndex = startCol; columnIndex <= endCol; columnIndex++) {
+                if (isNonBlankCell(values[columnIndex])) {
+                    return { rowIndex, columnIndex };
+                }
+            }
+        }
+        return undefined;
+    }
+    const startRow = Math.max(band.startRowIndex, 1);
+    const endRow = Math.min(band.endRowIndex, rows.length - 1);
+    for (let rowIndex = startRow; rowIndex <= endRow; rowIndex++) {
+        const values = rows[rowIndex]?.values;
+        if (!values)
+            continue;
+        const startCol = Math.max(band.startColumnIndex, firstPushed, 1);
+        for (let columnIndex = startCol; columnIndex < values.length; columnIndex++) {
+            if (isNonBlankCell(values[columnIndex])) {
+                return { rowIndex, 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 const findTornRange = (ranges, band, deletedBlock) => {
+    if (!ranges)
+        return undefined;
+    return ranges.find((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 const findTornMerge = (merges, band, deletedBlock) => findTornRange(merges, band, deletedBlock);
+/** TBL-05 — a table the band covers only partially (a table wholly inside the band moves intact). */
+export const findTornTable = (tables, sheetId, band, deletedBlock) => {
+    if (!tables)
+        return undefined;
+    return tables.find((table) => table.sheetId === sheetId &&
+        !!findTornRange([table.range], band, deletedBlock));
+};
+/** ANC-14 — a CSE / dynamic-array range the band covers only partially. */
+export const findTornArray = (arrayRanges, band, deletedBlock) => 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 const isRangeInsideBand = (range, band) => rangeContains(band, range);
+export const 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 const getShiftCellsRefusal = ({ direction, range, sheetId, rows, rowCount, columnCount, merges, tables, arrayRanges, }) => {
+    const band = shiftBand(direction, range);
+    const isDelete = direction === "up" || direction === "left";
+    const 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) {
+        const vertical = direction === "down";
+        const count = vertical
+            ? range.endRowIndex - range.startRowIndex + 1
+            : range.endColumnIndex - range.startColumnIndex + 1;
+        const pushed = findOffSheetPush({
+            rows,
+            axis: vertical ? "row" : "column",
+            count,
+            limit: vertical ? rowCount : columnCount,
+            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 const getInsertLinesRefusal = ({ axis, referenceIndex, count, rows, limit, }) => {
+    const 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, axis, count, limit, band })
+        ? structuralRefusal("off-sheet-push")
+        : undefined;
+};

package/dist/esm/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/esm/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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"}

package/dist/esm/api/structural-table-refs.js

@@ -0,0 +1,219 @@
+import { isCellNode } from "@rowsncolumns/dag";
+import { addressToCell, getCellUserEnteredValue, getExtendedValueFormula, } from "@rowsncolumns/utils";
+import { SheetCell } from "../sheet-cell";
+import { breakTableColumnsInFormula, breakTableReferencesInFormula, createSheetCellIdentifier, } from "./formula";
+import { createSheetDraft } from "./immer-utils";
+/**
+ * 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 const collectRemovedTableParts = (tables, sheetId, axis, minIndex, maxIndex) => {
+    const removed = { tables: [], columns: [] };
+    for (const table of tables ?? []) {
+        if (table.sheetId !== sheetId || !table.title)
+            continue;
+        if (axis === "row") {
+            const { startRowIndex } = table.range;
+            if (startRowIndex >= minIndex && startRowIndex <= maxIndex) {
+                removed.tables.push(table.title);
+            }
+            continue;
+        }
+        const { startColumnIndex, endColumnIndex } = table.range;
+        if (maxIndex < startColumnIndex || minIndex > endColumnIndex)
+            continue;
+        if (minIndex <= startColumnIndex && maxIndex >= endColumnIndex) {
+            removed.tables.push(table.title);
+            continue;
+        }
+        const overlapStart = Math.max(minIndex, startColumnIndex);
+        const overlapEnd = Math.min(maxIndex, endColumnIndex);
+        const names = [];
+        for (let column = overlapStart; column <= overlapEnd; column++) {
+            const name = table.columns?.[column - startColumnIndex]?.name;
+            if (name)
+                names.push(name);
+        }
+        if (names.length) {
+            removed.columns.push({
+                table: table.title,
+                sheetId,
+                range: table.range,
+                columns: names,
+            });
+        }
+    }
+    return removed;
+};
+const isEmptyRemoval = (removed) => removed.tables.length === 0 && removed.columns.length === 0;
+const isWithinRange = (range, rowIndex, columnIndex) => rowIndex >= range.startRowIndex &&
+    rowIndex <= range.endRowIndex &&
+    columnIndex >= range.startColumnIndex &&
+    columnIndex <= range.endColumnIndex;
+/**
+ * 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 const breakStructuredRefsForRemovedTableParts = ({ draft, sheetId, axis, referenceIndex, count, removed, getGraphNodes, enqueueCalculation, enqueueGraphOperation, recalcCells, locale, cellXfsRegistry, sharedStringRegistry, }) => {
+    if (isEmptyRemoval(removed))
+        return;
+    const sheetCell = new SheetCell();
+    const isRow = axis === "row";
+    const afterBand = referenceIndex + count;
+    for (const pos of collectFormulaPositions(draft, getGraphNodes)) {
+        const currentSheet = createSheetDraft(draft, pos.sheetId, pos.rowIndex);
+        const cellData = currentSheet[pos.rowIndex]?.values?.[pos.columnIndex];
+        const formula = getExtendedValueFormula(getCellUserEnteredValue(cellData));
+        if (!formula || !formula.includes("["))
+            continue;
+        let updated = formula;
+        for (const table of removed.tables) {
+            updated = breakTableReferencesInFormula(updated, table);
+        }
+        for (const entry of removed.columns) {
+            updated = breakTableColumnsInFormula(updated, entry.table, entry.columns);
+            // A bare `[@Col]` belongs to the table the formula cell sits in.
+            if (pos.sheetId === entry.sheetId &&
+                isWithinRange(entry.range, pos.rowIndex, pos.columnIndex)) {
+                updated = breakTableColumnsInFormula(updated, undefined, entry.columns);
+            }
+        }
+        if (updated === formula)
+            continue;
+        sheetCell.assign(pos.sheetId, { rowIndex: pos.rowIndex, columnIndex: pos.columnIndex }, cellData, { locale, cellXfsRegistry, sharedStringRegistry });
+        sheetCell.setFormulaValue(updated, false);
+        currentSheet[pos.rowIndex].values[pos.columnIndex] =
+            sheetCell.getCellData();
+        // Where the cell ends up after the splice that follows (cells strictly
+        // after the deleted band on the edited sheet close up by `count`).
+        const shifts = pos.sheetId === sheetId &&
+            (isRow ? pos.rowIndex : pos.columnIndex) >= afterBand;
+        const nextPosition = {
+            sheetId: pos.sheetId,
+            rowIndex: pos.rowIndex - (shifts && isRow ? count : 0),
+            columnIndex: pos.columnIndex - (shifts && !isRow ? count : 0),
+        };
+        const enqueueOperation = sheetCell.ephemeral()
+            ? enqueueCalculation
+            : enqueueGraphOperation;
+        enqueueOperation?.({ type: "remove", position: pos });
+        enqueueOperation?.({ type: "add", position: nextPosition, force: true });
+        recalcCells.set(createSheetCellIdentifier(nextPosition.sheetId, nextPosition.rowIndex, nextPosition.columnIndex), { ...nextPosition, force: true });
+    }
+};
+const collectFormulaPositions = (draft, getGraphNodes) => {
+    if (getGraphNodes) {
+        let graphNodes;
+        try {
+            graphNodes = getGraphNodes();
+        }
+        catch {
+            graphNodes = undefined;
+        }
+        if (graphNodes && typeof graphNodes.values === "function") {
+            const positions = [];
+            let sawNode = false;
+            for (const node of graphNodes.values()) {
+                if (!isCellNode(node))
+                    continue;
+                sawNode = true;
+                positions.push({ ...node.position });
+            }
+            if (sawNode)
+                return positions;
+        }
+    }
+    // Fallback sweep (no graph, or an empty one): every formula cell in the draft.
+    const positions = [];
+    for (const key of Object.keys(draft)) {
+        const sheetId = Number(key);
+        const rows = draft[sheetId];
+        if (!rows)
+            continue;
+        rows.forEach((row, rowIndex) => {
+            row?.values?.forEach((cellData, columnIndex) => {
+                if (getExtendedValueFormula(getCellUserEnteredValue(cellData))) {
+                    positions.push({ sheetId, rowIndex, columnIndex });
+                }
+            });
+        });
+    }
+    return positions;
+};
+export const removeSpillsOfDeletedAnchors = ({ draft, sheetId, axis, minIndex, maxIndex, getArrayRange, locale, cellXfsRegistry, sharedStringRegistry, }) => {
+    const sheetRows = draft[sheetId];
+    if (!sheetRows)
+        return;
+    const sheetCell = new SheetCell();
+    const anchors = [];
+    const collect = (rowIndex, columnIndex) => {
+        const cellData = sheetRows[rowIndex]?.values?.[columnIndex];
+        if (!cellData)
+            return;
+        // The calculator knows the current spill; the persisted `af` (written on
+        // calc success by hosts that track it) is the fallback.
+        const live = getExtendedValueFormula(getCellUserEnteredValue(cellData)) !== undefined
+            ? getArrayRange?.({ sheetId, rowIndex, columnIndex })
+            : undefined;
+        const range = live ?? spillRangeFromRef(cellData.af);
+        if (range)
+            anchors.push({ rowIndex, columnIndex, range });
+    };
+    if (axis === "row") {
+        for (let rowIndex = minIndex; rowIndex <= maxIndex; rowIndex++) {
+            sheetRows[rowIndex]?.values?.forEach((_cell, columnIndex) => collect(rowIndex, columnIndex));
+        }
+    }
+    else {
+        sheetRows.forEach((row, rowIndex) => {
+            if (!row?.values)
+                return;
+            for (let columnIndex = minIndex; columnIndex <= maxIndex; columnIndex++) {
+                collect(rowIndex, columnIndex);
+            }
+        });
+    }
+    for (const anchor of anchors) {
+        const { range } = anchor;
+        for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+            const rowValues = sheetRows[rowIndex]?.values;
+            if (!rowValues)
+                continue;
+            for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                if (rowIndex === anchor.rowIndex &&
+                    columnIndex === anchor.columnIndex) {
+                    continue;
+                }
+                const cellData = rowValues[columnIndex];
+                if (!cellData || getCellUserEnteredValue(cellData) !== undefined) {
+                    continue;
+                }
+                sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, { locale, cellXfsRegistry, sharedStringRegistry });
+                sheetCell.deleteContents();
+                rowValues[columnIndex] = sheetCell.getCellData();
+            }
+        }
+    }
+};
+/** `C1:C3` (the anchor's persisted `af`) → its rectangle; `undefined` when absent/unparseable. */
+const spillRangeFromRef = (ref) => {
+    if (!ref)
+        return undefined;
+    const [startAddress, endAddress] = ref.split(":");
+    const start = addressToCell(startAddress);
+    const end = addressToCell(endAddress ?? startAddress);
+    if (!start || !end)
+        return undefined;
+    return {
+        startRowIndex: start.rowIndex,
+        startColumnIndex: start.columnIndex,
+        endRowIndex: end.rowIndex,
+        endColumnIndex: end.columnIndex,
+    };
+};

package/dist/esm/constants.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Excel's refusal messages for structural edits (insert/delete cells with shift, whole row/column
+ * insert, move/cut). The engines refuse the edit and leave the document untouched; the UI shows the
+ * message. Shared by the legacy JS hooks (`api/structural-guards.ts`) and the rnc engine's
+ * `CommitResult.rejected` channel (`libs/rnc-engine`), so both surfaces speak the same words.
+ */
+export declare const STRUCTURAL_REFUSAL_TITLE = "Microsoft Excel";
+/** INS-06 / INS-09 / SHF-10 — a non-blank (or formatted) cell would be pushed past the last row/column. */
+export declare const OFF_SHEET_PUSH_MESSAGE = "Microsoft Excel can't insert new cells because it would push non-empty cells off the end of the worksheet. These non-empty cells might appear empty but have blank values, some formatting, or a formula. Delete enough rows or columns to make room for what you want to insert and then try again.";
+/** SHF-05 / MRG-07 — the shifted band covers only part of a merged cell. */
+export declare const MERGED_CELL_REFUSAL_MESSAGE = "We can't do that to a merged cell.";
+/** TBL-05 — the shifted band would tear a table apart. */
+export declare const TABLE_SHIFT_REFUSAL_MESSAGE = "This won't work because it would move cells in a table on your worksheet.";
+/** ANC-14 — the shifted band covers only part of a CSE / dynamic array. */
+export declare const ARRAY_REFUSAL_MESSAGE = "You can't change part of an array.";
+/** Machine-readable refusal codes — the rnc engine's `CommitResult.rejected.code` uses the same set. */
+export type StructuralRefusalCode = "off-sheet-push" | "torn-merge" | "torn-table" | "torn-array";
+export type StructuralRefusal = {
+    code: StructuralRefusalCode;
+    title: string;
+    message: string;
+};
+export declare const STRUCTURAL_REFUSAL_MESSAGES: Record<StructuralRefusalCode, string>;
+export declare const structuralRefusal: (code: StructuralRefusalCode) => StructuralRefusal;
+//# sourceMappingURL=constants.d.ts.map

package/dist/esm/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,oBAAoB,CAAC;AAE1D,2GAA2G;AAC3G,eAAO,MAAM,sBAAsB,ySACqQ,CAAC;AAEzS,4EAA4E;AAC5E,eAAO,MAAM,2BAA2B,uCAAuC,CAAC;AAEhF,0DAA0D;AAC1D,eAAO,MAAM,2BAA2B,8EACqC,CAAC;AAE9E,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB,uCAAuC,CAAC;AAE1E,wGAAwG;AACxG,MAAM,MAAM,qBAAqB,GAC7B,gBAAgB,GAChB,YAAY,GACZ,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,qBAAqB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,MAAM,CAAC,qBAAqB,EAAE,MAAM,CAK7E,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,MAAM,qBAAqB,KAC1B,iBAID,CAAC"}

package/dist/esm/constants.js

@@ -0,0 +1,26 @@
+/**
+ * Excel's refusal messages for structural edits (insert/delete cells with shift, whole row/column
+ * insert, move/cut). The engines refuse the edit and leave the document untouched; the UI shows the
+ * message. Shared by the legacy JS hooks (`api/structural-guards.ts`) and the rnc engine's
+ * `CommitResult.rejected` channel (`libs/rnc-engine`), so both surfaces speak the same words.
+ */
+export const STRUCTURAL_REFUSAL_TITLE = "Microsoft Excel";
+/** INS-06 / INS-09 / SHF-10 — a non-blank (or formatted) cell would be pushed past the last row/column. */
+export const OFF_SHEET_PUSH_MESSAGE = "Microsoft Excel can't insert new cells because it would push non-empty cells off the end of the worksheet. These non-empty cells might appear empty but have blank values, some formatting, or a formula. Delete enough rows or columns to make room for what you want to insert and then try again.";
+/** SHF-05 / MRG-07 — the shifted band covers only part of a merged cell. */
+export const MERGED_CELL_REFUSAL_MESSAGE = "We can't do that to a merged cell.";
+/** TBL-05 — the shifted band would tear a table apart. */
+export const TABLE_SHIFT_REFUSAL_MESSAGE = "This won't work because it would move cells in a table on your worksheet.";
+/** ANC-14 — the shifted band covers only part of a CSE / dynamic array. */
+export const ARRAY_REFUSAL_MESSAGE = "You can't change part of an array.";
+export const STRUCTURAL_REFUSAL_MESSAGES = {
+    "off-sheet-push": OFF_SHEET_PUSH_MESSAGE,
+    "torn-merge": MERGED_CELL_REFUSAL_MESSAGE,
+    "torn-table": TABLE_SHIFT_REFUSAL_MESSAGE,
+    "torn-array": ARRAY_REFUSAL_MESSAGE,
+};
+export const structuralRefusal = (code) => ({
+    code,
+    title: STRUCTURAL_REFUSAL_TITLE,
+    message: STRUCTURAL_REFUSAL_MESSAGES[code],
+});

package/dist/esm/hooks/use-calculation-worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-calculation-worker.d.ts","sourceRoot":"","sources":["../../../hooks/use-calculation-worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,8BAA8B,EAQ9B,mBAAmB,EACpB,MAAM,kCAAkC,CAAC;AAU1C,OAAO,KAAK,EACV,2BAA2B,EAE5B,MAAM,4BAA4B,CAAC;AAmBpC,OAAO,KAAK,EAEV,UAAU,EACV,SAAS,EACV,MAAM,2BAA2B,CAAC;AAgBnC,OAAO,KAAK,EAKV,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,KAAK,wBAAwB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAElE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EACD,OAAO,GACP,YAAY,GACZ,iBAAiB,GACjB,iBAAiB,GACjB,yBAAyB,GACzB,cAAc,GACd,UAAU,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAyEF,MAAM,MAAM,yBAAyB,GAAG,mBAAmB,GAAG;IAC5D,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,YAAY,CAAC,EAAE,8BAA8B,CAAC,QAAQ,CAAC,CAAC;IACxD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,2BAA2B,CAAC;IACnD,kBAAkB,CAAC,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAClD,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC,CAAC;AA8KF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,yBAAyB,KAC/B,wBA+/DF,CAAC"}
+{"version":3,"file":"use-calculation-worker.d.ts","sourceRoot":"","sources":["../../../hooks/use-calculation-worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,8BAA8B,EAQ9B,mBAAmB,EACpB,MAAM,kCAAkC,CAAC;AAU1C,OAAO,KAAK,EACV,2BAA2B,EAE5B,MAAM,4BAA4B,CAAC;AAmBpC,OAAO,KAAK,EAEV,UAAU,EACV,SAAS,EACV,MAAM,2BAA2B,CAAC;AAgBnC,OAAO,KAAK,EAKV,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,KAAK,wBAAwB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAElE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EACD,OAAO,GACP,YAAY,GACZ,iBAAiB,GACjB,iBAAiB,GACjB,yBAAyB,GACzB,cAAc,GACd,UAAU,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAyEF,MAAM,MAAM,yBAAyB,GAAG,mBAAmB,GAAG;IAC5D,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,YAAY,CAAC,EAAE,8BAA8B,CAAC,QAAQ,CAAC,CAAC;IACxD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,2BAA2B,CAAC;IACnD,kBAAkB,CAAC,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAClD,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC,CAAC;AAsLF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,yBAAyB,KAC/B,wBA4iEF,CAAC"}