@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/interface/change-formatting.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, FormattingType, Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnChangeFormattingWithCellFormat, OnChangeFormattingWithTypeValue, UseOnChangeFormattingProps } from "../hooks/use-on-change-formatting";
+export declare const changeFormatting: <T extends CellData, S extends Sheet, K extends FormattingType>({ createHistory, getFormattedValue, isMergedCell, onChangeSheetData, onChangeSheets, getRowHeight, getCellDimensions, locale, cellXfsRegistry, getDataValidationById, }: UseOnChangeFormattingProps<T, S>) => (...args: Parameters<OnChangeFormattingWithTypeValue<K> | OnChangeFormattingWithCellFormat>) => void;
+//# sourceMappingURL=change-formatting.d.ts.map

package/dist/esm/interface/change-formatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-formatting.d.ts","sourceRoot":"","sources":["../../../interface/change-formatting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAER,cAAc,EACd,KAAK,EACN,MAAM,2BAA2B,CAAC;AAKnC,OAAO,KAAK,EAEV,gCAAgC,EAChC,+BAA+B,EAC/B,0BAA0B,EAC3B,MAAM,mCAAmC,CAAC;AAG3C,eAAO,MAAM,gBAAgB,GAC3B,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,KAAK,EACf,CAAC,SAAS,cAAc,EACxB,yKAWC,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC,MAE/B,GAAG,MAAM,UAAU,CACjB,+BAA+B,CAAC,CAAC,CAAC,GAAG,gCAAgC,CACtE,SAiTJ,CAAC"}

package/dist/esm/interface/change-formatting.js

