@rowsncolumns/spreadsheet-state 28.0.74 → 28.0.76

package/dist/cjs/api/merges.d.ts

@@ -4,4 +4,12 @@ export declare const shrinkMergesOnRowDelete: (merges: GridRange[], deleteStart:
 export declare const shrinkMergesOnColumnDelete: (merges: GridRange[], deleteStart: number, deleteCount: number) => GridRange[];
 export declare const expandMergesOnRowInsert: (merges: GridRange[], insertIndex: number, count: number) => GridRange[];
 export declare const expandMergesOnColumnInsert: (merges: GridRange[], insertIndex: number, count: number) => GridRange[];
+/**
+ * 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 declare const shiftMergesInBand: (merges: GridRange[] | undefined | null, axis: "row" | "column", start: number, count: number, insert: boolean, spanStart: number, spanEnd: number) => GridRange[] | null | undefined;
 //# sourceMappingURL=merges.d.ts.map

package/dist/cjs/api/merges.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merges.d.ts","sourceRoot":"","sources":["../../../api/merges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAY5D,eAAO,MAAM,eAAe,GAC1B,aAAa,SAAS,EAAE,GAAG,SAAS,GAAG,IAAI,EAC3C,IAAI,eAAe,GAAG,YAAY,GAAG,eAAe,GAAG,YAAY,EACnE,gBAAgB,MAAM,EACtB,cAAS,EACT,YAAY,CAAC,IAAI,EAAE,SAAS,KAAK,OAAO,mCA2DzC,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,SAAS,EAAE,EACnB,aAAa,MAAM,EACnB,aAAa,MAAM,gBA8CpB,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,QAAQ,SAAS,EAAE,EACnB,aAAa,MAAM,EACnB,aAAa,MAAM,gBA8CpB,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,SAAS,EAAE,EACnB,aAAa,MAAM,EACnB,OAAO,MAAM,gBAyBd,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,QAAQ,SAAS,EAAE,EACnB,aAAa,MAAM,EACnB,OAAO,MAAM,gBAyBd,CAAC"}
+{"version":3,"file":"merges.d.ts","sourceRoot":"","sources":["../../../api/merges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAY5D,eAAO,MAAM,eAAe,GAC1B,aAAa,SAAS,EAAE,GAAG,SAAS,GAAG,IAAI,EAC3C,IAAI,eAAe,GAAG,YAAY,GAAG,eAAe,GAAG,YAAY,EACnE,gBAAgB,MAAM,EACtB,cAAS,EACT,YAAY,CAAC,IAAI,EAAE,SAAS,KAAK,OAAO,mCA2DzC,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,SAAS,EAAE,EACnB,aAAa,MAAM,EACnB,aAAa,MAAM,gBA8CpB,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,QAAQ,SAAS,EAAE,EACnB,aAAa,MAAM,EACnB,aAAa,MAAM,gBA8CpB,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,SAAS,EAAE,EACnB,aAAa,MAAM,EACnB,OAAO,MAAM,gBAyBd,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,QAAQ,SAAS,EAAE,EACnB,aAAa,MAAM,EACnB,OAAO,MAAM,gBAyBd,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,SAAS,EAAE,GAAG,SAAS,GAAG,IAAI,EACtC,MAAM,KAAK,GAAG,QAAQ,EACtB,OAAO,MAAM,EACb,OAAO,MAAM,EACb,QAAQ,OAAO,EACf,WAAW,MAAM,EACjB,SAAS,MAAM,mCAkDhB,CAAC"}

package/dist/cjs/api/merges.js

@@ -1,4 +1,4 @@
-import { __assign } from "tslib";
+import { __assign, __values } from "tslib";
 /**
  * Move merged cells when user is inserts, deletes row and columns
  * @param mergedCells
@@ -132,3 +132,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/paint-format.d.ts

@@ -1,4 +1,4 @@
-import type { CellFormat, GridRange } from "@rowsncolumns/common-types";
+import type { CellFormat, CellInterface, GridRange } from "@rowsncolumns/common-types";
 /**
  * Format-painter pattern shared by both engines: the captured 2-D format grid plus the
  * source block's merge configuration, re-based to the block's top-left so it can be tiled
@@ -19,6 +19,20 @@ export type PaintPattern = {
  * the selected cells, not of the cells around them).
  */
 export declare const collectPaintMerges: (merges: GridRange[] | null | undefined, source: GridRange) => GridRange[];
+/**
+ * The block the painter captures when it is armed WITHOUT a drag selection. A plain click on a
+ * merged cell selects the whole merged area in Excel and Sheets, but the grid reports it as the
+ * anchor active cell plus an empty selection list — so the source is the merge containing the
+ * active cell when there is one, otherwise the single cell.
+ */
+export declare const paintSourceForActiveCell: (merges: GridRange[] | null | undefined, activeCell: CellInterface) => GridRange;
+/**
+ * Excel stores a merged area's style on every constituent cell, and the grid paints a merge with
+ * its anchor's format. Copy the anchor's captured format over the covered cells of every merge in
+ * the pattern (in place) so the painted target carries the fill on all of them — an unmerge at the
+ * target, or a partial tile that drops the merge, still leaves every cell looking as it did.
+ */
+export declare const spreadMergeAnchorFormats: (formats: (CellFormat | null | undefined)[][], relativeMerges: GridRange[]) => void;
 /**
  * Tile a pattern's relative merges across `target` with the pattern's period (`rows` × `cols`),
  * the same way the format grid itself is tiled by the formatting applier. A merge that a partial

package/dist/cjs/api/paint-format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paint-format.d.ts","sourceRoot":"","sources":["../../../api/paint-format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAGxE;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,CAAC,UAAU,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EAAE,CAAC;IAC7C,kFAAkF;IAClF,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAQF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,SAAS,EAAE,GAAG,IAAI,GAAG,SAAS,EACtC,QAAQ,SAAS,KAChB,SAAS,EAaX,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAC1B,gBAAgB,SAAS,EAAE,EAC3B,MAAM,MAAM,EACZ,MAAM,MAAM,EACZ,QAAQ,SAAS,KAChB,SAAS,EAqBX,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAC9B,aAAa,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,SAAS,GAAG,IAAI,EACvD,UAAU,MAAM,EAChB,aAAa,MAAM,KAClB,UAAU,GAAG,SACyC,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,UAAU,UAAU,GAAG,IAAI,GAAG,SAAS,EACvC,QAAQ,UAAU,GAAG,SAAS,KAC7B,UAAU,GAAG,IAAI,GAAG,SAWtB,CAAC"}
+{"version":3,"file":"paint-format.d.ts","sourceRoot":"","sources":["../../../api/paint-format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,SAAS,EACV,MAAM,4BAA4B,CAAC;AAGpC;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,CAAC,UAAU,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EAAE,CAAC;IAC7C,kFAAkF;IAClF,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAQF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,SAAS,EAAE,GAAG,IAAI,GAAG,SAAS,EACtC,QAAQ,SAAS,KAChB,SAAS,EAaX,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,QAAQ,SAAS,EAAE,GAAG,IAAI,GAAG,SAAS,EACtC,YAAY,aAAa,KACxB,SAkBF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,SAAS,CAAC,UAAU,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EAAE,EAC5C,gBAAgB,SAAS,EAAE,KAC1B,IAYF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAC1B,gBAAgB,SAAS,EAAE,EAC3B,MAAM,MAAM,EACZ,MAAM,MAAM,EACZ,QAAQ,SAAS,KAChB,SAAS,EAqBX,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAC9B,aAAa,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,SAAS,GAAG,IAAI,EACvD,UAAU,MAAM,EAChB,aAAa,MAAM,KAClB,UAAU,GAAG,SACyC,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,UAAU,UAAU,GAAG,IAAI,GAAG,SAAS,EACvC,QAAQ,UAAU,GAAG,SAAS,KAC7B,UAAU,GAAG,IAAI,GAAG,SAWtB,CAAC"}

package/dist/cjs/api/paint-format.js

@@ -1,5 +1,5 @@
 import { __assign, __read, __values } from "tslib";
-import { cellIdentifier } from "@rowsncolumns/grid";
+import { cellIdentifier, isCellWithinBounds } from "@rowsncolumns/grid";
 var rangeContains = function (outer, inner) {
     return inner.startRowIndex >= outer.startRowIndex &&
         inner.endRowIndex <= outer.endRowIndex &&
@@ -39,6 +39,65 @@ export var collectPaintMerges = function (merges, source) {
     }
     return out;
 };
+/**
+ * The block the painter captures when it is armed WITHOUT a drag selection. A plain click on a
+ * merged cell selects the whole merged area in Excel and Sheets, but the grid reports it as the
+ * anchor active cell plus an empty selection list — so the source is the merge containing the
+ * active cell when there is one, otherwise the single cell.
+ */
+export var paintSourceForActiveCell = function (merges, activeCell) {
+    var merge = merges === null || merges === void 0 ? void 0 : merges.find(function (candidate) {
+        return isCellWithinBounds(activeCell, candidate);
+    });
+    if (merge) {
+        return {
+            startRowIndex: merge.startRowIndex,
+            endRowIndex: merge.endRowIndex,
+            startColumnIndex: merge.startColumnIndex,
+            endColumnIndex: merge.endColumnIndex,
+        };
+    }
+    return {
+        startRowIndex: activeCell.rowIndex,
+        endRowIndex: activeCell.rowIndex,
+        startColumnIndex: activeCell.columnIndex,
+        endColumnIndex: activeCell.columnIndex,
+    };
+};
+/**
+ * Excel stores a merged area's style on every constituent cell, and the grid paints a merge with
+ * its anchor's format. Copy the anchor's captured format over the covered cells of every merge in
+ * the pattern (in place) so the painted target carries the fill on all of them — an unmerge at the
+ * target, or a partial tile that drops the merge, still leaves every cell looking as it did.
+ */
+export var spreadMergeAnchorFormats = function (formats, relativeMerges) {
+    var e_2, _a;
+    var _b;
+    try {
+        for (var relativeMerges_1 = __values(relativeMerges), relativeMerges_1_1 = relativeMerges_1.next(); !relativeMerges_1_1.done; relativeMerges_1_1 = relativeMerges_1.next()) {
+            var merge = relativeMerges_1_1.value;
+            var anchor = (_b = formats[merge.startRowIndex]) === null || _b === void 0 ? void 0 : _b[merge.startColumnIndex];
+            for (var r = merge.startRowIndex; r <= merge.endRowIndex; r++) {
+                var row = formats[r];
+                if (!row)
+                    continue;
+                for (var c = merge.startColumnIndex; c <= merge.endColumnIndex; c++) {
+                    if (r === merge.startRowIndex && c === merge.startColumnIndex)
+                        continue;
+                    if (c < row.length)
+                        row[c] = anchor;
+                }
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (relativeMerges_1_1 && !relativeMerges_1_1.done && (_a = relativeMerges_1.return)) _a.call(relativeMerges_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+};
 /**
  * Tile a pattern's relative merges across `target` with the pattern's period (`rows` × `cols`),
  * the same way the format grid itself is tiled by the formatting applier. A merge that a partial
@@ -46,15 +105,15 @@ export var collectPaintMerges = function (merges, source) {
  * that the user did not drag over.
  */
 export var tilePaintMerges = function (relativeMerges, rows, cols, target) {
-    var e_2, _a;
+    var e_3, _a;
     if (!relativeMerges.length || rows <= 0 || cols <= 0)
         return [];
     var out = [];
     for (var top_1 = target.startRowIndex; top_1 <= target.endRowIndex; top_1 += rows) {
         for (var left = target.startColumnIndex; left <= target.endColumnIndex; left += cols) {
             try {
-                for (var relativeMerges_1 = (e_2 = void 0, __values(relativeMerges)), relativeMerges_1_1 = relativeMerges_1.next(); !relativeMerges_1_1.done; relativeMerges_1_1 = relativeMerges_1.next()) {
-                    var merge = relativeMerges_1_1.value;
+                for (var relativeMerges_2 = (e_3 = void 0, __values(relativeMerges)), relativeMerges_2_1 = relativeMerges_2.next(); !relativeMerges_2_1.done; relativeMerges_2_1 = relativeMerges_2.next()) {
+                    var merge = relativeMerges_2_1.value;
                     var placed = {
                         startRowIndex: top_1 + merge.startRowIndex,
                         endRowIndex: top_1 + merge.endRowIndex,
@@ -65,12 +124,12 @@ export var tilePaintMerges = function (relativeMerges, rows, cols, target) {
                         out.push(placed);
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
             finally {
                 try {
-                    if (relativeMerges_1_1 && !relativeMerges_1_1.done && (_a = relativeMerges_1.return)) _a.call(relativeMerges_1);
+                    if (relativeMerges_2_1 && !relativeMerges_2_1.done && (_a = relativeMerges_2.return)) _a.call(relativeMerges_2);
                 }
-                finally { if (e_2) throw e_2.error; }
+                finally { if (e_3) throw e_3.error; }
             }
         }
     }
@@ -90,7 +149,7 @@ export var getBandedCellFormat = function (bandedCells, rowIndex, columnIndex) {
  * `undefined` never clobbers a banded value.
  */
 export var layerBandedFormat = function (explicit, banded) {
-    var e_3, _a;
+    var e_4, _a;
     if (!banded)
         return explicit;
     var merged = __assign({}, banded);
@@ -103,12 +162,12 @@ export var layerBandedFormat = function (explicit, banded) {
                 }
             }
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_3) throw e_3.error; }
+            finally { if (e_4) throw e_4.error; }
         }
     }
     return merged;

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