@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-deferred-calculation-flush.d.ts

@@ -0,0 +1,14 @@
+import type { MutableRefObject } from "react";
+type DeferredMap<T> = Map<number, Map<string, T>>;
+type UseDeferredCalculationFlushOptions<T> = {
+    activeSheetId?: number;
+    deferredOperationsBySheetRef: MutableRefObject<DeferredMap<T>>;
+    enqueueOperation: (operation: T) => void;
+    onFlushComplete?: () => void;
+    onChunkComplete?: () => void | Promise<void>;
+    chunkSize?: number;
+    maxSliceMs?: number;
+};
+export declare const useDeferredCalculationFlush: <T>({ activeSheetId, deferredOperationsBySheetRef, enqueueOperation, onFlushComplete, onChunkComplete, chunkSize, maxSliceMs, }: UseDeferredCalculationFlushOptions<T>) => void;
+export {};
+//# sourceMappingURL=use-deferred-calculation-flush.d.ts.map

package/dist/cjs/hooks/use-deferred-calculation-flush.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-deferred-calculation-flush.d.ts","sourceRoot":"","sources":["../../../hooks/use-deferred-calculation-flush.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAK9C,KAAK,WAAW,CAAC,CAAC,IAAI,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;AAElD,KAAK,kCAAkC,CAAC,CAAC,IAAI;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4BAA4B,EAAE,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/D,gBAAgB,EAAE,CAAC,SAAS,EAAE,CAAC,KAAK,IAAI,CAAC;IACzC,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAI,CAAC,EAAE,6HAQ5C,kCAAkC,CAAC,CAAC,CAAC,SAqFvC,CAAC"}

package/dist/cjs/hooks/use-deferred-calculation-flush.js

@@ -0,0 +1,81 @@
+import { useCallbackRef } from "@rowsncolumns/spreadsheet";
+import { useCallback, useEffect, useRef } from "react";
+import { useIdleScheduler } from "./use-idle-scheduler";
+export var useDeferredCalculationFlush = function (_a) {
+    var activeSheetId = _a.activeSheetId, deferredOperationsBySheetRef = _a.deferredOperationsBySheetRef, enqueueOperation = _a.enqueueOperation, onFlushComplete = _a.onFlushComplete, onChunkComplete = _a.onChunkComplete, _b = _a.chunkSize, chunkSize = _b === void 0 ? 200 : _b, _c = _a.maxSliceMs, maxSliceMs = _c === void 0 ? 8 : _c;
+    var iteratorRef = useRef(null);
+    var runIdRef = useRef(0);
+    var enqueueOperationRef = useCallbackRef(enqueueOperation);
+    var onFlushCompleteRef = useCallbackRef(onFlushComplete);
+    var onChunkCompleteRef = useCallbackRef(onChunkComplete);
+    var _d = useIdleScheduler(), schedule = _d.schedule, cancel = _d.cancel;
+    var getTimestamp = function () {
+        return typeof performance !== "undefined" && typeof performance.now === "function"
+            ? performance.now()
+            : Date.now();
+    };
+    var scheduleNextChunk = useCallback(function (runId) {
+        schedule(function () {
+            if (runId !== runIdRef.current) {
+                return;
+            }
+            var iterator = iteratorRef.current;
+            if (!iterator) {
+                onFlushCompleteRef === null || onFlushCompleteRef === void 0 ? void 0 : onFlushCompleteRef();
+                return;
+            }
+            var start = getTimestamp();
+            var processed = 0;
+            while (processed < chunkSize) {
+                var next = iterator.next();
+                if (next.done) {
+                    iteratorRef.current = null;
+                    onFlushCompleteRef === null || onFlushCompleteRef === void 0 ? void 0 : onFlushCompleteRef();
+                    return;
+                }
+                enqueueOperationRef === null || enqueueOperationRef === void 0 ? void 0 : enqueueOperationRef(next.value);
+                processed += 1;
+                if (getTimestamp() - start >= maxSliceMs) {
+                    break;
+                }
+            }
+            var maybeYield = onChunkCompleteRef === null || onChunkCompleteRef === void 0 ? void 0 : onChunkCompleteRef();
+            if (maybeYield &&
+                typeof maybeYield.then === "function") {
+                Promise.resolve(maybeYield).then(function () {
+                    if (runId === runIdRef.current) {
+                        scheduleNextChunk(runId);
+                    }
+                });
+                return;
+            }
+            scheduleNextChunk(runId);
+        });
+    }, [
+        chunkSize,
+        schedule,
+        enqueueOperationRef,
+        onFlushCompleteRef,
+        onChunkCompleteRef,
+        maxSliceMs,
+    ]);
+    useEffect(function () {
+        if (typeof activeSheetId !== "number") {
+            return;
+        }
+        var deferred = deferredOperationsBySheetRef.current.get(activeSheetId);
+        if (!deferred || !deferred.size) {
+            return;
+        }
+        cancel();
+        deferredOperationsBySheetRef.current.delete(activeSheetId);
+        iteratorRef.current = deferred.values();
+        runIdRef.current += 1;
+        scheduleNextChunk(runIdRef.current);
+        return function () {
+            cancel();
+            runIdRef.current += 1;
+            iteratorRef.current = null;
+        };
+    }, [activeSheetId, cancel, deferredOperationsBySheetRef, scheduleNextChunk]);
+};

