@rowsncolumns/spreadsheet 10.2.68

package/dist/esm/atoms/formula-bar-editor-value.atom.d.ts

@@ -0,0 +1,19 @@
+import type { TextFormatRun } from "@rowsncolumns/ui";
+import { type TextEditorRef } from "@rowsncolumns/ui";
+export declare const useSetFormulabarEditorValue: () => (args_0: string | ((prev: string) => string)) => void;
+export declare const useFormulabarEditorValue: () => [string, (args_0: string | ((prev: string) => string)) => void];
+export declare const useFormulaBarTextFormatRuns: () => [TextFormatRun[] | null | undefined, (args_0: TextFormatRun[] | ((prev: TextFormatRun[] | null | undefined) => TextFormatRun[] | null | undefined) | null | undefined) => void];
+export declare const useSetFormulaBarTextFormatRuns: () => (args_0: TextFormatRun[] | ((prev: TextFormatRun[] | null | undefined) => TextFormatRun[] | null | undefined) | null | undefined) => void;
+export declare const useCellEditorValue: () => [string, (args_0: string | ((prev: string) => string)) => void];
+export declare const useSetCellEditorValue: () => (args_0: string | ((prev: string) => string)) => void;
+export declare const useCellEditorTextFormatRuns: () => [TextFormatRun[] | null | undefined, (args_0: TextFormatRun[] | ((prev: TextFormatRun[] | null | undefined) => TextFormatRun[] | null | undefined) | null | undefined) => void];
+export declare const formulaBarEditorInstanceAtom: import("jotai").PrimitiveAtom<TextEditorRef | undefined> & {
+    init: TextEditorRef | undefined;
+};
+export declare const useSetFormulaBarEditorInstance: () => (args_0: TextEditorRef | ((prev: TextEditorRef | undefined) => TextEditorRef | undefined) | undefined) => void;
+export declare const cellEditorInstanceAtom: import("jotai").PrimitiveAtom<TextEditorRef | undefined> & {
+    init: TextEditorRef | undefined;
+};
+export declare const useCellEditorInstance: () => TextEditorRef | undefined;
+export declare const useSetCellEditorInstance: () => (args_0: TextEditorRef | ((prev: TextEditorRef | undefined) => TextEditorRef | undefined) | undefined) => void;
+//# sourceMappingURL=formula-bar-editor-value.atom.d.ts.map

package/dist/esm/atoms/formula-bar-editor-value.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula-bar-editor-value.atom.d.ts","sourceRoot":"","sources":["../../../atoms/formula-bar-editor-value.atom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKtD,eAAO,MAAM,2BAA2B,6DACD,CAAC;AAExC,eAAO,MAAM,wBAAwB,uEACD,CAAC;AAKrC,eAAO,MAAM,2BAA2B,uLACD,CAAC;AAExC,eAAO,MAAM,8BAA8B,iJACD,CAAC;AAI3C,eAAO,MAAM,kBAAkB,uEAAqC,CAAC;AACrE,eAAO,MAAM,qBAAqB,6DAAwC,CAAC;AAM3E,eAAO,MAAM,2BAA2B,uLACD,CAAC;AAExC,eAAO,MAAM,4BAA4B;;CAExC,CAAC;AAEF,eAAO,MAAM,8BAA8B,sHACD,CAAC;AAE3C,eAAO,MAAM,sBAAsB;;CAAoC,CAAC;AAExE,eAAO,MAAM,qBAAqB,iCAA6C,CAAC;AAEhF,eAAO,MAAM,wBAAwB,sHACD,CAAC"}

package/dist/esm/atoms/formula-bar-editor-value.atom.js

@@ -0,0 +1,17 @@
+import { atom, useAtom, useAtomValue, useSetAtom } from "jotai";
+const formulaBarEditorValueAtom = atom("");
+export const useSetFormulabarEditorValue = () => useSetAtom(formulaBarEditorValueAtom);
+export const useFormulabarEditorValue = () => useAtom(formulaBarEditorValueAtom);
+const formulaBarTextFormatRunsAtom = atom(undefined);
+export const useFormulaBarTextFormatRuns = () => useAtom(formulaBarTextFormatRunsAtom);
+export const useSetFormulaBarTextFormatRuns = () => useSetAtom(formulaBarTextFormatRunsAtom);
+const cellEditorValueAtom = atom("");
+export const useCellEditorValue = () => useAtom(cellEditorValueAtom);
+export const useSetCellEditorValue = () => useSetAtom(cellEditorValueAtom);
+const cellEditorTextFormatRunsAtom = atom(undefined);
+export const useCellEditorTextFormatRuns = () => useAtom(cellEditorTextFormatRunsAtom);
+export const formulaBarEditorInstanceAtom = atom(undefined);
+export const useSetFormulaBarEditorInstance = () => useSetAtom(formulaBarEditorInstanceAtom);
+export const cellEditorInstanceAtom = atom();
+export const useCellEditorInstance = () => useAtomValue(cellEditorInstanceAtom);
+export const useSetCellEditorInstance = () => useSetAtom(cellEditorInstanceAtom);

package/dist/esm/atoms/formula-mode.atom.d.ts

@@ -0,0 +1,7 @@
+export declare const formulaModeAtom: import("jotai").PrimitiveAtom<boolean> & {
+    init: boolean;
+};
+export declare const useFormulaModeValue: () => boolean;
+export declare const useSetFormulaMode: () => (args_0: boolean | ((prev: boolean) => boolean)) => void;
+export declare const useFormulaMode: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+//# sourceMappingURL=formula-mode.atom.d.ts.map

package/dist/esm/atoms/formula-mode.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula-mode.atom.d.ts","sourceRoot":"","sources":["../../../atoms/formula-mode.atom.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;CAAc,CAAC;AAE3C,eAAO,MAAM,mBAAmB,eAAsC,CAAC;AACvE,eAAO,MAAM,iBAAiB,gEAAoC,CAAC;AACnE,eAAO,MAAM,cAAc,2EAAiC,CAAC"}

package/dist/esm/atoms/formula-mode.atom.js

@@ -0,0 +1,5 @@
+import { atom, useAtom, useAtomValue, useSetAtom } from "jotai";
+export const formulaModeAtom = atom(false);
+export const useFormulaModeValue = () => useAtomValue(formulaModeAtom);
+export const useSetFormulaMode = () => useSetAtom(formulaModeAtom);
+export const useFormulaMode = () => useAtom(formulaModeAtom);

package/dist/esm/atoms/formula-selection-state.atom.d.ts

