@odoo/o-spreadsheet 19.2.0-alpha.4 → 19.3.2

package/dist/types/registries/evaluation_registry.d.ts

@@ -0,0 +1,9 @@
+import { Getters } from "../types/getters";
+import { Registry } from "./registry";
+/**
+ * This registry is used to register functions that should be called after each iteration of the evaluation.
+ * This is use currently to mark the each pivot to be re-evaluated. We have to do this after each iteration
+ * to avoid to reload the data of the pivot at each function call (PIVOT.VALUE and PIVOT.HEADER). After each
+ * evaluation iteration, the pivot has to be re-evaluated during the next iteration.
+ */
+export declare const onIterationEndEvaluationRegistry: Registry<(getters: Getters) => void>;

package/dist/types/registries/figures_registry.d.ts

@@ -0,0 +1,19 @@
+import { Action } from "../actions/action";
+import { UID } from "../types";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+import { Registry } from "./registry";
+/**
+ * This registry is intended to map a type of figure (tag) to a class of
+ * component, that will be used in the UI to represent the figure.
+ *
+ * The most important type of figure will be the Chart
+ */
+export interface FigureContent {
+    Component: any;
+    menuBuilder: (figureId: UID, env: SpreadsheetChildEnv) => Action[];
+    SidePanelComponent?: string;
+    keepRatio?: boolean;
+    minFigSize?: number;
+    borderWidth?: number;
+}
+export declare const figureRegistry: Registry<FigureContent>;

package/dist/types/registries/icons_on_cell_registry.d.ts

@@ -0,0 +1,23 @@
+import { Getters } from "../types/getters";
+import { ImageSVG } from "../types/image";
+import { Align, CellPosition } from "../types/misc";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+import { Registry } from "./registry";
+export type IconsOfCell = Record<Exclude<Align, undefined>, GridIcon | undefined>;
+export interface GridIcon {
+    type: string;
+    position: CellPosition;
+    horizontalAlign: Exclude<Align, undefined>;
+    size: number;
+    margin: number;
+    svg?: ImageSVG;
+    hoverSvg?: ImageSVG;
+    priority: number;
+    onClick?: (position: CellPosition, env: SpreadsheetChildEnv) => void;
+}
+type ImageSvgCallback = (getters: Getters, position: CellPosition) => GridIcon | undefined;
+/**
+ * Registry to draw icons on cells
+ */
+export declare const iconsOnCellRegistry: Registry<ImageSvgCallback>;
+export {};

package/dist/types/registries/interactive_icon_on_cell_registry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/registries/inverse_command_registry.d.ts

@@ -0,0 +1,5 @@
+import { CoreCommand } from "../types/commands";
+import { Registry } from "./registry";
+type InverseFunction = (cmd: CoreCommand) => CoreCommand[];
+export declare const inverseCommandRegistry: Registry<InverseFunction>;
+export {};

package/dist/types/registries/menu_items_registry.d.ts

@@ -0,0 +1,21 @@
+import { Action, ActionBuilder, ActionSpec } from "../actions/action";
+import { Registry } from "./registry";
+/**
+ * The class Registry is extended in order to add the function addChild
+ *
+ */
+export declare class MenuItemRegistry extends Registry<ActionSpec> {
+    /**
+     * @override
+     */
+    replace(key: string, value: ActionSpec): this;
+    /**
+     * Add a subitem to an existing item
+     * @param path Path of items to add this subitem
+     * @param value Subitem to add
+     */
+    addChild(key: string, path: string[], value: ActionSpec | ActionBuilder): this;
+    replaceChild(key: string, path: string[], value: ActionSpec | ActionBuilder): this;
+    private _replaceChild;
+    getMenuItems(): Action[];
+}

package/dist/types/registries/menus/cell_menu_registry.d.ts

@@ -0,0 +1,2 @@
+import { MenuItemRegistry } from "../menu_items_registry";
+export declare const cellMenuRegistry: MenuItemRegistry;

