@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,428 @@
+import { __asyncValues, __awaiter, __generator, __read, __values } from "tslib";
+import { makeKey } from "@rowsncolumns/dag";
+import { isNil } from "@rowsncolumns/utils";
+import { produce } from "immer";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+var normalizeFormula = function (value) {
+    var trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    var formulaInput = trimmed.startsWith("=") ? trimmed : "=".concat(trimmed);
+    var formulaValue = formulaInput.slice(1);
+    return { formulaInput: formulaInput, formulaValue: formulaValue };
+};
+var hasStreamValue = function (cellInput) {
+    return !isNil(cellInput === null || cellInput === void 0 ? void 0 : cellInput.formula) && (cellInput === null || cellInput === void 0 ? void 0 : cellInput.formula) !== ""
+        ? true
+        : !isNil(cellInput === null || cellInput === void 0 ? void 0 : cellInput.value) && (cellInput === null || cellInput === void 0 ? void 0 : cellInput.value) !== ""
+            ? true
+            : !isNil(cellInput === null || cellInput === void 0 ? void 0 : cellInput.cell_styles);
+};
+export var changeBatchStream = function (_a) {
+    var locale = _a.locale, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, getEffectiveValuesFromRange = _a.getEffectiveValuesFromRange, getFormattedValue = _a.getFormattedValue, getCellDimensions = _a.getCellDimensions, getRowHeight = _a.getRowHeight, isMergedCell = _a.isMergedCell, getDataValidationById = _a.getDataValidationById, onRequestCalculate = _a.onRequestCalculate, getPrecedentsFromFormulaString = _a.getPrecedentsFromFormulaString, getSheetId = _a.getSheetId, cellXfsRegistry = _a.cellXfsRegistry, tokenizer = _a.tokenizer, onStreamStart = _a.onStreamStart, onStreamProgress = _a.onStreamProgress, onStreamEnd = _a.onStreamEnd;
+    return function (sheetId, range, stream, streamOptions) { return __awaiter(void 0, void 0, void 0, function () {
+        var streamId, sheetCell, rowCursorByIndex, overrides, disableDeltaUpdates, disableEvaluation, skipInvalidValues, preserveExistingValues, shouldUpdateRowHeights, _loop_1, state_1, e_1_1;
+        var _a, stream_1, stream_1_1;
+        var _b, e_1, _c, _d;
+        var _e, _f, _g, _h, _j, _k, _l;
+        return __generator(this, function (_m) {
+            switch (_m.label) {
+                case 0:
+                    streamId = "stream_".concat(Date.now(), "_").concat(Math.random()
+                        .toString(36)
+                        .substring(2, 9));
+                    onStreamStart === null || onStreamStart === void 0 ? void 0 : onStreamStart(streamId);
+                    sheetCell = new SheetCell();
+                    rowCursorByIndex = new Map();
+                    overrides = new Map();
+                    disableDeltaUpdates = (_e = streamOptions === null || streamOptions === void 0 ? void 0 : streamOptions.disableDelta) !== null && _e !== void 0 ? _e : true;
+                    disableEvaluation = streamOptions === null || streamOptions === void 0 ? void 0 : streamOptions.disableEvaluation;
+                    skipInvalidValues = (_f = streamOptions === null || streamOptions === void 0 ? void 0 : streamOptions.skipInvalidValues) !== null && _f !== void 0 ? _f : false;
+                    preserveExistingValues = (_g = streamOptions === null || streamOptions === void 0 ? void 0 : streamOptions.preserveExistingValues) !== null && _g !== void 0 ? _g : false;
+                    shouldUpdateRowHeights = (_h = streamOptions === null || streamOptions === void 0 ? void 0 : streamOptions.shouldUpdateRowHeights) !== null && _h !== void 0 ? _h : true;
+                    _m.label = 1;
+                case 1:
+                    _m.trys.push([1, , 15, 16]);
+                    _m.label = 2;
+                case 2:
+                    _m.trys.push([2, 8, 9, 14]);
+                    _loop_1 = function () {
+                        var rows, formulaCells, rowStyleUpdates, cellUpdates, lastCellPosition, rowIndex, row, absoluteRowIndex, startColumnIndex, lastNonEmptyIndex, columnIndex, absoluteColumnIndex, cellInput, position, formula, normalizedFormula, calculationResults, cellUpdates_1, cellUpdates_1_1, _o, position, cellInput, overrideValue, formulaCells_1, formulaCells_1_1, cell, result, err_1, e_2_1;
+                        var e_3, _p, e_2, _q;
+                        return __generator(this, function (_r) {
+                            switch (_r.label) {
+                                case 0:
+                                    _d = stream_1_1.value;
+                                    _a = false;
+                                    rows = _d;
+                                    if (!Array.isArray(rows) || !rows.length) {
+                                        return [2 /*return*/, "continue"];
+                                    }
+                                    formulaCells = [];
+                                    rowStyleUpdates = new Map();
+                                    cellUpdates = [];
+                                    lastCellPosition = null;
+                                    for (rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+                                        row = rows[rowIndex];
+                                        if (!row) {
+                                            continue;
+                                        }
+                                        absoluteRowIndex = range.startRowIndex + rowIndex;
+                                        if (absoluteRowIndex > range.endRowIndex) {
+                                            continue;
+                                        }
+                                        startColumnIndex = disableDeltaUpdates
+                                            ? 0
+                                            : (_j = rowCursorByIndex.get(rowIndex)) !== null && _j !== void 0 ? _j : 0;
+                                        lastNonEmptyIndex = -1;
+                                        for (columnIndex = startColumnIndex; columnIndex < row.length; columnIndex++) {
+                                            if (absoluteRowIndex > range.endRowIndex) {
+                                                continue;
+                                            }
+                                            absoluteColumnIndex = range.startColumnIndex + columnIndex;
+                                            if (absoluteColumnIndex > range.endColumnIndex) {
+                                                continue;
+                                            }
+                                            cellInput = row[columnIndex];
+                                            position = {
+                                                sheetId: sheetId,
+                                                rowIndex: absoluteRowIndex,
+                                                columnIndex: absoluteColumnIndex,
+                                            };
+                                            formula = cellInput === null || cellInput === void 0 ? void 0 : cellInput.formula;
+                                            if (disableEvaluation && !isNil(formula) && formula !== "") {
+                                                continue;
+                                            }
+                                            if (hasStreamValue(cellInput)) {
+                                                lastNonEmptyIndex = Math.max(lastNonEmptyIndex, columnIndex);
+                                                lastCellPosition = {
+                                                    rowIndex: position.rowIndex,
+                                                    columnIndex: position.columnIndex,
+                                                };
+                                                onStreamProgress === null || onStreamProgress === void 0 ? void 0 : onStreamProgress(streamId, sheetId, lastCellPosition);
+                                            }
+                                            cellUpdates.push({ position: position, cellInput: cellInput });
+                                            if (!disableEvaluation && !isNil(formula) && formula !== "") {
+                                                normalizedFormula = normalizeFormula(String(formula));
+                                                if (normalizedFormula) {
+                                                    formulaCells.push({
+                                                        position: position,
+                                                        formulaInput: normalizedFormula.formulaInput,
+                                                        formulaValue: normalizedFormula.formulaValue,
+                                                    });
+                                                }
+                                            }
+                                        }
+                                        if (!disableDeltaUpdates && lastNonEmptyIndex >= startColumnIndex) {
+                                            rowCursorByIndex.set(rowIndex, lastNonEmptyIndex + 1);
+                                        }
+                                    }
+                                    // Abortd
+                                    if ((_k = streamOptions === null || streamOptions === void 0 ? void 0 : streamOptions.isAborted) === null || _k === void 0 ? void 0 : _k.call(streamOptions)) {
+                                        return [2 /*return*/, { value: void 0 }];
+                                    }
+                                    calculationResults = new Map();
+                                    if (!(!disableEvaluation && formulaCells.length && onRequestCalculate)) return [3 /*break*/, 10];
+                                    try {
+                                        for (cellUpdates_1 = (e_3 = void 0, __values(cellUpdates)), cellUpdates_1_1 = cellUpdates_1.next(); !cellUpdates_1_1.done; cellUpdates_1_1 = cellUpdates_1.next()) {
+                                            _o = cellUpdates_1_1.value, position = _o.position, cellInput = _o.cellInput;
+                                            if (!cellInput) {
+                                                continue;
+                                            }
+                                            overrideValue = cellInput.value;
+                                            if (!isNil(overrideValue)) {
+                                                overrides.set(makeKey(position), overrideValue);
+                                            }
+                                        }
+                                    }
+                                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                    finally {
+                                        try {
+                                            if (cellUpdates_1_1 && !cellUpdates_1_1.done && (_p = cellUpdates_1.return)) _p.call(cellUpdates_1);
+                                        }
+                                        finally { if (e_3) throw e_3.error; }
+                                    }
+                                    _r.label = 1;
+                                case 1:
+                                    _r.trys.push([1, 8, 9, 10]);
+                                    formulaCells_1 = (e_2 = void 0, __values(formulaCells)), formulaCells_1_1 = formulaCells_1.next();
+                                    _r.label = 2;
+                                case 2:
+                                    if (!!formulaCells_1_1.done) return [3 /*break*/, 7];
+                                    cell = formulaCells_1_1.value;
+                                    _r.label = 3;
+                                case 3:
+                                    _r.trys.push([3, 5, , 6]);
+                                    return [4 /*yield*/, onRequestCalculate(cell.formulaInput, sheetId, cell.position.rowIndex, cell.position.columnIndex, {
+                                            overrides: overrides,
+                                            isArray: false,
+                                            disablePreview: true,
+                                            skipOnDemand: true,
+                                        })];
+                                case 4:
+                                    result = _r.sent();
+                                    // Set overrides for subsequent calculation calls
+                                    // that require this cell result works
+                                    overrides.set(makeKey(cell.position), result);
+                                    if (isNil(result) || Array.isArray(result)) {
+                                        return [3 /*break*/, 6];
+                                    }
+                                    calculationResults.set(makeKey(cell.position), result);
+                                    return [3 /*break*/, 6];
+                                case 5:
+                                    err_1 = _r.sent();
+                                    return [3 /*break*/, 6];
+                                case 6:
+                                    formulaCells_1_1 = formulaCells_1.next();
+                                    return [3 /*break*/, 2];
+                                case 7: return [3 /*break*/, 10];
+                                case 8:
+                                    e_2_1 = _r.sent();
+                                    e_2 = { error: e_2_1 };
+                                    return [3 /*break*/, 10];
+                                case 9:
+                                    try {
+                                        if (formulaCells_1_1 && !formulaCells_1_1.done && (_q = formulaCells_1.return)) _q.call(formulaCells_1);
+                                    }
+                                    finally { if (e_2) throw e_2.error; }
+                                    return [7 /*endfinally*/];
+                                case 10:
+                                    // Abortd
+                                    if ((_l = streamOptions === null || streamOptions === void 0 ? void 0 : streamOptions.isAborted) === null || _l === void 0 ? void 0 : _l.call(streamOptions)) {
+                                        return [2 /*return*/, { value: void 0 }];
+                                    }
+                                    onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+                                        var nextState = produce(prevSheetData, function (draft) {
+                                            var e_4, _a;
+                                            var _b, _c;
+                                            try {
+                                                for (var cellUpdates_2 = (e_4 = void 0, __values(cellUpdates)), cellUpdates_2_1 = cellUpdates_2.next(); !cellUpdates_2_1.done; cellUpdates_2_1 = cellUpdates_2.next()) {
+                                                    var _d = cellUpdates_2_1.value, position = _d.position, cellInput = _d.cellInput;
+                                                    var currentSheet = createSheetDraft(draft, sheetId, position.rowIndex);
+                                                    var cellData = (_b = currentSheet[position.rowIndex].values) === null || _b === void 0 ? void 0 : _b[position.columnIndex];
+                                                    sheetCell.assign(sheetId, position, cellData, {
+                                                        getRangeValues: getEffectiveValuesFromRange,
+                                                        locale: locale,
+                                                        cellXfsRegistry: cellXfsRegistry,
+                                                        getDataValidationById: getDataValidationById,
+                                                    });
+                                                    var formula = cellInput === null || cellInput === void 0 ? void 0 : cellInput.formula;
+                                                    var cellStyles = cellInput === null || cellInput === void 0 ? void 0 : cellInput.cell_styles;
+                                                    var normalizedFormula = null;
+                                                    // Formulae
+                                                    if (!disableEvaluation && !isNil(formula) && formula !== "") {
+                                                        normalizedFormula = normalizeFormula(String(formula));
+                                                        if (normalizedFormula) {
+                                                            sheetCell.setUserEnteredValue(normalizedFormula.formulaInput);
+                                                        }
+                                                        else {
+                                                            sheetCell.deleteContents();
+                                                        }
+                                                    }
+                                                    else if (!isNil(cellInput === null || cellInput === void 0 ? void 0 : cellInput.value) &&
+                                                        !(preserveExistingValues && cellInput.value === "")) {
+                                                        sheetCell.setUserEnteredValue(cellInput.value);
+                                                        // A streamed write has no dialog to confirm through: a value
+                                                        // failing a blocking rule is dropped silently and the cell
+                                                        // keeps its previous content, mirroring the agent-write
+                                                        // guard. Warning/information rules write through flagged,
+                                                        // like a user clicking past the prompt.
+                                                        if (skipInvalidValues && sheetCell.failsBlockingValidation) {
+                                                            continue;
+                                                        }
+                                                    }
+                                                    else if (cellStyles) {
+                                                        // Preserve existing value when only styles are provided.
+                                                    }
+                                                    else if (preserveExistingValues) {
+                                                        // An empty/absent cell input in the stream leaves the
+                                                        // existing cell untouched instead of clearing it. Cumulative
+                                                        // AI feeds (magic fill, tool-UI previews) re-send the whole
+                                                        // range every chunk with holes for cells they never fill —
+                                                        // without this, pre-filled cells (dropdown defaults) get
+                                                        // wiped by the first partial chunk.
+                                                        continue;
+                                                    }
+                                                    else {
+                                                        sheetCell.deleteContents();
+                                                    }
+                                                    if (cellStyles) {
+                                                        for (var key in cellStyles) {
+                                                            sheetCell.setUserEnteredFormat(key, cellStyles[key]);
+                                                        }
+                                                    }
+                                                    var isCalculatedValue = calculationResults.has(makeKey(position));
+                                                    if (isCalculatedValue) {
+                                                        var calculatedValue = calculationResults.get(makeKey(position));
+                                                        var preserveStringLiteral = typeof calculatedValue === "string";
+                                                        sheetCell.setEffectiveValue(calculatedValue, false, preserveStringLiteral);
+                                                        // Effective number format is derived at render time via
+                                                        // `useSheetProperties.getEffectiveFormat`, so we no longer
+                                                        // walk precedents and persist the result here.
+                                                    }
+                                                    // Disable cellXfs and shared strings
+                                                    currentSheet[position.rowIndex].values[position.columnIndex] =
+                                                        sheetCell.getCellData({ disableRegistry: true });
+                                                    if (cellStyles) {
+                                                        cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.registerCellXfs(sheetCell);
+                                                        if (shouldUpdateRowHeights &&
+                                                            (cellStyles.textFormat || cellStyles.wrapStrategy)) {
+                                                            var rowUpdates = (_c = rowStyleUpdates.get(position.rowIndex)) !== null && _c !== void 0 ? _c : [];
+                                                            rowUpdates.push({
+                                                                columnIndex: position.columnIndex,
+                                                                cellStyles: cellStyles,
+                                                                overrideValue: cellInput === null || cellInput === void 0 ? void 0 : cellInput.value,
+                                                            });
+                                                            rowStyleUpdates.set(position.rowIndex, rowUpdates);
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                                            finally {
+                                                try {
+                                                    if (cellUpdates_2_1 && !cellUpdates_2_1.done && (_a = cellUpdates_2.return)) _a.call(cellUpdates_2);
+                                                }
+                                                finally { if (e_4) throw e_4.error; }
+                                            }
+                                        });
+                                        return nextState;
+                                    });
+                                    if (shouldUpdateRowHeights &&
+                                        rowStyleUpdates.size > 0 &&
+                                        onChangeSheets &&
+                                        getRowHeight &&
+                                        getCellDimensions) {
+                                        onChangeSheets(function (prevSheets) {
+                                            return produce(prevSheets, function (draft) {
+                                                var e_5, _a;
+                                                var _b, _c, _d, _e;
+                                                var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                                                if (!sheet) {
+                                                    return;
+                                                }
+                                                var _loop_2 = function (rowIndex, updates) {
+                                                    var e_6, _j;
+                                                    var isResizedByUser = !!((_c = (_b = sheet.rowMetadata) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.resizedByUser);
+                                                    if (isResizedByUser) {
+                                                        return "continue";
+                                                    }
+                                                    var columnsToCheck = new Set(updates.map(function (update) { return update.columnIndex; }));
+                                                    var currentRowHeight = getRowHeight(sheetId, rowIndex, function (index) { return columnsToCheck.has(index); });
+                                                    if (isNil(currentRowHeight)) {
+                                                        return "continue";
+                                                    }
+                                                    var maxRowHeight = currentRowHeight !== null && currentRowHeight !== void 0 ? currentRowHeight : 0;
+                                                    var didUpdateRowHeight = false;
+                                                    try {
+                                                        for (var updates_1 = (e_6 = void 0, __values(updates)), updates_1_1 = updates_1.next(); !updates_1_1.done; updates_1_1 = updates_1.next()) {
+                                                            var update = updates_1_1.value;
+                                                            var cellStyles = update.cellStyles;
+                                                            if (!cellStyles ||
+                                                                (!cellStyles.textFormat && !cellStyles.wrapStrategy)) {
+                                                                continue;
+                                                            }
+                                                            if ((isMergedCell === null || isMergedCell === void 0 ? void 0 : isMergedCell(sheetId, rowIndex, update.columnIndex)) ===
+                                                                true) {
+                                                                continue;
+                                                            }
+                                                            var formattedValue = !isNil(update.overrideValue) && update.overrideValue !== ""
+                                                                ? String(update.overrideValue)
+                                                                : getFormattedValue === null || getFormattedValue === void 0 ? void 0 : getFormattedValue(sheetId, rowIndex, update.columnIndex);
+                                                            var shouldWrap = cellStyles.wrapStrategy
+                                                                ? cellStyles.wrapStrategy === "wrap"
+                                                                : undefined;
+                                                            var fontSize = (_d = cellStyles.textFormat) === null || _d === void 0 ? void 0 : _d.fontSize;
+                                                            var newCellDimension = getCellDimensions(sheetId, rowIndex, update.columnIndex, "x", {
+                                                                textOverride: formattedValue !== null && formattedValue !== void 0 ? formattedValue : undefined,
+                                                                textFormatOverride: fontSize ? { fontSize: fontSize } : undefined,
+                                                                shouldWrapOverride: shouldWrap,
+                                                            });
+                                                            if (!isNil(newCellDimension)) {
+                                                                maxRowHeight = Math.max(maxRowHeight, (_e = newCellDimension === null || newCellDimension === void 0 ? void 0 : newCellDimension.height) !== null && _e !== void 0 ? _e : 0);
+                                                                didUpdateRowHeight = true;
+                                                            }
+                                                        }
+                                                    }
+                                                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                                                    finally {
+                                                        try {
+                                                            if (updates_1_1 && !updates_1_1.done && (_j = updates_1.return)) _j.call(updates_1);
+                                                        }
+                                                        finally { if (e_6) throw e_6.error; }
+                                                    }
+                                                    if (didUpdateRowHeight && maxRowHeight > 0) {
+                                                        if (!sheet.rowMetadata) {
+                                                            sheet.rowMetadata = [];
+                                                        }
+                                                        if (!sheet.rowMetadata[rowIndex] ||
+                                                            typeof sheet.rowMetadata[rowIndex] !== "object") {
+                                                            sheet.rowMetadata[rowIndex] = {};
+                                                        }
+                                                        sheet.rowMetadata[rowIndex].size = maxRowHeight;
+                                                    }
+                                                };
+                                                try {
+                                                    for (var _f = (e_5 = void 0, __values(rowStyleUpdates.entries())), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                                        var _h = __read(_g.value, 2), rowIndex = _h[0], updates = _h[1];
+                                                        _loop_2(rowIndex, updates);
+                                                    }
+                                                }
+                                                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                                                finally {
+                                                    try {
+                                                        if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+                                                    }
+                                                    finally { if (e_5) throw e_5.error; }
+                                                }
+                                            });
+                                        });
+                                    }
+                                    // Save cellXfs
+                                    cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.getPatches();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _a = true, stream_1 = __asyncValues(stream);
+                    _m.label = 3;
+                case 3: return [4 /*yield*/, stream_1.next()];
+                case 4:
+                    if (!(stream_1_1 = _m.sent(), _b = stream_1_1.done, !_b)) return [3 /*break*/, 7];
+                    return [5 /*yield**/, _loop_1()];
+                case 5:
+                    state_1 = _m.sent();
+                    if (typeof state_1 === "object")
+                        return [2 /*return*/, state_1.value];
+                    _m.label = 6;
+                case 6:
+                    _a = true;
+                    return [3 /*break*/, 3];
+                case 7: return [3 /*break*/, 14];
+                case 8:
+                    e_1_1 = _m.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 14];
+                case 9:
+                    _m.trys.push([9, , 12, 13]);
+                    if (!(!_a && !_b && (_c = stream_1.return))) return [3 /*break*/, 11];
+                    return [4 /*yield*/, _c.call(stream_1)];
+                case 10:
+                    _m.sent();
+                    _m.label = 11;
+                case 11: return [3 /*break*/, 13];
+                case 12:
+                    if (e_1) throw e_1.error;
+                    return [7 /*endfinally*/];
+                case 13: return [7 /*endfinally*/];
+                case 14: return [3 /*break*/, 16];
+                case 15:
+                    onStreamEnd === null || onStreamEnd === void 0 ? void 0 : onStreamEnd(streamId);
+                    return [7 /*endfinally*/];
+                case 16: return [2 /*return*/];
+            }
+        });
+    }); };
+};

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