@@ -0,0 +1,16 @@
+import type { UseSelectionOptions } from "../hooks/use-selection";
+type FormulaSelectionStateProps = {
+    canSelectCells: boolean;
+    selectionMode: UseSelectionOptions["newSelectionMode"];
+    selectionIndex: number;
+};
+export declare const formulaSelectionStateAtom: import("jotai").PrimitiveAtom<FormulaSelectionStateProps> & {
+    init: FormulaSelectionStateProps;
+};
+export declare const useSetFormulaSelectionState: () => (args_0: FormulaSelectionStateProps | ((prev: FormulaSelectionStateProps) => FormulaSelectionStateProps)) => void;
+export declare const useFormualSelectionState: () => FormulaSelectionStateProps;
+export declare const useFormulaSelectionIndex: () => number;
+export declare const useFormulaSelectionMode: () => import("../hooks/use-selection").NewSelectionMode | undefined;
+export declare const useFormulaCanSelectCells: () => boolean;
+export {};
+//# sourceMappingURL=formula-selection-state.atom.d.ts.map

package/dist/esm/atoms/formula-selection-state.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula-selection-state.atom.d.ts","sourceRoot":"","sources":["../../../atoms/formula-selection-state.atom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAElE,KAAK,0BAA0B,GAAG;IAChC,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,EAAE,mBAAmB,CAAC,kBAAkB,CAAC,CAAC;IACvD,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,eAAO,MAAM,yBAAyB;;CAIpC,CAAC;AAEH,eAAO,MAAM,2BAA2B,yHACD,CAAC;AAExC,eAAO,MAAM,wBAAwB,kCACI,CAAC;AAM1C,eAAO,MAAM,wBAAwB,cACC,CAAC;AAMvC,eAAO,MAAM,uBAAuB,qEACC,CAAC;AAMtC,eAAO,MAAM,wBAAwB,eACC,CAAC"}

package/dist/esm/atoms/formula-selection-state.atom.js

@@ -0,0 +1,14 @@
+import { atom, useAtomValue, useSetAtom } from "jotai";
+export const formulaSelectionStateAtom = atom({
+    canSelectCells: false,
+    selectionMode: "append",
+    selectionIndex: 0,
+});
+export const useSetFormulaSelectionState = () => useSetAtom(formulaSelectionStateAtom);
+export const useFormualSelectionState = () => useAtomValue(formulaSelectionStateAtom);
+const selectionIndexSelector = atom((get) => get(formulaSelectionStateAtom).selectionIndex);
+export const useFormulaSelectionIndex = () => useAtomValue(selectionIndexSelector);
+const selectionModeSelector = atom((get) => get(formulaSelectionStateAtom).selectionMode);
+export const useFormulaSelectionMode = () => useAtomValue(selectionModeSelector);
+const canSelectCellsSelector = atom((get) => get(formulaSelectionStateAtom).canSelectCells);
+export const useFormulaCanSelectCells = () => useAtomValue(canSelectCellsSelector);

package/dist/esm/atoms/formula-selections.atom.d.ts

@@ -0,0 +1,8 @@
+import type { SelectionArea } from "@rowsncolumns/grid";
+import type { SelectionAttributes } from "../components/canvas-grid/typings";
+export declare const formulaSelectionsAtom: import("jotai").PrimitiveAtom<SelectionArea<SelectionAttributes>[]> & {
+    init: SelectionArea<SelectionAttributes>[];
+};
+export declare const useSetFormulaSelections: () => (args_0: SelectionArea<SelectionAttributes>[] | ((prev: SelectionArea<SelectionAttributes>[]) => SelectionArea<SelectionAttributes>[])) => void;
+export declare const useFormulaSelections: () => SelectionArea<SelectionAttributes>[];
+//# sourceMappingURL=formula-selections.atom.d.ts.map

package/dist/esm/atoms/formula-selections.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula-selections.atom.d.ts","sourceRoot":"","sources":["../../../atoms/formula-selections.atom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAE7E,eAAO,MAAM,qBAAqB;;CAEjC,CAAC;AAEF,eAAO,MAAM,uBAAuB,uJAA0C,CAAC;AAE/E,eAAO,MAAM,oBAAoB,4CAA4C,CAAC"}

package/dist/esm/atoms/formula-selections.atom.js

@@ -0,0 +1,4 @@
+import { atom, useAtomValue, useSetAtom } from "jotai";
+export const formulaSelectionsAtom = atom([]);
+export const useSetFormulaSelections = () => useSetAtom(formulaSelectionsAtom);
+export const useFormulaSelections = () => useAtomValue(formulaSelectionsAtom);

package/dist/esm/atoms/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./active-editor.atom";
+export * from "./editing-cell.atom";
+export * from "./formula-bar-editor-value.atom";
+export * from "./formula-mode.atom";
+export * from "./formula-selection-state.atom";
+export * from "./formula-selections.atom";
+export * from "./sheet-context.atom";
+export * from "./persistent-tooltip.atom";
+export * from "./sheet-status-display.atom";
+export * from "./spreadsheet-api.atom";
+export { useLoadingIndicator } from "./loading-indicator.atom";
+export * from "./selected-chart-embed.atom";
+export * from "./popover.atom";
+export * from "./paste-menu.atom";
+export * from "./magic-fill-state.atom";
+export * from "./validation-alert.atom";
+export * from "./sort-dialog.atom";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/atoms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../atoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC"}

package/dist/esm/atoms/index.js

@@ -0,0 +1,17 @@
+export * from "./active-editor.atom";
+export * from "./editing-cell.atom";
+export * from "./formula-bar-editor-value.atom";
+export * from "./formula-mode.atom";
+export * from "./formula-selection-state.atom";
+export * from "./formula-selections.atom";
+export * from "./sheet-context.atom";
+export * from "./persistent-tooltip.atom";
+export * from "./sheet-status-display.atom";
+export * from "./spreadsheet-api.atom";
+export { useLoadingIndicator } from "./loading-indicator.atom";
+export * from "./selected-chart-embed.atom";
+export * from "./popover.atom";
+export * from "./paste-menu.atom";
+export * from "./magic-fill-state.atom";
+export * from "./validation-alert.atom";
+export * from "./sort-dialog.atom";

package/dist/esm/atoms/loading-indicator.atom.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from "react";
+type StatefulLoaderProps = {
+    loading: boolean;
+    label?: ReactNode;
+};
+export declare const statefulLoaderAtom: import("jotai").PrimitiveAtom<StatefulLoaderProps> & {
+    init: StatefulLoaderProps;
+};
+export declare const useLoadingIndicator: () => ((label?: ReactNode) => void)[];
+export declare const useLoaderValue: () => StatefulLoaderProps;
+export {};
+//# sourceMappingURL=loading-indicator.atom.d.ts.map

