@rowsncolumns/spreadsheet-state 28.0.76 → 29.1.0

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

@@ -1,5 +1,7 @@
-import { uuid } from "@rowsncolumns/utils";
+import { getCellUserEnteredValue, getExtendedValueFormula, getNextTableCopyName, uuid, } from "@rowsncolumns/utils";
 import { castDraft, produceWithPatches } from "immer";
+import { retargetChartSpecRanges } from "../api/anchored-objects";
+import { renameTablesInFormula } from "../api/formula";
 import { createSheetDraft } from "../api/immer-utils";
 import { getGeneratedSheetCopyName } from "../generated-names";
 import { SheetCell } from "../sheet-cell";
@@ -8,6 +10,10 @@ export const duplicateSheet = ({ locale, maxSheetCount, sheets, idCreationStrate
         const saveHistory = createHistory();
         // Track the newSheetId that gets generated inside produceWithPatches
         let finalNewSheetId;
+        // A chartsheet copy owns a fresh copy of its chart; both ids are minted
+        // up front so the sheet and the chart agree.
+        let copiedChartSheetChartId;
+        let sourceChartSheetChartId;
         // Add sheet
         onChangeSheets((prevSheets) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
@@ -25,11 +31,18 @@ export const duplicateSheet = ({ locale, maxSheetCount, sheets, idCreationStrate
                 // Generate unique title using the CURRENT draft state
                 const existingTitles = draft.map((s) => s.title);
                 const newTitle = generateUniqueSheetName(existingTitles, sheet.title, generatedNames);
+                if (sheet.type === "chartsheet" && sheet.chartId != null) {
+                    sourceChartSheetChartId = sheet.chartId;
+                    copiedChartSheetChartId = idCreationStrategy?.("chart") ?? uuid();
+                }
                 /* Update the sheet title */
                 const newSheet = {
                     ...sheet,
                     sheetId: newSheetId,
                     title: newTitle,
+                    ...(copiedChartSheetChartId !== undefined
+                        ? { chartId: copiedChartSheetChartId }
+                        : {}),
                 };
                 draft.push(castDraft(newSheet));
                 finalNewSheetId = newSheetId;
@@ -48,6 +61,37 @@ export const duplicateSheet = ({ locale, maxSheetCount, sheets, idCreationStrate
             return undefined;
         }
         const newSheetId = finalNewSheetId;
+        // Copy tables first: the copy's formulas re-point their structured
+        // references at the copied tables (Excel: `Sales[Amount]` in the copy
+        // reads `Sales2[Amount]`), so the sheet-data copy needs the new names.
+        // Lower-cased old title → copy title.
+        const tableRenames = new Map();
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                const currentTables = draft.filter((table) => table.sheetId === sheetId);
+                // Excel names the copy `Sales2`, `Sales3`, … against every table
+                // in the workbook, including the copies made by this duplication.
+                const takenTitles = draft.map((table) => table.title);
+                for (const table of currentTables) {
+                    const title = getNextTableCopyName(table.title, takenTitles);
+                    takenTitles.push(title);
+                    if (table.title) {
+                        tableRenames.set(table.title.toLowerCase(), title);
+                    }
+                    draft.push({
+                        ...table,
+                        title,
+                        id: idCreationStrategy?.("table") ?? uuid(),
+                        sheetId: newSheetId,
+                    });
+                }
+            });
+            // Save history
+            saveHistory({
+                tables: { patches, inversePatches },
+            });
+            return nextState;
+        });
         onChangeSheetData?.((prevSheetData) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
                 // Clone the sheet
@@ -64,6 +108,16 @@ export const duplicateSheet = ({ locale, maxSheetCount, sheets, idCreationStrate
                         // Create a cell
                         sheetCell.assign(newSheetId, { rowIndex, columnIndex }, cellData, { locale });
                         if (sheetCell.isFormula()) {
+                            const formula = getExtendedValueFormula(getCellUserEnteredValue(cellData));
+                            const renamed = formula
+                                ? renameTablesInFormula(formula, tableRenames)
+                                : undefined;
+                            if (renamed !== undefined && renamed !== formula) {
+                                sheetCell.setFormulaValue(renamed, false);
+                                const copySheet = createSheetDraft(draft, newSheetId, rowIndex);
+                                copySheet[rowIndex].values[columnIndex] =
+                                    sheetCell.getCellData();
+                            }
                             enqueueGraphOperation({
                                 type: "add",
                                 position: {
@@ -82,35 +136,28 @@ export const duplicateSheet = ({ locale, maxSheetCount, sheets, idCreationStrate
             });
             return nextState;
         });
-        // Update tables
-        onChangeTables?.((prevTables) => {
-            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
-                const currentTables = draft.filter((table) => table.sheetId === sheetId);
-                draft.push(...currentTables.map((table, index) => ({
-                    ...table,
-                    title: `${table.title}${index + 1}`,
-                    id: idCreationStrategy?.("table") ?? uuid(),
-                    sheetId: newSheetId,
-                })));
-            });
-            // Save history
-            saveHistory({
-                tables: { patches, inversePatches },
-            });
-            return nextState;
-        });
         // Check if there are charts
         onChangeCharts?.((prevCharts) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
                 const current = draft.filter((chart) => chart.position.sheetId === sheetId);
-                draft.push(...current.map((chart) => ({
-                    ...chart,
-                    chartId: idCreationStrategy?.("chart") ?? uuid(),
-                    position: {
-                        ...chart.position,
-                        sheetId: newSheetId,
-                    },
-                })));
+                draft.push(...current.map((chart) => {
+                    // The copy reads the copy's own cells (Excel); ranges on other
+                    // sheets keep reading them.
+                    const spec = JSON.parse(JSON.stringify(chart.spec));
+                    retargetChartSpecRanges(spec, sheetId, newSheetId);
+                    return {
+                        ...chart,
+                        chartId: copiedChartSheetChartId !== undefined &&
+                            chart.chartId === sourceChartSheetChartId
+                            ? copiedChartSheetChartId
+                            : (idCreationStrategy?.("chart") ?? uuid()),
+                        spec,
+                        position: {
+                            ...chart.position,
+                            sheetId: newSheetId,
+                        },
+                    };
+                }));
             });
             // Save history
             saveHistory({

package/dist/esm/interface/embeds.d.ts

@@ -1,4 +1,4 @@
-import type { EmbeddedObject } from "@rowsncolumns/spreadsheet";
+import type { EmbeddedChart, EmbeddedObject, ZOrderChange } from "@rowsncolumns/spreadsheet";
 import { type CanvasGridProps, type CellData } from "@rowsncolumns/spreadsheet";
 import type { UseOnEmbedsProps } from "../hooks/use-on-embeds";
 export declare const deleteEmbed: <T extends CellData>({ onChangeEmbeds, createHistory, }: Omit<UseOnEmbedsProps<T>, "sheetId">) => (embedId: EmbeddedObject["embedId"]) => void;
@@ -6,4 +6,13 @@ export declare const updateEmbed: <T extends CellData>({ onChangeEmbeds, createH
 export declare const moveEmbed: <T extends CellData>({ onChangeEmbeds, createHistory, }: UseOnEmbedsProps<T>) => NonNullable<CanvasGridProps["onMoveEmbed"]>;
 export declare const resizeEmbed: <T extends CellData>({ onChangeEmbeds, createHistory, }: UseOnEmbedsProps<T>) => NonNullable<CanvasGridProps["onResizeEmbed"]>;
 export declare const createEmbed: <T extends CellData>({ onChangeEmbeds, createHistory, }: Omit<UseOnEmbedsProps<T>, "sheetId">) => (spec: EmbeddedObject) => void;
+/**
+ * Excel's Arrange menu: write the planned `position.zOrder` of every changed
+ * chart and embed (`planZOrderChange`) as ONE history entry — the charts and
+ * embeds patches share the entry, so a Bring Forward that swaps a chart with
+ * a picture undoes in one step.
+ */
+export declare const changeZOrder: <T extends CellData>({ onChangeCharts, onChangeEmbeds, createHistory, }: Omit<UseOnEmbedsProps<T>, "sheetId"> & {
+    onChangeCharts?: React.Dispatch<React.SetStateAction<EmbeddedChart[]>>;
+}) => (changes: ZOrderChange[]) => void;
 //# sourceMappingURL=embeds.d.ts.map

package/dist/esm/interface/embeds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embeds.d.ts","sourceRoot":"","sources":["../../../interface/embeds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAQ/D,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG7C,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC7B,SAAS,cAAc,CAAC,SAAS,CAAC,SA0B3C,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG7C,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC7B,OAAO,cAAc,SA0B9B,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG3C,gBAAgB,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,eAAe,CAAC,aAAa,CAAC,CA6BlE,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG7C,gBAAgB,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,eAAe,CAAC,eAAe,CAAC,CAuCpE,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG7C,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC7B,MAAM,cAAc,SAiB7B,CAAC"}
+{"version":3,"file":"embeds.d.ts","sourceRoot":"","sources":["../../../interface/embeds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,YAAY,EACb,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,QAAQ,EACd,MAAM,2BAA2B,CAAC;AAKnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAQ/D,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG7C,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC7B,SAAS,cAAc,CAAC,SAAS,CAAC,SA0B3C,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG7C,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC7B,OAAO,cAAc,SA0B9B,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG3C,gBAAgB,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,eAAe,CAAC,aAAa,CAAC,CAyClE,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG7C,gBAAgB,CAAC,CAAC,CAAC,KAAG,WAAW,CAAC,eAAe,CAAC,eAAe,CAAC,CA6CpE,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,oCAG7C,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,MAC7B,MAAM,cAAc,SAqB7B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,oDAI9C,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,GAAG;IACxC,cAAc,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;CACxE,MACS,SAAS,YAAY,EAAE,SAmEhC,CAAC"}

package/dist/esm/interface/embeds.js

@@ -1,5 +1,6 @@
 import { DEFAULT_ACTIVE_CELL } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
+import { setOverlayToAnchor } from "../api/anchored-objects";
 const DEFAULT_OVERLAY_POSITION = {
     anchorCell: DEFAULT_ACTIVE_CELL,
     heightPixels: 400,
@@ -18,8 +19,8 @@ export const deleteEmbed = ({ onChangeEmbeds, createHistory, }) => {
             saveHistory({
                 embeds: { patches, inversePatches },
                 selectedEmbedOrChart: {
-                    redo: embedId,
-                    undo: undefined,
+                    undo: embedId,
+                    redo: undefined,
                 },
             });
             return nextState;
@@ -39,8 +40,8 @@ export const updateEmbed = ({ onChangeEmbeds, createHistory, }) => {
             saveHistory({
                 embeds: { patches, inversePatches },
                 selectedEmbedOrChart: {
+                    undo: embed.embedId,
                     redo: embed.embedId,
-                    undo: undefined,
                 },
             });
             return nextState;
@@ -48,7 +49,7 @@ export const updateEmbed = ({ onChangeEmbeds, createHistory, }) => {
     };
 };
 export const moveEmbed = ({ onChangeEmbeds, createHistory, }) => {
-    return (embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels) => {
+    return (embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, toAnchor) => {
         const saveHistory = createHistory();
         onChangeEmbeds?.((prevCharts) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
@@ -63,17 +64,22 @@ export const moveEmbed = ({ onChangeEmbeds, createHistory, }) => {
                     embed.position.overlayPosition.anchorCell = anchorCell;
                     embed.position.overlayPosition.offsetXPixels = offsetXPixels;
                     embed.position.overlayPosition.offsetYPixels = offsetYPixels;
+                    setOverlayToAnchor(embed.position.overlayPosition, toAnchor);
                 }
             });
             saveHistory({
                 embeds: { patches, inversePatches },
+                selectedEmbedOrChart: {
+                    undo: embedId,
+                    redo: embedId,
+                },
             });
             return nextState;
         });
     };
 };
 export const resizeEmbed = ({ onChangeEmbeds, createHistory, }) => {
-    return (embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height) => {
+    return (embedId, sheetId, anchorCell, offsetXPixels, offsetYPixels, width, height, toAnchor) => {
         const saveHistory = createHistory();
         onChangeEmbeds?.((prevCharts) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
@@ -90,10 +96,15 @@ export const resizeEmbed = ({ onChangeEmbeds, createHistory, }) => {
                     embed.position.overlayPosition.offsetYPixels = offsetYPixels;
                     embed.position.overlayPosition.widthPixels = width;
                     embed.position.overlayPosition.heightPixels = height;
+                    setOverlayToAnchor(embed.position.overlayPosition, toAnchor);
                 }
             });
             saveHistory({
                 embeds: { patches, inversePatches },
+                selectedEmbedOrChart: {
+                    undo: embedId,
+                    redo: embedId,
+                },
             });
             return nextState;
         });
@@ -108,8 +119,76 @@ export const createEmbed = ({ onChangeEmbeds, createHistory, }) => {
             });
             saveHistory({
                 embeds: { patches, inversePatches },
+                selectedEmbedOrChart: {
+                    undo: undefined,
+                    redo: spec.embedId,
+                },
             });
             return nextState;
         });
     };
 };
+/**
+ * Excel's Arrange menu: write the planned `position.zOrder` of every changed
+ * chart and embed (`planZOrderChange`) as ONE history entry — the charts and
+ * embeds patches share the entry, so a Bring Forward that swaps a chart with
+ * a picture undoes in one step.
+ */
+export const changeZOrder = ({ onChangeCharts, onChangeEmbeds, createHistory, }) => {
+    return (changes) => {
+        const chartZOrders = new Map();
+        const embedZOrders = new Map();
+        for (const change of changes) {
+            if (change.kind === "chart") {
+                chartZOrders.set(change.chart.chartId, change.chart.position.zOrder ?? undefined);
+            }
+            else {
+                embedZOrders.set(change.embed.embedId, change.embed.position.zOrder ?? undefined);
+            }
+        }
+        const writesCharts = chartZOrders.size > 0 && !!onChangeCharts;
+        const writesEmbeds = embedZOrders.size > 0 && !!onChangeEmbeds;
+        if (!writesCharts && !writesEmbeds) {
+            return;
+        }
+        const saveHistory = createHistory();
+        const entry = {};
+        // Both setters run their updaters before the entry is saved, so the two
+        // patch sets land in the same history step.
+        let pending = (writesCharts ? 1 : 0) + (writesEmbeds ? 1 : 0);
+        const flush = () => {
+            pending -= 1;
+            if (pending === 0) {
+                saveHistory(entry);
+            }
+        };
+        if (writesCharts) {
+            onChangeCharts?.((prevCharts) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                    for (const chart of draft) {
+                        if (chartZOrders.has(chart.chartId)) {
+                            chart.position.zOrder = chartZOrders.get(chart.chartId);
+                        }
+                    }
+                });
+                entry.charts = { patches, inversePatches };
+                flush();
+                return nextState;
+            });
+        }
+        if (writesEmbeds) {
+            onChangeEmbeds?.((prevEmbeds) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevEmbeds, (draft) => {
+                    for (const embed of draft) {
+                        if (embedZOrders.has(embed.embedId)) {
+                            embed.position.zOrder = embedZOrders.get(embed.embedId);
+                        }
+                    }
+                });
+                entry.embeds = { patches, inversePatches };
+                flush();
+                return nextState;
+            });
+        }
+    };
+};

