@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/interface/table-totalrow.d.ts

@@ -0,0 +1,20 @@
+import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import type { UseOnTableProps } from "../hooks/use-on-table";
+import type { SpreadsheetPatch } from "../hooks/use-undo-redo";
+type TableTotalRowProps<T extends CellData, S extends Sheet> = Pick<UseOnTableProps<T, S>, "locale" | "onChangeSheetData" | "enqueueCalculation">;
+/**
+ * Add a total row to a table.
+ *
+ * Expects `updatedTable.range` to already include the total row, i.e.
+ * `range.endRowIndex` is the row the totals are written to.
+ */
+export declare const addTotalRow: <T extends CellData, S extends Sheet>({ locale, onChangeSheetData, enqueueCalculation, }: TableTotalRowProps<T, S>) => (sheetId: number, updatedTable: TableView, saveHistory: (patches: SpreadsheetPatch) => void) => void;
+/**
+ * Remove the total row from a table.
+ *
+ * Expects `updatedTable.range` to already exclude the total row, i.e. the
+ * total row being removed sits at `range.endRowIndex + 1`.
+ */
+export declare const removeTotalRow: <T extends CellData, S extends Sheet>({ locale, onChangeSheetData, enqueueCalculation, }: TableTotalRowProps<T, S>) => (sheetId: number, updatedTable: TableView, saveHistory: (patches: SpreadsheetPatch) => void) => void;
+export {};
+//# sourceMappingURL=table-totalrow.d.ts.map

package/dist/esm/interface/table-totalrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-totalrow.d.ts","sourceRoot":"","sources":["../../../interface/table-totalrow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAM5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI/D,KAAK,kBAAkB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI,IAAI,CACjE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EACrB,QAAQ,GAAG,mBAAmB,GAAG,oBAAoB,CACtD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,oDAI9D,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,MAEvB,SAAS,MAAM,EACf,cAAc,SAAS,EACvB,aAAa,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,SAuJnD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,oDAIjE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,MAEvB,SAAS,MAAM,EACf,cAAc,SAAS,EACvB,aAAa,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,SA4DnD,CAAC"}

package/dist/esm/interface/table-totalrow.js

