@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/api/xlsx-source.js

@@ -0,0 +1,30 @@
+/**
+ * Helpers for managing the `xlsxSource` field on round-trippable rules
+ * (ConditionalFormatRule, DataValidationRule, DataValidationRuleRecord).
+ *
+ * The xlsx exporter prefers `xlsxSource` over the high-level `condition` /
+ * `booleanRule` representation when emitting a rule, which preserves the
+ * verbatim source-xlsx attributes (cfRule type, operator, formula text,
+ * `text`/`timePeriod`/`rank`/etc.). That fidelity is correct for rules that
+ * round-trip untouched, but stale once the user edits the rule — the exporter
+ * would otherwise emit the pre-edit attributes and the user's change would
+ * disappear from the saved file.
+ *
+ * Every mutation path that updates a rule's condition, formula, format, or
+ * range must call `dropXlsxSource` on the rule before storing it. The export
+ * then falls through to the synthesizer for that rule, which reads the
+ * current `condition`/`booleanRule`/etc. and emits a faithful (if more
+ * canonicalized) representation of the user's intent.
+ *
+ * Untouched rules keep their `xlsxSource` and round-trip with full fidelity.
+ */
+export const dropXlsxSource = (rule) => {
+    if (rule === null || typeof rule !== "object")
+        return rule;
+    const r = rule;
+    if (r.xlsxSource === undefined || r.xlsxSource === null) {
+        return rule;
+    }
+    const { xlsxSource: _drop, ...rest } = r;
+    return rest;
+};

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

@@ -0,0 +1,6 @@
+export declare const deleteSheetIdAtom: import("jotai").PrimitiveAtom<number | undefined> & {
+    init: number | undefined;
+};
+export declare const useSetDeleteSheetId: () => (args_0: number | ((prev: number | undefined) => number | undefined) | undefined) => void;
+export declare const useDeleteSheetId: () => [number | undefined, (args_0: number | ((prev: number | undefined) => number | undefined) | undefined) => void];
+//# sourceMappingURL=delete-sheet-atom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-sheet-atom.d.ts","sourceRoot":"","sources":["../../../atoms/delete-sheet-atom.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;CAAiB,CAAC;AAEhD,eAAO,MAAM,mBAAmB,iGAAsC,CAAC;AACvE,eAAO,MAAM,gBAAgB,uHAAmC,CAAC"}

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

@@ -0,0 +1,4 @@
+import { atom, useAtom, useSetAtom } from "jotai";
+export const deleteSheetIdAtom = atom();
+export const useSetDeleteSheetId = () => useSetAtom(deleteSheetIdAtom);
+export const useDeleteSheetId = () => useAtom(deleteSheetIdAtom);

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

