@rowsncolumns/spreadsheet-state 29.0.0 → 29.1.1

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

@@ -1,14 +1,40 @@
 import { Direction } from "@rowsncolumns/common-types";
 import { produceWithPatches } from "immer";
-import { shiftChartsOnStructuralChange, shiftEmbedsOnStructuralChange, shiftProtectedRangesOnStructuralChange, } from "../api/anchored-objects";
+import { shiftChartsOnStructuralChange, shiftEmbedsOnStructuralChange, shiftSlicersOnStructuralChange, shiftProtectedRangesOnStructuralChange, refreshCitationAnchor, } from "../api/anchored-objects";
 import { shrinkMergesOnRowDelete } from "../api/merges";
 import { updateNamedRangesOnStructuralChange, updatePrintSettingsOnStructuralChange, } from "../api/named-range-structural";
 import { shiftPivotsOnDelete } from "../api/pivot-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";
-export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeActiveCell, onChangeSelections, onChangeConditionalFormats, onChangeDataValidations, onChangeCitations, onChangePivotTables, tables, getArrayRange, onChangeNamedRanges, onChangeEmbeds, onChangeCharts, onChangeProtectedRanges, }) => {
+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).
+ */
+const rowDeleteEffectOnTable = (table, rowIndexes) => {
+    const { startRowIndex, endRowIndex } = table.range;
+    const above = rowIndexes.filter((rowIndex) => rowIndex < startRowIndex).length;
+    const inside = rowIndexes.filter((rowIndex) => rowIndex >= startRowIndex && rowIndex <= endRowIndex).length;
+    const removed = inside === endRowIndex - startRowIndex + 1;
+    const nextStartRowIndex = startRowIndex - above;
+    const nextRange = {
+        ...table.range,
+        startRowIndex: nextStartRowIndex,
+        endRowIndex: Math.max(endRowIndex - above - inside, nextStartRowIndex +
+            (table.headerRow !== false ? 1 : 0) +
+            (table.totalRow ? 1 : 0)),
+    };
+    return { above, inside, removed, nextRange };
+};
+export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, getActiveCell, getSelections, getDependents, getGraphNodes, getGraphNodesInSheet, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeActiveCell, onChangeSelections, onChangeConditionalFormats, onChangeDataValidations, onChangeCitations, onChangePivotTables, tables, getArrayRange, onChangeNamedRanges, onChangeEmbeds, onChangeSlicers, onChangeCharts, onChangeProtectedRanges, }) => {
     return (sheetId, rowIndexes) => {
         if (!rowIndexes.length)
             return;
@@ -27,6 +53,20 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
             columnCount,
         });
         const 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.
+        const emptiedTotalsTables = (tables ?? []).filter((table) => {
+            if (table.sheetId !== sheetId || !table.totalRow)
+                return false;
+            const bodyStartRowIndex = table.range.startRowIndex + (table.headerRow !== false ? 1 : 0);
+            const bodyEndRowIndex = table.range.endRowIndex - 1;
+            return (minRowIndex >= bodyStartRowIndex &&
+                minRowIndex <= bodyEndRowIndex &&
+                maxRowIndex >= bodyEndRowIndex &&
+                sortedRowIndexes.filter((rowIndex) => rowIndex >= bodyStartRowIndex && rowIndex <= bodyEndRowIndex).length >
+                    bodyEndRowIndex - bodyStartRowIndex);
+        });
         const activeCell = getActiveCell();
         const selections = getSelections();
         const newRowCount = Math.max(1, rowCount - count);
@@ -61,25 +101,39 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
                 },
             };
         });
-        // Tables: shrink/move based on overlap with deletion; drop tables
-        // whose header row is removed.
+        // 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).
+        const headerRederivedTables = (tables ?? []).flatMap((table) => {
+            if (table.sheetId !== sheetId || table.headerRow === false)
+                return [];
+            const { removed, nextRange } = rowDeleteEffectOnTable(table, sortedRowIndexes);
+            return !removed && sortedRowIndexes.includes(table.range.startRowIndex)
+                ? [{ table, nextRange }]
+                : [];
+        });
+        // Re-derived column names by table id, filled in by the sheet-data pass.
+        const 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?.((prevTables) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
                 for (let idx = draft.length - 1; idx >= 0; idx--) {
                     const table = draft[idx];
                     if (table.sheetId !== sheetId)
                         continue;
-                    const { startRowIndex, endRowIndex } = table.range;
-                    if (minRowIndex < startRowIndex) {
-                        moveFilterView(table, count, Direction.Up);
-                    }
-                    if (minRowIndex >= startRowIndex && minRowIndex <= endRowIndex) {
-                        const delta = Math.min(endRowIndex - minRowIndex + 1, count);
-                        table.range.endRowIndex -= delta;
-                    }
-                    if (startRowIndex >= minRowIndex && startRowIndex <= maxRowIndex) {
+                    const { above, removed, nextRange } = rowDeleteEffectOnTable(table, sortedRowIndexes);
+                    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;
                 }
             });
             saveHistory({ tables: { patches, inversePatches } });
