@rowsncolumns/spreadsheet-state 28.0.76 → 29.1.0

package/dist/esm/interface/apply-fill.js

@@ -4,10 +4,11 @@ import { produceWithPatches } from "immer";
 import { FILL_UNTOUCHED } from "../api/fill";
 import { createSheetCellIdentifier } from "../api/formula";
 import { createSheetDraft } from "../api/immer-utils";
+import { findAdjacentTable } from "../api/table";
 import { defaultCellCoords, defaultSheetId, SheetCell } from "../sheet-cell";
 import { getFillDirection } from "./../api/selection";
 import { collectDataValidationTarget, extendDataValidationRanges, } from "./data-validation-utils";
-export const applyFill = ({ locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getCellData, getEffectiveValue, getFormattedValue, getAutoFillValues, getSheetName, enqueueCalculation, enqueueStructureChange, onChangeSheetData, createHistory, onChangeDataValidations, getMerges, onFillMerges, }) => {
+export const applyFill = ({ locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getCellData, getEffectiveValue, getFormattedValue, getAutoFillValues, getSheetName, enqueueCalculation, enqueueStructureChange, onChangeSheetData, createHistory, onChangeDataValidations, getMerges, onFillMerges, tables, getUserEnteredValue, onChangeTableColumn, batchHistory = (action) => action(), autoExpandTables = true, }) => {
     return async (
     // Active sheet ID
     sheetId, 
@@ -25,7 +26,6 @@ export const applyFill = ({ locale, cellXfsRegistry, sharedStringRegistry, getDa
             ? selections
             : selectionFromActiveCell(activeCell);
         const selection = finalSelections[finalSelections.length - 1];
-        const saveHistory = createHistory();
         const { range: fillBounds } = fillSelection;
         const direction = getFillDirection(fillSelection, selection);
         // We need to track this for history. Precedent cells
@@ -79,6 +79,20 @@ export const applyFill = ({ locale, cellXfsRegistry, sharedStringRegistry, getDa
                         startColumnIndex: targetBounds.startColumnIndex,
                         endColumnIndex: selection.range.startColumnIndex - 1,
                     };
+        // Excel grows a table whose last row / last column the fill handle is dragged past: the
+        // filled cells directly below it (within its columns) or directly to its right (within its
+        // rows) join the table, exactly as if they had been typed. Resolved BEFORE the write, since the
+        // adjacency test reads the not-yet-filled cells.
+        const tableExpansion = autoExpandTables
+            ? findFillTableExpansion({
+                sheetId,
+                direction,
+                selection: selection.range,
+                filledArea,
+                tables,
+                getUserEnteredValue,
+            })
+            : undefined;
         // Sample cell
         const sheetCell = new SheetCell(defaultSheetId, defaultCellCoords, undefined, { locale, cellXfsRegistry, getDataValidationById });
         const getFillValue = (rowIndex, columnIndex) => {
@@ -137,104 +151,190 @@ export const applyFill = ({ locale, cellXfsRegistry, sharedStringRegistry, getDa
             startColumnIndex: fillBounds.startColumnIndex,
             endColumnIndex: fillBounds.endColumnIndex,
         });
-        // Copy sheetdata
-        onChangeSheetData?.((prevSheetData) => {
-            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
-                switch (direction) {
-                    case Direction.Down: {
-                        const start = selection.range.endRowIndex + 1;
-                        const end = targetBounds.endRowIndex;
-                        let counter = 0;
-                        for (let i = start; i <= end; i++) {
-                            let rowIndex = selection.range.startRowIndex + counter;
-                            if (rowIndex > selection.range.endRowIndex) {
-                                counter = 0;
-                                rowIndex = selection.range.startRowIndex;
-                            }
-                            const rollingRowIndex = i - start;
-                            for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
-                                const rollingColumnIndex = columnIndex - selection.range.startColumnIndex;
-                                writeFilledCell(draft, i, columnIndex, rollingRowIndex, rollingColumnIndex);
+        // The fill and the table growth it triggers undo as ONE step.
+        batchHistory(() => {
+            const saveHistory = createHistory();
+            // Copy sheetdata
+            onChangeSheetData?.((prevSheetData) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                    switch (direction) {
+                        case Direction.Down: {
+                            const start = selection.range.endRowIndex + 1;
+                            const end = targetBounds.endRowIndex;
+                            let counter = 0;
+                            for (let i = start; i <= end; i++) {
+                                let rowIndex = selection.range.startRowIndex + counter;
+                                if (rowIndex > selection.range.endRowIndex) {
+                                    counter = 0;
+                                    rowIndex = selection.range.startRowIndex;
+                                }
+                                const rollingRowIndex = i - start;
+                                for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                                    const rollingColumnIndex = columnIndex - selection.range.startColumnIndex;
+                                    writeFilledCell(draft, i, columnIndex, rollingRowIndex, rollingColumnIndex);
+                                }
+                                counter++;
                             }
-                            counter++;
+                            break;
                         }
-                        break;
-                    }
-                    case Direction.Up: {
-                        const start = selection.range.startRowIndex - 1;
-                        const end = targetBounds.startRowIndex;
-                        for (let i = start; i >= end; i--) {
-                            const rollingRowIndex = i - targetBounds.startRowIndex;
-                            for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
-                                const rollingColumnIndex = columnIndex - selection.range.startColumnIndex;
-                                writeFilledCell(draft, i, columnIndex, rollingRowIndex, rollingColumnIndex);
+                        case Direction.Up: {
+                            const start = selection.range.startRowIndex - 1;
+                            const end = targetBounds.startRowIndex;
+                            for (let i = start; i >= end; i--) {
+                                const rollingRowIndex = i - targetBounds.startRowIndex;
+                                for (let columnIndex = selection.range.startColumnIndex; columnIndex <= selection.range.endColumnIndex; columnIndex++) {
+                                    const rollingColumnIndex = columnIndex - selection.range.startColumnIndex;
+                                    writeFilledCell(draft, i, columnIndex, rollingRowIndex, rollingColumnIndex);
+                                }
                             }
+                            break;
                         }
-                        break;
-                    }
-                    case Direction.Right: {
-                        for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-                            const start = selection.range.endColumnIndex + 1;
-                            const end = targetBounds.endColumnIndex;
-                            let counter = 0;
-                            const rollingRowIndex = rowIndex - selection.range.startRowIndex;
-                            for (let j = start; j <= end; j++) {
-                                let columnIndex = selection.range.startColumnIndex + counter;
-                                if (columnIndex > selection.range.endColumnIndex) {
-                                    counter = 0;
-                                    columnIndex = selection.range.startColumnIndex;
+                        case Direction.Right: {
+                            for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                                const start = selection.range.endColumnIndex + 1;
+                                const end = targetBounds.endColumnIndex;
+                                let counter = 0;
+                                const rollingRowIndex = rowIndex - selection.range.startRowIndex;
+                                for (let j = start; j <= end; j++) {
+                                    let columnIndex = selection.range.startColumnIndex + counter;
+                                    if (columnIndex > selection.range.endColumnIndex) {
+                                        counter = 0;
+                                        columnIndex = selection.range.startColumnIndex;
+                                    }
+                                    const rollingColumnIndex = j - start;
+                                    writeFilledCell(draft, rowIndex, j, rollingRowIndex, rollingColumnIndex);
+                                    counter++;
                                 }
-                                const rollingColumnIndex = j - start;
-                                writeFilledCell(draft, rowIndex, j, rollingRowIndex, rollingColumnIndex);
-                                counter++;
                             }
+                            break;
                         }
-                        break;
-                    }
-                    case Direction.Left: {
-                        for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
-                            const start = selection.range.startColumnIndex - 1;
-                            const end = targetBounds.startColumnIndex;
-                            const rollingRowIndex = rowIndex - selection.range.startRowIndex;
-                            let counter = 0;
-                            for (let j = start; j >= end; j--) {
-                                let columnIndex = selection.range.endColumnIndex + counter;
-                                if (columnIndex < selection.range.startColumnIndex) {
-                                    counter = 0;
-                                    columnIndex = selection.range.endColumnIndex;
+                        case Direction.Left: {
+                            for (let rowIndex = selection.range.startRowIndex; rowIndex <= selection.range.endRowIndex; rowIndex++) {
+                                const start = selection.range.startColumnIndex - 1;
+                                const end = targetBounds.startColumnIndex;
+                                const rollingRowIndex = rowIndex - selection.range.startRowIndex;
+                                let counter = 0;
+                                for (let j = start; j >= end; j--) {
+                                    let columnIndex = selection.range.endColumnIndex + counter;
+                                    if (columnIndex < selection.range.startColumnIndex) {
+                                        counter = 0;
+                                        columnIndex = selection.range.endColumnIndex;
+                                    }
+                                    const rollingColumnIndex = j - targetBounds.startColumnIndex;
+                                    writeFilledCell(draft, rowIndex, j, rollingRowIndex, rollingColumnIndex);
+                                    counter--;
                                 }
-                                const rollingColumnIndex = j - targetBounds.startColumnIndex;
-                                writeFilledCell(draft, rowIndex, j, rollingRowIndex, rollingColumnIndex);
-                                counter--;
                             }
+                            break;
                         }
-                        break;
                     }
-                }
-                // Series-dialog Trend: the seed cells Excel replaces with the fitted values.
-                for (const seed of fillValues.seedCells ?? []) {
-                    writeCell(draft, seed.rowIndex, seed.columnIndex, seed.cell);
-                }
-            });
-            // Save history
-            saveHistory({
-                sheetData: { patches, inversePatches },
-                recalcCells: { undo: recalcCells, redo: recalcCells },
-                sheetId: { undo: sheetId, redo: sheetId },
-                activeCell: { undo: activeCell, redo: activeCell },
-                selections: {
-                    undo: fillableSelections ?? selections,
-                    redo: [{ ...fillSelection, range: targetBounds }],
-                },
+                    // Series-dialog Trend: the seed cells Excel replaces with the fitted values.
+                    for (const seed of fillValues.seedCells ?? []) {
+                        writeCell(draft, seed.rowIndex, seed.columnIndex, seed.cell);
+                    }
+                });
+                // Save history
+                saveHistory({
+                    sheetData: { patches, inversePatches },
+                    recalcCells: { undo: recalcCells, redo: recalcCells },
+                    sheetId: { undo: sheetId, redo: sheetId },
+                    activeCell: { undo: activeCell, redo: activeCell },
+                    selections: {
+                        undo: fillableSelections ?? selections,
+                        redo: [{ ...fillSelection, range: targetBounds }],
+                    },
+                });
+                extendDataValidationRanges(dataValidationTargets, onChangeDataValidations, saveHistory);
+                sharedStringRegistry?.getPatches(saveHistory);
+                return nextState;
             });
-            extendDataValidationRanges(dataValidationTargets, onChangeDataValidations, saveHistory);
-            sharedStringRegistry?.getPatches(saveHistory);
-            return nextState;
+            // A merged seed replicates its block shape over the filled area (Excel).
+            const fillMerges = fillValues.fillMerges;
+            if (fillMerges?.length) {
+                onFillMerges?.(sheetId, activeCell, filledArea, fillMerges, targetBounds);
+            }
+            if (tableExpansion) {
+                const { table, coords, isRowExpansion, isColumnExpansion, range } = tableExpansion;
+                // The header cell of each new column names it (a rightward fill past the table grows it by
+                // every filled column); every other expansion needs no value.
+                const headerNameAt = (columnIndex) => {
+                    const headerValue = isColumnExpansion && coords.rowIndex === table.range.startRowIndex
+                        ? fillValues[coords.rowIndex - selection.range.startRowIndex]?.[columnIndex - (selection.range.endColumnIndex + 1)]
+                        : undefined;
+                    const headerName = headerValue === undefined || headerValue === FILL_UNTOUCHED
+                        ? undefined
+                        : typeof headerValue === "object"
+                            ? new SheetCell(sheetId, { rowIndex: coords.rowIndex, columnIndex }, headerValue, { locale }).getUserEnteredValue()
+                            : headerValue;
+                    return typeof headerName === "string" || typeof headerName === "boolean"
+                        ? headerName
+                        : typeof headerName === "number"
+                            ? String(headerName)
+                            : undefined;
+                };
+                const headerValues = [];
+                for (let columnIndex = coords.columnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                    headerValues.push(headerNameAt(columnIndex));
+                }
+                onChangeTableColumn?.(sheetId, coords, headerValues[0], table, isRowExpansion, isColumnExpansion, range, headerValues);
+            }
         });
-        // A merged seed replicates its block shape over the filled area (Excel).
-        const fillMerges = fillValues.fillMerges;
-        if (fillMerges?.length) {
-            onFillMerges?.(sheetId, activeCell, filledArea, fillMerges, targetBounds);
-        }
     };
 };
+/**
+ * The table a fill grows, if any: for a downward fill the first filled row is the row right after a
+ * table (within its columns); for a rightward fill the first filled column is the column right after
+ * a table (within its rows). The fill may start inside the table — a drag from any body row past the
+ * last row grows it from that last row on. Adjacency, the empty-line rule and the totals-row rule
+ * (a table with a totals row never auto-grows) are `findAdjacentTable`'s, shared with typing and
+ * paste. Fills upward / leftward never grow a table.
+ */
+export const findFillTableExpansion = ({ sheetId, direction, selection, filledArea, tables, getUserEnteredValue, }) => {
+    if (!tables?.length || !getUserEnteredValue) {
+        return undefined;
+    }
+    if (direction !== Direction.Down && direction !== Direction.Right) {
+        return undefined;
+    }
+    for (const table of tables) {
+        if (table.sheetId !== sheetId) {
+            continue;
+        }
+        const coords = direction === Direction.Down
+            ? table.range.endRowIndex + 1 >= filledArea.startRowIndex &&
+                table.range.endRowIndex + 1 <= filledArea.endRowIndex &&
+                selection.startColumnIndex >= table.range.startColumnIndex &&
+                selection.startColumnIndex <= table.range.endColumnIndex
+                ? {
+                    rowIndex: table.range.endRowIndex + 1,
+                    columnIndex: selection.startColumnIndex,
+                }
+                : undefined
+            : table.range.endColumnIndex + 1 >= filledArea.startColumnIndex &&
+                table.range.endColumnIndex + 1 <= filledArea.endColumnIndex &&
+                selection.startRowIndex >= table.range.startRowIndex &&
+                selection.startRowIndex <= table.range.endRowIndex
+                ? {
+                    rowIndex: selection.startRowIndex,
+                    columnIndex: table.range.endColumnIndex + 1,
+                }
+                : undefined;
+        if (!coords) {
+            continue;
+        }
+        const [adjacentTable, isRowExpansion, isColumnExpansion] = findAdjacentTable(sheetId, coords, tables, getUserEnteredValue);
+        if (!adjacentTable || !(isRowExpansion || isColumnExpansion)) {
+            continue;
+        }
+        return {
+            table: adjacentTable,
+            coords,
+            isRowExpansion,
+            isColumnExpansion,
+            range: direction === Direction.Down
+                ? { ...filledArea, startRowIndex: coords.rowIndex }
+                : { ...filledArea, startColumnIndex: coords.columnIndex },
+        };
+    }
+    return undefined;
+};

package/dist/esm/interface/change-batch.d.ts

@@ -35,5 +35,5 @@ export interface ChangeBatchOptions {
      */
     disableTypeInference?: boolean;
 }
-export declare const changeBatch: <T extends CellData, K extends CellFormat, S extends Sheet = Sheet>({ createHistory, enqueueCalculation, onChangeSheetData, onChangeSheets, onChangeTableColumn, onChangeCalculatedColumn, tokenizer, getEffectiveValuesFromRange, locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getFormattedValue, getUserEnteredValue, getCellDimensions, getRowHeight, isMergedCell, tables, onChangeCitations, }: UseOnChangeBatchProps<T, S>) => (sheetId: number, ranges: GridRange[] | GridRange, values: (string | boolean | number | undefined | null)[][] | string | boolean | number | undefined | null, formatting?: (K | undefined | null)[][] | K | null | undefined, citations?: (string | undefined | null)[][] | string | null | undefined, options?: ChangeBatchOptions) => void;
+export declare const changeBatch: <T extends CellData, K extends CellFormat, S extends Sheet = Sheet>({ createHistory, enqueueCalculation, enqueueGraphOperation, onChangeSheetData, onChangeSheets, onChangeTables, onChangeTableColumn, onChangeCalculatedColumn, tokenizer, getEffectiveValuesFromRange, locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getFormattedValue, getUserEnteredValue, getCellDimensions, getRowHeight, isMergedCell, tables, onChangeCitations, autoExpandTables, generatedNames, }: UseOnChangeBatchProps<T, S>) => (sheetId: number, ranges: GridRange[] | GridRange, values: (string | boolean | number | undefined | null)[][] | string | boolean | number | undefined | null, formatting?: (K | undefined | null)[][] | K | null | undefined, citations?: (string | undefined | null)[][] | string | null | undefined, options?: ChangeBatchOptions) => void;
 //# sourceMappingURL=change-batch.d.ts.map

package/dist/esm/interface/change-batch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"change-batch.d.ts","sourceRoot":"","sources":["../../../interface/change-batch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EACV,QAAQ,EAER,KAAK,EAEN,MAAM,2BAA2B,CAAC;AAiBnC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAI1E,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,eAAO,MAAM,WAAW,GACtB,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,KAAK,GAAG,KAAK,EACvB,0VAoBC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,MAE1B,SAAS,MAAM,EACf,QAAQ,SAAS,EAAE,GAAG,SAAS,EAC/B,QACI,CAAC,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,GAClD,MAAM,GACN,OAAO,GACP,MAAM,GACN,SAAS,GACT,IAAI,EACR,aAAa,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,IAAI,GAAG,SAAS,EAC9D,YAAY,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EACvE,UAAS,kBAAuB,SA2ZnC,CAAC"}
+{"version":3,"file":"change-batch.d.ts","sourceRoot":"","sources":["../../../interface/change-batch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EACV,QAAQ,EAER,KAAK,EAEN,MAAM,2BAA2B,CAAC;AAkBnC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAK1E,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,eAAO,MAAM,WAAW,GACtB,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,KAAK,GAAG,KAAK,EACvB,maAwBC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,MAE1B,SAAS,MAAM,EACf,QAAQ,SAAS,EAAE,GAAG,SAAS,EAC/B,QACI,CAAC,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,GAClD,MAAM,GACN,OAAO,GACP,MAAM,GACN,SAAS,GACT,IAAI,EACR,aAAa,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,IAAI,GAAG,SAAS,EAC9D,YAAY,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EACvE,UAAS,kBAAuB,SAggBnC,CAAC"}

package/dist/esm/interface/change-batch.js

@@ -3,9 +3,11 @@ import { alignmentImpliesWrap, isNil } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
 import { createSheetCellIdentifier } from "../api/formula";
 import { createSheetDraft } from "../api/immer-utils";
+import { renameHeaderCellsInFormulas } from "../api/structural-table-refs";
 import { findActiveTableWithinCell, findAdjacentTable, removeTableName, } from "../api/table";
+import { planHeaderCellRenames } from "./change-table-column";
 import { SheetCell } from "../sheet-cell";
-export const changeBatch = ({ createHistory, enqueueCalculation, onChangeSheetData, onChangeSheets, onChangeTableColumn, onChangeCalculatedColumn, tokenizer, getEffectiveValuesFromRange, locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getFormattedValue, getUserEnteredValue, getCellDimensions, getRowHeight, isMergedCell, tables, onChangeCitations, }) => {
+export const changeBatch = ({ createHistory, enqueueCalculation, enqueueGraphOperation, onChangeSheetData, onChangeSheets, onChangeTables, onChangeTableColumn, onChangeCalculatedColumn, tokenizer, getEffectiveValuesFromRange, locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getFormattedValue, getUserEnteredValue, getCellDimensions, getRowHeight, isMergedCell, tables, onChangeCitations, autoExpandTables = true, generatedNames, }) => {
     return (sheetId, ranges, values, formatting, citations, options = {}) => {
         const { enableEvaluation = true, enableHistory = true, formattingOnly = false, disableTypeInference = false, } = options;
         const saveHistory = enableHistory ? createHistory() : () => undefined;
@@ -35,12 +37,42 @@ export const changeBatch = ({ createHistory, enqueueCalculation, onChangeSheetDa
         let isColumnExpansion = false;
         let currentTable;
         if (!formattingOnly && tables?.length && coords) {
-            [adjacentTable, isRowExpansion, isColumnExpansion] = findAdjacentTable(sheetId, coords, tables, getUserEnteredValue);
+            if (autoExpandTables) {
+                [adjacentTable, isRowExpansion, isColumnExpansion] = findAdjacentTable(sheetId, coords, tables, getUserEnteredValue);
+            }
             currentTable =
                 isColumnExpansion && adjacentTable
                     ? adjacentTable
                     : findActiveTableWithinCell(sheetId, coords, tables);
         }
+        // Header cells of existing tables the batch lands on take the typed-header
+        // rule: text, de-duplicated, structured references following.
+        const headerRenames = !formattingOnly && tables?.length
+            ? planHeaderCellRenames({
+                sheetId,
+                tables,
+                generatedNames,
+                cells: finalRanges.flatMap((range) => {
+                    const cells = [];
+                    for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                        for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                            cells.push({
+                                rowIndex,
+                                columnIndex,
+                                value: Array.isArray(values)
+                                    ? values[rowIndex - range.startRowIndex]?.[columnIndex - range.startColumnIndex]
+                                    : values,
+                            });
+                        }
+                    }
+                    return cells;
+                }),
+            })
+            : [];
+        const headerRenameAt = new Map(headerRenames.map((rename) => [
+            `${rename.rowIndex}:${rename.columnIndex}`,
+            rename,
+        ]));
         // Update sheet data
         onChangeSheetData?.((prevSheetData) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
@@ -68,7 +100,14 @@ export const changeBatch = ({ createHistory, enqueueCalculation, onChangeSheetDa
                             });
                             // Set text value of the cell
                             // Skip value changes if formattingOnly is true
-                            if (!formattingOnly) {
+                            const headerRename = headerRenameAt.get(`${rowIndex}:${columnIndex}`);
+                            if (headerRename) {
+                                // A table header cell holds its column name as text.
+                                sheetCell.setUserEnteredValue(headerRename.newName, undefined, {
+                                    disableTypeInference: true,
+                                });
+                            }
+                            else if (!formattingOnly) {
                                 if (isNil(value)) {
                                     sheetCell.deleteContents();
                                 }
@@ -133,6 +172,16 @@ export const changeBatch = ({ createHistory, enqueueCalculation, onChangeSheetDa
                         }
                     }
                 }
+                renameHeaderCellsInFormulas({
+                    draft,
+                    headerRenames,
+                    enqueueCalculation,
+                    enqueueGraphOperation,
+                    recalcCells,
+                    locale,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
             });
             // Save history
             saveHistory({
@@ -144,8 +193,40 @@ export const changeBatch = ({ createHistory, enqueueCalculation, onChangeSheetDa
                 sheetId: { undo: sheetId, redo: sheetId },
                 recalcCells: { undo: recalcCells, redo: recalcCells },
             });
+            // Flush the registries HERE, after this updater interned the batch's
+            // strings and formats. When `onChangeSheetData` is a React state setter
+            // and the slice already has an update queued in this tick (a row insert
+            // composed with this write — Data → Subtotal, Insert Cut Cells, agent
+            // streams), React defers the updater to the render instead of running it
+            // eagerly; a flush issued after the dispatch would run before any string
+            // was minted, find the registries empty, and leave every text cell of the
+            // batch pointing at an `ss` id no table holds — blank locally and after
+            // reload. Inside the updater the strings are always there, and the
+            // patches land on this same history pointer.
+            cellXfsRegistry?.getPatches(saveHistory);
+            sharedStringRegistry?.getPatches(saveHistory);
             return nextState;
         });
+        if (headerRenames.length) {
+            onChangeTables?.((prevTables) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                    for (const { table, dimensionIndex, newName } of headerRenames) {
+                        const current = draft.find((candidate) => candidate.id === table.id);
+                        if (!current)
+                            continue;
+                        current.columns ??= [];
+                        if (current.columns[dimensionIndex]) {
+                            current.columns[dimensionIndex].name = newName;
+                        }
+                        else {
+                            current.columns[dimensionIndex] = { name: newName };
+                        }
+                    }
+                });
+                saveHistory({ tables: { patches, inversePatches } });
+                return nextState;
+            });
+        }
         // Update sheet rowCount and columnCount if values were added beyond current bounds
         onChangeSheets?.((prevSheets) => {
             const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
@@ -163,10 +244,6 @@ export const changeBatch = ({ createHistory, enqueueCalculation, onChangeSheetDa
             });
             return nextState;
         });
-        // Save cellXfs
-        cellXfsRegistry?.getPatches(saveHistory);
-        // Save shared strings patches
-        sharedStringRegistry?.getPatches(saveHistory);
         // Update row heights when text format or wrapping changes (Excel's
         // justify / distributed alignments wrap implicitly)
         const affectsRowHeight = (cellFormat) => !!cellFormat &&
@@ -270,7 +347,11 @@ export const changeBatch = ({ createHistory, enqueueCalculation, onChangeSheetDa
         }
         if (!formattingOnly && tables?.length && primaryRange && coords) {
             if (onChangeTableColumn) {
-                onChangeTableColumn(sheetId, coords, value, adjacentTable, isRowExpansion, isColumnExpansion, primaryRange);
+                // A block written right of the table names every new column from its header cell.
+                const headerValues = isColumnExpansion && Array.isArray(values)
+                    ? values[0]?.map((cell) => cell ?? undefined)
+                    : undefined;
+                onChangeTableColumn(sheetId, coords, value, adjacentTable, isRowExpansion, isColumnExpansion, primaryRange, headerValues);
             }
             if (onChangeCalculatedColumn) {
                 const isAdjacentColumn = currentTable &&

package/dist/esm/interface/change-calculated-column.d.ts

@@ -1,5 +1,9 @@
 import type { CellInterface } from "@rowsncolumns/common-types";
-import type { CellData, TableView } from "@rowsncolumns/spreadsheet";
+import type { CalculatedColumnFill, CellData, TableView } from "@rowsncolumns/spreadsheet";
 import type { UseOnChangeCalculatedColumnProps } from "../hooks/use-on-change-calculated-column";
-export declare const changeCalculatedColumn: <T extends CellData>({ locale, sharedStringRegistry, cellXfsRegistry, onChangeTables, onChangeSheetData, getUserEnteredValue, getSheetName, createHistory, enqueueCalculation, onCommand, }: UseOnChangeCalculatedColumnProps<T>) => (sheetId: number, coords: CellInterface, value: string | boolean | undefined, currentTable: TableView | undefined) => void;
+export declare const changeCalculatedColumn: <T extends CellData>({ locale, sharedStringRegistry, cellXfsRegistry, onChangeTables, onChangeSheetData, getUserEnteredValue, getSheetName, createHistory, enqueueCalculation, onCommand, autoCalculatedColumns, }: UseOnChangeCalculatedColumnProps<T>) => (sheetId: number, coords: CellInterface, value: string | boolean | undefined, currentTable: TableView | undefined, options?: ChangeCalculatedColumnOptions) => CalculatedColumnFill | undefined;
+export type ChangeCalculatedColumnOptions = {
+    /** Fill the column even over cells that differ from the typed formula (the smart tag's "Overwrite all cells in this column with this formula"). */
+    force?: boolean;
+};
 //# sourceMappingURL=change-calculated-column.d.ts.map

package/dist/esm/interface/change-calculated-column.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"change-calculated-column.d.ts","sourceRoot":"","sources":["../../../interface/change-calculated-column.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,4BAA4B,CAAC;AAC3E,OAAO,KAAK,EAEV,QAAQ,EACR,SAAS,EACV,MAAM,2BAA2B,CAAC;AAOnC,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,0CAA0C,CAAC;AAIjG,eAAO,MAAM,sBAAsB,GAChC,CAAC,SAAS,QAAQ,EAAE,wKAWlB,gCAAgC,CAAC,CAAC,CAAC,MAEpC,SAAS,MAAM,EACf,QAAQ,aAAa,EACrB,OAAO,MAAM,GAAG,OAAO,GAAG,SAAS,EACnC,cAAc,SAAS,GAAG,SAAS,SAuKpC,CAAC"}
+{"version":3,"file":"change-calculated-column.d.ts","sourceRoot":"","sources":["../../../interface/change-calculated-column.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,4BAA4B,CAAC;AAC3E,OAAO,KAAK,EAEV,oBAAoB,EAEpB,QAAQ,EACR,SAAS,EACV,MAAM,2BAA2B,CAAC;AAOnC,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,0CAA0C,CAAC;AAQjG,eAAO,MAAM,sBAAsB,GAChC,CAAC,SAAS,QAAQ,EAAE,+LAYlB,gCAAgC,CAAC,CAAC,CAAC,MAEpC,SAAS,MAAM,EACf,QAAQ,aAAa,EACrB,OAAO,MAAM,GAAG,OAAO,GAAG,SAAS,EACnC,cAAc,SAAS,GAAG,SAAS,EACnC,UAAU,6BAA6B,KACtC,oBAAoB,GAAG,SA8PzB,CAAC;AAEJ,MAAM,MAAM,6BAA6B,GAAG;IAC1C,mJAAmJ;IACnJ,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC"}