@rowsncolumns/spreadsheet-state 28.0.66

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

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

package/dist/esm/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/esm/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/esm/hooks/use-idle-scheduler.js

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

package/dist/esm/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/esm/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/esm/hooks/use-indent.js

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

package/dist/esm/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/esm/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/esm/hooks/use-named-range.js

@@ -0,0 +1,69 @@
+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 const useNamedRange = ({ namedRanges, getSheetName, }) => {
+    const getSelectionsFromFormula = useGetSelectionsFromFormula();
+    // Build case-insensitive lookup map for O(1) access
+    const namedRangeMap = useMemo(() => {
+        const map = new Map();
+        namedRanges?.forEach((range) => {
+            map.set(range.name.toLowerCase(), range);
+        });
+        return map;
+    }, [namedRanges]);
+    return useCallbackRef(useCallback((variableName) => {
+        // O(1) hash lookup instead of O(n) linear search
+        const namedRange = namedRangeMap.get(variableName.toLowerCase());
+        if (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
+        const result = namedRange?.value;
+        if (!isNil(result)) {
+            const 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.
+            const 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.
+                const selections = getSelectionsFromFormula?.(isFormula ? result : `=${result}`);
+                const firstSel = 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: '${variableName}'.`);
+    }, [namedRangeMap, getSheetName, getSelectionsFromFormula]));
+};

package/dist/esm/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/esm/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/esm/hooks/use-on-adjust-row-height.js

@@ -0,0 +1,63 @@
+import { useGetFinalRowHeight } from "@rowsncolumns/spreadsheet";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { useCanEditCellRange } from "./use-can-edit-cellrange";
+export const useOnAdjustRowHeight = ({ onChangeSheets, }) => {
+    const getFinalRowHeight = useGetFinalRowHeight();
+    const canEditCellRange = useCanEditCellRange();
+    return useCallback((sheetId, rowIndex, columnIndex, value, textFormat, shouldWrap, saveHistory, textFormatRuns) => {
+        if (!canEditCellRange(sheetId, { rowIndex, columnIndex })) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        const dimension = 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?.((prevSheets) => {
+                const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                    const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                    const axis = "x";
+                    if (sheet) {
+                        const metaData = axis === "x" ? "rowMetadata" : "columnMetadata";
+                        if (!sheet[metaData]) {
+                            sheet[metaData] = [];
+                        }
+                        const currentSize = sheet.rowMetadata?.[rowIndex]?.size ?? 0;
+                        const resizedByUser = sheet.rowMetadata?.[rowIndex]?.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,
+                            };
+                        }
+                    }
+                });
+                // Maybe move to use-undo-redo.ts
+                // ? @todo vinay
+                if (patches.length) {
+                    saveHistory({
+                        sheets: { patches, inversePatches },
+                    });
+                }
+                return nextState;
+            });
+        }
+    }, [onChangeSheets, canEditCellRange, getFinalRowHeight]);
+};

package/dist/esm/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/esm/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/esm/hooks/use-on-autoresize.js

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

package/dist/esm/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/esm/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/esm/hooks/use-on-banded-ranges.js

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

package/dist/esm/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/esm/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/esm/hooks/use-on-calculation-begin.js

@@ -0,0 +1,22 @@
+import { produce } from "immer";
+import { useCallback } from "react";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+export const useOnCalculationBegin = ({ locale, cellXfsRegistry, getDataValidationById, onChangeSheetData, }) => {
+    return useCallback((positions) => {
+        const sheetCell = new SheetCell();
+        onChangeSheetData?.((prevSheetData) => {
+            return produce(prevSheetData, (draft) => {
+                for (const { rowIndex, columnIndex, sheetId } of positions) {
+                    const currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                    sheetCell.assign(sheetId, { rowIndex, columnIndex }, draft[sheetId]?.[rowIndex]?.values?.[columnIndex], { locale, cellXfsRegistry, getDataValidationById });
+                    if (sheetCell.isFormula()) {
+                        sheetCell.setLoading();
+                        currentSheet[rowIndex].values[columnIndex] =
+                            sheetCell.getCellData({ disableRegistry: true });
+                    }
+                }
+            });
+        });
+    }, [onChangeSheetData, getDataValidationById, locale, cellXfsRegistry]);
+};

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