package/dist/esm/atoms/loading-indicator.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading-indicator.atom.d.ts","sourceRoot":"","sources":["../../../atoms/loading-indicator.atom.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,OAAO,CAAC;AAEpD,KAAK,mBAAmB,GAAG;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,kBAAkB;;CAE7B,CAAC;AAEH,eAAO,MAAM,mBAAmB,kBAGnB,SAAS,YAWrB,CAAC;AAEF,eAAO,MAAM,cAAc,2BAAyC,CAAC"}

package/dist/esm/atoms/loading-indicator.atom.js

@@ -0,0 +1,17 @@
+import { atom, useAtomValue, useSetAtom } from "jotai";
+import { useCallback } from "react";
+export const statefulLoaderAtom = atom({
+    loading: false,
+});
+export const useLoadingIndicator = () => {
+    const setter = useSetAtom(statefulLoaderAtom);
+    const showLoader = useCallback((label) => {
+        setter({
+            loading: true,
+            label,
+        });
+    }, [setter]);
+    const hideLoader = useCallback(() => setter({ loading: false }), [setter]);
+    return [showLoader, hideLoader];
+};
+export const useLoaderValue = () => useAtomValue(statefulLoaderAtom);

package/dist/esm/atoms/magic-fill-state.atom.d.ts

@@ -0,0 +1,5 @@
+import type { SheetRangeBorderStyle } from "../components/canvas-grid/typings";
+export declare const useQuickEditStateValue: () => SheetRangeBorderStyle[];
+export declare const useSetQuickEditState: () => (args_0: SheetRangeBorderStyle[] | ((prev: SheetRangeBorderStyle[]) => SheetRangeBorderStyle[])) => void;
+export declare const useQuickEditState: () => [SheetRangeBorderStyle[], (args_0: SheetRangeBorderStyle[] | ((prev: SheetRangeBorderStyle[]) => SheetRangeBorderStyle[])) => void];
+//# sourceMappingURL=magic-fill-state.atom.d.ts.map

package/dist/esm/atoms/magic-fill-state.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"magic-fill-state.atom.d.ts","sourceRoot":"","sources":["../../../atoms/magic-fill-state.atom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAK/E,eAAO,MAAM,sBAAsB,+BAAwC,CAAC;AAC5E,eAAO,MAAM,oBAAoB,gHAAsC,CAAC;AACxE,eAAO,MAAM,iBAAiB,2IAAmC,CAAC"}

package/dist/esm/atoms/magic-fill-state.atom.js

@@ -0,0 +1,6 @@
+import { atom, useAtom, useAtomValue, useSetAtom } from "jotai";
+// Quick edit family
+const quickEditBaseAtom = atom([]);
+export const useQuickEditStateValue = () => useAtomValue(quickEditBaseAtom);
+export const useSetQuickEditState = () => useSetAtom(quickEditBaseAtom);
+export const useQuickEditState = () => useAtom(quickEditBaseAtom);

package/dist/esm/atoms/paste-menu.atom.d.ts

@@ -0,0 +1,6 @@
+export declare const showPasteMenuAtom: import("jotai").PrimitiveAtom<boolean> & {
+    init: boolean;
+};
+export declare const useShowPasteMenu: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+export declare const useSetShowPasteMenu: () => (args_0: boolean | ((prev: boolean) => boolean)) => void;
+//# sourceMappingURL=paste-menu.atom.d.ts.map

package/dist/esm/atoms/paste-menu.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paste-menu.atom.d.ts","sourceRoot":"","sources":["../../../atoms/paste-menu.atom.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;CAAc,CAAC;AAE7C,eAAO,MAAM,gBAAgB,2EAAmC,CAAC;AACjE,eAAO,MAAM,mBAAmB,gEAAsC,CAAC"}

package/dist/esm/atoms/paste-menu.atom.js

@@ -0,0 +1,4 @@
+import { atom, useAtom, useSetAtom } from "jotai";
+export const showPasteMenuAtom = atom(false);
+export const useShowPasteMenu = () => useAtom(showPasteMenuAtom);
+export const useSetShowPasteMenu = () => useSetAtom(showPasteMenuAtom);

package/dist/esm/atoms/persistent-tooltip.atom.d.ts

@@ -0,0 +1,11 @@
+import type { SheetCoordinate } from "../types";
+export declare const persistentTooltip: import("jotai/vanilla/utils/atomFamily").AtomFamily<unknown, import("jotai").PrimitiveAtom<SheetCoordinate | undefined> & {
+    init: SheetCoordinate | undefined;
+}>;
+export declare const useNoteEditorCellValue: () => SheetCoordinate | undefined;
+export declare const useNoteEditorCell: () => [SheetCoordinate | undefined, (args_0: SheetCoordinate | ((prev: SheetCoordinate | undefined) => SheetCoordinate | undefined) | undefined) => void];
+export declare const useSetNoteEditorCell: () => (args_0: SheetCoordinate | ((prev: SheetCoordinate | undefined) => SheetCoordinate | undefined) | undefined) => void;
+export declare const usePinnedTooltipCellValue: () => SheetCoordinate | undefined;
+export declare const usePinnedTooltip: () => [SheetCoordinate | undefined, (args_0: SheetCoordinate | ((prev: SheetCoordinate | undefined) => SheetCoordinate | undefined) | undefined) => void];
+export declare const useSetPinnedTooltip: () => (args_0: SheetCoordinate | ((prev: SheetCoordinate | undefined) => SheetCoordinate | undefined) | undefined) => void;
+//# sourceMappingURL=persistent-tooltip.atom.d.ts.map

package/dist/esm/atoms/persistent-tooltip.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistent-tooltip.atom.d.ts","sourceRoot":"","sources":["../../../atoms/persistent-tooltip.atom.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGhD,eAAO,MAAM,iBAAiB;;EAE7B,CAAC;AAGF,eAAO,MAAM,sBAAsB,mCACY,CAAC;AAEhD,eAAO,MAAM,iBAAiB,2JAAiD,CAAC;AAEhF,eAAO,MAAM,oBAAoB,4HACY,CAAC;AAG9C,eAAO,MAAM,yBAAyB,mCACY,CAAC;AAEnD,eAAO,MAAM,gBAAgB,2JACgB,CAAC;AAE9C,eAAO,MAAM,mBAAmB,4HACgB,CAAC"}

package/dist/esm/atoms/persistent-tooltip.atom.js