package/dist/types/registries/menus/col_menu_registry.d.ts

@@ -0,0 +1,2 @@
+import { MenuItemRegistry } from "../menu_items_registry";
+export declare const colMenuRegistry: MenuItemRegistry;

package/dist/types/registries/menus/header_group_registry.d.ts

@@ -0,0 +1,7 @@
+import { Action } from "../../actions/action";
+import { Dimension, UID } from "../../types";
+import { MenuItemRegistry } from "../menu_items_registry";
+export declare function createHeaderGroupContainerContextMenu(sheetId: UID, dimension: Dimension): Action[];
+export declare function getHeaderGroupContextMenu(sheetId: UID, dimension: Dimension, start: number, end: number): Action[];
+export declare const groupHeadersMenuRegistry: MenuItemRegistry;
+export declare const unGroupHeadersMenuRegistry: MenuItemRegistry;

package/dist/types/registries/menus/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./cell_menu_registry";
+export * from "./col_menu_registry";
+export * from "./number_format_menu_registry";
+export * from "./row_menu_registry";
+export * from "./sheet_menu_registry";
+export * from "./topbar_menu_registry";

package/dist/types/registries/menus/number_format_menu_registry.d.ts

@@ -0,0 +1,7 @@
+import { ActionSpec } from "../../actions/action";
+import * as ACTION_FORMAT from "../../actions/format_actions";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { Registry } from "../registry";
+export declare const numberFormatMenuRegistry: Registry<ACTION_FORMAT.NumberFormatActionSpec>;
+export declare function getCustomNumberFormats(env: SpreadsheetChildEnv): ACTION_FORMAT.NumberFormatActionSpec[];
+export declare const formatNumberMenuItemSpec: ActionSpec;

package/dist/types/registries/menus/row_menu_registry.d.ts

@@ -0,0 +1,2 @@
+import { MenuItemRegistry } from "../menu_items_registry";
+export declare const rowMenuRegistry: MenuItemRegistry;

package/dist/types/registries/menus/sheet_menu_registry.d.ts

@@ -0,0 +1,5 @@
+import { MenuItemRegistry } from "../menu_items_registry";
+export declare function getSheetMenuRegistry(args: {
+    renameSheetCallback: () => void;
+    openSheetColorPickerCallback: () => void;
+}): MenuItemRegistry;

package/dist/types/registries/menus/table_style_menu_registry.d.ts

@@ -0,0 +1,3 @@
+import { Action } from "../../actions/action";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export declare function createTableStyleContextMenuActions(env: SpreadsheetChildEnv, styleId: string): Action[];

package/dist/types/registries/menus/topbar_menu_registry.d.ts

@@ -0,0 +1,2 @@
+import { MenuItemRegistry } from "../menu_items_registry";
+export declare const topbarMenuRegistry: MenuItemRegistry;

package/dist/types/registries/ot_registry.d.ts

@@ -0,0 +1,21 @@
+import { CoreCommand, CoreCommandTypes } from "../types/commands";
+import { Registry } from "./registry";
+export type TransformationFunction<U extends CoreCommandTypes, V extends CoreCommandTypes> = (toTransform: Extract<CoreCommand, {
+    type: U;
+}>, executed: Extract<CoreCommand, {
+    type: V;
+}>) => CoreCommand | undefined;
+export declare class OTRegistry extends Registry<Map<CoreCommandTypes, TransformationFunction<CoreCommandTypes, CoreCommandTypes>>> {
+    /**
+     * Add a transformation function to the registry. When the executed command
+     * happened, all the commands in toTransforms should be transformed using the
+     * transformation function given
+     */
+    addTransformation<U extends CoreCommandTypes, V extends CoreCommandTypes>(executed: U, toTransforms: V[], fn: TransformationFunction<CoreCommandTypes, CoreCommandTypes>): this;
+    /**
+     * Get the transformation function to transform the command toTransform, after
+     * that the executed command happened.
+     */
+    getTransformation<U extends CoreCommandTypes, V extends CoreCommandTypes>(toTransform: U, executed: V): TransformationFunction<CoreCommandTypes, CoreCommandTypes> | undefined;
+}
+export declare const otRegistry: OTRegistry;