@@ -0,0 +1,209 @@
+import { isNil } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+export const changeFormatting = ({ createHistory, getFormattedValue, isMergedCell, onChangeSheetData, onChangeSheets, getRowHeight, getCellDimensions, locale, cellXfsRegistry, getDataValidationById, }) => {
+    return (...args) => {
+        let sheetId;
+        let activeCell;
+        let selections;
+        let type;
+        let value;
+        let cellFormatOrCellFormatArray;
+        let formattingOptions;
+        if (typeof args[3] === "string") {
+            [sheetId, activeCell, selections, type, value, formattingOptions] =
+                args;
+            // Cell format
+            cellFormatOrCellFormatArray = { [type]: value };
+        }
+        else {
+            [
+                sheetId,
+                activeCell,
+                selections,
+                cellFormatOrCellFormatArray,
+                formattingOptions,
+            ] = args;
+        }
+        const finalSelections = selections.length
+            ? selections
+            : [
+                {
+                    range: {
+                        startRowIndex: activeCell.rowIndex,
+                        endRowIndex: activeCell.rowIndex,
+                        startColumnIndex: activeCell.columnIndex,
+                        endColumnIndex: activeCell.columnIndex,
+                    },
+                },
+            ];
+        const saveHistory = createHistory();
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                // Create a cell
+                const sheetCell = new SheetCell();
+                for (const sel of finalSelections) {
+                    let rollingRowIndex = 0;
+                    for (let rowIndex = sel.range.startRowIndex; rowIndex <= sel.range.endRowIndex; rowIndex++) {
+                        if (Array.isArray(cellFormatOrCellFormatArray) &&
+                            rollingRowIndex > cellFormatOrCellFormatArray.length - 1) {
+                            rollingRowIndex = 0;
+                        }
+                        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        let rollingColumnIndex = 0;
+                        for (let columnIndex = sel.range.startColumnIndex; columnIndex <= sel.range.endColumnIndex; columnIndex++) {
+                            if (Array.isArray(cellFormatOrCellFormatArray) &&
+                                rollingColumnIndex > cellFormatOrCellFormatArray[0].length - 1) {
+                                rollingColumnIndex = 0;
+                            }
+                            const cellData = currentSheet[rowIndex]?.values?.[columnIndex];
+                            // Create a cell
+                            sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+                                locale,
+                                cellXfsRegistry,
+                                getDataValidationById,
+                            });
+                            const cellFormat = Array.isArray(cellFormatOrCellFormatArray)
+                                ? cellFormatOrCellFormatArray[rollingRowIndex][rollingColumnIndex]
+                                : cellFormatOrCellFormatArray;
+                            // clear format
+                            if (formattingOptions?.replace) {
+                                sheetCell.clearUserEnteredFormat();
+                            }
+                            // Add cellformat
+                            for (const key in cellFormat) {
+                                // Set user entered format
+                                sheetCell.setUserEnteredFormat(key, cellFormat[key]);
+                            }
+                            // Set cell data
+                            currentSheet[rowIndex].values[columnIndex] =
+                                sheetCell.getCellData();
+                            // Register cellXfs
+                            cellXfsRegistry?.registerCellXfs(sheetCell);
+                            // Format-only edits no longer trigger a recalc on undo/redo:
+                            // the renderer derives effective format lazily at paint time
+                            // from the restored `uf`, so re-running the calculator for
+                            // these cells is wasted work.
+                            // Roll
+                            rollingColumnIndex++;
+                        }
+                        // Roll
+                        rollingRowIndex++;
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: {
+                    inversePatches,
+                    patches,
+                },
+                activeCell: { undo: activeCell, redo: activeCell },
+                selections: { undo: selections, redo: selections },
+                sheetId: { undo: sheetId, redo: undefined },
+            });
+            return nextState;
+        });
+        // Save cellXfs
+        // Order here matters since we are reading shouldWrap
+        // in getCellDimensions
+        cellXfsRegistry?.getPatches(saveHistory);
+        // Update row heights
+        // When text format and wrap changes,
+        // we have to resize the cells
+        // Check if any cellFormat has textFormat or wrapStrategy
+        let shouldUpdateRowHeights = false;
+        if (Array.isArray(cellFormatOrCellFormatArray)) {
+            shouldUpdateRowHeights = cellFormatOrCellFormatArray.some((row) => row.some((cellFormat) => cellFormat?.textFormat || cellFormat?.wrapStrategy));
+        }
+        else {
+            shouldUpdateRowHeights = !!(cellFormatOrCellFormatArray?.textFormat ||
+                cellFormatOrCellFormatArray?.wrapStrategy);
+        }
+        if (shouldUpdateRowHeights) {
+            onChangeSheets((prevSheets) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                    const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                    if (sheet) {
+                        for (const sel of finalSelections) {
+                            let rollingRowIndex = 0;
+                            for (let rowIndex = sel.range.startRowIndex; rowIndex <= sel.range.endRowIndex; rowIndex++) {
+                                if (Array.isArray(cellFormatOrCellFormatArray) &&
+                                    rollingRowIndex > cellFormatOrCellFormatArray.length - 1) {
+                                    rollingRowIndex = 0;
+                                }
+                                const currentRowHeight = getRowHeight?.(sheetId, rowIndex, 
+                                // Exclude columns within the selection
+                                (index) => index >= sel.range.startColumnIndex &&
+                                    index <= sel.range.endColumnIndex);
+                                let rollingColumnIndex = 0;
+                                for (let columnIndex = sel.range.startColumnIndex; columnIndex <= sel.range.endColumnIndex; columnIndex++) {
+                                    if (Array.isArray(cellFormatOrCellFormatArray) &&
+                                        rollingColumnIndex >
+                                            cellFormatOrCellFormatArray[0].length - 1) {
+                                        rollingColumnIndex = 0;
+                                    }
+                                    // Ignore merged cells
+                                    if (isMergedCell?.(sheetId, rowIndex, columnIndex)) {
+                                        rollingColumnIndex++;
+                                        continue;
+                                    }
+                                    const cellFormat = Array.isArray(cellFormatOrCellFormatArray)
+                                        ? cellFormatOrCellFormatArray[rollingRowIndex][rollingColumnIndex]
+                                        : cellFormatOrCellFormatArray;
+                                    // Skip if no cellFormat or no textFormat/wrapStrategy
+                                    if (!cellFormat ||
+                                        (!cellFormat.textFormat && !cellFormat.wrapStrategy)) {
+                                        rollingColumnIndex++;
+                                        continue;
+                                    }
+                                    const isResizedByUser = !!sheet.rowMetadata?.[rowIndex]?.resizedByUser;
+                                    // Skip if this row was resized by user
+                                    if (isResizedByUser) {
+                                        rollingColumnIndex++;
+                                        continue;
+                                    }
+                                    const formattedValue = getFormattedValue?.(sheetId, rowIndex, columnIndex);
+                                    const shouldWrap = cellFormat.wrapStrategy
+                                        ? cellFormat.wrapStrategy === "wrap"
+                                        : undefined;
+                                    const fontSize = cellFormat.textFormat?.fontSize;
+                                    const newCellDimension = getCellDimensions?.(sheetId, rowIndex, columnIndex, "x", {
+                                        textOverride: formattedValue ?? undefined,
+                                        textFormatOverride: fontSize
+                                            ? {
+                                                fontSize,
+                                            }
+                                            : undefined,
+                                        shouldWrapOverride: shouldWrap,
+                                    });
+                                    if (!isNil(newCellDimension) && !isNil(currentRowHeight)) {
+                                        const finalRowHeight = Math.max(newCellDimension?.height ?? 0, currentRowHeight ?? 0);
+                                        if (!sheet.rowMetadata) {
+                                            sheet.rowMetadata = [];
+                                        }
+                                        if (!sheet.rowMetadata[rowIndex] ||
+                                            typeof sheet.rowMetadata[rowIndex] !== "object") {
+                                            sheet.rowMetadata[rowIndex] = {};
+                                        }
+                                        sheet.rowMetadata[rowIndex].size = finalRowHeight;
+                                    }
+                                    // Roll
+                                    rollingColumnIndex++;
+                                }
+                                // Roll
+                                rollingRowIndex++;
+                            }
+                        }
+                    }
+                });
+                saveHistory({
+                    sheets: { patches, inversePatches },
+                });
+                return nextState;
+            });
+        }
+    };
+};