@@ -0,0 +1,23 @@
+export declare const dialogStateAtom: import("jotai/vanilla/utils/atomFamily").AtomFamily<unknown, import("jotai").PrimitiveAtom<boolean> & {
+    init: boolean;
+}>;
+export declare const useEditTableDialogState: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+export declare const useSetEditTableDialogValue: () => (args_0: boolean | ((prev: boolean) => boolean)) => void;
+export declare const useDeletSheetConfirmationDialogState: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+export declare const useEditNamedRangeDialogState: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+export declare const useSetEditNamedRangeDialogState: () => (args_0: boolean | ((prev: boolean) => boolean)) => void;
+export declare const useEditEmbedDialogState: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+export declare const useSetEditEmbedDialogState: () => (args_0: boolean | ((prev: boolean) => boolean)) => void;
+export declare const useResizeDimensionDialogState: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+export declare const useSetResizeDimensionDialogState: () => (args_0: boolean | ((prev: boolean) => boolean)) => void;
+export declare const useFormatCellsDialogState: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+export declare const useSetFormatCellsDialogState: () => (args_0: boolean | ((prev: boolean) => boolean)) => void;
+export declare const useConditionalFormatDialogState: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+export declare const useSetConditionalFormatDialogState: () => (args_0: boolean | ((prev: boolean) => boolean)) => void;
+export declare const useInsertImageDialogState: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+export declare const useSetInsertImageDialogState: () => (args_0: boolean | ((prev: boolean) => boolean)) => void;
+export declare const useInsertLinkDialogState: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+export declare const useSetInsertLinkDialogState: () => (args_0: boolean | ((prev: boolean) => boolean)) => void;
+export declare const useDataValidationDialogState: () => [boolean, (args_0: boolean | ((prev: boolean) => boolean)) => void];
+export declare const useSetDataValidationDialogAState: () => (args_0: boolean | ((prev: boolean) => boolean)) => void;
+//# sourceMappingURL=dialog-state.atom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dialog-state.atom.d.ts","sourceRoot":"","sources":["../../../atoms/dialog-state.atom.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;EAAyC,CAAC;AAGtE,eAAO,MAAM,uBAAuB,2EACG,CAAC;AAExC,eAAO,MAAM,0BAA0B,gEACG,CAAC;AAG3C,eAAO,MAAM,oCAAoC,2EACR,CAAC;AAG1C,eAAO,MAAM,4BAA4B,2EACG,CAAC;AAE7C,eAAO,MAAM,+BAA+B,gEACG,CAAC;AAGhD,eAAO,MAAM,uBAAuB,2EACG,CAAC;AAExC,eAAO,MAAM,0BAA0B,gEACG,CAAC;AAG3C,eAAO,MAAM,6BAA6B,2EACG,CAAC;AAE9C,eAAO,MAAM,gCAAgC,gEACG,CAAC;AAGjD,eAAO,MAAM,yBAAyB,2EACG,CAAC;AAE1C,eAAO,MAAM,4BAA4B,gEACG,CAAC;AAG7C,eAAO,MAAM,+BAA+B,2EACG,CAAC;AAEhD,eAAO,MAAM,kCAAkC,gEACG,CAAC;AAGnD,eAAO,MAAM,yBAAyB,2EACG,CAAC;AAE1C,eAAO,MAAM,4BAA4B,gEACG,CAAC;AAG7C,eAAO,MAAM,wBAAwB,2EACG,CAAC;AAEzC,eAAO,MAAM,2BAA2B,gEACG,CAAC;AAG5C,eAAO,MAAM,4BAA4B,2EACG,CAAC;AAE7C,eAAO,MAAM,gCAAgC,gEACE,CAAC"}

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

@@ -0,0 +1,34 @@
+import { atom } from "jotai";
+import { useAtom, useSetAtom } from "jotai";
+import { atomFamily } from "jotai/utils";
+// Define the base atomFamily for dialog states
+export const dialogStateAtom = atomFamily(() => atom(false));
+// Edit Table Dialog
+export const useEditTableDialogState = () => useAtom(dialogStateAtom("editTable"));
+export const useSetEditTableDialogValue = () => useSetAtom(dialogStateAtom("editTable"));
+// Delete Sheet Confirmation Dialog
+export const useDeletSheetConfirmationDialogState = () => useAtom(dialogStateAtom("deleteSheet"));
+// Edit Named Range Dialog
+export const useEditNamedRangeDialogState = () => useAtom(dialogStateAtom("editNamedRange"));
+export const useSetEditNamedRangeDialogState = () => useSetAtom(dialogStateAtom("editNamedRange"));
+// Edit Embed Dialog
+export const useEditEmbedDialogState = () => useAtom(dialogStateAtom("editEmbed"));
+export const useSetEditEmbedDialogState = () => useSetAtom(dialogStateAtom("editEmbed"));
+// Resize Dimension Dialog
+export const useResizeDimensionDialogState = () => useAtom(dialogStateAtom("resizeDimension"));
+export const useSetResizeDimensionDialogState = () => useSetAtom(dialogStateAtom("resizeDimension"));
+// Format Cells Dialog
+export const useFormatCellsDialogState = () => useAtom(dialogStateAtom("formatCells"));
+export const useSetFormatCellsDialogState = () => useSetAtom(dialogStateAtom("formatCells"));
+// Conditional Format Dialog
+export const useConditionalFormatDialogState = () => useAtom(dialogStateAtom("conditionalFormat"));
+export const useSetConditionalFormatDialogState = () => useSetAtom(dialogStateAtom("conditionalFormat"));
+// Insert Image Dialog
+export const useInsertImageDialogState = () => useAtom(dialogStateAtom("insertImage"));
+export const useSetInsertImageDialogState = () => useSetAtom(dialogStateAtom("insertImage"));
+// Insert Link Dialog
+export const useInsertLinkDialogState = () => useAtom(dialogStateAtom("insertLink"));
+export const useSetInsertLinkDialogState = () => useSetAtom(dialogStateAtom("insertLink"));
+// Data Validation Dialog
+export const useDataValidationDialogState = () => useAtom(dialogStateAtom("dataValidation"));
+export const useSetDataValidationDialogAState = () => useSetAtom(dialogStateAtom("dataValidation"));

