@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,39 @@
+import type { CellFormat, GridRange } from "@rowsncolumns/common-types";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnChangeBatchProps } from "../hooks/use-on-change-batch";
+export interface ChangeBatchOptions {
+    /**
+     * Whether to enable formula evaluation and recalculation after the change
+     * @default true
+     */
+    enableEvaluation?: boolean;
+    /**
+     * Whether to record changes in history for undo/redo
+     * @default true
+     */
+    enableHistory?: boolean;
+    /**
+     * When true, only applies formatting without changing cell values
+     * Useful when you want to preserve existing values but apply new formatting
+     * @default false
+     */
+    formattingOnly?: boolean;
+    /**
+     * Skip ``detectValueTypeAndPattern`` and write each cell with whatever
+     * JavaScript type was passed in. Strings stay ``stringValue``, numbers
+     * stay ``numberValue``, booleans stay ``boolValue`` — no auto-coercion
+     * of date-looking strings, no markdown / ``@``-prefix munging.
+     *
+     * Default is ``false`` because the cell-editor UX (typing into a cell in
+     * Olympus) expects Excel-style auto-detection — typing ``"Feb 17, 2025"``
+     * yields a real date. SDK callers (e.g. athena-openpyxl going through
+     * xlsx-studio's ``apps/api`` applier) should pass ``true`` so that
+     * ``ws["A5"] = "Feb 17, 2025"`` stays a string (matching stock openpyxl)
+     * and ``ws["A5"] = datetime(...)`` flows through as a pre-converted
+     * Excel serial number with the SDK-supplied number format.
+     * @default false
+     */
+    disableTypeInference?: boolean;
+}
+export declare const changeBatch: <T extends CellData, K extends CellFormat, S extends Sheet = Sheet>({ createHistory, enqueueCalculation, onChangeSheetData, onChangeSheets, onChangeTableColumn, onChangeCalculatedColumn, tokenizer, getEffectiveValuesFromRange, locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getFormattedValue, getUserEnteredValue, getCellDimensions, getRowHeight, isMergedCell, tables, onChangeCitations, }: UseOnChangeBatchProps<T, S>) => (sheetId: number, ranges: GridRange[] | GridRange, values: (string | boolean | number | undefined | null)[][] | string | boolean | number | undefined | null, formatting?: (K | undefined | null)[][] | K | null | undefined, citations?: (string | undefined | null)[][] | string | null | undefined, options?: ChangeBatchOptions) => void;
+//# sourceMappingURL=change-batch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"change-batch.d.ts","sourceRoot":"","sources":["../../../interface/change-batch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EACV,QAAQ,EAER,KAAK,EAEN,MAAM,2BAA2B,CAAC;AAiBnC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAI1E,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,eAAO,MAAM,WAAW,GACtB,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,KAAK,GAAG,KAAK,EACvB,0VAoBC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,MAE1B,SAAS,MAAM,EACf,QAAQ,SAAS,EAAE,GAAG,SAAS,EAC/B,QACI,CAAC,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,GAClD,MAAM,GACN,OAAO,GACP,MAAM,GACN,SAAS,GACT,IAAI,EACR,aAAa,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,IAAI,GAAG,SAAS,EAC9D,YAAY,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EAAE,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EACvE,UAAS,kBAAuB,SAoZnC,CAAC"}

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