package/dist/esm/interface/change-sheet-tabcolor.d.ts

@@ -0,0 +1,4 @@
+import { type CellData, type Color, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnChangeSheetTabcolorProps } from "../hooks/use-on-change-sheet-tabcolor";
+export declare const changeSheetTabcolor: <T extends CellData, S extends Sheet>({ onChangeSheets, createHistory, }: UseOnChangeSheetTabcolorProps<T, S>) => (sheetId: number, color: Color | undefined) => void;
+//# sourceMappingURL=change-sheet-tabcolor.d.ts.map

package/dist/esm/interface/change-sheet-tabcolor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-sheet-tabcolor.d.ts","sourceRoot":"","sources":["../../../interface/change-sheet-tabcolor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,KAAK,EACV,KAAK,KAAK,EACX,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uCAAuC,CAAC;AAE3F,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,oCAGtE,6BAA6B,CAAC,CAAC,EAAE,CAAC,CAAC,MAC5B,SAAS,MAAM,EAAE,OAAO,KAAK,GAAG,SAAS,SAqBlD,CAAC"}

package/dist/esm/interface/change-sheet-tabcolor.js

@@ -0,0 +1,19 @@
+import { produceWithPatches } from "immer";
+export const changeSheetTabcolor = ({ onChangeSheets, createHistory, }) => {
+    return (sheetId, color) => {
+        const saveHistory = createHistory();
+        onChangeSheets((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet) {
+                    sheet.tabColor = color;
+                }
+            });
+            // Save to history
+            saveHistory({
+                sheets: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/change-table-column.d.ts

@@ -0,0 +1,49 @@
+import type { CellInterface, GridRange } from "@rowsncolumns/common-types";
+import type { CellData, ParsedToken, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import type { Draft } from "immer";
+import type { CellXfsRegistry } from "../cellxfs-registry";
+import type { CalculationOperation, useCalculation } from "../hooks/use-calculation";
+import type { UseOnChangeTableColumnProps } from "../hooks/use-on-change-table-column";
+import type { SheetData } from "../hooks/use-spreadsheet-state";
+import type { RecalcCellCoordinate } from "../types";
+type ChangeTableColumnFactoryProps<T extends CellData, S extends Sheet> = UseOnChangeTableColumnProps<T, S> & {
+    tokenizer?: (value: string) => ParsedToken[];
+};
+export declare const changeTableColumn: <T extends CellData, S extends Sheet>({ locale, cellXfsRegistry, sharedStringRegistry, onChangeSheetData, onChangeTables, getDependents, enqueueCalculation, enqueueGraphOperation, createHistory, tokenizer, generatedNames, }: ChangeTableColumnFactoryProps<T, S>) => (sheetId: number, coords: CellInterface, value: string | boolean | undefined, currentTable: TableView | undefined, isRowExpansion: boolean, isColumnExpansion: boolean, range: GridRange) => void;
+export declare const addCalculatedColumnsForRowExpansion: <T extends CellData>({ sheetId, locale, currentTable, draft, recalcCells, range, enqueueCalculation, getDependents, }: {
+    sheetId: number;
+    locale: string | undefined;
+    currentTable: TableView;
+    draft: Draft<SheetData<T>>;
+    recalcCells: Map<string, RecalcCellCoordinate>;
+    range: GridRange;
+    enqueueCalculation(operation: CalculationOperation): void;
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+}) => void;
+/**
+ * When a table auto-expands downward, Excel applies the column's
+ * existing formatting to the new row's cells -- but only when every
+ * body cell in that column shares the same `userEnteredFormat`. If a
+ * column is inconsistent (user painted A2 red, A3 black, A4 blue),
+ * Excel applies nothing there. The whole row is styled at the moment
+ * of expansion so the band doesn't appear column-by-column as the
+ * user types into siblings. This implements that pass.
+ *
+ * Banded fills themselves come from the table style at render time
+ * (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.
+ */
+export declare const propagateColumnFormatsForRowExpansion: <T extends CellData>({ sheetId, locale, currentTable, draft, cellXfsRegistry, newRowStart, newRowEnd, }: {
+    sheetId: number;
+    locale: string | undefined;
+    currentTable: TableView;
+    draft: Draft<SheetData<T>>;
+    cellXfsRegistry?: CellXfsRegistry;
+    newRowStart: number;
+    newRowEnd: number;
+}) => void;
+export declare const processTableDependentCells: (table: TableView, getDependents: ReturnType<typeof useCalculation>["getDependents"], recalcCells: Map<string, RecalcCellCoordinate>, enqueueCalculation: (operation: CalculationOperation) => void) => void;
+export {};
+//# sourceMappingURL=change-table-column.d.ts.map

package/dist/esm/interface/change-table-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-table-column.d.ts","sourceRoot":"","sources":["../../../interface/change-table-column.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAE3E,OAAO,KAAK,EAEV,QAAQ,EACR,WAAW,EACX,KAAK,EACL,SAAS,EACV,MAAM,2BAA2B,CAAC;AAMnC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAMnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EACV,oBAAoB,EACpB,cAAc,EACf,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAC;AACvF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAEhE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErD,KAAK,6BAA6B,CAChC,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,KAAK,IACb,2BAA2B,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;IACtC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,WAAW,EAAE,CAAC;CAC9C,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC3B,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,2LAYnC,6BAA6B,CAAC,CAAC,EAAE,CAAC,CAAC,MAEpC,SAAS,MAAM,EACf,QAAQ,aAAa,EACrB,OAAO,MAAM,GAAG,OAAO,GAAG,SAAS,EACnC,cAAc,SAAS,GAAG,SAAS,EACnC,gBAAgB,OAAO,EACvB,mBAAmB,OAAO,EAC1B,OAAO,SAAS,SAsMjB,CAAC;AAEJ,eAAO,MAAM,mCAAmC,GAAI,CAAC,SAAS,QAAQ,EAAE,kGASrE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,YAAY,EAAE,SAAS,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC/C,KAAK,EAAE,SAAS,CAAC;IACjB,kBAAkB,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC1D,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;CACnE,SAqDA,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qCAAqC,GAAI,CAAC,SAAS,QAAQ,EAAE,oFAQvE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,YAAY,EAAE,SAAS,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,SA6DA,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,OAAO,SAAS,EAChB,eAAe,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,EACjE,aAAa,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC9C,oBAAoB,CAAC,SAAS,EAAE,oBAAoB,KAAK,IAAI,SAgC9D,CAAC"}

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

@@ -0,0 +1,247 @@
+import { isStaticNode } from "@rowsncolumns/dag";
+import { getCellXfsKey, isNil, iterateCellsInRange, } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+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) => {
+    if (isNil(currentTable)) {
+        return;
+    }
+    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;
+    const isEnteringNewColumnName = currentTable.range.startRowIndex === coords.rowIndex;
+    const saveHistory = createHistory();
+    const isAdjacentColumn = coords.columnIndex === currentTable.range.endColumnIndex + 1;
+    onChangeSheetData?.((prevSheetData) => {
+        const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+            if (isAdjacentColumn && !isNil(value) && typeof value !== "boolean") {
+                const currentSheet = createSheetDraft(draft, sheetId, coords.rowIndex);
+                const sheetCell = new SheetCell(sheetId, coords, currentSheet?.[coords.rowIndex].values?.[coords.columnIndex], { locale, cellXfsRegistry, sharedStringRegistry });
+                const finalValue = sheetCell.formula && tokenizer
+                    ? removeTableName(tokenizer(value), currentTable.title)
+                    : value;
+                sheetCell.setUserEnteredValue(finalValue);
+                currentSheet[coords.rowIndex].values[coords.columnIndex] =
+                    sheetCell.getCellData();
+                recalcCells.set(createSheetCellIdentifier(sheetId, coords.rowIndex, coords.columnIndex), {
+                    ...coords,
+                    sheetId,
+                });
+            }
+            if (isColumnExpansion && !isEnteringNewColumnName) {
+                const columnCell = {
+                    rowIndex: currentTable.range.startRowIndex,
+                    columnIndex: currentTable.range.endColumnIndex + 1,
+                };
+                const currentSheet = createSheetDraft(draft, sheetId, columnCell.rowIndex);
+                const sheetCell = new SheetCell(sheetId, columnCell, undefined, {
+                    locale,
+                });
+                sheetCell.setUserEnteredValue(newColumnName);
+                currentSheet[columnCell.rowIndex].values[columnCell.columnIndex] =
+                    sheetCell.getCellData();
+                enqueueGraphOperation({
+                    position: { ...columnCell, sheetId },
+                    type: "add",
+                });
+                recalcCells.set(createSheetCellIdentifier(sheetId, columnCell.rowIndex, columnCell.columnIndex), {
+                    ...columnCell,
+                    sheetId,
+                });
+            }
+            if (isRowExpansion) {
+                recalcCells.set(createSheetCellIdentifier(sheetId, coords.rowIndex, coords.columnIndex), {
+                    ...coords,
+                    sheetId,
+                });
+                addCalculatedColumnsForRowExpansion({
+                    sheetId,
+                    locale,
+                    currentTable,
+                    draft,
+                    enqueueCalculation,
+                    recalcCells,
+                    range: {
+                        ...currentTable.range,
+                        startRowIndex: range.startRowIndex,
+                        endRowIndex: range.endRowIndex,
+                    },
+                    getDependents,
+                });
+                propagateColumnFormatsForRowExpansion({
+                    sheetId,
+                    locale,
+                    currentTable,
+                    draft,
+                    cellXfsRegistry,
+                    newRowStart: coords.rowIndex,
+                    newRowEnd: coords.rowIndex + (range.endRowIndex - range.startRowIndex),
+                });
+            }
+            if (isRowExpansion || isColumnExpansion) {
+                processTableDependentCells(currentTable, getDependents, recalcCells, enqueueCalculation);
+            }
+        });
+        saveHistory({
+            sheetData: { patches, inversePatches },
+            recalcCells: { undo: recalcCells, redo: recalcCells },
+            ...(isAdjacentColumn
+                ? { activeCell: { undo: coords, redo: coords } }
+                : {}),
+        });
+        return nextState;
+    });
+    onChangeTables?.((prevTableData) => {
+        const [nextState, patches, inversePatches] = produceWithPatches(prevTableData, (draft) => {
+            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));
+                }
+                if (isColumnExpansion && newColumnName) {
+                    table.range.endColumnIndex += 1;
+                    table.columns?.push({
+                        name: newColumnName,
+                        filterButton: true,
+                    });
+                }
+            }
+        });
+        saveHistory({
+            tables: { patches, inversePatches },
+        });
+        return nextState;
+    });
+};
+export const addCalculatedColumnsForRowExpansion = ({ sheetId, locale, currentTable, draft, recalcCells, range, enqueueCalculation, getDependents, }) => {
+    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,
+                    });
+                }
+            }
+        }
+    }
+};
+/**
+ * When a table auto-expands downward, Excel applies the column's
+ * existing formatting to the new row's cells -- but only when every
+ * body cell in that column shares the same `userEnteredFormat`. If a
+ * column is inconsistent (user painted A2 red, A3 black, A4 blue),
+ * Excel applies nothing there. The whole row is styled at the moment
+ * of expansion so the band doesn't appear column-by-column as the
+ * user types into siblings. This implements that pass.
+ *
+ * Banded fills themselves come from the table style at render time
+ * (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.
+ */
+export const propagateColumnFormatsForRowExpansion = ({ sheetId, locale, currentTable, draft, cellXfsRegistry, newRowStart, newRowEnd, }) => {
+    const { startColumnIndex, endColumnIndex, startRowIndex, endRowIndex } = currentTable.range;
+    const bodyStart = startRowIndex + (currentTable.headerRow ?? true ? 1 : 0);
+    const bodyEnd = endRowIndex;
+    if (bodyEnd < bodyStart)
+        return;
+    // 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;
+    const probe = new SheetCell();
+    const target = new SheetCell();
+    for (let columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
+        let sharedKey;
+        let sharedFormat;
+        let consistent = true;
+        for (let r = bodyStart; r <= bodyEnd; r++) {
+            const cellData = draft[sheetId]?.[r]?.values?.[columnIndex];
+            probe.assign(sheetId, { rowIndex: r, columnIndex }, cellData, { locale, cellXfsRegistry });
+            const resolved = probe.getUserEnteredFormat();
+            if (!resolved) {
+                consistent = false;
+                break;
+            }
+            const key = getCellXfsKey(resolved);
+            if (sharedKey === undefined) {
+                sharedKey = key;
+                sharedFormat = resolved;
+            }
+            else if (key !== sharedKey) {
+                consistent = false;
+                break;
+            }
+        }
+        if (!consistent || !sharedFormat)
+            continue;
+        for (let r = newRowStart; r <= newRowEnd; r++) {
+            const currentSheet = createSheetDraft(draft, sheetId, r);
+            const existingCell = currentSheet[r].values?.[columnIndex];
+            target.assign(sheetId, { rowIndex: r, columnIndex }, existingCell, { locale, cellXfsRegistry });
+            if (target.getUserEnteredFormat())
+                continue;
+            target.inheritFormat(sharedFormat);
+            currentSheet[r].values[columnIndex] = target.getCellData();
+        }
+    }
+};
+export const processTableDependentCells = (table, getDependents, recalcCells, enqueueCalculation) => {
+    const deps = new Set();
+    for (const [rowIndex, columnIndex] of iterateCellsInRange(table.range)) {
+        const dependents = getDependents({
+            rowIndex,
+            columnIndex,
+            sheetId: table.sheetId,
+        });
+        for (const dependent of dependents) {
+            if (isStaticNode(dependent)) {
+                continue;
+            }
+            deps.add(dependent);
+        }
+    }
+    for (const { position } of deps) {
+        enqueueCalculation({
+            type: "add",
+            position,
+        });
+        recalcCells.set(createSheetCellIdentifier(table.sheetId, position.rowIndex, position.columnIndex), position);
+    }
+};