package/dist/esm/atoms/editing-data-validation-id.atom.d.ts

@@ -0,0 +1,7 @@
+export declare const editingDataValidationId: import("jotai").PrimitiveAtom<string | number | undefined> & {
+    init: string | number | undefined;
+};
+export declare const useEditingDataValidationIdValue: () => string | number | undefined;
+export declare const useSetEditingDataValidationId: () => (args_0: string | number | ((prev: string | number | undefined) => string | number | undefined) | undefined) => void;
+export declare const useEditingDataValidationIdState: () => [string | number | undefined, (args_0: string | number | ((prev: string | number | undefined) => string | number | undefined) | undefined) => void];
+//# sourceMappingURL=editing-data-validation-id.atom.d.ts.map

package/dist/esm/atoms/editing-data-validation-id.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editing-data-validation-id.atom.d.ts","sourceRoot":"","sources":["../../../atoms/editing-data-validation-id.atom.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,uBAAuB;;CAExB,CAAC;AAEb,eAAO,MAAM,+BAA+B,mCACL,CAAC;AAExC,eAAO,MAAM,6BAA6B,4HACL,CAAC;AAEtC,eAAO,MAAM,+BAA+B,2JACV,CAAC"}

package/dist/esm/atoms/editing-data-validation-id.atom.js

@@ -0,0 +1,6 @@
+import { atom } from "jotai";
+import { useAtom, useAtomValue, useSetAtom } from "jotai";
+export const editingDataValidationId = atom(undefined);
+export const useEditingDataValidationIdValue = () => useAtomValue(editingDataValidationId);
+export const useSetEditingDataValidationId = () => useSetAtom(editingDataValidationId);
+export const useEditingDataValidationIdState = () => useAtom(editingDataValidationId);

package/dist/esm/atoms/editing-embed.atom.d.ts

@@ -0,0 +1,8 @@
+import type { EmbeddedObject } from "@rowsncolumns/spreadsheet";
+export declare const editingEmbedAtom: import("jotai").PrimitiveAtom<EmbeddedObject | undefined> & {
+    init: EmbeddedObject | undefined;
+};
+export declare const useEditingEmbed: () => EmbeddedObject | undefined;
+export declare const useSetEditingEmbed: () => (args_0: EmbeddedObject | ((prev: EmbeddedObject | undefined) => EmbeddedObject | undefined) | undefined) => void;
+export declare const useEditingEmbedState: () => [EmbeddedObject | undefined, (args_0: EmbeddedObject | ((prev: EmbeddedObject | undefined) => EmbeddedObject | undefined) | undefined) => void];
+//# sourceMappingURL=editing-embed.atom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editing-embed.atom.d.ts","sourceRoot":"","sources":["../../../atoms/editing-embed.atom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAGhE,eAAO,MAAM,gBAAgB;;CAA8C,CAAC;AAE5E,eAAO,MAAM,eAAe,kCAAuC,CAAC;AACpE,eAAO,MAAM,kBAAkB,yHAAqC,CAAC;AACrE,eAAO,MAAM,oBAAoB,uJAAkC,CAAC"}

package/dist/esm/atoms/editing-embed.atom.js