package/dist/cjs/hooks/use-idle-scheduler.d.ts

@@ -0,0 +1,5 @@
+export declare const useIdleScheduler: () => {
+    schedule: (callback: () => void) => void;
+    cancel: () => void;
+};
+//# sourceMappingURL=use-idle-scheduler.d.ts.map

package/dist/cjs/hooks/use-idle-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-idle-scheduler.d.ts","sourceRoot":"","sources":["../../../hooks/use-idle-scheduler.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,gBAAgB;yBAoBa,MAAM,IAAI;;CA2BnD,CAAC"}

package/dist/cjs/hooks/use-idle-scheduler.js

@@ -0,0 +1,46 @@
+import { useCallback, useEffect, useRef } from "react";
+export var useIdleScheduler = function () {
+    var handleRef = useRef(null);
+    var callbackRef = useRef(null);
+    var cancel = useCallback(function () {
+        if (handleRef.current === null) {
+            return;
+        }
+        var handle = handleRef.current;
+        if (handle.kind === "raf") {
+            if (typeof cancelAnimationFrame === "function") {
+                cancelAnimationFrame(handle.handle);
+            }
+        }
+        else {
+            clearTimeout(handle.handle);
+        }
+        handleRef.current = null;
+        callbackRef.current = null;
+    }, []);
+    var schedule = useCallback(function (callback) {
+        callbackRef.current = callback;
+        if (handleRef.current !== null) {
+            return;
+        }
+        var run = function () {
+            handleRef.current = null;
+            var pending = callbackRef.current;
+            callbackRef.current = null;
+            pending === null || pending === void 0 ? void 0 : pending();
+        };
+        if (typeof requestAnimationFrame === "function") {
+            handleRef.current = {
+                kind: "raf",
+                handle: requestAnimationFrame(run),
+            };
+            return;
+        }
+        handleRef.current = {
+            kind: "timeout",
+            handle: setTimeout(run, 0),
+        };
+    }, []);
+    useEffect(function () { return cancel; }, [cancel]);
+    return { schedule: schedule, cancel: cancel };
+};

package/dist/cjs/hooks/use-indent.d.ts