package/dist/esm/interface/change-theme.d.ts

@@ -0,0 +1,4 @@
+import type { CellData, SpreadsheetTheme } from "@rowsncolumns/spreadsheet";
+import type { UseOnChangeThemeProps } from "../hooks/use-on-change-theme";
+export declare const changeTheme: <T extends CellData>({ createHistory, onChangeTheme, }: UseOnChangeThemeProps<T>) => (theme: SpreadsheetTheme) => void;
+//# sourceMappingURL=change-theme.d.ts.map

package/dist/esm/interface/change-theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-theme.d.ts","sourceRoot":"","sources":["../../../interface/change-theme.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAG5E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAE1E,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,mCAG7C,qBAAqB,CAAC,CAAC,CAAC,MACjB,OAAO,gBAAgB,SAyBhC,CAAC"}

package/dist/esm/interface/change-theme.js

@@ -0,0 +1,21 @@
+import { produceWithPatches } from "immer";
+export const changeTheme = ({ createHistory, onChangeTheme, }) => {
+    return (theme) => {
+        const saveHistory = createHistory();
+        // if (theme.primaryFontFamily !== "Arial") {
+        // await loadWebFont([
+        //   theme.primaryFontFamily,
+        //   `${theme.primaryFontFamily}:bold`,
+        // ]).catch(() => {
+        //   console.log("Error loading font", theme);
+        // });
+        // }
+        onChangeTheme?.((prevTheme) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevTheme, () => theme);
+            saveHistory({
+                theme: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    };
+};

package/dist/esm/interface/chart-extensions.d.ts

@@ -0,0 +1,32 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, EmbeddedChart, SelectionAttributes } from "@rowsncolumns/spreadsheet";
+type CreateChartFunction = <T extends CellData>(props: {
+    onChangeCharts: any;
+    getFormattedValue: any;
+    getEffectiveValue: any;
+    createHistory: any;
+}) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], chartSpec?: EmbeddedChart) => void;
+type DeleteChartFunction = <T extends CellData>(props: {
+    onChangeCharts: any;
+    createHistory: any;
+}) => (chartId: string | number) => void;
+type MoveChartFunction = <T extends CellData>(props: {
+    onChangeCharts: any;
+    createHistory: any;
+}) => (chartId: string | number, anchorCell: CellInterface, offsetXPixels: number, offsetYPixels: number) => void;
+type ResizeChartFunction = <T extends CellData>(props: {
+    onChangeCharts: any;
+    createHistory: any;
+}) => (chartId: string | number, anchorCell: CellInterface, offsetXPixels: number, offsetYPixels: number, width: number, height: number) => void;
+type UpdateChartFunction = <T extends CellData>(props: {
+    onChangeCharts: any;
+    createHistory: any;
+}) => (chart: EmbeddedChart) => void;
+export declare const isChartsAvailable: () => boolean;
+export declare const safeCreateChart: CreateChartFunction;
+export declare const safeDeleteChart: DeleteChartFunction;
+export declare const safeMoveChart: MoveChartFunction;
+export declare const safeResizeChart: ResizeChartFunction;
+export declare const safeUpdateChart: UpdateChartFunction;
+export {};
+//# sourceMappingURL=chart-extensions.d.ts.map