@@ -0,0 +1,5 @@
+import { atom, useAtom, useAtomValue, useSetAtom } from "jotai";
+export const editingEmbedAtom = atom(undefined);
+export const useEditingEmbed = () => useAtomValue(editingEmbedAtom);
+export const useSetEditingEmbed = () => useSetAtom(editingEmbedAtom);
+export const useEditingEmbedState = () => useAtom(editingEmbedAtom);

package/dist/esm/atoms/editing-table.atom.d.ts

@@ -0,0 +1,8 @@
+import type { TableView } from "@rowsncolumns/spreadsheet";
+export declare const editingTableAtom: import("jotai").PrimitiveAtom<TableView | undefined> & {
+    init: TableView | undefined;
+};
+export declare const useEditingTable: () => TableView | undefined;
+export declare const useSetEditingTable: () => (args_0: TableView | ((prev: TableView | undefined) => TableView | undefined) | undefined) => void;
+export declare const useEditingTableState: () => [TableView | undefined, (args_0: TableView | ((prev: TableView | undefined) => TableView | undefined) | undefined) => void];
+//# sourceMappingURL=editing-table.atom.d.ts.map

package/dist/esm/atoms/editing-table.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editing-table.atom.d.ts","sourceRoot":"","sources":["../../../atoms/editing-table.atom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAI3D,eAAO,MAAM,gBAAgB;;CAAyC,CAAC;AAEvE,eAAO,MAAM,eAAe,6BAAuC,CAAC;AACpE,eAAO,MAAM,kBAAkB,0GAAqC,CAAC;AACrE,eAAO,MAAM,oBAAoB,mIAAkC,CAAC"}

package/dist/esm/atoms/editing-table.atom.js

@@ -0,0 +1,6 @@
+import { atom } from "jotai";
+import { useAtom, useAtomValue, useSetAtom } from "jotai";
+export const editingTableAtom = atom(undefined);
+export const useEditingTable = () => useAtomValue(editingTableAtom);
+export const useSetEditingTable = () => useSetAtom(editingTableAtom);
+export const useEditingTableState = () => useAtom(editingTableAtom);

package/dist/esm/atoms/error-state.atom.d.ts

@@ -0,0 +1,10 @@
+export type ErrorState = {
+    title?: string;
+    message: string;
+};
+export declare const errorStateAtom: import("jotai").PrimitiveAtom<ErrorState | undefined> & {
+    init: ErrorState | undefined;
+};
+export declare const useErrorState: () => [ErrorState | undefined, (args_0: ErrorState | ((prev: ErrorState | undefined) => ErrorState | undefined) | undefined) => void];
+export declare const useShowError: () => (args_0: ErrorState | ((prev: ErrorState | undefined) => ErrorState | undefined) | undefined) => void;
+//# sourceMappingURL=error-state.atom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error-state.atom.d.ts","sourceRoot":"","sources":["../../../atoms/error-state.atom.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,cAAc;;CAA0C,CAAC;AAEtE,eAAO,MAAM,aAAa,uIAAgC,CAAC;AAC3D,eAAO,MAAM,YAAY,6GAAmC,CAAC"}

package/dist/esm/atoms/error-state.atom.js

@@ -0,0 +1,5 @@
+import { atom } from "jotai";
+import { useAtom, useSetAtom } from "jotai";
+export const errorStateAtom = atom(undefined);
+export const useErrorState = () => useAtom(errorStateAtom);
+export const useShowError = () => useSetAtom(errorStateAtom);

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

@@ -0,0 +1,5 @@
+export * from "./error-state.atom";
+export * from "./dialog-state.atom";
+export * from "./editing-embed.atom";
+export * from "./sheet-observer.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,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC"}

package/dist/esm/atoms/index.js

@@ -0,0 +1,4 @@
+export * from "./error-state.atom";
+export * from "./dialog-state.atom";
+export * from "./editing-embed.atom";
+export * from "./sheet-observer.atom";

package/dist/esm/atoms/insert-image-state.atom.d.ts