@@ -0,0 +1,23 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { CalculationOperation } 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 UseIndentProps<T extends CellData> = {
+    locale: string;
+    getDataValidationById?: ReturnType<typeof useSheetProperties>["getDataValidationById"];
+    enqueueCalculation(operation: CalculationOperation): void;
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    cellXfsRegistry?: CellXfsRegistry;
+    onCommand?: OnCommand;
+};
+export declare const useIndent: <T extends CellData>({ locale, cellXfsRegistry, enqueueCalculation, onChangeSheetData, createHistory, getDataValidationById, onCommand, }: UseIndentProps<T>) => {
+    onIncreaseIndent: (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+    onDecreaseIndent: (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+    onChangeIndent: (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], shouldIncrease: boolean) => void;
+};
+//# sourceMappingURL=use-indent.d.ts.map

package/dist/cjs/hooks/use-indent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-indent.d.ts","sourceRoot":"","sources":["../../../hooks/use-indent.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;AAG/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAM7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,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,cAAc,CAAC,CAAC,SAAS,QAAQ,IAAI;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB,CAAC,EAAE,UAAU,CAChC,OAAO,kBAAkB,CAC1B,CAAC,uBAAuB,CAAC,CAAC;IAC3B,kBAAkB,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC1D,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC/D,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,QAAQ,EAAE,sHAQ3C,cAAc,CAAC,CAAC,CAAC;gCAML,MAAM,cACH,aAAa,cACb,aAAa,CAAC,mBAAmB,CAAC,EAAE;gCAwCvC,MAAM,cACH,aAAa,cACb,aAAa,CAAC,mBAAmB,CAAC,EAAE;8BAwCvC,MAAM,cACH,aAAa,cACb,aAAa,CAAC,mBAAmB,CAAC,EAAE,kBAChC,OAAO;CAsC5B,CAAC"}

package/dist/cjs/hooks/use-indent.js

@@ -0,0 +1,98 @@
+import { useCallback, useMemo } from "react";
+import { changeIndent, decreaseIndent, increaseIndent, } from "../interface/indent";
+import { useCanEditCellRange } from "./use-can-edit-cellrange";
+export var useIndent = function (_a) {
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, enqueueCalculation = _a.enqueueCalculation, onChangeSheetData = _a.onChangeSheetData, createHistory = _a.createHistory, getDataValidationById = _a.getDataValidationById, onCommand = _a.onCommand;
+    var canEditCellRange = useCanEditCellRange();
+    // Increase indent
+    var onIncreaseIndent = useCallback(function (sheetId, activeCell, selections) {
+        if (!canEditCellRange(sheetId, activeCell)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        increaseIndent({
+            locale: locale,
+            enqueueCalculation: enqueueCalculation,
+            onChangeSheetData: onChangeSheetData,
+            createHistory: createHistory,
+            cellXfsRegistry: cellXfsRegistry,
+            getDataValidationById: getDataValidationById,
+        })(sheetId, activeCell, selections);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "increase-indent",
+            sheetId: sheetId,
+            activeCell: activeCell,
+            selections: selections,
+        });
+    }, [
+        locale,
+        cellXfsRegistry,
+        enqueueCalculation,
+        onChangeSheetData,
+        createHistory,
+        canEditCellRange,
+        getDataValidationById,
+        onCommand,
+    ]);
+    // Decrease indent
+    var onDecreaseIndent = useCallback(function (sheetId, activeCell, selections) {
+        if (!canEditCellRange(sheetId, activeCell)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        decreaseIndent({
+            locale: locale,
+            enqueueCalculation: enqueueCalculation,
+            onChangeSheetData: onChangeSheetData,
+            createHistory: createHistory,
+            cellXfsRegistry: cellXfsRegistry,
+            getDataValidationById: getDataValidationById,
+        })(sheetId, activeCell, selections);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "decrease-indent",
+            sheetId: sheetId,
+            activeCell: activeCell,
+            selections: selections,
+        });
+    }, [
+        locale,
+        enqueueCalculation,
+        onChangeSheetData,
+        createHistory,
+        canEditCellRange,
+        cellXfsRegistry,
+        getDataValidationById,
+        onCommand,
+    ]);
+    // Change indent
+    var onChangeIndent = useCallback(function (sheetId, activeCell, selections, shouldIncrease) {
+        changeIndent({
+            onChangeSheetData: onChangeSheetData,
+            createHistory: createHistory,
+            locale: locale,
+            enqueueCalculation: enqueueCalculation,
+            cellXfsRegistry: cellXfsRegistry,
+            getDataValidationById: getDataValidationById,
+        })(sheetId, activeCell, selections, shouldIncrease);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "change-indent",
+            sheetId: sheetId,
+            activeCell: activeCell,
+            selections: selections,
+            shouldIncrease: shouldIncrease,
+        });
+    }, [
+        locale,
+        enqueueCalculation,
+        onChangeSheetData,
+        createHistory,
+        cellXfsRegistry,
+        getDataValidationById,
+        onCommand,
+    ]);
+    return useMemo(function () { return ({
+        onIncreaseIndent: onIncreaseIndent,
+        onDecreaseIndent: onDecreaseIndent,
+        onChangeIndent: onChangeIndent,
+    }); }, [onIncreaseIndent, onChangeIndent, onDecreaseIndent]);
+};