package/dist/esm/interface/chart-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-extensions.d.ts","sourceRoot":"","sources":["../../../interface/chart-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EACb,mBAAmB,EACpB,MAAM,2BAA2B,CAAC;AAMnC,KAAK,mBAAmB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE;IACrD,cAAc,EAAE,GAAG,CAAC;IACpB,iBAAiB,EAAE,GAAG,CAAC;IACvB,iBAAiB,EAAE,GAAG,CAAC;IACvB,aAAa,EAAE,GAAG,CAAC;CACpB,KAAK,CACJ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,aAAa,EACzB,UAAU,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAChD,SAAS,CAAC,EAAE,aAAa,KACtB,IAAI,CAAC;AAEV,KAAK,mBAAmB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE;IACrD,cAAc,EAAE,GAAG,CAAC;IACpB,aAAa,EAAE,GAAG,CAAC;CACpB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,KAAK,IAAI,CAAC;AAEzC,KAAK,iBAAiB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE;IACnD,cAAc,EAAE,GAAG,CAAC;IACpB,aAAa,EAAE,GAAG,CAAC;CACpB,KAAK,CACJ,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,UAAU,EAAE,aAAa,EACzB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,KAClB,IAAI,CAAC;AAEV,KAAK,mBAAmB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE;IACrD,cAAc,EAAE,GAAG,CAAC;IACpB,aAAa,EAAE,GAAG,CAAC;CACpB,KAAK,CACJ,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,UAAU,EAAE,aAAa,EACzB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,KACX,IAAI,CAAC;AAEV,KAAK,mBAAmB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE;IACrD,cAAc,EAAE,GAAG,CAAC;IACpB,aAAa,EAAE,GAAG,CAAC;CACpB,KAAK,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;AA8BrC,eAAO,MAAM,iBAAiB,QAAO,OAQpC,CAAC;AAUF,eAAO,MAAM,eAAe,EAAE,mBAK7B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,mBAK7B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,iBAK3B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,mBAK7B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,mBAK7B,CAAC"}