@@ -0,0 +1,6 @@
+export declare const insertImageOverCellsStateAtom: import("jotai").PrimitiveAtom<boolean | undefined> & {
+    init: boolean | undefined;
+};
+export declare const useInsertImageOverCellsState: () => boolean | undefined;
+export declare const useSetInsertImageOverCellsState: () => (args_0: boolean | ((prev: boolean | undefined) => boolean | undefined) | undefined) => void;
+//# sourceMappingURL=insert-image-state.atom.d.ts.map

package/dist/esm/atoms/insert-image-state.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-image-state.atom.d.ts","sourceRoot":"","sources":["../../../atoms/insert-image-state.atom.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,6BAA6B;;CAAmC,CAAC;AAE9E,eAAO,MAAM,4BAA4B,2BACI,CAAC;AAE9C,eAAO,MAAM,+BAA+B,oGACD,CAAC"}

package/dist/esm/atoms/insert-image-state.atom.js

@@ -0,0 +1,5 @@
+import { atom } from "jotai";
+import { useAtomValue, useSetAtom } from "jotai";
+export const insertImageOverCellsStateAtom = atom(false);
+export const useInsertImageOverCellsState = () => useAtomValue(insertImageOverCellsStateAtom);
+export const useSetInsertImageOverCellsState = () => useSetAtom(insertImageOverCellsStateAtom);

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

@@ -0,0 +1,8 @@
+import type { NamedRange } from "@rowsncolumns/spreadsheet";
+export declare const editingNamedRange: import("jotai").PrimitiveAtom<NamedRange | undefined> & {
+    init: NamedRange | undefined;
+};
+export declare const useEditingNamedRange: () => NamedRange | undefined;
+export declare const useSetEditingNamedRange: () => (args_0: NamedRange | ((prev: NamedRange | undefined) => NamedRange | undefined) | undefined) => void;
+export declare const useEditingNamedRangeState: () => [NamedRange | undefined, (args_0: NamedRange | ((prev: NamedRange | undefined) => NamedRange | undefined) | undefined) => void];
+//# sourceMappingURL=named-range.atom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"named-range.atom.d.ts","sourceRoot":"","sources":["../../../atoms/named-range.atom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAI5D,eAAO,MAAM,iBAAiB;;CAA0C,CAAC;AAEzE,eAAO,MAAM,oBAAoB,8BAAwC,CAAC;AAC1E,eAAO,MAAM,uBAAuB,6GAAsC,CAAC;AAC3E,eAAO,MAAM,yBAAyB,uIAAmC,CAAC"}

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

@@ -0,0 +1,6 @@
+import { atom } from "jotai";
+import { useAtom, useAtomValue, useSetAtom } from "jotai";
+export const editingNamedRange = atom(undefined);
+export const useEditingNamedRange = () => useAtomValue(editingNamedRange);
+export const useSetEditingNamedRange = () => useSetAtom(editingNamedRange);
+export const useEditingNamedRangeState = () => useAtom(editingNamedRange);

package/dist/esm/atoms/resize-dimension.atom.d.ts

@@ -0,0 +1,12 @@
+import type { AXIS } from "@rowsncolumns/spreadsheet";
+export type ResizeDimensionState = {
+    sheetId: number;
+    axis: AXIS;
+    indexes: number[];
+};
+export declare const resizeDimensionAtom: import("jotai").PrimitiveAtom<ResizeDimensionState | undefined> & {
+    init: ResizeDimensionState | undefined;
+};
+export declare const useResizeDimensionValue: () => ResizeDimensionState | undefined;
+export declare const useSetResizeDimension: () => (args_0: ResizeDimensionState | ((prev: ResizeDimensionState | undefined) => ResizeDimensionState | undefined) | undefined) => void;
+//# sourceMappingURL=resize-dimension.atom.d.ts.map

package/dist/esm/atoms/resize-dimension.atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-dimension.atom.d.ts","sourceRoot":"","sources":["../../../atoms/resize-dimension.atom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAItD,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,IAAI,CAAC;IACX,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,mBAAmB;;CAE/B,CAAC;AAEF,eAAO,MAAM,uBAAuB,wCAA0C,CAAC;AAE/E,eAAO,MAAM,qBAAqB,2IAAwC,CAAC"}