@@ -0,0 +1,155 @@
+import { isNil, isNumber } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+/**
+ * Add a total row to a table.
+ *
+ * Expects `updatedTable.range` to already include the total row, i.e.
+ * `range.endRowIndex` is the row the totals are written to.
+ */
+export const addTotalRow = ({ locale, onChangeSheetData, enqueueCalculation, }) => {
+    return (sheetId, updatedTable, saveHistory) => {
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        /**
+         * 1. Validate number columns
+         * 2. Add Subtotal function
+         */
+        const numberColumnIndexes = [];
+        const sheetCell = new SheetCell();
+        const { range: { startRowIndex, startColumnIndex, endRowIndex, endColumnIndex }, } = updatedTable;
+        // Add total text
+        const totalRowIndex = endRowIndex;
+        /**
+         * Update sheet
+         */
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                // User is adding a total row
+                for (let columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
+                    const values = [];
+                    let isDateColumn = false;
+                    for (let rowIndex = startRowIndex + (updatedTable.headerRow ? 1 : 0); rowIndex < totalRowIndex; rowIndex++) {
+                        const cellData = draft[sheetId]?.[rowIndex]?.values?.[columnIndex];
+                        sheetCell.assign(sheetId, {
+                            rowIndex,
+                            columnIndex,
+                        }, cellData, { locale });
+                        const effectiveValue = sheetCell.getEffectiveValue();
+                        const numberFormat = sheetCell.getNumberFormat();
+                        // Dates are stored as numbers, but summing them is meaningless
+                        if (numberFormat?.type === "DATE" ||
+                            numberFormat?.type === "DATE_TIME") {
+                            isDateColumn = true;
+                            break;
+                        }
+                        if (!isNil(effectiveValue)) {
+                            values.push(effectiveValue);
+                        }
+                    }
+                    if (!isDateColumn && values.length && values.every(isNumber)) {
+                        numberColumnIndexes.push(columnIndex);
+                    }
+                }
+                const currentSheet = createSheetDraft(draft, sheetId, totalRowIndex);
+                sheetCell.assign(sheetId, {
+                    rowIndex: totalRowIndex,
+                    columnIndex: startColumnIndex,
+                }, currentSheet[totalRowIndex]?.values?.[startColumnIndex], { locale });
+                // Add total text
+                sheetCell.setUserEnteredValue("Total");
+                // Bold, can be overridden by user
+                sheetCell.setUserEnteredFormat("textFormat", {
+                    bold: true,
+                });
+                // Set cell data
+                currentSheet[totalRowIndex].values[startColumnIndex] =
+                    sheetCell.getCellData();
+                // Add subtotal
+                for (const columnIndex of numberColumnIndexes) {
+                    // The total label owns the first column
+                    if (columnIndex === startColumnIndex) {
+                        continue;
+                    }
+                    const rowIndex = totalRowIndex;
+                    const cellData = draft[sheetId]?.[rowIndex]?.values?.[columnIndex];
+                    sheetCell.assign(sheetId, {
+                        columnIndex,
+                        rowIndex,
+                    }, cellData, { locale });
+                    const columnName = updatedTable.columns?.[columnIndex - startColumnIndex]?.name;
+                    if (columnName) {
+                        sheetCell.setUserEnteredValue(`=SUBTOTAL(109, [${columnName}])`);
+                        // Bold, can be overridden by user
+                        sheetCell.setUserEnteredFormat("textFormat", {
+                            bold: true,
+                        });
+                        // Set cell data
+                        currentSheet[totalRowIndex].values[columnIndex] =
+                            sheetCell.getCellData();
+                        const position = {
+                            rowIndex,
+                            columnIndex,
+                            sheetId,
+                        };
+                        enqueueCalculation({
+                            type: "add",
+                            position,
+                        });
+                        // Add sheet id
+                        recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), position);
+                    }
+                }
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+    };
+};
+/**
+ * Remove the total row from a table.
+ *
+ * Expects `updatedTable.range` to already exclude the total row, i.e. the
+ * total row being removed sits at `range.endRowIndex + 1`.
+ */
+export const removeTotalRow = ({ locale, onChangeSheetData, enqueueCalculation, }) => {
+    return (sheetId, updatedTable, saveHistory) => {
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        const sheetCell = new SheetCell();
+        const { range: { startColumnIndex, endRowIndex, endColumnIndex }, } = updatedTable;
+        const totalRowIndex = endRowIndex + 1;
+        // Update sheetdata
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                const currentSheet = createSheetDraft(draft, sheetId, totalRowIndex);
+                for (let columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
+                    sheetCell.assign(sheetId, { rowIndex: totalRowIndex, columnIndex }, undefined, { locale });
+                    currentSheet[totalRowIndex].values[columnIndex] =
+                        sheetCell.getCellData();
+                    const position = {
+                        rowIndex: totalRowIndex,
+                        columnIndex,
+                        sheetId,
+                    };
+                    enqueueCalculation({
+                        type: "add",
+                        position,
+                    });
+                    // Add sheet id
+                    recalcCells.set(createSheetCellIdentifier(sheetId, totalRowIndex, columnIndex), position);
+                }
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/table-utils.d.ts

@@ -0,0 +1,21 @@
+import type { GridRange } from "@rowsncolumns/common-types";
+import type { CellData, TableView } from "@rowsncolumns/spreadsheet";
+import type { Draft } from "immer";
+import type { GeneratedNames } from "../generated-names";
+export declare const rangesOverlap: (a: GridRange, b: GridRange) => boolean;
+export declare const tableWouldOverlap: (candidate: {
+    sheetId: number;
+    range: GridRange;
+    id?: TableView["id"];
+}, existing: TableView[] | undefined) => boolean;
+type AddTableColumnOptions<T extends CellData> = {
+    sheetId: number;
+    draft: Draft<any>;
+    range: GridRange;
+    getFormattedValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | null | undefined;
+    locale?: string;
+    generatedNames?: GeneratedNames;
+};
+export declare const addTableColumn: <T extends CellData>({ draft, sheetId, range, getFormattedValue, locale, generatedNames, }: AddTableColumnOptions<T>) => void;
+export {};
+//# sourceMappingURL=table-utils.d.ts.map

package/dist/esm/interface/table-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-utils.d.ts","sourceRoot":"","sources":["../../../interface/table-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAU,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC7E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAGnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAOzD,eAAO,MAAM,aAAa,GAAI,GAAG,SAAS,EAAE,GAAG,SAAS,KAAG,OAMxD,CAAC;AAEJ,eAAO,MAAM,iBAAiB,GAC5B,WAAW;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC;IAAC,EAAE,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;CAAE,EACtE,UAAU,SAAS,EAAE,GAAG,SAAS,KAChC,OAQF,CAAC;AAEF,KAAK,qBAAqB,CAAC,CAAC,SAAS,QAAQ,IAAI;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IAClB,KAAK,EAAE,SAAS,CAAC;IACjB,iBAAiB,EAAE,CACjB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,uEAOhD,qBAAqB,CAAC,CAAC,CAAC,SAoC1B,CAAC"}

package/dist/esm/interface/table-utils.js

@@ -0,0 +1,38 @@
+import { createSheetDraft } from "../api/immer-utils";
+import { getNextTableColumnName } from "../helpers";
+import { SheetCell } from "../sheet-cell";
+// Excel rejects (recovers + drops) tables whose rectangles overlap on the same
+// sheet. Validate before mutating state so we never accumulate bad data that
+// later fails to export cleanly.
+export const rangesOverlap = (a, b) => !(a.endRowIndex < b.startRowIndex ||
+    b.endRowIndex < a.startRowIndex ||
+    a.endColumnIndex < b.startColumnIndex ||
+    b.endColumnIndex < a.startColumnIndex);
+export const tableWouldOverlap = (candidate, existing) => {
+    if (!existing?.length)
+        return false;
+    return existing.some((t) => t.sheetId === candidate.sheetId &&
+        t.id !== candidate.id &&
+        rangesOverlap(t.range, candidate.range));
+};
+export const addTableColumn = ({ draft, sheetId, range, getFormattedValue, locale, generatedNames, }) => {
+    // Validate first row
+    const columns = [];
+    const sheetCell = new SheetCell();
+    const currentSheet = createSheetDraft(draft, sheetId, range.startRowIndex);
+    for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+        const formattedValue = getFormattedValue(sheetId, range.startRowIndex, columnIndex);
+        // Get table column name
+        const columnName = getNextTableColumnName(columns, generatedNames);
+        // Add name to empty header cell
+        if (!formattedValue) {
+            sheetCell.assign(sheetId, { rowIndex: range.startRowIndex, columnIndex }, draft?.[sheetId]?.[range.startRowIndex]?.values?.[columnIndex], { locale });
+            sheetCell.setUserEnteredValue(columnName);
+            currentSheet[range.startRowIndex].values[columnIndex] =
+                sheetCell.getCellData();
+        }
+        columns.push({
+            name: formattedValue || columnName,
+        });
+    }
+};

package/dist/esm/interface/update-sheet.d.ts

@@ -0,0 +1,16 @@
+import type { CellCoordinate, CellNode, CellRangeNode } from "@rowsncolumns/dag";
+import { StaticNode } from "@rowsncolumns/dag";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseSpreadsheetProps } from "../hooks/use-spreadsheet-state";
+import type { SpreadsheetPatch } from "../hooks/use-undo-redo";
+export type UpdateSheetProps<T extends CellData, S extends Sheet> = {
+    sheets?: S[];
+    locale?: string;
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeSheetData?: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    getGraphNodes?: () => Map<string, CellNode | CellRangeNode | StaticNode>;
+    getPrecedents?: (source: CellCoordinate) => (CellNode | CellRangeNode | StaticNode)[];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+};
+export declare const updateSheet: <T extends CellData, S extends Sheet>({ sheets, locale, onChangeSheets, onChangeSheetData, getGraphNodes, getPrecedents, createHistory, }: UpdateSheetProps<T, S>) => (sheetId: number, sheetSpec: Partial<S>) => S | undefined;
+//# sourceMappingURL=update-sheet.d.ts.map