package/dist/cjs/hooks/use-named-range.d.ts

@@ -0,0 +1,7 @@
+import type { CellCoords, CellRange, FormulaResult } from "@rowsncolumns/fast-formula-parser";
+import type { NamedRange } from "@rowsncolumns/spreadsheet";
+export declare const useNamedRange: ({ namedRanges, getSheetName, }: {
+    namedRanges: NamedRange[] | undefined;
+    getSheetName(sheetId: number): string;
+}) => (variableName: string) => CellCoords | CellRange | FormulaResult;
+//# sourceMappingURL=use-named-range.d.ts.map

package/dist/cjs/hooks/use-named-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-named-range.d.ts","sourceRoot":"","sources":["../../../hooks/use-named-range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,SAAS,EACT,aAAa,EACd,MAAM,mCAAmC,CAAC;AAE3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAS5D,eAAO,MAAM,aAAa,GAAI,gCAG3B;IACD,WAAW,EAAE,UAAU,EAAE,GAAG,SAAS,CAAC;IACtC,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CACvC,oBAcoB,MAAM,KAAG,UAAU,GAAG,SAAS,GAAG,aAsEtD,CAAC"}

package/dist/cjs/hooks/use-named-range.js

@@ -0,0 +1,70 @@
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+import { checkIfStringIsReference, useCallbackRef, useGetSelectionsFromFormula, } from "@rowsncolumns/spreadsheet";
+import { isAFormula, isNil } from "@rowsncolumns/utils";
+import { useCallback, useMemo } from "react";
+export var useNamedRange = function (_a) {
+    var namedRanges = _a.namedRanges, getSheetName = _a.getSheetName;
+    var getSelectionsFromFormula = useGetSelectionsFromFormula();
+    // Build case-insensitive lookup map for O(1) access
+    var namedRangeMap = useMemo(function () {
+        var map = new Map();
+        namedRanges === null || namedRanges === void 0 ? void 0 : namedRanges.forEach(function (range) {
+            map.set(range.name.toLowerCase(), range);
+        });
+        return map;
+    }, [namedRanges]);
+    return useCallbackRef(useCallback(function (variableName) {
+        // O(1) hash lookup instead of O(n) linear search
+        var namedRange = namedRangeMap.get(variableName.toLowerCase());
+        if (namedRange === null || namedRange === void 0 ? void 0 : namedRange.range) {
+            return {
+                from: {
+                    row: namedRange.range.startRowIndex,
+                    col: namedRange.range.startColumnIndex,
+                },
+                to: {
+                    row: namedRange.range.endRowIndex,
+                    col: namedRange.range.endColumnIndex,
+                },
+                sheet: getSheetName(namedRange.range.sheetId),
+            };
+        }
+        // Get static or formula value
+        var result = namedRange === null || namedRange === void 0 ? void 0 : namedRange.value;
+        if (!isNil(result)) {
+            var isFormula = isAFormula(result);
+            // Reference values come in two shapes: "=Sheet1!$A$1"
+            // (spreadsheet convention) and bare "Sheet1!$A$1" (OOXML
+            // definedName convention). Both resolve as ranges. Bare
+            // external-workbook references like "'[1]Revenue'!$A$17"
+            // can't resolve to a local sheet, so they stay on the
+            // static-value path unless explicitly "="-prefixed.
+            var isExternalWorkbookRef = typeof result === "string" && result.includes("[");
+            if ((isFormula || !isExternalWorkbookRef) &&
+                typeof result === "string" &&
+                checkIfStringIsReference(result)) {
+                // Normalize to the "="-prefixed shape the tokenizer-backed
+                // selection resolver is exercised with everywhere else.
+                var selections = getSelectionsFromFormula === null || getSelectionsFromFormula === void 0 ? void 0 : getSelectionsFromFormula(isFormula ? result : "=".concat(result));
+                var firstSel = selections === null || selections === void 0 ? void 0 : selections[0];
+                if (firstSel) {
+                    return {
+                        from: {
+                            row: firstSel.range.startRowIndex,
+                            col: firstSel.range.startColumnIndex,
+                        },
+                        to: {
+                            row: firstSel.range.endRowIndex,
+                            col: firstSel.range.endColumnIndex,
+                        },
+                        sheet: firstSel.sheetName,
+                    };
+                }
+            }
+            // Calculation TBD
+            // Static value
+            return result;
+        }
+        throw new FormulaError("#NAME?", "Unknown range name: '".concat(variableName, "'."));
+    }, [namedRangeMap, getSheetName, getSelectionsFromFormula]));
+};