@@ -0,0 +1,282 @@
+import { DEFAULT_COLUMN_COUNT, DEFAULT_ROW_COUNT, MAX_COLUMN_COUNT, MAX_ROW_COUNT, } from "@rowsncolumns/utils";
+import { isNil } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { findActiveTableWithinCell, findAdjacentTable, removeTableName, } from "../api/table";
+import { SheetCell } from "../sheet-cell";
+export const changeBatch = ({ createHistory, enqueueCalculation, onChangeSheetData, onChangeSheets, onChangeTableColumn, onChangeCalculatedColumn, tokenizer, getEffectiveValuesFromRange, locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, getFormattedValue, getUserEnteredValue, getCellDimensions, getRowHeight, isMergedCell, tables, onChangeCitations, }) => {
+    return (sheetId, ranges, values, formatting, citations, options = {}) => {
+        const { enableEvaluation = true, enableHistory = true, formattingOnly = false, disableTypeInference = false, } = options;
+        const saveHistory = enableHistory ? createHistory() : () => undefined;
+        // We need to track this for history. Precedent cells
+        const recalcCells = new Map();
+        // Create a sheet cell
+        const sheetCell = new SheetCell();
+        // Track max row and column indices to update sheet bounds
+        // Calculate these before the async callbacks
+        const finalRanges = Array.isArray(ranges) ? ranges : [ranges];
+        const primaryRange = finalRanges[0];
+        let maxRowIndex = 0;
+        let maxColumnIndex = 0;
+        for (const range of finalRanges) {
+            maxRowIndex = Math.max(maxRowIndex, range.endRowIndex);
+            maxColumnIndex = Math.max(maxColumnIndex, range.endColumnIndex);
+        }
+        const coords = primaryRange
+            ? {
+                rowIndex: primaryRange.startRowIndex,
+                columnIndex: primaryRange.startColumnIndex,
+            }
+            : undefined;
+        const value = Array.isArray(values) ? values[0]?.[0] : values;
+        let adjacentTable;
+        let isRowExpansion = false;
+        let isColumnExpansion = false;
+        let currentTable;
+        if (!formattingOnly && tables?.length && coords) {
+            [adjacentTable, isRowExpansion, isColumnExpansion] = findAdjacentTable(sheetId, coords, tables, getUserEnteredValue);
+            currentTable =
+                isColumnExpansion && adjacentTable
+                    ? adjacentTable
+                    : findActiveTableWithinCell(sheetId, coords, tables);
+        }
+        // Update sheet data
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                for (const range of finalRanges) {
+                    for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                        for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                            const absoluteRowIndex = rowIndex - range.startRowIndex;
+                            const absoluteColumnIndex = columnIndex - range.startColumnIndex;
+                            const value = Array.isArray(values)
+                                ? values[absoluteRowIndex]?.[absoluteColumnIndex]
+                                : values;
+                            const cellFormat = Array.isArray(formatting)
+                                ? formatting[absoluteRowIndex]?.[absoluteColumnIndex]
+                                : formatting;
+                            const coords = { rowIndex, columnIndex };
+                            const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                            const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                            // Create a cell
+                            sheetCell.assign(sheetId, coords, cellData, {
+                                getRangeValues: getEffectiveValuesFromRange,
+                                locale,
+                                cellXfsRegistry,
+                                getDataValidationById,
+                                sharedStringRegistry,
+                            });
+                            // Set text value of the cell
+                            // Skip value changes if formattingOnly is true
+                            if (!formattingOnly) {
+                                if (isNil(value)) {
+                                    sheetCell.deleteContents();
+                                }
+                                else {
+                                    sheetCell.setUserEnteredValue(value, undefined, {
+                                        disableTypeInference,
+                                    });
+                                }
+                            }
+                            // Apply formatting
+                            if (cellFormat) {
+                                // Add cellformat
+                                for (const key in cellFormat) {
+                                    // Set user entered format
+                                    sheetCell.setUserEnteredFormat(key, cellFormat[key]);
+                                }
+                            }
+                            // Apply citations
+                            if (citations !== undefined) {
+                                const citationId = Array.isArray(citations)
+                                    ? citations[absoluteRowIndex]?.[absoluteColumnIndex]
+                                    : citations;
+                                if (citationId === null) {
+                                    // Explicitly clear citation
+                                    sheetCell.clearCitationId();
+                                }
+                                else if (citationId) {
+                                    // Set citation
+                                    sheetCell.updateCitationId(citationId);
+                                }
+                                // If citationId is undefined, leave existing citation unchanged
+                            }
+                            sharedStringRegistry?.registerCell(sheetCell);
+                            // Set cell data
+                            currentSheet[rowIndex].values[columnIndex] =
+                                sheetCell.getCellData();
+                            // Register cellXfs
+                            cellXfsRegistry?.registerCellXfs(sheetCell);
+                            const requiresRecalc = !formattingOnly ||
+                                (cellFormat && "numberFormat" in cellFormat);
+                            if (enableEvaluation && requiresRecalc) {
+                                const forceCalculation = formattingOnly ? false : true;
+                                // Formatting-only edits no longer need to flow through the
+                                // calculator — dependents derive format lazily at render
+                                // time. Value edits still enqueue an "add" to update the
+                                // dependency graph and trigger recalc.
+                                if (!formattingOnly) {
+                                    enqueueCalculation({
+                                        position: { rowIndex, columnIndex, sheetId },
+                                        type: "add",
+                                        force: forceCalculation,
+                                    });
+                                }
+                                // Add to recalc cells (replayed as "add" on undo)
+                                recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                    rowIndex,
+                                    columnIndex,
+                                    sheetId,
+                                    force: forceCalculation,
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: {
+                    inversePatches,
+                    patches,
+                },
+                // activeCell: { undo: coords, redo: coords },
+                sheetId: { undo: sheetId, redo: sheetId },
+                recalcCells: { undo: recalcCells, redo: recalcCells },
+            });
+            return nextState;
+        });
+        // Update sheet rowCount and columnCount if values were added beyond current bounds
+        onChangeSheets?.((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((s) => s.sheetId === sheetId);
+                if (sheet) {
+                    // Update rowCount if necessary
+                    sheet.rowCount = Math.min(MAX_ROW_COUNT, Math.max(sheet.rowCount ?? DEFAULT_ROW_COUNT, maxRowIndex));
+                    // Update columnCount if necessary
+                    sheet.columnCount = Math.min(MAX_COLUMN_COUNT, Math.max(sheet.columnCount ?? DEFAULT_COLUMN_COUNT, maxColumnIndex));
+                }
+            });
+            // Add sheet patches
+            saveHistory({
+                sheets: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Save cellXfs
+        cellXfsRegistry?.getPatches(saveHistory);
+        // Save shared strings patches
+        sharedStringRegistry?.getPatches(saveHistory);
+        // Update row heights when text format or wrapping changes
+        let shouldUpdateRowHeights = false;
+        if (Array.isArray(formatting)) {
+            shouldUpdateRowHeights = formatting.some((row) => row.some((cellFormat) => cellFormat?.textFormat || cellFormat?.wrapStrategy));
+        }
+        else {
+            shouldUpdateRowHeights = !!(formatting?.textFormat || formatting?.wrapStrategy);
+        }
+        if (shouldUpdateRowHeights) {
+            onChangeSheets((prevSheets) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                    const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                    if (sheet) {
+                        for (const range of finalRanges) {
+                            let rollingRowIndex = 0;
+                            for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                                if (Array.isArray(formatting) &&
+                                    rollingRowIndex > formatting.length - 1) {
+                                    rollingRowIndex = 0;
+                                }
+                                const currentRowHeight = getRowHeight?.(sheetId, rowIndex, (index) => index >= range.startColumnIndex &&
+                                    index <= range.endColumnIndex);
+                                let maxRowHeight = currentRowHeight ?? 0;
+                                let didUpdateRowHeight = false;
+                                const isResizedByUser = !!sheet.rowMetadata?.[rowIndex]?.resizedByUser;
+                                if (isResizedByUser) {
+                                    rollingRowIndex++;
+                                    continue;
+                                }
+                                let rollingColumnIndex = 0;
+                                for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                                    if (Array.isArray(formatting) &&
+                                        rollingColumnIndex > formatting[0].length - 1) {
+                                        rollingColumnIndex = 0;
+                                    }
+                                    if (isMergedCell?.(sheetId, rowIndex, columnIndex)) {
+                                        rollingColumnIndex++;
+                                        continue;
+                                    }
+                                    const cellFormat = Array.isArray(formatting)
+                                        ? formatting[rollingRowIndex][rollingColumnIndex]
+                                        : formatting;
+                                    if (!cellFormat ||
+                                        (!cellFormat.textFormat && !cellFormat.wrapStrategy)) {
+                                        rollingColumnIndex++;
+                                        continue;
+                                    }
+                                    const overrideValue = Array.isArray(values)
+                                        ? values[rollingRowIndex]?.[rollingColumnIndex]
+                                        : values;
+                                    const formattedValue = !isNil(overrideValue) && overrideValue !== ""
+                                        ? String(overrideValue)
+                                        : 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)) {
+                                        maxRowHeight = Math.max(maxRowHeight, newCellDimension?.height ?? 0);
+                                        didUpdateRowHeight = true;
+                                    }
+                                    rollingColumnIndex++;
+                                }
+                                if (didUpdateRowHeight &&
+                                    !isNil(currentRowHeight) &&
+                                    maxRowHeight > 0) {
+                                    if (!sheet.rowMetadata) {
+                                        sheet.rowMetadata = [];
+                                    }
+                                    if (!sheet.rowMetadata[rowIndex] ||
+                                        typeof sheet.rowMetadata[rowIndex] !== "object") {
+                                        sheet.rowMetadata[rowIndex] = {};
+                                    }
+                                    sheet.rowMetadata[rowIndex].size = maxRowHeight;
+                                }
+                                rollingRowIndex++;
+                            }
+                        }
+                    }
+                });
+                saveHistory({
+                    sheets: { patches, inversePatches },
+                });
+                return nextState;
+            });
+        }
+        if (!formattingOnly && tables?.length && primaryRange && coords) {
+            if (onChangeTableColumn) {
+                onChangeTableColumn(sheetId, coords, value, adjacentTable, isRowExpansion, isColumnExpansion, primaryRange);
+            }
+            if (onChangeCalculatedColumn) {
+                const isAdjacentColumn = currentTable &&
+                    coords.columnIndex === currentTable.range.endColumnIndex + 1;
+                const adjustedValue = isAdjacentColumn &&
+                    typeof value === "string" &&
+                    currentTable &&
+                    tokenizer
+                    ? removeTableName(tokenizer(value), currentTable.title)
+                    : value;
+                onChangeCalculatedColumn(sheetId, coords, adjustedValue, currentTable);
+            }
+        }
+    };
+};

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