package/dist/types/registries/registry.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Registry
+ *
+ * The Registry class is basically just a mapping from a string key to an object.
+ * It is really not much more than an object. It is however useful for the
+ * following reasons:
+ *
+ * 1. it let us react and execute code when someone add something to the registry
+ *   (for example, the FunctionRegistry subclass this for this purpose)
+ * 2. it throws an error when the get operation fails
+ * 3. it provides a chained API to add items to the registry.
+ */
+export declare class Registry<T> {
+    content: {
+        [key: string]: T;
+    };
+    /**
+     * Add an item to the registry, you can only add if there is no item
+     * already present in the registery with the given key
+     *
+     * Note that this also returns the registry, so another add method call can
+     * be chained
+     */
+    add(key: string, value: T): this;
+    /**
+     * Replace (or add) an item to the registry
+     *
+     * Note that this also returns the registry, so another add method call can
+     * be chained
+     */
+    replace(key: string, value: T): this;
+    /**
+     * Get an item from the registry
+     */
+    get(key: string): T;
+    /**
+     * Check if the key is already in the registry
+     */
+    contains(key: string): boolean;
+    /**
+     * Get a list of all elements in the registry
+     */
+    getAll(): T[];
+    /**
+     * Get a list of all keys in the registry
+     */
+    getKeys(): string[];
+    /**
+     * Remove an item from the registry
+     */
+    remove(key: string): void;
+}

package/dist/types/registries/repeat_commands_registry.d.ts

@@ -0,0 +1,3 @@
+import { Getters } from "../types";
+import { Command } from "../types/commands";
+export declare function genericRepeat<T extends Command>(getters: Getters, command: T): T;

package/dist/types/registries/repeat_transform_registry.d.ts

@@ -0,0 +1,18 @@
+import { CoreCommand, LocalCommand } from "../types/commands";
+import { Getters } from "../types/getters";
+import { Registry } from "./registry";
+type RepeatTransform = (getters: Getters, cmd: CoreCommand) => CoreCommand | undefined;
+type LocalRepeatTransform = (getters: Getters, cmd: LocalCommand, childCommands: readonly CoreCommand[]) => CoreCommand[] | LocalCommand | undefined;
+/**
+ *  Registry containing all the command that can be repeated on redo, and function to transform them
+ *  to the current state of the model.
+ *
+ * If the transform function is undefined, the command will be transformed using generic transformations.
+ * (change the sheetId, the row, the col, the target, the ranges, to the current active sheet & selection)
+ *
+ */
+export declare const repeatCommandTransformRegistry: Registry<RepeatTransform>;
+export declare const repeatLocalCommandTransformRegistry: Registry<LocalRepeatTransform>;
+export declare function repeatCoreCommand(getters: Getters, command: CoreCommand | undefined): CoreCommand | undefined;
+export declare function repeatLocalCommand(getters: Getters, command: LocalCommand, childCommands: readonly CoreCommand[]): CoreCommand[] | LocalCommand | undefined;
+export {};

package/dist/types/registries/side_panel_registry.d.ts

@@ -0,0 +1,15 @@
+import { SidePanelState } from "../components/side_panel/side_panel/side_panel_store";
+import { Getters } from "../types";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+import { Registry } from "./registry";
+export interface SidePanelContent {
+    title: string | ((env: SpreadsheetChildEnv, props: object) => string);
+    Body: any;
+    Footer?: any;
+    /**
+     * A callback used to validate the props or generate new props
+     * based on the current state of the spreadsheet model, using the getters.
+     */
+    computeState?: (getters: Getters, initialProps: object) => SidePanelState;
+}
+export declare const sidePanelRegistry: Registry<SidePanelContent>;

package/dist/types/registries/srt_registry.d.ts