@@ -0,0 +1,13 @@
+import { atom } from "jotai";
+import { useAtom, useAtomValue, useSetAtom } from "jotai";
+import { atomFamily } from "jotai/utils";
+// Create the atomFamily
+export const persistentTooltip = atomFamily(() => atom(undefined));
+// Custom hooks that maintain the same API as before
+export const useNoteEditorCellValue = () => useAtomValue(persistentTooltip("noteEditor"));
+export const useNoteEditorCell = () => useAtom(persistentTooltip("noteEditor"));
+export const useSetNoteEditorCell = () => useSetAtom(persistentTooltip("noteEditor"));
+// Custom hooks that maintain the same API as before
+export const usePinnedTooltipCellValue = () => useAtomValue(persistentTooltip("pinnedTooltip"));
+export const usePinnedTooltip = () => useAtom(persistentTooltip("pinnedTooltip"));
+export const useSetPinnedTooltip = () => useSetAtom(persistentTooltip("pinnedTooltip"));

package/dist/esm/atoms/popover.atom.d.ts

@@ -0,0 +1,7 @@
+import type { SheetCoordinate, SheetRange } from "./../types";
+export declare const popoverRangeAtom: import("jotai").PrimitiveAtom<SheetRange | SheetCoordinate | undefined> & {
+    init: SheetRange | SheetCoordinate | undefined;
+};
+export declare const usePopover: () => [SheetRange | SheetCoordinate | undefined, (args_0: SheetRange | SheetCoordinate | ((prev: SheetRange | SheetCoordinate | undefined) => SheetRange | SheetCoordinate | undefined) | undefined) => void];
+export declare const useSetCellPopover: () => (args_0: SheetRange | SheetCoordinate | ((prev: SheetRange | SheetCoordinate | undefined) => SheetRange | SheetCoordinate | undefined) | undefined) => void;
+//# sourceMappingURL=popover.atom.d.ts.map

package/dist/esm/atoms/popover.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"popover.atom.d.ts","sourceRoot":"","sources":["../../../atoms/popover.atom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,gBAAgB;;CAE5B,CAAC;AAEF,eAAO,MAAM,UAAU,+MAAkC,CAAC;AAE1D,eAAO,MAAM,iBAAiB,mKAAqC,CAAC"}

package/dist/esm/atoms/popover.atom.js

@@ -0,0 +1,4 @@
+import { atom, useAtom, useSetAtom } from "jotai";
+export const popoverRangeAtom = atom(undefined);
+export const usePopover = () => useAtom(popoverRangeAtom);
+export const useSetCellPopover = () => useSetAtom(popoverRangeAtom);

package/dist/esm/atoms/range-selector.atom.d.ts

@@ -0,0 +1,6 @@
+export declare const useRangeContext: () => {
+    scrollToCell: ((cell: import("@rowsncolumns/grid").OptionalCellInterface, align?: import("@rowsncolumns/grid").Align) => void) | undefined;
+    focusSheet: (() => void) | undefined;
+    navigateToSheetRange: ((sheetRange: import("@rowsncolumns/common-types").SheetRange, options?: import("../hooks/use-navigate-sheet-range").NavigateOptions) => void) | undefined;
+};
+//# sourceMappingURL=range-selector.atom.d.ts.map

package/dist/esm/atoms/range-selector.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range-selector.atom.d.ts","sourceRoot":"","sources":["../../../atoms/range-selector.atom.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,eAAe;;;;CAA2C,CAAC"}

package/dist/esm/atoms/range-selector.atom.js

@@ -0,0 +1,7 @@
+import { atom, useAtomValue } from "jotai";
+import { spreadsheetContextAtom } from "./sheet-context.atom";
+const rangeContextSelector = atom((get) => {
+    const { scrollToCell, focusSheet, navigateToSheetRange } = get(spreadsheetContextAtom);
+    return { scrollToCell, focusSheet, navigateToSheetRange };
+});
+export const useRangeContext = () => useAtomValue(rangeContextSelector);

package/dist/esm/atoms/selected-chart-embed.atom.d.ts

@@ -0,0 +1,6 @@
+export declare const selectedChartEmbedAtom: import("jotai").PrimitiveAtom<string | number | undefined> & {
+    init: string | number | undefined;
+};
+export declare const useSelectedChartEmbed: () => [string | number | undefined, (args_0: string | number | ((prev: string | number | undefined) => string | number | undefined) | undefined) => void];
+export declare const useFocusEmbedOrChart: () => (args_0: string | number | ((prev: string | number | undefined) => string | number | undefined) | undefined) => void;
+//# sourceMappingURL=selected-chart-embed.atom.d.ts.map

package/dist/esm/atoms/selected-chart-embed.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selected-chart-embed.atom.d.ts","sourceRoot":"","sources":["../../../atoms/selected-chart-embed.atom.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB;;CAEvB,CAAC;AAEb,eAAO,MAAM,qBAAqB,2JAAwC,CAAC;AAE3E,eAAO,MAAM,oBAAoB,4HAA2C,CAAC"}

package/dist/esm/atoms/selected-chart-embed.atom.js

@@ -0,0 +1,4 @@
+import { atom, useAtom, useSetAtom } from "jotai";
+export const selectedChartEmbedAtom = atom(undefined);
+export const useSelectedChartEmbed = () => useAtom(selectedChartEmbedAtom);
+export const useFocusEmbedOrChart = () => useSetAtom(selectedChartEmbedAtom);

package/dist/esm/atoms/sheet-context.atom.d.ts

