@rowsncolumns/spreadsheet-state 28.0.75 → 28.0.76

package/dist/cjs/api/formula.js

@@ -1,5 +1,5 @@
-import { __assign, __values } from "tslib";
-import { isRangeToken, lexify, stripPropertyFromCellRef, tokenVocabulary, } from "@rowsncolumns/calculator";
+import { __assign, __read, __values } from "tslib";
+import { cleanupColumnName, cleanupTableName, isRangeToken, lexify, stripPropertyFromCellRef, tokenVocabulary, } from "@rowsncolumns/calculator";
 import { addressToCell, alpha2number, cellToAddress, desanitizeSheetName, number2Alpha, sanitizeSheetName, } from "@rowsncolumns/utils";
 export { ERROR_CIRCULAR_DEPENDENCY, ERROR_REFERENCE, formulaToRelativeReference, } from "@rowsncolumns/calculator";
 /**
@@ -99,6 +99,145 @@ export var updateColumnName = function (formulaValue, newName, oldName) {
     }
     return detokenize(newTokens);
 };
+/** The column specifier Excel writes for a deleted table column (`Table1[@#REF!]`). */
+export var REF_ERROR_COLUMN = "#REF!";
+var REF_ERROR_TOKEN = "#REF!";
+/**
+ * One `#REF!` token standing in for the run `start … end` (a range's start,
+ * colon and end): it keeps `start`'s position and stretches to `end` so
+ * `detokenize` (which re-inserts a space wherever adjacent tokens' offsets
+ * disagree) prints `SUM(#REF!)`, not `SUM(#REF! )`.
+ */
+var collapseToRefError = function (start, end) {
+    var _a, _b;
+    return (__assign(__assign({}, start), { image: REF_ERROR_TOKEN, tokenType: tokenVocabulary.RefError, endOffset: (_a = end === null || end === void 0 ? void 0 : end.endOffset) !== null && _a !== void 0 ? _a : start.endOffset, endColumn: (_b = end === null || end === void 0 ? void 0 : end.endColumn) !== null && _b !== void 0 ? _b : start.endColumn }));
+};
+var isTableNameToken = function (token) {
+    return (token === null || token === void 0 ? void 0 : token.tokenType.name) === tokenVocabulary.TableName.name;
+};
+var isTableColumnToken = function (token) {
+    return (token === null || token === void 0 ? void 0 : token.tokenType.name) === tokenVocabulary.TableColumnName.name;
+};
+/** Bracket depth change contributed by one token's image (`Table1[` opens, `Qty]` closes). */
+var bracketDelta = function (image) {
+    var e_4, _a;
+    var depth = 0;
+    try {
+        for (var image_1 = __values(image), image_1_1 = image_1.next(); !image_1_1.done; image_1_1 = image_1.next()) {
+            var ch = image_1_1.value;
+            if (ch === "[")
+                depth++;
+            else if (ch === "]")
+                depth--;
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (image_1_1 && !image_1_1.done && (_a = image_1.return)) _a.call(image_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return depth;
+};
+/**
+ * Index just past the last token of the structured reference that starts at
+ * `start` (a TableName token): consume tokens until the bracket the table name
+ * opened is closed again.
+ */
+var structuredReferenceEnd = function (tokens, start) {
+    var depth = 0;
+    var i = start;
+    while (i < tokens.length) {
+        depth += bracketDelta(tokens[i].image);
+        i++;
+        if (depth <= 0)
+            break;
+    }
+    return i;
+};
+/**
+ * Rewrite every structured reference into `tableName` to the `#REF!` token —
+ * Excel's text for a formula whose table was deleted (`=SUM(Table1[Price])`
+ * → `=SUM(#REF!)`), so the cell evaluates to `#REF!` rather than `#NAME?`.
+ * Returns the input unchanged when the formula never names the table.
+ */
+export var breakTableReferencesInFormula = function (formulaValue, tableName) {
+    var _a;
+    if (!formulaValue.includes("["))
+        return formulaValue;
+    var tokens = cloneTokens(lexify(formulaValue).tokens);
+    var newTokens = [];
+    var target = tableName.toLowerCase();
+    var hasChanges = false;
+    for (var i = 0; i < tokens.length; i++) {
+        var token = tokens[i];
+        if (isTableNameToken(token) &&
+            cleanupTableName(token.image).trim().toLowerCase() === target) {
+            var end = structuredReferenceEnd(tokens, i);
+            var last = (_a = tokens[end - 1]) !== null && _a !== void 0 ? _a : token;
+            newTokens.push(__assign(__assign({}, token), { image: REF_ERROR_TOKEN, endOffset: last.endOffset, endColumn: last.endColumn, tokenType: tokenVocabulary.RefError }));
+            i = end - 1;
+            hasChanges = true;
+            continue;
+        }
+        newTokens.push(token);
+    }
+    return hasChanges ? detokenize(newTokens) : formulaValue;
+};
+/**
+ * Rewrite the column specifiers of `columnNames` inside structured references
+ * to `tableName` (or, when `tableName` is undefined, the bare this-row form
+ * `[@Col]` whose table is implied by the formula's own cell) to `#REF!` —
+ * Excel's text for a deleted table column (`=Table1[@Qty]*2` →
+ * `=Table1[@#REF!]*2`). Keeps every other character of the reference as typed.
+ */
+export var breakTableColumnsInFormula = function (formulaValue, tableName, columnNames) {
+    if (!formulaValue.includes("[") || columnNames.length === 0) {
+        return formulaValue;
+    }
+    var targets = new Set(columnNames.map(function (name) { return name.toLowerCase(); }));
+    var target = tableName === null || tableName === void 0 ? void 0 : tableName.toLowerCase();
+    var tokens = cloneTokens(lexify(formulaValue).tokens);
+    var hasChanges = false;
+    var i = 0;
+    while (i < tokens.length) {
+        var token = tokens[i];
+        if (isTableNameToken(token)) {
+            var end = structuredReferenceEnd(tokens, i);
+            var matches = target !== undefined &&
+                cleanupTableName(token.image).trim().toLowerCase() === target;
+            if (matches) {
+                for (var j = i + 1; j < end; j++) {
+                    if (breakColumnToken(tokens[j], targets))
+                        hasChanges = true;
+                }
+            }
+            i = end;
+            continue;
+        }
+        // A bare `[@Col]` / `[Col]` names the table the formula cell sits in.
+        if (target === undefined && isTableColumnToken(token)) {
+            if (breakColumnToken(token, targets))
+                hasChanges = true;
+        }
+        i++;
+    }
+    return hasChanges ? detokenize(tokens) : formulaValue;
+};
+var breakColumnToken = function (token, targets) {
+    if (!token || !isTableColumnToken(token))
+        return false;
+    var name = cleanupColumnName(token.image);
+    if (!name || !targets.has(name.toLowerCase()))
+        return false;
+    var at = token.image.indexOf(name);
+    if (at === -1)
+        return false;
+    token.image =
+        token.image.slice(0, at) + REF_ERROR_COLUMN + token.image.slice(at + name.length);
+    return true;
+};
 /**
  * Converts tokens to string
  * @param tokens
@@ -158,19 +297,34 @@ export var isAbsoluteRowReference = function (formula) {
         return false;
     return /\$\d+/gi.test(formula);
 };
+var isRangeWithinBandSpan = function (startCell, endCell, dimension, bandSpan) {
+    if (!bandSpan)
+        return true;
+    var _a = __read(dimension === "row"
+        ? [startCell.columnIndex, endCell.columnIndex]
+        : [startCell.rowIndex, endCell.rowIndex], 2), start = _a[0], end = _a[1];
+    return (Math.min(start, end) >= bandSpan.startIndex &&
+        Math.max(start, end) <= bandSpan.endIndex);
+};
 /**
  * Expands ranges in a formula when rows or columns are inserted within the range
  * @param formula The formula to process
  * @param insertionIndex The row or column index where insertion happens
  * @param count Number of rows or columns being inserted
  * @param dimension Whether inserting 'row' or 'column'
- * @param activeSheetName Active sheet name to scope range updates
+ * @param activeSheetName Name of the EDITED sheet: only references that resolve
+ *   to it are touched
+ * @param options `includeUnqualifiedReferences` — whether references without a
+ *   sheet qualifier resolve to the edited sheet (true when the formula lives on
+ *   it; false for a formula on another sheet, whose bare `A1:A3` is its own)
  * @returns The formula with expanded ranges, or undefined if no changes
  */
-export var expandRangesInFormula = function (formula, insertionIndex, count, dimension, activeSheetName) {
+export var expandRangesInFormula = function (formula, insertionIndex, count, dimension, activeSheetName, options) {
+    if (options === void 0) { options = {}; }
     if (!formula || count <= 0) {
         return formula;
     }
+    var _a = options.includeUnqualifiedReferences, includeUnqualifiedReferences = _a === void 0 ? true : _a, bandSpan = options.bandSpan;
     var normalizedActiveSheetName = activeSheetName.toLowerCase();
     var tokens = cloneTokens(lexify(formula).tokens);
     var newTokens = [];
@@ -178,7 +332,9 @@ export var expandRangesInFormula = function (formula, insertionIndex, count, dim
     for (var i = 0; i < tokens.length; i++) {
         var token = tokens[i];
         var sheetName = getSheetNameFromToken(tokens[i - 1]);
-        var skipSheet = sheetName && sheetName.toLowerCase() !== normalizedActiveSheetName;
+        var skipSheet = sheetName
+            ? sheetName.toLowerCase() !== normalizedActiveSheetName
+            : !includeUnqualifiedReferences;
         // Handle cell ranges (e.g., A1:A10)
         if (token.tokenType.name === tokenVocabulary.Cell.name) {
             var isRange = isRangeToken(tokens[i + 1]);
@@ -193,7 +349,9 @@ export var expandRangesInFormula = function (formula, insertionIndex, count, dim
             if (isRange && tokens[i + 2]) {
                 var startCell = addressToCell(stripPropertyFromCellRef(token.image));
                 var endCell = addressToCell(stripPropertyFromCellRef(tokens[i + 2].image));
-                if (startCell && endCell) {
+                if (startCell &&
+                    endCell &&
+                    isRangeWithinBandSpan(startCell, endCell, dimension, bandSpan)) {
                     var isAbsoluteEndRow = isAbsoluteRowReference(tokens[i + 2].image);
                     var isAbsoluteEndCol = isAbsoluteColumnReference(tokens[i + 2].image);
                     if (dimension === "row") {
@@ -233,7 +391,7 @@ export var expandRangesInFormula = function (formula, insertionIndex, count, dim
         if (dimension === "column" &&
             token.tokenType.name === tokenVocabulary.Column.name) {
             var isRange = isRangeToken(tokens[i + 1]);
-            if (skipSheet) {
+            if (skipSheet || bandSpan) {
                 if (isRange) {
                     newTokens.push(token, tokens[i + 1], tokens[i + 2]);
                     i += 2;
@@ -260,7 +418,7 @@ export var expandRangesInFormula = function (formula, insertionIndex, count, dim
         if (dimension === "row" &&
             token.tokenType.name === tokenVocabulary.Number.name) {
             var isRange = isRangeToken(tokens[i + 1]);
-            if (skipSheet) {
+            if (skipSheet || bandSpan) {
                 if (isRange) {
                     newTokens.push(token, tokens[i + 1], tokens[i + 2]);
                     i += 2;
@@ -293,22 +451,48 @@ export var expandRangesInFormula = function (formula, insertionIndex, count, dim
  * @param deletionIndex The row or column index where deletion starts
  * @param count Number of rows or columns being deleted
  * @param dimension Whether deleting 'row' or 'column'
- * @param activeSheetName Active sheet name to scope range updates
+ * @param activeSheetName Name of the EDITED sheet: only references that resolve
+ *   to it are touched
+ * @param options `includeUnqualifiedReferences` — see `expandRangesInFormula`
  * @returns The formula with contracted ranges, or undefined if no changes
+ *
+ * Excel semantics for the deleted band: a range whose rows/columns are ALL
+ * deleted becomes the `#REF!` token (`=SUM(A2:A3)` → `=SUM(#REF!)`); a single
+ * cell reference into the band becomes `#REF!` (`=A3+1` → `=#REF!+1`, a spill
+ * reference `=C1#` → `=#REF!#`); a partially covered range shrinks.
  */
-export var contractRangesInFormula = function (formula, deletionIndex, count, dimension, activeSheetName) {
+export var contractRangesInFormula = function (formula, deletionIndex, count, dimension, activeSheetName, options) {
+    if (options === void 0) { options = {}; }
     if (!formula || count <= 0) {
         return formula;
     }
+    var _a = options.includeUnqualifiedReferences, includeUnqualifiedReferences = _a === void 0 ? true : _a, bandSpan = options.bandSpan;
     var normalizedActiveSheetName = activeSheetName.toLowerCase();
     var tokens = cloneTokens(lexify(formula).tokens);
     var newTokens = [];
     var hasChanges = false;
     var deletionEnd = deletionIndex + count - 1;
+    var inDeletedBand = function (cell) {
+        var index = dimension === "row" ? cell.rowIndex : cell.columnIndex;
+        return index >= deletionIndex && index <= deletionEnd;
+    };
+    var overlapsBand = function (start, end) {
+        return deletionIndex <= end && deletionEnd >= start;
+    };
+    // The survivors of a span that overlaps (but is not swallowed by) the band:
+    // whatever lay before the band keeps its start, whatever lay inside starts at
+    // the deletion point; an end past the band moves up by the full count, an
+    // end inside the band stops just before it.
+    var contractSpan = function (start, end) { return ({
+        start: Math.min(start, deletionIndex),
+        end: end > deletionEnd ? end - count : deletionIndex - 1,
+    }); };
     for (var i = 0; i < tokens.length; i++) {
         var token = tokens[i];
         var sheetName = getSheetNameFromToken(tokens[i - 1]);
-        var skipSheet = sheetName && sheetName.toLowerCase() !== normalizedActiveSheetName;
+        var skipSheet = sheetName
+            ? sheetName.toLowerCase() !== normalizedActiveSheetName
+            : !includeUnqualifiedReferences;
         // Handle cell ranges (e.g., A1:A10)
         if (token.tokenType.name === tokenVocabulary.Cell.name) {
             var isRange = isRangeToken(tokens[i + 1]);
@@ -320,10 +504,33 @@ export var contractRangesInFormula = function (formula, deletionIndex, count, di
                 }
                 continue;
             }
+            if (!isRange) {
+                // Single cell: broken when it sits in the deleted band. The trailing
+                // spilled-range operator (`C1#`) stays on the token (`#REF!#`).
+                var spill = token.image.endsWith("#") ? "#" : "";
+                var cell = addressToCell(stripPropertyFromCellRef(spill ? token.image.slice(0, -1) : token.image));
+                if (cell &&
+                    inDeletedBand(cell) &&
+                    isRangeWithinBandSpan(cell, cell, dimension, bandSpan)) {
+                    token.image = "".concat(REF_ERROR_TOKEN).concat(spill);
+                    hasChanges = true;
+                }
+                newTokens.push(token);
+                continue;
+            }
             if (isRange && tokens[i + 2]) {
                 var startCell = addressToCell(stripPropertyFromCellRef(token.image));
                 var endCell = addressToCell(stripPropertyFromCellRef(tokens[i + 2].image));
-                if (startCell && endCell) {
+                if (startCell &&
+                    endCell &&
+                    isRangeWithinBandSpan(startCell, endCell, dimension, bandSpan)) {
+                    // Every row/column of the range deleted → the whole range is #REF!.
+                    if (inDeletedBand(startCell) && inDeletedBand(endCell)) {
+                        newTokens.push(collapseToRefError(token, tokens[i + 2]));
+                        i += 2;
+                        hasChanges = true;
+                        continue;
+                    }
                     var isAbsoluteStartRow = isAbsoluteRowReference(token.image);
                     var isAbsoluteEndRow = isAbsoluteRowReference(tokens[i + 2].image);
                     var isAbsoluteStartCol = isAbsoluteColumnReference(token.image);
@@ -331,18 +538,10 @@ export var contractRangesInFormula = function (formula, deletionIndex, count, di
                     if (dimension === "row") {
                         var rangeStart = startCell.rowIndex;
                         var rangeEnd = endCell.rowIndex;
-                        // Check if deletion overlaps with range
-                        if (deletionIndex <= rangeEnd && deletionEnd >= rangeStart) {
-                            // Calculate how many deleted rows are within the range
-                            var overlapStart = Math.max(deletionIndex, rangeStart);
-                            var overlapEnd = Math.min(deletionEnd, rangeEnd);
-                            var rowsDeletedInRange = overlapEnd - overlapStart + 1;
-                            // Contract the end of the range
-                            endCell.rowIndex -= rowsDeletedInRange;
-                            // If entire range is deleted, result in #REF! (but we'll just contract to minimum)
-                            if (endCell.rowIndex < startCell.rowIndex) {
-                                endCell.rowIndex = startCell.rowIndex;
-                            }
+                        if (overlapsBand(rangeStart, rangeEnd)) {
+                            var survivors = contractSpan(rangeStart, rangeEnd);
+                            startCell.rowIndex = survivors.start;
+                            endCell.rowIndex = survivors.end;
                             var newStartAddress = cellToAddress(startCell, isAbsoluteStartCol, isAbsoluteStartRow);
                             var newEndAddress = cellToAddress(endCell, isAbsoluteEndCol, isAbsoluteEndRow);
                             if (newStartAddress && newEndAddress) {
@@ -356,18 +555,10 @@ export var contractRangesInFormula = function (formula, deletionIndex, count, di
                         // dimension === 'column'
                         var rangeStart = startCell.columnIndex;
                         var rangeEnd = endCell.columnIndex;
-                        // Check if deletion overlaps with range
-                        if (deletionIndex <= rangeEnd && deletionEnd >= rangeStart) {
-                            // Calculate how many deleted columns are within the range
-                            var overlapStart = Math.max(deletionIndex, rangeStart);
-                            var overlapEnd = Math.min(deletionEnd, rangeEnd);
-                            var colsDeletedInRange = overlapEnd - overlapStart + 1;
-                            // Contract the end of the range
-                            endCell.columnIndex -= colsDeletedInRange;
-                            // If entire range is deleted, result in #REF! (but we'll just contract to minimum)
-                            if (endCell.columnIndex < startCell.columnIndex) {
-                                endCell.columnIndex = startCell.columnIndex;
-                            }
+                        if (overlapsBand(rangeStart, rangeEnd)) {
+                            var survivors = contractSpan(rangeStart, rangeEnd);
+                            startCell.columnIndex = survivors.start;
+                            endCell.columnIndex = survivors.end;
                             var newStartAddress = cellToAddress(startCell, isAbsoluteStartCol, isAbsoluteStartRow);
                             var newEndAddress = cellToAddress(endCell, isAbsoluteEndCol, isAbsoluteEndRow);
                             if (newStartAddress && newEndAddress) {
@@ -387,7 +578,7 @@ export var contractRangesInFormula = function (formula, deletionIndex, count, di
         if (dimension === "column" &&
             token.tokenType.name === tokenVocabulary.Column.name) {
             var isRange = isRangeToken(tokens[i + 1]);
-            if (skipSheet) {
+            if (skipSheet || bandSpan) {
                 if (isRange) {
                     newTokens.push(token, tokens[i + 1], tokens[i + 2]);
                     i += 2;
@@ -397,20 +588,19 @@ export var contractRangesInFormula = function (formula, deletionIndex, count, di
             if (isRange && tokens[i + 2]) {
                 var startColumnIndex = alpha2number(token.image);
                 var endColumnIndex = alpha2number(tokens[i + 2].image);
-                // Check if deletion overlaps with range
-                if (deletionIndex <= endColumnIndex &&
-                    deletionEnd >= startColumnIndex) {
-                    // Calculate how many deleted columns are within the range
-                    var overlapStart = Math.max(deletionIndex, startColumnIndex);
-                    var overlapEnd = Math.min(deletionEnd, endColumnIndex);
-                    var colsDeletedInRange = overlapEnd - overlapStart + 1;
-                    // Contract the end column
-                    var newEndColumnIndex = endColumnIndex - colsDeletedInRange;
-                    // If entire range is deleted, keep at minimum
-                    if (newEndColumnIndex >= startColumnIndex) {
-                        tokens[i + 2].image = number2Alpha(newEndColumnIndex - 1);
+                if (overlapsBand(startColumnIndex, endColumnIndex)) {
+                    // Every column deleted → #REF!; otherwise the survivors close up.
+                    if (startColumnIndex >= deletionIndex &&
+                        endColumnIndex <= deletionEnd) {
+                        newTokens.push(collapseToRefError(token, tokens[i + 2]));
+                        i += 2;
                         hasChanges = true;
+                        continue;
                     }
+                    var survivors = contractSpan(startColumnIndex, endColumnIndex);
+                    token.image = number2Alpha(survivors.start - 1);
+                    tokens[i + 2].image = number2Alpha(survivors.end - 1);
+                    hasChanges = true;
                 }
                 newTokens.push(token, tokens[i + 1], tokens[i + 2]);
                 i += 2;
@@ -421,7 +611,7 @@ export var contractRangesInFormula = function (formula, deletionIndex, count, di
         if (dimension === "row" &&
             token.tokenType.name === tokenVocabulary.Number.name) {
             var isRange = isRangeToken(tokens[i + 1]);
-            if (skipSheet) {
+            if (skipSheet || bandSpan) {
                 if (isRange) {
                     newTokens.push(token, tokens[i + 1], tokens[i + 2]);
                     i += 2;
@@ -433,19 +623,18 @@ export var contractRangesInFormula = function (formula, deletionIndex, count, di
                 tokens[i + 2].tokenType.name === tokenVocabulary.Number.name) {
                 var startRowIndex = Number(token.image);
                 var endRowIndex = Number(tokens[i + 2].image);
-                // Check if deletion overlaps with range
-                if (deletionIndex <= endRowIndex && deletionEnd >= startRowIndex) {
-                    // Calculate how many deleted rows are within the range
-                    var overlapStart = Math.max(deletionIndex, startRowIndex);
-                    var overlapEnd = Math.min(deletionEnd, endRowIndex);
-                    var rowsDeletedInRange = overlapEnd - overlapStart + 1;
-                    // Contract the end row
-                    var newEndRowIndex = endRowIndex - rowsDeletedInRange;
-                    // If entire range is deleted, keep at minimum
-                    if (newEndRowIndex >= startRowIndex) {
-                        tokens[i + 2].image = String(newEndRowIndex);
+                if (overlapsBand(startRowIndex, endRowIndex)) {
+                    // Every row deleted → #REF!; otherwise the survivors close up.
+                    if (startRowIndex >= deletionIndex && endRowIndex <= deletionEnd) {
+                        newTokens.push(collapseToRefError(token, tokens[i + 2]));
+                        i += 2;
                         hasChanges = true;
+                        continue;
                     }
+                    var survivors = contractSpan(startRowIndex, endRowIndex);
+                    token.image = String(survivors.start);
+                    tokens[i + 2].image = String(survivors.end);
+                    hasChanges = true;
                 }
                 newTokens.push(token, tokens[i + 1], tokens[i + 2]);
                 i += 2;

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