@@ -0,0 +1,11 @@
+import { CoreCommand } from "../types/commands";
+import { RangeAdapterFunctions } from "../types/misc";
+import { Registry } from "./registry";
+type CommandAdaptRangeFunction<C extends CoreCommand> = (cmd: C, rangeAdapters: RangeAdapterFunctions) => C;
+declare class SpecificRangeTransformRegistry extends Registry<CommandAdaptRangeFunction<CoreCommand>> {
+    add<C extends CoreCommand>(cmdType: C["type"], fn: CommandAdaptRangeFunction<C>): this;
+    replace<C extends CoreCommand>(cmdType: C["type"], fn: CommandAdaptRangeFunction<C>): this;
+    get<C extends CoreCommand>(cmdType: C["type"]): CommandAdaptRangeFunction<CoreCommand>;
+}
+export declare const specificRangeTransformRegistry: SpecificRangeTransformRegistry;
+export {};

package/dist/types/registries/toolbar_menu_registry.d.ts

@@ -0,0 +1,19 @@
+import { ComponentConstructor } from "@odoo/owl";
+import { PropsOf } from "../types/props_of";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+type ToolBarItem<C extends ComponentConstructor = ComponentConstructor> = {
+    component: C;
+    props: PropsOf<C>;
+    sequence: number;
+    isVisible?: (env: SpreadsheetChildEnv) => boolean;
+};
+export declare class ToolBarRegistry {
+    content: {
+        [key: string]: ToolBarItem[];
+    };
+    add(key: string): this;
+    addChild(key: string, value: ToolBarItem): this;
+    getEntries(id: string): ToolBarItem[];
+    getCategories(): string[];
+}
+export {};

package/dist/types/registries/topbar_component_registry.d.ts

@@ -0,0 +1,20 @@
+import { UuidGenerator } from "../helpers";
+import { UID } from "../types";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+import { Registry } from "./registry";
+export interface TopbarComponent {
+    id: UID;
+    component: any;
+    isVisible?: (env: SpreadsheetChildEnv) => boolean;
+    sequence: number;
+}
+declare class TopBarComponentRegistry extends Registry<TopbarComponent> {
+    mapping: {
+        [key: string]: Function;
+    };
+    uuidGenerator: UuidGenerator;
+    replace(name: string, value: Omit<TopbarComponent, "id">): this;
+    getAllOrdered(): TopbarComponent[];
+}
+export declare const topbarComponentRegistry: TopBarComponentRegistry;
+export {};

package/dist/types/registry.d.ts

@@ -0,0 +1,10 @@
+export declare class Registry<T> {
+    content: Record<string, T>;
+    add(key: string, value: T): this;
+    replace(key: string, value: T): this;
+    get(key: string): T;
+    contains(key: string): boolean;
+    getAll(): T[];
+    getKeys(): string[];
+    remove(key: string): void;
+}

package/dist/types/selection_stream/event_stream.d.ts

@@ -0,0 +1,65 @@
+export interface StreamCallbacks<Event> {
+    handleEvent: (event: Event) => void;
+    /** this callback will only be called when another consumer captures the stream,
+     * not when the current consumer decides to release itself */
+    release?: () => void;
+}
+type Owner = unknown;
+/**
+ * Stateless sequence of events that can be processed by consumers.
+ *
+ * There are three kind of consumers:
+ * - the main consumer
+ * - the default consumer
+ * - observer consumers
+ *
+ * Main consumer
+ * -------------
+ * Anyone can capture the event stream and become the main consumer.
+ * If there is already a main consumer, it is kicked off and it will no longer
+ * receive events.
+ * The main consumer can release the stream at any moment to stop listening
+ * events.
+ *
+ * Default consumer
+ * ----------------
+ * When the main consumer releases the stream and until the stream is captured
+ * again, all events are transmitted to the default consumer.
+ *
+ * Observer consumers
+ * ------------------
+ * Observers permanently receive events.
+ *
+ */
+export declare class EventStream<Event> {
+    private observers;
+    /**
+     * the one we default to when someone releases the stream by themeselves
+     */
+    private defaultSubscription?;
+    private mainSubscription?;
+    registerAsDefault(owner: Owner, callbacks: StreamCallbacks<Event>): void;
+    /**
+     * Register callbacks to observe the stream
+     */
+    observe(owner: Owner, callbacks: StreamCallbacks<Event>): void;
+    unobserve(owner: Owner): void;
+    /**
+     * Capture the stream for yourself
+     */
+    capture(owner: Owner, callbacks: StreamCallbacks<Event>): void;
+    release(owner: Owner): void;
+    /**
+     * Release whichever subscription in charge and get back to the default subscription
+     */
+    getBackToDefault(): void;
+    /**
+     * Check if you are currently the main stream consumer
+     */
+    isListening(owner: Owner): boolean;
+    /**
+     * Push an event to the stream and broadcast it to consumers
+     */
+    send(event: Event): void;
+}
+export {};

