@rowsncolumns/spreadsheet-state 28.0.76 → 29.1.0

package/dist/cjs/interface/delete-row.js

@@ -1,17 +1,38 @@
-import { __assign, __read, __spreadArray } from "tslib";
+import { __assign, __read, __spreadArray, __values } from "tslib";
 import { Direction } from "@rowsncolumns/common-types";
 import { produceWithPatches } from "immer";
-import { shiftChartsOnStructuralChange, shiftEmbedsOnStructuralChange, shiftProtectedRangesOnStructuralChange, } from "../api/anchored-objects";
+import { shiftChartsOnStructuralChange, shiftEmbedsOnStructuralChange, shiftSlicersOnStructuralChange, shiftProtectedRangesOnStructuralChange, } from "../api/anchored-objects";
 import { shrinkMergesOnRowDelete } from "../api/merges";
 import { updateNamedRangesOnStructuralChange, updatePrintSettingsOnStructuralChange, } from "../api/named-range-structural";
 import { shiftPivotsOnDelete } from "../api/pivot-range";
-import { updateSheetRangeOnDelete } from "../api/range";
 import { updateRangedRulesOnStructuralChange } from "../api/range-rule-helpers";
 import { moveFilterView } from "../api/selection";
 import { updateFormulasForStructuralChange } from "../api/structural-formula-update";