@@ -0,0 +1,5 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { BorderLocation, BorderStyle, CellData, Color, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseOnChangeFormattingProps } from "../hooks/use-on-change-formatting";
+export declare const changeBorder: <T extends CellData, S extends Sheet>({ createHistory, onChangeSheetData, locale, cellXfsRegistry, getDataValidationById, }: UseOnChangeFormattingProps<T, S>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], location: BorderLocation, color: Color | undefined, style?: BorderStyle | undefined) => void;
+//# sourceMappingURL=change-border.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"change-border.d.ts","sourceRoot":"","sources":["../../../interface/change-border.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE/E,OAAO,KAAK,EAEV,cAAc,EACd,WAAW,EACX,QAAQ,EACR,KAAK,EACL,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AAMnC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAGpF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,uFAM/D,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC,MAE/B,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAChD,UAAU,cAAc,EACxB,OAAO,KAAK,GAAG,SAAS,EACxB,QAAO,WAAW,GAAG,SAAmB,SAwI3C,CAAC"}

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

@@ -0,0 +1,116 @@
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { getBorderWidthFromStyle } from "../api/border";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+export const changeBorder = ({ createHistory, onChangeSheetData, locale, cellXfsRegistry, getDataValidationById, }) => {
+    return (sheetId, activeCell, selections, location, color, style = "solid") => {
+        const finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        const saveHistory = createHistory();
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                // Create a cell
+                const sheetCell = new SheetCell();
+                for (const selection of finalSelections) {
+                    for (const [rowIndex, columnIndex] of iterateCellsInRange(selection.range)) {
+                        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        const cellData = currentSheet[rowIndex]?.values?.[columnIndex];
+                        // Create a cell
+                        sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, { locale, cellXfsRegistry, getDataValidationById });
+                        // Selected border
+                        const selectedBorder = {
+                            color,
+                            style,
+                            width: getBorderWidthFromStyle(style),
+                        };
+                        if (location === "all") {
+                            sheetCell.setAllBorders({
+                                color,
+                                style,
+                                width: getBorderWidthFromStyle(style),
+                            });
+                        }
+                        // Outisde
+                        if (location === "outer") {
+                            if (rowIndex === selection.range.startRowIndex) {
+                                sheetCell.setBorder("top", selectedBorder);
+                            }
+                            if (columnIndex === selection.range.startColumnIndex) {
+                                sheetCell.setBorder("left", selectedBorder);
+                            }
+                            if (columnIndex === selection.range.endColumnIndex) {
+                                sheetCell.setBorder("right", selectedBorder);
+                            }
+                            if (rowIndex === selection.range.endRowIndex) {
+                                sheetCell.setBorder("bottom", selectedBorder);
+                            }
+                        }
+                        // Inside
+                        if (location === "inner") {
+                            if (columnIndex !== selection.range.startColumnIndex) {
+                                sheetCell.setBorder("left", selectedBorder);
+                            }
+                            if (rowIndex !== selection.range.startRowIndex) {
+                                sheetCell.setBorder("top", selectedBorder);
+                            }
+                        }
+                        // Horizontal
+                        if (location === "horizontal") {
+                            if (rowIndex !== selection.range.endRowIndex) {
+                                sheetCell.setBorder("bottom", selectedBorder);
+                            }
+                        }
+                        // Vertical
+                        if (location === "vertical") {
+                            if (columnIndex !== selection.range.endColumnIndex) {
+                                sheetCell.setBorder("right", selectedBorder);
+                            }
+                        }
+                        // Left
+                        if (location === "left") {
+                            if (columnIndex === selection.range.startColumnIndex) {
+                                sheetCell.setBorder("left", selectedBorder);
+                            }
+                        }
+                        // Right
+                        if (location === "right") {
+                            if (columnIndex === selection.range.endColumnIndex) {
+                                sheetCell.setBorder("right", selectedBorder);
+                            }
+                        }
+                        // Bottom
+                        if (location === "bottom") {
+                            if (rowIndex === selection.range.endRowIndex) {
+                                sheetCell.setBorder("bottom", selectedBorder);
+                            }
+                        }
+                        // top
+                        if (location === "top") {
+                            if (rowIndex === selection.range.startRowIndex) {
+                                sheetCell.setBorder("top", selectedBorder);
+                            }
+                        }
+                        // Set cell data
+                        currentSheet[rowIndex].values[columnIndex] =
+                            sheetCell.getCellData();
+                        // Register cellXfs
+                        cellXfsRegistry?.registerCellXfs(sheetCell);
+                    }
+                }
+            });
+            // Save history
+            saveHistory({
+                sheetData: { patches, inversePatches },
+                sheetId: { redo: sheetId, undo: sheetId },
+                selections: { undo: selections, redo: selections },
+                activeCell: { undo: activeCell, redo: activeCell },
+            });
+            return nextState;
+        });
+        // Save cellXfs
+        cellXfsRegistry?.getPatches(saveHistory);
+    };
+};

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