package/dist/esm/interface/update-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-sheet.d.ts","sourceRoot":"","sources":["../../../interface/update-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,QAAQ,EACR,aAAa,EACd,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAMjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAClE,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,iBAAiB,CAAC,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IACnE,aAAa,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,QAAQ,GAAG,aAAa,GAAG,UAAU,CAAC,CAAC;IACzE,aAAa,CAAC,EAAE,CACd,MAAM,EAAE,cAAc,KACnB,CAAC,QAAQ,GAAG,aAAa,GAAG,UAAU,CAAC,EAAE,CAAC;IAC/C,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACtD,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,qGAQ9D,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,MACf,SAAS,MAAM,EAAE,WAAW,OAAO,CAAC,CAAC,CAAC,kBAkF/C,CAAC"}

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

@@ -0,0 +1,64 @@
+import { produceWithPatches } from "immer";
+import { updateFormulaSheetReferences } from "../api/rename-sheet";
+import { sanitizeSheetSpecTitle } from "../helpers/sheet-title";
+export const updateSheet = ({ sheets, locale, onChangeSheets, onChangeSheetData, getGraphNodes, getPrecedents, createHistory, }) => {
+    return (sheetId, sheetSpec) => {
+        const saveHistory = createHistory();
+        const sanitizedSheetSpec = sanitizeSheetSpecTitle(sheetSpec);
+        const curSheet = sheets?.find((sheet) => sheet.sheetId === sheetId);
+        if (!curSheet) {
+            return undefined;
+        }
+        const oldTitle = curSheet.title;
+        const newTitle = sanitizedSheetSpec.title;
+        const isTitleChanging = newTitle !== undefined && newTitle !== oldTitle && oldTitle !== undefined;
+        // Update the sheet
+        onChangeSheets((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheetIndex = draft.findIndex((sheet) => sheet.sheetId === sheetId);
+                if (sheetIndex === -1) {
+                    throw new Error(`Sheet with ID ${sheetId} not found`);
+                }
+                // Update the sheet with the new spec
+                Object.assign(draft[sheetIndex], sanitizedSheetSpec);
+                // Validate sheetId
+                if (!draft[sheetIndex].sheetId) {
+                    draft[sheetIndex].sheetId = sheetId;
+                }
+            });
+            // Save to history
+            saveHistory({
+                sheets: { patches, inversePatches },
+                sheetId: { undo: sheetId, redo: sheetId },
+            });
+            return nextState;
+        });
+        // Update formula references if title changed
+        if (isTitleChanging &&
+            onChangeSheetData &&
+            getGraphNodes &&
+            getPrecedents) {
+            onChangeSheetData((prevSheetData) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                    updateFormulaSheetReferences(draft, {
+                        sheetId,
+                        oldName: oldTitle,
+                        newName: newTitle,
+                        locale,
+                        getGraphNodes,
+                        getPrecedents,
+                    });
+                });
+                // Save sheet data history
+                saveHistory({
+                    sheetData: { patches, inversePatches },
+                });
+                return nextState;
+            });
+        }
+        return {
+            ...curSheet,
+            ...sanitizedSheetSpec,
+        };
+    };
+};