package/dist/cjs/hooks/use-on-adjust-row-height.d.ts

@@ -0,0 +1,11 @@
+import type { CellData, Sheet, TextFormat } from "@rowsncolumns/spreadsheet";
+import type { TextFormatRun } from "@rowsncolumns/ui";
+import type { Patch } from "immer";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnAdjustRowHeightProps<T extends CellData, S extends Sheet> = {
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+};
+export declare const useOnAdjustRowHeight: <T extends CellData, S extends Sheet>({ onChangeSheets, }: UseOnAdjustRowHeightProps<T, S>) => (sheetId: number, rowIndex: number, columnIndex: number, value: string, textFormat: TextFormat | undefined, shouldWrap: boolean | undefined, saveHistory: (patches: SpreadsheetPatch<Patch>) => void, textFormatRuns?: TextFormatRun[] | null) => void;
+export {};
+//# sourceMappingURL=use-on-adjust-row-height.d.ts.map

package/dist/cjs/hooks/use-on-adjust-row-height.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-adjust-row-height.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-adjust-row-height.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAER,KAAK,EACL,UAAU,EACX,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAKnC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,yBAAyB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACpE,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;CAC7D,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,qBAEvE,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,eAKnB,MAAM,YACL,MAAM,eACH,MAAM,SACZ,MAAM,cACD,UAAU,GAAG,SAAS,cACtB,OAAO,GAAG,SAAS,eAClB,CAAC,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,IAAI,mBACtC,aAAa,EAAE,GAAG,IAAI,SAqE5C,CAAC"}

package/dist/cjs/hooks/use-on-adjust-row-height.js