package/dist/esm/atoms/resize-dimension.atom.js

@@ -0,0 +1,5 @@
+import { atom } from "jotai";
+import { useAtomValue, useSetAtom } from "jotai";
+export const resizeDimensionAtom = atom(undefined);
+export const useResizeDimensionValue = () => useAtomValue(resizeDimensionAtom);
+export const useSetResizeDimension = () => useSetAtom(resizeDimensionAtom);

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

@@ -0,0 +1,16 @@
+import type { CellCoordinate, CellCoordinateRange, StaticNode, StaticReference } from "@rowsncolumns/dag";
+import { Subject } from "rxjs";
+export type UseSheetObserverProps = {
+    onAddStaticReference(source: StaticReference, sourcePosition: CellCoordinate | CellCoordinateRange): void;
+    onRemoveStaticReference(source: StaticReference): void;
+};
+/**
+ * Simple wrapper over rxjs subject
+ */
+export declare class SheetObserver extends Subject<StaticNode> {
+    onAddStaticReference?: (source: StaticReference, sourcePosition: CellCoordinate | CellCoordinateRange) => void;
+    onRemoveStaticReference?: (source: StaticReference) => void;
+    constructor(props?: UseSheetObserverProps);
+}
+export declare const useSheetObserverValue: () => SheetObserver;
+//# sourceMappingURL=sheet-observer.atom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sheet-observer.atom.d.ts","sourceRoot":"","sources":["../../../atoms/sheet-observer.atom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACnB,UAAU,EACV,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B,MAAM,MAAM,qBAAqB,GAAG;IAClC,oBAAoB,CAClB,MAAM,EAAE,eAAe,EACvB,cAAc,EAAE,cAAc,GAAG,mBAAmB,GACnD,IAAI,CAAC;IACR,uBAAuB,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC;CACxD,CAAC;AAEF;;GAEG;AACH,qBAAa,aAAc,SAAQ,OAAO,CAAC,UAAU,CAAC;IACpD,oBAAoB,CAAC,EAAE,CACrB,MAAM,EAAE,eAAe,EACvB,cAAc,EAAE,cAAc,GAAG,mBAAmB,KACjD,IAAI,CAAC;IACV,uBAAuB,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;gBAChD,KAAK,CAAC,EAAE,qBAAqB;CAK1C;AAID,eAAO,MAAM,qBAAqB,qBAAwC,CAAC"}

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

@@ -0,0 +1,16 @@
+import { atom, useAtomValue } from "jotai";
+import { Subject } from "rxjs";
+/**
+ * Simple wrapper over rxjs subject
+ */
+export class SheetObserver extends Subject {
+    onAddStaticReference;
+    onRemoveStaticReference;
+    constructor(props) {
+        super();
+        this.onAddStaticReference = props?.onAddStaticReference;
+        this.onRemoveStaticReference = props?.onRemoveStaticReference;
+    }
+}
+const sheetObserverAtom = atom(new SheetObserver());
+export const useSheetObserverValue = () => useAtomValue(sheetObserverAtom);

package/dist/esm/cellxfs-registry.d.ts

