@rowsncolumns/spreadsheet-state 29.0.0 → 29.1.1

package/dist/esm/hooks/use-on-table.js

@@ -1,22 +1,23 @@
-import { areaIntersects, selectionFromActiveCell } from "@rowsncolumns/grid";
+import { areaIntersects, isAreasEqual, selectionFromActiveCell, } from "@rowsncolumns/grid";
 import { isCellWithinBounds } from "@rowsncolumns/grid";
-import { uuid } from "@rowsncolumns/utils";
+import { tableIdDuplicateMessage, uuid, validateTableName, } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
 import { useCallback } from "react";
-import { getConfictingTable } from "../helpers";
-import { createTable } from "../interface/create-table";
+import { getShiftCellsRefusal, getTableEditRefusal, getTableRangeRefusal, shiftBand, } from "../api/structural-guards";
+import { createTable, resolveCreateTableRange, } from "../interface/create-table";
 import { deleteTableColumn } from "../interface/delete-table-column";
 import { insertTableColumn } from "../interface/insert-column";
 import { removeTable } from "../interface/remove-table";
-import { updateTable } from "../interface/update-table";
+import { tableHeaderRowAboveIsFree, tableRowHasContent, } from "../interface/table-utils";
+import { resolveUpdatedTableRange, updateTable, } from "../interface/update-table";
 import { useShowError } from "./../atoms/error-state.atom";
 import { SHEET_PROTECTION_ERROR_TITLE, useCanPerformSheetAction, } from "./use-can-edit-cellrange";
 import { getHiddenRowsFromFilterSpecs } from "./use-on-filter-table";
