@rowsncolumns/spreadsheet-state 29.0.0 → 29.1.1

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

@@ -1,83 +1,237 @@
-import { __assign, __read, __values } from "tslib";
+import { __assign, __read, __spreadArray, __values } from "tslib";
 import { isStaticNode } from "@rowsncolumns/dag";
-import { getCellXfsKey, isNil, iterateCellsInRange, } from "@rowsncolumns/utils";
+import { areaIntersects, getCellXfsKey, isNil, iterateCellsInRange, isAFormula, } from "@rowsncolumns/utils";
 import { produceWithPatches } from "immer";
+import { growChartsWithTable, tableBinding } from "../api/anchored-objects";
 import { createSheetCellIdentifier } from "../api/formula";
 import { createSheetDraft } from "../api/immer-utils";
 import { removeTableName } from "../api/table";
 import { getNextTableColumnName } from "../helpers";
 import { SheetCell } from "../sheet-cell";
+import { getUniqueTableColumnName } from "./table-utils";
+/**
+ * The header cells a block write (paste, change-batch) lands on, with the name each column takes —
+ * the typed-header rule: the cell's text de-duplicated against the table's other names and the
+ * names this same write gives earlier cells (`Name`, `Name2`), a blank taking the first free
+ * `ColumnN`. A formula is left to the caller (written as typed).
+ */
+export var planHeaderCellRenames = function (_a) {
+    var e_1, _b;
+    var _c, _d, _e, _f;
+    var sheetId = _a.sheetId, tables = _a.tables, cells = _a.cells, generatedNames = _a.generatedNames;
+    var renames = [];
+    if (!(tables === null || tables === void 0 ? void 0 : tables.length))
+        return renames;
+    var pending = new Map();
+    var _loop_1 = function (rowIndex, columnIndex, value) {
+        if (typeof value === "string" && isAFormula(value))
+            return "continue";
+        var table = tables.find(function (candidate) {
+            return candidate.sheetId === sheetId &&
+                candidate.headerRow !== false &&
+                candidate.range.startRowIndex === rowIndex &&
+                columnIndex >= candidate.range.startColumnIndex &&
+                columnIndex <= candidate.range.endColumnIndex;
+        });
+        if (!table)
+            return "continue";
+        var dimensionIndex = columnIndex - table.range.startColumnIndex;
+        var names = (_c = pending.get(table.id)) !== null && _c !== void 0 ? _c : new Map();
+        var otherColumns = ((_d = table.columns) !== null && _d !== void 0 ? _d : [])
+            .map(function (column, index) { var _a; return ({ name: (_a = names.get(index)) !== null && _a !== void 0 ? _a : column.name }); })
+            .filter(function (_, index) { return index !== dimensionIndex; });
+        var newName = getTypedTableHeaderName(typeof value === "number" ? String(value) : value, otherColumns, generatedNames);
+        names.set(dimensionIndex, newName);
+        pending.set(table.id, names);
+        renames.push({
+            table: table,
+            dimensionIndex: dimensionIndex,
+            rowIndex: rowIndex,
+            columnIndex: columnIndex,
+            oldName: (_f = (_e = table.columns) === null || _e === void 0 ? void 0 : _e[dimensionIndex]) === null || _f === void 0 ? void 0 : _f.name,
+            newName: newName,
+        });
+    };
+    try {
+        for (var cells_1 = __values(cells), cells_1_1 = cells_1.next(); !cells_1_1.done; cells_1_1 = cells_1.next()) {
+            var _g = cells_1_1.value, rowIndex = _g.rowIndex, columnIndex = _g.columnIndex, value = _g.value;
+            _loop_1(rowIndex, columnIndex, value);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (cells_1_1 && !cells_1_1.done && (_b = cells_1.return)) _b.call(cells_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return renames;
+};
+/**
+ * The column name a typed header takes (Excel): the typed text, de-duplicated against the table's
+ * other columns (`Name`, `Name2`, …); a cleared header takes the first free `ColumnN`.
+ */
+export var getTypedTableHeaderName = function (value, otherColumns, generatedNames) {
+    return value === "" || isNil(value)
+        ? getNextTableColumnName(__spreadArray([], __read(otherColumns), false), generatedNames)
+        : getUniqueTableColumnName(String(value), otherColumns.map(function (column) { return column.name; }));
+};
 export var changeTableColumn = function (_a) {
-    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, onChangeSheetData = _a.onChangeSheetData, onChangeTables = _a.onChangeTables, getDependents = _a.getDependents, enqueueCalculation = _a.enqueueCalculation, enqueueGraphOperation = _a.enqueueGraphOperation, createHistory = _a.createHistory, tokenizer = _a.tokenizer, generatedNames = _a.generatedNames;
-    return function (sheetId, coords, value, currentTable, isRowExpansion, isColumnExpansion, range) {
-        var _a, _b;
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, onChangeSheetData = _a.onChangeSheetData, onChangeTables = _a.onChangeTables, onChangeCharts = _a.onChangeCharts, getDependents = _a.getDependents, getSheetName = _a.getSheetName, enqueueCalculation = _a.enqueueCalculation, enqueueGraphOperation = _a.enqueueGraphOperation, createHistory = _a.createHistory, tokenizer = _a.tokenizer, generatedNames = _a.generatedNames, tables = _a.tables;
+    return function (sheetId, coords, value, currentTable, isRowExpansion, isColumnExpansion, range, 
+    /**
+     * The header-row text of every written column from `coords` on (index 0 = `value`), when the
+     * write covers the header row — a pasted / filled block right of the table names each new
+     * column from its own header cell.
+     */
+    headerValues) {
+        var _a;
         if (isNil(currentTable)) {
-            return;
+            return undefined;
+        }
+        // A table with a totals row never grows by rows (Excel — `findAdjacentTable` and the Rust
+        // engine's `grow_tables_over_rect` refuse it): a caller flagging one is writing beside the
+        // totals row, and the totals row must not take the calculated columns' formulas.
+        if (currentTable.totalRow) {
+            isRowExpansion = false;
         }
         var recalcCells = new Map();
-        var newColumnName = isColumnExpansion
-            ? currentTable.range.startRowIndex === coords.rowIndex
-                ? value
-                    ? String(value)
-                    : getNextTableColumnName((_a = currentTable.columns) !== null && _a !== void 0 ? _a : undefined, generatedNames)
-                : getNextTableColumnName((_b = currentTable.columns) !== null && _b !== void 0 ? _b : undefined, generatedNames)
-            : undefined;
+        // What the growth writes besides the user's value — "Undo Table AutoExpansion" clears these.
+        var writes = { values: [], formats: [] };
         var isEnteringNewColumnName = currentTable.range.startRowIndex === coords.rowIndex;
+        var firstNewColumnIndex = currentTable.range.endColumnIndex + 1;
+        // Every written column from the adjacent one on joins the table (Excel grows by the whole
+        // pasted / filled block), stopping at a column another table occupies. Each new column is
+        // named from its header cell — de-duplicated against the table's columns AND the columns
+        // added before it (`Name`, `Name2`) — or takes the next free `ColumnN`.
+        var newColumnNames = [];
+        if (isColumnExpansion) {
+            var lastWrittenColumnIndex = Math.max(firstNewColumnIndex, range.endColumnIndex);
+            var _loop_2 = function (columnIndex) {
+                var line = __assign(__assign({}, currentTable.range), { startColumnIndex: columnIndex, endColumnIndex: columnIndex });
+                if (tables === null || tables === void 0 ? void 0 : tables.some(function (other) {
+                    return other.id !== currentTable.id &&
+                        other.sheetId === sheetId &&
+                        areaIntersects(other.range, line);
+                })) {
+                    return "break";
+                }
+                var taken = __spreadArray(__spreadArray([], __read(((_a = currentTable.columns) !== null && _a !== void 0 ? _a : [])), false), __read(newColumnNames.map(function (name) { return ({ name: name }); })), false);
+                var offset = columnIndex - firstNewColumnIndex;
+                var typed = offset === 0 ? value : headerValues === null || headerValues === void 0 ? void 0 : headerValues[offset];
+                newColumnNames.push(isEnteringNewColumnName
+                    ? getTypedTableHeaderName(typeof typed === "number" ? String(typed) : typed, taken, generatedNames)
+                    : getNextTableColumnName(taken, generatedNames));
+            };
+            for (var columnIndex = firstNewColumnIndex; columnIndex <= lastWrittenColumnIndex; columnIndex++) {
+                var state_1 = _loop_2(columnIndex);
+                if (state_1 === "break")
+                    break;
+            }
+        }
+        var newColumnName = newColumnNames[0];
+        // Every written row from the adjacent one on joins the table (Excel grows by the whole
+        // pasted / filled block), stopping at a row another table occupies — row by row, like the rnc
+        // engine's `grow_tables_over_rect`. Cells written past that row stay plain cells.
+        var lastNewRowIndex = coords.rowIndex - 1;
+        if (isRowExpansion) {
+            var lastWrittenRowIndex = coords.rowIndex + (range.endRowIndex - range.startRowIndex);
+            var _loop_3 = function (rowIndex) {
+                var line = __assign(__assign({}, currentTable.range), { startRowIndex: rowIndex, endRowIndex: rowIndex });
+                if (tables === null || tables === void 0 ? void 0 : tables.some(function (other) {
+                    return other.id !== currentTable.id &&
+                        other.sheetId === sheetId &&
+                        areaIntersects(other.range, line);
+                })) {
+                    return "break";
+                }
+                lastNewRowIndex = rowIndex;
+            };
+            for (var rowIndex = coords.rowIndex; rowIndex <= lastWrittenRowIndex; rowIndex++) {
+                var state_2 = _loop_3(rowIndex);
+                if (state_2 === "break")
+                    break;
+            }
+        }
         var saveHistory = createHistory();
         var isAdjacentColumn = coords.columnIndex === currentTable.range.endColumnIndex + 1;
         onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
             var _a = __read(produceWithPatches(prevSheetData, function (draft) {
-                var _a;
+                var _a, _b;
+                var _c;
                 if (isAdjacentColumn && !isNil(value) && typeof value !== "boolean") {
                     var currentSheet = createSheetDraft(draft, sheetId, coords.rowIndex);
-                    var sheetCell = new SheetCell(sheetId, coords, (_a = currentSheet === null || currentSheet === void 0 ? void 0 : currentSheet[coords.rowIndex].values) === null || _a === void 0 ? void 0 : _a[coords.columnIndex], { locale: locale, cellXfsRegistry: cellXfsRegistry, sharedStringRegistry: sharedStringRegistry });
+                    var sheetCell = new SheetCell(sheetId, coords, (_c = currentSheet === null || currentSheet === void 0 ? void 0 : currentSheet[coords.rowIndex].values) === null || _c === void 0 ? void 0 : _c[coords.columnIndex], { locale: locale, cellXfsRegistry: cellXfsRegistry, sharedStringRegistry: sharedStringRegistry });
                     var finalValue = sheetCell.formula && tokenizer
                         ? removeTableName(tokenizer(value), currentTable.title)
                         : value;
-                    sheetCell.setUserEnteredValue(finalValue);
+                    if (isEnteringNewColumnName && newColumnName) {
+                        // The new column's header cell reads its (de-duplicated) name, as text.
+                        sheetCell.setUserEnteredValue(newColumnName, undefined, {
+                            disableTypeInference: true,
+                        });
+                    }
+                    else {
+                        sheetCell.setUserEnteredValue(finalValue);
+                    }
                     currentSheet[coords.rowIndex].values[coords.columnIndex] =
                         sheetCell.getCellData();
                     recalcCells.set(createSheetCellIdentifier(sheetId, coords.rowIndex, coords.columnIndex), __assign(__assign({}, coords), { sheetId: sheetId }));
                 }
-                if (isColumnExpansion && !isEnteringNewColumnName) {
+                // The header cell of every new column reads its name: the first one was written above
+                // from `value` when the write covers the header row; the rest (and every column of a
+                // body-row write) take theirs here, as text.
+                newColumnNames.forEach(function (name, offset) {
+                    var _a;
+                    if (offset === 0 && isEnteringNewColumnName) {
+                        return;
+                    }
                     var columnCell = {
                         rowIndex: currentTable.range.startRowIndex,
-                        columnIndex: currentTable.range.endColumnIndex + 1,
+                        columnIndex: firstNewColumnIndex + offset,
                     };
                     var currentSheet = createSheetDraft(draft, sheetId, columnCell.rowIndex);
-                    var sheetCell = new SheetCell(sheetId, columnCell, undefined, {
-                        locale: locale,
-                    });
-                    sheetCell.setUserEnteredValue(newColumnName);
+                    var sheetCell = new SheetCell(sheetId, columnCell, (_a = currentSheet[columnCell.rowIndex].values) === null || _a === void 0 ? void 0 : _a[columnCell.columnIndex], { locale: locale, cellXfsRegistry: cellXfsRegistry, sharedStringRegistry: sharedStringRegistry });
+                    if (isEnteringNewColumnName) {
+                        sheetCell.setUserEnteredValue(name, undefined, {
+                            disableTypeInference: true,
+                        });
+                    }
+                    else {
+                        sheetCell.setUserEnteredValue(name);
+                    }
                     currentSheet[columnCell.rowIndex].values[columnCell.columnIndex] =
                         sheetCell.getCellData();
+                    if (!isEnteringNewColumnName) {
+                        writes.values.push(columnCell);
+                    }
                     enqueueGraphOperation({
                         position: __assign(__assign({}, columnCell), { sheetId: sheetId }),
                         type: "add",
                     });
                     recalcCells.set(createSheetCellIdentifier(sheetId, columnCell.rowIndex, columnCell.columnIndex), __assign(__assign({}, columnCell), { sheetId: sheetId }));
-                }
+                });
                 if (isRowExpansion) {
                     recalcCells.set(createSheetCellIdentifier(sheetId, coords.rowIndex, coords.columnIndex), __assign(__assign({}, coords), { sheetId: sheetId }));
-                    addCalculatedColumnsForRowExpansion({
+                    (_a = writes.values).push.apply(_a, __spreadArray([], __read(addCalculatedColumnsForRowExpansion({
                         sheetId: sheetId,
                         locale: locale,
                         currentTable: currentTable,
                         draft: draft,
                         enqueueCalculation: enqueueCalculation,
                         recalcCells: recalcCells,
-                        range: __assign(__assign({}, currentTable.range), { startRowIndex: range.startRowIndex, endRowIndex: range.endRowIndex }),
-                        getDependents: getDependents,
-                    });
-                    propagateColumnFormatsForRowExpansion({
+                        range: __assign(__assign({}, currentTable.range), { startRowIndex: range.startRowIndex, endRowIndex: lastNewRowIndex }),
+                        activeSheetName: getSheetName === null || getSheetName === void 0 ? void 0 : getSheetName(sheetId),
+                    })), false));
+                    (_b = writes.formats).push.apply(_b, __spreadArray([], __read(propagateColumnFormatsForRowExpansion({
                         sheetId: sheetId,
                         locale: locale,
                         currentTable: currentTable,
                         draft: draft,
                         cellXfsRegistry: cellXfsRegistry,
                         newRowStart: coords.rowIndex,
-                        newRowEnd: coords.rowIndex + (range.endRowIndex - range.startRowIndex),
-                    });
+                        newRowEnd: lastNewRowIndex,
+                    })), false));
                 }
                 if (isRowExpansion || isColumnExpansion) {
                     processTableDependentCells(currentTable, getDependents, recalcCells, enqueueCalculation);
@@ -94,14 +248,14 @@ export var changeTableColumn = function (_a) {
                 var table = draft.find(function (table) { return table.id === currentTable.id && table.sheetId === sheetId; });
                 if (table) {
                     if (isRowExpansion) {
-                        table.range.endRowIndex = Math.max(table.range.endRowIndex, coords.rowIndex + (range.endRowIndex - range.startRowIndex));
+                        table.range.endRowIndex = Math.max(table.range.endRowIndex, lastNewRowIndex);
                     }
-                    if (isColumnExpansion && newColumnName) {
-                        table.range.endColumnIndex += 1;
-                        (_a = table.columns) === null || _a === void 0 ? void 0 : _a.push({
-                            name: newColumnName,
+                    if (newColumnNames.length) {
+                        table.range.endColumnIndex += newColumnNames.length;
+                        (_a = table.columns) === null || _a === void 0 ? void 0 : _a.push.apply(_a, __spreadArray([], __read(newColumnNames.map(function (name) { return ({
+                            name: name,
                             filterButton: true,
-                        });
+                        }); })), false));
                     }
                 }
             }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
@@ -110,42 +264,145 @@ export var changeTableColumn = function (_a) {
             });
             return nextState;
         });
+        // A chart range bound to the table (a column's body, or header + body) grows with the
+        // auto-expansion, like Excel's series on a table column.
+        var rowDelta = isRowExpansion
+            ? Math.max(0, lastNewRowIndex - currentTable.range.endRowIndex)
+            : 0;
+        var columnDelta = newColumnNames.length;
+        if (!rowDelta && !columnDelta) {
+            return undefined;
+        }
+        onChangeCharts === null || onChangeCharts === void 0 ? void 0 : onChangeCharts(function (prevCharts) {
+            var _a = __read(produceWithPatches(prevCharts, function (draft) {
+                growChartsWithTable(draft, sheetId, tableBinding(currentTable), rowDelta, columnDelta);
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({ charts: { patches: patches, inversePatches: inversePatches } });
+            return nextState;
+        });
+        // The record behind Excel's AutoCorrect smart tag ("Undo Table AutoExpansion" resizes the
+        // table back to `previousRange` and clears `writes`).
+        return {
+            sheetId: sheetId,
+            tableId: currentTable.id,
+            previousRange: currentTable.range,
+            range: __assign(__assign({}, currentTable.range), { endRowIndex: currentTable.range.endRowIndex + rowDelta, endColumnIndex: currentTable.range.endColumnIndex + columnDelta }),
+            anchor: coords,
+            writes: writes,
+        };
     };
 };
+/**
+ * The first body row of a table — the row a recorded calculated-column formula
+ * (`columns[].formula`, Excel's `<calculatedColumnFormula>`) is written for.
+ */
+export var getTableFirstBodyRowIndex = function (table) { var _a; return table.range.startRowIndex + (((_a = table.headerRow) !== null && _a !== void 0 ? _a : true) ? 1 : 0); };
+/**
+ * Relativise a formula written for row `fromRowIndex` of a column to row
+ * `toRowIndex` of the same column: relative references shift, `$`-anchored
+ * and structured references stay put (Excel).
+ */
+export var getRowRelativeFormula = function (formula, columnIndex, fromRowIndex, toRowIndex, activeSheetName) {
+    var _a;
+    if (activeSheetName === void 0) { activeSheetName = ""; }
+    return (_a = SheetCell.getRelativeFormula(formula.trim().startsWith("=") ? formula.trim() : "=".concat(formula.trim()), { rowIndex: fromRowIndex, columnIndex: columnIndex }, { rowIndex: toRowIndex, columnIndex: columnIndex }, activeSheetName, undefined, false, undefined, undefined, true)) !== null && _a !== void 0 ? _a : formula;
+};
+/**
+ * The formula a NEW row of a table column inherits, written for the table's
+ * first body row — `undefined` when the column is not a calculated column.
+ * The column's cells are the reference: when every non-empty body cell
+ * (`bodyEndRowIndex` bounds the rows considered) is a formula and they all
+ * agree once relativised, that formula — so a table created over a consistent
+ * formula column inherits it, and the template tracks every structural edit
+ * the cells went through. Otherwise the recorded `columns[].formula`: a column
+ * with a literal exception in it, or an emptied body, is still Excel's
+ * calculated column.
+ */
+export var getCalculatedColumnTemplate = function (_a) {
+    var _b, _c, _d, _e;
+    var draft = _a.draft, sheetId = _a.sheetId, table = _a.table, columnIndex = _a.columnIndex, bodyEndRowIndex = _a.bodyEndRowIndex, _f = _a.activeSheetName, activeSheetName = _f === void 0 ? "" : _f;
+    var firstBodyRowIndex = getTableFirstBodyRowIndex(table);
+    var lastBodyRowIndex = bodyEndRowIndex !== null && bodyEndRowIndex !== void 0 ? bodyEndRowIndex : table.range.endRowIndex - (table.totalRow ? 1 : 0);
+    var column = (_b = table.columns) === null || _b === void 0 ? void 0 : _b[columnIndex - table.range.startColumnIndex];
+    var recorded = (column === null || column === void 0 ? void 0 : column.formula) || undefined;
+    var probe = new SheetCell();
+    var template;
+    for (var rowIndex = firstBodyRowIndex; rowIndex <= lastBodyRowIndex; rowIndex++) {
+        var cellData = (_e = (_d = (_c = draft[sheetId]) === null || _c === void 0 ? void 0 : _c[rowIndex]) === null || _d === void 0 ? void 0 : _d.values) === null || _e === void 0 ? void 0 : _e[columnIndex];
+        probe.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData);
+        var userEnteredValue = probe.getUserEnteredValue();
+        if (isNil(userEnteredValue) || userEnteredValue === "") {
+            continue;
+        }
+        var formula = probe.formula;
+        if (!formula) {
+            return recorded;
+        }
+        var anchored = getRowRelativeFormula(formula, columnIndex, rowIndex, firstBodyRowIndex, activeSheetName);
+        if (template === undefined) {
+            template = anchored;
+        }
+        else if (template !== anchored) {
+            return recorded;
+        }
+    }
+    return template !== null && template !== void 0 ? template : recorded;
+};
+/**
+ * Excel table row expansion, formula half: the cells of the NEW body rows
+ * (`range`'s rows, already inside the table's range) take each calculated
+ * column's formula, row-relativised — auto-grow by typing below, Insert Table
+ * Row, and the resize handle all route here. A new cell that already holds a
+ * value (the typed one) keeps it.
+ */
 export var addCalculatedColumnsForRowExpansion = function (_a) {
-    var _b, _c, _d, _e, _f;
-    var sheetId = _a.sheetId, locale = _a.locale, currentTable = _a.currentTable, draft = _a.draft, recalcCells = _a.recalcCells, range = _a.range, enqueueCalculation = _a.enqueueCalculation, getDependents = _a.getDependents;
+    var _b;
+    var sheetId = _a.sheetId, locale = _a.locale, currentTable = _a.currentTable, draft = _a.draft, recalcCells = _a.recalcCells, range = _a.range, enqueueCalculation = _a.enqueueCalculation, _c = _a.activeSheetName, activeSheetName = _c === void 0 ? "" : _c;
+    var written = [];
+    if (range.endRowIndex < range.startRowIndex) {
+        return written;
+    }
+    var firstBodyRowIndex = getTableFirstBodyRowIndex(currentTable);
     var sheetCell = new SheetCell();
-    for (var i = 0; i < ((_c = (_b = currentTable.columns) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0); i++) {
-        var column = (_d = currentTable.columns) === null || _d === void 0 ? void 0 : _d[i];
-        if (column && column.formula) {
-            var newRange = __assign(__assign({}, range), { startRowIndex: currentTable.range.startRowIndex +
-                    (((_e = currentTable.headerRow) !== null && _e !== void 0 ? _e : true) ? 1 : 0), startColumnIndex: currentTable.range.startColumnIndex + i, endColumnIndex: currentTable.range.startColumnIndex + i });
-            for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
-                for (var columnIndex = newRange.startColumnIndex; columnIndex <= newRange.endColumnIndex; columnIndex++) {
-                    if (!getDependents({ sheetId: sheetId, rowIndex: rowIndex, columnIndex: columnIndex }).length) {
-                        continue;
-                    }
-                    var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
-                    var cellData = (_f = currentSheet[rowIndex].values) === null || _f === void 0 ? void 0 : _f[columnIndex];
-                    sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
-                        locale: locale,
-                    });
-                    sheetCell.setUserEnteredValue(column.formula);
-                    currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
-                    enqueueCalculation({
-                        type: "add",
-                        position: { rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
-                    });
-                    recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
-                        rowIndex: rowIndex,
-                        columnIndex: columnIndex,
-                        sheetId: sheetId,
-                    });
-                }
+    for (var columnIndex = currentTable.range.startColumnIndex; columnIndex <= currentTable.range.endColumnIndex; columnIndex++) {
+        var template = getCalculatedColumnTemplate({
+            draft: draft,
+            sheetId: sheetId,
+            table: currentTable,
+            columnIndex: columnIndex,
+            // The new rows are part of the body already; the template comes from
+            // the rows above them.
+            bodyEndRowIndex: range.startRowIndex - 1,
+            activeSheetName: activeSheetName,
+        });
+        if (!template) {
+            continue;
+        }
+        for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+            var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+            var cellData = (_b = currentSheet[rowIndex].values) === null || _b === void 0 ? void 0 : _b[columnIndex];
+            sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
+                locale: locale,
+            });
+            var occupied = sheetCell.getUserEnteredValue();
+            if (!isNil(occupied) && occupied !== "") {
+                continue;
             }
+            sheetCell.setUserEnteredValue(getRowRelativeFormula(template, columnIndex, firstBodyRowIndex, rowIndex, activeSheetName));
+            currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+            written.push({ rowIndex: rowIndex, columnIndex: columnIndex });
+            enqueueCalculation({
+                type: "add",
+                position: { rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
+            });
+            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                rowIndex: rowIndex,
+                columnIndex: columnIndex,
+                sheetId: sheetId,
+            });
         }
     }
+    return written;
 };
 /**
  * When a table auto-expands downward, Excel applies the column's
@@ -160,20 +417,21 @@ export var addCalculatedColumnsForRowExpansion = function (_a) {
  * (see `apps/spreadsheet/components/canvas-grid` -- `getBandedCells`
  * / `getBandedCellFormat`), so this only handles user-applied
  * formats: number format, borders, fill, font, data-validation-driven
- * styling, etc.
+ * styling, etc. Returns the cells that inherited a format.
  */
 export var propagateColumnFormatsForRowExpansion = function (_a) {
     var _b, _c, _d, _e, _f;
     var sheetId = _a.sheetId, locale = _a.locale, currentTable = _a.currentTable, draft = _a.draft, cellXfsRegistry = _a.cellXfsRegistry, newRowStart = _a.newRowStart, newRowEnd = _a.newRowEnd;
+    var written = [];
     var _g = currentTable.range, startColumnIndex = _g.startColumnIndex, endColumnIndex = _g.endColumnIndex, startRowIndex = _g.startRowIndex, endRowIndex = _g.endRowIndex;
     var bodyStart = startRowIndex + (((_b = currentTable.headerRow) !== null && _b !== void 0 ? _b : true) ? 1 : 0);
     var bodyEnd = endRowIndex;
     if (bodyEnd < bodyStart)
-        return;
+        return written;
     // No-op: nothing to do when the "new" rows are inside the existing
     // body range (re-entering an existing row, not expanding).
     if (newRowStart <= bodyEnd)
-        return;
+        return written;
     var probe = new SheetCell();
     var target = new SheetCell();
     for (var columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
@@ -208,11 +466,13 @@ export var propagateColumnFormatsForRowExpansion = function (_a) {
                 continue;
             target.inheritFormat(sharedFormat);
             currentSheet[r].values[columnIndex] = target.getCellData();
+            written.push({ rowIndex: r, columnIndex: columnIndex });
         }
     }
+    return written;
 };
 export var processTableDependentCells = function (table, getDependents, recalcCells, enqueueCalculation) {
-    var e_1, _a, e_2, _b, e_3, _c;
+    var e_2, _a, e_3, _b, e_4, _c;
     var deps = new Set();
     try {
         for (var _d = __values(iterateCellsInRange(table.range)), _e = _d.next(); !_e.done; _e = _d.next()) {
@@ -223,7 +483,7 @@ export var processTableDependentCells = function (table, getDependents, recalcCe
                 sheetId: table.sheetId,
             });
             try {
-                for (var dependents_1 = (e_2 = void 0, __values(dependents)), dependents_1_1 = dependents_1.next(); !dependents_1_1.done; dependents_1_1 = dependents_1.next()) {
+                for (var dependents_1 = (e_3 = void 0, __values(dependents)), dependents_1_1 = dependents_1.next(); !dependents_1_1.done; dependents_1_1 = dependents_1.next()) {
                     var dependent = dependents_1_1.value;
                     if (isStaticNode(dependent)) {
                         continue;
@@ -231,21 +491,21 @@ export var processTableDependentCells = function (table, getDependents, recalcCe
                     deps.add(dependent);
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
             finally {
                 try {
                     if (dependents_1_1 && !dependents_1_1.done && (_b = dependents_1.return)) _b.call(dependents_1);
                 }
-                finally { if (e_2) throw e_2.error; }
+                finally { if (e_3) throw e_3.error; }
             }
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
     finally {
         try {
             if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
         }
-        finally { if (e_1) throw e_1.error; }
+        finally { if (e_2) throw e_2.error; }
     }
     try {
         for (var deps_1 = __values(deps), deps_1_1 = deps_1.next(); !deps_1_1.done; deps_1_1 = deps_1.next()) {
@@ -257,11 +517,11 @@ export var processTableDependentCells = function (table, getDependents, recalcCe
             recalcCells.set(createSheetCellIdentifier(table.sheetId, position.rowIndex, position.columnIndex), position);
         }
     }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
     finally {
         try {
             if (deps_1_1 && !deps_1_1.done && (_c = deps_1.return)) _c.call(deps_1);
         }
-        finally { if (e_3) throw e_3.error; }
+        finally { if (e_4) throw e_4.error; }
     }
 };

package/dist/cjs/interface/create-table.d.ts

@@ -1,5 +1,17 @@
-import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
-import type { BandedDefinition, CellData, SelectionAttributes, Sheet, TableTheme, TableView } from "@rowsncolumns/spreadsheet";
+import type { CellInterface, GridRange, SelectionArea } from "@rowsncolumns/common-types";
+import type { BandedDefinition, CellData, CreateTableOptions, SelectionAttributes, Sheet, TableTheme, TableView } from "@rowsncolumns/spreadsheet";
 import type { UseOnTableProps } from "../hooks/use-on-table";
-export declare const createTable: <T extends CellData, S extends Sheet>({ locale, rowCount, columnCount, tables, basicFilter, theme: spreadsheetTheme, idCreationStrategy, enqueueCalculation, createHistory, onChangeSheets, onChangeTables, onChangeSheetData, getFormattedValue, getEffectiveValue, onRequestCalculate, getDependents, enqueueGraphOperation, getContentfulRangeAroundCell, generatedNames, }: UseOnTableProps<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], tableSpec?: Partial<TableView>, theme?: TableTheme, bandedRange?: BandedDefinition) => void;
+/**
+ * The data range a create-table targets: the spec's range, else the last selection, else the data
+ * region around the active cell (Ctrl+A's region), else the active cell. The hook's refusal guards
+ * and the create itself must agree on it, so both resolve it here.
+ */
+export declare const resolveCreateTableRange: ({ sheetId, activeCell, selections, tableSpec, getContentfulRangeAroundCell, }: {
+    sheetId: number;
+    activeCell: CellInterface;
+    selections: SelectionArea<SelectionAttributes>[];
+    tableSpec?: Partial<TableView>;
+    getContentfulRangeAroundCell?: UseOnTableProps<CellData, Sheet>["getContentfulRangeAroundCell"];
+}) => GridRange;
+export declare const createTable: <T extends CellData, S extends Sheet>({ locale, rowCount, columnCount, tables, namedRanges, basicFilter, cellXfsRegistry, sharedStringRegistry, theme: spreadsheetTheme, idCreationStrategy, enqueueCalculation, enqueueStructureChange, createHistory, onChangeSheets, onChangeTables, onChangeSheetData, onChangeCitations, onChangeCharts, getActiveCell, getSelections, getFormattedValue, getEffectiveValue, onRequestCalculate, getDependents, getSheetName, enqueueGraphOperation, getContentfulRangeAroundCell, generatedNames, }: UseOnTableProps<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], tableSpec?: Partial<TableView>, theme?: TableTheme, bandedRange?: BandedDefinition, options?: CreateTableOptions) => void;
 //# sourceMappingURL=create-table.d.ts.map

package/dist/cjs/interface/create-table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-table.d.ts","sourceRoot":"","sources":["../../../interface/create-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAO/E,OAAO,KAAK,EACV,gBAAgB,EAChB,QAAQ,EAER,mBAAmB,EACnB,KAAK,EACL,UAAU,EACV,SAAS,EACV,MAAM,2BAA2B,CAAC;AAMnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAG7D,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,0UAoB9D,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,MAEpB,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAChD,YAAY,OAAO,CAAC,SAAS,CAAC,EAC9B,QAAQ,UAAU,EAClB,cAAc,gBAAgB,SAsIjC,CAAC"}
+{"version":3,"file":"create-table.d.ts","sourceRoot":"","sources":["../../../interface/create-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,aAAa,EACd,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EACV,gBAAgB,EAChB,QAAQ,EAER,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,EACL,UAAU,EACV,SAAS,EACV,MAAM,2BAA2B,CAAC;AAanC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GAAI,+EAMrC;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,aAAa,CAAC;IAC1B,UAAU,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAAE,CAAC;IACjD,SAAS,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC/B,4BAA4B,CAAC,EAAE,eAAe,CAC5C,QAAQ,EACR,KAAK,CACN,CAAC,8BAA8B,CAAC,CAAC;CACnC,KAAG,SAQH,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,qeA6B9D,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,MAEpB,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAChD,YAAY,OAAO,CAAC,SAAS,CAAC,EAC9B,QAAQ,UAAU,EAClB,cAAc,gBAAgB,EAC9B,UAAU,kBAAkB,SAsM/B,CAAC"}