@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/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/cjs/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/cjs/interface/table-totalrow.js

@@ -0,0 +1,170 @@
+import { __read, __values } from "tslib";
+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 var addTotalRow = function (_a) {
+    var locale = _a.locale, onChangeSheetData = _a.onChangeSheetData, enqueueCalculation = _a.enqueueCalculation;
+    return function (sheetId, updatedTable, saveHistory) {
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        /**
+         * 1. Validate number columns
+         * 2. Add Subtotal function
+         */
+        var numberColumnIndexes = [];
+        var sheetCell = new SheetCell();
+        var _a = updatedTable.range, startRowIndex = _a.startRowIndex, startColumnIndex = _a.startColumnIndex, endRowIndex = _a.endRowIndex, endColumnIndex = _a.endColumnIndex;
+        // Add total text
+        var totalRowIndex = endRowIndex;
+        /**
+         * Update sheet
+         */
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_1, _a;
+                var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+                // User is adding a total row
+                for (var columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
+                    var values = [];
+                    var isDateColumn = false;
+                    for (var rowIndex = startRowIndex + (updatedTable.headerRow ? 1 : 0); rowIndex < totalRowIndex; rowIndex++) {
+                        var cellData = (_d = (_c = (_b = draft[sheetId]) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[columnIndex];
+                        sheetCell.assign(sheetId, {
+                            rowIndex: rowIndex,
+                            columnIndex: columnIndex,
+                        }, cellData, { locale: locale });
+                        var effectiveValue = sheetCell.getEffectiveValue();
+                        var numberFormat = sheetCell.getNumberFormat();
+                        // Dates are stored as numbers, but summing them is meaningless
+                        if ((numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "DATE" ||
+                            (numberFormat === null || numberFormat === void 0 ? void 0 : numberFormat.type) === "DATE_TIME") {
+                            isDateColumn = true;
+                            break;
+                        }
+                        if (!isNil(effectiveValue)) {
+                            values.push(effectiveValue);
+                        }
+                    }
+                    if (!isDateColumn && values.length && values.every(isNumber)) {
+                        numberColumnIndexes.push(columnIndex);
+                    }
+                }
+                var currentSheet = createSheetDraft(draft, sheetId, totalRowIndex);
+                sheetCell.assign(sheetId, {
+                    rowIndex: totalRowIndex,
+                    columnIndex: startColumnIndex,
+                }, (_f = (_e = currentSheet[totalRowIndex]) === null || _e === void 0 ? void 0 : _e.values) === null || _f === void 0 ? void 0 : _f[startColumnIndex], { locale: 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();
+                try {
+                    // Add subtotal
+                    for (var numberColumnIndexes_1 = __values(numberColumnIndexes), numberColumnIndexes_1_1 = numberColumnIndexes_1.next(); !numberColumnIndexes_1_1.done; numberColumnIndexes_1_1 = numberColumnIndexes_1.next()) {
+                        var columnIndex = numberColumnIndexes_1_1.value;
+                        // The total label owns the first column
+                        if (columnIndex === startColumnIndex) {
+                            continue;
+                        }
+                        var rowIndex = totalRowIndex;
+                        var cellData = (_j = (_h = (_g = draft[sheetId]) === null || _g === void 0 ? void 0 : _g[rowIndex]) === null || _h === void 0 ? void 0 : _h.values) === null || _j === void 0 ? void 0 : _j[columnIndex];
+                        sheetCell.assign(sheetId, {
+                            columnIndex: columnIndex,
+                            rowIndex: rowIndex,
+                        }, cellData, { locale: locale });
+                        var columnName = (_l = (_k = updatedTable.columns) === null || _k === void 0 ? void 0 : _k[columnIndex - startColumnIndex]) === null || _l === void 0 ? void 0 : _l.name;
+                        if (columnName) {
+                            sheetCell.setUserEnteredValue("=SUBTOTAL(109, [".concat(columnName, "])"));
+                            // Bold, can be overridden by user
+                            sheetCell.setUserEnteredFormat("textFormat", {
+                                bold: true,
+                            });
+                            // Set cell data
+                            currentSheet[totalRowIndex].values[columnIndex] =
+                                sheetCell.getCellData();
+                            var position = {
+                                rowIndex: rowIndex,
+                                columnIndex: columnIndex,
+                                sheetId: sheetId,
+                            };
+                            enqueueCalculation({
+                                type: "add",
+                                position: position,
+                            });
+                            // Add sheet id
+                            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), position);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (numberColumnIndexes_1_1 && !numberColumnIndexes_1_1.done && (_a = numberColumnIndexes_1.return)) _a.call(numberColumnIndexes_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: 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 var removeTotalRow = function (_a) {
+    var locale = _a.locale, onChangeSheetData = _a.onChangeSheetData, enqueueCalculation = _a.enqueueCalculation;
+    return function (sheetId, updatedTable, saveHistory) {
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        var sheetCell = new SheetCell();
+        var _a = updatedTable.range, startColumnIndex = _a.startColumnIndex, endRowIndex = _a.endRowIndex, endColumnIndex = _a.endColumnIndex;
+        var totalRowIndex = endRowIndex + 1;
+        // Update sheetdata
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var currentSheet = createSheetDraft(draft, sheetId, totalRowIndex);
+                for (var columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
+                    sheetCell.assign(sheetId, { rowIndex: totalRowIndex, columnIndex: columnIndex }, undefined, { locale: locale });
+                    currentSheet[totalRowIndex].values[columnIndex] =
+                        sheetCell.getCellData();
+                    var position = {
+                        rowIndex: totalRowIndex,
+                        columnIndex: columnIndex,
+                        sheetId: sheetId,
+                    };
+                    enqueueCalculation({
+                        type: "add",
+                        position: position,
+                    });
+                    // Add sheet id
+                    recalcCells.set(createSheetCellIdentifier(sheetId, totalRowIndex, columnIndex), position);
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/cjs/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/cjs/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/cjs/interface/table-utils.js

@@ -0,0 +1,44 @@
+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 var rangesOverlap = function (a, b) {
+    return !(a.endRowIndex < b.startRowIndex ||
+        b.endRowIndex < a.startRowIndex ||
+        a.endColumnIndex < b.startColumnIndex ||
+        b.endColumnIndex < a.startColumnIndex);
+};
+export var tableWouldOverlap = function (candidate, existing) {
+    if (!(existing === null || existing === void 0 ? void 0 : existing.length))
+        return false;
+    return existing.some(function (t) {
+        return t.sheetId === candidate.sheetId &&
+            t.id !== candidate.id &&
+            rangesOverlap(t.range, candidate.range);
+    });
+};
+export var addTableColumn = function (_a) {
+    var _b, _c, _d;
+    var draft = _a.draft, sheetId = _a.sheetId, range = _a.range, getFormattedValue = _a.getFormattedValue, locale = _a.locale, generatedNames = _a.generatedNames;
+    // Validate first row
+    var columns = [];
+    var sheetCell = new SheetCell();
+    var currentSheet = createSheetDraft(draft, sheetId, range.startRowIndex);
+    for (var columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+        var formattedValue = getFormattedValue(sheetId, range.startRowIndex, columnIndex);
+        // Get table column name
+        var columnName = getNextTableColumnName(columns, generatedNames);
+        // Add name to empty header cell
+        if (!formattedValue) {
+            sheetCell.assign(sheetId, { rowIndex: range.startRowIndex, columnIndex: columnIndex }, (_d = (_c = (_b = draft === null || draft === void 0 ? void 0 : draft[sheetId]) === null || _b === void 0 ? void 0 : _b[range.startRowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[columnIndex], { locale: locale });
+            sheetCell.setUserEnteredValue(columnName);
+            currentSheet[range.startRowIndex].values[columnIndex] =
+                sheetCell.getCellData();
+        }
+        columns.push({
+            name: formattedValue || columnName,
+        });
+    }
+};

package/dist/cjs/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/cjs/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/cjs/interface/update-sheet.js

@@ -0,0 +1,63 @@
+import { __assign, __read } from "tslib";
+import { produceWithPatches } from "immer";
+import { updateFormulaSheetReferences } from "../api/rename-sheet";
+import { sanitizeSheetSpecTitle } from "../helpers/sheet-title";
+export var updateSheet = function (_a) {
+    var sheets = _a.sheets, locale = _a.locale, onChangeSheets = _a.onChangeSheets, onChangeSheetData = _a.onChangeSheetData, getGraphNodes = _a.getGraphNodes, getPrecedents = _a.getPrecedents, createHistory = _a.createHistory;
+    return function (sheetId, sheetSpec) {
+        var saveHistory = createHistory();
+        var sanitizedSheetSpec = sanitizeSheetSpecTitle(sheetSpec);
+        var curSheet = sheets === null || sheets === void 0 ? void 0 : sheets.find(function (sheet) { return sheet.sheetId === sheetId; });
+        if (!curSheet) {
+            return undefined;
+        }
+        var oldTitle = curSheet.title;
+        var newTitle = sanitizedSheetSpec.title;
+        var isTitleChanging = newTitle !== undefined && newTitle !== oldTitle && oldTitle !== undefined;
+        // Update the sheet
+        onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var sheetIndex = draft.findIndex(function (sheet) { return sheet.sheetId === sheetId; });
+                if (sheetIndex === -1) {
+                    throw new Error("Sheet with ID ".concat(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;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save to history
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+                sheetId: { undo: sheetId, redo: sheetId },
+            });
+            return nextState;
+        });
+        // Update formula references if title changed
+        if (isTitleChanging &&
+            onChangeSheetData &&
+            getGraphNodes &&
+            getPrecedents) {
+            onChangeSheetData(function (prevSheetData) {
+                var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                    updateFormulaSheetReferences(draft, {
+                        sheetId: sheetId,
+                        oldName: oldTitle,
+                        newName: newTitle,
+                        locale: locale,
+                        getGraphNodes: getGraphNodes,
+                        getPrecedents: getPrecedents,
+                    });
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                // Save sheet data history
+                saveHistory({
+                    sheetData: { patches: patches, inversePatches: inversePatches },
+                });
+                return nextState;
+            });
+        }
+        return __assign(__assign({}, curSheet), sanitizedSheetSpec);
+    };
+};

package/dist/cjs/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/cjs/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/cjs/interface/update-table.js

@@ -0,0 +1,109 @@
+import { __assign, __read } from "tslib";
+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 var updateTable = function (_a) {
+    var locale = _a.locale, tables = _a.tables, enqueueCalculation = _a.enqueueCalculation, createHistory = _a.createHistory, onChangeTables = _a.onChangeTables, onChangeSheetData = _a.onChangeSheetData, getFormattedValue = _a.getFormattedValue, getDependents = _a.getDependents, generatedNames = _a.generatedNames;
+    return function (sheetId, tableId, updatedTable) {
+        var _a, _b;
+        var saveHistory = createHistory();
+        var table = tables === null || tables === void 0 ? void 0 : tables.find(function (table) { return 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: 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.
+        var newTable = __assign(__assign({}, table), updatedTable);
+        var newColumnLength = newTable.range.endColumnIndex - newTable.range.startColumnIndex + 1;
+        if (newTable.headerRow) {
+            var emptyColumnCounter = (_b = (_a = newTable.columns) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+            if (!newTable.columns) {
+                newTable.columns = [];
+            }
+            // Set length
+            newTable.columns = newTable.columns.slice(0, newColumnLength);
+            for (var columnIndex = newTable.range.startColumnIndex; columnIndex <= newTable.range.endColumnIndex; columnIndex++) {
+                var formattedValue = getFormattedValue(sheetId, newTable.range.startRowIndex, columnIndex);
+                var 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.
+        var hadTotalRow = table.totalRow === true;
+        var willHaveTotalRow = "totalRow" in updatedTable
+            ? updatedTable.totalRow === true
+            : hadTotalRow;
+        if (hadTotalRow !== willHaveTotalRow) {
+            var newEndRowIndex = newTable.range.endRowIndex;
+            if (willHaveTotalRow) {
+                // User has added a total row
+                newEndRowIndex++;
+            }
+            else {
+                // User has removed a total row
+                newEndRowIndex--;
+            }
+            newTable.range = __assign(__assign({}, newTable.range), { endRowIndex: newEndRowIndex });
+        }
+        // Update sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var _a;
+                addTableColumn({
+                    draft: draft,
+                    getFormattedValue: getFormattedValue,
+                    sheetId: sheetId,
+                    range: (_a = updatedTable.range) !== null && _a !== void 0 ? _a : table.range,
+                    locale: locale,
+                });
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Move tables if necessary
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTables) {
+            var _a = __read(produceWithPatches(prevTables, function (draft) {
+                var tableIndex = draft.findIndex(function (table) { return table.id === tableId; });
+                if (tableIndex !== -1) {
+                    // Set the merged table
+                    draft[tableIndex] = newTable;
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Mark table cells as dirty
+            var recalcCells = markTableAsDirty(table.sheetId, newTable.range, getDependents, enqueueCalculation);
+            saveHistory({
+                tables: { patches: patches, inversePatches: inversePatches },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        // Total row has changed
+        if (hadTotalRow !== willHaveTotalRow) {
+            if (willHaveTotalRow) {
+                addTotalRow({ locale: locale, onChangeSheetData: onChangeSheetData, enqueueCalculation: enqueueCalculation })(sheetId, newTable, saveHistory);
+            }
+            else {
+                removeTotalRow({ locale: locale, onChangeSheetData: onChangeSheetData, enqueueCalculation: enqueueCalculation })(sheetId, newTable, saveHistory);
+            }
+        }
+    };
+};

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