package/dist/esm/interface/insert-cells-shift-down.d.ts

@@ -10,5 +10,5 @@ import type { UseOnInsertCellsShiftDown } from "../hooks/use-on-insert-cells-shi
  * insertion (FMT-03). Refusals (torn merge/table/array, off-sheet push) are decided by the hook via
  * `getShiftCellsRefusal` before this runs.
  */
-export declare const insertCellsShiftDown: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, }: UseOnInsertCellsShiftDown<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+export declare const insertCellsShiftDown: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, onChangeCharts, }: UseOnInsertCellsShiftDown<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
 //# sourceMappingURL=insert-cells-shift-down.d.ts.map

package/dist/esm/interface/insert-cells-shift-down.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"insert-cells-shift-down.d.ts","sourceRoot":"","sources":["../../../interface/insert-cells-shift-down.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAe5E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAIzF;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,8RAkBvE,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,MAE9B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAoQnD,CAAC"}
+{"version":3,"file":"insert-cells-shift-down.d.ts","sourceRoot":"","sources":["../../../interface/insert-cells-shift-down.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAgB5E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAIzF;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,8SAmBvE,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,MAE9B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAwRnD,CAAC"}

package/dist/esm/interface/insert-cells-shift-down.js

@@ -1,4 +1,5 @@
 import { produceWithPatches } from "immer";
+import { shiftChartsOnCellShift } from "../api/anchored-objects";
 import { collectUniqueDependentsForRange, processSideEffectDependentCells, } from "../api/dependency";
 import { createSheetCellIdentifier, expandRangesInFormula } from "../api/formula";
 import { cloneCellWithFormatting, createSheetDraft } from "../api/immer-utils";
@@ -14,7 +15,7 @@ import { SheetCell } from "../sheet-cell";
  * insertion (FMT-03). Refusals (torn merge/table/array, off-sheet push) are decided by the hook via
  * `getShiftCellsRefusal` before this runs.
  */
-export const insertCellsShiftDown = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, }) => {
+export const insertCellsShiftDown = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, onChangeCharts, }) => {
     return (sheetId, activeCell, selections) => {
         const saveHistory = createHistory();
         // We need to track this for history. Precedent cells
@@ -87,6 +88,14 @@ export const insertCellsShiftDown = ({ rowCount, columnCount, locale, cellXfsReg
             });
             return nextState;
         });