@@ -0,0 +1,66 @@
+import type { CanvasGridMethods } from "../components/canvas-grid/typings";
+export declare const spreadsheetContextAtom: import("jotai").PrimitiveAtom<CanvasGridMethods> & {
+    init: CanvasGridMethods;
+};
+export declare const useSpreadsheet: () => CanvasGridMethods;
+export declare const tokenizerSelector: import("jotai").Atom<(str: string) => import("..").ParsedToken[]>;
+export declare const useTokenizer: () => (str: string) => import("..").ParsedToken[];
+export declare const useSetSpreadsheetContext: () => (args_0: CanvasGridMethods | ((prev: CanvasGridMethods) => CanvasGridMethods)) => void;
+export declare const useGetCellBounds: () => ((coords: import("@rowsncolumns/grid").CellInterface, spanMerges?: boolean | undefined) => import("@rowsncolumns/grid").GridRange) | undefined;
+export declare const useGetSelectionsFromFormula: () => ((value: string, anchorCell?: import("@rowsncolumns/grid").CellInterface) => import("@rowsncolumns/grid").SelectionArea<import("../components/canvas-grid/typings").SelectionAttributes>[]) | undefined;
+export declare const useGetAddressFromSelection: () => ((selections: import("@rowsncolumns/grid").SelectionArea<import("../components/canvas-grid/typings").SelectionAttributes>, sheetName: string | undefined, anchorCell?: import("@rowsncolumns/common-types").SheetCoordinate) => string | undefined) | undefined;
+export declare const useGetR1C1AddressFromSelection: () => ((range: import("@rowsncolumns/grid").GridRange, sheetName?: string) => string | undefined) | undefined;
+export declare const useGetCellDimensions: () => ((sheetId: number, rowIndex: number, columnIndex: number, axis?: import("..").AXIS | undefined, options?: import("../components/canvas-grid/typings").GetCellDimensionsOptions) => {
+    width: number;
+    height: number;
+}) | undefined;
+export declare const useGetRowHeight: () => ((sheetId: number, rowIndex: number, shouldExclude?: (index: number) => boolean) => number) | undefined;
+export declare const useGetColumnWidth: () => ((sheetId: number, columnIndex: number, options?: {
+    rowStartIndexRegion?: number;
+    rowStopIndexRegion?: number;
+    fallbackToDefaultIfEmpty?: boolean;
+}) => number) | undefined;
+export declare const useGetContentfulRangeAroundCell: () => ((sheetId: number, startCell: import("@rowsncolumns/grid").CellInterface) => import("@rowsncolumns/grid").GridRange) | undefined;
+export declare const useGetCellCoordsFromOffset: () => ((x: number, y: number, includeFrozen: boolean) => import("@rowsncolumns/grid").CellInterface | undefined) | undefined;
+export declare const useGetCellOffsetFromCoords: () => ((cell: import("@rowsncolumns/grid").CellInterface) => import("@rowsncolumns/grid").CellPosition | undefined) | undefined;
+export declare const updateSelectionStartEndReferenceSelector: import("jotai").Atom<((cell: import("@rowsncolumns/grid").CellInterface | undefined, selections?: import("@rowsncolumns/grid").SelectionArea<import("../components/canvas-grid/typings").SelectionAttributes>[] | undefined) => void) | undefined>;
+export declare const useUpdateSelectionStartEndReference: () => ((cell: import("@rowsncolumns/grid").CellInterface | undefined, selections?: import("@rowsncolumns/grid").SelectionArea<import("../components/canvas-grid/typings").SelectionAttributes>[] | undefined) => void) | undefined;
+export declare const canEditCellSelector: import("jotai").Atom<((sheetId: number, cell: import("@rowsncolumns/grid").CellInterface) => boolean) | undefined>;
+export declare const useCanEditCell: () => ((sheetId: number, cell: import("@rowsncolumns/grid").CellInterface) => boolean) | undefined;
+export declare const isSheetProtectedSelector: import("jotai").Atom<((sheetId: number) => boolean) | undefined>;
+export declare const useIsSheetProtected: () => ((sheetId: number) => boolean) | undefined;
+export declare const isWorkbookProtectedSelector: import("jotai").Atom<(() => boolean) | undefined>;
+export declare const useIsWorkbookProtected: () => (() => boolean) | undefined;
+export declare const getSheetProtectionSelector: import("jotai").Atom<((sheetId: number) => import("..").SheetProtection | null | undefined) | undefined>;
+export declare const useGetSheetProtection: () => ((sheetId: number) => import("..").SheetProtection | null | undefined) | undefined;
+export declare const getEffectiveValuesFromRangeSelector: import("jotai").Atom<((address: string) => import("@rowsncolumns/common-types").ConditionValue[]) | undefined>;
+export declare const useGetEffectiveValuesFromRange: () => ((address: string) => import("@rowsncolumns/common-types").ConditionValue[]) | undefined;
+export declare const insertNoteSelector: import("jotai").Atom<((sheetId: number, cell: import("@rowsncolumns/grid").CellInterface, selections: import("@rowsncolumns/grid").SelectionArea<import("../components/canvas-grid/typings").SelectionAttributes>[]) => void) | undefined>;
+export declare const useInsertNote: () => ((sheetId: number, cell: import("@rowsncolumns/grid").CellInterface, selections: import("@rowsncolumns/grid").SelectionArea<import("../components/canvas-grid/typings").SelectionAttributes>[]) => void) | undefined;
+export declare const focusSheetSelector: import("jotai").Atom<(() => void) | undefined>;
+export declare const useFocusSheet: () => (() => void) | undefined;
+export declare const getSheetDimensionsSelector: import("jotai").Atom<(() => readonly [width: number, height: number]) | undefined>;
+export declare const useGetSheetDimensions: () => (() => readonly [width: number, height: number]) | undefined;
+export declare const getFinalRowHeightSelector: import("jotai").Atom<((sheetId: number, rowIndex: number, columnIndex: number, options?: import("../components/canvas-grid/typings").GetCellDimensionsOptions) => number | undefined) | undefined>;
+export declare const useGetFinalRowHeight: () => ((sheetId: number, rowIndex: number, columnIndex: number, options?: import("../components/canvas-grid/typings").GetCellDimensionsOptions) => number | undefined) | undefined;
+export declare const onEditorKeyDownSelector: import("jotai").Atom<((e: React.KeyboardEvent<HTMLDivElement>) => void) | undefined>;
+export declare const useOnEditorKeyDown: () => ((e: React.KeyboardEvent<HTMLDivElement>) => void) | undefined;
+export declare const getSheetNameSelector: import("jotai").Atom<((sheetId: number) => string) | undefined>;
+export declare const useGetSheetName: () => ((sheetId: number) => string) | undefined;
+export declare const getSheetIdSelector: import("jotai").Atom<((sheetName: string) => number | undefined) | undefined>;
+export declare const useGetSheetId: () => ((sheetName: string) => number | undefined) | undefined;
+export declare const getShowCellPopoverSelector: import("jotai").Atom<((popoverRange: import("@rowsncolumns/common-types").SheetRange | import("@rowsncolumns/common-types").SheetCoordinate, content: import("..").Maybe<React.ReactNode | React.ComponentType>) => void) | undefined>;
+export declare const useShowCellPopover: () => ((popoverRange: import("@rowsncolumns/common-types").SheetRange | import("@rowsncolumns/common-types").SheetCoordinate, content: import("..").Maybe<React.ReactNode | React.ComponentType>) => void) | undefined;
+export declare const scrollToCellSelector: import("jotai").Atom<((cell: import("@rowsncolumns/grid").OptionalCellInterface, align?: import("@rowsncolumns/grid").Align) => void) | undefined>;
+export declare const useScrollToCell: () => ((cell: import("@rowsncolumns/grid").OptionalCellInterface, align?: import("@rowsncolumns/grid").Align) => void) | undefined;
+export declare const redrawGridSelector: import("jotai").Atom<(() => void) | undefined>;
+export declare const useRedrawGrid: () => (() => void) | undefined;
+export declare const getViewPortSelector: import("jotai").Atom<(() => import("@rowsncolumns/grid").ViewPortProps) | undefined>;
+export declare const useGetViewPort: () => (() => import("@rowsncolumns/grid").ViewPortProps) | undefined;
+export declare const getNamedRangesSelector: import("jotai").Atom<(() => import("@rowsncolumns/ui").OptionItem[] | undefined) | undefined>;
+export declare const useGetNamedRanges: () => (() => import("@rowsncolumns/ui").OptionItem[] | undefined) | undefined;
+export declare const getGridRefSelector: import("jotai").Atom<(() => import("@rowsncolumns/grid").GridRef | null) | undefined>;
+export declare const useGetGridRef: () => (() => import("@rowsncolumns/grid").GridRef | null) | undefined;
+export declare const navigateToSheetRangeSelector: import("jotai").Atom<((sheetRange: import("@rowsncolumns/common-types").SheetRange, options?: import("../hooks/use-navigate-sheet-range").NavigateOptions) => void) | undefined>;
+export declare const useNavigateToSheetRange: () => ((sheetRange: import("@rowsncolumns/common-types").SheetRange, options?: import("../hooks/use-navigate-sheet-range").NavigateOptions) => void) | undefined;
+//# sourceMappingURL=sheet-context.atom.d.ts.map

