@rowsncolumns/spreadsheet-state 28.0.75 → 29.0.0

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

@@ -86,6 +86,11 @@ export const updateFormulasForStructuralChange = (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.
+    const deletedRange = isInsert ? undefined : pass1Range;
+    const editedSheetName = getSheetName(sheetId);
     // ---- PASS 1 ----
     const pass1Formulas = collectUniqueDependentsForRange({
         draft,
@@ -104,10 +109,15 @@ export const updateFormulasForStructuralChange = (params) => {
             const formulaValue = sheetCell.formula;
             if (!formulaValue)
                 continue;
-            const 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.
+            const rangeOptions = {
+                includeUnqualifiedReferences: pos.sheetId === sheetId,
+            };
             const 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);
@@ -165,7 +175,7 @@ export const updateFormulasForStructuralChange = (params) => {
             shiftExternalDependentFormulaReferences({
                 draft,
                 position: pos,
-                editedSheetName: getSheetName(sheetId),
+                editedSheetName,
                 enqueueCalculation,
                 enqueueGraphOperation,
                 recalcCells,
@@ -173,6 +183,7 @@ export const updateFormulasForStructuralChange = (params) => {
                 rowDelta,
                 columnDelta,
                 sourceRange: pass2SourceRange,
+                deletedRange,
                 locale,
                 rowCount,
                 columnCount,
@@ -192,6 +203,7 @@ export const updateFormulasForStructuralChange = (params) => {
             rowDelta,
             columnDelta,
             sourceRange: pass2SourceRange,
+            deletedRange,
             locale,
             rowCount,
             columnCount,
@@ -206,7 +218,7 @@ export const updateFormulasForStructuralChange = (params) => {
         shiftExternalDependentFormulaReferences({
             draft,
             position,
-            editedSheetName: getSheetName(sheetId),
+            editedSheetName,
             enqueueCalculation,
             enqueueGraphOperation,
             recalcCells,
@@ -214,6 +226,7 @@ export const updateFormulasForStructuralChange = (params) => {
             rowDelta,
             columnDelta,
             sourceRange: pass2SourceRange,
+            deletedRange,
             locale,
             rowCount,
             columnCount,
@@ -249,6 +262,7 @@ export const updateFormulasForStructuralChange = (params) => {
                     rowIndex: pos.rowIndex,
                     columnIndex: pos.columnIndex,
                 },
+                activeSheetName: editedSheetName,
                 enqueueCalculation,
                 enqueueGraphOperation,
                 recalcCells,
@@ -256,6 +270,7 @@ export const updateFormulasForStructuralChange = (params) => {
                 rowDelta,
                 columnDelta,
                 sourceRange: pass2SourceRange,
+                deletedRange,
                 locale,
                 rowCount,
                 columnCount,
@@ -285,6 +300,7 @@ export const updateFormulasForStructuralChange = (params) => {
                 moveFormulaAtPosition({
                     draft,
                     position: { sheetId, rowIndex, columnIndex },
+                    activeSheetName: editedSheetName,
                     enqueueCalculation,
                     enqueueGraphOperation,
                     recalcCells,
@@ -292,6 +308,7 @@ export const updateFormulasForStructuralChange = (params) => {
                     rowDelta,
                     columnDelta,
                     sourceRange: pass2SourceRange,
+                    deletedRange,
                     locale,
                     rowCount,
                     columnCount,
@@ -302,7 +319,7 @@ export const updateFormulasForStructuralChange = (params) => {
         }
     }
 };
-const shiftExternalDependentFormulaReferences = ({ draft, position, editedSheetName, enqueueCalculation, enqueueGraphOperation, recalcCells, movedKeys, rowDelta, columnDelta, sourceRange, locale, rowCount, columnCount, cellXfsRegistry, sharedStringRegistry, }) => {
+const shiftExternalDependentFormulaReferences = ({ draft, position, editedSheetName, enqueueCalculation, enqueueGraphOperation, recalcCells, movedKeys, rowDelta, columnDelta, sourceRange, deletedRange, 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];
@@ -317,6 +334,7 @@ const shiftExternalDependentFormulaReferences = ({ draft, position, editedSheetN
         columnIndex: position.columnIndex + columnDelta,
     }, editedSheetName, {
         exclusionRange: sourceRange,
+        deletedRange,
         rowCount,
         columnCount,
         referenceSheetName: editedSheetName,

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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"}