@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,329 @@
+import { __read, __values } from "tslib";
+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 var changeBatch = function (_a) {
+    var createHistory = _a.createHistory, enqueueCalculation = _a.enqueueCalculation, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTableColumn = _a.onChangeTableColumn, onChangeCalculatedColumn = _a.onChangeCalculatedColumn, tokenizer = _a.tokenizer, getEffectiveValuesFromRange = _a.getEffectiveValuesFromRange, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getDataValidationById = _a.getDataValidationById, getFormattedValue = _a.getFormattedValue, getUserEnteredValue = _a.getUserEnteredValue, getCellDimensions = _a.getCellDimensions, getRowHeight = _a.getRowHeight, isMergedCell = _a.isMergedCell, tables = _a.tables, onChangeCitations = _a.onChangeCitations;
+    return function (sheetId, ranges, values, formatting, citations, options) {
+        var e_1, _a, _b;
+        var _c;
+        if (options === void 0) { options = {}; }
+        var _d = options.enableEvaluation, enableEvaluation = _d === void 0 ? true : _d, _e = options.enableHistory, enableHistory = _e === void 0 ? true : _e, _f = options.formattingOnly, formattingOnly = _f === void 0 ? false : _f, _g = options.disableTypeInference, disableTypeInference = _g === void 0 ? false : _g;
+        var saveHistory = enableHistory ? createHistory() : function () { return undefined; };
+        // We need to track this for history. Precedent cells
+        var recalcCells = new Map();
+        // Create a sheet cell
+        var sheetCell = new SheetCell();
+        // Track max row and column indices to update sheet bounds
+        // Calculate these before the async callbacks
+        var finalRanges = Array.isArray(ranges) ? ranges : [ranges];
+        var primaryRange = finalRanges[0];
+        var maxRowIndex = 0;
+        var maxColumnIndex = 0;
+        try {
+            for (var finalRanges_1 = __values(finalRanges), finalRanges_1_1 = finalRanges_1.next(); !finalRanges_1_1.done; finalRanges_1_1 = finalRanges_1.next()) {
+                var range = finalRanges_1_1.value;
+                maxRowIndex = Math.max(maxRowIndex, range.endRowIndex);
+                maxColumnIndex = Math.max(maxColumnIndex, range.endColumnIndex);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (finalRanges_1_1 && !finalRanges_1_1.done && (_a = finalRanges_1.return)) _a.call(finalRanges_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var coords = primaryRange
+            ? {
+                rowIndex: primaryRange.startRowIndex,
+                columnIndex: primaryRange.startColumnIndex,
+            }
+            : undefined;
+        var value = Array.isArray(values) ? (_c = values[0]) === null || _c === void 0 ? void 0 : _c[0] : values;
+        var adjacentTable;
+        var isRowExpansion = false;
+        var isColumnExpansion = false;
+        var currentTable;
+        if (!formattingOnly && (tables === null || tables === void 0 ? void 0 : tables.length) && coords) {
+            _b = __read(findAdjacentTable(sheetId, coords, tables, getUserEnteredValue), 3), adjacentTable = _b[0], isRowExpansion = _b[1], isColumnExpansion = _b[2];
+            currentTable =
+                isColumnExpansion && adjacentTable
+                    ? adjacentTable
+                    : findActiveTableWithinCell(sheetId, coords, tables);
+        }
+        // Update sheet data
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_2, _a;
+                var _b, _c, _d, _e;
+                try {
+                    for (var finalRanges_2 = __values(finalRanges), finalRanges_2_1 = finalRanges_2.next(); !finalRanges_2_1.done; finalRanges_2_1 = finalRanges_2.next()) {
+                        var range = finalRanges_2_1.value;
+                        for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                            for (var columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                                var absoluteRowIndex = rowIndex - range.startRowIndex;
+                                var absoluteColumnIndex = columnIndex - range.startColumnIndex;
+                                var value_1 = Array.isArray(values)
+                                    ? (_b = values[absoluteRowIndex]) === null || _b === void 0 ? void 0 : _b[absoluteColumnIndex]
+                                    : values;
+                                var cellFormat = Array.isArray(formatting)
+                                    ? (_c = formatting[absoluteRowIndex]) === null || _c === void 0 ? void 0 : _c[absoluteColumnIndex]
+                                    : formatting;
+                                var coords_1 = { rowIndex: rowIndex, columnIndex: columnIndex };
+                                var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                                var cellData = (_d = currentSheet[rowIndex].values) === null || _d === void 0 ? void 0 : _d[columnIndex];
+                                // Create a cell
+                                sheetCell.assign(sheetId, coords_1, cellData, {
+                                    getRangeValues: getEffectiveValuesFromRange,
+                                    locale: locale,
+                                    cellXfsRegistry: cellXfsRegistry,
+                                    getDataValidationById: getDataValidationById,
+                                    sharedStringRegistry: sharedStringRegistry,
+                                });
+                                // Set text value of the cell
+                                // Skip value changes if formattingOnly is true
+                                if (!formattingOnly) {
+                                    if (isNil(value_1)) {
+                                        sheetCell.deleteContents();
+                                    }
+                                    else {
+                                        sheetCell.setUserEnteredValue(value_1, undefined, {
+                                            disableTypeInference: disableTypeInference,
+                                        });
+                                    }
+                                }
+                                // Apply formatting
+                                if (cellFormat) {
+                                    // Add cellformat
+                                    for (var key in cellFormat) {
+                                        // Set user entered format
+                                        sheetCell.setUserEnteredFormat(key, cellFormat[key]);
+                                    }
+                                }
+                                // Apply citations
+                                if (citations !== undefined) {
+                                    var citationId = Array.isArray(citations)
+                                        ? (_e = citations[absoluteRowIndex]) === null || _e === void 0 ? void 0 : _e[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 === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.registerCell(sheetCell);
+                                // Set cell data
+                                currentSheet[rowIndex].values[columnIndex] =
+                                    sheetCell.getCellData();
+                                // Register cellXfs
+                                cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.registerCellXfs(sheetCell);
+                                var requiresRecalc = !formattingOnly ||
+                                    (cellFormat && "numberFormat" in cellFormat);
+                                if (enableEvaluation && requiresRecalc) {
+                                    var 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: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
+                                            type: "add",
+                                            force: forceCalculation,
+                                        });
+                                    }
+                                    // Add to recalc cells (replayed as "add" on undo)
+                                    recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                        rowIndex: rowIndex,
+                                        columnIndex: columnIndex,
+                                        sheetId: sheetId,
+                                        force: forceCalculation,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (finalRanges_2_1 && !finalRanges_2_1.done && (_a = finalRanges_2.return)) _a.call(finalRanges_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: {
+                    inversePatches: inversePatches,
+                    patches: 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 === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+            var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                var _a, _b;
+                var sheet = draft.find(function (s) { return s.sheetId === sheetId; });
+                if (sheet) {
+                    // Update rowCount if necessary
+                    sheet.rowCount = Math.min(MAX_ROW_COUNT, Math.max((_a = sheet.rowCount) !== null && _a !== void 0 ? _a : DEFAULT_ROW_COUNT, maxRowIndex));
+                    // Update columnCount if necessary
+                    sheet.columnCount = Math.min(MAX_COLUMN_COUNT, Math.max((_b = sheet.columnCount) !== null && _b !== void 0 ? _b : DEFAULT_COLUMN_COUNT, maxColumnIndex));
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Add sheet patches
+            saveHistory({
+                sheets: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Save cellXfs
+        cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.getPatches(saveHistory);
+        // Save shared strings patches
+        sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.getPatches(saveHistory);
+        // Update row heights when text format or wrapping changes
+        var shouldUpdateRowHeights = false;
+        if (Array.isArray(formatting)) {
+            shouldUpdateRowHeights = formatting.some(function (row) {
+                return row.some(function (cellFormat) { return (cellFormat === null || cellFormat === void 0 ? void 0 : cellFormat.textFormat) || (cellFormat === null || cellFormat === void 0 ? void 0 : cellFormat.wrapStrategy); });
+            });
+        }
+        else {
+            shouldUpdateRowHeights = !!((formatting === null || formatting === void 0 ? void 0 : formatting.textFormat) || (formatting === null || formatting === void 0 ? void 0 : formatting.wrapStrategy));
+        }
+        if (shouldUpdateRowHeights) {
+            onChangeSheets(function (prevSheets) {
+                var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                    var e_3, _a;
+                    var _b, _c, _d, _e, _f;
+                    var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                    if (sheet) {
+                        var _loop_1 = function (range) {
+                            var rollingRowIndex = 0;
+                            for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                                if (Array.isArray(formatting) &&
+                                    rollingRowIndex > formatting.length - 1) {
+                                    rollingRowIndex = 0;
+                                }
+                                var currentRowHeight = getRowHeight === null || getRowHeight === void 0 ? void 0 : getRowHeight(sheetId, rowIndex, function (index) {
+                                    return index >= range.startColumnIndex &&
+                                        index <= range.endColumnIndex;
+                                });
+                                var maxRowHeight = currentRowHeight !== null && currentRowHeight !== void 0 ? currentRowHeight : 0;
+                                var didUpdateRowHeight = false;
+                                var isResizedByUser = !!((_c = (_b = sheet.rowMetadata) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.resizedByUser);
+                                if (isResizedByUser) {
+                                    rollingRowIndex++;
+                                    continue;
+                                }
+                                var rollingColumnIndex = 0;
+                                for (var columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                                    if (Array.isArray(formatting) &&
+                                        rollingColumnIndex > formatting[0].length - 1) {
+                                        rollingColumnIndex = 0;
+                                    }
+                                    if (isMergedCell === null || isMergedCell === void 0 ? void 0 : isMergedCell(sheetId, rowIndex, columnIndex)) {
+                                        rollingColumnIndex++;
+                                        continue;
+                                    }
+                                    var cellFormat = Array.isArray(formatting)
+                                        ? formatting[rollingRowIndex][rollingColumnIndex]
+                                        : formatting;
+                                    if (!cellFormat ||
+                                        (!cellFormat.textFormat && !cellFormat.wrapStrategy)) {
+                                        rollingColumnIndex++;
+                                        continue;
+                                    }
+                                    var overrideValue = Array.isArray(values)
+                                        ? (_d = values[rollingRowIndex]) === null || _d === void 0 ? void 0 : _d[rollingColumnIndex]
+                                        : values;
+                                    var formattedValue = !isNil(overrideValue) && overrideValue !== ""
+                                        ? String(overrideValue)
+                                        : getFormattedValue === null || getFormattedValue === void 0 ? void 0 : getFormattedValue(sheetId, rowIndex, columnIndex);
+                                    var shouldWrap = cellFormat.wrapStrategy
+                                        ? cellFormat.wrapStrategy === "wrap"
+                                        : undefined;
+                                    var fontSize = (_e = cellFormat.textFormat) === null || _e === void 0 ? void 0 : _e.fontSize;
+                                    var newCellDimension = getCellDimensions === null || getCellDimensions === void 0 ? void 0 : getCellDimensions(sheetId, rowIndex, columnIndex, "x", {
+                                        textOverride: formattedValue !== null && formattedValue !== void 0 ? formattedValue : undefined,
+                                        textFormatOverride: fontSize
+                                            ? {
+                                                fontSize: fontSize,
+                                            }
+                                            : undefined,
+                                        shouldWrapOverride: shouldWrap,
+                                    });
+                                    if (!isNil(newCellDimension) && !isNil(currentRowHeight)) {
+                                        maxRowHeight = Math.max(maxRowHeight, (_f = newCellDimension === null || newCellDimension === void 0 ? void 0 : newCellDimension.height) !== null && _f !== void 0 ? _f : 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++;
+                            }
+                        };
+                        try {
+                            for (var finalRanges_3 = __values(finalRanges), finalRanges_3_1 = finalRanges_3.next(); !finalRanges_3_1.done; finalRanges_3_1 = finalRanges_3.next()) {
+                                var range = finalRanges_3_1.value;
+                                _loop_1(range);
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (finalRanges_3_1 && !finalRanges_3_1.done && (_a = finalRanges_3.return)) _a.call(finalRanges_3);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                saveHistory({
+                    sheets: { patches: patches, inversePatches: inversePatches },
+                });
+                return nextState;
+            });
+        }
+        if (!formattingOnly && (tables === null || tables === void 0 ? void 0 : tables.length) && primaryRange && coords) {
+            if (onChangeTableColumn) {
+                onChangeTableColumn(sheetId, coords, value, adjacentTable, isRowExpansion, isColumnExpansion, primaryRange);
+            }
+            if (onChangeCalculatedColumn) {
+                var isAdjacentColumn = currentTable &&
+                    coords.columnIndex === currentTable.range.endColumnIndex + 1;
+                var adjustedValue = isAdjacentColumn &&
+                    typeof value === "string" &&
+                    currentTable &&
+                    tokenizer
+                    ? removeTableName(tokenizer(value), currentTable.title)
+                    : value;
+                onChangeCalculatedColumn(sheetId, coords, adjustedValue, currentTable);
+            }
+        }
+    };
+};

package/dist/cjs/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/cjs/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/cjs/interface/change-border.js

@@ -0,0 +1,141 @@
+import { __read, __values } from "tslib";
+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 var changeBorder = function (_a) {
+    var createHistory = _a.createHistory, onChangeSheetData = _a.onChangeSheetData, locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, getDataValidationById = _a.getDataValidationById;
+    return function (sheetId, activeCell, selections, location, color, style) {
+        if (style === void 0) { style = "solid"; }
+        var finalSelections = selections.length
+            ? selections
+            : selectionFromActiveCell(activeCell);
+        var saveHistory = createHistory();
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_1, _a, e_2, _b;
+                var _c, _d;
+                // Create a cell
+                var sheetCell = new SheetCell();
+                try {
+                    for (var finalSelections_1 = __values(finalSelections), finalSelections_1_1 = finalSelections_1.next(); !finalSelections_1_1.done; finalSelections_1_1 = finalSelections_1.next()) {
+                        var selection = finalSelections_1_1.value;
+                        try {
+                            for (var _e = (e_2 = void 0, __values(iterateCellsInRange(selection.range))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                var _g = __read(_f.value, 2), rowIndex = _g[0], columnIndex = _g[1];
+                                var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                                var cellData = (_d = (_c = currentSheet[rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[columnIndex];
+                                // Create a cell
+                                sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
+                                // Selected border
+                                var selectedBorder = {
+                                    color: color,
+                                    style: style,
+                                    width: getBorderWidthFromStyle(style),
+                                };
+                                if (location === "all") {
+                                    sheetCell.setAllBorders({
+                                        color: color,
+                                        style: 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 === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.registerCellXfs(sheetCell);
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (finalSelections_1_1 && !finalSelections_1_1.done && (_a = finalSelections_1.return)) _a.call(finalSelections_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            // Save history
+            saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+                sheetId: { redo: sheetId, undo: sheetId },
+                selections: { undo: selections, redo: selections },
+                activeCell: { undo: activeCell, redo: activeCell },
+            });
+            return nextState;
+        });
+        // Save cellXfs
+        cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.getPatches(saveHistory);
+    };
+};

package/dist/cjs/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/cjs/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/cjs/interface/change-calculated-column.js

@@ -0,0 +1,131 @@
+import { __assign, __read, __values } from "tslib";
+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 var changeCalculatedColumn = function (_a) {
+    var locale = _a.locale, sharedStringRegistry = _a.sharedStringRegistry, cellXfsRegistry = _a.cellXfsRegistry, onChangeTables = _a.onChangeTables, onChangeSheetData = _a.onChangeSheetData, getUserEnteredValue = _a.getUserEnteredValue, getSheetName = _a.getSheetName, createHistory = _a.createHistory, enqueueCalculation = _a.enqueueCalculation, onCommand = _a.onCommand;
+    return function (sheetId, coords, value, currentTable) {
+        var _a, _b;
+        var activeSheetName = getSheetName(sheetId);
+        var recalcCells = new Map();
+        var isFormula = isAFormula(value);
+        if (!isFormula || !currentTable) {
+            return;
+        }
+        var columnOffset = coords.columnIndex - currentTable.range.startColumnIndex;
+        var columnDefinition = (_a = currentTable.columns) === null || _a === void 0 ? void 0 : _a[columnOffset];
+        var existingColumnFormula = columnDefinition === null || columnDefinition === void 0 ? void 0 : columnDefinition.formula;
+        var range = __assign(__assign({}, currentTable.range), { startRowIndex: ((_b = currentTable.headerRow) !== null && _b !== void 0 ? _b : true)
+                ? currentTable.range.startRowIndex + 1
+                : currentTable.range.startRowIndex, endRowIndex: currentTable.totalRow
+                ? currentTable.range.endRowIndex - 1
+                : currentTable.range.endRowIndex, startColumnIndex: coords.columnIndex, endColumnIndex: coords.columnIndex });
+        var 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 === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "calculated-column",
+            sheetId: sheetId,
+            tableId: currentTable.id,
+            columnIndex: coords.columnIndex,
+            formula: value,
+            fromRowIndex: coords.rowIndex,
+        });
+        var saveHistory = createHistory();
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var e_1, _a;
+                var _b, _c;
+                var sheetCell = new SheetCell();
+                try {
+                    for (var _d = __values(iterateCellsInRange(range)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                        var _f = __read(_e.value, 2), rowIndex = _f[0], columnIndex = _f[1];
+                        if (coords.rowIndex === rowIndex) {
+                            continue;
+                        }
+                        var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        var cellData = (_b = currentSheet[rowIndex].values) === null || _b === void 0 ? void 0 : _b[columnIndex];
+                        sheetCell.assign(sheetId, coords, cellData, {
+                            locale: locale,
+                            cellXfsRegistry: cellXfsRegistry,
+                            sharedStringRegistry: sharedStringRegistry,
+                        });
+                        var previousFormula = sheetCell.formula;
+                        var structuredValue = (_c = sheetCell.effectiveValue) === null || _c === void 0 ? void 0 : _c.structuredValue;
+                        sheetCell.setUserEnteredValue(value);
+                        if (structuredValue) {
+                            sheetCell.setStructuredValue(structuredValue);
+                        }
+                        var newFormula = isFormula
+                            ? SheetCell.getRelativeFormula(value, coords, {
+                                rowIndex: rowIndex,
+                                columnIndex: columnIndex,
+                            }, activeSheetName)
+                            : undefined;
+                        var formulaChanged = previousFormula !== newFormula;
+                        var shouldResetValue = isFormula && formulaChanged;
+                        if (shouldResetValue) {
+                            if (sheetCell.isFormula()) {
+                                sheetCell.moveFormula(coords, {
+                                    rowIndex: rowIndex,
+                                    columnIndex: columnIndex,
+                                }, activeSheetName);
+                            }
+                            sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.registerCell(sheetCell);
+                            currentSheet[rowIndex].values[columnIndex] =
+                                sheetCell.getCellData();
+                            enqueueCalculation({
+                                position: { rowIndex: rowIndex, columnIndex: columnIndex, sheetId: sheetId },
+                                type: "add",
+                                force: true,
+                            });
+                            recalcCells.set(createSheetCellIdentifier(sheetId, rowIndex, columnIndex), {
+                                rowIndex: rowIndex,
+                                columnIndex: columnIndex,
+                                sheetId: sheetId,
+                                force: true,
+                            });
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                    }
+                    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;
+        });
+        onChangeTables === null || onChangeTables === void 0 ? void 0 : onChangeTables(function (prevTableData) {
+            var _a = __read(produceWithPatches(prevTableData, function (draft) {
+                var _a;
+                var table = draft.find(function (table) { return table.id === currentTable.id; });
+                if (table) {
+                    var column = (_a = table.columns) === null || _a === void 0 ? void 0 : _a[coords.columnIndex - table.range.startColumnIndex];
+                    if (column) {
+                        column.formula = value;
+                    }
+                }
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory({
+                tables: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+        // Save shared strings patches
+        sharedStringRegistry === null || sharedStringRegistry === void 0 ? void 0 : sharedStringRegistry.getPatches(saveHistory);
+    };
+};

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