package/dist/esm/atoms/sheet-context.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sheet-context.atom.d.ts","sourceRoot":"","sources":["../../../atoms/sheet-context.atom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E,eAAO,MAAM,sBAAsB;;CAEjC,CAAC;AAEH,eAAO,MAAM,cAAc,yBAA6C,CAAC;AAGzE,eAAO,MAAM,iBAAiB,mEAE7B,CAAC;AAEF,eAAO,MAAM,YAAY,mDAAwC,CAAC;AAElE,eAAO,MAAM,wBAAwB,8FACD,CAAC;AAOrC,eAAO,MAAM,gBAAgB,sJAA4C,CAAC;AAO1E,eAAO,MAAM,2BAA2B,+MACK,CAAC;AAO9C,eAAO,MAAM,0BAA0B,uQACM,CAAC;AAO9C,eAAO,MAAM,8BAA8B,+GACM,CAAC;AAMlD,eAAO,MAAM,oBAAoB;;;cACQ,CAAC;AAM1C,eAAO,MAAM,eAAe,+GAA2C,CAAC;AAMxE,eAAO,MAAM,iBAAiB;;;;yBAA6C,CAAC;AAM5E,eAAO,MAAM,+BAA+B,wIACY,CAAC;AAMzD,eAAO,MAAM,0BAA0B,8HACQ,CAAC;AAMhD,eAAO,MAAM,0BAA0B,iIACQ,CAAC;AAEhD,eAAO,MAAM,wCAAwC,oPAEpD,CAAC;AAEF,eAAO,MAAM,mCAAmC,oOACQ,CAAC;AAEzD,eAAO,MAAM,mBAAmB,oHAE/B,CAAC;AAEF,eAAO,MAAM,cAAc,oGAA0C,CAAC;AAEtE,eAAO,MAAM,wBAAwB,kEAEpC,CAAC;AAEF,eAAO,MAAM,mBAAmB,kDAA+C,CAAC;AAEhF,eAAO,MAAM,2BAA2B,mDAEvC,CAAC;AAEF,eAAO,MAAM,sBAAsB,mCACQ,CAAC;AAE5C,eAAO,MAAM,0BAA0B,0GAEtC,CAAC;AAEF,eAAO,MAAM,qBAAqB,0FACQ,CAAC;AAE3C,eAAO,MAAM,mCAAmC,gHAE/C,CAAC;AAEF,eAAO,MAAM,8BAA8B,gGACQ,CAAC;AAEpD,eAAO,MAAM,kBAAkB,4OAE9B,CAAC;AAEF,eAAO,MAAM,aAAa,4NAAyC,CAAC;AAEpE,eAAO,MAAM,kBAAkB,gDAE9B,CAAC;AAEF,eAAO,MAAM,aAAa,gCAAyC,CAAC;AAEpE,eAAO,MAAM,0BAA0B,oFAEtC,CAAC;AAEF,eAAO,MAAM,qBAAqB,oEACQ,CAAC;AAE3C,eAAO,MAAM,yBAAyB,oMAErC,CAAC;AAEF,eAAO,MAAM,oBAAoB,oLACQ,CAAC;AAE1C,eAAO,MAAM,uBAAuB,sFAEnC,CAAC;AAEF,eAAO,MAAM,kBAAkB,sEAA8C,CAAC;AAE9E,eAAO,MAAM,oBAAoB,iEAEhC,CAAC;AAEF,eAAO,MAAM,eAAe,iDAA2C,CAAC;AAExE,eAAO,MAAM,kBAAkB,+EAE9B,CAAC;AAEF,eAAO,MAAM,aAAa,+DAAyC,CAAC;AAEpE,eAAO,MAAM,0BAA0B,wOAEtC,CAAC;AAEF,eAAO,MAAM,kBAAkB,wNACW,CAAC;AAE3C,eAAO,MAAM,oBAAoB,oJAEhC,CAAC;AAEF,eAAO,MAAM,eAAe,oIAA2C,CAAC;AAExE,eAAO,MAAM,kBAAkB,gDAE9B,CAAC;AAEF,eAAO,MAAM,aAAa,gCAAyC,CAAC;AAEpE,eAAO,MAAM,mBAAmB,sFAE/B,CAAC;AAEF,eAAO,MAAM,cAAc,sEAA0C,CAAC;AAEtE,eAAO,MAAM,sBAAsB,+FAElC,CAAC;AAEF,eAAO,MAAM,iBAAiB,+EAA6C,CAAC;AAE5E,eAAO,MAAM,kBAAkB,uFAE9B,CAAC;AACF,eAAO,MAAM,aAAa,uEAAyC,CAAC;AAEpE,eAAO,MAAM,4BAA4B,kLAExC,CAAC;AACF,eAAO,MAAM,uBAAuB,kKACQ,CAAC"}

package/dist/esm/atoms/sheet-context.atom.js

