@odoo/o-spreadsheet 18.0.55 → 18.0.68

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
+     */
+    add(key: string, value: ActionSpec): MenuItemRegistry;
+    /**
+     * 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, options?: {
+        force: boolean;
+    }): MenuItemRegistry;
+    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,7 @@
+export * from "./cell_menu_registry";
+export * from "./col_menu_registry";
+export * from "./link_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/link_menu_registry.d.ts

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

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";
+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/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";
+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,44 @@
+/**
+ * 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
+     *
+     * Note that this also returns the registry, so another add method call can
+     * be chained
+     */
+    add(key: string, value: T): Registry<T>;
+    /**
+     * 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,19 @@
+import { CoreCommand, Getters } from "../types";
+import { Command, LocalCommand } from "./../types/commands";
+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 genericRepeat<T extends Command>(getters: Getters, command: T): T;
+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,14 @@
+import { SidePanelState } from "../components/side_panel/side_panel/side_panel_store";
+import { Getters, SpreadsheetChildEnv } from "../types";
+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/side_panel_registry_entries.d.ts

@@ -0,0 +1 @@
+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/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;
+    add(name: string, value: Omit<TopbarComponent, "id">): Registry<TopbarComponent>;
+    getAllOrdered(): TopbarComponent[];
+}
+export declare const topbarComponentRegistry: TopBarComponentRegistry;
+export {};

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;
+    detachObserver(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,154 @@
+import { AnchorZone, Direction, DispatchResult, Getters, SelectionStep } from "../types";
+import { SelectionEvent, SelectionEventOptions } from "../types/event_stream";
+import { HeaderIndex } from "./../types/misc";
+import { StreamCallbacks } from "./event_stream";
+type StatefulStream<Event, State> = {
+    capture(owner: unknown, state: State, callbacks: StreamCallbacks<Event>): void;
+    registerAsDefault: (owner: unknown, state: State, callbacks: StreamCallbacks<Event>) => void;
+    resetDefaultAnchor: (owner: unknown, state: State) => void;
+    resetAnchor: (owner: unknown, state: State) => void;
+    observe: (owner: unknown, callbacks: StreamCallbacks<Event>) => void;
+    detachObserver: (owner: unknown) => void;
+    release: (owner: unknown) => void;
+    getBackToDefault(): void;
+};
+/**
+ * Allows to select cells in the grid and update the selection
+ */
+interface SelectionProcessor {
+    selectZone(anchor: AnchorZone, options?: SelectionEventOptions): DispatchResult;
+    selectCell(col: number, row: number): DispatchResult;
+    moveAnchorCell(direction: Direction, step: SelectionStep): DispatchResult;
+    setAnchorCorner(col: number, row: number): DispatchResult;
+    addCellToSelection(col: number, row: number): DispatchResult;
+    resizeAnchorZone(direction: Direction, step: SelectionStep): DispatchResult;
+    selectColumn(index: number, mode: SelectionEvent["mode"]): DispatchResult;
+    selectRow(index: number, mode: SelectionEvent["mode"]): DispatchResult;
+    selectAll(): DispatchResult;
+    loopSelection(): DispatchResult;
+    selectTableAroundSelection(): DispatchResult;
+    isListening(owner: unknown): boolean;
+}
+export type SelectionStreamProcessor = SelectionProcessor & StatefulStream<SelectionEvent, AnchorZone>;
+/**
+ * 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;
+    detachObserver(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 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;
+    /**
+     * 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: SelectionEvent["mode"]): DispatchResult;
+    selectRow(index: HeaderIndex, mode: SelectionEvent["mode"]): 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;
+}
+export {};

package/dist/types/state_observer.d.ts

@@ -0,0 +1,17 @@
+import { CoreCommand, HistoryChange } from "./types";
+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,25 @@
+import { EventBus } from "../helpers/event_bus";
+import { StoreConstructor, StoreParams } from "./store";
+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;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export * from "./dependency_container";
+export * from "./store";
+export * from "./store_hooks";

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

@@ -0,0 +1,72 @@
+/**
+ * An injectable store constructor
+ */
+export interface StoreConstructor<T = any, A extends unknown[] = any[]> {
+    new (get: Get, ...args: A): T;
+}
+/**
+ * A store constructor for a store that implements the Disposable interface.
+ * Useful for local stores that need to be disposed when the component unmounts.
+ */
+export interface LocalStoreConstructor<T extends Disposable = any, A extends unknown[] = unknown[]> {
+    new (get: Get, ...args: A): T;
+}
+export interface Disposable {
+    dispose(): void;
+}
+export type StoreParams<T extends StoreConstructor> = SkipFirst<ConstructorParameters<T>>;
+/**
+ * A function used to inject dependencies in a store constructor
+ */
+export type Get = <T extends StoreConstructor>(Store: T) => T extends StoreConstructor<infer I> ? Store<I> : never;
+/**
+ * Remove the first element of a tuple
+ * @example
+ * type A = SkipFirst<[number, string, boolean]> // [string, boolean]
+ */
+type SkipFirst<T extends any[]> = T extends [any, ...infer U] ? U : never;
+type OmitFunctions<T> = {
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+};
+/**
+ * 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 type Store<S> = S extends {
+    mutators: readonly (keyof S)[];
+} ? CQS<Pick<S, S["mutators"][number]> & OmitFunctions<S>> : CQS<OmitFunctions<S>>;
+/**
+ * Command Query Separation [1,2] implementation with types.
+ *
+ * Mapped type applying CQS principles to an object by forcing
+ * - methods (commands) to never return anything, effectively making them write-only,
+ * - all properties (queries) to be read-only [3]
+ *
+ * [1] https://martinfowler.com/bliki/CommandQuerySeparation.html
+ * [2] https://en.wikipedia.org/wiki/Command%E2%80%93query_separation
+ * [3] in an ideal world, they would be deeply read-only, but that's not possible natively in TypeScript
+ */
+type CQS<T> = {
+    readonly [key in keyof T]: NeverReturns<T[key]>;
+};
+/**
+ * Force any function to never return anything, effectively
+ * making it write-only.
+ */
+type NeverReturns<T> = T extends (...args: any[]) => any ? (...args: Parameters<T>) => void : T;
+export declare class DisposableStore implements Disposable {
+    protected get: Get;
+    private disposeCallbacks;
+    constructor(get: Get);
+    protected onDispose(callback: () => void): void;
+    dispose(): void;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { DependencyContainer } from "./dependency_container";
+import { LocalStoreConstructor, Store, StoreConstructor, StoreParams } from "./store";
+/**
+ * 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,14 @@
+import { Get } from "../store_engine";
+import { Highlight } from "../types";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export declare class ArrayFormulaHighlight extends SpreadsheetStore {
+    protected highlightStore: {
+        readonly register: (highlightProvider: import("./highlight_store").HighlightProvider) => void;
+        readonly unRegister: (highlightProvider: import("./highlight_store").HighlightProvider) => void;
+        readonly mutators: readonly ["register", "unRegister"];
+        readonly renderingLayers: readonly ["Highlights"];
+        readonly highlights: Highlight[];
+    };
+    constructor(get: Get);
+    get highlights(): Highlight[];
+}

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

@@ -0,0 +1,36 @@
+import { Get } from "../store_engine";
+import { GridRenderingContext, LayerName } from "../types/index";
+export declare const CELL_BACKGROUND_GRIDLINE_STROKE_STYLE = "#111";
+export declare class GridRenderer {
+    private getters;
+    private renderer;
+    constructor(get: Get);
+    get renderingLayers(): readonly ["Background", "Headers"];
+    /**
+     * Get the offset of a header (see getColRowOffsetInViewport), adjusted with the header
+     * size (HEADER_HEIGHT and HEADER_WIDTH)
+     */
+    private getHeaderOffset;
+    drawLayer(renderingContext: GridRenderingContext, layer: LayerName): void;
+    private drawGlobalBackground;
+    private drawBackground;
+    private drawCellBackground;
+    private drawOverflowingCellBackground;
+    private drawBorders;
+    private drawTexts;
+    private drawIcon;
+    /** Computes the vertical start point from which a text line should be draw.
+     *
+     * Note that in case the cell does not have enough spaces to display its text lines,
+     * (wrapping cell case) then the vertical align should be at the top.
+     * */
+    private computeTextYCoordinate;
+    private drawHeaders;
+    private drawFrozenPanesHeaders;
+    private drawFrozenPanes;
+    private findNextEmptyCol;
+    private findPreviousEmptyCol;
+    private computeCellAlignment;
+    private createZoneBox;
+    private getGridBoxes;
+}

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

@@ -0,0 +1,16 @@
+import { Get } from "../store_engine";
+import { GridRenderingContext, Highlight, LayerName } from "../types";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export interface HighlightProvider {
+    highlights: Highlight[];
+}
+export declare class HighlightStore extends SpreadsheetStore {
+    mutators: readonly ["register", "unRegister"];
+    private providers;
+    constructor(get: Get);
+    get renderingLayers(): readonly ["Highlights"];
+    get highlights(): Highlight[];
+    register(highlightProvider: HighlightProvider): void;
+    unRegister(highlightProvider: HighlightProvider): void;
+    drawLayer(ctx: GridRenderingContext, layer: LayerName): void;
+}

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

@@ -0,0 +1,2 @@
+export * from "./model_store";
+export * from "./spreadsheet_store";

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

@@ -0,0 +1,2 @@
+import { Model } from "../model";
+export declare const ModelStore: import("..").StoreConstructor<Model, any[]>;