@odoo/o-spreadsheet 19.2.11 → 19.4.0-alpha.4

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

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

@@ -0,0 +1,15 @@
+import { ClientId } from "../types/collaborative/session";
+import { Get } from "../types/store_engine";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export declare class ClientFocusStore extends SpreadsheetStore {
+    mutators: readonly ["focusClient", "unfocusClient", "showClientTag", "hideClientTag", "jumpToClient"];
+    private _showClientTag;
+    private clientFocusTimeout;
+    constructor(get: Get);
+    get focusedClients(): Set<ClientId>;
+    jumpToClient(clientId: ClientId): void;
+    showClientTag(): void;
+    hideClientTag(): void;
+    focusClient(clientId: ClientId): void;
+    unfocusClient(clientId: ClientId): void;
+}

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

@@ -0,0 +1,18 @@
+import { PositionMap } from "../helpers/cells/position_map";
+import { Command } from "../types/commands";
+import { Color } from "../types/misc";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export declare class FormulaFingerprintStore extends SpreadsheetStore {
+    mutators: readonly ["enable", "disable"];
+    private isInvalidated;
+    private fingerprintColors;
+    isEnabled: boolean;
+    colors: PositionMap<Color>;
+    handle(cmd: Command): void;
+    finalize(): void;
+    enable(): void;
+    disable(): void;
+    private computeFingerprints;
+    private colorSpreadZone;
+    private assignColors;
+}

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

@@ -0,0 +1,44 @@
+import { DisposableStore } from "../store_engine/store";
+import { Command } from "../types/commands";
+import { RenderingGetters } from "../types/getters";
+import { GridRenderingContext, LayerName } from "../types/rendering";
+import { Get, Store } from "../types/store_engine";
+import { RendererStore } from "./renderer_store";
+export declare const CELL_BACKGROUND_GRIDLINE_STROKE_STYLE = "#111";
+export declare const CELL_ANIMATION_DURATION = 200;
+export declare class GridRenderer extends DisposableStore {
+    private renderer;
+    private fingerprints;
+    private hoveredTables;
+    private hoveredIcon;
+    private lastRenderSheetId;
+    private lastRenderBoxes;
+    private preventNewAnimationsInNextFrame;
+    private zonesWithPreventedAnimationsInNextFrame;
+    private animations;
+    protected getters: RenderingGetters;
+    constructor(get: Get, renderer?: Store<RendererStore>);
+    handle(cmd: Command): void;
+    finalize(): void;
+    get renderingLayers(): readonly ["Background", "Headers"];
+    drawLayer(renderingContext: GridRenderingContext, layer: LayerName, timeStamp: number | undefined): void;
+    private drawGlobalBackground;
+    private drawBackground;
+    private drawCellBackground;
+    private drawOverflowingCellBackground;
+    private drawBorders;
+    private drawTexts;
+    private drawIcon;
+    private drawHeaders;
+    private drawFrozenPanesHeaders;
+    private drawFrozenPanes;
+    private findNextEmptyCol;
+    private findPreviousEmptyCol;
+    private computeCellAlignment;
+    private createZoneBox;
+    private getGridBoxes;
+    private getBoxesWithAnimations;
+    private updateBoxesWithAnimations;
+    private updateAnimationsProgress;
+    private addNewAnimations;
+}

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

@@ -0,0 +1,17 @@
+import { Highlight } from "../types/misc";
+import { GridRenderingContext, LayerName } from "../types/rendering";
+import { Get } from "../types/store_engine";
+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/model_store.d.ts

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

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

@@ -0,0 +1,8 @@
+import { NotificationStoreMethods } from "../types/stores/notification_store_methods";
+export declare class NotificationStore {
+    mutators: readonly ["notifyUser", "raiseError", "askConfirmation", "updateNotificationCallbacks"];
+    notifyUser: NotificationStoreMethods["notifyUser"];
+    askConfirmation: NotificationStoreMethods["askConfirmation"];
+    raiseError: NotificationStoreMethods["raiseError"];
+    updateNotificationCallbacks(methods: Partial<NotificationStoreMethods>): void;
+}

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