@@ -0,0 +1,73 @@
+import { atom, useAtomValue, useSetAtom } from "jotai";
+export const spreadsheetContextAtom = atom({
+    tokenizer: () => [],
+});
+export const useSpreadsheet = () => useAtomValue(spreadsheetContextAtom);
+// Tokenizer selector
+export const tokenizerSelector = atom((get) => get(spreadsheetContextAtom).tokenizer);
+export const useTokenizer = () => useAtomValue(tokenizerSelector);
+export const useSetSpreadsheetContext = () => useSetAtom(spreadsheetContextAtom);
+// Cellbounds selector
+const getCellBoundsSelector = atom((get) => get(spreadsheetContextAtom).getCellBounds);
+export const useGetCellBounds = () => useAtomValue(getCellBoundsSelector);
+// Get selections
+const selectionsFromFormulaSelector = atom((get) => get(spreadsheetContextAtom).getSelectionsFromFormula);
+export const useGetSelectionsFromFormula = () => useAtomValue(selectionsFromFormulaSelector);
+// Get address from selection
+const addressFromSelectionsSelector = atom((get) => get(spreadsheetContextAtom).getAddressFromSelection);
+export const useGetAddressFromSelection = () => useAtomValue(addressFromSelectionsSelector);
+// Get R1C1 from selection
+const addressR1C1FromSelectionsSelector = atom((get) => get(spreadsheetContextAtom).getR1C1AddressFromSelection);
+export const useGetR1C1AddressFromSelection = () => useAtomValue(addressR1C1FromSelectionsSelector);
+const getCellDimensionsSelector = atom((get) => get(spreadsheetContextAtom).getCellDimensions);
+export const useGetCellDimensions = () => useAtomValue(getCellDimensionsSelector);
+const getRowHeightSelector = atom((get) => get(spreadsheetContextAtom).getRowHeight);
+export const useGetRowHeight = () => useAtomValue(getRowHeightSelector);
+const getColumnWidthSelector = atom((get) => get(spreadsheetContextAtom).getColumnWidth);
+export const useGetColumnWidth = () => useAtomValue(getColumnWidthSelector);
+const getContentfulGridRangeAroundCellSelector = atom((get) => get(spreadsheetContextAtom).getContentfulGridRangeAroundCell);
+export const useGetContentfulRangeAroundCell = () => useAtomValue(getContentfulGridRangeAroundCellSelector);
+const getCellCoordsFromOffsetSelector = atom((get) => get(spreadsheetContextAtom).getCellCoordsFromOffset);
+export const useGetCellCoordsFromOffset = () => useAtomValue(getCellCoordsFromOffsetSelector);
+const getCellOffsetFromCoordsSelector = atom((get) => get(spreadsheetContextAtom).getCellOffsetFromCoords);
+export const useGetCellOffsetFromCoords = () => useAtomValue(getCellOffsetFromCoordsSelector);
+export const updateSelectionStartEndReferenceSelector = atom((get) => get(spreadsheetContextAtom).updateSelectionStartEndReference);
+export const useUpdateSelectionStartEndReference = () => useAtomValue(updateSelectionStartEndReferenceSelector);
+export const canEditCellSelector = atom((get) => get(spreadsheetContextAtom).canEditCell);
+export const useCanEditCell = () => useAtomValue(canEditCellSelector);
+export const isSheetProtectedSelector = atom((get) => get(spreadsheetContextAtom).isSheetProtected);
+export const useIsSheetProtected = () => useAtomValue(isSheetProtectedSelector);
+export const isWorkbookProtectedSelector = atom((get) => get(spreadsheetContextAtom).isWorkbookProtected);
+export const useIsWorkbookProtected = () => useAtomValue(isWorkbookProtectedSelector);
+export const getSheetProtectionSelector = atom((get) => get(spreadsheetContextAtom).getSheetProtection);
+export const useGetSheetProtection = () => useAtomValue(getSheetProtectionSelector);
+export const getEffectiveValuesFromRangeSelector = atom((get) => get(spreadsheetContextAtom).getEffectiveValuesFromRange);
+export const useGetEffectiveValuesFromRange = () => useAtomValue(getEffectiveValuesFromRangeSelector);
+export const insertNoteSelector = atom((get) => get(spreadsheetContextAtom).onInsertNote);
+export const useInsertNote = () => useAtomValue(insertNoteSelector);
+export const focusSheetSelector = atom((get) => get(spreadsheetContextAtom).focusSheet);
+export const useFocusSheet = () => useAtomValue(focusSheetSelector);
+export const getSheetDimensionsSelector = atom((get) => get(spreadsheetContextAtom).getSheetDimensions);
+export const useGetSheetDimensions = () => useAtomValue(getSheetDimensionsSelector);
+export const getFinalRowHeightSelector = atom((get) => get(spreadsheetContextAtom).getFinalRowHeight);
+export const useGetFinalRowHeight = () => useAtomValue(getFinalRowHeightSelector);
+export const onEditorKeyDownSelector = atom((get) => get(spreadsheetContextAtom).onEditorKeyDown);
+export const useOnEditorKeyDown = () => useAtomValue(onEditorKeyDownSelector);
+export const getSheetNameSelector = atom((get) => get(spreadsheetContextAtom).getSheetName);
+export const useGetSheetName = () => useAtomValue(getSheetNameSelector);
+export const getSheetIdSelector = atom((get) => get(spreadsheetContextAtom).getSheetId);
+export const useGetSheetId = () => useAtomValue(getSheetIdSelector);
+export const getShowCellPopoverSelector = atom((get) => get(spreadsheetContextAtom).showCellPopover);
+export const useShowCellPopover = () => useAtomValue(getShowCellPopoverSelector);
+export const scrollToCellSelector = atom((get) => get(spreadsheetContextAtom).scrollToCell);
+export const useScrollToCell = () => useAtomValue(scrollToCellSelector);
+export const redrawGridSelector = atom((get) => get(spreadsheetContextAtom).redrawGrid);
+export const useRedrawGrid = () => useAtomValue(redrawGridSelector);
+export const getViewPortSelector = atom((get) => get(spreadsheetContextAtom).getViewPort);
+export const useGetViewPort = () => useAtomValue(getViewPortSelector);
+export const getNamedRangesSelector = atom((get) => get(spreadsheetContextAtom).getNamedRanges);
+export const useGetNamedRanges = () => useAtomValue(getNamedRangesSelector);
+export const getGridRefSelector = atom((get) => get(spreadsheetContextAtom).getGridRef);
+export const useGetGridRef = () => useAtomValue(getGridRefSelector);
+export const navigateToSheetRangeSelector = atom((get) => get(spreadsheetContextAtom).navigateToSheetRange);
+export const useNavigateToSheetRange = () => useAtomValue(navigateToSheetRangeSelector);

package/dist/esm/atoms/sheet-status-display.atom.d.ts

@@ -0,0 +1,15 @@
+type SheetStatusDisplay = {
+    showAverage?: boolean;
+    showMin?: boolean;
+    showMax?: boolean;
+    showSum?: boolean;
+    showCount?: boolean;
+    showNumericalCount?: boolean;
+};
+export declare const sheetStatusDisplayAtom: import("jotai").PrimitiveAtom<SheetStatusDisplay> & {
+    init: SheetStatusDisplay;
+};
+export declare const useSheetStatusDisplay: () => [SheetStatusDisplay, (args_0: SheetStatusDisplay | ((prev: SheetStatusDisplay) => SheetStatusDisplay)) => void];
+export declare const useSheetStatusDisplayValue: () => SheetStatusDisplay;
+export {};
+//# sourceMappingURL=sheet-status-display.atom.d.ts.map

