@rowsncolumns/spreadsheet 10.2.68

package/dist/esm/hooks/use-context-setter.js

@@ -0,0 +1,128 @@
+import { useImperativeHandle, useMemo } from "react";
+import { useSetSpreadsheetContext } from "../atoms/sheet-context.atom";
+import { useIsomorphicLayoutEffect } from "./use-isomorphic-layout-effect";
+export const useContextSetter = (forwardedRef, contextValue) => {
+    const setSpreadsheetContext = useSetSpreadsheetContext();
+    const { submitEditor, cancelEditor, commit, makeEditable, editCell, getNextFocusableCell, onEditorKeyDown, scrollToCell, scrollToBottom, focusSheet, canEditCell, isSheetProtected, isWorkbookProtected, getSheetProtection, getSelectionsFromFormula, getAddressFromSelection, getR1C1AddressFromSelection, tokenizer, setEditorValue, getCellBounds, getTableNames, getStructuredProperties, getNamedRanges, getTableColumnNames, updateSelectionStartEndReference, getCellDimensions, getRowHeight, getContentfulGridRangeAroundCell, getCellCoordsFromOffset, getCellOffsetFromCoords, getEffectiveValuesFromRange, getSheetDimensions, getFinalRowHeight, getColumnWidth, getSheetId, getSheetName, onInsertNote, onPinToolTip, onUnpinTooltip, showCellPopover, redrawGrid, flash, navigateToSheetRange, mark, unmark, exportRange, getViewPort, setActiveCell, getGridRef, getMentions, dispatchEvent, splitTextToColumns, copy, cut, paste, } = contextValue;
+    // Expose grid methods in context and ref
+    const imperativeHandleRefs = useMemo(() => ({
+        submitEditor,
+        cancelEditor,
+        commit,
+        makeEditable,
+        editCell,
+        getNextFocusableCell,
+        onEditorKeyDown,
+        scrollToCell,
+        scrollToBottom,
+        focusSheet,
+        canEditCell,
+        isSheetProtected,
+        isWorkbookProtected,
+        getSheetProtection,
+        getSelectionsFromFormula,
+        getAddressFromSelection,
+        getR1C1AddressFromSelection,
+        tokenizer,
+        setEditorValue,
+        getCellBounds,
+        getTableNames,
+        getStructuredProperties,
+        getNamedRanges,
+        getTableColumnNames,
+        updateSelectionStartEndReference,
+        getCellDimensions,
+        getRowHeight,
+        getContentfulGridRangeAroundCell,
+        getCellCoordsFromOffset,
+        getCellOffsetFromCoords,
+        getEffectiveValuesFromRange,
+        getSheetDimensions,
+        getFinalRowHeight,
+        getColumnWidth,
+        getSheetId,
+        getSheetName,
+        onInsertNote,
+        onPinToolTip,
+        onUnpinTooltip,
+        showCellPopover,
+        redrawGrid,
+        flash,
+        navigateToSheetRange,
+        mark,
+        unmark,
+        exportRange,
+        getViewPort,
+        setActiveCell,
+        getGridRef,
+        getMentions,
+        dispatchEvent,
+        splitTextToColumns,
+        copy,
+        cut,
+        paste,
+    }), [
+        submitEditor,
+        cancelEditor,
+        commit,
+        makeEditable,
+        editCell,
+        getNextFocusableCell,
+        onEditorKeyDown,
+        scrollToCell,
+        scrollToBottom,
+        focusSheet,
+        canEditCell,
+        isSheetProtected,
+        isWorkbookProtected,
+        getSheetProtection,
+        getSelectionsFromFormula,
+        getAddressFromSelection,
+        getR1C1AddressFromSelection,
+        tokenizer,
+        setEditorValue,
+        getCellBounds,
+        getTableNames,
+        getNamedRanges,
+        getStructuredProperties,
+        getTableColumnNames,
+        updateSelectionStartEndReference,
+        getCellDimensions,
+        getRowHeight,
+        getContentfulGridRangeAroundCell,
+        getCellCoordsFromOffset,
+        getCellOffsetFromCoords,
+        getEffectiveValuesFromRange,
+        getSheetDimensions,
+        getFinalRowHeight,
+        getColumnWidth,
+        getSheetId,
+        getSheetName,
+        onInsertNote,
+        onPinToolTip,
+        onUnpinTooltip,
+        showCellPopover,
+        redrawGrid,
+        flash,
+        navigateToSheetRange,
+        mark,
+        unmark,
+        exportRange,
+        getViewPort,
+        setActiveCell,
+        getGridRef,
+        getMentions,
+        dispatchEvent,
+        splitTextToColumns,
+        copy,
+        cut,
+        paste,
+    ]);
+    // Update sheet context
+    useIsomorphicLayoutEffect(() => {
+        setSpreadsheetContext(imperativeHandleRefs);
+    }, [imperativeHandleRefs]);
+    useImperativeHandle(forwardedRef, () => imperativeHandleRefs, [
+        imperativeHandleRefs,
+    ]);
+};