package/dist/esm/interface/update-table.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import type { UseOnTableProps } from "../hooks/use-on-table";
+export declare const updateTable: <T extends CellData, S extends Sheet>({ locale, tables, enqueueCalculation, createHistory, onChangeTables, onChangeSheetData, getFormattedValue, getDependents, generatedNames, }: Pick<UseOnTableProps<T, S>, "locale" | "tables" | "enqueueCalculation" | "getDependents" | "createHistory" | "onChangeTables" | "onChangeSheetData" | "getFormattedValue" | "generatedNames">) => (sheetId: number, tableId: TableView["id"], updatedTable: Partial<TableView>) => void;
+//# sourceMappingURL=update-table.d.ts.map

package/dist/esm/interface/update-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-table.d.ts","sourceRoot":"","sources":["../../../interface/update-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAI5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAK7D,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,6IAU9D,IAAI,CACL,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,QAAQ,GACR,QAAQ,GACR,oBAAoB,GACpB,eAAe,GACf,eAAe,GACf,gBAAgB,GAChB,mBAAmB,GACnB,mBAAmB,GACnB,gBAAgB,CACnB,MAEG,SAAS,MAAM,EACf,SAAS,SAAS,CAAC,IAAI,CAAC,EACxB,cAAc,OAAO,CAAC,SAAS,CAAC,SA0JnC,CAAC"}

