@rowsncolumns/spreadsheet-state 28.0.74 → 28.0.76

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

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

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

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

package/dist/cjs/api/structural-formula-update.js

@@ -89,6 +89,11 @@ export var updateFormulasForStructuralChange = function (params) {
             startColumnIndex: isInsert ? referenceIndex : referenceIndex + count,
             endColumnIndex: columnCount,
         };
+    // The cells a delete removes: any reference into them (that Pass 1 did not
+    // already contract) is broken to `#REF!` instead of sliding onto the cell
+    // that moves into its place.
+    var deletedRange = isInsert ? undefined : pass1Range;
+    var editedSheetName = getSheetName(sheetId);
     // ---- PASS 1 ----
     var pass1Formulas = collectUniqueDependentsForRange({
         draft: draft,
@@ -109,10 +114,15 @@ export var updateFormulasForStructuralChange = function (params) {
                 var formulaValue = sheetCell.formula;
                 if (!formulaValue)
                     continue;
-                var activeSheetName = getSheetName(pos.sheetId);
+                // Scope to the EDITED sheet: a qualified `Sheet1!A1:A3` on another
+                // sheet expands like a local range, while that other sheet's own bare
+                // `A1:A3` (which resolves to ITS sheet) is left alone.
+                var rangeOptions = {
+                    includeUnqualifiedReferences: pos.sheetId === sheetId,
+                };
                 var updatedFormula = isInsert
-                    ? expandRangesInFormula(formulaValue, referenceIndex, count, axis, activeSheetName)
-                    : contractRangesInFormula(formulaValue, referenceIndex, count, axis, activeSheetName);
+                    ? expandRangesInFormula(formulaValue, referenceIndex, count, axis, editedSheetName, rangeOptions)
+                    : contractRangesInFormula(formulaValue, referenceIndex, count, axis, editedSheetName, rangeOptions);
                 if (!updatedFormula || updatedFormula === formulaValue)
                     continue;
                 sheetCell.setFormulaValue(updatedFormula, false);
@@ -180,7 +190,7 @@ export var updateFormulasForStructuralChange = function (params) {
                 shiftExternalDependentFormulaReferences({
                     draft: draft,
                     position: pos,
-                    editedSheetName: getSheetName(sheetId),
+                    editedSheetName: editedSheetName,
                     enqueueCalculation: enqueueCalculation,
                     enqueueGraphOperation: enqueueGraphOperation,
                     recalcCells: recalcCells,
@@ -188,6 +198,7 @@ export var updateFormulasForStructuralChange = function (params) {
                     rowDelta: rowDelta,
                     columnDelta: columnDelta,
                     sourceRange: pass2SourceRange,
+                    deletedRange: deletedRange,
                     locale: locale,
                     rowCount: rowCount,
                     columnCount: columnCount,
@@ -207,6 +218,7 @@ export var updateFormulasForStructuralChange = function (params) {
                 rowDelta: rowDelta,
                 columnDelta: columnDelta,
                 sourceRange: pass2SourceRange,
+                deletedRange: deletedRange,
                 locale: locale,
                 rowCount: rowCount,
                 columnCount: columnCount,
@@ -231,7 +243,7 @@ export var updateFormulasForStructuralChange = function (params) {
             shiftExternalDependentFormulaReferences({
                 draft: draft,
                 position: position,
-                editedSheetName: getSheetName(sheetId),
+                editedSheetName: editedSheetName,
                 enqueueCalculation: enqueueCalculation,
                 enqueueGraphOperation: enqueueGraphOperation,
                 recalcCells: recalcCells,
@@ -239,6 +251,7 @@ export var updateFormulasForStructuralChange = function (params) {
                 rowDelta: rowDelta,
                 columnDelta: columnDelta,
                 sourceRange: pass2SourceRange,
+                deletedRange: deletedRange,
                 locale: locale,
                 rowCount: rowCount,
                 columnCount: columnCount,
@@ -284,6 +297,7 @@ export var updateFormulasForStructuralChange = function (params) {
                         rowIndex: pos.rowIndex,
                         columnIndex: pos.columnIndex,
                     },
+                    activeSheetName: editedSheetName,
                     enqueueCalculation: enqueueCalculation,
                     enqueueGraphOperation: enqueueGraphOperation,
                     recalcCells: recalcCells,
@@ -291,6 +305,7 @@ export var updateFormulasForStructuralChange = function (params) {
                     rowDelta: rowDelta,
                     columnDelta: columnDelta,
                     sourceRange: pass2SourceRange,
+                    deletedRange: deletedRange,
                     locale: locale,
                     rowCount: rowCount,
                     columnCount: columnCount,
@@ -328,6 +343,7 @@ export var updateFormulasForStructuralChange = function (params) {
                 moveFormulaAtPosition({
                     draft: draft,
                     position: { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex },
+                    activeSheetName: editedSheetName,
                     enqueueCalculation: enqueueCalculation,
                     enqueueGraphOperation: enqueueGraphOperation,
                     recalcCells: recalcCells,
@@ -335,6 +351,7 @@ export var updateFormulasForStructuralChange = function (params) {
                     rowDelta: rowDelta,
                     columnDelta: columnDelta,
                     sourceRange: pass2SourceRange,
+                    deletedRange: deletedRange,
                     locale: locale,
                     rowCount: rowCount,
                     columnCount: columnCount,
@@ -347,7 +364,7 @@ export var updateFormulasForStructuralChange = function (params) {
 };
 var shiftExternalDependentFormulaReferences = function (_a) {
     var _b, _c;
-    var draft = _a.draft, position = _a.position, editedSheetName = _a.editedSheetName, enqueueCalculation = _a.enqueueCalculation, enqueueGraphOperation = _a.enqueueGraphOperation, recalcCells = _a.recalcCells, movedKeys = _a.movedKeys, rowDelta = _a.rowDelta, columnDelta = _a.columnDelta, sourceRange = _a.sourceRange, locale = _a.locale, rowCount = _a.rowCount, columnCount = _a.columnCount, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry;
+    var draft = _a.draft, position = _a.position, editedSheetName = _a.editedSheetName, enqueueCalculation = _a.enqueueCalculation, enqueueGraphOperation = _a.enqueueGraphOperation, recalcCells = _a.recalcCells, movedKeys = _a.movedKeys, rowDelta = _a.rowDelta, columnDelta = _a.columnDelta, sourceRange = _a.sourceRange, deletedRange = _a.deletedRange, locale = _a.locale, rowCount = _a.rowCount, columnCount = _a.columnCount, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry;
     var sheetCell = new SheetCell();
     var currentSheet = createSheetDraft(draft, position.sheetId, position.rowIndex);
     var cellData = (_c = (_b = currentSheet[position.rowIndex]) === null || _b === void 0 ? void 0 : _b.values) === null || _c === void 0 ? void 0 : _c[position.columnIndex];
@@ -362,6 +379,7 @@ var shiftExternalDependentFormulaReferences = function (_a) {
         columnIndex: position.columnIndex + columnDelta,
     }, editedSheetName, {
         exclusionRange: sourceRange,
+        deletedRange: deletedRange,
         rowCount: rowCount,
         columnCount: columnCount,
         referenceSheetName: editedSheetName,

package/dist/cjs/api/structural-guards.d.ts

@@ -0,0 +1,78 @@
+import type { CellData, CellInterface, GridRange, SelectionArea } from "@rowsncolumns/common-types";
+import type { SelectionAttributes, TableView } from "@rowsncolumns/spreadsheet";
+import { type StructuralRefusal } from "../constants";
+import type { SheetData } from "../hooks/use-spreadsheet-state";
+/**
+ * Pure predicates behind Excel's structural-edit refusals. The hooks run them BEFORE the interface
+ * function touches any state and `showError` the Excel message on refusal, so a refused edit leaves
+ * sheetData / merges / tables / selection exactly as they were.
+ *
+ * A "band" is the rectangle of cells an edit relocates. Shift cells down at `B2:B3` moves
+ * `B2:B∞` — an open end is expressed with `Number.POSITIVE_INFINITY`.
+ */
+export type StructuralBand = GridRange;
+export type ShiftDirection = "down" | "right" | "up" | "left";
+/** The selection a cell shift operates on — the LAST selection, or the active cell as a 1×1. The
+ * hooks' guards and the interface functions must agree on it, so both resolve it here. */
+export declare const resolveShiftSelection: (activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => SelectionArea<SelectionAttributes>;
+/** The cells a shift relocates: the selection's rows/columns from its leading edge to the sheet edge. */
+export declare const shiftBand: (direction: ShiftDirection, range: GridRange) => StructuralBand;
+export declare const isNonBlankCell: (cell: CellData | null | undefined) => boolean;
+/**
+ * INS-06 / INS-09 / SHF-10 — the first non-blank cell that a shift of `count` rows (axis `row`) or
+ * columns (axis `column`) would push past `limit` (the last valid row/column index). Only cells
+ * inside `band` move. `undefined` when the edit is safe.
+ */
+export declare const findOffSheetPush: <T extends CellData>({ rows, axis, count, limit, band, }: {
+    rows: SheetData<T>[number] | undefined;
+    axis: "row" | "column";
+    count: number;
+    limit: number | undefined;
+    band: StructuralBand;
+}) => CellInterface | undefined;
+/**
+ * A range the band reaches but does not contain whole is TORN by the shift. For a delete, a range
+ * that touches the deleted block must lie wholly inside it (it is removed with the block) — one
+ * straddling the block's edge is torn too.
+ */
+export declare const findTornRange: (ranges: readonly GridRange[] | undefined | null, band: StructuralBand, deletedBlock?: GridRange) => GridRange | undefined;
+/** SHF-05 / MRG-07 — a merge the band covers only partially. */
+export declare const findTornMerge: (merges: readonly GridRange[] | undefined | null, band: StructuralBand, deletedBlock?: GridRange) => GridRange | undefined;
+/** TBL-05 — a table the band covers only partially (a table wholly inside the band moves intact). */
+export declare const findTornTable: (tables: readonly TableView[] | undefined | null, sheetId: number, band: StructuralBand, deletedBlock?: GridRange) => TableView | undefined;
+/** ANC-14 — a CSE / dynamic-array range the band covers only partially. */
+export declare const findTornArray: (arrayRanges: readonly GridRange[] | undefined | null, band: StructuralBand, deletedBlock?: GridRange) => GridRange | undefined;
+/** Ranges (merges / tables) that travel with the band: wholly inside it and, for a delete, not
+ * inside the deleted block. */
+export declare const isRangeInsideBand: (range: GridRange, band: StructuralBand) => boolean;
+export declare const isRangeInsideBlock: (outer: GridRange, inner: GridRange) => boolean;
+/**
+ * The Excel refusal (if any) for an insert/delete-cells shift of `range`. Checks run in Excel's
+ * order: array tear, merge tear, table tear, off-sheet push. `undefined` means the edit may proceed.
+ */
+export declare const getShiftCellsRefusal: <T extends CellData>({ direction, range, sheetId, rows, rowCount, columnCount, merges, tables, arrayRanges, }: {
+    direction: ShiftDirection;
+    range: GridRange;
+    sheetId: number;
+    rows: SheetData<T>[number] | undefined;
+    /** Last valid row index for a vertical shift (the grid does not grow on a cell shift). */
+    rowCount?: number;
+    /** Last valid column index for a horizontal shift. */
+    columnCount?: number;
+    merges?: readonly GridRange[] | null;
+    tables?: readonly TableView[] | null;
+    arrayRanges?: readonly GridRange[] | null;
+}) => StructuralRefusal | undefined;
+/**
+ * INS-06 / INS-09 — the refusal for a whole-row (`axis: "row"`) or whole-column insert of `count`
+ * lines before `referenceIndex`, given the hard grid cap (`maxRowCount` / `maxColumnCount`). Blank
+ * trailing lines may fall off the end; a non-blank one refuses the insert.
+ */
+export declare const getInsertLinesRefusal: <T extends CellData>({ axis, referenceIndex, count, rows, limit, }: {
+    axis: "row" | "column";
+    referenceIndex: number;
+    count: number;
+    rows: SheetData<T>[number] | undefined;
+    limit: number | undefined;
+}) => StructuralRefusal | undefined;
+//# sourceMappingURL=structural-guards.d.ts.map

package/dist/cjs/api/structural-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structural-guards.d.ts","sourceRoot":"","sources":["../../../api/structural-guards.ts"],"names":[],"mappings":"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"}

package/dist/cjs/api/structural-guards.js

@@ -0,0 +1,202 @@
+import { __read } from "tslib";
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { structuralRefusal, } from "../constants";
+/** The selection a cell shift operates on — the LAST selection, or the active cell as a 1×1. The
+ * hooks' guards and the interface functions must agree on it, so both resolve it here. */
+export var resolveShiftSelection = function (activeCell, selections) {
+    var finalSelections = selections.length
+        ? selections
+        : selectionFromActiveCell(activeCell);
+    return finalSelections[finalSelections.length - 1];
+};
+var rangesIntersect = function (a, b) {
+    return a.startRowIndex <= b.endRowIndex &&
+        a.endRowIndex >= b.startRowIndex &&
+        a.startColumnIndex <= b.endColumnIndex &&
+        a.endColumnIndex >= b.startColumnIndex;
+};
+var rangeContains = function (outer, inner) {
+    return inner.startRowIndex >= outer.startRowIndex &&
+        inner.endRowIndex <= outer.endRowIndex &&
+        inner.startColumnIndex >= outer.startColumnIndex &&
+        inner.endColumnIndex <= outer.endColumnIndex;
+};
+/** The cells a shift relocates: the selection's rows/columns from its leading edge to the sheet edge. */
+export var shiftBand = function (direction, range) {
+    switch (direction) {
+        case "down":
+        case "up":
+            return {
+                startRowIndex: range.startRowIndex,
+                endRowIndex: Number.POSITIVE_INFINITY,
+                startColumnIndex: range.startColumnIndex,
+                endColumnIndex: range.endColumnIndex,
+            };
+        case "right":
+        case "left":
+            return {
+                startRowIndex: range.startRowIndex,
+                endRowIndex: range.endRowIndex,
+                startColumnIndex: range.startColumnIndex,
+                endColumnIndex: Number.POSITIVE_INFINITY,
+            };
+    }
+};
+/**
+ * A cell counts as non-blank when it carries a value, a formula, a format, a note, a link or a
+ * citation — Excel's "might appear empty but have blank values, some formatting, or a formula".
+ * Derived render results (CF / DV results) don't count.
+ */
+var DERIVED_CELL_KEYS = new Set([
+    "conditionalFormattingResultById",
+    "dataValidationResult",
+]);
+export var isNonBlankCell = function (cell) {
+    if (!cell)
+        return false;
+    return Object.entries(cell).some(function (_a) {
+        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+        return !DERIVED_CELL_KEYS.has(key) && value !== undefined && value !== null;
+    });
+};
+/**
+ * INS-06 / INS-09 / SHF-10 — the first non-blank cell that a shift of `count` rows (axis `row`) or
+ * columns (axis `column`) would push past `limit` (the last valid row/column index). Only cells
+ * inside `band` move. `undefined` when the edit is safe.
+ */
+export var findOffSheetPush = function (_a) {
+    var _b, _c;
+    var rows = _a.rows, axis = _a.axis, count = _a.count, limit = _a.limit, band = _a.band;
+    if (!rows || limit === undefined || count <= 0)
+        return undefined;
+    var firstPushed = limit - count + 1;
+    if (axis === "row") {
+        var startRow_1 = Math.max(band.startRowIndex, firstPushed, 1);
+        for (var rowIndex = startRow_1; rowIndex < rows.length; rowIndex++) {
+            var values = (_b = rows[rowIndex]) === null || _b === void 0 ? void 0 : _b.values;
+            if (!values)
+                continue;
+            var startCol = Math.max(band.startColumnIndex, 1);
+            var endCol = Math.min(band.endColumnIndex, values.length - 1);
+            for (var columnIndex = startCol; columnIndex <= endCol; columnIndex++) {
+                if (isNonBlankCell(values[columnIndex])) {
+                    return { rowIndex: rowIndex, columnIndex: columnIndex };
+                }
+            }
+        }
+        return undefined;
+    }
+    var startRow = Math.max(band.startRowIndex, 1);
+    var endRow = Math.min(band.endRowIndex, rows.length - 1);
+    for (var rowIndex = startRow; rowIndex <= endRow; rowIndex++) {
+        var values = (_c = rows[rowIndex]) === null || _c === void 0 ? void 0 : _c.values;
+        if (!values)
+            continue;
+        var startCol = Math.max(band.startColumnIndex, firstPushed, 1);
+        for (var columnIndex = startCol; columnIndex < values.length; columnIndex++) {
+            if (isNonBlankCell(values[columnIndex])) {
+                return { rowIndex: rowIndex, columnIndex: columnIndex };
+            }
+        }
+    }
+    return undefined;
+};
+/**
+ * A range the band reaches but does not contain whole is TORN by the shift. For a delete, a range
+ * that touches the deleted block must lie wholly inside it (it is removed with the block) — one
+ * straddling the block's edge is torn too.
+ */
+export var findTornRange = function (ranges, band, deletedBlock) {
+    if (!ranges)
+        return undefined;
+    return ranges.find(function (range) {
+        if (rangesIntersect(range, band) && !rangeContains(band, range)) {
+            return true;
+        }
+        if (deletedBlock &&
+            rangesIntersect(range, deletedBlock) &&
+            !rangeContains(deletedBlock, range)) {
+            return true;
+        }
+        return false;
+    });
+};
+/** SHF-05 / MRG-07 — a merge the band covers only partially. */
+export var findTornMerge = function (merges, band, deletedBlock) { return findTornRange(merges, band, deletedBlock); };
+/** TBL-05 — a table the band covers only partially (a table wholly inside the band moves intact). */
+export var findTornTable = function (tables, sheetId, band, deletedBlock) {
+    if (!tables)
+        return undefined;
+    return tables.find(function (table) {
+        return table.sheetId === sheetId &&
+            !!findTornRange([table.range], band, deletedBlock);
+    });
+};
+/** ANC-14 — a CSE / dynamic-array range the band covers only partially. */
+export var findTornArray = function (arrayRanges, band, deletedBlock) { return findTornRange(arrayRanges, band, deletedBlock); };
+/** Ranges (merges / tables) that travel with the band: wholly inside it and, for a delete, not
+ * inside the deleted block. */
+export var isRangeInsideBand = function (range, band) {
+    return rangeContains(band, range);
+};
+export var isRangeInsideBlock = rangeContains;
+/**
+ * The Excel refusal (if any) for an insert/delete-cells shift of `range`. Checks run in Excel's
+ * order: array tear, merge tear, table tear, off-sheet push. `undefined` means the edit may proceed.
+ */
+export var getShiftCellsRefusal = function (_a) {
+    var direction = _a.direction, range = _a.range, sheetId = _a.sheetId, rows = _a.rows, rowCount = _a.rowCount, columnCount = _a.columnCount, merges = _a.merges, tables = _a.tables, arrayRanges = _a.arrayRanges;
+    var band = shiftBand(direction, range);
+    var isDelete = direction === "up" || direction === "left";
+    var deletedBlock = isDelete ? range : undefined;
+    if (findTornArray(arrayRanges, band, deletedBlock)) {
+        return structuralRefusal("torn-array");
+    }
+    if (findTornMerge(merges, band, deletedBlock)) {
+        return structuralRefusal("torn-merge");
+    }
+    if (findTornTable(tables, sheetId, band, deletedBlock)) {
+        return structuralRefusal("torn-table");
+    }
+    if (!isDelete) {
+        var vertical = direction === "down";
+        var count = vertical
+            ? range.endRowIndex - range.startRowIndex + 1
+            : range.endColumnIndex - range.startColumnIndex + 1;
+        var pushed = findOffSheetPush({
+            rows: rows,
+            axis: vertical ? "row" : "column",
+            count: count,
+            limit: vertical ? rowCount : columnCount,
+            band: band,
+        });
+        if (pushed) {
+            return structuralRefusal("off-sheet-push");
+        }
+    }
+    return undefined;
+};
+/**
+ * INS-06 / INS-09 — the refusal for a whole-row (`axis: "row"`) or whole-column insert of `count`
+ * lines before `referenceIndex`, given the hard grid cap (`maxRowCount` / `maxColumnCount`). Blank
+ * trailing lines may fall off the end; a non-blank one refuses the insert.
+ */
+export var getInsertLinesRefusal = function (_a) {
+    var axis = _a.axis, referenceIndex = _a.referenceIndex, count = _a.count, rows = _a.rows, limit = _a.limit;
+    var band = axis === "row"
+        ? {
+            startRowIndex: referenceIndex,
+            endRowIndex: Number.POSITIVE_INFINITY,
+            startColumnIndex: 1,
+            endColumnIndex: Number.POSITIVE_INFINITY,
+        }
+        : {
+            startRowIndex: 1,
+            endRowIndex: Number.POSITIVE_INFINITY,
+            startColumnIndex: referenceIndex,
+            endColumnIndex: Number.POSITIVE_INFINITY,
+        };
+    return findOffSheetPush({ rows: rows, axis: axis, count: count, limit: limit, band: band })
+        ? structuralRefusal("off-sheet-push")
+        : undefined;
+};