@rowsncolumns/spreadsheet-state 28.0.76 → 29.1.0

package/dist/cjs/api/anchored-objects.js

@@ -89,11 +89,26 @@ var isSheetRangeLike = function (value) {
  * (`sources`), nulled on properties (`dataRange`) — the chart's `#REF!`.
  * Unknown keys are left untouched. Mutates in place; returns whether anything
  * changed.
+ *
+ * `band` restricts the rewrite to ranges whose PERPENDICULAR span lies wholly
+ * inside it — the insert/delete-CELLS shift of columns `B:C` only touches
+ * ranges living entirely in B..C, exactly like `expandRangesInFormula` /
+ * `contractRangesInFormula` with the same `bandSpan` (SHF-07 / SHF-08), so a
+ * chart and a formula reading the same cells always agree. A range that only
+ * partially overlaps the band keeps its address, as in Excel.
  */
-export var shiftChartSpecRanges = function (spec, sheetId, axis, op, index, count) {
+export var shiftChartSpecRanges = function (spec, sheetId, axis, op, index, count, band) {
     var changed = false;
+    var _a = __read(axis === "row"
+        ? ["startColumnIndex", "endColumnIndex"]
+        : ["startRowIndex", "endRowIndex"], 2), acrossStartKey = _a[0], acrossEndKey = _a[1];
+    var isWithinBand = function (range) {
+        return !band ||
+            (range[acrossStartKey] >= band.startIndex &&
+                range[acrossEndKey] <= band.endIndex);
+    };
     var shiftRange = function (range) {
-        if (range.sheetId !== sheetId)
+        if (range.sheetId !== sheetId || !isWithinBand(range))
             return range;
         var next = shiftGridRangeLikeReference(range, axis, op, index, count);
         if (next !== range)
@@ -146,59 +161,132 @@ export var shiftChartSpecRanges = function (spec, sheetId, axis, op, index, coun
     walk(spec);
     return changed;
 };
-/** Shift the anchor cell of every embed (picture, shape, text box…) on the edited sheet. */
+/**
+ * Record (or clear) the second anchor a move / resize gesture reported —
+ * `moveAndSize` objects carry one, `moveOnly` / `absolute` never do.
+ */
+export var setOverlayToAnchor = function (overlay, toAnchor) {
+    if (toAnchor) {
+        overlay.toCell = toAnchor.toCell;
+        overlay.toOffsetXPixels = toAnchor.toOffsetXPixels;
+        overlay.toOffsetYPixels = toAnchor.toOffsetYPixels;
+        return;
+    }
+    delete overlay.toCell;
+    delete overlay.toOffsetXPixels;
+    delete overlay.toOffsetYPixels;
+};
+/**
+ * Shift a floating object's anchors for a whole row / column insert or
+ * delete, per its placement mode. Returns `"removed"` when a delete consumed
+ * the whole span of a `moveAndSize` object (Excel deletes it), otherwise
+ * whether anything moved.
+ */
+export var shiftOverlayOnStructuralChange = function (overlay, axis, op, index, count) {
+    var _a;
+    if (!overlay.anchorCell || overlay.placement === "absolute")
+        return false;
+    var moveAndSize = ((_a = overlay.placement) !== null && _a !== void 0 ? _a : "moveAndSize") === "moveAndSize";
+    var toCell = moveAndSize ? overlay.toCell : undefined;
+    if (toCell && op === "delete" && count > 0) {
+        var key = axis === "row" ? "rowIndex" : "columnIndex";
+        var start = overlay.anchorCell[key];
+        // `to` sits on the cell the corner lands in; a corner flush with the
+        // cell's leading edge does not occupy it.
+        var offset = axis === "row" ? overlay.toOffsetYPixels : overlay.toOffsetXPixels;
+        var end = (offset !== null && offset !== void 0 ? offset : 0) > 0 ? toCell[key] : Math.max(start, toCell[key] - 1);
+        if (index <= start && index + count - 1 >= end)
+            return "removed";
+    }
+    var changed = false;
+    var next = shiftAnchorCell(overlay.anchorCell, axis, op, index, count);
+    if (next !== overlay.anchorCell) {
+        overlay.anchorCell = next;
+        changed = true;
+    }
+    if (toCell) {
+        var nextTo = shiftAnchorCell(toCell, axis, op, index, count);
+        if (nextTo !== toCell) {
+            overlay.toCell = nextTo;
+            changed = true;
+        }
+    }
+    return changed;
+};
+/** Shift the anchors of every embed (picture, shape, text box…) on the edited sheet. */
 export var shiftEmbedsOnStructuralChange = function (draft, sheetId, axis, op, index, count) {
-    var e_2, _a;
-    try {
-        for (var draft_1 = __values(draft), draft_1_1 = draft_1.next(); !draft_1_1.done; draft_1_1 = draft_1.next()) {
-            var embed = draft_1_1.value;
-            var position = embed.position;
-            if (!position || position.sheetId !== sheetId)
-                continue;
-            var overlay = position.overlayPosition;
-            if (!(overlay === null || overlay === void 0 ? void 0 : overlay.anchorCell))
-                continue;
-            var next = shiftAnchorCell(overlay.anchorCell, axis, op, index, count);
-            if (next !== overlay.anchorCell)
-                overlay.anchorCell = next;
+    for (var i = draft.length - 1; i >= 0; i--) {
+        var position = draft[i].position;
+        if (!position || position.sheetId !== sheetId)
+            continue;
+        var overlay = position.overlayPosition;
+        if (!(overlay === null || overlay === void 0 ? void 0 : overlay.anchorCell))
+            continue;
+        if (shiftOverlayOnStructuralChange(overlay, axis, op, index, count) ===
+            "removed") {
+            draft.splice(i, 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);
+};
+/**
+ * Shift the anchors of every slicer on the edited sheet — a slicer is a
+ * floating frame with the same placement modes as a picture (#668 C-46).
+ */
+export var shiftSlicersOnStructuralChange = function (draft, sheetId, axis, op, index, count) {
+    for (var i = draft.length - 1; i >= 0; i--) {
+        var position = draft[i].position;
+        if (!position || position.sheetId !== sheetId)
+            continue;
+        var overlay = position.overlayPosition;
+        if (!(overlay === null || overlay === void 0 ? void 0 : overlay.anchorCell))
+            continue;
+        if (shiftOverlayOnStructuralChange(overlay, axis, op, index, count) ===
+            "removed") {
+            draft.splice(i, 1);
         }
-        finally { if (e_2) throw e_2.error; }
     }
 };
 /**
- * Shift every chart on the edited sheet: its anchor cell like a floating
+ * Shift every chart on the edited sheet: its anchors like a floating
  * object, and the ranges inside its spec like references.
  */
 export var shiftChartsOnStructuralChange = function (draft, sheetId, axis, op, index, count) {
-    var e_3, _a;
-    var _b;
+    var _a;
+    for (var i = draft.length - 1; i >= 0; i--) {
+        var chart = draft[i];
+        var position = chart.position;
+        if ((position === null || position === void 0 ? void 0 : position.sheetId) === sheetId &&
+            ((_a = position.overlayPosition) === null || _a === void 0 ? void 0 : _a.anchorCell) &&
+            shiftOverlayOnStructuralChange(position.overlayPosition, axis, op, index, count) === "removed") {
+            draft.splice(i, 1);
+            continue;
+        }
+        // Series ranges may point at ANY sheet, so the spec walk is not gated on
+        // the chart's own sheet.
+        shiftChartSpecRanges(chart.spec, sheetId, axis, op, index, count);
+    }
+};
+/**
+ * Insert/delete CELLS with shift (SHF-*): only the ranges a chart reads move —
+ * those wholly inside the shifted band's columns (shift down/up) or rows
+ * (shift right/left), with the reference rule along the shift axis. Excel
+ * moves drawing anchors only for whole row/column edits, so the chart frame
+ * stays where it is.
+ */
+export var shiftChartsOnCellShift = function (draft, sheetId, axis, op, index, count, band) {
+    var e_2, _a;
     try {
-        for (var draft_2 = __values(draft), draft_2_1 = draft_2.next(); !draft_2_1.done; draft_2_1 = draft_2.next()) {
-            var chart = draft_2_1.value;
-            var position = chart.position;
-            if ((position === null || position === void 0 ? void 0 : position.sheetId) === sheetId && ((_b = position.overlayPosition) === null || _b === void 0 ? void 0 : _b.anchorCell)) {
-                var overlay = position.overlayPosition;
-                var next = shiftAnchorCell(overlay.anchorCell, axis, op, index, count);
-                if (next !== overlay.anchorCell)
-                    overlay.anchorCell = next;
-            }
-            // Series ranges may point at ANY sheet, so the spec walk is not gated on
-            // the chart's own sheet.
-            shiftChartSpecRanges(chart.spec, sheetId, axis, op, index, count);
+        for (var draft_1 = __values(draft), draft_1_1 = draft_1.next(); !draft_1_1.done; draft_1_1 = draft_1.next()) {
+            var chart = draft_1_1.value;
+            shiftChartSpecRanges(chart.spec, sheetId, axis, op, index, count, band);
         }
     }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
     finally {
         try {
-            if (draft_2_1 && !draft_2_1.done && (_a = draft_2.return)) _a.call(draft_2);
+            if (draft_1_1 && !draft_1_1.done && (_a = draft_1.return)) _a.call(draft_1);
         }
-        finally { if (e_3) throw e_3.error; }
+        finally { if (e_2) throw e_2.error; }
     }
 };
 /**
@@ -206,7 +294,7 @@ export var shiftChartsOnStructuralChange = function (draft, sheetId, axis, op, i
  * (sheet-scoped protection) is untouched; one the delete consumes is removed.
  */
 export var shiftProtectedRangesOnStructuralChange = function (draft, sheetId, axis, op, index, count) {
-    var e_4, _a;
+    var e_3, _a;
     var _b = __read(axis === "row"
         ? ["startRowIndex", "endRowIndex"]
         : ["startColumnIndex", "endColumnIndex"], 2), startKey = _b[0], endKey = _b[1];
@@ -232,7 +320,7 @@ export var shiftProtectedRangesOnStructuralChange = function (draft, sheetId, ax
             var kept = [];
             var unprotectedChanged = false;
             try {
-                for (var _c = (e_4 = void 0, __values(protectedRange.unprotectedRanges)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                for (var _c = (e_3 = void 0, __values(protectedRange.unprotectedRanges)), _d = _c.next(); !_d.done; _d = _c.next()) {
                     var unprotected = _d.value;
                     if (unprotected.sheetId !== sheetId) {
                         kept.push(unprotected);
@@ -245,15 +333,348 @@ export var shiftProtectedRangesOnStructuralChange = function (draft, sheetId, ax
                         kept.push(next);
                 }
             }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
             finally {
                 try {
                     if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                 }
-                finally { if (e_4) throw e_4.error; }
+                finally { if (e_3) throw e_3.error; }
             }
             if (unprotectedChanged)
                 protectedRange.unprotectedRanges = kept;
         }
     }
 };
+/**
+ * Visit every `SheetRange` a chart spec holds — `dataRange`, per-series /
+ * per-domain `sources`, error-bar `plusRange` / `minusRange`, and any future
+ * range-valued key — replacing it with what `rewrite` returns. A range the
+ * rewrite returns `null` for is removed — spliced out of arrays (`sources`),
+ * nulled on properties (`dataRange`) — the chart's `#REF!`; a move never
+ * consumes a range, so its rewrites always return a range. Mutates in place;
+ * returns whether anything changed.
+ */
+var rewriteChartSpecRanges = function (spec, rewrite) {
+    var changed = false;
+    var walk = function (node) {
+        var e_4, _a;
+        if (!node || typeof node !== "object")
+            return;
+        if (Array.isArray(node)) {
+            for (var i = node.length - 1; i >= 0; i--) {
+                var item = node[i];
+                if (isSheetRangeLike(item)) {
+                    var next = rewrite(item);
+                    if (next === null) {
+                        node.splice(i, 1);
+                        changed = true;
+                    }
+                    else if (next !== item) {
+                        node[i] = next;
+                        changed = true;
+                    }
+                }
+                else {
+                    walk(item);
+                }
+            }
+            return;
+        }
+        var obj = node;
+        try {
+            for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                var value = obj[key];
+                if (isSheetRangeLike(value)) {
+                    var next = rewrite(value);
+                    if (next !== value) {
+                        obj[key] = next;
+                        changed = true;
+                    }
+                }
+                else {
+                    walk(value);
+                }
+            }
+        }
+        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_4) throw e_4.error; }
+        }
+    };
+    walk(spec);
+    return changed;
+};
+/**
+ * Deleting a sheet consumes every range on it: a chart elsewhere whose series
+ * / category / data range read the deleted sheet keeps the chart but loses
+ * that range (Excel's empty `#REF!` series).
+ */
+export var removeChartSpecRangesOnSheet = function (spec, sheetId) {
+    return rewriteChartSpecRanges(spec, function (range) {
+        return range.sheetId === sheetId ? null : range;
+    });
+};
+/**
+ * Re-point every range on `fromSheetId` at `toSheetId` — a duplicated sheet's
+ * charts read the copy's own cells (Excel), while ranges on other sheets keep
+ * reading the original.
+ */
+export var retargetChartSpecRanges = function (spec, fromSheetId, toSheetId) {
+    return rewriteChartSpecRanges(spec, function (range) {
+        return range.sheetId === fromSheetId ? __assign(__assign({}, range), { sheetId: toSheetId }) : range;
+    });
+};
+/**
+ * Relocate the ranges inside a chart spec when the block `from` on
+ * `fromSheetId` is moved (drag-move, cut → paste) to `to` on `toSheetId`, the
+ * way Excel re-points series like references: a range that lies ENTIRELY
+ * inside the moved block travels with it (shifted by the move delta and onto
+ * the destination sheet); a range the block covers only partially, and any
+ * range outside it, keeps referring to its original cells. Mirrors
+ * `move_spec_sheet_ranges` in `rnc-store`.
+ */
+export var moveChartSpecRanges = function (spec, fromSheetId, from, toSheetId, to) {
+    var rowDelta = to.startRowIndex - from.startRowIndex;
+    var columnDelta = to.startColumnIndex - from.startColumnIndex;
+    if (rowDelta === 0 && columnDelta === 0 && fromSheetId === toSheetId) {
+        return false;
+    }
+    return rewriteChartSpecRanges(spec, function (range) {
+        if (range.sheetId !== fromSheetId ||
+            range.startRowIndex < from.startRowIndex ||
+            range.endRowIndex > from.endRowIndex ||
+            range.startColumnIndex < from.startColumnIndex ||
+            range.endColumnIndex > from.endColumnIndex) {
+            return range;
+        }
+        return __assign(__assign({}, range), { sheetId: toSheetId, startRowIndex: range.startRowIndex + rowDelta, endRowIndex: range.endRowIndex + rowDelta, startColumnIndex: range.startColumnIndex + columnDelta, endColumnIndex: range.endColumnIndex + columnDelta });
+    });
+};
+/** Re-point the ranges of every chart when a cell block is moved (see `moveChartSpecRanges`). */
+export var moveChartsOnRangeMove = function (draft, fromSheetId, from, toSheetId, to) {
+    var e_5, _a;
+    try {
+        for (var draft_2 = __values(draft), draft_2_1 = draft_2.next(); !draft_2_1.done; draft_2_1 = draft_2.next()) {
+            var chart = draft_2_1.value;
+            moveChartSpecRanges(chart.spec, fromSheetId, from, toSheetId, to);
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (draft_2_1 && !draft_2_1.done && (_a = draft_2.return)) _a.call(draft_2);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+};
+/**
+ * Where line `index` (a row or column) ends up after the whole lines `lines`
+ * (sorted ascending) are moved so the block lands at `target` in the
+ * post-removal frame — the permutation a row/column move applies to every
+ * cell. A moved line lands at `target` + its rank in the block; a line outside
+ * closes the gap the block left and is pushed by the block landing at or
+ * before it. Mirrors `moved_line_index` in `rnc-store`.
+ */
+export var movedLineIndex = function (lines, target, index) {
+    var e_6, _a;
+    var rank = lines.indexOf(index);
+    if (rank !== -1)
+        return target + rank;
+    var removedBefore = 0;
+    try {
+        for (var lines_1 = __values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
+            var line = lines_1_1.value;
+            if (line < index)
+                removedBefore++;
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    var settled = index - removedBefore;
+    return settled < target ? settled : settled + lines.length;
+};
+/**
+ * Re-point the ranges inside a chart spec when whole rows / columns of
+ * `sheetId` are moved (`lines` land at `target`), with the rule the engines
+ * apply to formula references: both edges follow their line, and the range is
+ * rewritten only when that yields a range of the same size — so a range wholly
+ * inside the moved block relocates with it, one wholly inside the displaced
+ * band shifts by the block size, and one straddling the block and its
+ * neighbours keeps its text (it still covers the same cells). Mirrors
+ * `permute_spec_sheet_ranges` in `rnc-store` / `remap_formula_axis`.
+ */
+export var reorderChartSpecRanges = function (spec, sheetId, axis, lines, target) {
+    if (!lines.length)
+        return false;
+    var _a = __read(axis === "row"
+        ? ["startRowIndex", "endRowIndex"]
+        : ["startColumnIndex", "endColumnIndex"], 2), startKey = _a[0], endKey = _a[1];
+    return rewriteChartSpecRanges(spec, function (range) {
+        var _a;
+        if (range.sheetId !== sheetId)
+            return range;
+        var start = range[startKey];
+        var end = range[endKey];
+        var nextStart = movedLineIndex(lines, target, start);
+        var nextEnd = movedLineIndex(lines, target, end);
+        if (nextEnd < nextStart ||
+            nextEnd - nextStart !== end - start ||
+            (nextStart === start && nextEnd === end)) {
+            return range;
+        }
+        return __assign(__assign({}, range), (_a = {}, _a[startKey] = nextStart, _a[endKey] = nextEnd, _a));
+    });
+};
+/** Re-point the ranges of every chart when whole rows / columns are moved (see `reorderChartSpecRanges`). */
+export var reorderChartsOnLineMove = function (draft, sheetId, axis, lines, target) {
+    var e_7, _a;
+    try {
+        for (var draft_3 = __values(draft), draft_3_1 = draft_3.next(); !draft_3_1.done; draft_3_1 = draft_3.next()) {
+            var chart = draft_3_1.value;
+            reorderChartSpecRanges(chart.spec, sheetId, axis, lines, target);
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (draft_3_1 && !draft_3_1.done && (_a = draft_3.return)) _a.call(draft_3);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+};
+export var tableBinding = function (table) {
+    var range = table.range;
+    var bodyStartRowIndex = range.startRowIndex + (table.headerRow === false ? 0 : 1);
+    return {
+        range: range,
+        rowStarts: [range.startRowIndex, bodyStartRowIndex],
+        bodyEndRowIndex: range.endRowIndex - (table.totalRow ? 1 : 0),
+    };
+};
+/**
+ * A range bound to the table along `axis`: it covers the body rows (or header + body) of one or
+ * more table columns — for a column edit ALL of them, since a series is a column and only a range
+ * reading the whole table gains a column with it.
+ */
+var isTableBoundRange = function (range, binding, axis) {
+    return binding.rowStarts.includes(range.startRowIndex) &&
+        range.endRowIndex === binding.bodyEndRowIndex &&
+        range.startColumnIndex >= binding.range.startColumnIndex &&
+        range.endColumnIndex <= binding.range.endColumnIndex &&
+        (axis === "row" ||
+            (range.startColumnIndex === binding.range.startColumnIndex &&
+                range.endColumnIndex === binding.range.endColumnIndex));
+};
+/** The table's extent across `axis` — the band a table-local edit moves cells in. */
+var tableBand = function (binding, axis) {
+    return axis === "row"
+        ? {
+            startIndex: binding.range.startColumnIndex,
+            endIndex: binding.range.endColumnIndex,
+        }
+        : {
+            startIndex: binding.range.startRowIndex,
+            endIndex: binding.range.endRowIndex,
+        };
+};
+var growSpan = function (range, axis, delta) {
+    var _a;
+    var _b = __read(axis === "row"
+        ? ["startRowIndex", "endRowIndex"]
+        : ["startColumnIndex", "endColumnIndex"], 2), startKey = _b[0], endKey = _b[1];
+    var end = range[endKey] + delta;
+    return end < range[startKey] ? null : __assign(__assign({}, range), (_a = {}, _a[endKey] = end, _a));
+};
+/**
+ * Insert / delete table rows (or columns): the cells inside the table's columns (rows) at/after
+ * `index` move, so every chart range wholly inside that band follows the reference rule like
+ * insert/delete-cells — except a range bound to the table (`isTableBoundRange`), which grows /
+ * shrinks by `count` even when the rows are appended below the last body row (where the
+ * reference rule would leave it alone) or inserted above the first one (where it would shift):
+ * Excel keeps the series on the table column. A range that collapses is removed (`#REF!`).
+ * Mutates in place; returns whether anything changed. Mirrors
+ * `shift_spec_sheet_ranges_for_table_edit` in `rnc-store`.
+ */
+export var shiftChartSpecRangesOnTableEdit = function (spec, sheetId, binding, axis, op, index, count) {
+    var band = tableBand(binding, axis);
+    var _a = __read(axis === "row"
+        ? ["startColumnIndex", "endColumnIndex"]
+        : ["startRowIndex", "endRowIndex"], 2), acrossStartKey = _a[0], acrossEndKey = _a[1];
+    return rewriteChartSpecRanges(spec, function (range) {
+        if (range.sheetId !== sheetId ||
+            range[acrossStartKey] < band.startIndex ||
+            range[acrossEndKey] > band.endIndex) {
+            return range;
+        }
+        if (isTableBoundRange(range, binding, axis)) {
+            return growSpan(range, axis, op === "insert" ? count : -count);
+        }
+        return shiftGridRangeLikeReference(range, axis, op, index, count);
+    });
+};
+/**
+ * Table growth without a cell shift — the resize handle, typing below / to the right of the
+ * table: a range bound to the table (`isTableBoundRange`) grows / shrinks with its body by
+ * `rowDelta` rows, then by `columnDelta` columns against the row-grown table. Mutates in place;
+ * returns whether anything changed. Mirrors `grow_table_bound_spec_ranges` in `rnc-store`.
+ */
+export var growTableBoundChartSpecRanges = function (spec, sheetId, binding, rowDelta, columnDelta) {
+    if (rowDelta === 0 && columnDelta === 0)
+        return false;
+    var rowGrown = __assign(__assign({}, binding), { range: __assign(__assign({}, binding.range), { endRowIndex: binding.range.endRowIndex + rowDelta }), bodyEndRowIndex: binding.bodyEndRowIndex + rowDelta });
+    return rewriteChartSpecRanges(spec, function (range) {
+        if (range.sheetId !== sheetId)
+            return range;
+        var next = range;
+        if (rowDelta !== 0 && isTableBoundRange(next, binding, "row")) {
+            next = growSpan(next, "row", rowDelta);
+        }
+        if (next && columnDelta !== 0 && isTableBoundRange(next, rowGrown, "column")) {
+            next = growSpan(next, "column", columnDelta);
+        }
+        return next;
+    });
+};
+/** Every chart's ranges follow a table-local row / column insert or delete (see `shiftChartSpecRangesOnTableEdit`). */
+export var shiftChartsOnTableEdit = function (draft, sheetId, binding, axis, op, index, count) {
+    var e_8, _a;
+    try {
+        for (var draft_4 = __values(draft), draft_4_1 = draft_4.next(); !draft_4_1.done; draft_4_1 = draft_4.next()) {
+            var chart = draft_4_1.value;
+            shiftChartSpecRangesOnTableEdit(chart.spec, sheetId, binding, axis, op, index, count);
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (draft_4_1 && !draft_4_1.done && (_a = draft_4.return)) _a.call(draft_4);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+};
+/** Every chart's table-bound ranges grow / shrink with a resized or auto-expanded table (see `growTableBoundChartSpecRanges`). */
+export var growChartsWithTable = function (draft, sheetId, binding, rowDelta, columnDelta) {
+    var e_9, _a;
+    try {
+        for (var draft_5 = __values(draft), draft_5_1 = draft_5.next(); !draft_5_1.done; draft_5_1 = draft_5.next()) {
+            var chart = draft_5_1.value;
+            growTableBoundChartSpecRanges(chart.spec, sheetId, binding, rowDelta, columnDelta);
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (draft_5_1 && !draft_5_1.done && (_a = draft_5.return)) _a.call(draft_5);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+};

package/dist/cjs/api/copy-paste.d.ts

@@ -1,10 +1,16 @@
 import type { CellInterface, GridRange } from "@rowsncolumns/common-types";
 import type { CellData, EmbeddedObject, TableView } from "@rowsncolumns/spreadsheet";
-import type { GeneratedNames } from "../generated-names";
 import type { UseSpreadsheetProps } from "../hooks/use-spreadsheet-state";
 export type ClipBoardFormat = "text/html" | "text/csv" | "text/plain" | "application/json" | "image/apng" | "image/bmp" | "image/gif" | "image/jpeg" | "image/pjpeg" | "image/png" | "image/svg+xml" | "image/tiff" | "image/webp" | "image/x-icon";
 export declare const SUPPORTED_IMAGE_TYPES: string[];
-export declare const generateDataFromClipboard: <T extends CellData>(e: ClipboardEvent | undefined, activeCell: CellInterface, sheetId: number, activeSheetName: string, preserveFormatting?: boolean, locale?: string, idCreationStrategy?: UseSpreadsheetProps<T>["idCreationStrategy"], forcePlainText?: boolean, sanitizeHtml?: (html: string) => string, generatedNames?: GeneratedNames) => Promise<{
+export declare const generateDataFromClipboard: <T extends CellData>(e: ClipboardEvent | undefined, activeCell: CellInterface, sheetId: number, activeSheetName: string, preserveFormatting?: boolean, locale?: string, idCreationStrategy?: UseSpreadsheetProps<T>["idCreationStrategy"], forcePlainText?: boolean, sanitizeHtml?: (html: string) => string, options?: {
+    /**
+     * Re-anchor each copied formula's relative refs from its `sourceCell` to the paste
+     * destination (a COPY). `false` for a CUT: Excel keeps a moved formula's text verbatim and
+     * only repoints references INTO the moved block, which the consumer does itself.
+     */
+    relocateFormulas?: boolean;
+}) => Promise<{
     results?: (CellData | null | undefined)[][];
     merges?: GridRange[];
     embeds?: EmbeddedObject[];

package/dist/cjs/api/copy-paste.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"copy-paste.d.ts","sourceRoot":"","sources":["../../../api/copy-paste.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,aAAa,EACb,SAAS,EACV,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EACd,SAAS,EAEV,MAAM,2BAA2B,CAAC;AAanC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAW1E,MAAM,MAAM,eAAe,GACvB,WAAW,GACX,UAAU,GACV,YAAY,GACZ,kBAAkB,GAClB,YAAY,GACZ,WAAW,GACX,WAAW,GACX,YAAY,GACZ,aAAa,GACb,WAAW,GACX,eAAe,GACf,YAAY,GACZ,YAAY,GACZ,cAAc,CAAC;AAEnB,eAAO,MAAM,qBAAqB,UAWjC,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAU,CAAC,SAAS,QAAQ,EAChE,GAAG,cAAc,GAAG,SAAS,EAC7B,YAAY,aAAa,EACzB,SAAS,MAAM,EACf,iBAAiB,MAAM,EACvB,qBAAqB,OAAO,EAC5B,SAAS,MAAM,EACf,qBAAqB,mBAAmB,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,EACjE,iBAAiB,OAAO,EACxB,eAAe,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EACvC,iBAAiB,cAAc,KAC9B,OAAO,CACN;IACE,OAAO,CAAC,EAAE,CAAC,QAAQ,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EAAE,CAAC;IAC5C,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,MAAM,CAAC,EAAE,cAAc,EAAE,CAAC;IAC1B,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB,GACD,SAAS,CAqQZ,CAAC;AAEF,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,SAazC;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,EAC/C,MAAM,EAAE,CAAC,QAAQ,GAAG,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,yCAwB9C;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAC1C,MAAM,EAAE,CAAC,QAAQ,GAAG,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,EAC7C,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,yCAkChB;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,QAAQ,EAC5C,MAAM,EAAE,CAAC,QAAQ,GAAG,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,EAC7C,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,yCAwBhB;AAED,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7D,MAAM,CAAC,MAAM,GAAG,CAAC,GAAG,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,KACnD,MAAM,EAmBR,CAAC"}
+{"version":3,"file":"copy-paste.d.ts","sourceRoot":"","sources":["../../../api/copy-paste.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,aAAa,EACb,SAAS,EACV,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EACd,SAAS,EAEV,MAAM,2BAA2B,CAAC;AAcnC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAW1E,MAAM,MAAM,eAAe,GACvB,WAAW,GACX,UAAU,GACV,YAAY,GACZ,kBAAkB,GAClB,YAAY,GACZ,WAAW,GACX,WAAW,GACX,YAAY,GACZ,aAAa,GACb,WAAW,GACX,eAAe,GACf,YAAY,GACZ,YAAY,GACZ,cAAc,CAAC;AAEnB,eAAO,MAAM,qBAAqB,UAWjC,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAU,CAAC,SAAS,QAAQ,EAChE,GAAG,cAAc,GAAG,SAAS,EAC7B,YAAY,aAAa,EACzB,SAAS,MAAM,EACf,iBAAiB,MAAM,EACvB,qBAAqB,OAAO,EAC5B,SAAS,MAAM,EACf,qBAAqB,mBAAmB,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,EACjE,iBAAiB,OAAO,EACxB,eAAe,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EACvC,UAAU;IACR;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,KACA,OAAO,CACN;IACE,OAAO,CAAC,EAAE,CAAC,QAAQ,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EAAE,CAAC;IAC5C,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,MAAM,CAAC,EAAE,cAAc,EAAE,CAAC;IAC1B,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB,GACD,SAAS,CAqQZ,CAAC;AAEF,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,SAazC;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,EAC/C,MAAM,EAAE,CAAC,QAAQ,GAAG,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,yCAwB9C;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAC1C,MAAM,EAAE,CAAC,QAAQ,GAAG,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,EAC7C,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,yCAkChB;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,QAAQ,EAC5C,MAAM,EAAE,CAAC,QAAQ,GAAG,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,EAC7C,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,yCAwBhB;AAED,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7D,MAAM,CAAC,MAAM,GAAG,CAAC,GAAG,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,KACnD,MAAM,EAmBR,CAAC"}

package/dist/cjs/api/copy-paste.js

@@ -2,7 +2,6 @@ import { __assign, __awaiter, __generator, __read, __rest, __spreadArray, __valu
 import { createCellDataArrayFromCSVString, readImageFileAsDataUri, } from "@rowsncolumns/toolkit";
 import { getCellEffectiveFormat, isAFormula, isNil, log, } from "@rowsncolumns/utils";
 import { uuid } from "@rowsncolumns/utils";
-import { getGeneratedTableCopyName } from "../generated-names";
 import { defaultCellCoords, defaultSheetId, isStyleReference, SheetCell, } from "../sheet-cell";
 import { isRichSharedString } from "../types";
 import { isBoolean, isValidURLorEmail } from "./datatype";
@@ -19,7 +18,7 @@ export var SUPPORTED_IMAGE_TYPES = [
     "image/webp",
     "image/x-icon",
 ];
-export var generateDataFromClipboard = function (e, activeCell, sheetId, activeSheetName, preserveFormatting, locale, idCreationStrategy, forcePlainText, sanitizeHtml, generatedNames) { return __awaiter(void 0, void 0, void 0, function () {
+export var generateDataFromClipboard = function (e, activeCell, sheetId, activeSheetName, preserveFormatting, locale, idCreationStrategy, forcePlainText, sanitizeHtml, options) { return __awaiter(void 0, void 0, void 0, function () {
     var items, files, formatOrder, plainTextValue, isFormula, format, rows, filesArray, filesArray_1, filesArray_1_1, file, _a, imageUrl, e_1_1, clipboardValue, sheetCell, clipboard, isPlainTextOnly, _b, parsed, sheetData, tables, cellXfs, parsedSharedStrings, sharedStrings_1, tables_1, tables_1_1, table, rowDelta, colDelta, rowSpan, colSpan, merges_1, cellXfsMap_1, results, itemsArray, itemsArray_1, itemsArray_1_1, item, e_2_1, results, results;
     var e_1, _c, e_3, _d, e_2, _e;
     var _f, _g, _h, _j, _k, _l, _m;
@@ -118,7 +117,6 @@ export var generateDataFromClipboard = function (e, activeCell, sheetId, activeS
                                     rowSpan = table.range.endRowIndex - table.range.startRowIndex;
                                     colSpan = table.range.endColumnIndex - table.range.startColumnIndex;
                                     table.id = (_m = idCreationStrategy === null || idCreationStrategy === void 0 ? void 0 : idCreationStrategy("table")) !== null && _m !== void 0 ? _m : uuid();
-                                    table.title = getGeneratedTableCopyName(table.title, generatedNames);
                                     // Update sheet id
                                     table.sheetId = sheetId;
                                     table.range.startRowIndex = activeCell.rowIndex + rowDelta;
@@ -193,7 +191,9 @@ export var generateDataFromClipboard = function (e, activeCell, sheetId, activeS
                                 // Delete structured
                                 (_b = data === null || data === void 0 ? void 0 : data.ev) === null || _b === void 0 ? true : delete _b.structuredValue;
                                 // Move formulas if source cell is present
-                                if (((_c = data === null || data === void 0 ? void 0 : data.ue) === null || _c === void 0 ? void 0 : _c.fv) && sourceCell) {
+                                if (((_c = data === null || data === void 0 ? void 0 : data.ue) === null || _c === void 0 ? void 0 : _c.fv) &&
+                                    sourceCell &&
+                                    (options === null || options === void 0 ? void 0 : options.relocateFormulas) !== false) {
                                     var destinationCell = {
                                         rowIndex: activeCell.rowIndex + i,
                                         columnIndex: activeCell.columnIndex + j,

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

@@ -1,10 +1,24 @@
-import type { ColorFilterCriteria, ConditionType, ConditionValue, FilterSpec, IconFilterCriteria } from "@rowsncolumns/spreadsheet";
+import type { BooleanCondition, ColorFilterCriteria, ConditionType, ConditionValue, FilterConditionJoin, FilterCriteria, FilterSpec, IconFilterCriteria } from "@rowsncolumns/spreadsheet";
 export type CreateFilterSpecsExtras = {
     /** Pass `null` to clear an existing color filter on this column. */
     colorFilter?: ColorFilterCriteria | null;
     /** Pass `null` to clear an existing icon filter on this column. */
     iconFilter?: IconFilterCriteria | null;
+    /**
+     * Custom AutoFilter second clause + join (Excel's And / Or). Pass `null`
+     * to drop an existing second clause; omit to preserve it.
+     */
+    condition2?: BooleanCondition | null;
+    conditionJoin?: FilterConditionJoin | null;
 };
+/**
+ * Whether a column's criteria still filter anything. An entry with no
+ * condition, no value whitelist and no color / icon criterion is inert, so
+ * `createFilterSpecs` drops it — Excel's "Clear Filter From <column>" —
+ * instead of leaving a stale spec behind (the rnc engine's
+ * `upsert_filter_spec` removes such entries the same way).
+ */
+export declare const isFilterCriteriaActive: (criteria: FilterCriteria) => boolean;
 /**
  * Create a new filterspec
  * @param filterSpecs