+        // Chart ranges wholly inside the shifted columns grow/shift like references; the frame stays put.
+        onChangeCharts?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                shiftChartsOnCellShift(draft, sheetId, "row", "insert", r1, count, { startIndex: c1, endIndex: c2 });
+            });
+            saveHistory({ charts: { patches, inversePatches } });
+            return nextState;
+        });
         // Sheet data
         onChangeSheetData?.((prevSheetData) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {

package/dist/esm/interface/insert-cells-shift-right.d.ts

@@ -10,5 +10,5 @@ import type { UseOnInsertCellsShiftRight } from "../hooks/use-on-insert-cells-sh
  * (torn merge/table/array, a non-blank cell pushed past `columnCount` — SHF-10) are decided by the
  * hook before this runs.
  */
-export declare const insertCellsShiftRight: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, }: UseOnInsertCellsShiftRight<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+export declare const insertCellsShiftRight: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, onChangeCharts, }: UseOnInsertCellsShiftRight<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
 //# sourceMappingURL=insert-cells-shift-right.d.ts.map

package/dist/esm/interface/insert-cells-shift-right.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"insert-cells-shift-right.d.ts","sourceRoot":"","sources":["../../../interface/insert-cells-shift-right.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAgB5E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AAI3F;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,8RAkBxE,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC,MAE/B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAqQnD,CAAC"}
+{"version":3,"file":"insert-cells-shift-right.d.ts","sourceRoot":"","sources":["../../../interface/insert-cells-shift-right.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EAEb,aAAa,EACd,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAiB5E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AAI3F;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,8SAmBxE,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC,MAE/B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAyRnD,CAAC"}

package/dist/esm/interface/insert-cells-shift-right.js

@@ -1,5 +1,6 @@
 import { createArrayRange } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
+import { shiftChartsOnCellShift } from "../api/anchored-objects";
 import { collectUniqueDependentsForRange, processSideEffectDependentCells, } from "../api/dependency";
 import { createSheetCellIdentifier, expandRangesInFormula } from "../api/formula";
 import { cloneCellWithFormatting, createSheetDraft } from "../api/immer-utils";
@@ -15,7 +16,7 @@ import { SheetCell } from "../sheet-cell";
  * (torn merge/table/array, a non-blank cell pushed past `columnCount` — SHF-10) are decided by the
  * hook before this runs.
  */
-export const insertCellsShiftRight = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, }) => {
+export const insertCellsShiftRight = ({ rowCount, columnCount, locale, cellXfsRegistry, sharedStringRegistry, getActiveCell, getSelections, getDependents, getSheetName, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeCitations, onChangeCharts, }) => {
     return (sheetId, activeCell, selections) => {
         const saveHistory = createHistory();
         // We need to track this for history. Precedent cells
@@ -88,6 +89,14 @@ export const insertCellsShiftRight = ({ rowCount, columnCount, locale, cellXfsRe
             });
             return nextState;
         });
+        // Chart ranges wholly inside the shifted rows widen/shift like references; the frame stays put.
+        onChangeCharts?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                shiftChartsOnCellShift(draft, sheetId, "column", "insert", c1, count, { startIndex: r1, endIndex: r2 });
+            });
+            saveHistory({ charts: { patches, inversePatches } });
+            return nextState;
+        });
         // Sheet data
         onChangeSheetData?.((prevSheetData) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {

package/dist/esm/interface/insert-column.d.ts

@@ -2,6 +2,6 @@ import { Direction } from "@rowsncolumns/common-types";
 import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
 import type { UseOnInsertColumnProps } from "../hooks/use-on-insert-column";
 import type { UseOnTableProps } from "../hooks/use-on-table";
-export declare const insertColumn: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, maxColumnCount, tables, cellXfsRegistry, sharedStringRegistry, getSheetName, getDependents, getGraphNodes, getGraphNodesInSheet, getActiveCell, getSelections, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, onChangeCitations, onChangePivotTables, onChangeNamedRanges, onChangeEmbeds, onChangeCharts, onChangeProtectedRanges, generatedNames, }: UseOnInsertColumnProps<T, S>) => (sheetId: number, referenceColumnIndex: number, numColumns?: number) => void;
-export declare const insertTableColumn: <T extends CellData, S extends Sheet>({ tables, columnCount, rowCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, createHistory, onChangeTables, onChangeSheets, onChangeSheetData, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, getDependents, generatedNames, }: Pick<UseOnTableProps<T, S>, "tables" | "columnCount" | "rowCount" | "locale" | "cellXfsRegistry" | "sharedStringRegistry" | "createHistory" | "onChangeTables" | "onChangeSheets" | "onChangeSheetData" | "enqueueCalculation" | "enqueueStructureChange" | "enqueueGraphOperation" | "getDependents" | "getSheetName" | "generatedNames">) => (tableView: TableView, dimensionIndex: number, direction: Direction.Left | Direction.Right) => void;
+export declare const insertColumn: <T extends CellData, S extends Sheet>({ rowCount, columnCount, locale, maxColumnCount, tables, cellXfsRegistry, sharedStringRegistry, getSheetName, getDependents, getGraphNodes, getGraphNodesInSheet, getActiveCell, getSelections, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, onChangeCitations, onChangePivotTables, onChangeNamedRanges, onChangeEmbeds, onChangeSlicers, onChangeCharts, onChangeProtectedRanges, generatedNames, }: UseOnInsertColumnProps<T, S>) => (sheetId: number, referenceColumnIndex: number, numColumns?: number) => void;
+export declare const insertTableColumn: <T extends CellData, S extends Sheet>({ tables, columnCount, rowCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, createHistory, onChangeTables, onChangeSheets, onChangeSheetData, onChangeCharts, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, getDependents, generatedNames, }: Pick<UseOnTableProps<T, S>, "tables" | "columnCount" | "rowCount" | "locale" | "cellXfsRegistry" | "sharedStringRegistry" | "createHistory" | "onChangeTables" | "onChangeSheets" | "onChangeSheetData" | "onChangeCharts" | "enqueueCalculation" | "enqueueStructureChange" | "enqueueGraphOperation" | "getDependents" | "getSheetName" | "generatedNames">) => (tableView: TableView, dimensionIndex: number, direction: Direction.Left | Direction.Right, count?: number) => void;
 //# sourceMappingURL=insert-column.d.ts.map

