@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-on-calculation-success.d.ts

@@ -0,0 +1,22 @@
+import type { CellFormat } from "@rowsncolumns/common-types";
+import type { CellCoordinate } from "@rowsncolumns/dag";
+import type { CellData } from "@rowsncolumns/spreadsheet";
+import type { CalculationResult, CalculationSuccessContext, useCalculation } from "./use-calculation";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { useUndoRedo } from "./use-undo-redo";
+type UseOnCalculationSuccessProps<T extends CellData> = {
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    getDataValidationById: ReturnType<typeof useSheetProperties>["getDataValidationById"];
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+    createHistory: ReturnType<typeof useUndoRedo>["createHistoryWithoutPointer"];
+    getPrecedents: ReturnType<typeof useCalculation>["getPrecedents"];
+    getSheetId: (sheetname: string) => number;
+};
+export declare const useOnCalculationSuccess: <T extends CellData = CellData>({ locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, onChangeSheetData, createHistory, getPrecedents, getSheetId, }: UseOnCalculationSuccessProps<T>) => (results: Array<[CellCoordinate, CalculationResult, formatting?: CellFormat]> | IterableIterator<[CellCoordinate, CalculationResult, formatting?: CellFormat]>, isFullRecalc?: boolean, _context?: CalculationSuccessContext) => void;
+export {};
+//# sourceMappingURL=use-on-calculation-success.d.ts.map

package/dist/cjs/hooks/use-on-calculation-success.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-calculation-success.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-calculation-success.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAe1D,OAAO,KAAK,EACV,iBAAiB,EACjB,yBAAyB,EACzB,cAAc,EACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAyBnD,KAAK,4BAA4B,CAAC,CAAC,SAAS,QAAQ,IAAI;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,qBAAqB,EAAE,UAAU,CAC/B,OAAO,kBAAkB,CAC1B,CAAC,uBAAuB,CAAC,CAAC;IAC3B,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,aAAa,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,6BAA6B,CAAC,CAAC;IAC7E,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;CAC3C,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAAE,wIASpE,4BAA4B,CAAC,CAAC,CAAC,eAMxB,KAAK,CAAC,CAAC,cAAc,EAAE,iBAAiB,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,CAAC,GACnE,gBAAgB,CACd,CAAC,cAAc,EAAE,iBAAiB,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,CAC7D,iBACU,OAAO,aACX,yBAAyB,SAqMzC,CAAC"}

package/dist/cjs/hooks/use-on-calculation-success.js

