@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/hooks/use-on-protect-range.d.ts

@@ -0,0 +1,20 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnProtectRangeProps<T extends CellData, S extends Sheet> = {
+    /**
+     * Id creation strategy
+     */
+    idCreationStrategy?: UseSpreadsheetProps["idCreationStrategy"];
+    onChangeProtectedRanges: UseSpreadsheetProps<T, S>["onChangeProtectedRanges"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onCommand?: OnCommand;
+};
+export declare const useOnProtectRange: <T extends CellData, S extends Sheet>({ idCreationStrategy, createHistory, onChangeProtectedRanges, onCommand, }: UseOnProtectRangeProps<T, S>) => {
+    onProtectRange: (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[] | undefined) => void;
+    onUnProtectRange: (sheetId: number, protectedRangeId: number | string) => void;
+};
+export {};
+//# sourceMappingURL=use-on-protect-range.d.ts.map

package/dist/esm/hooks/use-on-protect-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-protect-range.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-protect-range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE/E,OAAO,KAAK,EACV,QAAQ,EACR,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AAMnC,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;;OAEG;IACH,kBAAkB,CAAC,EAAE,mBAAmB,CAAC,oBAAoB,CAAC,CAAC;IAC/D,uBAAuB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC;IAC9E,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,4EAKpE,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC;8BAGhB,MAAM,cACH,aAAa,cACb,aAAa,CAAC,mBAAmB,CAAC,EAAE,GAAG,SAAS;gCAqDpD,MAAM,oBAAoB,MAAM,GAAG,MAAM;CAqCtD,CAAC"}

package/dist/esm/hooks/use-on-protect-range.js

@@ -0,0 +1,67 @@
+import { selectionFromActiveCell } from "@rowsncolumns/grid";
+import { isProtectedRange } from "@rowsncolumns/spreadsheet";
+import { uuid } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+export const useOnProtectRange = ({ idCreationStrategy, createHistory, onChangeProtectedRanges, onCommand, }) => {
+    const onProtectRange = useCallback((sheetId, activeCell, selections) => {
+        const saveHistory = createHistory();
+        // Update sheets
+        onChangeProtectedRanges?.((prevRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevRanges, (draft) => {
+                const selection = selections?.length
+                    ? selections[0]
+                    : selectionFromActiveCell(activeCell)[0];
+                const isProtected = isProtectedRange(sheetId, selection.range, draft);
+                if (isProtected) {
+                    return;
+                }
+                draft.push({
+                    protectedRangeId: idCreationStrategy?.("protected-range") ?? uuid(),
+                    range: {
+                        ...selection.range,
+                        sheetId,
+                    },
+                });
+            });
+            // Save history
+            saveHistory({
+                protectedRanges: { patches, inversePatches },
+                selections: { undo: selections, redo: selections },
+                activeCell: { undo: activeCell, redo: activeCell },
+            });
+            return nextState;
+        });
+        onCommand?.({
+            command: "protect-range",
+            sheetId,
+            activeCell,
+            selections,
+        });
+    }, [idCreationStrategy, createHistory, onChangeProtectedRanges, onCommand]);
+    const onUnProtectRange = useCallback((sheetId, protectedRangeId) => {
+        const saveHistory = createHistory();
+        // Update sheets
+        onChangeProtectedRanges?.((prevRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevRanges, (draft) => {
+                if (draft) {
+                    return draft.filter((item) => item.protectedRangeId !== protectedRangeId);
+                }
+            });
+            // Save history
+            saveHistory({
+                protectedRanges: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        onCommand?.({
+            command: "unprotect-range",
+            sheetId,
+            protectedRangeId,
+        });
+    }, [createHistory, onChangeProtectedRanges, onCommand]);
+    return {
+        onProtectRange,
+        onUnProtectRange,
+    };
+};

package/dist/esm/hooks/use-on-protect-sheet.d.ts

@@ -0,0 +1,19 @@
+import type { 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 UseOnProtectSheetProps<T extends CellData, S extends Sheet> = {
+    /**
+     * Id creation strategy
+     */
+    idCreationStrategy?: UseSpreadsheetProps["idCreationStrategy"];
+    onChangeProtectedRanges: UseSpreadsheetProps<T, S>["onChangeProtectedRanges"];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onCommand?: OnCommand;
+};
+export declare const useOnProtectSheet: <T extends CellData, S extends Sheet>({ idCreationStrategy, onChangeProtectedRanges, createHistory, onCommand, }: UseOnProtectSheetProps<T, S>) => {
+    onProtectSheet: (sheetId: number) => void;
+    onUnProtectSheet: (sheetId: number) => void;
+};
+export {};
+//# sourceMappingURL=use-on-protect-sheet.d.ts.map

package/dist/esm/hooks/use-on-protect-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-protect-sheet.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-protect-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAMjE,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;;OAEG;IACH,kBAAkB,CAAC,EAAE,mBAAmB,CAAC,oBAAoB,CAAC,CAAC;IAC/D,uBAAuB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC;IAC9E,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,4EAKpE,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC;8BAGjB,MAAM;gCAoCN,MAAM;CAwCnB,CAAC"}

package/dist/esm/hooks/use-on-protect-sheet.js

@@ -0,0 +1,61 @@
+import { isProtectedSheet } from "@rowsncolumns/spreadsheet";
+import { uuid } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+export const useOnProtectSheet = ({ idCreationStrategy, onChangeProtectedRanges, createHistory, onCommand, }) => {
+    // Protect
+    const onProtectSheet = useCallback((sheetId) => {
+        const saveHistory = createHistory();
+        onChangeProtectedRanges?.((prevRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevRanges, (draft) => {
+                const isProtected = isProtectedSheet(sheetId, draft);
+                if (isProtected) {
+                    return;
+                }
+                draft.push({
+                    protectedRangeId: idCreationStrategy?.("protected-range") ?? uuid(),
+                    range: {
+                        sheetId,
+                    },
+                });
+            });
+            // Save history
+            saveHistory({
+                protectedRanges: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        onCommand?.({ command: "protect-sheet", sheetId });
+    }, [idCreationStrategy, onChangeProtectedRanges, createHistory, onCommand]);
+    // Un protect
+    const onUnProtectSheet = useCallback((sheetId) => {
+        const saveHistory = createHistory();
+        onChangeProtectedRanges?.((prevRanges) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevRanges, (draft) => {
+                const isProtected = isProtectedSheet(sheetId, draft ?? []);
+                if (isProtected) {
+                    return draft?.filter(({ range }) => {
+                        const rangeExists = range.startRowIndex &&
+                            range.endRowIndex &&
+                            range.startColumnIndex &&
+                            range.endColumnIndex;
+                        if (rangeExists) {
+                            return true;
+                        }
+                        return range.sheetId !== sheetId;
+                    });
+                }
+            });
+            // Save history
+            saveHistory({
+                protectedRanges: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        onCommand?.({ command: "unprotect-sheet", sheetId });
+    }, [createHistory, onChangeProtectedRanges, onCommand]);
+    return {
+        onProtectSheet,
+        onUnProtectSheet,
+    };
+};

package/dist/esm/hooks/use-on-remove-duplicates.d.ts

@@ -0,0 +1,21 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { CellData, SelectionAttributes, Sheet } from "@rowsncolumns/spreadsheet";
+import type { useCalculation } from "./use-calculation";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+import type { OnCommand } from "../commands";
+import { CellXfsRegistry } from "./use-cellxfs-registry";
+import { SharedStringRegistry } from "./use-ss-registry";
+export type UseOnRemoveDuplicatesProps<T extends CellData> = {
+    locale?: string;
+    cellXfsRegistry?: CellXfsRegistry;
+    sharedStringRegistry?: SharedStringRegistry;
+    getFormattedValue: ReturnType<typeof useSheetProperties>["getFormattedValue"];
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    onChangeSheetData: UseSpreadsheetProps<T, Sheet>["onChangeSheetData"];
+    onCommand?: OnCommand;
+};
+export declare const useOnRemoveDuplicates: <T extends CellData>({ locale, cellXfsRegistry, sharedStringRegistry, getFormattedValue, onChangeSheetData, enqueueCalculation, createHistory, onCommand, }: UseOnRemoveDuplicatesProps<T>) => (sheetId: number, activeCell: CellInterface, selections?: SelectionArea<SelectionAttributes>[]) => import("../interface/remove-duplicates").RemoveDuplicatesResult | undefined;
+//# sourceMappingURL=use-on-remove-duplicates.d.ts.map

package/dist/esm/hooks/use-on-remove-duplicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-remove-duplicates.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-remove-duplicates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,KAAK,EACV,QAAQ,EACR,mBAAmB,EACnB,KAAK,EACN,MAAM,2BAA2B,CAAC;AAKnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,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;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,QAAQ,IAAI;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,iBAAiB,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAC9E,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,mBAAmB,CAAC,CAAC;IACtE,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,wIASvD,0BAA0B,CAAC,CAAC,CAAC,eAKjB,MAAM,cACH,aAAa,eACZ,aAAa,CAAC,mBAAmB,CAAC,EAAE,gFAyCtD,CAAC"}

package/dist/esm/hooks/use-on-remove-duplicates.js

@@ -0,0 +1,39 @@
+import { useCallback } from "react";
+import { removeDuplicates } from "../interface/remove-duplicates";
+import { useCanEditCellRange } from "./use-can-edit-cellrange";
+export const useOnRemoveDuplicates = ({ locale, cellXfsRegistry, sharedStringRegistry, getFormattedValue, onChangeSheetData, enqueueCalculation, createHistory, onCommand, }) => {
+    const canEditCellRange = useCanEditCellRange();
+    return useCallback((sheetId, activeCell, selections) => {
+        if (!canEditCellRange(sheetId, activeCell)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        const result = removeDuplicates({
+            locale,
+            cellXfsRegistry,
+            sharedStringRegistry,
+            getFormattedValue,
+            onChangeSheetData,
+            enqueueCalculation,
+            createHistory,
+        })(sheetId, activeCell, selections);
+        // Stream the semantic command so an engine consumer recomputes from the deduped cells.
+        onCommand?.({
+            command: "remove-duplicates",
+            sheetId,
+            activeCell,
+            selections: selections ?? [],
+        });
+        return result;
+    }, [
+        locale,
+        cellXfsRegistry,
+        sharedStringRegistry,
+        getFormattedValue,
+        onChangeSheetData,
+        enqueueCalculation,
+        createHistory,
+        onCommand,
+        canEditCellRange,
+    ]);
+};

package/dist/esm/hooks/use-on-rename-sheet.d.ts

@@ -0,0 +1,21 @@
+import type { CellInterface } from "@rowsncolumns/common-types";
+import type { CellCoordinate, CellNode, CellRangeNode } from "@rowsncolumns/dag";
+import { StaticNode } from "@rowsncolumns/dag";
+import { type CellData, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { OnCommand } from "../commands";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseOnRenameSheetProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeSheets: UseSpreadsheetProps<T, S>["onChangeSheets"];
+    onChangeActiveCell(sheetId: number, cell: CellInterface): void;
+    getActiveCell(): CellInterface;
+    getGraphNodes(): Map<string, CellNode | CellRangeNode | StaticNode>;
+    getPrecedents(source: CellCoordinate): (CellNode | CellRangeNode | StaticNode)[];
+    createHistory(): (patches: SpreadsheetPatch) => void;
+    onCommand?: OnCommand;
+};
+export declare const useOnRenameSheet: <T extends CellData, S extends Sheet>({ locale, onChangeSheetData, onChangeSheets, onChangeActiveCell, getActiveCell, getGraphNodes, getPrecedents, createHistory, onCommand, }: UseOnRenameSheetProps<T, S>) => (sheetId: number, name: string, oldName: string) => void;
+export {};
+//# sourceMappingURL=use-on-rename-sheet.d.ts.map

package/dist/esm/hooks/use-on-rename-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-rename-sheet.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-rename-sheet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EACV,cAAc,EACd,QAAQ,EACR,aAAa,EACd,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAKtE,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,KAAK,qBAAqB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAChE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,cAAc,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC5D,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAAC;IAC/D,aAAa,IAAI,aAAa,CAAC;IAC/B,aAAa,IAAI,GAAG,CAAC,MAAM,EAAE,QAAQ,GAAG,aAAa,GAAG,UAAU,CAAC,CAAC;IACpE,aAAa,CACX,MAAM,EAAE,cAAc,GACrB,CAAC,QAAQ,GAAG,aAAa,GAAG,UAAU,CAAC,EAAE,CAAC;IAC7C,aAAa,IAAI,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,2IAUnE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,eAIhB,MAAM,QAAQ,MAAM,WAAW,MAAM,SAyFlD,CAAC"}

package/dist/esm/hooks/use-on-rename-sheet.js

@@ -0,0 +1,78 @@
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { updateFormulaSheetReferences } from "../api/rename-sheet";
+import { truncateSheetTitle } from "../helpers/sheet-title";
+import { useCanEditSheet, useCanEditWorkbook } from "./use-can-edit-cellrange";
+export const useOnRenameSheet = ({ locale, onChangeSheetData, onChangeSheets, onChangeActiveCell, getActiveCell, getGraphNodes, getPrecedents, createHistory, onCommand, }) => {
+    const canEditSheet = useCanEditSheet();
+    const canEditWorkbook = useCanEditWorkbook();
+    return useCallback((sheetId, name, oldName) => {
+        // Worksheet names cannot be empty or whitespace-only
+        if (name.trim().length === 0) {
+            console.debug("Sheet name cannot be empty.");
+            return;
+        }
+        const truncatedName = truncateSheetTitle(name);
+        if (!canEditWorkbook()) {
+            console.debug("Workbook is structurally protected, cannot rename a sheet.");
+            return;
+        }
+        if (!canEditSheet(sheetId)) {
+            console.debug("This range is protected, users cannot edit this cell range.");
+            return;
+        }
+        const saveHistory = createHistory();
+        // Update sheets
+        onChangeSheets((prevSheets) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheets, (draft) => {
+                const sheet = draft.find((sheet) => sheet.sheetId === sheetId);
+                if (sheet) {
+                    sheet.title = truncatedName;
+                }
+            });
+            // Save sheets history
+            saveHistory({
+                sheets: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Update all formula references
+        onChangeSheetData?.((prevSheetData) => {
+            const [nextState, patches, inversePatches] = produceWithPatches(prevSheetData, (draft) => {
+                updateFormulaSheetReferences(draft, {
+                    sheetId,
+                    oldName,
+                    newName: truncatedName,
+                    locale,
+                    getGraphNodes,
+                    getPrecedents,
+                });
+            });
+            // Save sheet data
+            saveHistory({
+                sheetData: { patches, inversePatches },
+            });
+            return nextState;
+        });
+        // Trigger active cell change
+        onChangeActiveCell(sheetId, { ...getActiveCell() });
+        onCommand?.({
+            command: "rename-sheet",
+            sheetId,
+            name: truncatedName,
+            oldName,
+        });
+    }, [
+        locale,
+        onChangeActiveCell,
+        onChangeSheetData,
+        onChangeSheets,
+        getGraphNodes,
+        getPrecedents,
+        getActiveCell,
+        createHistory,
+        canEditSheet,
+        canEditWorkbook,
+        onCommand,
+    ]);
+};

package/dist/esm/hooks/use-on-request-calculate-wrapper.d.ts

@@ -0,0 +1,30 @@
+import type { CellCoordinate, CellNode, CellRangeNode, StaticNode } from "@rowsncolumns/dag";
+import type { CellData } from "@rowsncolumns/spreadsheet";
+import type { CalculationResult, useCalculation } from "./use-calculation";
+import type { CellXfsRegistry } from "./use-cellxfs-registry";
+import type { useSheetProperties } from "./use-sheet-properties";
+import type { SheetData } from "./use-spreadsheet-state";
+type UseOnRequestCalculateWrapperProps<T extends CellData> = {
+    sheetData?: SheetData<T>;
+    locale?: string;
+    onRequestCalculate: ReturnType<typeof useCalculation>["onRequestCalculate"];
+    getPrecedentsFromFormulaString: (value: string, source: CellCoordinate) => (CellNode | CellRangeNode | StaticNode)[];
+    getSheetId: (sheetname: string) => number;
+    cellXfsRegistry?: CellXfsRegistry;
+    getDataValidationById?: ReturnType<typeof useSheetProperties>["getDataValidationById"];
+    /**
+     * Resolves a cell's effective format (user-entered ∪ derived). Used so
+     * the preview can inherit formats through formula chains — e.g.
+     * `N1 = M1 = …` where the dated cell upstream has no persisted format
+     * on the intermediate links.
+     */
+    getEffectiveFormat?: ReturnType<typeof useSheetProperties>["getEffectiveFormat"];
+};
+export declare const useOnRequestCalculateWrapper: <T extends CellData>({ locale, sheetData, onRequestCalculate, getPrecedentsFromFormulaString, getSheetId, cellXfsRegistry, getDataValidationById, getEffectiveFormat, }: UseOnRequestCalculateWrapperProps<T>) => (value: string, sheetId: number, rowIndex: number, columnIndex: number, options?: {
+    isArray?: boolean;
+    disablePreview?: boolean;
+    overrides?: Map<string, CalculationResult | undefined | null>;
+    skipOnDemand?: boolean;
+}) => Promise<string | import("@rowsncolumns/fast-formula-parser").FormulaResultArray | null | undefined>;
+export {};
+//# sourceMappingURL=use-on-request-calculate-wrapper.d.ts.map

package/dist/esm/hooks/use-on-request-calculate-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-request-calculate-wrapper.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-request-calculate-wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,QAAQ,EACR,aAAa,EACb,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAU1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAgBzD,KAAK,iCAAiC,CAAC,CAAC,SAAS,QAAQ,IAAI;IAC3D,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E,8BAA8B,EAAE,CAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,cAAc,KACnB,CAAC,QAAQ,GAAG,aAAa,GAAG,UAAU,CAAC,EAAE,CAAC;IAC/C,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;IAC1C,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,qBAAqB,CAAC,EAAE,UAAU,CAChC,OAAO,kBAAkB,CAC1B,CAAC,uBAAuB,CAAC,CAAC;IAC3B;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,UAAU,CAC7B,OAAO,kBAAkB,CAC1B,CAAC,oBAAoB,CAAC,CAAC;CACzB,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,CAAC,SAAS,QAAQ,EAAE,oJAS9D,iCAAiC,CAAC,CAAC,CAAC,aAK1B,MAAM,WACJ,MAAM,YACL,MAAM,eACH,MAAM,YACT;IACR,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,GAAG,IAAI,CAAC,CAAC;IAC9D,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,wGAoGN,CAAC"}

package/dist/esm/hooks/use-on-request-calculate-wrapper.js

@@ -0,0 +1,88 @@
+import { useTokenizer } from "@rowsncolumns/spreadsheet";
+import { isNil } from "@rowsncolumns/utils";
+import cloneDeep from "lodash/cloneDeep";
+import { useCallback } from "react";
+import { createFormattedValue } from "../api/datatype";
+import { deriveEffectiveNumberFormatFromPrecedents } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+import { FormulaError } from "@rowsncolumns/fast-formula-parser";
+/** Whether a calculation result is a formula error. `instanceof FormulaError` alone is not
+ * reliable: when two copies of `fast-formula-parser` end up in the bundle (the calculator's
+ * instance vs this module's import), the prototype chains differ and `instanceof` is false, so
+ * the error object slipped through and the editor preview rendered `#NAME?` for an in-progress
+ * formula. Duck-type as the fallback: a FormulaError is an `Error` (the GLOBAL Error — shared
+ * across package copies) carrying its `#…` code on the `error` getter. */
+const isFormulaErrorLike = (value) => {
+    if (value instanceof FormulaError)
+        return true;
+    if (!(value instanceof Error))
+        return false;
+    const code = value.error;
+    return typeof code === "string" && code.startsWith("#");
+};
+export const useOnRequestCalculateWrapper = ({ locale, sheetData, onRequestCalculate, getPrecedentsFromFormulaString, getSheetId, cellXfsRegistry, getDataValidationById, getEffectiveFormat, }) => {
+    const tokenizer = useTokenizer();
+    return useCallback(async (value, sheetId, rowIndex, columnIndex, options) => {
+        const sheetCell = new SheetCell();
+        const result = await onRequestCalculate?.(value, sheetId, rowIndex, columnIndex, options);
+        if (isFormulaErrorLike(result)) {
+            return undefined;
+        }
+        // Return early
+        if (isNil(result)) {
+            return result;
+        }
+        if (!Array.isArray(result)) {
+            const cellData = cloneDeep({
+                ...sheetData?.[sheetId]?.[rowIndex]?.values?.[columnIndex],
+            });
+            sheetCell.assign(sheetId, { rowIndex, columnIndex }, cellData, {
+                locale,
+                cellXfsRegistry,
+                getDataValidationById,
+            });
+            // Set effective value of a cell after calculation. This produces an
+            // initial formattedValue based on whatever number format is on the
+            // cell today (uf only — ef is no longer authoritative).
+            const preserveStringLiteral = typeof result === "string";
+            sheetCell.setEffectiveValue(result, true, preserveStringLiteral);
+            // For numeric previews, layer the precedent-derived number format
+            // on top so the editor's preview matches what the cell will show
+            // after the calc commits and the renderer re-derives at paint time.
+            // (deriveEffectiveNumberFormatFromPrecedents already returns
+            // userEnteredFormat.numberFormat early if the user has set one.)
+            if (typeof result === "number") {
+                // Resolver lets the precedent walk see formats that live on
+                // formula-cell precedents (derived, not persisted on `uf`),
+                // so the preview matches what the renderer will show after
+                // commit. Without it, `=M11` where M11 itself derives a date
+                // format would preview as the raw serial number.
+                const resolveNumberFormat = getEffectiveFormat
+                    ? (psId, pr, pc) => getEffectiveFormat(psId, pr, pc)?.numberFormat
+                    : undefined;
+                const derivedNumberFormat = deriveEffectiveNumberFormatFromPrecedents(value, getPrecedentsFromFormulaString(value.slice(1), {
+                    rowIndex,
+                    columnIndex,
+                    sheetId,
+                }), sheetData, tokenizer, sheetId, rowIndex, columnIndex, locale, getSheetId, cellXfsRegistry, getDataValidationById, result, resolveNumberFormat);
+                if (derivedNumberFormat?.pattern) {
+                    return createFormattedValue(result, "numberValue", derivedNumberFormat.pattern, locale);
+                }
+            }
+            return sheetCell.formattedValue;
+        }
+        else {
+            return result;
+        }
+    }, [
+        locale,
+        sheetData,
+        cellXfsRegistry,
+        tokenizer,
+        onRequestCalculate,
+        getSheetId,
+        getPrecedentsFromFormulaString,
+        getDataValidationById,
+        getEffectiveFormat,
+    ]);
+};

package/dist/esm/hooks/use-on-request-conditional-format.d.ts

@@ -0,0 +1,2 @@
+export declare const useOnRequestConditionalFormat: () => () => void;
+//# sourceMappingURL=use-on-request-conditional-format.d.ts.map

package/dist/esm/hooks/use-on-request-conditional-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-request-conditional-format.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-request-conditional-format.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,6BAA6B,kBAKzC,CAAC"}

package/dist/esm/hooks/use-on-request-conditional-format.js

@@ -0,0 +1,8 @@
+import { useCallback } from "react";
+import { useSetConditionalFormatDialogState } from "../atoms/dialog-state.atom";
+export const useOnRequestConditionalFormat = () => {
+    const onOpenChange = useSetConditionalFormatDialogState();
+    return useCallback(() => {
+        onOpenChange(true);
+    }, [onOpenChange]);
+};

package/dist/esm/hooks/use-on-request-data-validation.d.ts

@@ -0,0 +1,7 @@
+import type { useDataValidationRules } from "./use-data-validation-rules";
+type UseOnRequestDataValidationProps = {
+    onCreateDataValidationRule?: ReturnType<typeof useDataValidationRules>["onCreateDataValidationRule"];
+};
+export declare const useOnRequestDataValidation: ({ onCreateDataValidationRule, }: UseOnRequestDataValidationProps) => (sheetId: number, activeCell: import("@rowsncolumns/grid").CellInterface, selections: import("@rowsncolumns/grid").SelectionArea<import("@rowsncolumns/spreadsheet").SelectionAttributes>[], initialDataValidationRule?: import("@rowsncolumns/common-types").DataValidationRuleRecord, showEditUI?: boolean) => void;
+export {};
+//# sourceMappingURL=use-on-request-data-validation.d.ts.map

package/dist/esm/hooks/use-on-request-data-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-request-data-validation.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-request-data-validation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAE1E,KAAK,+BAA+B,GAAG;IACrC,0BAA0B,CAAC,EAAE,UAAU,CACrC,OAAO,sBAAsB,CAC9B,CAAC,4BAA4B,CAAC,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,iCAExC,+BAA+B,0TA4BjC,CAAC"}

package/dist/esm/hooks/use-on-request-data-validation.js

@@ -0,0 +1,21 @@
+import { useCallback } from "react";
+import { useSetDataValidationDialogAState } from "../atoms/dialog-state.atom";
+import { useSetEditingDataValidationId } from "../atoms/editing-data-validation-id.atom";
+export const useOnRequestDataValidation = ({ onCreateDataValidationRule, }) => {
+    const onOpenChange = useSetDataValidationDialogAState();
+    const setEditingDataValidationId = useSetEditingDataValidationId();
+    return useCallback((sheetId, activeCell, selections, initialDataValidationRule, showEditUI = true) => {
+        if (initialDataValidationRule) {
+            // Create a new rule
+            onCreateDataValidationRule?.(initialDataValidationRule);
+        }
+        if (showEditUI) {
+            // Open dialog
+            onOpenChange(true);
+            if (initialDataValidationRule) {
+                // Set editing id
+                setEditingDataValidationId(initialDataValidationRule.id);
+            }
+        }
+    }, [onOpenChange, setEditingDataValidationId, onCreateDataValidationRule]);
+};

package/dist/esm/hooks/use-on-request-define-named-range.d.ts

@@ -0,0 +1,8 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/common-types";
+import type { NamedRange, SelectionAttributes } from "@rowsncolumns/spreadsheet";
+type UseOnRequestDefineNamedRangeProps = {
+    namedRanges?: NamedRange[];
+};
+export declare const useOnRequestDefineNamedRange: ({ namedRanges, }: UseOnRequestDefineNamedRangeProps) => (sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]) => void;
+export {};
+//# sourceMappingURL=use-on-request-define-named-range.d.ts.map

package/dist/esm/hooks/use-on-request-define-named-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-request-define-named-range.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-request-define-named-range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE/E,OAAO,KAAK,EACV,UAAU,EACV,mBAAmB,EACpB,MAAM,2BAA2B,CAAC;AAMnC,KAAK,iCAAiC,GAAG;IACvC,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,kBAE1C,iCAAiC,eAKrB,MAAM,cACH,aAAa,cACb,aAAa,CAAC,mBAAmB,CAAC,EAAE,SAyBrD,CAAC"}

package/dist/esm/hooks/use-on-request-define-named-range.js

@@ -0,0 +1,25 @@
+import { isAreasEqual, selectionFromActiveCell } from "@rowsncolumns/grid";
+import { useCallback } from "react";
+import { useSetEditNamedRangeDialogState } from "../atoms/dialog-state.atom";
+import { useSetEditingNamedRange } from "../atoms/named-range.atom";
+export const useOnRequestDefineNamedRange = ({ namedRanges, }) => {
+    const setEditDialog = useSetEditNamedRangeDialogState();
+    const setEditingNamedRange = useSetEditingNamedRange();
+    return useCallback((sheetId, activeCell, selections) => {
+        const range = selections.length
+            ? selections[0].range
+            : selectionFromActiveCell(activeCell)[0].range;
+        // Check if there is a named range
+        const namedRange = namedRanges?.find((n) => n.range?.sheetId === sheetId && isAreasEqual(n.range, range));
+        setEditingNamedRange({
+            name: "",
+            range: {
+                ...range,
+                sheetId,
+            },
+            namedRangeId: "new",
+            ...namedRange,
+        });
+        setEditDialog(true);
+    }, [setEditDialog, setEditingNamedRange, namedRanges]);
+};

package/dist/esm/hooks/use-on-request-delete-sheet.d.ts

@@ -0,0 +1,2 @@
+export declare const useOnRequestDeleteSheet: () => (sheetId: number) => void;
+//# sourceMappingURL=use-on-request-delete-sheet.d.ts.map

package/dist/esm/hooks/use-on-request-delete-sheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-request-delete-sheet.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-request-delete-sheet.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,uBAAuB,kBAItB,MAAM,SAMnB,CAAC"}

package/dist/esm/hooks/use-on-request-delete-sheet.js

@@ -0,0 +1,11 @@
+import { useCallback } from "react";
+import { useSetDeleteSheetId } from "../atoms/delete-sheet-atom";
+import { useDeletSheetConfirmationDialogState } from "../atoms/dialog-state.atom";
+export const useOnRequestDeleteSheet = () => {
+    const [_, onOpenChange] = useDeletSheetConfirmationDialogState();
+    const setDeleteSheetId = useSetDeleteSheetId();
+    return useCallback((sheetId) => {
+        setDeleteSheetId(sheetId);
+        onOpenChange(true);
+    }, [onOpenChange, setDeleteSheetId]);
+};

package/dist/esm/hooks/use-on-request-edit-table.d.ts

@@ -0,0 +1,3 @@
+import type { TableView } from "@rowsncolumns/spreadsheet";
+export declare const useOnRequestEditTable: () => (table: TableView) => void;
+//# sourceMappingURL=use-on-request-edit-table.d.ts.map

package/dist/esm/hooks/use-on-request-edit-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-request-edit-table.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-request-edit-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAM3D,eAAO,MAAM,qBAAqB,gBAItB,SAAS,SAMpB,CAAC"}

package/dist/esm/hooks/use-on-request-edit-table.js

@@ -0,0 +1,11 @@
+import { useCallback } from "react";
+import { useSetEditTableDialogValue } from "../atoms/dialog-state.atom";
+import { useSetEditingTable } from "../atoms/editing-table.atom";
+export const useOnRequestEditTable = () => {
+    const setEditDialog = useSetEditTableDialogValue();
+    const setEditingTable = useSetEditingTable();
+    return useCallback((table) => {
+        setEditingTable(table);
+        setEditDialog(true);
+    }, [setEditDialog, setEditingTable]);
+};

package/dist/esm/hooks/use-on-request-format-cells.d.ts

@@ -0,0 +1,2 @@
+export declare const useOnRequestFormatCells: () => () => void;
+//# sourceMappingURL=use-on-request-format-cells.d.ts.map

package/dist/esm/hooks/use-on-request-format-cells.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-on-request-format-cells.d.ts","sourceRoot":"","sources":["../../../hooks/use-on-request-format-cells.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,uBAAuB,kBAKnC,CAAC"}

package/dist/esm/hooks/use-on-request-format-cells.js

@@ -0,0 +1,8 @@
+import { useCallback } from "react";
+import { useSetFormatCellsDialogState } from "../atoms/dialog-state.atom";
+export const useOnRequestFormatCells = () => {
+    const onOpenChange = useSetFormatCellsDialogState();
+    return useCallback(() => {
+        onOpenChange(true);
+    }, [onOpenChange]);
+};