package/dist/esm/interface/insert-column.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"insert-column.d.ts","sourceRoot":"","sources":["../../../interface/insert-column.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AA6B5E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,mgBA8B/D,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,MACrB,SAAS,MAAM,EAAE,sBAAsB,MAAM,EAAE,mBAAc,SAmZtE,CAAC;AAMF,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,qQAiBpE,IAAI,CACL,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,QAAQ,GACR,aAAa,GACb,UAAU,GACV,QAAQ,GACR,iBAAiB,GACjB,sBAAsB,GACtB,eAAe,GACf,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,oBAAoB,GACpB,wBAAwB,GACxB,uBAAuB,GACvB,eAAe,GACf,cAAc,GACd,gBAAgB,CACnB,MAEG,WAAW,SAAS,EACpB,gBAAgB,MAAM,EACtB,WAAW,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,KAAK,SA2V9C,CAAC"}
+{"version":3,"file":"insert-column.d.ts","sourceRoot":"","sources":["../../../interface/insert-column.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAoC5E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,ohBA+B/D,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,MACrB,SAAS,MAAM,EAAE,sBAAsB,MAAM,EAAE,mBAAc,SAobtE,CAAC;AAMF,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,qRAkBpE,IAAI,CACL,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,QAAQ,GACR,aAAa,GACb,UAAU,GACV,QAAQ,GACR,iBAAiB,GACjB,sBAAsB,GACtB,eAAe,GACf,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,gBAAgB,GAChB,oBAAoB,GACpB,wBAAwB,GACxB,uBAAuB,GACvB,eAAe,GACf,cAAc,GACd,gBAAgB,CACnB,MAEG,WAAW,SAAS,EACpB,gBAAgB,MAAM,EACtB,WAAW,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,KAAK,EAC3C,cAAS,SAwXZ,CAAC"}

package/dist/esm/interface/insert-column.js

@@ -1,19 +1,19 @@
 import { Direction } from "@rowsncolumns/common-types";
+import { isNil } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
-import { shiftChartsOnStructuralChange, shiftEmbedsOnStructuralChange, shiftProtectedRangesOnStructuralChange, } from "../api/anchored-objects";
+import { shiftChartsOnStructuralChange, shiftChartsOnTableEdit, shiftEmbedsOnStructuralChange, shiftSlicersOnStructuralChange, shiftProtectedRangesOnStructuralChange, tableBinding, } from "../api/anchored-objects";
 import { collectUniqueDependentsForRange, moveFormulaAtPosition, } from "../api/dependency";
 import { createSheetCellIdentifier, expandRangesInFormula, } from "../api/formula";
-import { cloneCellWithFormatting, createSheetDraft } from "../api/immer-utils";
+import { cloneCellWithFormatting, createSheetDraft, inheritedDimensionMetadata, } from "../api/immer-utils";
 import { expandMergesOnColumnInsert, moveMergedCells } from "../api/merges";
 import { updateNamedRangesOnStructuralChange, updatePrintSettingsOnStructuralChange, } from "../api/named-range-structural";
 import { shiftPivotsOnInsert } from "../api/pivot-range";
 import { updateRangedRulesOnStructuralChange } from "../api/range-rule-helpers";
 import { moveFilterView } from "../api/selection";
 import { updateFormulasForStructuralChange } from "../api/structural-formula-update";
-import { getGeneratedTableColumnName } from "../generated-names";
 import { getNextTableColumnName } from "../helpers";
 import { SheetCell } from "../sheet-cell";
-export const insertColumn = ({ rowCount, columnCount, locale, maxColumnCount, tables, cellXfsRegistry, sharedStringRegistry, getSheetName, getDependents, getGraphNodes, getGraphNodesInSheet, getActiveCell, getSelections, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, onChangeCitations, onChangePivotTables, onChangeNamedRanges, onChangeEmbeds, onChangeCharts, onChangeProtectedRanges, generatedNames, }) => {
+export const insertColumn = ({ rowCount, columnCount, locale, maxColumnCount, tables, cellXfsRegistry, sharedStringRegistry, getSheetName, getDependents, getGraphNodes, getGraphNodesInSheet, getActiveCell, getSelections, createHistory, enqueueGraphOperation, enqueueCalculation, enqueueStructureChange, onChangeSheetData, onChangeSheets, onChangeTables, onChangeDataValidations, onChangeConditionalFormats, onChangeCitations, onChangePivotTables, onChangeNamedRanges, onChangeEmbeds, onChangeSlicers, onChangeCharts, onChangeProtectedRanges, generatedNames, }) => {
     return (sheetId, referenceColumnIndex, numColumns = 1) => {
         if (numColumns <= 0)
             return;
@@ -127,6 +127,13 @@ export const insertColumn = ({ rowCount, columnCount, locale, maxColumnCount, ta
             saveHistory({ embeds: { patches, inversePatches } });
             return nextState;
         });
+        onChangeSlicers?.((prevSlicers) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSlicers, (draft) => {
+                shiftSlicersOnStructuralChange(draft, sheetId, "column", "insert", referenceColumnIndex, numColumns);
+            });
+            saveHistory({ slicers: { patches, inversePatches } });
+            return nextState;
+        });
         onChangeCharts?.((prevCharts) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
                 shiftChartsOnStructuralChange(draft, sheetId, "column", "insert", referenceColumnIndex, numColumns);
@@ -148,7 +155,11 @@ export const insertColumn = ({ rowCount, columnCount, locale, maxColumnCount, ta
                 if (!sheet)
                     return;
                 if (sheet.columnMetadata) {
-                    sheet.columnMetadata.splice(referenceColumnIndex, 0, ...Array.from({ length: numColumns }, () => null));
+                    // Excel "Format Same As Left" (FMT-02) covers the column width and
+                    // hidden state: the inserted columns inherit the metadata of the
+                    // column to the left (column A takes the pushed-right column's).
+                    const inherited = inheritedDimensionMetadata(sheet.columnMetadata, referenceColumnIndex);
+                    sheet.columnMetadata.splice(referenceColumnIndex, 0, ...Array.from({ length: numColumns }, () => inherited ? { ...inherited } : null));
                 }
                 if (sheet.basicFilter) {
                     const { startColumnIndex, endColumnIndex } = sheet.basicFilter.range;
@@ -211,42 +222,47 @@ export const insertColumn = ({ rowCount, columnCount, locale, maxColumnCount, ta
                     cellXfsRegistry,
                     sharedStringRegistry,
                 });
-                // Insert columns into each row's values array.
+                // Insert columns into each row's values array. Excel "Format Same
+                // As Left" (FMT-02): every new cell takes the formatting (never the
+                // value) of the cell to its LEFT; only an insert at column A seeds
+                // from the column being pushed right.
                 const sheetRows = draft[sheetId];
                 if (sheetRows) {
+                    const sourceColumnIndex = referenceColumnIndex > 1
+                        ? referenceColumnIndex - 1
+                        : referenceColumnIndex;
                     for (let rowIndex = 1; rowIndex < sheetRows.length; rowIndex++) {
                         const row = sheetRows[rowIndex];
                         if (!row?.values)
                             continue;
-                        if (row.values.length > referenceColumnIndex) {
-                            const formattingSource = row.values[referenceColumnIndex] ??
-                                row.values[referenceColumnIndex - 1] ??
-                                undefined;
-                            const newColumns = Array.from({ length: numColumns }, () => cloneCellWithFormatting(formattingSource));
-                            row.values.splice(referenceColumnIndex, 0, ...newColumns);
-                        }
+                        const formattingSource = row.values[sourceColumnIndex] ?? undefined;
+                        // Rows that end before the insertion point have nothing to
+                        // shift; they only grow when there is a format to inherit.
+                        const hasCellsToShift = row.values.length > referenceColumnIndex;
+                        if (!hasCellsToShift && isNil(formattingSource))
+                            continue;
+                        const newColumns = Array.from({ length: numColumns }, () => cloneCellWithFormatting(formattingSource));
+                        row.values.splice(referenceColumnIndex, 0, ...newColumns);
                     }
                 }
                 // Add table column headers for any table whose header row was
                 // affected by the insertion.
                 for (const { range, sheetId: tSheetId, headerRow, columns } of tables ?? []) {
                     if (tSheetId !== sheetId ||
-                        !headerRow ||
+                        headerRow === false ||
                         referenceColumnIndex <= range.startColumnIndex ||
                         referenceColumnIndex > range.endColumnIndex) {
                         continue;
                     }
                     const currentSheet = createSheetDraft(draft, tSheetId, range.startRowIndex);
+                    // The same first-free `ColumnN` walk as the table's `columns`
+                    // above: each generated name is reserved for the next one.
+                    const existingColumns = [...(columns || [])];
                     for (let i = 0; i < numColumns; i++) {
                         const currentColumnIndex = referenceColumnIndex + i;
                         const formattingSource = cloneCellWithFormatting(draft[tSheetId]?.[range.startRowIndex]?.values?.[currentColumnIndex]);
-                        const existingColumns = [...(columns || [])];
-                        for (let j = 0; j < i; j++) {
-                            existingColumns.push({
-                                name: getGeneratedTableColumnName(j + 1, generatedNames),
-                            });
-                        }
                         const columnName = getNextTableColumnName(existingColumns, generatedNames);
+                        existingColumns.push({ name: columnName });
                         const sheetCell = new SheetCell(tSheetId, {
                             rowIndex: range.startRowIndex,
                             columnIndex: currentColumnIndex,
@@ -274,10 +290,21 @@ export const insertColumn = ({ rowCount, columnCount, locale, maxColumnCount, ta
 // existing table view) and uses the legacy three-pass logic below. Worth
 // migrating to the shared helper later but leaving it untouched here to keep
 // scope tight.
-export const insertTableColumn = ({ tables, columnCount, rowCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, createHistory, onChangeTables, onChangeSheets, onChangeSheetData, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, getDependents, generatedNames, }) => {
-    return (tableView, dimensionIndex, direction) => {
+export const insertTableColumn = ({ tables, columnCount, rowCount, locale, cellXfsRegistry, sharedStringRegistry, getSheetName, createHistory, onChangeTables, onChangeSheets, onChangeSheetData, onChangeCharts, enqueueCalculation, enqueueStructureChange, enqueueGraphOperation, getDependents, generatedNames, }) => {
+    return (tableView, dimensionIndex, direction, count = 1) => {
         const { sheetId } = tableView;
-        const numColumns = 1;
+        const numColumns = Math.max(1, Math.floor(count));
+        // One generated name per inserted column, each unique against the
+        // table's columns and the names generated before it.
+        const newColumnNames = [];
+        {
+            const columns = [...(tableView.columns ?? [])];
+            for (let index = 0; index < numColumns; index++) {
+                const name = getNextTableColumnName(columns, generatedNames);
+                newColumnNames.push(name);
+                columns.push({ name });
+            }
+        }
         const saveHistory = createHistory();
         const recalcCells = new Map();
         let referenceColumnIndex = tableView.range.startColumnIndex + dimensionIndex;
@@ -309,8 +336,7 @@ export const insertTableColumn = ({ tables, columnCount, rowCount, locale, cellX
                     if (referenceColumnIndex >= table.range.startColumnIndex &&
                         referenceColumnIndex <= table.range.endColumnIndex + numColumns) {
                         const tableColumnIndex = referenceColumnIndex - table.range.startColumnIndex;
-                        const columnName = getNextTableColumnName(table.columns ?? undefined, generatedNames);
-                        table.columns?.splice(tableColumnIndex, 0, { name: columnName });
+                        table.columns?.splice(tableColumnIndex, 0, ...newColumnNames.map((name) => ({ name })));
                         if (table.filterSpecs) {
                             for (const spec of table.filterSpecs) {
                                 if (spec.columnIndex >= referenceColumnIndex) {
@@ -332,6 +358,15 @@ export const insertTableColumn = ({ tables, columnCount, rowCount, locale, cellX
             saveHistory({ tables: { patches, inversePatches } });
             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) gains the column with it.
+        onChangeCharts?.((prevCharts) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+                shiftChartsOnTableEdit(draft, sheetId, tableBinding(tableView), "column", "insert", referenceColumnIndex, numColumns);
+            });
+            saveHistory({ charts: { patches, inversePatches } });
+            return nextState;
+        });
         onChangeSheets?.((prevSheets) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
                 const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
@@ -501,14 +536,16 @@ export const insertTableColumn = ({ tables, columnCount, rowCount, locale, cellX
                     referenceColumnIndex >= range.startColumnIndex &&
                     referenceColumnIndex <= range.endColumnIndex + numColumns) {
                     const currentSheet = createSheetDraft(draft, sheetId, range.startRowIndex);
-                    const columnName = getNextTableColumnName(tableView.columns ?? undefined, generatedNames);
-                    const sheetCell = new SheetCell(sheetId, {
-                        rowIndex: range.startRowIndex,
-                        columnIndex: referenceColumnIndex,
-                    }, cloneCellWithFormatting(draft[sheetId]?.[range.startRowIndex]?.values?.[referenceColumnIndex]));
-                    sheetCell.setUserEnteredValue(columnName);
-                    currentSheet[range.startRowIndex].values[referenceColumnIndex] =
-                        sheetCell.getCellData();
+                    newColumnNames.forEach((columnName, index) => {
+                        const columnIndex = referenceColumnIndex + index;
+                        const sheetCell = new SheetCell(sheetId, {
+                            rowIndex: range.startRowIndex,
+                            columnIndex,
+                        }, cloneCellWithFormatting(draft[sheetId]?.[range.startRowIndex]?.values?.[columnIndex]));
+                        sheetCell.setUserEnteredValue(columnName);
+                        currentSheet[range.startRowIndex].values[columnIndex] =
+                            sheetCell.getCellData();
+                    });
                 }
             });
             saveHistory({