@@ -0,0 +1,182 @@
+import { __read, __values } from "tslib";
+import { useGetEffectiveValuesFromRange } from "@rowsncolumns/spreadsheet";
+import { isNil, selectionToAddress } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import isEqual from "lodash/isEqual";
+import { useCallback } from "react";
+import { createSheetDraft, deriveCellFromPrecedents, peekIterable, } from "./../api/immer-utils";
+import { AWAITING_CALCULATION } from "./../helpers";
+import { LOADING_VALUE, SheetCell } from "./../sheet-cell";
+var arrayResultToA1Ref = function (rowIndex, columnIndex, result) {
+    var _a, _b;
+    var numRows = result.length;
+    var numCols = (_b = (_a = result[0]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+    if (numRows === 0 || numCols === 0)
+        return undefined;
+    // selectionToAddress consumes 1-indexed GridRange and returns A1 form.
+    // For single-cell ranges it returns "G7"; the xlsx t="array" ref convention
+    // is the colon form ("G7:G7"), so we expand it when needed.
+    var address = selectionToAddress({
+        range: {
+            startRowIndex: rowIndex + 1,
+            endRowIndex: rowIndex + numRows,
+            startColumnIndex: columnIndex + 1,
+            endColumnIndex: columnIndex + numCols,
+        },
+    });
+    if (!address)
+        return undefined;
+    return address.includes(":") ? address : "".concat(address, ":").concat(address);
+};
+export var useOnCalculationSuccess = function (_a) {
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getDataValidationById = _a.getDataValidationById, onChangeSheetData = _a.onChangeSheetData, createHistory = _a.createHistory, getPrecedents = _a.getPrecedents, getSheetId = _a.getSheetId;
+    // Allowed values
+    var getEffectiveValuesFromRange = useGetEffectiveValuesFromRange();
+    return useCallback(function (results, isFullRecalc, _context) {
+        var finalIterable = peekIterable(Array.isArray(results) ? results.values() : results);
+        var isEmpty = finalIterable.peeked.done === true;
+        if (!isEmpty) {
+            var saveHistory_1 = createHistory();
+            // Update sheets
+            onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+                // SheetCell holds mutable scratch state across the per-cell
+                // iteration below (assign → hideLoading → setEffectiveValue …).
+                // It MUST be created fresh inside each invocation of this state
+                // updater — React 18 concurrent rendering can re-invoke the
+                // updater (interrupted/replayed renders, concurrent updates from
+                // collab sync, etc.), and a shared sheetCell would carry state
+                // from the previous invocation into the next. The next
+                // invocation would then see `isSameEffectiveValue === true` for
+                // every cell, produce zero Immer patches, and React would
+                // commit a no-op — calc results never reach the grid.
+                var sheetCell = new SheetCell();
+                var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                    var e_1, _a;
+                    var _b, _c;
+                    try {
+                        for (var _d = __values(finalIterable.rebuiltIterator()), _e = _d.next(); !_e.done; _e = _d.next()) {
+                            var _f = __read(_e.value, 3), position = _f[0], result = _f[1], formatting = _f[2];
+                            var rowIndex = position.rowIndex, columnIndex = position.columnIndex, sheetId = position.sheetId, conditionalFormatId = position.conditionalFormatId, dataValidationId = position.dataValidationId;
+                            var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                            var cellData = (_b = currentSheet[rowIndex].values) === null || _b === void 0 ? void 0 : _b[columnIndex];
+                            sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
+                                getRangeValues: getEffectiveValuesFromRange,
+                                locale: locale,
+                                cellXfsRegistry: cellXfsRegistry,
+                                getDataValidationById: getDataValidationById,
+                                sharedStringRegistry: sharedStringRegistry,
+                            });
+                            // If calc-begin marked this cell as loading, the draft
+                            // holds `fv = "Loading..."`. We need to write the cell
+                            // back through getCellData to clear that placeholder
+                            // even when the recalculated value is unchanged —
+                            // otherwise the "Loading..." indicator sticks forever.
+                            var wasLoading = (cellData === null || cellData === void 0 ? void 0 : cellData.fv) === LOADING_VALUE;
+                            // Remove loading
+                            sheetCell.hideLoading();
+                            if (!isNil(conditionalFormatId)) {
+                                var currentResult = (_c = sheetCell.conditionalFormattingResultById) === null || _c === void 0 ? void 0 : _c[conditionalFormatId];
+                                if (isEqual(currentResult, result)) {
+                                    continue;
+                                }
+                                sheetCell.setConditionalFormatResult(conditionalFormatId, result);
+                            }
+                            else if (!isNil(dataValidationId)) {
+                                if (isEqual(sheetCell.dataValidationResult, result)) {
+                                    continue;
+                                }
+                                sheetCell.setDataValidationResult(result);
+                            }
+                            else {
+                                // AWAITING_CALCULATION is the on-demand gate's "not
+                                // evaluated" placeholder (published when the gate skips an
+                                // on-demand formula like =AOP() that wasn't force-recalced).
+                                // A cell that already holds a persisted error keeps it:
+                                // writing the placeholder back would emit a recalc patch
+                                // that overwrites the persisted error ev in the Y.Doc,
+                                // blanking the cell on the next reload.
+                                if (result === AWAITING_CALCULATION &&
+                                    sheetCell.error &&
+                                    !wasLoading) {
+                                    continue;
+                                }
+                                // Track array-formula spill range on the anchor cell.
+                                // An array result means this cell's formula spills into a
+                                // rectangle; record the A1 ref so xlsx export can emit
+                                // <f t="array" ref="..."/>. Scalar results clear any
+                                // previously-recorded ref (formula no longer spills).
+                                if (Array.isArray(result)) {
+                                    var ref = arrayResultToA1Ref(rowIndex, columnIndex, result);
+                                    if (ref) {
+                                        sheetCell.setArrayFormulaRef(ref);
+                                    }
+                                }
+                                else {
+                                    sheetCell.clearArrayFormulaRef();
+                                }
+                                // Effective number format is now derived lazily at render
+                                // time (see `getEffectiveFormat` in use-sheet-properties),
+                                // so we no longer write it onto the cell here. The only
+                                // exception is `formatting` supplied by the calculator
+                                // (e.g. spilled FILTER results) — that's a persistent
+                                // override and lands on `uf` so the renderer respects it
+                                // without walking precedents.
+                                var currentEffectiveValue = sheetCell.getEffectiveValue();
+                                var isSameEffectiveValue = isEqual(currentEffectiveValue, result);
+                                var hasFormatting = !!formatting && Object.keys(formatting).length > 0;
+                                if (hasFormatting && formatting) {
+                                    for (var type in formatting) {
+                                        sheetCell.setUserEnteredFormat(type, formatting[type]);
+                                    }
+                                }
+                                if (!isSameEffectiveValue) {
+                                    // Set effective value of a cell after calculation. The
+                                    // number format and formatted value are no longer
+                                    // computed here — the renderer derives them from `uf`
+                                    // and the cell value.
+                                    var preserveStringLiteral = typeof result === "string";
+                                    sheetCell.setEffectiveValue(result, false, preserveStringLiteral);
+                                    // Formula that directly derived a cell
+                                    // A1: Link  B1 =A1 (use properties of link)
+                                    var derivedCell = deriveCellFromPrecedents(sheetCell.formula, getPrecedents(position), draft, sheetId, locale, cellXfsRegistry);
+                                    if (derivedCell) {
+                                        sheetCell.processDerivedCell(derivedCell);
+                                    }
+                                }
+                                else if (!hasFormatting && !wasLoading) {
+                                    continue;
+                                }
+                            }
+                            currentSheet[rowIndex].values[columnIndex] =
+                                sheetCell.getCellData();
+                            cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.registerCellXfs(sheetCell);
+                        }
+                    }
+                    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_1({
+                    sheetData: { patches: patches, inversePatches: inversePatches },
+                    disableRecalc: true,
+                    isFullRecalc: isFullRecalc,
+                });
+                return nextState;
+            });
+            // Save registries
+            cellXfsRegistry === null || cellXfsRegistry === void 0 ? void 0 : cellXfsRegistry.getPatches(saveHistory_1);
+        }
+    }, [
+        locale,
+        cellXfsRegistry,
+        getDataValidationById,
+        createHistory,
+        onChangeSheetData,
+        getPrecedents,
+        getEffectiveValuesFromRange,
+    ]);
+};