@@ -0,0 +1,66 @@
+import { __read } from "tslib";
+import { useGetFinalRowHeight } from "@rowsncolumns/spreadsheet";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { useCanEditCellRange } from "./use-can-edit-cellrange";
+export var useOnAdjustRowHeight = function (_a) {
+    var onChangeSheets = _a.onChangeSheets;
+    var getFinalRowHeight = useGetFinalRowHeight();
+    var canEditCellRange = useCanEditCellRange();
+    return useCallback(function (sheetId, rowIndex, columnIndex, value, textFormat, shouldWrap, saveHistory, textFormatRuns) {
+        if (!canEditCellRange(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex })) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        var dimension = getFinalRowHeight === null || getFinalRowHeight === void 0 ? void 0 : getFinalRowHeight(sheetId, rowIndex, columnIndex, {
+            textOverride: value,
+            textFormatOverride: textFormat,
+            shouldWrapOverride: shouldWrap,
+            // Measure with the runs being committed, not the cell's stored
+            // (pre-commit) runs — a run-level font-size change must be able
+            // to grow/shrink the row on commit.
+            textFormatRunsOverride: textFormatRuns,
+        });
+        if (dimension !== undefined) {
+            onChangeSheets === null || onChangeSheets === void 0 ? void 0 : onChangeSheets(function (prevSheets) {
+                var _a = __read(produceWithPatches(prevSheets, function (draft) {
+                    var _a, _b, _c, _d, _e;
+                    var sheet = draft.find(function (sheet) { return sheet.sheetId === sheetId; });
+                    var axis = "x";
+                    if (sheet) {
+                        var metaData = axis === "x" ? "rowMetadata" : "columnMetadata";
+                        if (!sheet[metaData]) {
+                            sheet[metaData] = [];
+                        }
+                        var currentSize = (_c = (_b = (_a = sheet.rowMetadata) === null || _a === void 0 ? void 0 : _a[rowIndex]) === null || _b === void 0 ? void 0 : _b.size) !== null && _c !== void 0 ? _c : 0;
+                        var resizedByUser = (_e = (_d = sheet.rowMetadata) === null || _d === void 0 ? void 0 : _d[rowIndex]) === null || _e === void 0 ? void 0 : _e.resizedByUser;
+                        // Auto-resize only when the user hasn't pinned the row
+                        // height. If they have, treat it as authoritative — even
+                        // if the content now wants a different size, the explicit
+                        // drag wins. When auto-managed, set to the new measured
+                        // dimension whether that's bigger (multi-line text just
+                        // typed) OR smaller (user deleted lines and the row
+                        // should shrink back). The previous "grow only" rule
+                        // left rows stuck at the tallest historical value.
+                        if (dimension !== 0 &&
+                            !resizedByUser &&
+                            dimension !== currentSize) {
+                            sheet[metaData][rowIndex] = {
+                                size: dimension,
+                                resizedByUser: false,
+                            };
+                        }
+                    }
+                }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+                // Maybe move to use-undo-redo.ts
+                // ? @todo vinay
+                if (patches.length) {
+                    saveHistory({
+                        sheets: { patches: patches, inversePatches: inversePatches },
+                    });
+                }
+                return nextState;
+            });
+        }
+    }, [onChangeSheets, canEditCellRange, getFinalRowHeight]);
+};

package/dist/cjs/hooks/use-on-autoresize.d.ts

@@ -0,0 +1,17 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { AXIS, CanvasGridMethods, CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseOnAutoResizeProps<T extends CellData, S extends Sheet> = {
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    getActiveCell: () => CellInterface;
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    getRowHeight?: CanvasGridMethods["getRowHeight"];
+    getColumnWidth?: CanvasGridMethods["getColumnWidth"];
+    getCellDimensions?: CanvasGridMethods["getCellDimensions"];
+    isMergedCell?: (sheetId: number, rowIndex: number, columnIndex: number) => boolean | undefined;
+    onCommand?: OnCommand;
+};
+export declare const useOnAutoResize: <T extends CellData, S extends Sheet>({ onChangeSheets, createHistory, getActiveCell, getRowHeight, getColumnWidth, getCellDimensions, isMergedCell, onCommand, }: UseOnAutoResizeProps<T, S>) => (sheetId: number, indexes: number[], axis: AXIS) => void;
+//# sourceMappingURL=use-on-autoresize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-autoresize.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-autoresize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EACV,IAAI,EACJ,iBAAiB,EACjB,QAAQ,EACR,KAAK,EACN,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACtE,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,aAAa,EAAE,MAAM,aAAa,CAAC;IACnC,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,YAAY,CAAC,EAAE,iBAAiB,CAAC,cAAc,CAAC,CAAC;IACjD,cAAc,CAAC,EAAE,iBAAiB,CAAC,gBAAgB,CAAC,CAAC;IACrD,iBAAiB,CAAC,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAC;IAC3D,YAAY,CAAC,EAAE,CACb,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,KAChB,OAAO,GAAG,SAAS,CAAC;IACzB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,6HASlE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,eAIf,MAAM,WAAW,MAAM,EAAE,QAAQ,IAAI,SAuClD,CAAC"}

package/dist/cjs/hooks/use-on-autoresize.js

@@ -0,0 +1,39 @@
+import { useCallback } from "react";
+import { autoResize } from "../interface/auto-resize";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+export var useOnAutoResize = function (_a) {
+    var onChangeSheets = _a.onChangeSheets, createHistory = _a.createHistory, getActiveCell = _a.getActiveCell, getRowHeight = _a.getRowHeight, getColumnWidth = _a.getColumnWidth, getCellDimensions = _a.getCellDimensions, isMergedCell = _a.isMergedCell, onCommand = _a.onCommand;
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, indexes, axis) {
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        var result = autoResize({
+            createHistory: createHistory,
+            getActiveCell: getActiveCell,
+            onChangeSheets: onChangeSheets,
+            getColumnWidth: getColumnWidth,
+            getRowHeight: getRowHeight,
+            getCellDimensions: getCellDimensions,
+            isMergedCell: isMergedCell,
+        })(sheetId, indexes, axis);
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({
+            command: "auto-resize",
+            sheetId: sheetId,
+            indexes: indexes,
+            axis: axis,
+        });
+        return result;
+    }, [
+        onChangeSheets,
+        getActiveCell,
+        getRowHeight,
+        getColumnWidth,
+        getCellDimensions,
+        isMergedCell,
+        createHistory,
+        canEditSheet,
+        onCommand,
+    ]);
+};