package/dist/esm/hooks/use-copy-paste-cut.d.ts

@@ -0,0 +1,45 @@
+import type { CellInterface, SelectionArea } from "@rowsncolumns/grid";
+import type { CanvasGridProps } from "../components/canvas-grid/typings";
+export type UseCopyPasteCutProps = {
+    /**
+     * Active sheet Id
+     */
+    sheetId: number;
+    /**
+     * Current activeCell
+     */
+    activeCell: CellInterface;
+    /**
+     * Current sheet selection
+     */
+    selections: SelectionArea[];
+    /**
+     * Programmatically focus the sheet
+     */
+    focusSheet(): void;
+    /**
+     * Callback when user pastes a selection or cell
+     */
+    onPaste: CanvasGridProps["onPaste"];
+    /**
+     * Callback when user copies a selection or cell
+     */
+    onCopy: CanvasGridProps["onCopy"];
+    /**
+     * Callback when user cuts a selection or cell
+     */
+    onCut: CanvasGridProps["onCut"];
+};
+export type PasteSpecialType = "Transposed" | "Formatting" | "Value" | "Formula" | "Link";
+export declare const useCopyPasteCut: ({ selections, activeCell, sheetId, onPaste, onCopy, onCut, focusSheet, }: UseCopyPasteCutProps) => {
+    selections: SelectionArea[];
+    copy: () => void;
+    cut: () => void;
+    paste: (pasteSpecialType?: PasteSpecialType) => Promise<void>;
+    copiedSelections: any[];
+    clearCopiedSelections: () => void;
+    onInternalCopy: (e: ClipboardEvent) => void;
+    onInternalPaste: (e: ClipboardEvent) => void;
+    onInternalCut: (e: ClipboardEvent) => void;
+};
+//# sourceMappingURL=use-copy-paste-cut.d.ts.map

package/dist/esm/hooks/use-copy-paste-cut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-copy-paste-cut.d.ts","sourceRoot":"","sources":["../../../hooks/use-copy-paste-cut.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAWvE,OAAO,KAAK,EACV,eAAe,EAEhB,MAAM,mCAAmC,CAAC;AAK3C,MAAM,MAAM,oBAAoB,GAAG;IACjC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,UAAU,EAAE,aAAa,CAAC;IAC1B;;OAEG;IACH,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B;;OAEG;IACH,UAAU,IAAI,IAAI,CAAC;IACnB;;OAEG;IACH,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,CAAC;IACpC;;OAEG;IACH,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;IAClC;;OAEG;IACH,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GACxB,YAAY,GACZ,YAAY,GACZ,OAAO,GACP,SAAS,GACT,MAAM,CAAC;AAEX,eAAO,MAAM,eAAe,GAAI,0EAQ7B,oBAAoB;;;;+BA6QO,gBAAgB;;;wBArKtC,cAAc;yBAkDd,cAAc;uBAvBd,cAAc;CAoMrB,CAAC"}

package/dist/esm/hooks/use-copy-paste-cut.js