@@ -0,0 +1,37 @@
+import type { CellFormat, StyleReference } from "@rowsncolumns/spreadsheet";
+import type { Patch } from "immer";
+import type { Dispatch, SetStateAction } from "react";
+import type { SheetCell } from "./sheet-cell";
+import type { CellXfs } from "./types";
+import type { SpreadsheetPatch } from "./hooks/use-undo-redo";
+export declare class CellXfsRegistry {
+    readonly onChangeCellXfs?: Dispatch<SetStateAction<CellXfs | undefined | null>> | undefined;
+    incomingCellXfs: CellXfs;
+    cellXfs: CellXfs | undefined | null;
+    private cellXfsUsage;
+    private pendingRemovals;
+    private processedFormats;
+    constructor(cellXfs?: CellXfs | null, onChangeCellXfs?: Dispatch<SetStateAction<CellXfs | undefined | null>> | undefined);
+    /**
+     * Check if cellXfs registry is active
+     */
+    get active(): boolean;
+    registerCellXfs(sheetCell: SheetCell): void;
+    /**
+     * Unregister a cell and remove unused cellXfs
+     */
+    unRegister(sheetCell: SheetCell): void;
+    /**
+     * Remove a cell from cellXfs usage tracking
+     */
+    private removeCellXfsUsage;
+    /**
+     * Track that a cell is using a specific cellXfs
+     */
+    private trackCellXfsUsage;
+    getCellXfsKey(cellFormat: CellFormat | undefined | null): string;
+    setCellXfs(cellXfs: CellXfs | undefined | null): void;
+    getCellXfsFromStyleId(styleId: StyleReference["styleId"]): import("@rowsncolumns/common-types").CellFormat | null | undefined;
+    getPatches(saveHistory?: (patches: SpreadsheetPatch<Patch>) => void): void;
+}
+//# sourceMappingURL=cellxfs-registry.d.ts.map

package/dist/esm/cellxfs-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cellxfs-registry.d.ts","sourceRoot":"","sources":["../../cellxfs-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE5E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAGnC,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAEtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,qBAAa,eAAe;IAYxB,QAAQ,CAAC,eAAe,CAAC,EAAE,QAAQ,CACjC,cAAc,CAAC,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC,CAC3C;IAbH,eAAe,EAAE,OAAO,CAAC;IACzB,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC;IAEpC,OAAO,CAAC,YAAY,CAAuC;IAE3D,OAAO,CAAC,eAAe,CAA0B;IAEjD,OAAO,CAAC,gBAAgB,CAA0B;gBAGhD,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,EACf,eAAe,CAAC,EAAE,QAAQ,CACjC,cAAc,CAAC,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC,CAC3C,YAAA;IAMH;;OAEG;IACH,IAAI,MAAM,YAET;IAED,eAAe,CAAC,SAAS,EAAE,SAAS;IA8BpC;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,SAAS;IAkB/B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAa1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAOzB,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,GAAG,IAAI;IAIvD,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI;IAI9C,qBAAqB,CAAC,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC;IAMxD,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,IAAI;CAiDpE"}

package/dist/esm/cellxfs-registry.js