@@ -0,0 +1,5 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { CellData, TableView } from "@rowsncolumns/spreadsheet";
+import type { UseOnChangeCalculatedColumnProps } from "../hooks/use-on-change-calculated-column";
+export declare const changeCalculatedColumn: <T extends CellData>({ locale, sharedStringRegistry, cellXfsRegistry, onChangeTables, onChangeSheetData, getUserEnteredValue, getSheetName, createHistory, enqueueCalculation, onCommand, }: UseOnChangeCalculatedColumnProps<T>) => (sheetId: number, coords: CellInterface, value: string | boolean | undefined, currentTable: TableView | undefined) => void;
+//# sourceMappingURL=change-calculated-column.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"change-calculated-column.d.ts","sourceRoot":"","sources":["../../../interface/change-calculated-column.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,4BAA4B,CAAC;AAC3E,OAAO,KAAK,EAEV,QAAQ,EACR,SAAS,EACV,MAAM,2BAA2B,CAAC;AAOnC,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,0CAA0C,CAAC;AAIjG,eAAO,MAAM,sBAAsB,GAChC,CAAC,SAAS,QAAQ,EAAE,wKAWlB,gCAAgC,CAAC,CAAC,CAAC,MAEpC,SAAS,MAAM,EACf,QAAQ,aAAa,EACrB,OAAO,MAAM,GAAG,OAAO,GAAG,SAAS,EACnC,cAAc,SAAS,GAAG,SAAS,SAuKpC,CAAC"}

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