@@ -0,0 +1,253 @@
+import { canUseDOM } from "@rowsncolumns/grid";
+import { useCallback, useRef, useState } from "react";
+import { createSelectionFromCell } from "../api/copy-paste";
+import { isSelectionACell } from "../api/selections";
+import { useCellEditorInstance, useGetCellBounds, useSetShowPasteMenu, } from "../atoms";
+import { DEFAULT_ARRAY } from "../config";
+import { useCallbackRef } from "./use-callback-ref";
+import { useIsomorphicLayoutEffect } from "./use-isomorphic-layout-effect";
+export const useCopyPasteCut = ({ selections, activeCell, sheetId, onPaste, onCopy, onCut, focusSheet, }) => {
+    const cellEditorInstance = useCellEditorInstance();
+    const getCellBounds = useGetCellBounds();
+    const [copiedSelections, setCopiedSelections] = useState(DEFAULT_ARRAY);
+    // SheetId of the copied selection
+    const copiedSheetIdRef = useRef(undefined);
+    const getActiveSheetId = useCallbackRef(() => sheetId);
+    // Create a flag, so that we can delete cut selections after a paste
+    const isCutOperation = useRef(false);
+    // Saved copied selection state to show dashed borders. Cleared everytime user does `Paste`
+    const copiedSelectionRef = useRef(undefined);
+    // Saves copied selection, Only clears when user does `Cut/Paste`
+    const initialCopiedSelectionRef = useRef(undefined);
+    const onCopyRef = useCallbackRef(onCopy);
+    const onCutRef = useCallbackRef(onCut);
+    const onPasteRef = useCallbackRef(onPaste);
+    const activeCellRef = useRef(undefined);
+    const selectionsRef = useRef(undefined);
+    const lastPasteModifiersRef = useRef(null);
+    // Set paste menu
+    const setShowPasteMenu = useSetShowPasteMenu();
+    const getSelectionsFromCells = useCallback((activeCell, selections) => {
+        const lastSelection = selections[selections.length - 1];
+        if (!lastSelection) {
+            const range = getCellBounds?.(activeCell);
+            if (range) {
+                return [{ range }];
+            }
+        }
+        return [lastSelection];
+    }, [getCellBounds]);
+    // Get selections from activecell and selections
+    const getSelections = useCallbackRef(useCallback(() => {
+        return getSelectionsFromCells(activeCell, selections);
+    }, [activeCell, selections, getSelectionsFromCells]));
+    //* Keep a ref to avoid closures
+    useIsomorphicLayoutEffect(() => {
+        copiedSelectionRef.current = copiedSelections;
+    }, [copiedSelections]);
+    //* Keep a ref to avoid closures
+    useIsomorphicLayoutEffect(() => {
+        activeCellRef.current = activeCell;
+    }, [activeCell]);
+    //* Keep a ref to avoid closures
+    useIsomorphicLayoutEffect(() => {
+        selectionsRef.current = selections;
+    }, [selections]);
+    useIsomorphicLayoutEffect(() => {
+        if (!canUseDOM) {
+            return;
+        }
+        const handleKeyDown = (e) => {
+            if (!e.key || e.key.toLowerCase() !== "v") {
+                return;
+            }
+            if (!e.metaKey && !e.ctrlKey) {
+                return;
+            }
+            lastPasteModifiersRef.current = {
+                shiftKey: e.shiftKey,
+                metaKey: e.metaKey,
+                ctrlKey: e.ctrlKey,
+                time: Date.now(),
+            };
+        };
+        document.addEventListener("keydown", handleKeyDown);
+        return () => document.removeEventListener("keydown", handleKeyDown);
+    }, []);
+    // Clear selections in clipboard
+    const clearCopiedSelections = useCallback(() => {
+        // User has not copied any selections yet
+        if (!copiedSelectionRef.current?.length) {
+            return;
+        }
+        setCopiedSelections(DEFAULT_ARRAY);
+    }, []);
+    // Copy current selection
+    const handleCopy = useCallback((e) => {
+        // Prevent the default behavior.
+        e.preventDefault();
+        // Get current selections
+        const currentSelections = getSelections();
+        if (currentSelections) {
+            // Set copied sheetId
+            copiedSheetIdRef.current = getActiveSheetId();
+            // Update state, so we can highlight it in the grid
+            setCopiedSelections(currentSelections);
+            // Set initial copied selections
+            // So users can paste selection multiple times
+            initialCopiedSelectionRef.current = currentSelections;
+            // Callback
+            onCopyRef?.(e, sheetId, currentSelections);
+        }
+    }, [onCopyRef, getSelections, getActiveSheetId, sheetId]);
+    // Cut operation
+    const handleCut = useCallback((e) => {
+        // Prevent the default behavior.
+        e.preventDefault();
+        isCutOperation.current = true;
+        // Copy the selections
+        handleCopy(e);
+        // Oncut
+        onCutRef?.(e, sheetId);
+    }, [handleCopy, onCutRef, sheetId]);
+    /**
+     * Paste handler
+     * 1. If user has made any selections
+     *  => Paste should only copy cells this selection and ignore original selection
+     * 2. If user only have activeCell and no selections
+     *  => Move original selection to activeCell
+     */
+    const handlePaste = useCallback((e) => {
+        // Prevent the default behavior.
+        e.preventDefault();
+        if (activeCellRef.current) {
+            /* Get current selections */
+            const currentSelections = selectionsRef.current;
+            const selectables = currentSelections?.length
+                ? currentSelections
+                : createSelectionFromCell(activeCellRef.current, initialCopiedSelectionRef.current);
+            const finalSelections = isSelectionACell(selectables)
+                ? undefined
+                : selectables;
+            // Active sheet id
+            const sourceSheetId = copiedSheetIdRef.current;
+            const destinationSheetId = sheetId;
+            /* Callback */
+            const recentModifiers = lastPasteModifiersRef.current;
+            const withinWindow = recentModifiers && Date.now() - recentModifiers.time < 1000;
+            const shouldForcePlainText = Boolean(withinWindow &&
+                recentModifiers?.shiftKey &&
+                (recentModifiers?.metaKey || recentModifiers?.ctrlKey));
+            lastPasteModifiersRef.current = null;
+            if (shouldForcePlainText) {
+                e.__forcePlainText =
+                    true;
+            }
+            onPasteRef?.(e, sourceSheetId, destinationSheetId, initialCopiedSelectionRef.current, activeCellRef.current, currentSelections, finalSelections, isCutOperation.current);
+            // Show paste menu
+            setShowPasteMenu(true);
+            /* Clear copied selections */
+            clearCopiedSelections();
+            /* Remove all clipboard data */
+            if (isCutOperation.current) {
+                // Remove copied selections
+                initialCopiedSelectionRef.current = undefined;
+            }
+        }
+        /* Reset delete flag */
+        isCutOperation.current = false;
+    }, [
+        isCutOperation,
+        clearCopiedSelections,
+        onPasteRef,
+        sheetId,
+        setShowPasteMenu,
+    ]);
+    // From contextmenu
+    const copy = useCallback(() => {
+        const editorEl = cellEditorInstance?.el?.();
+        if (editorEl && canUseDOM) {
+            // @todo Vinay
+            // Find a cross browser solution without using execCommand
+            document.execCommand("copy");
+            // editorEl.dispatchEvent(
+            //   new ClipboardEvent("copy", {
+            //     bubbles: true,
+            //     cancelable: true,
+            //     clipboardData: new DataTransfer(),
+            //   })
+            // );
+        }
+        // Focus sheet
+        focusSheet();
+    }, [cellEditorInstance, focusSheet]);
+    // From contextmenu
+    const cut = useCallback(() => {
+        const editorEl = cellEditorInstance?.el?.();
+        if (editorEl && canUseDOM) {
+            // @todo Vinay
+            // Find a cross browser solution without using execCommand
+            document.execCommand("cut");
+            // editorEl.dispatchEvent(
+            //   new ClipboardEvent("cut", {
+            //     bubbles: true,
+            //     cancelable: true,
+            //     clipboardData: new DataTransfer(),
+            //   })
+            // );
+        }
+        // Focus sheet
+        focusSheet();
+    }, [cellEditorInstance, focusSheet]);
+    // From contextmenu
+    const paste = useCallback(async (pasteSpecialType) => {
+        async function getClipboardContents() {
+            try {
+                // We are listening to paste event
+                const editorEl = cellEditorInstance?.el?.();
+                // Focus editor
+                cellEditorInstance?.focus();
+                const dataTransfer = new DataTransfer();
+                const evt = new ClipboardEvent("paste", {
+                    clipboardData: dataTransfer,
+                    bubbles: true,
+                    cancelable: true,
+                });
+                const clipboardItems = await navigator.clipboard.read();
+                for (const clipboardItem of clipboardItems) {
+                    for (const type of clipboardItem.types) {
+                        const blob = await clipboardItem.getType(type);
+                        const text = await blob.text();
+                        evt.clipboardData?.setData(type, text);
+                    }
+                }
+                if (pasteSpecialType) {
+                    evt.clipboardData?.setData("pasteSpecialType", pasteSpecialType);
+                }
+                if (editorEl) {
+                    editorEl.dispatchEvent(evt);
+                }
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
+        // Dispatch a paste event in document
+        if (canUseDOM) {
+            await getClipboardContents();
+        }
+        // Focus sheet
+        focusSheet();
+    }, [cellEditorInstance, focusSheet]);
+    return {
+        selections,
+        copy,
+        cut,
+        paste,
+        copiedSelections: copiedSheetIdRef.current === sheetId ? copiedSelections : DEFAULT_ARRAY,
+        clearCopiedSelections,
+        onInternalCopy: handleCopy,
+        onInternalPaste: handlePaste,
+        onInternalCut: handleCut,
+    };
+};

package/dist/esm/hooks/use-create-address-from-selection.d.ts

@@ -0,0 +1,15 @@
+import type { GridRange, SelectionArea } from "@rowsncolumns/grid";
+import type { SelectionAttributes } from "../components/canvas-grid/typings";
+import type { NamedRange, TableView } from "../types";
+type UseCreateAddressFromSelectionProps = {
+    sheetId: number;
+    tables?: TableView[];
+    namedRanges?: NamedRange[];
+    namedRangeMap?: Map<string, NamedRange>;
+    rowCount: number;
+    columnCount: number;
+    merges?: GridRange[] | null;
+};
+export declare const useCreateAddressFromSelection: ({ sheetId, namedRanges, namedRangeMap: externalNamedRangeMap, tables, rowCount, columnCount, merges, }: UseCreateAddressFromSelectionProps) => readonly [(selection: SelectionArea<SelectionAttributes>, currentSheetName?: string | undefined, activeCellCoordinate?: import("@rowsncolumns/common-types").SheetCoordinate | undefined) => string | undefined, (range: GridRange, sheetName?: string) => string];
+export {};
+//# sourceMappingURL=use-create-address-from-selection.d.ts.map

package/dist/esm/hooks/use-create-address-from-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-create-address-from-selection.d.ts","sourceRoot":"","sources":["../../../hooks/use-create-address-from-selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AASnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAGtD,KAAK,kCAAkC,GAAG;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,eAAO,MAAM,6BAA6B,GAAI,wGAQ3C,kCAAkC,2BA4BlB,aAAa,CAAC,mBAAmB,CAAC,qBAC1B,MAAM,GAAG,SAAS,0HAgE/B,SAAS,cAAc,MAAM,YAiB1C,CAAC"}

package/dist/esm/hooks/use-create-address-from-selection.js

@@ -0,0 +1,69 @@
+import { useCallback, useMemo } from "react";
+import { getTableFromSelection, selectionToTableAddress, } from "../api/selections";
+import { selectionToAddress } from "@rowsncolumns/utils";
+import { useEditingCellCoordinate, useGetSheetName } from "../atoms";
+import { useCallbackRef } from "./use-callback-ref";
+export const useCreateAddressFromSelection = ({ sheetId, namedRanges, namedRangeMap: externalNamedRangeMap, tables, rowCount, columnCount, merges, }) => {
+    const getSheetName = useGetSheetName();
+    const editingCellCoordinate = useEditingCellCoordinate();
+    // Build reverse lookup: serialize range → named range for O(1) access
+    // Only build if not using external map
+    const namedRangesByRange = useMemo(() => {
+        const map = new Map();
+        namedRanges?.forEach((namedRange) => {
+            if (namedRange.range && namedRange.range.sheetId === sheetId) {
+                // Create a unique key from the range coordinates
+                const key = selectionToAddress({ range: namedRange.range }, getSheetName?.(sheetId));
+                if (key) {
+                    map.set(key, namedRange);
+                }
+            }
+        });
+        return map;
+    }, [namedRanges, sheetId, getSheetName]);
+    // Get address from selection
+    // Named ranges and tables will be applied
+    const getAddressFromSelection = useCallbackRef(useCallback((selection, currentSheetName, activeCellCoordinate = editingCellCoordinate) => {
+        const editingSheetName = activeCellCoordinate
+            ? getSheetName?.(activeCellCoordinate.sheetId)
+            : currentSheetName;
+        const addressSheetName = 
+        // If editingCell does not exist, it means user is using
+        // an external cell input to get selections from the sheet
+        activeCellCoordinate && editingSheetName === currentSheetName
+            ? undefined
+            : currentSheetName;
+        /**
+         * Check if user has selected a table cell
+         */
+        const table = activeCellCoordinate
+            ? getTableFromSelection(tables, activeCellCoordinate, selection, addressSheetName ?? editingSheetName, getSheetName)
+            : undefined;
+        // Check if there is a named range - O(1) lookup using serialized range key
+        const rangeKey = selectionToAddress({ range: selection.range }, selection.sheetName);
+        const namedRange = rangeKey
+            ? namedRangesByRange.get(rangeKey)
+            : undefined;
+        const address = table
+            ? selectionToTableAddress(selection, table, activeCellCoordinate)
+            : namedRange
+                ? namedRange.name
+                : selectionToAddress(selection, addressSheetName, merges, rowCount, columnCount);
+        return address;
+    }, [
+        getSheetName,
+        editingCellCoordinate,
+        sheetId,
+        tables,
+        namedRanges,
+        rowCount,
+        columnCount,
+        merges,
+    ]));
+    // R1C1 notation
+    const getR1C1AddressFromSelection = useCallbackRef(useCallback((range, sheetName) => {
+        return (`=` +
+            selectionToAddress({ range }, sheetName, merges, rowCount, columnCount));
+    }, [rowCount, columnCount, merges]));
+    return [getAddressFromSelection, getR1C1AddressFromSelection];
+};

package/dist/esm/hooks/use-create-formula-tokenizer.d.ts

@@ -0,0 +1,15 @@
+import type { CellInterface } from "@rowsncolumns/grid";
+import type { CanvasGridProps, GetSelectionFromNamedRange } from "../components/canvas-grid/typings";
+import type { SheetCoordinate } from "../types";
+import type { useOnStructuredReferenceSelection } from "./use-structured-reference-selection";
+type UseTokenizerProps = {
+    getSelectionFromNamedRange: GetSelectionFromNamedRange;
+    getSelectionFromTable: ReturnType<typeof useOnStructuredReferenceSelection>;
+    tokenizer: CanvasGridProps["tokenizer"];
+    editingCellCoordinate?: SheetCoordinate;
+    sheetId: number;
+    activeCell: CellInterface;
+};
+export declare const useCreateFormulaTokenizer: ({ getSelectionFromNamedRange, getSelectionFromTable, tokenizer, editingCellCoordinate, sheetId, activeCell, }: UseTokenizerProps) => (value: string) => import("../types").ParsedToken[];
+export {};
+//# sourceMappingURL=use-create-formula-tokenizer.d.ts.map

package/dist/esm/hooks/use-create-formula-tokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-create-formula-tokenizer.d.ts","sourceRoot":"","sources":["../../../hooks/use-create-formula-tokenizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,KAAK,EACV,eAAe,EACf,0BAA0B,EAC3B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,sCAAsC,CAAC;AAE9F,KAAK,iBAAiB,GAAG;IACvB,0BAA0B,EAAE,0BAA0B,CAAC;IACvD,qBAAqB,EAAE,UAAU,CAAC,OAAO,iCAAiC,CAAC,CAAC;IAC5E,SAAS,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC;IACxC,qBAAqB,CAAC,EAAE,eAAe,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,aAAa,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAI,+GAOvC,iBAAiB,aAON,MAAM,qCAkDnB,CAAC"}

package/dist/esm/hooks/use-create-formula-tokenizer.js

@@ -0,0 +1,48 @@
+import { useCallback } from "react";
+import { useCallbackRef } from "./use-callback-ref";
+export const useCreateFormulaTokenizer = ({ getSelectionFromNamedRange, getSelectionFromTable, tokenizer, editingCellCoordinate, sheetId, activeCell, }) => {
+    const editingSheetId = editingCellCoordinate?.sheetId ?? sheetId;
+    const editingCell = editingCellCoordinate
+        ? editingCellCoordinate
+        : activeCell;
+    return useCallbackRef(useCallback((value) => {
+        const tokens = tokenizer?.(value) ?? [];
+        let index = -1;
+        for (const token of tokens) {
+            if (token.selection) {
+                token["index"] = ++index;
+            }
+            if (token.isNamedRange) {
+                if (getSelectionFromNamedRange?.(token.image)) {
+                    token["index"] = ++index;
+                }
+                else {
+                    delete token["index"];
+                }
+            }
+            if (token.structured) {
+                const structuredSelection = getSelectionFromTable?.(editingSheetId, editingCell, token.tableName, token.columnNames, token.thisRow, token.specialItem);
+                if (structuredSelection) {
+                    token["index"] = ++index;
+                    const { range, sheetName } = structuredSelection;
+                    token.resolvedSheetName = sheetName;
+                    token.resolvedRowIndex = range.startRowIndex;
+                    token.resolvedColumnIndex = range.startColumnIndex;
+                }
+                else {
+                    delete token["index"];
+                    delete token.resolvedSheetName;
+                    delete token.resolvedRowIndex;
+                    delete token.resolvedColumnIndex;
+                }
+            }
+        }
+        return tokens;
+    }, [
+        getSelectionFromTable,
+        getSelectionFromNamedRange,
+        editingCell,
+        editingSheetId,
+        tokenizer,
+    ]));
+};

package/dist/esm/hooks/use-delayed-value.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a delayed version of a value
+ * @param value - The source value to delay
+ * @param delay - Delay in milliseconds
+ * @param isEqual - Optional equality comparison function
+ */
+export declare function useDelayedValue<T>(value: T, delay: number): T;
+//# sourceMappingURL=use-delayed-value.d.ts.map

package/dist/esm/hooks/use-delayed-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-delayed-value.d.ts","sourceRoot":"","sources":["../../../hooks/use-delayed-value.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CA0B7D"}

package/dist/esm/hooks/use-delayed-value.js

@@ -0,0 +1,30 @@
+import { useEffect, useState } from "react";
+import isEqual from "lodash/isEqual";
+/**
+ * Returns a delayed version of a value
+ * @param value - The source value to delay
+ * @param delay - Delay in milliseconds
+ * @param isEqual - Optional equality comparison function
+ */
+export function useDelayedValue(value, delay) {
+    const [delayedValue, setDelayedValue] = useState(value);
+    useEffect(() => {
+        // If clearing value (null/undefined), apply immediately
+        if (!value) {
+            setDelayedValue(value);
+            return;
+        }
+        // If values are equal, no need to delay
+        if (isEqual && isEqual(value, delayedValue)) {
+            return;
+        }
+        // Apply delay for new value
+        const timeoutId = setTimeout(() => {
+            setDelayedValue(value);
+        }, delay);
+        return () => {
+            clearTimeout(timeoutId);
+        };
+    }, [value, delay, delayedValue]);
+    return delayedValue;
+}