@@ -0,0 +1,23 @@
+import { GridRenderingContext, LayerName } from "../types/rendering";
+import { Get } from "../types/store_engine";
+export interface Renderer {
+    drawLayer(ctx: GridRenderingContext, layer: LayerName, timestamp: number | undefined): void;
+    renderingLayers: Readonly<LayerName[]>;
+}
+export declare class RendererStore {
+    private layers;
+    mutators: readonly ["register", "unRegister", "draw", "startAnimation", "stopAnimation"];
+    private renderers;
+    private model;
+    private context;
+    private animationFrameId;
+    private registeredAnimations;
+    constructor(get: Get, layers?: ("Background" | "Highlights" | "Clipboard" | "Chart" | "Autofill" | "Selection" | "Headers")[]);
+    register(renderer: Renderer): void;
+    unRegister(renderer: Renderer): void;
+    private drawLayer;
+    draw(context?: GridRenderingContext, timestamp?: number): string;
+    startAnimation(animationId: string): string;
+    stopAnimation(animationId: string): string;
+    dispose(): void;
+}

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

@@ -0,0 +1,6 @@
+export declare class ScreenWidthStore {
+    mutators: readonly ["setSmallThreshhold"];
+    private _isSmallCallback;
+    get isSmall(): boolean;
+    setSmallThreshhold(isSmall: () => boolean): void;
+}

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

@@ -0,0 +1,16 @@
+import { Model } from "../model";
+import { DisposableStore } from "../store_engine/store";
+import { Command } from "../types/commands";
+import { GridRenderingContext, LayerName } from "../types/rendering";
+import { Get } from "../types/store_engine";
+import { RendererStore } from "./renderer_store";
+export declare class SpreadsheetStore extends DisposableStore {
+    protected model: Model;
+    protected getters: import("..").Getters;
+    protected renderer: import("../types/store_engine").CQS<Pick<RendererStore, "register" | "unRegister" | "draw" | "startAnimation" | "stopAnimation"> & import("../types/store_engine").OmitFunctions<RendererStore>>;
+    constructor(get: Get);
+    get renderingLayers(): Readonly<LayerName[]>;
+    protected handle(cmd: Command): void;
+    protected finalize(): void;
+    drawLayer(ctx: GridRenderingContext, layer: LayerName, timestamp: number | undefined): void;
+}

package/dist/types/translation.d.ts

@@ -0,0 +1,21 @@
+type SprintfValues = (string | String | number)[] | [{
+    [key: string]: string | number;
+}];
+export type TranslationFunction = (string: string, ...values: SprintfValues) => string;
+/***
+ * Allow to inject a translation function from outside o-spreadsheet. This should be called before instantiating
+ * a model.
+ * @param tfn the function that will do the translation
+ * @param loaded a function that returns true when the translation is loaded
+ */
+export declare function setTranslationMethod(tfn: TranslationFunction, loaded?: () => boolean): void;
+/**
+ * If no translation function has been set, this will mark the translation are loaded.
+ *
+ * By default, the translations should not be set as loaded, otherwise top-level translated constants will never be
+ * translated. But if by the time the model is instantiated no custom translation function has been set, we can set
+ * the default translation function as loaded so o-spreadsheet can be run in standalone with no translations.
+ */
+export declare function setDefaultTranslationMethod(): void;
+export declare const _t: TranslationFunction;
+export {};

package/dist/types/types/autofill.d.ts