package/dist/types/selection_stream/selection_stream_processor.d.ts

@@ -0,0 +1,138 @@
+import { DispatchResult } from "../types/commands";
+import { SelectionEvent, SelectionEventOptions } from "../types/event_stream";
+import { Getters } from "../types/getters";
+import { AnchorZone, Direction, HeaderIndex, SelectionStep } from "../types/misc";
+import { SelectionStreamProcessor } from "../types/selection_stream_processor";
+import { StreamCallbacks } from "./event_stream";
+/**
+ * Processes all selection updates (usually from user inputs) and emits an event
+ * with the new selected anchor
+ */
+export declare class SelectionStreamProcessorImpl implements SelectionStreamProcessor {
+    private getters;
+    private stream;
+    /**
+     * "Active" anchor used as a reference to compute new anchors
+     * An new initial value is given each time the stream is
+     * captured. The value is updated with each new anchor.
+     */
+    private anchor;
+    private defaultAnchor;
+    constructor(getters: Getters);
+    capture(owner: unknown, anchor: AnchorZone, callbacks: StreamCallbacks<SelectionEvent>): void;
+    /**
+     * Register as default subscriber and capture the event stream.
+     */
+    registerAsDefault(owner: unknown, anchor: AnchorZone, callbacks: StreamCallbacks<SelectionEvent>): void;
+    resetDefaultAnchor(owner: unknown, anchor: AnchorZone): void;
+    resetAnchor(owner: unknown, anchor: AnchorZone): void;
+    observe(owner: unknown, callbacks: StreamCallbacks<SelectionEvent>): void;
+    unobserve(owner: unknown): void;
+    release(owner: unknown): void;
+    getBackToDefault(): void;
+    private modifyAnchor;
+    /**
+     * Select a new anchor
+     */
+    selectZone(anchor: AnchorZone, options?: SelectionEventOptions): DispatchResult;
+    /**
+     * Select a single cell as the new anchor.
+     */
+    selectCell(col: HeaderIndex, row: HeaderIndex): DispatchResult;
+    /**
+     * Set the selection to one of the cells adjacent to the current anchor cell.
+     */
+    moveAnchorCell(direction: Direction, step?: SelectionStep): DispatchResult;
+    /**
+     * Update the anchor cell while keeping the current anchor zone unchanged.
+     */
+    updateAnchorCell(col: HeaderIndex, row: HeaderIndex, options?: SelectionEventOptions): DispatchResult;
+    /**
+     * Update the current anchor such that it includes the given
+     * cell position.
+     */
+    setAnchorCorner(col: HeaderIndex, row: HeaderIndex): DispatchResult;
+    /**
+     * Add a new cell to the current selection
+     */
+    addCellToSelection(col: HeaderIndex, row: HeaderIndex): DispatchResult;
+    /**
+     * Triggered on mouse up to finalize the selection.
+     * - If the current anchor zone already exists in the selection, it will be removed.
+     * - If the anchor zone overlaps with existing zones, it will be split into
+     *   multiple non-overlapping parts.
+     */
+    commitSelection(): DispatchResult;
+    /**
+     * Increase or decrease the size of the current anchor zone.
+     * The anchor cell remains where it is. It's the opposite side
+     * of the anchor zone which moves.
+     */
+    resizeAnchorZone(direction: Direction, step?: SelectionStep): DispatchResult;
+    selectColumn(index: HeaderIndex, mode: Exclude<SelectionEvent["mode"], "commitSelection">): DispatchResult;
+    selectRow(index: HeaderIndex, mode: Exclude<SelectionEvent["mode"], "commitSelection">): DispatchResult;
+    /**
+     * Loop the current selection while keeping the same anchor. The selection will loop through:
+     *  1) the smallest zone that contain the anchor and that have only empty cells bordering it
+     *  2) the whole sheet
+     *  3) the anchor cell
+     */
+    loopSelection(): DispatchResult;
+    /**
+     * Select a "table" around the current selection.
+     * We define a table by the smallest zone that contain the anchor and that have only empty
+     * cells bordering it
+     */
+    selectTableAroundSelection(): DispatchResult;
+    /**
+     * Select the entire sheet
+     */
+    selectAll(): DispatchResult;
+    isListening(owner: unknown): boolean;
+    /**
+     * Process a new anchor selection event. If the new anchor is inside
+     * the sheet boundaries, the event is pushed to the event stream to
+     * be processed.
+     */
+    private processEvent;
+    private checkEventAnchorZone;
+    private checkAnchorZone;
+    private checkAnchorZoneOrThrow;
+    /**
+     *  ---- PRIVATE ----
+     */
+    /** Computes the next cell position in the direction of deltaX and deltaY
+     * by crossing through merges and skipping hidden cells.
+     * Note that the resulting position might be out of the sheet, it needs to be validated.
+     */
+    private getNextAvailablePosition;
+    private getNextAvailableCol;
+    private getNextAvailableRow;
+    private getNextAvailableHeader;
+    /**
+     * Finds a visible cell in the currently selected zone starting with the anchor.
+     * If the anchor is hidden, browses from left to right and top to bottom to
+     * find a visible cell.
+     */
+    private getReferenceAnchor;
+    private deltaToTarget;
+    private getStartingPosition;
+    /**
+     * Given a starting position, compute the end of the cluster containing the position in the given
+     * direction or the start of the next cluster. We define cluster here as side-by-side cells that
+     * all have a content.
+     *
+     * We will return the end of the cluster if the given cell is inside a cluster, and the start of the
+     * next cluster if the given cell is outside a cluster or at the border of a cluster in the given direction.
+     */
+    private getEndOfCluster;
+    /** Computes the next cell position in the given direction by crossing through merges and skipping hidden cells.
+     *
+     * This has the same behaviour as getNextAvailablePosition() for certain arguments, but use this method instead
+     * inside directionToDelta(), which is called in getNextAvailablePosition(), to avoid possible infinite
+     * recursion.
+     */
+    private getNextCellPosition;
+    private getPosition;
+    private isCellSkippableInCluster;
+}

