@rowsncolumns/spreadsheet-state 28.0.76 → 29.1.0

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

@@ -1,24 +1,131 @@
 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";
-export const changeTableColumn = ({ locale, cellXfsRegistry, sharedStringRegistry, onChangeSheetData, onChangeTables, getDependents, enqueueCalculation, enqueueGraphOperation, createHistory, tokenizer, generatedNames, }) => (sheetId, coords, value, currentTable, isRowExpansion, isColumnExpansion, range) => {
+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 const planHeaderCellRenames = ({ sheetId, tables, cells, generatedNames, }) => {
+    const renames = [];
+    if (!tables?.length)
+        return renames;
+    const pending = new Map();
+    for (const { rowIndex, columnIndex, value } of cells) {
+        if (typeof value === "string" && isAFormula(value))
+            continue;
+        const table = tables.find((candidate) => candidate.sheetId === sheetId &&
+            candidate.headerRow !== false &&
+            candidate.range.startRowIndex === rowIndex &&
+            columnIndex >= candidate.range.startColumnIndex &&
+            columnIndex <= candidate.range.endColumnIndex);
+        if (!table)
+            continue;
+        const dimensionIndex = columnIndex - table.range.startColumnIndex;
+        const names = pending.get(table.id) ?? new Map();
+        const otherColumns = (table.columns ?? [])
+            .map((column, index) => ({ name: names.get(index) ?? column.name }))
+            .filter((_, index) => index !== dimensionIndex);
+        const newName = getTypedTableHeaderName(typeof value === "number" ? String(value) : value, otherColumns, generatedNames);
+        names.set(dimensionIndex, newName);
+        pending.set(table.id, names);
+        renames.push({
+            table,
+            dimensionIndex,
+            rowIndex,
+            columnIndex,
+            oldName: table.columns?.[dimensionIndex]?.name,
+            newName,
+        });
+    }
+    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 const getTypedTableHeaderName = (value, otherColumns, generatedNames) => value === "" || isNil(value)
+    ? getNextTableColumnName([...otherColumns], generatedNames)
+    : getUniqueTableColumnName(String(value), otherColumns.map((column) => column.name));
+export const changeTableColumn = ({ locale, cellXfsRegistry, sharedStringRegistry, onChangeSheetData, onChangeTables, onChangeCharts, getDependents, getSheetName, enqueueCalculation, enqueueGraphOperation, createHistory, tokenizer, generatedNames, tables, }) => (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) => {
     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;
     }
     const recalcCells = new Map();
-    const newColumnName = isColumnExpansion
-        ? currentTable.range.startRowIndex === coords.rowIndex
-            ? value
-                ? String(value)
-                : getNextTableColumnName(currentTable.columns ?? undefined, generatedNames)
-            : getNextTableColumnName(currentTable.columns ?? undefined, generatedNames)
-        : undefined;
+    // What the growth writes besides the user's value — "Undo Table AutoExpansion" clears these.
+    const writes = { values: [], formats: [] };
     const isEnteringNewColumnName = currentTable.range.startRowIndex === coords.rowIndex;
+    const 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`.
+    const newColumnNames = [];
+    if (isColumnExpansion) {
+        const lastWrittenColumnIndex = Math.max(firstNewColumnIndex, range.endColumnIndex);
+        for (let columnIndex = firstNewColumnIndex; columnIndex <= lastWrittenColumnIndex; columnIndex++) {
+            const line = {
+                ...currentTable.range,
+                startColumnIndex: columnIndex,
+                endColumnIndex: columnIndex,
+            };
+            if (tables?.some((other) => other.id !== currentTable.id &&
+                other.sheetId === sheetId &&
+                areaIntersects(other.range, line))) {
+                break;
+            }
+            const taken = [
+                ...(currentTable.columns ?? []),
+                ...newColumnNames.map((name) => ({ name })),
+            ];
+            const offset = columnIndex - firstNewColumnIndex;
+            const typed = offset === 0 ? value : headerValues?.[offset];
+            newColumnNames.push(isEnteringNewColumnName
+                ? getTypedTableHeaderName(typeof typed === "number" ? String(typed) : typed, taken, generatedNames)
+                : getNextTableColumnName(taken, generatedNames));
+        }
+    }
+    const 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.
+    let lastNewRowIndex = coords.rowIndex - 1;
+    if (isRowExpansion) {
+        const lastWrittenRowIndex = coords.rowIndex + (range.endRowIndex - range.startRowIndex);
+        for (let rowIndex = coords.rowIndex; rowIndex <= lastWrittenRowIndex; rowIndex++) {
+            const line = {
+                ...currentTable.range,
+                startRowIndex: rowIndex,
+                endRowIndex: rowIndex,
+            };
+            if (tables?.some((other) => other.id !== currentTable.id &&
+                other.sheetId === sheetId &&
+                areaIntersects(other.range, line))) {
+                break;
+            }
+            lastNewRowIndex = rowIndex;
+        }
+    }
     const saveHistory = createHistory();
     const isAdjacentColumn = coords.columnIndex === currentTable.range.endColumnIndex + 1;
     onChangeSheetData?.((prevSheetData) => {
@@ -29,7 +136,15 @@ export const changeTableColumn = ({ locale, cellXfsRegistry, sharedStringRegistr
                 const 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), {
@@ -37,18 +152,32 @@ export const changeTableColumn = ({ locale, cellXfsRegistry, sharedStringRegistr
                     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((name, offset) => {
+                if (offset === 0 && isEnteringNewColumnName) {
+                    return;
+                }
                 const columnCell = {
                     rowIndex: currentTable.range.startRowIndex,
-                    columnIndex: currentTable.range.endColumnIndex + 1,
+                    columnIndex: firstNewColumnIndex + offset,
                 };
                 const currentSheet = createSheetDraft(draft, sheetId, columnCell.rowIndex);
-                const sheetCell = new SheetCell(sheetId, columnCell, undefined, {
-                    locale,
-                });
-                sheetCell.setUserEnteredValue(newColumnName);
+                const sheetCell = new SheetCell(sheetId, columnCell, currentSheet[columnCell.rowIndex].values?.[columnCell.columnIndex], { locale, cellXfsRegistry, 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: { ...columnCell, sheetId },
                     type: "add",
@@ -57,13 +186,13 @@ export const changeTableColumn = ({ locale, cellXfsRegistry, sharedStringRegistr
                     ...columnCell,
                     sheetId,
                 });
-            }
+            });
             if (isRowExpansion) {
                 recalcCells.set(createSheetCellIdentifier(sheetId, coords.rowIndex, coords.columnIndex), {
                     ...coords,
                     sheetId,
                 });
-                addCalculatedColumnsForRowExpansion({
+                writes.values.push(...addCalculatedColumnsForRowExpansion({
                     sheetId,
                     locale,
                     currentTable,
@@ -73,19 +202,19 @@ export const changeTableColumn = ({ locale, cellXfsRegistry, sharedStringRegistr
                     range: {
                         ...currentTable.range,
                         startRowIndex: range.startRowIndex,
-                        endRowIndex: range.endRowIndex,
+                        endRowIndex: lastNewRowIndex,
                     },
-                    getDependents,
-                });
-                propagateColumnFormatsForRowExpansion({
+                    activeSheetName: getSheetName?.(sheetId),
+                }));
+                writes.formats.push(...propagateColumnFormatsForRowExpansion({
                     sheetId,
                     locale,
                     currentTable,
                     draft,
                     cellXfsRegistry,
                     newRowStart: coords.rowIndex,
-                    newRowEnd: coords.rowIndex + (range.endRowIndex - range.startRowIndex),
-                });
+                    newRowEnd: lastNewRowIndex,
+                }));
             }
             if (isRowExpansion || isColumnExpansion) {
                 processTableDependentCells(currentTable, getDependents, recalcCells, enqueueCalculation);
@@ -105,14 +234,14 @@ export const changeTableColumn = ({ locale, cellXfsRegistry, sharedStringRegistr
             const table = draft.find((table) => 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;
-                    table.columns?.push({
-                        name: newColumnName,
+                if (newColumnNames.length) {
+                    table.range.endColumnIndex += newColumnNames.length;
+                    table.columns?.push(...newColumnNames.map((name) => ({
+                        name,
                         filterButton: true,
-                    });
+                    })));
                 }
             }
         });
@@ -121,44 +250,140 @@ export const changeTableColumn = ({ locale, cellXfsRegistry, sharedStringRegistr
         });
         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.
+    const rowDelta = isRowExpansion
+        ? Math.max(0, lastNewRowIndex - currentTable.range.endRowIndex)
+        : 0;
+    const columnDelta = newColumnNames.length;
+    if (!rowDelta && !columnDelta) {
+        return undefined;
+    }
+    onChangeCharts?.((prevCharts) => {
+        const [nextState, patches, inversePatches] = produceWithPatches(prevCharts, (draft) => {
+            growChartsWithTable(draft, sheetId, tableBinding(currentTable), rowDelta, columnDelta);
+        });
+        saveHistory({ charts: { patches, 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,
+        tableId: currentTable.id,
+        previousRange: currentTable.range,
+        range: {
+            ...currentTable.range,
+            endRowIndex: currentTable.range.endRowIndex + rowDelta,
+            endColumnIndex: currentTable.range.endColumnIndex + columnDelta,
+        },
+        anchor: coords,
+        writes,
+    };
+};
+/**
+ * The first body row of a table — the row a recorded calculated-column formula
+ * (`columns[].formula`, Excel's `<calculatedColumnFormula>`) is written for.
+ */
+export const getTableFirstBodyRowIndex = (table) => table.range.startRowIndex + (table.headerRow ?? 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 const getRowRelativeFormula = (formula, columnIndex, fromRowIndex, toRowIndex, activeSheetName = "") => SheetCell.getRelativeFormula(formula.trim().startsWith("=") ? formula.trim() : `=${formula.trim()}`, { rowIndex: fromRowIndex, columnIndex }, { rowIndex: toRowIndex, columnIndex }, activeSheetName, undefined, false, undefined, undefined, true) ?? 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 const getCalculatedColumnTemplate = ({ draft, sheetId, table, columnIndex, bodyEndRowIndex, activeSheetName = "", }) => {
+    const firstBodyRowIndex = getTableFirstBodyRowIndex(table);
+    const lastBodyRowIndex = bodyEndRowIndex ?? table.range.endRowIndex - (table.totalRow ? 1 : 0);
+    const column = table.columns?.[columnIndex - table.range.startColumnIndex];
+    const recorded = column?.formula || undefined;
+    const probe = new SheetCell();
+    let template;
+    for (let rowIndex = firstBodyRowIndex; rowIndex <= lastBodyRowIndex; rowIndex++) {
+        const cellData = draft[sheetId]?.[rowIndex]?.values?.[columnIndex];
+        probe.assign(sheetId, { rowIndex, columnIndex }, cellData);
+        const userEnteredValue = probe.getUserEnteredValue();
+        if (isNil(userEnteredValue) || userEnteredValue === "") {
+            continue;
+        }
+        const formula = probe.formula;
+        if (!formula) {
+            return recorded;
+        }
+        const anchored = getRowRelativeFormula(formula, columnIndex, rowIndex, firstBodyRowIndex, activeSheetName);
+        if (template === undefined) {
+            template = anchored;
+        }
+        else if (template !== anchored) {
+            return recorded;
+        }
+    }
+    return template ?? recorded;
 };
-export const addCalculatedColumnsForRowExpansion = ({ sheetId, locale, currentTable, draft, recalcCells, range, enqueueCalculation, getDependents, }) => {
+/**
+ * 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 const addCalculatedColumnsForRowExpansion = ({ sheetId, locale, currentTable, draft, recalcCells, range, enqueueCalculation, activeSheetName = "", }) => {
+    const written = [];
+    if (range.endRowIndex < range.startRowIndex) {
+        return written;
+    }
+    const firstBodyRowIndex = getTableFirstBodyRowIndex(currentTable);
     const sheetCell = new SheetCell();
-    for (let i = 0; i < (currentTable.columns?.length ?? 0); i++) {
-        const column = currentTable.columns?.[i];
-        if (column && column.formula) {
-            const newRange = {
-                ...range,
-                startRowIndex: currentTable.range.startRowIndex +
-                    (currentTable.headerRow ?? true ? 1 : 0),
-                startColumnIndex: currentTable.range.startColumnIndex + i,
-                endColumnIndex: currentTable.range.startColumnIndex + i,
-            };
-            for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
-                for (let columnIndex = newRange.startColumnIndex; columnIndex <= newRange.endColumnIndex; columnIndex++) {
-                    if (!getDependents({ sheetId, rowIndex, columnIndex }).length) {
-                        continue;
-                    }
-                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
-                    const cellData = currentSheet[rowIndex].values?.[columnIndex];
-                    sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
-                        locale,
-                    });
-                    sheetCell.setUserEnteredValue(column.formula);
-                    currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
-                    enqueueCalculation({
-                        type: "add",
-                        position: { rowIndex, columnIndex, sheetId },
-                    });
-                    recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
-                        rowIndex,
-                        columnIndex,
-                        sheetId,
-                    });
-                }
+    for (let columnIndex = currentTable.range.startColumnIndex; columnIndex <= currentTable.range.endColumnIndex; columnIndex++) {
+        const template = getCalculatedColumnTemplate({
+            draft,
+            sheetId,
+            table: currentTable,
+            columnIndex,
+            // The new rows are part of the body already; the template comes from
+            // the rows above them.
+            bodyEndRowIndex: range.startRowIndex - 1,
+            activeSheetName,
+        });
+        if (!template) {
+            continue;
+        }
+        for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+            const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+            const cellData = currentSheet[rowIndex].values?.[columnIndex];
+            sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+                locale,
+            });
+            const 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, columnIndex });
+            enqueueCalculation({
+                type: "add",
+                position: { rowIndex, columnIndex, sheetId },
+            });
+            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                rowIndex,
+                columnIndex,
+                sheetId,
+            });
         }
     }
+    return written;
 };
 /**
  * When a table auto-expands downward, Excel applies the column's
@@ -173,18 +398,19 @@ export const addCalculatedColumnsForRowExpansion = ({ sheetId, locale, currentTa
  * (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 const propagateColumnFormatsForRowExpansion = ({ sheetId, locale, currentTable, draft, cellXfsRegistry, newRowStart, newRowEnd, }) => {
+    const written = [];
     const { startColumnIndex, endColumnIndex, startRowIndex, endRowIndex } = currentTable.range;
     const bodyStart = startRowIndex + (currentTable.headerRow ?? true ? 1 : 0);
     const 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;
     const probe = new SheetCell();
     const target = new SheetCell();
     for (let columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
@@ -219,8 +445,10 @@ export const propagateColumnFormatsForRowExpansion = ({ sheetId, locale, current
                 continue;
             target.inheritFormat(sharedFormat);
             currentSheet[r].values[columnIndex] = target.getCellData();
+            written.push({ rowIndex: r, columnIndex });
         }
     }
+    return written;
 };
 export const processTableDependentCells = (table, getDependents, recalcCells, enqueueCalculation) => {
     const deps = new Set();

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