package/dist/cjs/hooks/use-on-change-batch-stream.d.ts

@@ -0,0 +1,7 @@
+import type { GridRange } from "@rowsncolumns/common-types";
+import { type CellData, type ChangeBatchStreamOptions, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { ChangeBatchStreamProps } from "../interface/change-batch-stream";
+import type { ChangeBatchStreamInput } from "../types";
+export type UseOnChangeBatchStreamProps<T extends CellData, S extends Sheet = Sheet> = ChangeBatchStreamProps<T, S>;
+export declare const useOnChangeBatchStream: <T extends CellData, S extends Sheet = Sheet>({ onChangeSheetData, onChangeSheets, getEffectiveValuesFromRange, getFormattedValue, getCellDimensions, getRowHeight, isMergedCell, locale, getDataValidationById, onRequestCalculate, getPrecedentsFromFormulaString, getSheetId, cellXfsRegistry, enqueueCalculation, onStreamStart, onStreamProgress, onStreamEnd, }: UseOnChangeBatchStreamProps<T, S>) => (sheetId: number, range: GridRange, stream: ChangeBatchStreamInput, options?: ChangeBatchStreamOptions) => Promise<void> | undefined;
+//# sourceMappingURL=use-on-change-batch-stream.d.ts.map

package/dist/cjs/hooks/use-on-change-batch-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-change-batch-stream.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-change-batch-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,wBAAwB,EAC7B,KAAK,KAAK,EAEX,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAE/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAGvD,MAAM,MAAM,2BAA2B,CACrC,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,KAAK,GAAG,KAAK,IACrB,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEjC,eAAO,MAAM,sBAAsB,GACjC,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,KAAK,GAAG,KAAK,EACvB,yTAkBC,2BAA2B,CAAC,CAAC,EAAE,CAAC,CAAC,eAKrB,MAAM,SACR,SAAS,UACR,sBAAsB,YACpB,wBAAwB,8BAuDvC,CAAC"}

package/dist/cjs/hooks/use-on-change-batch-stream.js

@@ -0,0 +1,59 @@
+import { useTokenizer, } from "@rowsncolumns/spreadsheet";
+import { useCallback } from "react";
+import { changeBatchStream } from "../interface/change-batch-stream";
+import { useCanEditCellRange } from "./use-can-edit-cellrange";
+export var useOnChangeBatchStream = function (_a) {
+    var onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, getEffectiveValuesFromRange = _a.getEffectiveValuesFromRange, getFormattedValue = _a.getFormattedValue, getCellDimensions = _a.getCellDimensions, getRowHeight = _a.getRowHeight, isMergedCell = _a.isMergedCell, locale = _a.locale, getDataValidationById = _a.getDataValidationById, onRequestCalculate = _a.onRequestCalculate, getPrecedentsFromFormulaString = _a.getPrecedentsFromFormulaString, getSheetId = _a.getSheetId, cellXfsRegistry = _a.cellXfsRegistry, enqueueCalculation = _a.enqueueCalculation, onStreamStart = _a.onStreamStart, onStreamProgress = _a.onStreamProgress, onStreamEnd = _a.onStreamEnd;
+    var tokenizer = useTokenizer();
+    var canEditCellRange = useCanEditCellRange();
+    return useCallback(function (sheetId, range, stream, options) {
+        // Protection enforcement — streamed batch edits are still
+        // mutations; gate the destination range up front. Once the
+        // stream starts the host can't easily unwind partial writes,
+        // so we check before kicking off `changeBatchStream`.
+        if (!canEditCellRange(sheetId, range)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        return changeBatchStream({
+            onChangeSheetData: onChangeSheetData,
+            onChangeSheets: onChangeSheets,
+            enqueueCalculation: enqueueCalculation,
+            getEffectiveValuesFromRange: getEffectiveValuesFromRange,
+            getFormattedValue: getFormattedValue,
+            getCellDimensions: getCellDimensions,
+            getRowHeight: getRowHeight,
+            isMergedCell: isMergedCell,
+            locale: locale,
+            getDataValidationById: getDataValidationById,
+            onRequestCalculate: onRequestCalculate,
+            getPrecedentsFromFormulaString: getPrecedentsFromFormulaString,
+            getSheetId: getSheetId,
+            cellXfsRegistry: cellXfsRegistry,
+            tokenizer: tokenizer,
+            onStreamStart: onStreamStart,
+            onStreamProgress: onStreamProgress,
+            onStreamEnd: onStreamEnd,
+        })(sheetId, range, stream, options);
+    }, [
+        onChangeSheetData,
+        onChangeSheets,
+        getEffectiveValuesFromRange,
+        getFormattedValue,
+        getCellDimensions,
+        getRowHeight,
+        isMergedCell,
+        locale,
+        getDataValidationById,
+        onRequestCalculate,
+        getPrecedentsFromFormulaString,
+        getSheetId,
+        cellXfsRegistry,
+        tokenizer,
+        enqueueCalculation,
+        onStreamStart,
+        onStreamProgress,
+        onStreamEnd,
+        canEditCellRange,
+    ]);
+};

package/dist/cjs/hooks/use-on-change-batch.d.ts

@@ -0,0 +1,54 @@
+import type { CellFormat, GridRange } from "@rowsncolumns/common-types";
+import type { CanvasGridMethods, CellData, ConditionValue, DataValidationRuleRecord, ParsedToken, Sheet, TableView } from "@rowsncolumns/spreadsheet";
+import type { Patch } from "immer";
+import type { OnCommand } from "../commands";
+import type { GeneratedNames } from "../generated-names";
+import type { ChangeBatchOptions } from "../interface/change-batch";
+import type { CalculationOperation, useCalculation } from "./use-calculation";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnChangeBatchProps<T extends CellData, S extends Sheet = Sheet> = {
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    getDataValidationById?: (id: DataValidationRuleRecord["id"]) => DataValidationRuleRecord | undefined;
+    getFormattedValue?: ReturnType<typeof useSheetProperties>["getFormattedValue"];
+    getUserEnteredValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | undefined;
+    /**
+     * Check if a cell is merged cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     * @returns
+     */
+    isMergedCell?: (sheetId: number, rowIndex: number, columnIndex: number) => boolean | undefined;
+    getCellDimensions?: CanvasGridMethods["getCellDimensions"];
+    enqueueCalculation(operation: CalculationOperation): void;
+    enqueueGraphOperation(operation: CalculationOperation): void;
+    getDependents: ReturnType<typeof useCalculation>["getDependents"];
+    getSheetName(sheetId: number): string;
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeTables?: UseSpreadsheetProps<T, S>["onChangeTables"];
+    onChangeCitations?: UseSpreadsheetProps<T, S>["onChangeCitations"];
+    onChangeTableColumn?: (sheetId: number, coords: {
+        rowIndex: number;
+        columnIndex: number;
+    }, value: string | boolean | undefined, currentTable: TableView | undefined, isRowExpansion: boolean, isColumnExpansion: boolean, range: GridRange) => void;
+    onChangeCalculatedColumn?: (sheetId: number, coords: {
+        rowIndex: number;
+        columnIndex: number;
+    }, value: string | boolean | undefined, currentTable: TableView | undefined) => void;
+    tables?: TableView[];
+    createHistory: () => (patches: SpreadsheetPatch<Patch>) => void;
+    getEffectiveValuesFromRange?: (address: string) => ConditionValue[];
+    getRowHeight?: CanvasGridMethods["getRowHeight"];
+    tokenizer?(value: string): ParsedToken[];
+    onCommand?: OnCommand;
+    generatedNames?: GeneratedNames;
+};
+export declare const useOnChangeBatch: <T extends CellData, K extends CellFormat, S extends Sheet = Sheet>({ locale, cellXfsRegistry, sharedStringRegistry, getDataValidationById, enqueueCalculation, onChangeSheetData, onChangeSheets, onChangeTables, tables, createHistory, getFormattedValue, getUserEnteredValue, getCellDimensions, getRowHeight, isMergedCell, enqueueGraphOperation, getDependents, getSheetName, onChangeCitations, onCommand, generatedNames, }: UseOnChangeBatchProps<T, S>) => (sheetId: number, ranges: GridRange[] | GridRange, values: (string | boolean | number | null | undefined)[][] | string | boolean | number | null | undefined, formatting?: (K | undefined | null)[][] | K | null | undefined, citations?: (string | undefined | null)[][] | string | null | undefined, changeBatchOptions?: ChangeBatchOptions) => void;
+//# sourceMappingURL=use-on-change-batch.d.ts.map

package/dist/cjs/hooks/use-on-change-batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-change-batch.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-change-batch.ts"],"names":[],"mappings":"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"}

package/dist/cjs/hooks/use-on-change-batch.js

@@ -0,0 +1,124 @@
+import { __values } from "tslib";
+import { useGetEffectiveValuesFromRange, useTokenizer, } from "@rowsncolumns/spreadsheet";
+import { useCallback } from "react";
+import { changeBatch } from "../interface/change-batch";
+import { useCanEditCellRange } from "./use-can-edit-cellrange";
+import { useOnChangeCalculatedColumn } from "./use-on-change-calculated-column";
+import { useOnChangeTableColumn } from "./use-on-change-table-column";
+export var useOnChangeBatch = function (_a) {
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, getDataValidationById = _a.getDataValidationById, enqueueCalculation = _a.enqueueCalculation, onChangeSheetData = _a.onChangeSheetData, onChangeSheets = _a.onChangeSheets, onChangeTables = _a.onChangeTables, tables = _a.tables, createHistory = _a.createHistory, getFormattedValue = _a.getFormattedValue, getUserEnteredValue = _a.getUserEnteredValue, getCellDimensions = _a.getCellDimensions, getRowHeight = _a.getRowHeight, isMergedCell = _a.isMergedCell, enqueueGraphOperation = _a.enqueueGraphOperation, getDependents = _a.getDependents, getSheetName = _a.getSheetName, onChangeCitations = _a.onChangeCitations, onCommand = _a.onCommand, generatedNames = _a.generatedNames;
+    // Allowed values
+    var getEffectiveValuesFromRange = useGetEffectiveValuesFromRange();
+    var tokenizer = useTokenizer();
+    var canEditCellRange = useCanEditCellRange();
+    var onChangeTableColumn = useOnChangeTableColumn({
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        onChangeSheetData: onChangeSheetData,
+        onChangeTables: onChangeTables,
+        getDependents: getDependents,
+        enqueueCalculation: enqueueCalculation,
+        enqueueGraphOperation: enqueueGraphOperation,
+        createHistory: createHistory,
+        onCommand: onCommand,
+        generatedNames: generatedNames,
+    });
+    var onChangeCalculatedColumn = useOnChangeCalculatedColumn({
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        sharedStringRegistry: sharedStringRegistry,
+        onChangeTables: onChangeTables,
+        onChangeSheetData: onChangeSheetData,
+        getUserEnteredValue: getUserEnteredValue,
+        getSheetName: getSheetName,
+        createHistory: createHistory,
+        enqueueCalculation: enqueueCalculation,
+        onCommand: onCommand,
+    });
+    return useCallback(function (sheetId, ranges, values, formatting, citations, changeBatchOptions) {
+        var e_1, _a;
+        // Protection enforcement — block batch edits that overlap any
+        // locked cell on a protected sheet. Multi-range writes have to
+        // pass for every range; one protected range vetoes the whole
+        // batch (consistent with how a single onChange would behave
+        // for any one of the ranges).
+        var targetRanges = Array.isArray(ranges) ? ranges : [ranges];
+        try {
+            for (var targetRanges_1 = __values(targetRanges), targetRanges_1_1 = targetRanges_1.next(); !targetRanges_1_1.done; targetRanges_1_1 = targetRanges_1.next()) {
+                var range = targetRanges_1_1.value;
+                if (!canEditCellRange(sheetId, range)) {
+                    console.debug("This range is protected, users cannot edit this cell range.");
+                    return;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (targetRanges_1_1 && !targetRanges_1_1.done && (_a = targetRanges_1.return)) _a.call(targetRanges_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        changeBatch({
+            createHistory: createHistory,
+            enqueueCalculation: enqueueCalculation,
+            onChangeSheetData: onChangeSheetData,
+            onChangeSheets: onChangeSheets,
+            onChangeTables: onChangeTables,
+            getEffectiveValuesFromRange: getEffectiveValuesFromRange,
+            locale: locale,
+            cellXfsRegistry: cellXfsRegistry,
+            sharedStringRegistry: sharedStringRegistry,
+            getDataValidationById: getDataValidationById,
+            getFormattedValue: getFormattedValue,
+            getUserEnteredValue: getUserEnteredValue,
+            onChangeTableColumn: onChangeTableColumn,
+            onChangeCalculatedColumn: onChangeCalculatedColumn,
+            tokenizer: tokenizer,
+            getCellDimensions: getCellDimensions,
+            getRowHeight: getRowHeight,
+            isMergedCell: isMergedCell,
+            enqueueGraphOperation: enqueueGraphOperation,
+            getDependents: getDependents,
+            getSheetName: getSheetName,
+            tables: tables,
+            onChangeCitations: onChangeCitations,
+        })(sheetId, ranges, values, formatting, citations, changeBatchOptions);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "change-batch",
+            sheetId: sheetId,
+            ranges: ranges,
+            values: values,
+            formatting: formatting,
+            citations: citations,
+            options: changeBatchOptions,
+        });
+    }, [
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getDataValidationById,
+        getFormattedValue,
+        getUserEnteredValue,
+        getCellDimensions,
+        enqueueCalculation,
+        createHistory,
+        onChangeSheetData,
+        onChangeSheets,
+        getEffectiveValuesFromRange,
+        onChangeTables,
+        getRowHeight,
+        isMergedCell,
+        tables,
+        tokenizer,
+        onChangeTableColumn,
+        onChangeCalculatedColumn,
+        enqueueGraphOperation,
+        getDependents,
+        getSheetName,
+        onChangeCitations,
+        onCommand,
+        canEditCellRange,
+    ]);
+};

package/dist/cjs/hooks/use-on-change-calculated-column.d.ts

@@ -0,0 +1,23 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { CellData, TableView } from "@rowsncolumns/spreadsheet";
+import type { Patch } from "immer";
+import type { OnCommand } from "../commands";
+import type { CalculationOperation } from "./use-calculation";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SharedStringRegistry } from "./use-ss-registry";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnChangeCalculatedColumnProps<T extends CellData> = {
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    onChangeTables: UseSpreadsheetProps<T>["onChangeTables"];
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+    getUserEnteredValue: (sheetId: number, rowIndex: number, columnIndex: number) => string | undefined;
+    getSheetName(sheetId: number): string;
+    enqueueCalculation(operation: CalculationOperation): void;
+    createHistory: () => (patches: SpreadsheetPatch<Patch>) => void;
+    onCommand?: OnCommand;
+};
+export declare const useOnChangeCalculatedColumn: <T extends CellData>({ locale, cellXfsRegistry, sharedStringRegistry, onChangeTables, onChangeSheetData, getUserEnteredValue, getSheetName, createHistory, enqueueCalculation, onCommand, }: UseOnChangeCalculatedColumnProps<T>) => (sheetId: number, coords: CellInterface, value: string | boolean | undefined, currentTable: TableView | undefined) => void;
+//# sourceMappingURL=use-on-change-calculated-column.d.ts.map

package/dist/cjs/hooks/use-on-change-calculated-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-change-calculated-column.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-change-calculated-column.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,gCAAgC,CAAC,CAAC,SAAS,QAAQ,IAAI;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,cAAc,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IACzD,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,mBAAmB,EAAE,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,MAAM,GAAG,SAAS,CAAC;IACxB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC,kBAAkB,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC1D,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IAChE,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAI,CAAC,SAAS,QAAQ,EAAE,wKAW7D,gCAAgC,CAAC,CAAC,CAAC,eAGvB,MAAM,UACP,aAAa,SACd,MAAM,GAAG,OAAO,GAAG,SAAS,gBACrB,SAAS,GAAG,SAAS,SA4BxC,CAAC"}

package/dist/cjs/hooks/use-on-change-calculated-column.js

@@ -0,0 +1,30 @@
+import { useCallback } from "react";
+import { changeCalculatedColumn } from "../interface/change-calculated-column";
+export var useOnChangeCalculatedColumn = function (_a) {
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry, onChangeTables = _a.onChangeTables, onChangeSheetData = _a.onChangeSheetData, getUserEnteredValue = _a.getUserEnteredValue, getSheetName = _a.getSheetName, createHistory = _a.createHistory, enqueueCalculation = _a.enqueueCalculation, onCommand = _a.onCommand;
+    return useCallback(function (sheetId, coords, value, currentTable) {
+        changeCalculatedColumn({
+            locale: locale,
+            cellXfsRegistry: cellXfsRegistry,
+            sharedStringRegistry: sharedStringRegistry,
+            onChangeTables: onChangeTables,
+            onChangeSheetData: onChangeSheetData,
+            getUserEnteredValue: getUserEnteredValue,
+            getSheetName: getSheetName,
+            createHistory: createHistory,
+            enqueueCalculation: enqueueCalculation,
+            onCommand: onCommand,
+        })(sheetId, coords, value, currentTable);
+    }, [
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        onChangeTables,
+        onChangeSheetData,
+        getUserEnteredValue,
+        getSheetName,
+        createHistory,
+        enqueueCalculation,
+        onCommand,
+    ]);
+};

package/dist/cjs/hooks/use-on-change-decimals.d.ts

@@ -0,0 +1,22 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import type { Patch } from "immer";
+import type { OnCommand } from "../commands";
+import type { useCalculation } from "./use-calculation";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseChangeDecimalsProps<T extends CellData> = {
+    locale?: string;
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+    createHistory: () => (patches: SpreadsheetPatch<Patch>) => void;
+    cellXfsRegistry?: CellXfsRegistry;
+    getDataValidationById?: ReturnType<typeof useSheetProperties>["getDataValidationById"];
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    onCommand?: OnCommand;
+};
+type UpDownType = "increment" | "decrement";
+export declare const useOnChangeDecimals: <T extends CellData>({ locale, cellXfsRegistry, onChangeSheetData, createHistory, enqueueCalculation, getDataValidationById, onCommand, }: UseChangeDecimalsProps<T>) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], type: UpDownType) => void;
+export {};
+//# sourceMappingURL=use-on-change-decimals.d.ts.map

package/dist/cjs/hooks/use-on-change-decimals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-change-decimals.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-change-decimals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAC/E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,QAAQ,IAAI;IACvD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IAChE,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,qBAAqB,CAAC,EAAE,UAAU,CAChC,OAAO,kBAAkB,CAC1B,CAAC,uBAAuB,CAAC,CAAC;IAC3B,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,KAAK,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC;AAE5C,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,QAAQ,EAAE,sHAQrD,sBAAsB,CAAC,CAAC,CAAC,eAIb,MAAM,cACH,aAAa,cACb,aAAa,CAAC,mBAAmB,CAAC,EAAE,QAC1C,UAAU,SA8CrB,CAAC"}

package/dist/cjs/hooks/use-on-change-decimals.js

@@ -0,0 +1,47 @@
+import { useCallback } from "react";
+import { changeDecimals } from "../interface/change-decimals";
+import { useCanEditCellRange } from "./use-can-edit-cellrange";
+export var useOnChangeDecimals = function (_a) {
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, onChangeSheetData = _a.onChangeSheetData, createHistory = _a.createHistory, enqueueCalculation = _a.enqueueCalculation, getDataValidationById = _a.getDataValidationById, onCommand = _a.onCommand;
+    var canEditCellRange = useCanEditCellRange();
+    return useCallback(function (sheetId, activeCell, selections, type) {
+        var _a, _b;
+        // Protection — increase/decrease-decimal modifies the cell's
+        // number format. Block if any selected cell is locked on a
+        // protected sheet.
+        var targetRange = (_b = (_a = selections[0]) === null || _a === void 0 ? void 0 : _a.range) !== null && _b !== void 0 ? _b : {
+            startRowIndex: activeCell.rowIndex,
+            endRowIndex: activeCell.rowIndex,
+            startColumnIndex: activeCell.columnIndex,
+            endColumnIndex: activeCell.columnIndex,
+        };
+        if (!canEditCellRange(sheetId, targetRange)) {
+            console.debug("This range is protected, users cannot change decimal precision.");
+            return;
+        }
+        changeDecimals({
+            locale: locale,
+            onChangeSheetData: onChangeSheetData,
+            createHistory: createHistory,
+            enqueueCalculation: enqueueCalculation,
+            cellXfsRegistry: cellXfsRegistry,
+            getDataValidationById: getDataValidationById,
+        })(sheetId, activeCell, selections, type);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "change-decimals",
+            sheetId: sheetId,
+            activeCell: activeCell,
+            selections: selections,
+            type: type,
+        });
+    }, [
+        locale,
+        cellXfsRegistry,
+        getDataValidationById,
+        onChangeSheetData,
+        enqueueCalculation,
+        createHistory,
+        onCommand,
+        canEditCellRange,
+    ]);
+};