package/dist/types/state_observer.d.ts

@@ -0,0 +1,18 @@
+import { CoreCommand } from "./types/commands";
+import { HistoryChange } from "./types/history";
+type HistoryPath = [any, ...(number | string)[]];
+export declare class StateObserver {
+    private changes;
+    private commands;
+    /**
+     * Record the changes which could happen in the given callback, save them in a
+     * new revision with the given id and userId.
+     */
+    recordChanges(callback: () => void): {
+        changes: HistoryChange[];
+        commands: CoreCommand[];
+    };
+    addCommand(command: CoreCommand): void;
+    addChange(...args: [...HistoryPath, any]): void;
+}
+export {};

package/dist/types/store_engine/dependency_container.d.ts

@@ -0,0 +1,26 @@
+import { EventBus } from "../helpers/event_bus";
+import { StoreConstructor, StoreParams } from "../types/store_engine";
+interface StoreUpdateEvent {
+    type: "store-updated";
+}
+/**
+ * A type-safe dependency container
+ */
+export declare class DependencyContainer extends EventBus<StoreUpdateEvent> {
+    private dependencies;
+    private factory;
+    /**
+     * Injects a store instance in the dependency container.
+     * Useful for injecting an external store that is not created by the container.
+     * Also useful for mocking a store.
+     */
+    inject<T extends StoreConstructor>(Store: T, instance: InstanceType<T>): void;
+    /**
+     * Get an instance of a store.
+     */
+    get<T>(Store: StoreConstructor<T>): T;
+    instantiate<T>(Store: StoreConstructor<T>, ...args: StoreParams<StoreConstructor<T>>): T;
+    resetStores(): void;
+    dispose(): void;
+}
+export {};