package/dist/cjs/hooks/use-on-banded-ranges.d.ts

@@ -0,0 +1,15 @@
+import type { BandedRange, CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnBandedRangesProps<T extends CellData, S extends Sheet> = {
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    onChangeBandedRanges: UseSpreadsheetProps<T, S>["onChangeBandedRanges"];
+    onCommand?: OnCommand;
+};
+export declare const useOnBandedRanges: <T extends CellData, S extends Sheet>({ onChangeBandedRanges, onCommand, }: UseOnBandedRangesProps<T, S>) => {
+    onAddBandedRange: (sheetId: number, bandedRange: BandedRange) => void;
+    onRemoveBandedRange: (sheetId: number, bandedRange: BandedRange) => void;
+};
+export {};
+//# sourceMappingURL=use-on-banded-ranges.d.ts.map

package/dist/cjs/hooks/use-on-banded-ranges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-banded-ranges.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-banded-ranges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAI9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,sBAAsB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IACjE,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,oBAAoB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC;IACxE,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,sCAGpE,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC;gCAGjB,MAAM,eAAe,WAAW;mCAyBhC,MAAM,eAAe,WAAW;CAqB7C,CAAC"}

package/dist/cjs/hooks/use-on-banded-ranges.js

@@ -0,0 +1,38 @@
+import { __read } from "tslib";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+export var useOnBandedRanges = function (_a) {
+    var onChangeBandedRanges = _a.onChangeBandedRanges, onCommand = _a.onCommand;
+    // Adds a banded range
+    var onAddBandedRange = useCallback(function (sheetId, bandedRange) {
+        // Track banded ranges in sheets
+        onChangeBandedRanges === null || onChangeBandedRanges === void 0 ? void 0 : onChangeBandedRanges(function (prevRanges) {
+            var _a = __read(produceWithPatches(prevRanges, function (draft) {
+                var exists = draft === null || draft === void 0 ? void 0 : draft.find(function (band) { return band.bandedRangeId === bandedRange.bandedRangeId; });
+                if (!exists) {
+                    if (!draft) {
+                        draft = [];
+                    }
+                    draft === null || draft === void 0 ? void 0 : draft.push(bandedRange);
+                }
+            }), 1), nextState = _a[0];
+            return nextState;
+        });
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "add-banded-range", sheetId: sheetId, bandedRange: bandedRange });
+    }, [onChangeBandedRanges, onCommand]);
+    // Removes a banded range
+    var onRemoveBandedRange = useCallback(function (sheetId, bandedRange) {
+        // Track banded ranges in sheets
+        onChangeBandedRanges === null || onChangeBandedRanges === void 0 ? void 0 : onChangeBandedRanges(function (prevRanges) {
+            var _a = __read(produceWithPatches(prevRanges, function (draft) {
+                return draft === null || draft === void 0 ? void 0 : draft.filter(function (band) { return band.bandedRangeId !== bandedRange.bandedRangeId; });
+            }), 1), nextState = _a[0];
+            return nextState;
+        });
+        onCommand === null || onCommand === void 0 ? void 0 : onCommand({ command: "remove-banded-range", sheetId: sheetId, bandedRange: bandedRange });
+    }, [onChangeBandedRanges, onCommand]);
+    return {
+        onAddBandedRange: onAddBandedRange,
+        onRemoveBandedRange: onRemoveBandedRange,
+    };
+};

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