@@ -0,0 +1,120 @@
+import { isAFormula, iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetCellIdentifier } from "../api/formula";
+import { createSheetDraft } from "../api/immer-utils";
+import { isTableColumnCellsFillable } from "../api/table";
+import { SheetCell } from "../sheet-cell";
+export const changeCalculatedColumn = ({ locale, sharedStringRegistry, cellXfsRegistry, onChangeTables, onChangeSheetData, getUserEnteredValue, getSheetName, createHistory, enqueueCalculation, onCommand, }) => (sheetId, coords, value, currentTable) => {
+    const activeSheetName = getSheetName(sheetId);
+    const recalcCells = new Map();
+    const isFormula = isAFormula(value);
+    if (!isFormula || !currentTable) {
+        return;
+    }
+    const columnOffset = coords.columnIndex - currentTable.range.startColumnIndex;
+    const columnDefinition = currentTable.columns?.[columnOffset];
+    const existingColumnFormula = columnDefinition
+        ?.formula;
+    const range = {
+        ...currentTable.range,
+        startRowIndex: currentTable.headerRow ?? true
+            ? currentTable.range.startRowIndex + 1
+            : currentTable.range.startRowIndex,
+        endRowIndex: currentTable.totalRow
+            ? currentTable.range.endRowIndex - 1
+            : currentTable.range.endRowIndex,
+        startColumnIndex: coords.columnIndex,
+        endColumnIndex: coords.columnIndex,
+    };
+    const isTableFillable = isTableColumnCellsFillable(sheetId, range, coords, existingColumnFormula, value, activeSheetName, getUserEnteredValue);
+    if (!isTableFillable) {
+        return;
+    }
+    // Stream the intent: the engine fills the whole column body with the row-relativized formula
+    // (the windowed UI can't reach every row). Emitted only once the fill conditions hold, so the
+    // engine fills exactly when the UI does. `value` is the formula string (isFormula checked above).
+    onCommand?.({
+        command: "calculated-column",
+        sheetId,
+        tableId: currentTable.id,
+        columnIndex: coords.columnIndex,
+        formula: value,
+        fromRowIndex: coords.rowIndex,
+    });
+    const saveHistory = createHistory();
+    onChangeSheetData?.((prevSheetData) => {
+        const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+            const sheetCell = new SheetCell();
+            for (const [rowIndex, columnIndex] of iterateCellsInRange(range)) {
+                if (coords.rowIndex === rowIndex) {
+                    continue;
+                }
+                const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                const cellData = currentSheet[rowIndex].values?.[columnIndex];
+                sheetCell.assign(sheetId, coords, cellData, {
+                    locale,
+                    cellXfsRegistry,
+                    sharedStringRegistry,
+                });
+                const previousFormula = sheetCell.formula;
+                const structuredValue = sheetCell.effectiveValue?.structuredValue;
+                sheetCell.setUserEnteredValue(value);
+                if (structuredValue) {
+                    sheetCell.setStructuredValue(structuredValue);
+                }
+                const newFormula = isFormula
+                    ? SheetCell.getRelativeFormula(value, coords, {
+                        rowIndex,
+                        columnIndex,
+                    }, activeSheetName)
+                    : undefined;
+                const formulaChanged = previousFormula !== newFormula;
+                const shouldResetValue = isFormula && formulaChanged;
+                if (shouldResetValue) {
+                    if (sheetCell.isFormula()) {
+                        sheetCell.moveFormula(coords, {
+                            rowIndex,
+                            columnIndex,
+                        }, activeSheetName);
+                    }
+                    sharedStringRegistry?.registerCell(sheetCell);
+                    currentSheet[rowIndex].values[columnIndex] =
+                        sheetCell.getCellData();
+                    enqueueCalculation({
+                        position: { rowIndex, columnIndex, sheetId },
+                        type: "add",
+                        force: true,
+                    });
+                    recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                        rowIndex,
+                        columnIndex,
+                        sheetId,
+                        force: true,
+                    });
+                }
+            }
+        });
+        saveHistory({
+            sheetData: { patches, inversePatches },
+            recalcCells: { undo: recalcCells, redo: recalcCells },
+        });
+        return nextState;
+    });
+    onChangeTables?.((prevTableData) => {
+        const [nextState, patches, inversePatches] = produceWithPatches(prevTableData, (draft) => {
+            const table = draft.find((table) => table.id === currentTable.id);
+            if (table) {
+                const column = table.columns?.[coords.columnIndex - table.range.startColumnIndex];
+                if (column) {
+                    column.formula = value;
+                }
+            }
+        });
+        saveHistory({
+            tables: { patches, inversePatches },
+        });
+        return nextState;
+    });
+    // Save shared strings patches
+    sharedStringRegistry?.getPatches(saveHistory);
+};

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