@@ -122,6 +176,7 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
         // Citations: drop if overlapping with deletion, shift up if entirely
         // after.
         onChangeCitations?.((prevCitations) => {
+            const updatedAt = new Date().toISOString();
             const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
                 const deleteEnd = minRowIndex + count - 1;
                 for (let idx = draft.length - 1; idx >= 0; idx--) {
@@ -131,11 +186,16 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
                     const citationStart = citation.range.startRowIndex;
                     const citationEnd = citation.range.endRowIndex;
                     if (citationStart <= deleteEnd && citationEnd >= minRowIndex) {
-                        draft.splice(idx, 1);
+                        // Soft-delete: keep the record for provenance / undo, hide it from the UI
+                        if (citation.active !== false) {
+                            citation.active = false;
+                            citation.updated_at = updatedAt;
+                        }
                     }
                     else if (citationStart > deleteEnd) {
                         citation.range.startRowIndex -= count;
                         citation.range.endRowIndex -= count;
+                        refreshCitationAnchor(citation);
                     }
                 }
             });
@@ -153,6 +213,13 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
             saveHistory({ embeds: { patches, inversePatches } });
             return nextState;
         });
+        onChangeSlicers?.((prevSlicers) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSlicers, (draft) => {
+                shiftSlicersOnStructuralChange(draft, sheetId, "row", "delete", minRowIndex, count);
+            });
+            saveHistory({ slicers: { patches, inversePatches } });
+            return nextState;
+        });
         onChangeCharts?.((prevCharts) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
                 shiftChartsOnStructuralChange(draft, sheetId, "row", "delete", minRowIndex, count);
@@ -207,7 +274,7 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
             saveHistory({ sheets: { patches, 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.
         const removedTableParts = collectRemovedTableParts(tables, sheetId, "row", minRowIndex, maxRowIndex);
         // Sheet data: three-pass formula update, then splice the rows out.
@@ -265,6 +332,86 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
                 for (let i = sortedRowIndexes.length - 1; i >= 0; i--) {
                     draft[sheetId]?.splice(sortedRowIndexes[i], 1);
                 }
+                for (const table of emptiedTotalsTables) {
+                    const totalsRowIndex = table.range.startRowIndex +
+                        (table.headerRow !== false ? 1 : 0);
+                    const bodyRowIndex = totalsRowIndex + 1;
+                    const totalsRow = createSheetDraft(draft, sheetId, totalsRowIndex);
+                    const bodyRow = createSheetDraft(draft, sheetId, bodyRowIndex);
+                    for (let columnIndex = table.range.startColumnIndex; columnIndex <= table.range.endColumnIndex; columnIndex++) {
+                        const totalsCell = totalsRow[totalsRowIndex].values[columnIndex];
+                        totalsRow[totalsRowIndex].values[columnIndex] =
+                            bodyRow[bodyRowIndex].values[columnIndex];
+                        bodyRow[bodyRowIndex].values[columnIndex] = totalsCell;
+                        for (const rowIndex of [totalsRowIndex, bodyRowIndex]) {
+                            enqueueCalculation?.({
+                                type: "dirty",
+                                position: { sheetId, rowIndex, columnIndex },
+                            });
+                            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), { sheetId, rowIndex, columnIndex });
+                        }
+                    }
+                }
+                // 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.
+                const sheetCell = new SheetCell();
+                const cellOptions = { locale, cellXfsRegistry, sharedStringRegistry };
+                for (const { table, nextRange } of headerRederivedTables) {
+                    const headerRowIndex = nextRange.startRowIndex;
+                    const names = getTableHeaderNames({
+                        sheetId,
+                        range: nextRange,
+                        getFormattedValue: (sid, rowIndex, columnIndex) => {
+                            sheetCell.assign(sid, { rowIndex, columnIndex }, draft[sid]?.[rowIndex]?.values?.[columnIndex], cellOptions);
+                            const value = sheetCell.getEffectiveValue() ??
+                                (sheetCell.isFormula()
+                                    ? undefined
+                                    : sheetCell.getUserEnteredValue());
+                            return value === undefined ? undefined : String(value);
+                        },
+                    });
+                    const headerRow = createSheetDraft(draft, sheetId, headerRowIndex);
+                    const renames = new Map();
+                    names.forEach((name, index) => {
+                        const columnIndex = nextRange.startColumnIndex + index;
+                        const position = { sheetId, rowIndex: headerRowIndex, columnIndex };
+                        sheetCell.assign(sheetId, position, headerRow[headerRowIndex].values[columnIndex], cellOptions);
+                        if (sheetCell.isFormula()) {
+                            enqueueGraphOperation?.({ type: "remove", position });
+                        }
+                        // A table header cell holds its column name as text.
+                        sheetCell.setUserEnteredValue(name, undefined, {
+                            disableTypeInference: true,
+                        });
+                        headerRow[headerRowIndex].values[columnIndex] =
+                            sheetCell.getCellData();
+                        enqueueCalculation?.({ type: "dirty", position });
+                        recalcCells.set(createSheetCellIdentifier(sheetId, headerRowIndex, columnIndex), position);
+                        const oldName = table.columns?.[index]?.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,
+                            table: { title: table.title, sheetId, range: nextRange },
+                            renames,
+                            getGraphNodes,
+                            enqueueCalculation,
+                            enqueueGraphOperation,
+                            recalcCells,
+                            locale,
+                            cellXfsRegistry,
+                            sharedStringRegistry,
+                        });
+                    }
+                    rederivedColumnNames.set(table.id, names);
+                }
             });
             saveHistory({
                 sheetData: { patches, inversePatches },
@@ -277,6 +424,23 @@ export const deleteRow = ({ rowCount, columnCount, locale, cellXfsRegistry, shar
             });
             return nextState;
         });
