@rowsncolumns/spreadsheet-state 28.0.75 → 28.0.76

package/dist/cjs/api/named-range-structural.js

@@ -0,0 +1,197 @@
+import { __assign, __read, __values } from "tslib";
+/**
+ * The `value` a defined name carries once every cell of its range has been
+ * deleted. Excel keeps the name in the Name Manager as `=Sheet1!#REF!` and
+ * every formula that uses it evaluates to `#REF!` (not `#NAME?`), so the
+ * name survives with no range and this error marker as its value; the
+ * calculation worker's name resolver turns it into `FormulaError.REF`.
+ */
+export var NAMED_RANGE_REF_ERROR = "#REF!";
+export var isRefErrorNamedRange = function (namedRange) { return !namedRange.range && namedRange.value === NAMED_RANGE_REF_ERROR; };
+/**
+ * Shift the inclusive `[start, end]` band of a defined name / print band for
+ * an insert or delete of `count` rows or columns at `index` (1-based).
+ * Excel's rule for a name's RefersTo, identical to the Rust engine's
+ * `shift_named_ranges`:
+ *
+ * - insert at or above the first index → the whole band shifts;
+ * - insert strictly inside → the band grows;
+ * - insert at the boundary directly below → unchanged;
+ * - delete wholly above → shifts back; delete overlapping → shrinks by the
+ *   deleted indices inside the band; delete covering the band → `null`.
+ */
+export var shiftNamedBand = function (start, end, op, index, count) {
+    if (count <= 0)
+        return [start, end];
+    var s = Math.max(1, start);
+    var e = Math.max(s, end);
+    if (op === "insert") {
+        if (index <= s)
+            return [s + count, e + count];
+        if (index <= e)
+            return [s, e + count];
+        return [s, e];
+    }
+    var deleteEnd = index + count - 1;
+    if (deleteEnd < s)
+        return [s - count, e - count];
+    if (index > e)
+        return [s, e];
+    if (index <= s && deleteEnd >= e)
+        return null;
+    var before = Math.max(s - index, 0);
+    var inside = Math.min(deleteEnd, e) - Math.max(index, s) + 1;
+    return [s - before, e - before - inside];
+};
+var shiftGridRange = function (range, axis, op, index, count) {
+    var _a;
+    var _b = __read(axis === "row"
+        ? ["startRowIndex", "endRowIndex"]
+        : ["startColumnIndex", "endColumnIndex"], 2), startKey = _b[0], endKey = _b[1];
+    var next = shiftNamedBand(range[startKey], range[endKey], op, index, count);
+    if (!next)
+        return null;
+    if (next[0] === range[startKey] && next[1] === range[endKey])
+        return range;
+    return __assign(__assign({}, range), (_a = {}, _a[startKey] = next[0], _a[endKey] = next[1], _a));
+};
+/**
+ * Adjust defined names for a sheet-level insert/delete on `sheetId`,
+ * mutating the immer `draft` in place. Only names whose `range.sheetId` is
+ * the edited sheet move — a name's scope (`scopeSheetId`) governs how it is
+ * resolved, not which sheet's edits shift it (a Sheet2-scoped name pointing
+ * at Sheet2!$B$4 shifts on Sheet2 edits, never on Sheet1 edits). Value
+ * names (`=SUM(...)*2`, `0.1`) have no grid range and pass through.
+ *
+ * A name whose entire range is deleted is NOT dropped: it keeps its entry
+ * with `range` cleared and `value: "#REF!"`, so `=SUM(Data)` evaluates to
+ * `#REF!` like Excel rather than `#NAME?`.
+ */
+export var updateNamedRangesOnStructuralChange = function (draft, axis, op, index, count, sheetId) {
+    var e_1, _a;
+    var changed = [];
+    var refErrored = [];
+    if (count <= 0)
+        return { changed: changed, refErrored: refErrored };
+    try {
+        for (var draft_1 = __values(draft), draft_1_1 = draft_1.next(); !draft_1_1.done; draft_1_1 = draft_1.next()) {
+            var namedRange = draft_1_1.value;
+            var range = namedRange.range;
+            if (!range || range.sheetId !== sheetId)
+                continue;
+            var next = shiftGridRange(range, axis, op, index, count);
+            if (next === range)
+                continue;
+            if (next === null) {
+                namedRange.range = undefined;
+                namedRange.value = NAMED_RANGE_REF_ERROR;
+                refErrored.push(namedRange);
+                continue;
+            }
+            namedRange.range = next;
+            changed.push(namedRange);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (draft_1_1 && !draft_1_1.done && (_a = draft_1.return)) _a.call(draft_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return { changed: changed, refErrored: refErrored };
+};
+/**
+ * Pure variant of {@link updateNamedRangesOnStructuralChange}: returns the
+ * adjusted list (sharing untouched entries) plus the names that changed.
+ */
+export var shiftNamedRangesOnStructuralChange = function (namedRanges, axis, op, index, count, sheetId) {
+    var changed = [];
+    var refErrored = [];
+    var next = namedRanges.map(function (namedRange) {
+        var range = namedRange.range;
+        if (!range || range.sheetId !== sheetId || count <= 0)
+            return namedRange;
+        var shifted = shiftGridRange(range, axis, op, index, count);
+        if (shifted === range)
+            return namedRange;
+        if (shifted === null) {
+            var broken = __assign(__assign({}, namedRange), { range: undefined, value: NAMED_RANGE_REF_ERROR });
+            refErrored.push(broken);
+            return broken;
+        }
+        var moved = __assign(__assign({}, namedRange), { range: shifted });
+        changed.push(moved);
+        return moved;
+    });
+    return { next: next, changed: changed, refErrored: refErrored };
+};
+/**
+ * `_xlnm.Print_Area` / `_xlnm.Print_Titles` are sheet-scoped defined names
+ * in Excel and follow the same RefersTo rule as any other name. Mutates the
+ * sheet's `printSettings` draft: each print-area rectangle shifts / grows /
+ * shrinks (a rectangle wholly deleted is removed; an emptied print area is
+ * cleared), and the repeated title rows / columns shift as a band along the
+ * edited axis (cleared when every title row / column is deleted).
+ */
+export var updatePrintSettingsOnStructuralChange = function (printSettings, axis, op, index, count) {
+    var e_2, _a;
+    var _b;
+    if (count <= 0)
+        return false;
+    var changed = false;
+    if ((_b = printSettings.printArea) === null || _b === void 0 ? void 0 : _b.length) {
+        var nextAreas = [];
+        try {
+            for (var _c = __values(printSettings.printArea), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var area = _d.value;
+                var next = shiftGridRange(area, axis, op, index, count);
+                if (next !== area)
+                    changed = true;
+                if (next)
+                    nextAreas.push(next);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        if (changed) {
+            if (nextAreas.length) {
+                printSettings.printArea = nextAreas;
+            }
+            else {
+                delete printSettings.printArea;
+            }
+        }
+    }
+    var titles = printSettings.printTitles;
+    if (titles) {
+        var _e = __read(axis === "row" ? ["rowStart", "rowEnd"] : ["columnStart", "columnEnd"], 2), startKey = _e[0], endKey = _e[1];
+        var start = titles[startKey];
+        var end = titles[endKey];
+        if (start != null && end != null) {
+            var next = shiftNamedBand(start, end, op, index, count);
+            if (!next) {
+                delete titles[startKey];
+                delete titles[endKey];
+                changed = true;
+                if (titles.rowStart == null &&
+                    titles.rowEnd == null &&
+                    titles.columnStart == null &&
+                    titles.columnEnd == null) {
+                    delete printSettings.printTitles;
+                }
+            }
+            else if (next[0] !== start || next[1] !== end) {
+                titles[startKey] = next[0];
+                titles[endKey] = next[1];
+                changed = true;
+            }
+        }
+    }
+    return changed;
+};

package/dist/cjs/api/range-rule-helpers.d.ts

@@ -1,17 +1,61 @@
 import type { GridRange, SheetRange } from "@rowsncolumns/common-types";
 import type { WritableDraft } from "immer";
 type RangedRuleAxis = "row" | "column";
+/**
+ * Sheet-name lookup the rule-formula rewrite needs to scope references:
+ * unqualified references in a CF/DV formula resolve on the sheet the rule's
+ * applies-to range lives on, so only when that is the edited sheet do they
+ * move; `EditedSheet!`-qualified references move from any sheet.
+ */
+export type RuleFormulaScope = {
+    getSheetName(sheetId: number): string;
+};
+export type RuleFormulaStructuralParams = {
+    op: "insert" | "delete";
+    axis: RangedRuleAxis;
+    /** 1-based index the rows/columns are inserted at / deleted from. */
+    index: number;
+    count: number;
+    /** Name of the sheet being edited. */
+    editedSheetName: string;
+    /** Name of the sheet the rule's applies-to range lives on. */
+    ruleSheetName: string;
+    /**
+     * How many rows/columns (along `axis`) the rule's top-left cell moved
+     * WITHIN the pre-edit grid because the previous top-left was deleted —
+     * the surviving top-left's instance formula becomes the rule text, so
+     * relative references are re-anchored by this delta first. 0 otherwise.
+     */
+    anchorRebase?: number;
+};
+/**
+ * Rewrite one CF / DV formula (`=…`) for a sheet-level insert or delete,
+ * exactly as Excel rewrites the rule text: the formula is read as if it
+ * were entered in the rule's top-left cell, so relative and absolute
+ * references alike are grid positions that shift when they sit at/after
+ * the edit (`=$A1>$C$10` + insert row 5 → `=$A1>$C$11`), ranges spanning
+ * the edit grow / shrink, and a reference inside a deleted band becomes
+ * `#REF!`. Returns the input unchanged when it is not a formula or when
+ * no reference moved.
+ */
+export declare const shiftRuleFormulaForStructuralChange: (formula: string, { op, axis, index, count, editedSheetName, ruleSheetName, anchorRebase, }: RuleFormulaStructuralParams) => string;
 /**
  * Apply an insert or delete range adjustment to a list of rules whose
  * `ranges: SheetRange[]` field references cells. Used for tables, conditional
  * formats, data validations, etc. Mutates the immer draft in place; rules
  * whose ranges all collapse to nothing are spliced out.
  *
+ * When `formulaScope` is given, each rule's condition formulas
+ * (`booleanRule.condition.values[].userEnteredValue` for CF,
+ * `condition.values[].userEnteredValue` for DV — those starting with `=`)
+ * are rewritten as if entered in the rule's applies-to top-left cell, see
+ * {@link shiftRuleFormulaForStructuralChange}.
+ *
  * Walks `draft` from the end so splice indices don't shift mid-iteration.
  */
 export declare const updateRangedRulesOnStructuralChange: <R extends {
     ranges?: SheetRange[] | null;
-}>(draft: WritableDraft<R>[], op: "insert" | "delete", axis: RangedRuleAxis, index: number, count: number, sheetId: number) => void;
+}>(draft: WritableDraft<R>[], op: "insert" | "delete", axis: RangedRuleAxis, index: number, count: number, sheetId: number, formulaScope?: RuleFormulaScope) => void;
 /**
  * Returns true when a sheet range has any cells in the given grid bounds.
  * Cheap pre-check used by callers to skip patch generation for sheets that

package/dist/cjs/api/range-rule-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"range-rule-helpers.d.ts","sourceRoot":"","sources":["../../../api/range-rule-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAI3C,KAAK,cAAc,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEvC;;;;;;;GAOG;AACH,eAAO,MAAM,mCAAmC,GAC9C,CAAC,SAAS;IAAE,MAAM,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI,CAAA;CAAE,EAE1C,OAAO,aAAa,CAAC,CAAC,CAAC,EAAE,EACzB,IAAI,QAAQ,GAAG,QAAQ,EACvB,MAAM,cAAc,EACpB,OAAO,MAAM,EACb,OAAO,MAAM,EACb,SAAS,MAAM,SAkBhB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,UAAU,EACjB,SAAS,MAAM,EACf,QAAQ,SAAS,YASlB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,MAAM,EACb,YAAY,MAAM,EAClB,WAAW,MAAM,EACjB,gBAAgB,MAAM,KACrB,MAiBF,CAAC;AAEF,KAAK,WAAW,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEpC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B,GACrC,CAAC,SAAS;IAAE,MAAM,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI,CAAA;CAAE,EAE1C,OAAO,aAAa,CAAC,CAAC,CAAC,EAAE,EACzB,MAAM,WAAW,EACjB,YAAY,MAAM,EAClB,WAAW,MAAM,EACjB,gBAAgB,MAAM,EACtB,SAAS,MAAM;AACf;;;;;;;;;GASG;AACH,qBAAqB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,SAkEpD,CAAC"}
+{"version":3,"file":"range-rule-helpers.d.ts","sourceRoot":"","sources":["../../../api/range-rule-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,SAAS,EACT,UAAU,EACX,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAS3C,KAAK,cAAc,GAAG,KAAK,GAAG,QAAQ,CAAC;AAMvC;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,EAAE,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACxB,IAAI,EAAE,cAAc,CAAC;IACrB,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,eAAe,EAAE,MAAM,CAAC;IACxB,8DAA8D;IAC9D,aAAa,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,mCAAmC,GAC9C,SAAS,MAAM,EACf,2EAQG,2BAA2B,KAC7B,MAoHF,CAAC;AAsBF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mCAAmC,GAC9C,CAAC,SAAS;IAAE,MAAM,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI,CAAA;CAAE,EAE1C,OAAO,aAAa,CAAC,CAAC,CAAC,EAAE,EACzB,IAAI,QAAQ,GAAG,QAAQ,EACvB,MAAM,cAAc,EACpB,OAAO,MAAM,EACb,OAAO,MAAM,EACb,SAAS,MAAM,EACf,eAAe,gBAAgB,SA8ChC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,UAAU,EACjB,SAAS,MAAM,EACf,QAAQ,SAAS,YASlB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,MAAM,EACb,YAAY,MAAM,EAClB,WAAW,MAAM,EACjB,gBAAgB,MAAM,KACrB,MAiBF,CAAC;AAEF,KAAK,WAAW,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEpC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B,GACrC,CAAC,SAAS;IAAE,MAAM,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI,CAAA;CAAE,EAE1C,OAAO,aAAa,CAAC,CAAC,CAAC,EAAE,EACzB,MAAM,WAAW,EACjB,YAAY,MAAM,EAClB,WAAW,MAAM,EACjB,gBAAgB,MAAM,EACtB,SAAS,MAAM;AACf;;;;;;;;;GASG;AACH,qBAAqB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,SAkEpD,CAAC"}

package/dist/cjs/api/range-rule-helpers.js

@@ -1,23 +1,176 @@
 import { __assign, __values } from "tslib";
+import { contractRangesInFormula, expandRangesInFormula, formulaToRelativeReference, } from "./formula";
 import { updateSheetRangeOnDelete, updateSheetRangeOnInsert } from "./range";
+/** Excel's grid bounds — the shift region for "every reference at/after the edit". */
+var MAX_ROW_INDEX = 1048576;
+var MAX_COLUMN_INDEX = 16384;
+/**
+ * Rewrite one CF / DV formula (`=…`) for a sheet-level insert or delete,
+ * exactly as Excel rewrites the rule text: the formula is read as if it
+ * were entered in the rule's top-left cell, so relative and absolute
+ * references alike are grid positions that shift when they sit at/after
+ * the edit (`=$A1>$C$10` + insert row 5 → `=$A1>$C$11`), ranges spanning
+ * the edit grow / shrink, and a reference inside a deleted band becomes
+ * `#REF!`. Returns the input unchanged when it is not a formula or when
+ * no reference moved.
+ */
+export var shiftRuleFormulaForStructuralChange = function (formula, _a) {
+    var _b, _c, _d, _e;
+    var op = _a.op, axis = _a.axis, index = _a.index, count = _a.count, editedSheetName = _a.editedSheetName, ruleSheetName = _a.ruleSheetName, _f = _a.anchorRebase, anchorRebase = _f === void 0 ? 0 : _f;
+    if (!formula.startsWith("=") || count <= 0)
+        return formula;
+    var sameSheet = ruleSheetName.toLowerCase() === editedSheetName.toLowerCase();
+    var isRow = axis === "row";
+    var gridBounds = { rowCount: MAX_ROW_INDEX, columnCount: MAX_COLUMN_INDEX };
+    var next = formula;
+    // 1. The rule's previous top-left cell was deleted: the rule text is now
+    //    the instance formula of the first surviving cell — relative
+    //    references move with the anchor, absolutes stay.
+    if (anchorRebase > 0 && sameSheet) {
+        var source = { rowIndex: 1, columnIndex: 1 };
+        var destination = {
+            rowIndex: 1 + (isRow ? anchorRebase : 0),
+            columnIndex: 1 + (isRow ? 0 : anchorRebase),
+        };
+        next =
+            (_b = formulaToRelativeReference(next, source, destination, ruleSheetName, __assign({ preserveAbsolutes: true, ignoreCircular: true, ignoreReferenceError: true }, gridBounds))) !== null && _b !== void 0 ? _b : next;
+    }
+    // 2. Delete: references wholly inside the deleted band are gone → `#REF!`.
+    //    Shifting the band far off-grid lets `formulaToRelativeReference`'s
+    //    reference-error path emit the token.
+    if (op === "delete") {
+        var band = isRow
+            ? {
+                startRowIndex: index,
+                endRowIndex: index + count - 1,
+                startColumnIndex: 1,
+                endColumnIndex: MAX_COLUMN_INDEX,
+            }
+            : {
+                startRowIndex: 1,
+                endRowIndex: MAX_ROW_INDEX,
+                startColumnIndex: index,
+                endColumnIndex: index + count - 1,
+            };
+        var offGrid = -(index + count);
+        next =
+            (_c = formulaToRelativeReference(next, { rowIndex: index, columnIndex: index }, {
+                rowIndex: isRow ? offGrid : index,
+                columnIndex: isRow ? index : offGrid,
+            }, editedSheetName, {
+                exclusionRange: band,
+                ignoreCircular: true,
+                ignoreReferenceError: true,
+                referenceSheetName: editedSheetName,
+                includeUnqualifiedReferences: sameSheet,
+                // Deliberately NOT the grid bounds: a whole-row / whole-column
+                // reference inside the band would otherwise be pushed to a
+                // negative index instead of `#REF!`; those stay put and are
+                // handled by the range contraction below.
+                rowCount: MAX_ROW_INDEX + 1,
+                columnCount: MAX_COLUMN_INDEX + 1,
+            })) !== null && _c !== void 0 ? _c : next;
+    }
+    // 3. Ranges that span the edit grow (insert) / shrink (delete).
+    next =
+        (_d = (op === "insert" ? expandRangesInFormula : contractRangesInFormula)(next, index, count, axis, editedSheetName, { includeUnqualifiedReferences: sameSheet })) !== null && _d !== void 0 ? _d : next;
+    // 4. Everything at/after the edit shifts by ±count along the axis.
+    var delta = op === "insert" ? count : -count;
+    var regionStart = op === "insert" ? index : index + count;
+    var region = isRow
+        ? {
+            startRowIndex: regionStart,
+            endRowIndex: MAX_ROW_INDEX,
+            startColumnIndex: 1,
+            endColumnIndex: MAX_COLUMN_INDEX,
+        }
+        : {
+            startRowIndex: 1,
+            endRowIndex: MAX_ROW_INDEX,
+            startColumnIndex: regionStart,
+            endColumnIndex: MAX_COLUMN_INDEX,
+        };
+    next =
+        (_e = formulaToRelativeReference(next, { rowIndex: regionStart, columnIndex: regionStart }, {
+            rowIndex: regionStart + (isRow ? delta : 0),
+            columnIndex: regionStart + (isRow ? 0 : delta),
+        }, editedSheetName, __assign({ exclusionRange: region, ignoreCircular: true, ignoreReferenceError: true, referenceSheetName: editedSheetName, includeUnqualifiedReferences: sameSheet }, gridBounds))) !== null && _e !== void 0 ? _e : next;
+    return next;
+};
+var rewriteConditionFormulas = function (condition, params) {
+    var e_1, _a;
+    if (!(condition === null || condition === void 0 ? void 0 : condition.values))
+        return;
+    try {
+        for (var _b = __values(condition.values), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var value = _c.value;
+            var text = value.userEnteredValue;
+            if (typeof text !== "string" || !text.startsWith("="))
+                continue;
+            var next = shiftRuleFormulaForStructuralChange(text, params);
+            if (next !== text)
+                value.userEnteredValue = next;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+};
 /**
  * Apply an insert or delete range adjustment to a list of rules whose
  * `ranges: SheetRange[]` field references cells. Used for tables, conditional
  * formats, data validations, etc. Mutates the immer draft in place; rules
  * whose ranges all collapse to nothing are spliced out.
  *
+ * When `formulaScope` is given, each rule's condition formulas
+ * (`booleanRule.condition.values[].userEnteredValue` for CF,
+ * `condition.values[].userEnteredValue` for DV — those starting with `=`)
+ * are rewritten as if entered in the rule's applies-to top-left cell, see
+ * {@link shiftRuleFormulaForStructuralChange}.
+ *
  * Walks `draft` from the end so splice indices don't shift mid-iteration.
  */
-export var updateRangedRulesOnStructuralChange = function (draft, op, axis, index, count, sheetId) {
-    var _a, _b;
+export var updateRangedRulesOnStructuralChange = function (draft, op, axis, index, count, sheetId, formulaScope) {
+    var _a, _b, _c, _d;
     var updater = op === "insert" ? updateSheetRangeOnInsert : updateSheetRangeOnDelete;
+    var isRow = axis === "row";
     for (var i = draft.length - 1; i >= 0; i--) {
         var rule = draft[i];
-        var ranges = (_b = (_a = rule.ranges) === null || _a === void 0 ? void 0 : _a.map(function (range) { return updater(range, axis, index, count, sheetId); }).filter(function (range) { return !!range; })) !== null && _b !== void 0 ? _b : [];
+        var anchorRange = (_a = rule.ranges) === null || _a === void 0 ? void 0 : _a[0];
+        var ranges = (_c = (_b = rule.ranges) === null || _b === void 0 ? void 0 : _b.map(function (range) { return updater(range, axis, index, count, sheetId); }).filter(function (range) { return !!range; })) !== null && _c !== void 0 ? _c : [];
         if (ranges.length) {
             // immer's typing for nested-mutation assignment is flaky here; cast
             // through `unknown` since the runtime shape matches the rule type.
             rule.ranges = ranges;
+            if (formulaScope && anchorRange) {
+                // Excel anchors a rule's formula at its applies-to top-left. When
+                // that cell is deleted, the first surviving cell (right after the
+                // deleted band) becomes the anchor and its instance formula the
+                // rule text.
+                var anchorPosition = isRow
+                    ? anchorRange.startRowIndex
+                    : anchorRange.startColumnIndex;
+                var anchorDeleted = op === "delete" &&
+                    anchorRange.sheetId === sheetId &&
+                    anchorPosition >= index &&
+                    anchorPosition <= index + count - 1;
+                var params = {
+                    op: op,
+                    axis: axis,
+                    index: index,
+                    count: count,
+                    editedSheetName: formulaScope.getSheetName(sheetId),
+                    ruleSheetName: formulaScope.getSheetName(anchorRange.sheetId),
+                    anchorRebase: anchorDeleted ? index + count - anchorPosition : 0,
+                };
+                var carrier = rule;
+                rewriteConditionFormulas((_d = carrier.booleanRule) === null || _d === void 0 ? void 0 : _d.condition, params);
+                rewriteConditionFormulas(carrier.condition, params);
+            }
         }
         else {
             draft.splice(i, 1);
@@ -92,7 +245,7 @@ export var updateRangedRulesOnReorder = function (draft, axis, firstIndex, lastI
  * bounds (no current caller, but kept symmetric).
  */
 orthogonalBoundary) {
-    var e_1, _a;
+    var e_2, _a;
     var _b;
     if (firstIndex > lastIndex)
         return;
@@ -132,11 +285,11 @@ orthogonalBoundary) {
             rule.ranges = nextRanges;
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
     finally {
         try {
             if (draft_1_1 && !draft_1_1.done && (_a = draft_1.return)) _a.call(draft_1);
         }
-        finally { if (e_1) throw e_1.error; }
+        finally { if (e_2) throw e_2.error; }
     }
 };

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

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

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,