-export const useOnTable = ({ locale, cellXfsRegistry, sharedStringRegistry, rowCount, columnCount, tables, basicFilter, theme: spreadsheetTheme, idCreationStrategy, enqueueCalculation, enqueueStructureChange, createHistory, onChangeSheets, onChangeTables, onChangeSheetData, getFormattedValue, getEffectiveValue, onRequestCalculate, getDependents, enqueueGraphOperation, getContentfulRangeAroundCell, getSheetName, onCommand, generatedNames, }) => {
+export const useOnTable = ({ locale, batchHistory, sheetData, sheets, getActiveCell, getSelections, onChangeCitations, onChangeCharts, cellXfsRegistry, sharedStringRegistry, rowCount, columnCount, tables, namedRanges, basicFilter, theme: spreadsheetTheme, idCreationStrategy, enqueueCalculation, enqueueStructureChange, createHistory, onChangeSheets, onChangeTables, onChangeSheetData, getFormattedValue, getEffectiveValue, onRequestCalculate, getDependents, getGraphNodes, getBandedCells, enqueueGraphOperation, getContentfulRangeAroundCell, getSheetName, onCommand, generatedNames, getArrayRanges, onChangeDataValidations, onChangeConditionalFormats, }) => {
     const showError = useShowError();
     const canPerformSheetAction = useCanPerformSheetAction();
     // Create a new table
-    const onCreateTable = useCallback((sheetId, activeCell, selections, tableSpec, theme, bandedRange) => {
+    const onCreateTable = useCallback((sheetId, activeCell, selections, tableSpec, theme, bandedRange, options) => {
         // Validate
         const lastSelection = selections?.[selections.length - 1];
         // Check basicFilter intersection
@@ -28,31 +29,90 @@ export const useOnTable = ({ locale, cellXfsRegistry, sharedStringRegistry, rowC
             });
             return;
         }
-        // Check if this selection intersects
-        const tableIntersects = tables?.find((table) => areaIntersects(table.range, lastSelection?.range) &&
-            table.sheetId === sheetId);
-        if (tableIntersects) {
+        if (tableSpec?.id !== undefined &&
+            tables?.some((table) => table.id === tableSpec.id)) {
             showError({
                 title: "Error",
-                message: "You cannot create a table that spans another table.",
+                message: tableIdDuplicateMessage(tableSpec.id),
             });
             return;
         }
-        createTable({
+        const titleError = tableSpec?.title !== undefined
+            ? validateTableName(tableSpec.title, tables?.map((table) => table.title), namedRanges?.map((namedRange) => namedRange.name))
+            : undefined;
+        if (titleError) {
+            showError({ title: "Error", message: titleError });
+            return;
+        }
+        const dataRange = resolveCreateTableRange({
+            sheetId,
+            activeCell,
+            selections,
+            tableSpec,
+            getContentfulRangeAroundCell,
+        });
+        const merges = sheets?.find((sheet) => sheet.sheetId === sheetId)?.merges;
+        // "My table has headers" unchecked: the header row is inserted by shifting the range's
+        // columns down one row — refused (Excel) when that would tear a merge, table or array or
+        // push a non-blank cell off the sheet.
+        const insertsHeaderRow = options?.hasHeaders === false;
+        const headerRowInsert = insertsHeaderRow
+            ? { ...dataRange, endRowIndex: dataRange.startRowIndex }
+            : undefined;
+        if (headerRowInsert) {
+            const refusal = getShiftCellsRefusal({
+                direction: "down",
+                range: headerRowInsert,
+                sheetId,
+                rows: sheetData?.[sheetId],
+                rowCount,
+                merges,
+                tables,
+            });
+            if (refusal) {
+                showError({ title: refusal.title, message: refusal.message });
+                return;
+            }
+        }
+        // Excel: a table cannot overlap another table or cover merged cells (T-07) — judged on the
+        // range the table will cover; with an inserted header row, tables and merges wholly inside
+        // the shifted columns have moved down one row by then.
+        const rangeRefusal = getTableRangeRefusal({
+            sheetId,
+            range: headerRowInsert
+                ? { ...dataRange, endRowIndex: dataRange.endRowIndex + 1 }
+                : dataRange,
+            tables,
+            merges,
+            insertedRows: headerRowInsert
+                ? { band: shiftBand("down", headerRowInsert), count: 1 }
+                : undefined,
+        });
+        if (rangeRefusal) {
+            showError(rangeRefusal);
+            return;
+        }
+        const create = () => createTable({
             locale,
             rowCount,
             columnCount,
             tables,
+            namedRanges,
             basicFilter,
             cellXfsRegistry,
             sharedStringRegistry,
             theme: spreadsheetTheme,
             idCreationStrategy,
             enqueueCalculation,
+            enqueueStructureChange,
             createHistory,
             onChangeSheets,
             onChangeTables,
             onChangeSheetData,
+            onChangeCitations,
+            onChangeCharts,
+            getActiveCell,
+            getSelections,
             getFormattedValue,
             getEffectiveValue,
             onRequestCalculate,
@@ -61,7 +121,13 @@ export const useOnTable = ({ locale, cellXfsRegistry, sharedStringRegistry, rowC
             getContentfulRangeAroundCell,
             getSheetName,
             generatedNames,
-        })(sheetId, activeCell, selections, tableSpec, theme, bandedRange);
+        })(sheetId, activeCell, selections, tableSpec, theme, bandedRange, options);
+        if (insertsHeaderRow && batchHistory) {
+            batchHistory(create);
+        }
+        else {
+            create();
+        }
         onCommand?.({
             command: "create-table",
             sheetId,
@@ -70,10 +136,20 @@ export const useOnTable = ({ locale, cellXfsRegistry, sharedStringRegistry, rowC
             tableSpec,
             theme,
             bandedRange,
+            hasHeaders: options?.hasHeaders,
         });
     }, [
         locale,
+        batchHistory,
+        sheetData,
+        sheets,
+        getActiveCell,
+        getSelections,
+        onChangeCitations,
+        onChangeCharts,
+        enqueueStructureChange,
         tables,
+        namedRanges,
         basicFilter,
         columnCount,
         cellXfsRegistry,
@@ -99,33 +175,133 @@ export const useOnTable = ({ locale, cellXfsRegistry, sharedStringRegistry, rowC
     // Remove table
     const onRemoveTable = useCallback((tableView) => {
         removeTable({
+            locale,
+            cellXfsRegistry,
+            sharedStringRegistry,
+            getSheetName,
             onChangeTables,
             onChangeSheets,
+            onChangeSheetData,
             createHistory,
             getDependents,
+            getGraphNodes,
+            getBandedCells,
             enqueueCalculation,
+            enqueueGraphOperation,
         })(tableView);
         onCommand?.({ command: "remove-table", tableView });
     }, [
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getSheetName,
         onChangeTables,
         getDependents,
+        getGraphNodes,
+        getBandedCells,
         enqueueCalculation,
+        enqueueGraphOperation,
         onChangeSheets,
+        onChangeSheetData,
         createHistory,
         onCommand,
     ]);
     // Update a table
     const onUpdateTable = useCallback((sheetId, tableId, updatedTable) => {
+        const table = tables?.find((table) => table.id === tableId);
+        const titleError = table &&
+            updatedTable.title !== undefined &&
+            updatedTable.title !== table.title
+            ? validateTableName(updatedTable.title, tables?.filter((t) => t.id !== tableId).map((t) => t.title), namedRanges?.map((namedRange) => namedRange.name))
+            : undefined;
+        if (titleError) {
+            showError({ title: "Error", message: titleError });
+            return;
+        }
+        // Switching Total Row on over an occupied row shifts the table's column
+        // band down (`updateTable`); Excel refuses that shift when it would tear
+        // another table, a merge or an array, or push content off the sheet.
+        const totalRowShift = table &&
+            !table.totalRow &&
+            updatedTable.totalRow === true &&
+            tableRowHasContent(sheetData?.[sheetId], table.range.endRowIndex + 1, table.range.startColumnIndex, table.range.endColumnIndex)
+            ? {
+                startRowIndex: table.range.endRowIndex + 1,
+                endRowIndex: table.range.endRowIndex + 1,
+                startColumnIndex: table.range.startColumnIndex,
+                endColumnIndex: table.range.endColumnIndex,
+            }
+            : undefined;
+        const merges = sheets?.find((sheet) => sheet.sheetId === sheetId)?.merges;
+        if (totalRowShift) {
+            const refusal = getShiftCellsRefusal({
+                direction: "down",
+                range: totalRowShift,
+                sheetId,
+                rows: sheetData?.[sheetId],
+                rowCount,
+                merges,
+                tables,
+                arrayRanges: getArrayRanges?.(sheetId),
+            });
+            if (refusal) {
+                showError({ title: refusal.title, message: refusal.message });
+                return;
+            }
+        }
+        // Excel: the table's new range (an edited range, a total row switched on, or a header row
+        // re-added above the data) cannot overlap another table or cover merged cells (T-07). An
+        // unchanged range is not re-judged; with the occupied-row shift above, tables and merges
+        // wholly inside the shifted band are judged one row lower.
+        const nextRange = table &&
+            resolveUpdatedTableRange(table, updatedTable, {
+                headerRowAboveIsFree: tableHeaderRowAboveIsFree({
+                    sheetId,
+                    table,
+                    sheetData,
+                    tables,
+                }),
+            });
+        const rangeRefusal = table && nextRange && !isAreasEqual(nextRange, table.range)
+            ? getTableRangeRefusal({
+                sheetId,
+                range: nextRange,
+                tables,
+                merges,
+                excludeTableId: tableId,
+                insertedRows: totalRowShift
+                    ? { band: shiftBand("down", totalRowShift), count: 1 }
+                    : undefined,
+            })
+            : undefined;
+        if (rangeRefusal) {
+            showError(rangeRefusal);
+            return;
+        }
         updateTable({
             locale,
             enqueueCalculation,
+            enqueueGraphOperation,
+            getGraphNodes,
             createHistory,
             onChangeTables,
             onChangeSheetData,
             getFormattedValue,
             getDependents,
             tables,
+            namedRanges,
             generatedNames,
+            sheetData,
+            rowCount,
+            columnCount,
+            cellXfsRegistry,
+            sharedStringRegistry,
+            getSheetName,
+            getActiveCell,
+            enqueueStructureChange,
+            onChangeSheets,
+            onChangeDataValidations,
+            onChangeConditionalFormats,
         })(sheetId, tableId, updatedTable);
         onCommand?.({
             command: "update-table",
@@ -136,14 +312,33 @@ export const useOnTable = ({ locale, cellXfsRegistry, sharedStringRegistry, rowC
     }, [
         locale,
         tables,
+        namedRanges,
+        sheets,
+        showError,
         createHistory,
         getFormattedValue,
         onChangeTables,
         onChangeSheetData,
         enqueueCalculation,
+        enqueueGraphOperation,
+        getGraphNodes,
         getDependents,
         onCommand,
         generatedNames,
+        sheetData,
+        sheets,
+        getArrayRanges,
+        rowCount,
+        columnCount,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getSheetName,
+        getActiveCell,
+        enqueueGraphOperation,
+        enqueueStructureChange,
+        onChangeSheets,
+        onChangeDataValidations,
+        onChangeConditionalFormats,
     ]);
     /**
      * Create a basic filter
@@ -271,12 +466,16 @@ export const useOnTable = ({ locale, cellXfsRegistry, sharedStringRegistry, rowC
     /**
      * Insert table column
      */
-    const onInsertTableColumn = useCallback((tableView, dimensionIndex, direction) => {
-        // Validate
-        if (getConfictingTable(tables, tableView)) {
-            showError({
-                message: "You cannot insert or delete cells over part of a table.",
-            });
+    const onInsertTableColumn = useCallback((tableView, dimensionIndex, direction, count) => {
+        // Excel refuses a table-column insert whose shifted band would tear another table (T-47).
+        const refusal = getTableEditRefusal({
+            sheetId: tableView.sheetId,
+            table: tableView,
+            axis: "column",
+            tables,
+        });
+        if (refusal) {
+            showError({ title: refusal.title, message: refusal.message });
             return;
         }
         insertTableColumn({
@@ -291,17 +490,19 @@ export const useOnTable = ({ locale, cellXfsRegistry, sharedStringRegistry, rowC
             onChangeTables,
             onChangeSheets,
             onChangeSheetData,
+            onChangeCharts,
             enqueueCalculation,
             enqueueStructureChange,
             enqueueGraphOperation,
             getDependents,
             generatedNames,
-        })(tableView, dimensionIndex, direction);
+        })(tableView, dimensionIndex, direction, count);
         onCommand?.({
             command: "insert-table-column",
             tableView,
             dimensionIndex,
             direction,
+            count,
         });
     }, [
         tables,
@@ -315,6 +516,7 @@ export const useOnTable = ({ locale, cellXfsRegistry, sharedStringRegistry, rowC
         onChangeTables,
         onChangeSheets,
         onChangeSheetData,
+        onChangeCharts,
         enqueueCalculation,
         enqueueStructureChange,
         enqueueGraphOperation,
@@ -325,11 +527,15 @@ export const useOnTable = ({ locale, cellXfsRegistry, sharedStringRegistry, rowC
     ]);
     // Delete a table column
     const onDeleteTableColumn = useCallback((tableView, dimensionIndex) => {
-        // Validate - keep React-specific validation at hook level
-        if (getConfictingTable(tables, tableView)) {
-            showError({
-                message: "You cannot insert or delete cells over part of a table.",
-            });
+        // Excel refuses a table-column delete whose shifted band would tear another table (T-47).
+        const refusal = getTableEditRefusal({
+            sheetId: tableView.sheetId,
+            table: tableView,
+            axis: "column",
+            tables,
+        });
+        if (refusal) {
+            showError({ title: refusal.title, message: refusal.message });
             return;
         }
         deleteTableColumn({
@@ -343,6 +549,7 @@ export const useOnTable = ({ locale, cellXfsRegistry, sharedStringRegistry, rowC
             onChangeTables,
             onChangeSheets,
             onChangeSheetData,
+            onChangeCharts,
             enqueueCalculation,
             enqueueStructureChange,
             enqueueGraphOperation,
@@ -365,6 +572,7 @@ export const useOnTable = ({ locale, cellXfsRegistry, sharedStringRegistry, rowC
         onChangeTables,
         onChangeSheets,
         onChangeSheetData,
+        onChangeCharts,
         enqueueCalculation,
         enqueueStructureChange,
         enqueueGraphOperation,

package/dist/esm/hooks/use-on-undo-calculated-column.d.ts

@@ -0,0 +1,23 @@
+import type { CalculatedColumnFill, CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { useCalculation } from "./use-calculation";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnUndoCalculatedColumnProps<T extends CellData, S extends Sheet> = {
+    tables?: TableView[];
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    /** `useUndoRedo`'s `batchHistory`: the restored cells and the dropped column formula undo as one step. */
+    batchHistory: <R>(action: () => R) => R;
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeTables: UseSpreadsheetProps<T, S>["onChangeTables"];
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    onCommand?: OnCommand;
+};
+/**
+ * Excel's "Undo Calculated Column" (the AutoCorrect smart tag after a formula typed into a table
+ * column filled it): the fill alone reverts — every body cell the fill overwrote goes back to what
+ * it held (empty, or the column's previous formula) — and the column stops being a calculated
+ * column. The typed cell keeps its formula. One undo step.
+ */
+export declare const useOnUndoCalculatedColumn: <T extends CellData, S extends Sheet>({ tables, createHistory, batchHistory, onChangeSheetData, onChangeTables, enqueueCalculation, onCommand, }: UseOnUndoCalculatedColumnProps<T, S>) => (fill: CalculatedColumnFill) => void;
+//# sourceMappingURL=use-on-undo-calculated-column.d.ts.map

package/dist/esm/hooks/use-on-undo-calculated-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-undo-calculated-column.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-undo-calculated-column.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,oBAAoB,EACpB,QAAQ,EACR,KAAK,EACL,SAAS,EACV,MAAM,2BAA2B,CAAC;AAMnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,8BAA8B,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAChF,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,0GAA0G;IAC1G,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACxC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,4GAQ5E,8BAA8B,CAAC,CAAC,EAAE,CAAC,CAAC,YAE5B,oBAAoB,SAgE9B,CAAC"}

package/dist/esm/hooks/use-on-undo-calculated-column.js

@@ -0,0 +1,62 @@
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+/**
+ * Excel's "Undo Calculated Column" (the AutoCorrect smart tag after a formula typed into a table
+ * column filled it): the fill alone reverts — every body cell the fill overwrote goes back to what
+ * it held (empty, or the column's previous formula) — and the column stops being a calculated
+ * column. The typed cell keeps its formula. One undo step.
+ */
+export const useOnUndoCalculatedColumn = ({ tables, createHistory, batchHistory, onChangeSheetData, onChangeTables, enqueueCalculation, onCommand, }) => {
+    return useCallback((fill) => {
+        const { sheetId, tableId, columnIndex, previous } = fill;
+        const table = tables?.find((candidate) => candidate.id === tableId && candidate.sheetId === sheetId);
+        if (!table) {
+            return;
+        }
+        batchHistory(() => {
+            const saveHistory = createHistory();
+            const recalcCells = new Map();
+            onChangeSheetData?.((prevSheetData) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                    for (const { rowIndex, columnIndex: col, cell } of previous) {
+                        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        currentSheet[rowIndex].values[col] = (cell ?? undefined);
+                        const position = { sheetId, rowIndex, columnIndex: col };
+                        enqueueCalculation({ type: cell ? "add" : "remove", position, force: true });
+                        recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, col), {
+                            ...position,
+                            force: true,
+                        });
+                    }
+                });
+                saveHistory({
+                    sheetData: { patches, inversePatches },
+                    ...(recalcCells.size
+                        ? { recalcCells: { undo: recalcCells, redo: recalcCells } }
+                        : {}),
+                });
+                return nextState;
+            });
+            onChangeTables?.((prevTables) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                    const current = draft.find((candidate) => candidate.id === tableId && candidate.sheetId === sheetId);
+                    const column = current?.columns?.[columnIndex - current.range.startColumnIndex];
+                    if (column) {
+                        delete column.formula;
+                    }
+                });
+                saveHistory({ tables: { patches, inversePatches } });
+                return nextState;
+            });
+        });
+        onCommand?.({
+            command: "undo-calculated-column",
+            sheetId,
+            tableId,
+            columnIndex,
+            previous,
+        });
+    }, [tables, createHistory, batchHistory, onChangeSheetData, onChangeTables, enqueueCalculation, onCommand]);
+};

package/dist/esm/hooks/use-on-undo-table-auto-expansion.d.ts

@@ -0,0 +1,28 @@
+import type { GridRange } from "@rowsncolumns/common-types";
+import type { CellData, Sheet, TableAutoExpansion, TableView } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { useCalculation } from "./use-calculation";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnUndoTableAutoExpansionProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    tables?: TableView[];
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    /** `useUndoRedo`'s `batchHistory`: the resize and the cell clears undo as one step. */
+    batchHistory: <R>(action: () => R) => R;
+    onResizeTable: (sheetId: number, table: TableView, range: GridRange) => void;
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    onCommand?: OnCommand;
+};
+/**
+ * Excel's "Undo Table AutoExpansion" (the AutoCorrect smart tag after a table grew over a typed,
+ * pasted or filled cell): the table resizes back to the range it had before the growth, and the
+ * cells the growth itself wrote — the calculated-column formulas and generated header names it
+ * put into empty cells, the column formatting it copied onto cells that had none — are cleared.
+ * The user's own value stays, now a plain cell outside the table. One undo step.
+ */
+export declare const useOnUndoTableAutoExpansion: <T extends CellData, S extends Sheet>({ locale, cellXfsRegistry, tables, createHistory, batchHistory, onResizeTable, onChangeSheetData, enqueueCalculation, onCommand, }: UseOnUndoTableAutoExpansionProps<T, S>) => (expansion: TableAutoExpansion) => void;
+//# sourceMappingURL=use-on-undo-table-auto-expansion.d.ts.map

package/dist/esm/hooks/use-on-undo-table-auto-expansion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-undo-table-auto-expansion.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-undo-table-auto-expansion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EACV,QAAQ,EACR,KAAK,EACL,kBAAkB,EAClB,SAAS,EACV,MAAM,2BAA2B,CAAC;AAMnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,gCAAgC,CAC1C,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,KAAK,IACb;IACF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,uFAAuF;IACvF,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACxC,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IAC7E,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,oIAU9E,gCAAgC,CAAC,CAAC,EAAE,CAAC,CAAC,iBAEzB,kBAAkB,SA4EjC,CAAC"}

package/dist/esm/hooks/use-on-undo-table-auto-expansion.js

@@ -0,0 +1,75 @@
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+/**
+ * Excel's "Undo Table AutoExpansion" (the AutoCorrect smart tag after a table grew over a typed,
+ * pasted or filled cell): the table resizes back to the range it had before the growth, and the
+ * cells the growth itself wrote — the calculated-column formulas and generated header names it
+ * put into empty cells, the column formatting it copied onto cells that had none — are cleared.
+ * The user's own value stays, now a plain cell outside the table. One undo step.
+ */
+export const useOnUndoTableAutoExpansion = ({ locale, cellXfsRegistry, tables, createHistory, batchHistory, onResizeTable, onChangeSheetData, enqueueCalculation, onCommand, }) => {
+    return useCallback((expansion) => {
+        const { sheetId, tableId, previousRange, writes } = expansion;
+        const table = tables?.find((candidate) => candidate.id === tableId && candidate.sheetId === sheetId);
+        if (!table) {
+            return;
+        }
+        batchHistory(() => {
+            onResizeTable(sheetId, table, previousRange);
+            const saveHistory = createHistory();
+            const recalcCells = new Map();
+            onChangeSheetData?.((prevSheetData) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                    const sheetCell = new SheetCell();
+                    for (const { rowIndex, columnIndex } of writes.values) {
+                        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        currentSheet[rowIndex].values[columnIndex] = undefined;
+                        const position = { sheetId, rowIndex, columnIndex };
+                        enqueueCalculation({ type: "remove", position });
+                        recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), position);
+                    }
+                    for (const { rowIndex, columnIndex } of writes.formats) {
+                        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                        if (!cellData) {
+                            continue;
+                        }
+                        sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, { locale, cellXfsRegistry });
+                        sheetCell.clearUserEnteredFormat();
+                        currentSheet[rowIndex].values[columnIndex] =
+                            sheetCell.getCellData();
+                        cellXfsRegistry?.unRegister(sheetCell);
+                    }
+                });
+                saveHistory({
+                    sheetData: { patches, inversePatches },
+                    ...(recalcCells.size
+                        ? { recalcCells: { undo: recalcCells, redo: recalcCells } }
+                        : {}),
+                });
+                return nextState;
+            });
+            cellXfsRegistry?.getPatches(saveHistory);
+        });
+        onCommand?.({
+            command: "undo-table-auto-expansion",
+            sheetId,
+            tableId,
+            previousRange,
+            writes,
+        });
+    }, [
+        locale,
+        cellXfsRegistry,
+        tables,
+        createHistory,
+        batchHistory,
+        onResizeTable,
+        onChangeSheetData,
+        enqueueCalculation,
+        onCommand,
+    ]);
+};

package/dist/esm/hooks/use-on-update-named-range.d.ts

@@ -1,11 +1,13 @@
 import type { CellInterface } from "@rowsncolumns/common-types";
-import type { CellData, NamedRange } from "@rowsncolumns/spreadsheet";
+import type { CellData, NamedRange, TableView } from "@rowsncolumns/spreadsheet";
 import type { OnCommand } from "../commands";
 import type { useCalculation } from "./use-calculation";
 import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
 import type { SpreadsheetPatch } from "./use-undo-redo";
 type UseOnUpdateNamedRangeProps<T extends CellData> = {
     locale?: string;
+    /** The workbook's tables — a defined name may not be renamed to one of them (Excel's single namespace). */
+    tables?: TableView[];
     enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
     getActiveCell(): CellInterface;
     getDependents: ReturnType<typeof useCalculation>["getDependents"];
@@ -14,6 +16,6 @@ type UseOnUpdateNamedRangeProps<T extends CellData> = {
     createHistory(): (patches: SpreadsheetPatch) => void;
     onCommand?: OnCommand;
 };
-export declare const useOnUpdateNamedRange: <T extends CellData>({ locale, getDependents, enqueueCalculation, createHistory, onChangeNamedRanges, onChangeSheetData, onCommand, }: UseOnUpdateNamedRangeProps<T>) => (sheetId: number, namedRange: NamedRange, previousNamedRange: NamedRange) => void;
+export declare const useOnUpdateNamedRange: <T extends CellData>({ locale, tables, getDependents, enqueueCalculation, createHistory, onChangeNamedRanges, onChangeSheetData, onCommand, }: UseOnUpdateNamedRangeProps<T>) => (sheetId: number, namedRange: NamedRange, previousNamedRange: NamedRange) => void;
 export {};
 //# sourceMappingURL=use-on-update-named-range.d.ts.map

package/dist/esm/hooks/use-on-update-named-range.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-on-update-named-range.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-update-named-range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAMtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAI7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,0BAA0B,CAAC,CAAC,SAAS,QAAQ,IAAI;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,aAAa,IAAI,aAAa,CAAC;IAC/B,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,mBAAmB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;IACnE,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,kHAQvD,0BAA0B,CAAC,CAAC,CAAC,eAGlB,MAAM,cAAc,UAAU,sBAAsB,UAAU,SA+I3E,CAAC"}
+{"version":3,"file":"use-on-update-named-range.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-update-named-range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE,OAAO,KAAK,EACV,QAAQ,EACR,UAAU,EACV,SAAS,EACV,MAAM,2BAA2B,CAAC;AAQnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAI7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,0BAA0B,CAAC,CAAC,SAAS,QAAQ,IAAI;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2GAA2G;IAC3G,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,aAAa,IAAI,aAAa,CAAC;IAC/B,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,mBAAmB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;IACnE,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,0HASvD,0BAA0B,CAAC,CAAC,CAAC,eAIlB,MAAM,cAAc,UAAU,sBAAsB,UAAU,SA4J3E,CAAC"}