@rowsncolumns/spreadsheet-state 28.0.75 → 29.0.0

package/dist/cjs/api/merges.js

@@ -1,4 +1,15 @@
-import { __assign } from "tslib";
+import { __assign, __values } from "tslib";
+import { areaInsideArea, areaIntersects } from "@rowsncolumns/grid";
+/** Excel's refusal when a move / cut-paste / shift would tear a merged cell. */
+export var MERGED_CELL_MOVE_ERROR = "We can't do that to a merged cell.";
+/**
+ * The first merge that `range` covers only PARTIALLY (it intersects the range without being
+ * wholly inside it). Excel refuses any move, cut + paste or cell shift whose source or destination
+ * does that ("We can't do that to a merged cell."); merges wholly inside the range travel intact.
+ */
+export var findPartiallyCoveredMerge = function (range, merges) {
+    return merges === null || merges === void 0 ? void 0 : merges.find(function (merge) { return areaIntersects(merge, range) && !areaInsideArea(merge, range); });
+};
 /**
  * Move merged cells when user is inserts, deletes row and columns
  * @param mergedCells
@@ -132,3 +143,66 @@ export var expandMergesOnColumnInsert = function (merges, insertIndex, count) {
     })
         .filter(function (merge) { return !isSingleCellMerge(merge); });
 };
+/**
+ * Merges that travel with an insert/delete-cells shift: a merge wholly inside the shifted band
+ * (rows `>= start` in the band's columns for a vertical shift; columns `>= start` in its rows for a
+ * horizontal one) moves by `count`; on a delete, a merge wholly inside the deleted block is dropped
+ * with it. Merges the band only partially covers are refused upstream (`findTornMerge`) — this
+ * helper never tears one, it leaves anything outside the band untouched.
+ */
+export var shiftMergesInBand = function (merges, axis, start, count, insert, spanStart, spanEnd) {
+    var e_1, _a;
+    if (!merges || count <= 0) {
+        return merges;
+    }
+    var deletedEnd = start + count - 1;
+    var inSpan = axis === "row"
+        ? function (merge) {
+            return merge.startColumnIndex >= spanStart && merge.endColumnIndex <= spanEnd;
+        }
+        : function (merge) {
+            return merge.startRowIndex >= spanStart && merge.endRowIndex <= spanEnd;
+        };
+    var lineStart = function (merge) {
+        return axis === "row" ? merge.startRowIndex : merge.startColumnIndex;
+    };
+    var lineEnd = function (merge) {
+        return axis === "row" ? merge.endRowIndex : merge.endColumnIndex;
+    };
+    var moved = function (merge, delta) {
+        return axis === "row"
+            ? __assign(__assign({}, merge), { startRowIndex: merge.startRowIndex + delta, endRowIndex: merge.endRowIndex + delta }) : __assign(__assign({}, merge), { startColumnIndex: merge.startColumnIndex + delta, endColumnIndex: merge.endColumnIndex + delta });
+    };
+    var next = [];
+    try {
+        for (var merges_1 = __values(merges), merges_1_1 = merges_1.next(); !merges_1_1.done; merges_1_1 = merges_1.next()) {
+            var merge = merges_1_1.value;
+            if (!inSpan(merge) || lineStart(merge) < start) {
+                next.push(merge);
+                continue;
+            }
+            if (insert) {
+                next.push(moved(merge, count));
+                continue;
+            }
+            if (lineEnd(merge) <= deletedEnd) {
+                // Wholly inside the deleted block — removed with it.
+                continue;
+            }
+            if (lineStart(merge) > deletedEnd) {
+                next.push(moved(merge, -count));
+                continue;
+            }
+            // Straddles the deleted block's edge: refused upstream; never tear it here.
+            next.push(merge);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (merges_1_1 && !merges_1_1.done && (_a = merges_1.return)) _a.call(merges_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return next;
+};

package/dist/cjs/api/named-range-structural.d.ts

@@ -0,0 +1,62 @@
+import type { NamedRange, SheetPrintSettings } from "@rowsncolumns/spreadsheet";
+import type { WritableDraft } from "immer";
+export type StructuralAxis = "row" | "column";
+export type StructuralOp = "insert" | "delete";
+/**
+ * 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 declare const NAMED_RANGE_REF_ERROR = "#REF!";
+export declare const isRefErrorNamedRange: (namedRange: Pick<NamedRange, "range" | "value">) => boolean;
+/**
+ * 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 declare const shiftNamedBand: (start: number, end: number, op: StructuralOp, index: number, count: number) => [number, number] | null;
+export type NamedRangeStructuralUpdate<N extends NamedRange> = {
+    /** Names whose range moved, grew, or shrank. */
+    changed: N[];
+    /** Names whose whole range was deleted — kept, now `=#REF!`. */
+    refErrored: N[];
+};
+/**
+ * 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 declare const updateNamedRangesOnStructuralChange: (draft: WritableDraft<NamedRange>[], axis: StructuralAxis, op: StructuralOp, index: number, count: number, sheetId: number) => NamedRangeStructuralUpdate<WritableDraft<NamedRange>>;
+/**
+ * Pure variant of {@link updateNamedRangesOnStructuralChange}: returns the
+ * adjusted list (sharing untouched entries) plus the names that changed.
+ */
+export declare const shiftNamedRangesOnStructuralChange: <N extends NamedRange>(namedRanges: readonly N[], axis: StructuralAxis, op: StructuralOp, index: number, count: number, sheetId: number) => {
+    next: N[];
+} & NamedRangeStructuralUpdate<N>;
+/**
+ * `_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 declare const updatePrintSettingsOnStructuralChange: (printSettings: WritableDraft<SheetPrintSettings>, axis: StructuralAxis, op: StructuralOp, index: number, count: number) => boolean;
+//# sourceMappingURL=named-range-structural.d.ts.map

package/dist/cjs/api/named-range-structural.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"named-range-structural.d.ts","sourceRoot":"","sources":["../../../api/named-range-structural.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,UAAU,EAEV,kBAAkB,EACnB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE3C,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,QAAQ,CAAC;AAC9C,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,UAAU,CAAC;AAE7C,eAAO,MAAM,oBAAoB,GAC/B,YAAY,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,YACmB,CAAC;AAErE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,GACzB,OAAO,MAAM,EACb,KAAK,MAAM,EACX,IAAI,YAAY,EAChB,OAAO,MAAM,EACb,OAAO,MAAM,KACZ,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAgBrB,CAAC;AAmBF,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,UAAU,IAAI;IAC7D,gDAAgD;IAChD,OAAO,EAAE,CAAC,EAAE,CAAC;IACb,gEAAgE;IAChE,UAAU,EAAE,CAAC,EAAE,CAAC;CACjB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mCAAmC,GAC9C,OAAO,aAAa,CAAC,UAAU,CAAC,EAAE,EAClC,MAAM,cAAc,EACpB,IAAI,YAAY,EAChB,OAAO,MAAM,EACb,OAAO,MAAM,EACb,SAAS,MAAM,KACd,0BAA0B,CAAC,aAAa,CAAC,UAAU,CAAC,CAmBtD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kCAAkC,GAAI,CAAC,SAAS,UAAU,EACrE,aAAa,SAAS,CAAC,EAAE,EACzB,MAAM,cAAc,EACpB,IAAI,YAAY,EAChB,OAAO,MAAM,EACb,OAAO,MAAM,EACb,SAAS,MAAM,KACd;IAAE,IAAI,EAAE,CAAC,EAAE,CAAA;CAAE,GAAG,0BAA0B,CAAC,CAAC,CAsB9C,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,qCAAqC,GAChD,eAAe,aAAa,CAAC,kBAAkB,CAAC,EAChD,MAAM,cAAc,EACpB,IAAI,YAAY,EAChB,OAAO,MAAM,EACb,OAAO,MAAM,KACZ,OAiDF,CAAC"}

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