@@ -0,0 +1,71 @@
+/**
+ * An AutofillModifier describe the possible operations to apply to the
+ * content of a cell when we autofill this cell.
+ *
+ * It could be:
+ *  - Increment: increment the content by a given step
+ *  - Copy: simply copy the content
+ *  - Formula: update the formula, with the same behavior than paste
+ */
+import { Cell } from "./cells";
+import { Getters } from "./getters";
+import { Border, DIRECTION, UID, UpdateCellData } from "./misc";
+export interface IncrementModifier {
+    type: "INCREMENT_MODIFIER";
+    increment: number;
+    current: number;
+}
+export interface AlphanumericIncrementModifier {
+    type: "ALPHANUMERIC_INCREMENT_MODIFIER";
+    increment: number;
+    current: number;
+    prefix: string;
+    numberPostfixLength: number;
+}
+export interface DateIncrementModifier {
+    type: "DATE_INCREMENT_MODIFIER";
+    current: number;
+    increment: {
+        years: number;
+        months: number;
+        days: number;
+    };
+}
+export interface CopyModifier {
+    type: "COPY_MODIFIER";
+}
+export interface FormulaModifier {
+    type: "FORMULA_MODIFIER";
+    increment: number;
+    current: number;
+}
+export type AutofillModifier = IncrementModifier | AlphanumericIncrementModifier | CopyModifier | FormulaModifier | DateIncrementModifier;
+export interface Tooltip {
+    props: any;
+    component?: any;
+}
+export interface AutofillCellData extends UpdateCellData {
+    border?: Border;
+}
+export interface AutofillData {
+    cell?: Cell;
+    col: number;
+    row: number;
+    sheetId: UID;
+    border?: Border;
+}
+export interface AutofillResult {
+    cellData: AutofillCellData;
+    tooltip?: Tooltip;
+    origin: {
+        col: number;
+        row: number;
+    };
+}
+export interface GeneratorCell {
+    data: AutofillData;
+    rule: AutofillModifier;
+}
+export interface AutofillModifierImplementation {
+    apply: (rule: AutofillModifier, data: AutofillData, getters: Getters, direction: DIRECTION) => Omit<AutofillResult, "origin">;
+}

package/dist/types/types/canvas.d.ts

@@ -0,0 +1,2 @@
+export type CanvasSurface = HTMLCanvasElement | OffscreenCanvas;
+export type Canvas2DContext = CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;

package/dist/types/types/cell_popovers.d.ts

@@ -0,0 +1,51 @@
+import { ComponentConstructor } from "@odoo/owl";
+import { Getters } from "./getters";
+import { CellPosition } from "./misc";
+import { PropsOf } from "./props_of";
+import { Rect } from "./rendering";
+export type CellPopoverType = "ErrorToolTip" | "LinkDisplay" | "FilterMenu" | "LinkEditor";
+export type PopoverPropsPosition = "top-right" | "bottom-left";
+type MaxSizedComponentConstructor = ComponentConstructor & {
+    maxSize?: {
+        maxWidth?: number;
+        maxHeight?: number;
+    };
+};
+/**
+ * If the cell at the given position have an associated component (linkDisplay, errorTooltip, ...),
+ * returns the parameters to display the component
+ */
+type CellPopoverBuilder = (position: CellPosition, getters: Getters) => CellPopoverComponent<MaxSizedComponentConstructor>;
+export interface PopoverBuilders {
+    onOpen?: CellPopoverBuilder;
+    onHover?: CellPopoverBuilder;
+}
+export interface ClosedCellPopover {
+    isOpen: false;
+}
+export interface OpenCellPopover {
+    isOpen: true;
+    type: CellPopoverType;
+    col: number;
+    row: number;
+}
+/**
+ * Description of a cell component.
+ * i.e. which component class, which props and where to
+ * display it relative to the cell
+ */
+type OpenCellPopoverComponent<C extends ComponentConstructor> = {
+    isOpen: true;
+    Component: C;
+    props: PropsOf<C>;
+    cellCorner: PopoverPropsPosition;
+};
+export type CellPopoverComponent<C extends MaxSizedComponentConstructor = MaxSizedComponentConstructor> = ClosedCellPopover | OpenCellPopoverComponent<C>;
+export type PositionedCellPopoverComponent<C extends MaxSizedComponentConstructor = MaxSizedComponentConstructor> = {
+    isOpen: true;
+    Component: C;
+    props: PropsOf<C>;
+    anchorRect: Rect;
+    cellCorner: PopoverPropsPosition;
+};
+export {};

package/dist/types/types/cells.d.ts