package/dist/esm/interface/update-table.js

@@ -0,0 +1,111 @@
+import { produceWithPatches } from "immer";
+import { getGeneratedTableColumnName } from "../generated-names";
+import { markTableAsDirty } from "./helpers";
+import { addTotalRow, removeTotalRow } from "./table-totalrow";
+import { addTableColumn, tableWouldOverlap } from "./table-utils";
+export const updateTable = ({ locale, tables, enqueueCalculation, createHistory, onChangeTables, onChangeSheetData, getFormattedValue, getDependents, generatedNames, }) => {
+    return (sheetId, tableId, updatedTable) => {
+        const saveHistory = createHistory();
+        const table = tables?.find((table) => table.id === tableId);
+        if (!table) {
+            return;
+        }
+        // Refuse range updates that would overlap a different table on the same
+        // sheet — Excel rejects overlapping tables on open.
+        if (updatedTable.range &&
+            tableWouldOverlap({ sheetId, range: updatedTable.range, id: tableId }, tables)) {
+            return;
+        }
+        // Resolve the fully-merged table up front so every consumer below —
+        // including the totals-row handlers, which run outside the state
+        // updaters — sees a concrete range and columns even when callers pass a
+        // partial spec and state updaters are applied asynchronously.
+        const newTable = {
+            ...table,
+            ...updatedTable,
+        };
+        const newColumnLength = newTable.range.endColumnIndex - newTable.range.startColumnIndex + 1;
+        if (newTable.headerRow) {
+            let emptyColumnCounter = newTable.columns?.length ?? 0;
+            if (!newTable.columns) {
+                newTable.columns = [];
+            }
+            // Set length
+            newTable.columns = newTable.columns.slice(0, newColumnLength);
+            for (let columnIndex = newTable.range.startColumnIndex; columnIndex <= newTable.range.endColumnIndex; columnIndex++) {
+                const formattedValue = getFormattedValue(sheetId, newTable.range.startRowIndex, columnIndex);
+                const colIndex = columnIndex - newTable.range.startColumnIndex;
+                if (!newTable.columns[colIndex]) {
+                    newTable.columns[colIndex] = {
+                        name: formattedValue ||
+                            getGeneratedTableColumnName(++emptyColumnCounter, generatedNames),
+                    };
+                }
+            }
+        }
+        // Total row has changed
+        // Only adjust range if totalRow is actually being toggled — a partial
+        // update that omits `totalRow` must not shrink a table that has one.
+        const hadTotalRow = table.totalRow === true;
+        const willHaveTotalRow = "totalRow" in updatedTable
+            ? updatedTable.totalRow === true
+            : hadTotalRow;
+        if (hadTotalRow !== willHaveTotalRow) {
+            let newEndRowIndex = newTable.range.endRowIndex;
+            if (willHaveTotalRow) {
+                // User has added a total row
+                newEndRowIndex++;
+            }
+            else {
+                // User has removed a total row
+                newEndRowIndex--;
+            }
+            newTable.range = {
+                ...newTable.range,
+                endRowIndex: newEndRowIndex,
+            };
+        }
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                addTableColumn({
+                    draft,
+                    getFormattedValue,
+                    sheetId,
+                    range: updatedTable.range ?? table.range,
+                    locale,
+                });
+            });
+            saveHistory({
+                sheetData: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Move tables if necessary
+        onChangeTables?.((prevTables) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTables, (draft) => {
+                const tableIndex = draft.findIndex((table) => table.id === tableId);
+                if (tableIndex !== -1) {
+                    // Set the merged table
+                    draft[tableIndex] = newTable;
+                }
+            });
+            // Mark table cells as dirty
+            const recalcCells = markTableAsDirty(table.sheetId, newTable.range, getDependents, enqueueCalculation);
+            saveHistory({
+                tables: { patches, inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        // Total row has changed
+        if (hadTotalRow !== willHaveTotalRow) {
+            if (willHaveTotalRow) {
+                addTotalRow({ locale, onChangeSheetData, enqueueCalculation })(sheetId, newTable, saveHistory);
+            }
+            else {
+                removeTotalRow({ locale, onChangeSheetData, enqueueCalculation })(sheetId, newTable, saveHistory);
+            }
+        }
+    };
+};

package/dist/esm/server-utils.d.ts

@@ -0,0 +1,8 @@
+export { SheetCell } from "./sheet-cell";
+export { cloneCellWithFormatting, createSheetDraft } from "./api/immer-utils";
+export { createSheetCellIdentifier } from "./api/formula";
+export type { CellXfsRegistry } from "./hooks/use-cellxfs-registry";
+export type { SharedStringRegistry } from "./hooks/use-ss-registry";
+export type { SheetData } from "./hooks/use-spreadsheet-state";
+export type { RecalcCellCoordinate } from "./types";
+//# sourceMappingURL=server-utils.d.ts.map

package/dist/esm/server-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-utils.d.ts","sourceRoot":"","sources":["../../server-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC9E,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAC1D,YAAY,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,YAAY,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACpE,YAAY,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC/D,YAAY,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC"}

package/dist/esm/server-utils.js

@@ -0,0 +1,3 @@
+export { SheetCell } from "./sheet-cell";
+export { cloneCellWithFormatting, createSheetDraft } from "./api/immer-utils";
+export { createSheetCellIdentifier } from "./api/formula";

package/dist/esm/server.browser.d.ts

@@ -0,0 +1,9 @@
+export { Spreadsheet } from "./interface/spreadsheet-interface";
+export { SheetCell } from "./sheet-cell";
+export { createSheetDraft } from "./api/immer-utils";
+export { createSheetCellIdentifier } from "./api/formula";
+export { registerPivotModule, isPivotAvailable, } from "./interface/pivot-extensions";
+export type { PivotModule } from "./interface/pivot-extensions";
+export type * from "./interface/spreadsheet-interface";
+export type { RecalcCellCoordinate } from "./types";
+//# sourceMappingURL=server.browser.d.ts.map

package/dist/esm/server.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.browser.d.ts","sourceRoot":"","sources":["../../server.browser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EACL,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,8BAA8B,CAAC;AACtC,YAAY,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,mBAAmB,mCAAmC,CAAC;AACvD,YAAY,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC"}

package/dist/esm/server.browser.js

@@ -0,0 +1,5 @@
+export { Spreadsheet } from "./interface/spreadsheet-interface";
+export { SheetCell } from "./sheet-cell";
+export { createSheetDraft } from "./api/immer-utils";
+export { createSheetCellIdentifier } from "./api/formula";
+export { registerPivotModule, isPivotAvailable, } from "./interface/pivot-extensions";

package/dist/esm/server.d.ts

@@ -0,0 +1,9 @@
+export { Spreadsheet } from "./interface/spreadsheet-interface";
+export { SheetCell } from "./sheet-cell";
+export { createSheetDraft } from "./api/immer-utils";
+export { createSheetCellIdentifier } from "./api/formula";
+export { registerPivotModule, isPivotAvailable, } from "./interface/pivot-extensions";
+export type { PivotModule } from "./interface/pivot-extensions";
+export type * from "./interface/spreadsheet-interface";
+export type { RecalcCellCoordinate } from "./types";
+//# sourceMappingURL=server.d.ts.map

package/dist/esm/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EACL,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,8BAA8B,CAAC;AACtC,YAAY,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,mBAAmB,mCAAmC,CAAC;AACvD,YAAY,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC"}

package/dist/esm/server.js

@@ -0,0 +1,5 @@
+export { Spreadsheet } from "./interface/spreadsheet-interface";
+export { SheetCell } from "./sheet-cell";
+export { createSheetDraft } from "./api/immer-utils";
+export { createSheetCellIdentifier } from "./api/formula";
+export { registerPivotModule, isPivotAvailable, } from "./interface/pivot-extensions";

package/dist/esm/shared-string-registry.d.ts

@@ -0,0 +1,35 @@
+import type { Patch } from "immer";
+import type { Dispatch, SetStateAction } from "react";
+import type { SheetCell } from "./sheet-cell";
+import type { SharedStrings } from "./types";
+import type { SpreadsheetPatch } from "./hooks/use-undo-redo";
+export declare class SharedStringRegistry {
+    readonly onChangeSharedStrings?: Dispatch<SetStateAction<SharedStrings>> | undefined;
+    private sharedStrings;
+    private incomingStrings;
+    constructor(sharedStrings?: SharedStrings | null, onChangeSharedStrings?: Dispatch<SetStateAction<SharedStrings>> | undefined);
+    get active(): boolean;
+    getSharedStrings(): SharedStrings | null | undefined;
+    registerCell(sheetCell: SheetCell): void;
+    /**
+     * Get-or-create a rich shared-string slot. The hash input is the
+     * canonical (text + runs) form, so:
+     *   - rich entries dedupe with identical-content rich entries (one
+     *     slot for 1000 cells of bold "abc"),
+     *   - rich entries can't collide with a plain entry of the same
+     *     text (the canonical's `RICH_MARKER` prefix is never a valid
+     *     plain string), and
+     *   - two rich entries with same text but different runs land at
+     *     different ids.
+     */
+    private getOrCreateRichIndex;
+    private findExistingRichIndex;
+    setSharedStrings(sharedStrings?: SharedStrings | null): void;
+    private getOrCreateIndex;
+    private idExists;
+    private createShortId;
+    private createUniqueId;
+    private findExistingIndex;
+    getPatches(saveHistory: (patches: SpreadsheetPatch<Patch>) => void): void;
+}
+//# sourceMappingURL=shared-string-registry.d.ts.map

package/dist/esm/shared-string-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-string-registry.d.ts","sourceRoot":"","sources":["../../shared-string-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAEnC,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAGtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAqB,MAAM,SAAS,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAO9D,qBAAa,oBAAoB;IAS7B,QAAQ,CAAC,qBAAqB,CAAC,EAAE,QAAQ,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;IAR1E,OAAO,CAAC,aAAa,CAAmC;IAIxD,OAAO,CAAC,eAAe,CAA6C;gBAGlE,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,EAC3B,qBAAqB,CAAC,EAAE,QAAQ,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,YAAA;IAK1E,IAAI,MAAM,YAET;IAED,gBAAgB;IAIhB,YAAY,CAAC,SAAS,EAAE,SAAS;IA8BjC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,oBAAoB;IAc5B,OAAO,CAAC,qBAAqB;IAoC7B,gBAAgB,CAAC,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI;IAIrD,OAAO,CAAC,gBAAgB;IAexB,OAAO,CAAC,QAAQ;IAkBhB,OAAO,CAAC,aAAa;IAwBrB,OAAO,CAAC,cAAc;IA4CtB,OAAO,CAAC,iBAAiB;IA6CzB,UAAU,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,IAAI;CA+BnE"}