-import { breakStructuredRefsForRemovedTableParts, collectRemovedTableParts, removeSpillsOfDeletedAnchors, } from "../api/structural-table-refs";
+import { breakStructuredRefsForRemovedTableParts, collectRemovedTableParts, removeSpillsOfDeletedAnchors, renameTableColumnsInFormulas, } from "../api/structural-table-refs";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+import { getTableHeaderNames } from "./table-utils";
+/**
+ * How deleting the sorted `rowIndexes` lands on `table`: the rows deleted
+ * above it (the table moves up by that many), the rows deleted inside it (the
+ * table shrinks by that many), and whether every row of it goes (the table is
+ * removed). Excel never leaves a table without a data row, so a shrink stops
+ * at header + one body row (+ totals row).
+ */
+var rowDeleteEffectOnTable = function (table, rowIndexes) {
+    var _a = table.range, startRowIndex = _a.startRowIndex, endRowIndex = _a.endRowIndex;
+    var above = rowIndexes.filter(function (rowIndex) { return rowIndex < startRowIndex; }).length;
+    var inside = rowIndexes.filter(function (rowIndex) { return rowIndex >= startRowIndex && rowIndex <= endRowIndex; }).length;
+    var removed = inside === endRowIndex - startRowIndex + 1;
+    var nextStartRowIndex = startRowIndex - above;
+    var nextRange = __assign(__assign({}, table.range), { startRowIndex: nextStartRowIndex, endRowIndex: Math.max(endRowIndex - above - inside, nextStartRowIndex +
+            (table.headerRow !== false ? 1 : 0) +
+            (table.totalRow ? 1 : 0)) });
+    return { above: above, inside: inside, removed: removed, nextRange: nextRange };
+};
 export var deleteRow = function (_a) {
-    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getSheetName = _a.getSheetName, getActiveCell = _a.getActiveCell, getSelections = _a.getSelections, getDependents = _a.getDependents, getGraphNodes = _a.getGraphNodes, getGraphNodesInSheet = _a.getGraphNodesInSheet, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeActiveCell = _a.onChangeActiveCell, onChangeSelections = _a.onChangeSelections, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeDataValidations = _a.onChangeDataValidations, onChangeCitations = _a.onChangeCitations, onChangePivotTables = _a.onChangePivotTables, tables = _a.tables, getArrayRange = _a.getArrayRange, onChangeNamedRanges = _a.onChangeNamedRanges, onChangeEmbeds = _a.onChangeEmbeds, onChangeCharts = _a.onChangeCharts, onChangeProtectedRanges = _a.onChangeProtectedRanges;
+    var rowCount = _a.rowCount, columnCount = _a.columnCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getSheetName = _a.getSheetName, getActiveCell = _a.getActiveCell, getSelections = _a.getSelections, getDependents = _a.getDependents, getGraphNodes = _a.getGraphNodes, getGraphNodesInSheet = _a.getGraphNodesInSheet, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, onChangeActiveCell = _a.onChangeActiveCell, onChangeSelections = _a.onChangeSelections, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeDataValidations = _a.onChangeDataValidations, onChangeCitations = _a.onChangeCitations, onChangePivotTables = _a.onChangePivotTables, tables = _a.tables, getArrayRange = _a.getArrayRange, onChangeNamedRanges = _a.onChangeNamedRanges, onChangeEmbeds = _a.onChangeEmbeds, onChangeSlicers = _a.onChangeSlicers, onChangeCharts = _a.onChangeCharts, onChangeProtectedRanges = _a.onChangeProtectedRanges;
     return function (sheetId, rowIndexes) {
         if (!rowIndexes.length)
             return;
@@ -30,55 +51,86 @@ export var deleteRow = function (_a) {
             columnCount: columnCount,
         });
         var recalcCells = new Map();
+        // Tables whose body the delete empties while their totals row survives:
+        // the totals row closes up under the header and must swap with the row
+        // that becomes the single body row so it stays the table's last row.
+        var emptiedTotalsTables = (tables !== null && tables !== void 0 ? tables : []).filter(function (table) {
+            if (table.sheetId !== sheetId || !table.totalRow)
+                return false;
+            var bodyStartRowIndex = table.range.startRowIndex + (table.headerRow !== false ? 1 : 0);
+            var bodyEndRowIndex = table.range.endRowIndex - 1;
+            return (minRowIndex >= bodyStartRowIndex &&
+                minRowIndex <= bodyEndRowIndex &&
+                maxRowIndex >= bodyEndRowIndex &&
+                sortedRowIndexes.filter(function (rowIndex) {
+                    return rowIndex >= bodyStartRowIndex && rowIndex <= bodyEndRowIndex;
+                }).length >
+                    bodyEndRowIndex - bodyStartRowIndex);
+        });
         var activeCell = getActiveCell();
         var selections = getSelections();
         var newRowCount = Math.max(1, rowCount - count);
-        // NOTE: this treats `[minRowIndex..maxRowIndex]` as a contiguous block.
-        // Non-contiguous deletes (e.g. rows [2, 5, 10]) currently misclassify
-        // intermediate rows as deleted. Document/track separately.
-        var inDeletedRows = activeCell.rowIndex >= minRowIndex && activeCell.rowIndex <= maxRowIndex;
-        var nextActiveRowIndex = activeCell.rowIndex;
-        if (inDeletedRows) {
-            nextActiveRowIndex = Math.max(1, minRowIndex - 1);
-        }
-        else if (activeCell.rowIndex > maxRowIndex) {
-            nextActiveRowIndex = Math.max(1, activeCell.rowIndex - count);
-        }
-        if (nextActiveRowIndex > newRowCount) {
-            nextActiveRowIndex = newRowCount;
-        }
+        // Excel keeps the selection where it was (UI-02): after deleting rows 3:4
+        // the selection still reads 3:4 — now over the rows that moved up — and
+        // the active cell sits in the first deleted row. Every coordinate simply
+        // loses the deleted rows that lie BEFORE it, so an area entirely inside
+        // the deleted band keeps its place while areas below slide up; partially
+        // overlapping areas shrink like any other range.
+        var deletedBefore = function (rowIndex) {
+            return sortedRowIndexes.filter(function (index) { return index < rowIndex; }).length;
+        };
+        var clampRow = function (rowIndex) {
+            return Math.min(Math.max(1, rowIndex), newRowCount);
+        };
+        var nextActiveRowIndex = clampRow(activeCell.rowIndex - deletedBefore(activeCell.rowIndex));
         var nextActiveCell = nextActiveRowIndex === activeCell.rowIndex
             ? activeCell
             : __assign(__assign({}, activeCell), { rowIndex: nextActiveRowIndex });
-        var fallbackSelectionRowIndex = nextActiveCell.rowIndex;
         var nextSelections = selections.map(function (selection) {
             if (!selection.range)
                 return selection;
-            var updatedRange = updateSheetRangeOnDelete(__assign(__assign({}, selection.range), { sheetId: sheetId }), "row", minRowIndex, count, sheetId);
-            if (updatedRange) {
-                return __assign(__assign({}, selection), { range: __assign(__assign({}, selection.range), { startRowIndex: updatedRange.startRowIndex, endRowIndex: updatedRange.endRowIndex }) });
-            }
-            return __assign(__assign({}, selection), { range: __assign(__assign({}, selection.range), { startRowIndex: fallbackSelectionRowIndex, endRowIndex: fallbackSelectionRowIndex }) });
+            var _a = selection.range, startRowIndex = _a.startRowIndex, endRowIndex = _a.endRowIndex;
+            var deletedWithin = sortedRowIndexes.filter(function (index) { return index >= startRowIndex && index <= endRowIndex; }).length;
+            var size = endRowIndex - startRowIndex + 1;
+            var nextStart = clampRow(startRowIndex - deletedBefore(startRowIndex));
+            // A partially covered area shrinks by the rows it lost; an area deleted
+            // outright keeps its size (it now frames the rows that moved up).
+            var nextSize = deletedWithin < size ? size - deletedWithin : size;
+            return __assign(__assign({}, selection), { range: __assign(__assign({}, selection.range), { startRowIndex: nextStart, endRowIndex: clampRow(nextStart + nextSize - 1) }) });
+        });
+        // Tables whose header row goes while data rows survive keep going (Excel):
+        // the first surviving row becomes the header, so its cells become the
+        // column names once the rows have closed up (see the sheet-data pass).
+        var headerRederivedTables = (tables !== null && tables !== void 0 ? tables : []).flatMap(function (table) {
+            if (table.sheetId !== sheetId || table.headerRow === false)
+                return [];
+            var _a = rowDeleteEffectOnTable(table, sortedRowIndexes), removed = _a.removed, nextRange = _a.nextRange;
+            return !removed && sortedRowIndexes.includes(table.range.startRowIndex)
+                ? [{ table: table, nextRange: nextRange }]
+                : [];
         });
-        // Tables: shrink/move based on overlap with deletion; drop tables
-        // whose header row is removed.
+        // Re-derived column names by table id, filled in by the sheet-data pass.
+        var rederivedColumnNames = new Map();
+        // Tables: move up by the rows deleted above, shrink by the rows deleted
+        // inside; a table every row of which is deleted goes.
         onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
             var _a = __read(produceWithPatches(prevTables, function (draft) {
                 for (var idx = draft.length - 1; idx >= 0; idx--) {
                     var table = draft[idx];
                     if (table.sheetId !== sheetId)
                         continue;
-                    var _a = table.range, startRowIndex = _a.startRowIndex, endRowIndex = _a.endRowIndex;
-                    if (minRowIndex < startRowIndex) {
-                        moveFilterView(table, count, Direction.Up);
-                    }
-                    if (minRowIndex >= startRowIndex && minRowIndex <= endRowIndex) {
-                        var delta = Math.min(endRowIndex - minRowIndex + 1, count);
-                        table.range.endRowIndex -= delta;
-                    }
-                    if (startRowIndex >= minRowIndex && startRowIndex <= maxRowIndex) {
+                    var _a = rowDeleteEffectOnTable(table, sortedRowIndexes), above = _a.above, removed = _a.removed, nextRange = _a.nextRange;
+                    if (removed) {
                         draft.splice(idx, 1);
+                        continue;
+                    }
+                    if (above) {
+                        moveFilterView(table, above, Direction.Up);
                     }
+                    // Excel never leaves a table without a data row: a delete that
+                    // empties the body keeps one body row (the row that closed up
+                    // under the header).
+                    table.range.endRowIndex = nextRange.endRowIndex;
                 }
             }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
             saveHistory({ tables: { patches: patches, inversePatches: inversePatches } });
@@ -152,6 +204,13 @@ export var deleteRow = function (_a) {
             saveHistory({ embeds: { patches: patches, inversePatches: inversePatches } });
             return nextState;
         });
+        onChangeSlicers === null || onChangeSlicers === void 0 ? void 0 : onChangeSlicers(function (prevSlicers) {
+            var _a = __read(produceWithPatches(prevSlicers, function (draft) {
+                shiftSlicersOnStructuralChange(draft, sheetId, "row", "delete", minRowIndex, count);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ slicers: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
         onChangeCharts === null || onChangeCharts === void 0 ? void 0 : onChangeCharts(function (prevCharts) {
             var _a = __read(produceWithPatches(prevCharts, function (draft) {
                 shiftChartsOnStructuralChange(draft, sheetId, "row", "delete", minRowIndex, count);
@@ -207,13 +266,14 @@ export var deleteRow = function (_a) {
             saveHistory({ sheets: { patches: patches, inversePatches: inversePatches } });
             return nextState;
         });
-        // Tables whose header row goes (dropped above): their structured refs
+        // Tables every row of which goes (dropped above): their structured refs
         // break to `#REF!`, computed from the PRE-edit definitions.
         var removedTableParts = collectRemovedTableParts(tables, sheetId, "row", minRowIndex, maxRowIndex);
         // Sheet data: three-pass formula update, then splice the rows out.
         onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
             var _a = __read(produceWithPatches(prevSheetData, function (draft) {
-                var _a;
+                var e_1, _a, e_2, _b, e_3, _c;
+                var _d;
                 // A dynamic array whose anchor row is deleted takes its spill with
                 // it — drop the projected cells before the rows close up.
                 removeSpillsOfDeletedAnchors({
@@ -264,7 +324,121 @@ export var deleteRow = function (_a) {
                 });
                 // Splice from the end so indices don't shift mid-loop.
                 for (var i = sortedRowIndexes.length - 1; i >= 0; i--) {
-                    (_a = draft[sheetId]) === null || _a === void 0 ? void 0 : _a.splice(sortedRowIndexes[i], 1);
+                    (_d = draft[sheetId]) === null || _d === void 0 ? void 0 : _d.splice(sortedRowIndexes[i], 1);
+                }
+                try {
+                    for (var emptiedTotalsTables_1 = __values(emptiedTotalsTables), emptiedTotalsTables_1_1 = emptiedTotalsTables_1.next(); !emptiedTotalsTables_1_1.done; emptiedTotalsTables_1_1 = emptiedTotalsTables_1.next()) {
+                        var table = emptiedTotalsTables_1_1.value;
+                        var totalsRowIndex = table.range.startRowIndex +
+                            (table.headerRow !== false ? 1 : 0);
+                        var bodyRowIndex = totalsRowIndex + 1;
+                        var totalsRow = createSheetDraft(draft, sheetId, totalsRowIndex);
+                        var bodyRow = createSheetDraft(draft, sheetId, bodyRowIndex);
+                        for (var columnIndex = table.range.startColumnIndex; columnIndex <= table.range.endColumnIndex; columnIndex++) {
+                            var totalsCell = totalsRow[totalsRowIndex].values[columnIndex];
+                            totalsRow[totalsRowIndex].values[columnIndex] =
+                                bodyRow[bodyRowIndex].values[columnIndex];
+                            bodyRow[bodyRowIndex].values[columnIndex] = totalsCell;
+                            try {
+                                for (var _e = (e_2 = void 0, __values([totalsRowIndex, bodyRowIndex])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                    var rowIndex = _f.value;
+                                    enqueueCalculation === null || enqueueCalculation === void 0 ? void 0 : enqueueCalculation({
+                                        type: "dirty",
+                                        position: { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex },
+                                    });
+                                    recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), { sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex });
+                                }
+                            }
+                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                            finally {
+                                try {
+                                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                            }
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (emptiedTotalsTables_1_1 && !emptiedTotalsTables_1_1.done && (_a = emptiedTotalsTables_1.return)) _a.call(emptiedTotalsTables_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                // A table that lost its header row: the row that closed up under
+                // it is the header now (Excel) — its cells become the (text,
+                // unique) column names and structured references follow the
+                // renames, like typing over a header cell.
+                var sheetCell = new SheetCell();
+                var cellOptions = { locale: locale, cellXfsRegistry: cellXfsRegistry, sharedStringRegistry: sharedStringRegistry };
+                var _loop_1 = function (table, nextRange) {
+                    var headerRowIndex = nextRange.startRowIndex;
+                    var names = getTableHeaderNames({
+                        sheetId: sheetId,
+                        range: nextRange,
+                        getFormattedValue: function (sid, rowIndex, columnIndex) {
+                            var _a, _b, _c, _d;
+                            sheetCell.assign(sid, { rowIndex: rowIndex, columnIndex: columnIndex }, (_c = (_b = (_a = draft[sid]) === null || _a === void 0 ? void 0 : _a[rowIndex]) === null || _b === void 0 ? void 0 : _b.values) === null || _c === void 0 ? void 0 : _c[columnIndex], cellOptions);
+                            var value = (_d = sheetCell.getEffectiveValue()) !== null && _d !== void 0 ? _d : (sheetCell.isFormula()
+                                ? undefined
+                                : sheetCell.getUserEnteredValue());
+                            return value === undefined ? undefined : String(value);
+                        },
+                    });
+                    var headerRow = createSheetDraft(draft, sheetId, headerRowIndex);
+                    var renames = new Map();
+                    names.forEach(function (name, index) {
+                        var _a, _b;
+                        var columnIndex = nextRange.startColumnIndex + index;
+                        var position = { sheetId: sheetId, rowIndex: headerRowIndex, columnIndex: columnIndex };
+                        sheetCell.assign(sheetId, position, headerRow[headerRowIndex].values[columnIndex], cellOptions);
+                        if (sheetCell.isFormula()) {
+                            enqueueGraphOperation === null || enqueueGraphOperation === void 0 ? void 0 : enqueueGraphOperation({ type: "remove", position: position });
+                        }
+                        // A table header cell holds its column name as text.
+                        sheetCell.setUserEnteredValue(name, undefined, {
+                            disableTypeInference: true,
+                        });
+                        headerRow[headerRowIndex].values[columnIndex] =
+                            sheetCell.getCellData();
+                        enqueueCalculation === null || enqueueCalculation === void 0 ? void 0 : enqueueCalculation({ type: "dirty", position: position });
+                        recalcCells.set(createSheetCellIdentifier(sheetId, headerRowIndex, columnIndex), position);
+                        var oldName = (_b = (_a = table.columns) === null || _a === void 0 ? void 0 : _a[index]) === null || _b === void 0 ? void 0 : _b.name;
+                        if (oldName && oldName !== name) {
+                            renames.set(oldName.toLowerCase(), name);
+                        }
+                    });
+                    // One pass over the formulas for every renamed column, so the
+                    // re-derived names swapping (`Name`,`Qty` → `Qty`,`Name`) never chain.
+                    if (table.title && renames.size) {
+                        renameTableColumnsInFormulas({
+                            draft: draft,
+                            table: { title: table.title, sheetId: sheetId, range: nextRange },
+                            renames: renames,
+                            getGraphNodes: getGraphNodes,
+                            enqueueCalculation: enqueueCalculation,
+                            enqueueGraphOperation: enqueueGraphOperation,
+                            recalcCells: recalcCells,
+                            locale: locale,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                    }
+                    rederivedColumnNames.set(table.id, names);
+                };
+                try {
+                    for (var headerRederivedTables_1 = __values(headerRederivedTables), headerRederivedTables_1_1 = headerRederivedTables_1.next(); !headerRederivedTables_1_1.done; headerRederivedTables_1_1 = headerRederivedTables_1.next()) {
+                        var _g = headerRederivedTables_1_1.value, table = _g.table, nextRange = _g.nextRange;
+                        _loop_1(table, nextRange);
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (headerRederivedTables_1_1 && !headerRederivedTables_1_1.done && (_c = headerRederivedTables_1.return)) _c.call(headerRederivedTables_1);
+                    }
+                    finally { if (e_3) throw e_3.error; }
                 }
             }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
             saveHistory({
@@ -278,6 +452,37 @@ export var deleteRow = function (_a) {
             });
             return nextState;
         });
+        if (rederivedColumnNames.size) {
+            onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+                var _a = __read(produceWithPatches(prevTables, function (draft) {
+                    var e_4, _a;
+                    var _loop_2 = function (table) {
+                        var names = rederivedColumnNames.get(table.id);
+                        if (!names)
+                            return "continue";
+                        table.columns = names.map(function (name, index) {
+                            var _a, _b;
+                            return (__assign(__assign({}, ((_b = (_a = table.columns) === null || _a === void 0 ? void 0 : _a[index]) !== null && _b !== void 0 ? _b : {})), { name: name }));
+                        });
+                    };
+                    try {
+                        for (var draft_1 = __values(draft), draft_1_1 = draft_1.next(); !draft_1_1.done; draft_1_1 = draft_1.next()) {
+                            var table = draft_1_1.value;
+                            _loop_2(table);
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (draft_1_1 && !draft_1_1.done && (_a = draft_1.return)) _a.call(draft_1);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                saveHistory({ tables: { patches: patches, inversePatches: inversePatches } });
+                return nextState;
+            });
+        }
         if (nextActiveCell.rowIndex !== activeCell.rowIndex) {
             onChangeActiveCell === null || onChangeActiveCell === void 0 ? void 0 : onChangeActiveCell(sheetId, nextActiveCell);
         }

package/dist/cjs/interface/delete-sheet.d.ts

@@ -1,4 +1,4 @@
-import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
 import type { UseOnDeleteSheetProps } from "../hooks/use-on-delete-sheet";
-export declare const deleteSheet: <T extends CellData, S extends Sheet>({ sheets, onChangeSheetData, onChangeActiveSheet, onChangeSheets, createHistory, enqueueGraphOperation, }: UseOnDeleteSheetProps<T, S>) => (sheetId: number) => void;
+export declare const deleteSheet: <T extends CellData, S extends Sheet>({ sheets, onChangeSheetData, onChangeActiveSheet, onChangeSheets, onChangeCharts, onChangeEmbeds, onChangeSlicers, onChangeTables, onChangeConditionalFormats, onChangeDataValidations, onChangeNamedRanges, onChangeProtectedRanges, createHistory, enqueueGraphOperation, }: UseOnDeleteSheetProps<T, S>) => (sheetId: number) => void;
 //# sourceMappingURL=delete-sheet.d.ts.map

package/dist/cjs/interface/delete-sheet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete-sheet.d.ts","sourceRoot":"","sources":["../../../interface/delete-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAG1E,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,2GAO9D,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,MACpB,SAAS,MAAM,SAkGxB,CAAC"}
+{"version":3,"file":"delete-sheet.d.ts","sourceRoot":"","sources":["../../../interface/delete-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAc,MAAM,2BAA2B,CAAC;AAO7E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAG1E,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+QAe9D,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,MACpB,SAAS,MAAM,SAgPxB,CAAC"}

package/dist/cjs/interface/delete-sheet.js

@@ -1,9 +1,11 @@
 import { __read } from "tslib";
 import { sortSheetsByIndex } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
+import { removeChartSpecRangesOnSheet } from "../api/anchored-objects";
 import { createSheetCellIdentifier } from "../api/formula";
+import { NAMED_RANGE_REF_ERROR } from "../api/named-range-structural";
 export var deleteSheet = function (_a) {
-    var sheets = _a.sheets, onChangeSheetData = _a.onChangeSheetData, onChangeActiveSheet = _a.onChangeActiveSheet, onChangeSheets = _a.onChangeSheets, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation;
+    var sheets = _a.sheets, onChangeSheetData = _a.onChangeSheetData, onChangeActiveSheet = _a.onChangeActiveSheet, onChangeSheets = _a.onChangeSheets, onChangeCharts = _a.onChangeCharts, onChangeEmbeds = _a.onChangeEmbeds, onChangeSlicers = _a.onChangeSlicers, onChangeTables = _a.onChangeTables, onChangeConditionalFormats = _a.onChangeConditionalFormats, onChangeDataValidations = _a.onChangeDataValidations, onChangeNamedRanges = _a.onChangeNamedRanges, onChangeProtectedRanges = _a.onChangeProtectedRanges, createHistory = _a.createHistory, enqueueGraphOperation = _a.enqueueGraphOperation;
     return function (sheetId) {
         var saveHistory = createHistory();
         var sortedSheets = sortSheetsByIndex(sheets).filter(function (sheet) { return !sheet.hidden; });
@@ -77,5 +79,120 @@ export var deleteSheet = function (_a) {
             });
             return nextState;
         });
+        // Excel: the deleted sheet takes its floating objects with it, and a chart
+        // on another sheet whose ranges read the deleted sheet keeps the chart but
+        // loses those ranges (`#REF!`, an empty series).
+        onChangeCharts === null || onChangeCharts === void 0 ? void 0 : onChangeCharts(function (prevCharts) {
+            var _a = __read(produceWithPatches(prevCharts, function (draft) {
+                var _a;
+                for (var i = draft.length - 1; i >= 0; i--) {
+                    var chart = draft[i];
+                    if (((_a = chart.position) === null || _a === void 0 ? void 0 : _a.sheetId) === sheetId) {
+                        draft.splice(i, 1);
+                        continue;
+                    }
+                    removeChartSpecRangesOnSheet(chart.spec, sheetId);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ charts: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        onChangeEmbeds === null || onChangeEmbeds === void 0 ? void 0 : onChangeEmbeds(function (prevEmbeds) {
+            var _a = __read(produceWithPatches(prevEmbeds, function (draft) {
+                var _a;
+                for (var i = draft.length - 1; i >= 0; i--) {
+                    if (((_a = draft[i].position) === null || _a === void 0 ? void 0 : _a.sheetId) === sheetId) {
+                        draft.splice(i, 1);
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ embeds: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        onChangeSlicers === null || onChangeSlicers === void 0 ? void 0 : onChangeSlicers(function (prevSlicers) {
+            var _a = __read(produceWithPatches(prevSlicers, function (draft) {
+                var _a;
+                for (var i = draft.length - 1; i >= 0; i--) {
+                    if (((_a = draft[i].position) === null || _a === void 0 ? void 0 : _a.sheetId) === sheetId) {
+                        draft.splice(i, 1);
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ slicers: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // Excel: everything scoped to the deleted sheet goes with it — its tables, the CF / DV
+        // ranges on it (a rule left with no range is dropped), the names scoped to it and the
+        // protected ranges on it. A workbook-scoped name whose range lived on the sheet is KEPT
+        // as `=#REF!` (Excel's Name Manager), like a name whose whole range is deleted: range
+        // cleared, value the `#REF!` marker, so `=SUM(Data)` evaluates `#REF!` rather than `#NAME?`.
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                for (var i = draft.length - 1; i >= 0; i--) {
+                    if (draft[i].sheetId === sheetId) {
+                        draft.splice(i, 1);
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ tables: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        var dropRulesOnSheet = function (draft) {
+            var _a, _b;
+            for (var i = draft.length - 1; i >= 0; i--) {
+                var rule = draft[i];
+                var kept = (_a = rule.ranges) === null || _a === void 0 ? void 0 : _a.filter(function (range) { return range.sheetId !== sheetId; });
+                if (!kept || kept.length === ((_b = rule.ranges) === null || _b === void 0 ? void 0 : _b.length))
+                    continue;
+                if (kept.length) {
+                    rule.ranges = kept;
+                }
+                else {
+                    draft.splice(i, 1);
+                }
+            }
+        };
+        onChangeConditionalFormats === null || onChangeConditionalFormats === void 0 ? void 0 : onChangeConditionalFormats(function (prevRules) {
+            var _a = __read(produceWithPatches(prevRules, function (draft) {
+                dropRulesOnSheet(draft);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ conditionalFormats: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        onChangeDataValidations === null || onChangeDataValidations === void 0 ? void 0 : onChangeDataValidations(function (prevRules) {
+            var _a = __read(produceWithPatches(prevRules, function (draft) {
+                dropRulesOnSheet(draft);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ dataValidations: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        onChangeNamedRanges === null || onChangeNamedRanges === void 0 ? void 0 : onChangeNamedRanges(function (prevNamedRanges) {
+            var _a = __read(produceWithPatches(prevNamedRanges, function (draft) {
+                var _a;
+                for (var i = draft.length - 1; i >= 0; i--) {
+                    var namedRange = draft[i];
+                    if (namedRange.scopeSheetId === sheetId) {
+                        draft.splice(i, 1);
+                    }
+                    else if (((_a = namedRange.range) === null || _a === void 0 ? void 0 : _a.sheetId) === sheetId) {
+                        namedRange.range = undefined;
+                        namedRange.value = NAMED_RANGE_REF_ERROR;
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ namedRanges: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        onChangeProtectedRanges === null || onChangeProtectedRanges === void 0 ? void 0 : onChangeProtectedRanges(function (prevProtectedRanges) {
+            var _a = __read(produceWithPatches(prevProtectedRanges, function (draft) {
+                for (var i = draft.length - 1; i >= 0; i--) {
+                    if (draft[i].range.sheetId === sheetId) {
+                        draft.splice(i, 1);
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ protectedRanges: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
     };
 };

package/dist/cjs/interface/delete-table-column.d.ts

@@ -1,4 +1,4 @@
 import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
 import type { UseOnTableProps } from "../hooks/use-on-table";
-export declare const deleteTableColumn: <T extends CellData, S extends Sheet>({ columnCount, rowCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, createHistory, onChangeTables, onChangeSheets, onChangeSheetData, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, getDependents, }: Pick<UseOnTableProps<T, S>, "columnCount" | "rowCount" | "locale" | "cellXfsRegistry" | "sharedStringRegistry" | "getSheetName" | "createHistory" | "onChangeTables" | "onChangeSheets" | "onChangeSheetData" | "enqueueCalculation" | "enqueueStructureChange" | "enqueueGraphOperation" | "getDependents">) => (tableView: TableView, dimensionIndex: number) => void;
+export declare const deleteTableColumn: <T extends CellData, S extends Sheet>({ columnCount, rowCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, createHistory, onChangeTables, onChangeSheets, onChangeSheetData, onChangeCharts, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, getDependents, }: Pick<UseOnTableProps<T, S>, "columnCount" | "rowCount" | "locale" | "cellXfsRegistry" | "sharedStringRegistry" | "getSheetName" | "createHistory" | "onChangeTables" | "onChangeSheets" | "onChangeSheetData" | "onChangeCharts" | "enqueueCalculation" | "enqueueStructureChange" | "enqueueGraphOperation" | "getDependents">) => (tableView: TableView, dimensionIndex: number) => void;
 //# sourceMappingURL=delete-table-column.d.ts.map

package/dist/cjs/interface/delete-table-column.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete-table-column.d.ts","sourceRoot":"","sources":["../../../interface/delete-table-column.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAY5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,6OAepE,IAAI,CACL,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,aAAa,GACb,UAAU,GACV,QAAQ,GACR,iBAAiB,GACjB,sBAAsB,GACtB,cAAc,GACd,eAAe,GACf,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,oBAAoB,GACpB,wBAAwB,GACxB,uBAAuB,GACvB,eAAe,CAClB,MACS,WAAW,SAAS,EAAE,gBAAgB,MAAM,SA8VrD,CAAC"}
+{"version":3,"file":"delete-table-column.d.ts","sourceRoot":"","sources":["../../../interface/delete-table-column.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAa5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,6PAgBpE,IAAI,CACL,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,aAAa,GACb,UAAU,GACV,QAAQ,GACR,iBAAiB,GACjB,sBAAsB,GACtB,cAAc,GACd,eAAe,GACf,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,gBAAgB,GAChB,oBAAoB,GACpB,wBAAwB,GACxB,uBAAuB,GACvB,eAAe,CAClB,MACS,WAAW,SAAS,EAAE,gBAAgB,MAAM,SAmXrD,CAAC"}

package/dist/cjs/interface/delete-table-column.js

@@ -2,6 +2,7 @@ import { __assign, __read, __values } from "tslib";
 import { Direction } from "@rowsncolumns/common-types";
 import { getCellUserEnteredValue, getExtendedValueFormula } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
+import { shiftChartsOnTableEdit, tableBinding } from "../api/anchored-objects";
 import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
 import { contractRangesInFormula, createSheetCellIdentifier } from "../api/formula";
 import { createSheetDraft } from "../api/immer-utils";
@@ -9,7 +10,7 @@ import { moveMergedCells } from "../api/merges";
 import { moveFilterView } from "../api/selection";
 import { SheetCell } from "../sheet-cell";
 export var deleteTableColumn = function (_a) {
-    var columnCount = _a.columnCount, rowCount = _a.rowCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getSheetName = _a.getSheetName, createHistory = _a.createHistory, onChangeTables = _a.onChangeTables, onChangeSheets = _a.onChangeSheets, onChangeSheetData = _a.onChangeSheetData, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, enqueueGraphOperation = _a.enqueueGraphOperation, getDependents = _a.getDependents;
+    var columnCount = _a.columnCount, rowCount = _a.rowCount, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getSheetName = _a.getSheetName, createHistory = _a.createHistory, onChangeTables = _a.onChangeTables, onChangeSheets = _a.onChangeSheets, onChangeSheetData = _a.onChangeSheetData, onChangeCharts = _a.onChangeCharts, enqueueCalculation = _a.enqueueCalculation, enqueueStructureChange = _a.enqueueStructureChange, enqueueGraphOperation = _a.enqueueGraphOperation, getDependents = _a.getDependents;
     return function (tableView, dimensionIndex) {
         var sheetId = tableView.sheetId, range = tableView.range;
         var saveHistory = createHistory();
@@ -103,6 +104,15 @@ export var deleteTableColumn = function (_a) {
             });
             return nextState;
         });
+        // Chart ranges inside the table's rows follow the shifted cells; a range reading the whole
+        // table (its body, or header + body, across every column) loses the column with it.
+        onChangeCharts === null || onChangeCharts === void 0 ? void 0 : onChangeCharts(function (prevCharts) {
+            var _a = __read(produceWithPatches(prevCharts, function (draft) {
+                shiftChartsOnTableEdit(draft, sheetId, tableBinding(tableView), "column", "delete", minColumnIndex, count);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ charts: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
         // Update sheets
         onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
             var _a = __read(produceWithPatches(prevSheets, function (draft) {

package/dist/cjs/interface/delete-table-row.d.ts

@@ -1,4 +1,4 @@
 import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
 import { type UseOnDeleteTableRowProps } from "../hooks/use-on-delete-table-row";
-export declare const deleteTableRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, }: UseOnDeleteTableRowProps<T, S>) => (tableView: TableView, rowIndexes: number[]) => void;
+export declare const deleteTableRow: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getDependents, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCharts, onChangeDataValidations, onChangeConditionalFormats, }: UseOnDeleteTableRowProps<T, S>) => (tableView: TableView, rowIndexes: number[]) => void;
 //# sourceMappingURL=delete-table-row.d.ts.map

package/dist/cjs/interface/delete-table-row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete-table-row.d.ts","sourceRoot":"","sources":["../../../interface/delete-table-row.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAgB5E,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAIjF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,kSAiBjE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,MACvB,WAAW,SAAS,EAAE,YAAY,MAAM,EAAE,SAoYnD,CAAC"}
+{"version":3,"file":"delete-table-row.d.ts","sourceRoot":"","sources":["../../../interface/delete-table-row.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAkB5E,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAKjF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,kTAkBjE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,MACvB,WAAW,SAAS,EAAE,YAAY,MAAM,EAAE,SA0enD,CAAC"}