@@ -0,0 +1,66 @@
+import { CompiledFormula } from "../formulas/compiler";
+import { Format, FormattedValue } from "./format";
+import { CellPosition, FunctionResultObject, Link, Style } from "./misc";
+interface CellAttributes {
+    readonly id: number;
+    readonly style?: Style;
+    readonly format?: Format;
+}
+export interface LiteralCell extends CellAttributes {
+    /**
+     * Raw cell content
+     */
+    readonly content: string;
+    readonly isFormula: false;
+    readonly parsedValue: CellValue;
+}
+export interface FormulaCell extends CellAttributes {
+    readonly isFormula: true;
+    readonly compiledFormula: CompiledFormula;
+}
+export type Cell = LiteralCell | FormulaCell;
+interface EvaluatedCellProperties extends FunctionResultObject {
+    readonly format?: Format;
+    /**
+     * Cell value formatted based on the format
+     */
+    readonly formattedValue: FormattedValue;
+    readonly defaultAlign: "right" | "center" | "left";
+    /**
+     * Can the cell appear in an automatic sum zone.
+     */
+    readonly isAutoSummable: boolean;
+    readonly link?: Link;
+    readonly position?: CellPosition;
+}
+export type CellValue = string | number | boolean | null;
+export type EvaluatedCell = NumberCell | TextCell | BooleanCell | EmptyCell | ErrorCell;
+export interface NumberCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.number;
+    readonly value: number;
+}
+export interface TextCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.text;
+    readonly value: string;
+}
+export interface BooleanCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.boolean;
+    readonly value: boolean;
+}
+export interface EmptyCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.empty;
+    readonly value: null;
+}
+export interface ErrorCell extends EvaluatedCellProperties {
+    readonly type: CellValueType.error;
+    readonly value: string;
+    readonly message?: string;
+}
+export declare enum CellValueType {
+    boolean = "boolean",
+    number = "number",
+    text = "text",
+    empty = "empty",
+    error = "error"
+}
+export {};

package/dist/types/types/chart/bar_chart.d.ts

@@ -0,0 +1,17 @@
+import { ChartConfiguration } from "chart.js";
+import { Range } from "../range";
+import { CommonChartDefinition } from "./common_chart";
+export interface BarChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "bar";
+    readonly stacked: boolean;
+    readonly horizontal?: boolean;
+    readonly zoomable?: boolean;
+}
+export type BarChartRuntime = {
+    chartJsConfig: ChartConfiguration<"bar" | "line">;
+    masterChartConfig?: ChartConfiguration<"bar">;
+    customizableSeries: {
+        dataSetId: string;
+        label: string;
+    }[];
+};

package/dist/types/types/chart/bubble_chart.d.ts

@@ -0,0 +1,24 @@
+import { ChartConfiguration } from "chart.js";
+import { AxesDesign, Color, Range } from "../..";
+import { LegendPosition, NonDataSourceBaseChartDefinition, VerticalAxisPosition } from "./common_chart";
+export type BubbleColorMode = {
+    color: "multiple" | Color;
+    transparent?: boolean;
+};
+export interface BubbleChartDefinition<T extends string | Range = string> extends NonDataSourceBaseChartDefinition {
+    readonly type: "bubble";
+    readonly legendPosition: LegendPosition;
+    readonly axesDesign?: AxesDesign;
+    readonly showValues?: boolean;
+    readonly dataSetsHaveTitle: boolean;
+    readonly yRanges: T[];
+    readonly xRange?: T;
+    readonly labelRange?: T;
+    readonly sizeRange?: T;
+    readonly labelsAsText: boolean;
+    readonly bubbleColor: BubbleColorMode;
+    readonly verticalAxisPosition: VerticalAxisPosition;
+}
+export type BubbleChartRuntime = {
+    chartJsConfig: ChartConfiguration<"line">;
+};

package/dist/types/types/chart/calendar_chart.d.ts

@@ -0,0 +1,17 @@
+import { ChartConfiguration } from "chart.js";
+import { Color } from "../misc";
+import { Range } from "../range";
+import { ChartColorScale } from "./chart";
+import { CommonChartDefinition } from "./common_chart";
+export declare const CALENDAR_CHART_GRANULARITIES: ("year" | "second_number" | "minute_number" | "hour_number" | "day_of_week" | "day_of_month" | "iso_week_number" | "month_number" | "quarter_number")[];
+export type CalendarChartGranularity = (typeof CALENDAR_CHART_GRANULARITIES)[number];
+export interface CalendarChartDefinition<T extends string | Range = Range> extends CommonChartDefinition<T> {
+    readonly type: "calendar";
+    readonly horizontalGroupBy: CalendarChartGranularity;
+    readonly verticalGroupBy: CalendarChartGranularity;
+    readonly colorScale?: ChartColorScale;
+    readonly missingValueColor?: Color;
+}
+export type CalendarChartRuntime = {
+    chartJsConfig: ChartConfiguration;
+};