@@ -0,0 +1,7 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import type { UseChangeDecimalsProps } from "../hooks/use-on-change-decimals";
+type UpDownType = "increment" | "decrement";
+export declare const changeDecimals: <T extends CellData>({ locale, onChangeSheetData, createHistory, getDataValidationById, cellXfsRegistry, }: UseChangeDecimalsProps<T>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], type: UpDownType) => void;
+export {};
+//# sourceMappingURL=change-decimals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"change-decimals.d.ts","sourceRoot":"","sources":["../../../interface/change-decimals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE/E,OAAO,KAAK,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAK/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAG9E,KAAK,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC;AAE5C,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,QAAQ,EAAE,uFAMhD,sBAAsB,CAAC,CAAC,CAAC,MAExB,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,YAAY,aAAa,CAAC,mBAAmB,CAAC,EAAE,EAChD,MAAM,UAAU,SAiEnB,CAAC"}

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

@@ -0,0 +1,58 @@
+import { selectionFromActiveCell } from "@rowsncolumns/utils";
+import { iterateCellsInRange } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+export const changeDecimals = ({ locale, onChangeSheetData, createHistory, getDataValidationById, cellXfsRegistry, }) => {
+    return (sheetId, activeCell, selections, type) => {
+        const finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        const saveHistory = createHistory();
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                // Create a cell
+                const sheetCell = new SheetCell();
+                for (const sel of finalSelections) {
+                    for (const [rowIndex, columnIndex] of iterateCellsInRange(sel.range)) {
+                        const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        const cellData = currentSheet[rowIndex]?.values?.[columnIndex];
+                        // Create a cell
+                        sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+                            locale,
+                            cellXfsRegistry,
+                            getDataValidationById,
+                        });
+                        if (type === "decrement") {
+                            sheetCell.decreaseDecimals();
+                        }
+                        else {
+                            sheetCell.increaseDecimals();
+                        }
+                        // Set cell data
+                        currentSheet[rowIndex].values[columnIndex] =
+                            sheetCell.getCellData();
+                        // Register cellXfs
+                        cellXfsRegistry?.registerCellXfs(sheetCell);
+                        // Decimals edits are format-only: the renderer derives the
+                        // formatted value lazily at paint time, so no calc enqueue
+                        // here and no recalcCells entry to replay on undo/redo.
+                    }
+                }
+            });
+            // 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
+        cellXfsRegistry?.getPatches(saveHistory);
+    };
+};