+        if (rederivedColumnNames.size) {
+            onChangeTables?.((prevTables) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                    for (const table of draft) {
+                        const names = rederivedColumnNames.get(table.id);
+                        if (!names)
+                            continue;
+                        table.columns = names.map((name, index) => ({
+                            ...(table.columns?.[index] ?? {}),
+                            name,
+                        }));
+                    }
+                });
+                saveHistory({ tables: { patches, inversePatches } });
+                return nextState;
+            });
+        }
         if (nextActiveCell.rowIndex !== activeCell.rowIndex) {
             onChangeActiveCell?.(sheetId, nextActiveCell);
         }

package/dist/esm/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, onChangeCitations, createHistory, enqueueGraphOperation, }: UseOnDeleteSheetProps<T, S>) => (sheetId: number) => void;
 //# sourceMappingURL=delete-sheet.d.ts.map

package/dist/esm/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,kSAgB9D,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,MACpB,SAAS,MAAM,SAuQxB,CAAC"}

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

@@ -1,7 +1,9 @@
 import { sortSheetsByIndex } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
+import { removeChartSpecRangesOnSheet } from "../api/anchored-objects";
 import { createSheetCellIdentifier } from "../api/formula";
-export const deleteSheet = ({ sheets, onChangeSheetData, onChangeActiveSheet, onChangeSheets, createHistory, enqueueGraphOperation, }) => {
+import { NAMED_RANGE_REF_ERROR } from "../api/named-range-structural";
+export const deleteSheet = ({ sheets, onChangeSheetData, onChangeActiveSheet, onChangeSheets, onChangeCharts, onChangeEmbeds, onChangeSlicers, onChangeTables, onChangeConditionalFormats, onChangeDataValidations, onChangeNamedRanges, onChangeProtectedRanges, onChangeCitations, createHistory, enqueueGraphOperation, }) => {
     return (sheetId) => {
         const saveHistory = createHistory();
         const sortedSheets = sortSheetsByIndex(sheets).filter((sheet) => !sheet.hidden);
@@ -36,6 +38,25 @@ export const deleteSheet = ({ sheets, onChangeSheetData, onChangeActiveSheet, on
             });
             return nextState;
         });
+        // Retire the citations anchored on the deleted sheet. Soft-delete keeps the
+        // record for provenance / undo and hides it from the UI; the patch rides the
+        // same history entry as the sheet removal so one undo restores both.
+        onChangeCitations?.((prevCitations) => {
+            const updatedAt = new Date().toISOString();
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCitations, (draft) => {
+                for (const citation of draft) {
+                    if (citation.active !== false && citation.range.sheetId === sheetId) {
+                        citation.active = false;
+                        citation.updated_at = updatedAt;
+                    }
+                }
+            });
+            if (patches.length === 0) {
+                return prevCitations;
+            }
+            saveHistory({ citations: { patches, inversePatches } });
+            return nextState;
+        });
         // Add cells to recalc
         onChangeSheetData?.((prevSheetData) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
@@ -74,5 +95,115 @@ export const deleteSheet = ({ sheets, onChangeSheetData, onChangeActiveSheet, on
             });
             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?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                for (let i = draft.length - 1; i >= 0; i--) {
+                    const chart = draft[i];
+                    if (chart.position?.sheetId === sheetId) {
+                        draft.splice(i, 1);
+                        continue;
+                    }
+                    removeChartSpecRangesOnSheet(chart.spec, sheetId);
+                }
+            });
+            saveHistory({ charts: { patches, inversePatches } });
+            return nextState;
+        });
+        onChangeEmbeds?.((prevEmbeds) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevEmbeds, (draft) => {
+                for (let i = draft.length - 1; i >= 0; i--) {
+                    if (draft[i].position?.sheetId === sheetId) {
+                        draft.splice(i, 1);
+                    }
+                }
+            });
+            saveHistory({ embeds: { patches, inversePatches } });
+            return nextState;
+        });
+        onChangeSlicers?.((prevSlicers) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSlicers, (draft) => {
+                for (let i = draft.length - 1; i >= 0; i--) {
+                    if (draft[i].position?.sheetId === sheetId) {
+                        draft.splice(i, 1);
+                    }
+                }
+            });
+            saveHistory({ slicers: { patches, 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?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                for (let i = draft.length - 1; i >= 0; i--) {
+                    if (draft[i].sheetId === sheetId) {
+                        draft.splice(i, 1);
+                    }
+                }
+            });
+            saveHistory({ tables: { patches, inversePatches } });
+            return nextState;
+        });
+        const dropRulesOnSheet = (draft) => {
+            for (let i = draft.length - 1; i >= 0; i--) {
+                const rule = draft[i];
+                const kept = rule.ranges?.filter((range) => range.sheetId !== sheetId);
+                if (!kept || kept.length === rule.ranges?.length)
+                    continue;
+                if (kept.length) {
+                    rule.ranges = kept;
+                }
+                else {
+                    draft.splice(i, 1);
+                }
+            }
+        };
+        onChangeConditionalFormats?.((prevRules) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevRules, (draft) => {
+                dropRulesOnSheet(draft);
+            });
+            saveHistory({ conditionalFormats: { patches, inversePatches } });
+            return nextState;
+        });
+        onChangeDataValidations?.((prevRules) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevRules, (draft) => {
+                dropRulesOnSheet(draft);
+            });
+            saveHistory({ dataValidations: { patches, inversePatches } });
+            return nextState;
+        });
+        onChangeNamedRanges?.((prevNamedRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevNamedRanges, (draft) => {
+                for (let i = draft.length - 1; i >= 0; i--) {
+                    const namedRange = draft[i];
+                    if (namedRange.scopeSheetId === sheetId) {
+                        draft.splice(i, 1);
+                    }
+                    else if (namedRange.range?.sheetId === sheetId) {
+                        namedRange.range = undefined;
+                        namedRange.value = NAMED_RANGE_REF_ERROR;
+                    }
+                }
+            });
+            saveHistory({ namedRanges: { patches, inversePatches } });
+            return nextState;
+        });
+        onChangeProtectedRanges?.((prevProtectedRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevProtectedRanges, (draft) => {
+                for (let i = draft.length - 1; i >= 0; i--) {
+                    if (draft[i].range.sheetId === sheetId) {
+                        draft.splice(i, 1);
+                    }
+                }
+            });
+            saveHistory({ protectedRanges: { patches, inversePatches } });
+            return nextState;
+        });
     };
 };

package/dist/esm/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/esm/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/esm/interface/delete-table-column.js

@@ -1,13 +1,14 @@
 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";
 import { moveMergedCells } from "../api/merges";
 import { moveFilterView } from "../api/selection";
 import { SheetCell } from "../sheet-cell";
-export const deleteTableColumn = ({ columnCount, rowCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, createHistory, onChangeTables, onChangeSheets, onChangeSheetData, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, getDependents, }) => {
+export const deleteTableColumn = ({ columnCount, rowCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, createHistory, onChangeTables, onChangeSheets, onChangeSheetData, onChangeCharts, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, getDependents, }) => {
     return (tableView, dimensionIndex) => {
         const { sheetId, range } = tableView;
         const saveHistory = createHistory();
@@ -69,6 +70,15 @@ export const deleteTableColumn = ({ columnCount, rowCount, locale, cellXfsRegist
             });
             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?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                shiftChartsOnTableEdit(draft, sheetId, tableBinding(tableView), "column", "delete", minColumnIndex, count);
+            });
+            saveHistory({ charts: { patches, inversePatches } });
+            return nextState;
+        });
         // Update sheets
         onChangeSheets?.((prevSheets) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {

package/dist/esm/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/esm/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"}