@rowsncolumns/spreadsheet-state 28.0.75 → 29.0.0

package/dist/esm/api/merges.js

@@ -1,3 +1,12 @@
+import { areaInsideArea, areaIntersects } from "@rowsncolumns/grid";
+/** Excel's refusal when a move / cut-paste / shift would tear a merged cell. */
+export const 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 const findPartiallyCoveredMerge = (range, merges) => merges?.find((merge) => areaIntersects(merge, range) && !areaInsideArea(merge, range));
 /**
  * Move merged cells when user is inserts, deletes row and columns
  * @param mergedCells
@@ -172,3 +181,54 @@ export const expandMergesOnColumnInsert = (merges, insertIndex, count) => {
     })
         .filter((merge) => !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 const shiftMergesInBand = (merges, axis, start, count, insert, spanStart, spanEnd) => {
+    if (!merges || count <= 0) {
+        return merges;
+    }
+    const deletedEnd = start + count - 1;
+    const inSpan = axis === "row"
+        ? (merge) => merge.startColumnIndex >= spanStart && merge.endColumnIndex <= spanEnd
+        : (merge) => merge.startRowIndex >= spanStart && merge.endRowIndex <= spanEnd;
+    const lineStart = (merge) => axis === "row" ? merge.startRowIndex : merge.startColumnIndex;
+    const lineEnd = (merge) => axis === "row" ? merge.endRowIndex : merge.endColumnIndex;
+    const moved = (merge, delta) => axis === "row"
+        ? {
+            ...merge,
+            startRowIndex: merge.startRowIndex + delta,
+            endRowIndex: merge.endRowIndex + delta,
+        }
+        : {
+            ...merge,
+            startColumnIndex: merge.startColumnIndex + delta,
+            endColumnIndex: merge.endColumnIndex + delta,
+        };
+    const next = [];
+    for (const merge of merges) {
+        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);
+    }
+    return next;
+};

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

@@ -0,0 +1,176 @@
+/**
+ * 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 const NAMED_RANGE_REF_ERROR = "#REF!";
+export const isRefErrorNamedRange = (namedRange) => !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 const shiftNamedBand = (start, end, op, index, count) => {
+    if (count <= 0)
+        return [start, end];
+    const s = Math.max(1, start);
+    const 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];
+    }
+    const 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;
+    const before = Math.max(s - index, 0);
+    const inside = Math.min(deleteEnd, e) - Math.max(index, s) + 1;
+    return [s - before, e - before - inside];
+};
+const shiftGridRange = (range, axis, op, index, count) => {
+    const [startKey, endKey] = axis === "row"
+        ? ["startRowIndex", "endRowIndex"]
+        : ["startColumnIndex", "endColumnIndex"];
+    const 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 { ...range, [startKey]: next[0], [endKey]: next[1] };
+};
+/**
+ * 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 const updateNamedRangesOnStructuralChange = (draft, axis, op, index, count, sheetId) => {
+    const changed = [];
+    const refErrored = [];
+    if (count <= 0)
+        return { changed, refErrored };
+    for (const namedRange of draft) {
+        const range = namedRange.range;
+        if (!range || range.sheetId !== sheetId)
+            continue;
+        const 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);
+    }
+    return { changed, refErrored };
+};
+/**
+ * Pure variant of {@link updateNamedRangesOnStructuralChange}: returns the
+ * adjusted list (sharing untouched entries) plus the names that changed.
+ */
+export const shiftNamedRangesOnStructuralChange = (namedRanges, axis, op, index, count, sheetId) => {
+    const changed = [];
+    const refErrored = [];
+    const next = namedRanges.map((namedRange) => {
+        const range = namedRange.range;
+        if (!range || range.sheetId !== sheetId || count <= 0)
+            return namedRange;
+        const shifted = shiftGridRange(range, axis, op, index, count);
+        if (shifted === range)
+            return namedRange;
+        if (shifted === null) {
+            const broken = {
+                ...namedRange,
+                range: undefined,
+                value: NAMED_RANGE_REF_ERROR,
+            };
+            refErrored.push(broken);
+            return broken;
+        }
+        const moved = { ...namedRange, range: shifted };
+        changed.push(moved);
+        return moved;
+    });
+    return { next, changed, 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 const updatePrintSettingsOnStructuralChange = (printSettings, axis, op, index, count) => {
+    if (count <= 0)
+        return false;
+    let changed = false;
+    if (printSettings.printArea?.length) {
+        const nextAreas = [];
+        for (const area of printSettings.printArea) {
+            const next = shiftGridRange(area, axis, op, index, count);
+            if (next !== area)
+                changed = true;
+            if (next)
+                nextAreas.push(next);
+        }
+        if (changed) {
+            if (nextAreas.length) {
+                printSettings.printArea = nextAreas;
+            }
+            else {
+                delete printSettings.printArea;
+            }
+        }
+    }
+    const titles = printSettings.printTitles;
+    if (titles) {
+        const [startKey, endKey] = axis === "row" ? ["rowStart", "rowEnd"] : ["columnStart", "columnEnd"];
+        const start = titles[startKey];
+        const end = titles[endKey];
+        if (start != null && end != null) {
+            const 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/esm/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/esm/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/esm/api/range-rule-helpers.js

@@ -1,16 +1,143 @@
+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". */
+const MAX_ROW_INDEX = 1_048_576;
+const MAX_COLUMN_INDEX = 16_384;
+/**
+ * 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 const shiftRuleFormulaForStructuralChange = (formula, { op, axis, index, count, editedSheetName, ruleSheetName, anchorRebase = 0, }) => {
+    if (!formula.startsWith("=") || count <= 0)
+        return formula;
+    const sameSheet = ruleSheetName.toLowerCase() === editedSheetName.toLowerCase();
+    const isRow = axis === "row";
+    const gridBounds = { rowCount: MAX_ROW_INDEX, columnCount: MAX_COLUMN_INDEX };
+    let 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) {
+        const source = { rowIndex: 1, columnIndex: 1 };
+        const destination = {
+            rowIndex: 1 + (isRow ? anchorRebase : 0),
+            columnIndex: 1 + (isRow ? 0 : anchorRebase),
+        };
+        next =
+            formulaToRelativeReference(next, source, destination, ruleSheetName, {
+                preserveAbsolutes: true,
+                ignoreCircular: true,
+                ignoreReferenceError: true,
+                ...gridBounds,
+            }) ?? 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") {
+        const 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,
+            };
+        const offGrid = -(index + count);
+        next =
+            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,
+            }) ?? next;
+    }
+    // 3. Ranges that span the edit grow (insert) / shrink (delete).
+    next =
+        (op === "insert" ? expandRangesInFormula : contractRangesInFormula)(next, index, count, axis, editedSheetName, { includeUnqualifiedReferences: sameSheet }) ?? next;
+    // 4. Everything at/after the edit shifts by ±count along the axis.
+    const delta = op === "insert" ? count : -count;
+    const regionStart = op === "insert" ? index : index + count;
+    const 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 =
+        formulaToRelativeReference(next, { rowIndex: regionStart, columnIndex: regionStart }, {
+            rowIndex: regionStart + (isRow ? delta : 0),
+            columnIndex: regionStart + (isRow ? 0 : delta),
+        }, editedSheetName, {
+            exclusionRange: region,
+            ignoreCircular: true,
+            ignoreReferenceError: true,
+            referenceSheetName: editedSheetName,
+            includeUnqualifiedReferences: sameSheet,
+            ...gridBounds,
+        }) ?? next;
+    return next;
+};
+const rewriteConditionFormulas = (condition, params) => {
+    if (!condition?.values)
+        return;
+    for (const value of condition.values) {
+        const text = value.userEnteredValue;
+        if (typeof text !== "string" || !text.startsWith("="))
+            continue;
+        const next = shiftRuleFormulaForStructuralChange(text, params);
+        if (next !== text)
+            value.userEnteredValue = next;
+    }
+};
 /**
  * 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 const updateRangedRulesOnStructuralChange = (draft, op, axis, index, count, sheetId) => {
+export const updateRangedRulesOnStructuralChange = (draft, op, axis, index, count, sheetId, formulaScope) => {
     const updater = op === "insert" ? updateSheetRangeOnInsert : updateSheetRangeOnDelete;
+    const isRow = axis === "row";
     for (let i = draft.length - 1; i >= 0; i--) {
         const rule = draft[i];
+        const anchorRange = rule.ranges?.[0];
         const ranges = rule.ranges
             ?.map((range) => updater(range, axis, index, count, sheetId))
             .filter((range) => !!range) ?? [];
@@ -18,6 +145,31 @@ export const updateRangedRulesOnStructuralChange = (draft, op, axis, index, coun
             // 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.
+                const anchorPosition = isRow
+                    ? anchorRange.startRowIndex
+                    : anchorRange.startColumnIndex;
+                const anchorDeleted = op === "delete" &&
+                    anchorRange.sheetId === sheetId &&
+                    anchorPosition >= index &&
+                    anchorPosition <= index + count - 1;
+                const params = {
+                    op,
+                    axis,
+                    index,
+                    count,
+                    editedSheetName: formulaScope.getSheetName(sheetId),
+                    ruleSheetName: formulaScope.getSheetName(anchorRange.sheetId),
+                    anchorRebase: anchorDeleted ? index + count - anchorPosition : 0,
+                };
+                const carrier = rule;
+                rewriteConditionFormulas(carrier.booleanRule?.condition, params);
+                rewriteConditionFormulas(carrier.condition, params);
+            }
         }
         else {
             draft.splice(i, 1);

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