@@ -0,0 +1,14 @@
+import type { CellCoordinate } from "@rowsncolumns/dag";
+import type { CellData } from "@rowsncolumns/spreadsheet";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+type UseOnCalculationBeginProps<T extends CellData> = {
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    getDataValidationById?: ReturnType<typeof useSheetProperties>["getDataValidationById"];
+    onChangeSheetData: UseSpreadsheetProps<T>["onChangeSheetData"];
+};
+export declare const useOnCalculationBegin: <T extends CellData>({ locale, cellXfsRegistry, getDataValidationById, onChangeSheetData, }: UseOnCalculationBeginProps<T>) => (positions: CellCoordinate[]) => void;
+export {};
+//# sourceMappingURL=use-on-calculation-begin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-calculation-begin.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-calculation-begin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAM1D,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;AAEnE,KAAK,0BAA0B,CAAC,CAAC,SAAS,QAAQ,IAAI;IACpD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,qBAAqB,CAAC,EAAE,UAAU,CAChC,OAAO,kBAAkB,CAC1B,CAAC,uBAAuB,CAAC,CAAC;IAC3B,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;CAChE,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,wEAKvD,0BAA0B,CAAC,CAAC,CAAC,iBAEhB,cAAc,EAAE,SAwB/B,CAAC"}

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

@@ -0,0 +1,36 @@
+import { __values } from "tslib";
+import { produce } from "immer";
+import { useCallback } from "react";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+export var useOnCalculationBegin = function (_a) {
+    var locale = _a.locale, cellXfsRegistry = _a.cellXfsRegistry, getDataValidationById = _a.getDataValidationById, onChangeSheetData = _a.onChangeSheetData;
+    return useCallback(function (positions) {
+        var sheetCell = new SheetCell();
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            return produce(prevSheetData, function (draft) {
+                var e_1, _a;
+                var _b, _c, _d;
+                try {
+                    for (var positions_1 = __values(positions), positions_1_1 = positions_1.next(); !positions_1_1.done; positions_1_1 = positions_1.next()) {
+                        var _e = positions_1_1.value, rowIndex = _e.rowIndex, columnIndex = _e.columnIndex, sheetId = _e.sheetId;
+                        var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                        sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, (_d = (_c = (_b = draft[sheetId]) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[columnIndex], { locale: locale, cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
+                        if (sheetCell.isFormula()) {
+                            sheetCell.setLoading();
+                            currentSheet[rowIndex].values[columnIndex] =
+                                sheetCell.getCellData({ disableRegistry: true });
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (positions_1_1 && !positions_1_1.done && (_a = positions_1.return)) _a.call(positions_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            });
+        });
+    }, [onChangeSheetData, getDataValidationById, locale, cellXfsRegistry]);
+};