package/dist/esm/atoms/sheet-status-display.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sheet-status-display.atom.d.ts","sourceRoot":"","sources":["../../../atoms/sheet-status-display.atom.ts"],"names":[],"mappings":"AAEA,KAAK,kBAAkB,GAAG;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,sBAAsB;;CAOjC,CAAC;AAEH,eAAO,MAAM,qBAAqB,uHAAwC,CAAC;AAE3E,eAAO,MAAM,0BAA0B,0BACD,CAAC"}

package/dist/esm/atoms/sheet-status-display.atom.js

@@ -0,0 +1,11 @@
+import { atom, useAtom, useAtomValue } from "jotai";
+export const sheetStatusDisplayAtom = atom({
+    showAverage: false,
+    showCount: true,
+    showSum: false,
+    showMin: false,
+    showMax: false,
+    showNumericalCount: false,
+});
+export const useSheetStatusDisplay = () => useAtom(sheetStatusDisplayAtom);
+export const useSheetStatusDisplayValue = () => useAtomValue(sheetStatusDisplayAtom);

package/dist/esm/atoms/show-formula-help.atom.d.ts

@@ -0,0 +1,8 @@
+export declare const showFormulaHelpAtom: import("jotai").PrimitiveAtom<boolean> & {
+    init: boolean;
+};
+export declare const useShowFormulaHelp: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+export declare const useShowFormulaHelpValue: () => boolean;
+export declare const useOnHideFormulaHelp: () => () => void;
+export declare const useOnShowFormulaHelp: () => () => void;
+//# sourceMappingURL=show-formula-help.atom.d.ts.map

package/dist/esm/atoms/show-formula-help.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"show-formula-help.atom.d.ts","sourceRoot":"","sources":["../../../atoms/show-formula-help.atom.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB;;CAAa,CAAC;AAE9C,eAAO,MAAM,kBAAkB,2EAAqC,CAAC;AACrE,eAAO,MAAM,uBAAuB,eAA0C,CAAC;AAE/E,eAAO,MAAM,oBAAoB,kBAGhC,CAAC;AAEF,eAAO,MAAM,oBAAoB,kBAGhC,CAAC"}

package/dist/esm/atoms/show-formula-help.atom.js

@@ -0,0 +1,13 @@
+import { atom, useAtom, useAtomValue, useSetAtom } from "jotai";
+import { useCallback } from "react";
+export const showFormulaHelpAtom = atom(true);
+export const useShowFormulaHelp = () => useAtom(showFormulaHelpAtom);
+export const useShowFormulaHelpValue = () => useAtomValue(showFormulaHelpAtom);
+export const useOnHideFormulaHelp = () => {
+    const setShowFormulaHelp = useSetAtom(showFormulaHelpAtom);
+    return useCallback(() => setShowFormulaHelp(false), [setShowFormulaHelp]);
+};
+export const useOnShowFormulaHelp = () => {
+    const setShowFormulaHelp = useSetAtom(showFormulaHelpAtom);
+    return useCallback(() => setShowFormulaHelp(true), [setShowFormulaHelp]);
+};

package/dist/esm/atoms/sort-dialog.atom.d.ts

@@ -0,0 +1,22 @@
+import type { SortDialogColumn } from "../components/sort-range-dialog";
+import type { SortSpecs } from "../types";
+/**
+ * Open-state + payload for the multi-level Sort dialog. The filter box (which
+ * lives inside a popover that unmounts on close) opens the dialog by setting
+ * this atom; the dialog itself is host-mounted so it survives the popover
+ * closing. Mirrors the validation-alert atom pattern.
+ */
+export type SortDialogRequest = {
+    columns: SortDialogColumn[];
+    customLists?: string[][];
+    initialSpecs?: SortSpecs[];
+    /** Routed to `onSortTable` / `onSortRange` by the opener. */
+    onApply: (specs: SortSpecs[]) => void;
+};
+export declare const sortDialogAtom: import("jotai").PrimitiveAtom<SortDialogRequest | null> & {
+    init: SortDialogRequest | null;
+};
+export declare const useSortDialogState: () => [SortDialogRequest | null, (args_0: SortDialogRequest | ((prev: SortDialogRequest | null) => SortDialogRequest | null) | null) => void];
+/** Returns a function that opens the host-mounted Sort dialog. */
+export declare const useOpenSortDialog: () => (request: SortDialogRequest) => void;
+//# sourceMappingURL=sort-dialog.atom.d.ts.map

package/dist/esm/atoms/sort-dialog.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-dialog.atom.d.ts","sourceRoot":"","sources":["../../../atoms/sort-dialog.atom.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE,SAAS,EAAE,CAAC;IAC3B,6DAA6D;IAC7D,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,IAAI,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,cAAc;;CAAuC,CAAC;AAEnE,eAAO,MAAM,kBAAkB,+IAAgC,CAAC;AAEhE,kEAAkE;AAClE,eAAO,MAAM,iBAAiB,kBAGhB,iBAAiB,SAG9B,CAAC"}

package/dist/esm/atoms/sort-dialog.atom.js

@@ -0,0 +1,9 @@
+import { atom, useAtom, useSetAtom } from "jotai";
+import { useCallback } from "react";
+export const sortDialogAtom = atom(null);
+export const useSortDialogState = () => useAtom(sortDialogAtom);
+/** Returns a function that opens the host-mounted Sort dialog. */
+export const useOpenSortDialog = () => {
+    const setRequest = useSetAtom(sortDialogAtom);
+    return useCallback((request) => setRequest(request), [setRequest]);
+};

package/dist/esm/atoms/spreadsheet-api.atom.d.ts

@@ -0,0 +1,5 @@
+import type { SpreadsheetApi } from "../api/spreadsheet-api";
+import type { CellData } from "../types";
+export declare const useSpreadsheetApi: <T extends CellData>() => SpreadsheetApi<T> | undefined;
+export declare const useSetSpreadsheetApi: () => (args_0: SpreadsheetApi<any> | ((prev: SpreadsheetApi<any> | undefined) => SpreadsheetApi<any> | undefined) | undefined) => void;
+//# sourceMappingURL=spreadsheet-api.atom.d.ts.map

package/dist/esm/atoms/spreadsheet-api.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spreadsheet-api.atom.d.ts","sourceRoot":"","sources":["../../../atoms/spreadsheet-api.atom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAIzC,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,QAAQ,oCACa,CAAC;AAElE,eAAO,MAAM,oBAAoB,wIAAuC,CAAC"}