package/dist/types/store_engine/index.d.ts

@@ -0,0 +1,4 @@
+export type { CQS, Disposable, Get, LocalStoreConstructor, NeverReturns, OmitFunctions, SkipFirst, Store, StoreConstructor, StoreParams, } from "../types/store_engine";
+export * from "./dependency_container";
+export * from "./store";
+export * from "./store_hooks";

package/dist/types/store_engine/store.d.ts

@@ -0,0 +1,20 @@
+import { Disposable, Get, StoreConstructor } from "../types/store_engine";
+/**
+ * Create a store to expose an external resource (which is not a store itself)
+ * to other stores.
+ * The external resource needs to be injected in the store provider to provide
+ * the store implementation.
+ *
+ * @example
+ * const MyMetaStore = createAbstractStore("MyStore");
+ * const stores = useStoreProvider();
+ * stores.inject(MyMetaStore, externalResourceInstance);
+ */
+export declare function createAbstractStore<T extends unknown>(storeName: string): StoreConstructor<T>;
+export declare class DisposableStore implements Disposable {
+    protected get: Get;
+    private disposeCallbacks;
+    constructor(get: Get);
+    protected onDispose(callback: () => void): void;
+    dispose(): void;
+}

package/dist/types/store_engine/store_hooks.d.ts

@@ -0,0 +1,18 @@
+import { LocalStoreConstructor, Store, StoreConstructor, StoreParams } from "../types/store_engine";
+import { DependencyContainer } from "./dependency_container";
+/**
+ * This hook should be used at the root of your app to provide the store container.
+ */
+export declare function useStoreProvider(): DependencyContainer;
+/**
+ * Get the instance of a store.
+ */
+export declare function useStore<T extends StoreConstructor>(Store: T): Store<InstanceType<T>>;
+export declare function useLocalStore<T extends LocalStoreConstructor<any>>(Store: T, ...args: StoreParams<T> extends never ? [] : StoreParams<T>): Store<InstanceType<T>>;
+/**
+ * Creates a proxied version of a store object with mutation tracking.
+ * Whenever a mutator method of the store is called, the provided callback function is invoked.
+ */
+export declare function proxifyStoreMutation<S extends {
+    mutators: readonly (keyof S)[];
+}>(store: S, callback: () => void): S;

package/dist/types/stores/DOM_focus_store.d.ts

@@ -0,0 +1,6 @@
+export declare class DOMFocusableElementStore {
+    mutators: readonly ["setFocusableElement", "focus"];
+    private focusableElement;
+    setFocusableElement(element: HTMLElement): string;
+    focus(): "noStateChange" | undefined;
+}

package/dist/types/stores/array_formula_highlight.d.ts

@@ -0,0 +1,9 @@
+import { Get } from "../store_engine";
+import { Highlight } from "../types";
+import { HighlightStore } from "./highlight_store";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export declare class ArrayFormulaHighlight extends SpreadsheetStore {
+    protected highlightStore: import("../store_engine").CQS<Pick<HighlightStore, "register" | "unRegister"> & import("../store_engine").OmitFunctions<HighlightStore>>;
+    constructor(get: Get);
+    get highlights(): Highlight[];
+}