@@ -0,0 +1,147 @@
+import { getCellXfsKey, getStyleId, isNil } from "@rowsncolumns/utils";
+import { produceWithPatches } from "immer";
+import cloneDeep from "lodash/cloneDeep";
+import { isStyleReference } from "./sheet-cell";
+export class CellXfsRegistry {
+    onChangeCellXfs;
+    incomingCellXfs;
+    cellXfs;
+    // Track which cells are using which cellXfs keys
+    cellXfsUsage = new Map();
+    // Track pending removals
+    pendingRemovals = new Set();
+    // Cache processed formats within the same operation to avoid redundant processing
+    processedFormats = new Set();
+    constructor(cellXfs, onChangeCellXfs) {
+        this.onChangeCellXfs = onChangeCellXfs;
+        this.cellXfs = cellXfs;
+        this.incomingCellXfs = new Map();
+    }
+    /**
+     * Check if cellXfs registry is active
+     */
+    get active() {
+        return !!this.cellXfs;
+    }
+    registerCellXfs(sheetCell) {
+        let uf = sheetCell.getUserEnteredFormat();
+        let ef = sheetCell.getEffectiveCellFormat();
+        const cellKey = sheetCell.key;
+        if (!isStyleReference(uf) && !isNil(uf)) {
+            const ufKey = getCellXfsKey(uf);
+            // Only process if we haven't seen this format key in this operation
+            if (!this.processedFormats.has(ufKey)) {
+                // to prevent TypeError: Cannot perform 'get' on a proxy that has been revoked
+                uf = cloneDeep(uf);
+                this.incomingCellXfs.set(ufKey, uf);
+                this.processedFormats.add(ufKey);
+            }
+            this.trackCellXfsUsage(ufKey, cellKey);
+        }
+        if (!isStyleReference(ef) && !isNil(ef)) {
+            const efKey = getCellXfsKey(ef);
+            // Only process if we haven't seen this format key in this operation
+            if (!this.processedFormats.has(efKey)) {
+                // to prevent TypeError: Cannot perform 'get' on a proxy that has been revoked
+                ef = cloneDeep(ef);
+                this.incomingCellXfs.set(efKey, ef);
+                this.processedFormats.add(efKey);
+            }
+            this.trackCellXfsUsage(efKey, cellKey);
+        }
+    }
+    /**
+     * Unregister a cell and remove unused cellXfs
+     */
+    unRegister(sheetCell) {
+        const cellKey = sheetCell.key;
+        const uf = sheetCell.getUserEnteredFormat();
+        const ef = sheetCell.getEffectiveCellFormat();
+        // Remove cell from usage tracking for user entered format
+        if (isStyleReference(uf)) {
+            const ufKey = getStyleId(uf);
+            this.removeCellXfsUsage(ufKey, cellKey);
+        }
+        // Remove cell from usage tracking for effective format
+        if (isStyleReference(ef)) {
+            const efKey = getStyleId(ef);
+            this.removeCellXfsUsage(efKey, cellKey);
+        }
+    }
+    /**
+     * Remove a cell from cellXfs usage tracking
+     */
+    removeCellXfsUsage(cellXfsKey, cellKey) {
+        const usageSet = this.cellXfsUsage.get(cellXfsKey);
+        if (usageSet) {
+            usageSet.delete(cellKey);
+            // If no cells are using this cellXfs anymore, mark it for removal
+            if (usageSet.size === 0) {
+                this.cellXfsUsage.delete(cellXfsKey);
+                this.pendingRemovals.add(cellXfsKey);
+            }
+        }
+    }
+    /**
+     * Track that a cell is using a specific cellXfs
+     */
+    trackCellXfsUsage(cellXfsKey, cellKey) {
+        if (!this.cellXfsUsage.has(cellXfsKey)) {
+            this.cellXfsUsage.set(cellXfsKey, new Set());
+        }
+        this.cellXfsUsage.get(cellXfsKey).add(cellKey);
+    }
+    getCellXfsKey(cellFormat) {
+        return getCellXfsKey(cellFormat);
+    }
+    setCellXfs(cellXfs) {
+        this.cellXfs = cellXfs;
+    }
+    getCellXfsFromStyleId(styleId) {
+        if (!styleId)
+            return undefined;
+        const format = this.cellXfs?.get(styleId);
+        return format ? cloneDeep(format) : format;
+    }
+    getPatches(saveHistory) {
+        // User is not using cellXfs registry
+        if (!this.cellXfs) {
+            return;
+        }
+        // Exit early
+        if (this.incomingCellXfs.size === 0 && this.pendingRemovals.size === 0) {
+            return;
+        }
+        // Capture the data before any async operations
+        const incomingCellXfs = new Map(this.incomingCellXfs);
+        const pendingRemovals = new Set(this.pendingRemovals);
+        this.onChangeCellXfs?.((prev) => {
+            // Add validation for prev
+            if (!prev || !(prev instanceof Map)) {
+                return prev || new Map(); // Return a fallback
+            }
+            const [nextState, patches, inversePatches] = produceWithPatches(prev, (draft) => {
+                // Add new cellXfs from captured data
+                // Skip keys already present — same key implies same format payload,
+                // so re-setting would emit a no-op replace patch.
+                for (const [key, value] of incomingCellXfs) {
+                    if (!draft.has(key)) {
+                        draft.set(key, value);
+                    }
+                }
+                // Remove unused cellXfs from captured data
+                for (const keyToRemove of pendingRemovals) {
+                    draft.delete(keyToRemove);
+                }
+                // Clear immediately after the onChangeCellXfs call
+                this.incomingCellXfs.clear();
+                this.pendingRemovals.clear();
+                this.processedFormats.clear();
+            });
+            saveHistory?.({
+                cellXfs: { patches, inversePatches },
+            });
+            return nextState;
+        });
+    }
+}