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

package/dist/types/components/composer/content_editable_helper.d.ts

@@ -0,0 +1,41 @@
+import { HtmlContent } from "./composer/composer";
+export declare class ContentEditableHelper {
+    el: HTMLElement;
+    constructor(el: HTMLElement);
+    updateEl(el: HTMLElement): void;
+    /**
+     * select the text at position start to end, no matter the children
+     */
+    selectRange(start: number, end: number): void;
+    /**
+     * finds the dom element that contains the character at `offset`
+     */
+    private findChildAtCharacterIndex;
+    /**
+     * Sets (or Replaces all) the text inside the root element in the form of distinctive paragraphs and
+     * span for each element provided in `contents`.
+     *
+     * The function will apply the diff between the current content and the new content to avoid the systematic
+     * destruction of DOM elements which interferes with IME[1]
+     *
+     * Each line of text will be encapsulated in a paragraph element.
+     * Each span will have its own fontcolor and specific class if provided in the HtmlContent object.
+     *
+     * [1] https://developer.mozilla.org/en-US/docs/Glossary/Input_method_editor
+     */
+    setText(contents: HtmlContent[][]): void;
+    scrollSelectionIntoView(): void;
+    /**
+     * remove the current selection of the user
+     * */
+    removeSelection(): void;
+    private removeAll;
+    /**
+     * finds the indexes of the current selection.
+     * */
+    getCurrentSelection(): {
+        start: number;
+        end: number;
+    };
+    getText(): string;
+}

package/dist/types/components/composer/formula_assistant/formula_assistant.d.ts

@@ -0,0 +1,31 @@
+import { Component } from "@odoo/owl";
+import { FunctionDescription } from "../../../types";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { Collapse } from "../../side_panel/components/collapse/collapse";
+interface Props {
+    functionDescription: FunctionDescription;
+    argsToFocus: number[];
+    repeatingArgGroupIndex: number | undefined;
+}
+export declare class FunctionDescriptionProvider extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        functionDescription: ObjectConstructor;
+        argsToFocus: ArrayConstructor;
+        repeatingArgGroupIndex: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        Collapse: typeof Collapse;
+    };
+    private state;
+    toggle(): void;
+    getContext(): Props;
+    get formulaHeaderContent(): {
+        content: string;
+        focused?: boolean;
+    }[];
+}
+export {};

package/dist/types/components/composer/grid_composer/grid_composer.d.ts

@@ -0,0 +1,48 @@
+import { Component } from "@odoo/owl";
+import { Store } from "../../../store_engine";
+import { ComposerFocusType, DOMDimension } from "../../../types/index";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { CellComposerProps, Composer } from "../composer/composer";
+import { ComposerFocusStore } from "../composer_focus_store";
+interface Props {
+    gridDims: DOMDimension;
+    onInputContextMenu: (event: MouseEvent) => void;
+}
+/**
+ * This component is a composer which positions itself on the grid at the anchor cell.
+ * It also applies the style of the cell to the composer input.
+ */
+export declare class GridComposer extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        gridDims: ObjectConstructor;
+        onInputContextMenu: FunctionConstructor;
+    };
+    static components: {
+        Composer: typeof Composer;
+    };
+    private rect;
+    private isEditing;
+    private isCellReferenceVisible;
+    private currentEditedCell;
+    private composerStore;
+    composerFocusStore: Store<ComposerFocusStore>;
+    private composerInterface;
+    get defaultRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    setup(): void;
+    get shouldDisplayCellReference(): boolean;
+    get cellReference(): string;
+    get cellReferenceStyle(): string;
+    get focus(): ComposerFocusType;
+    get composerProps(): CellComposerProps;
+    get containerStyle(): string;
+    private updateComponentPosition;
+    private updateCellReferenceVisibility;
+    onFocus(): void;
+}
+export {};

package/dist/types/components/composer/speech_bubble/speech_bubble.d.ts

@@ -0,0 +1,18 @@
+import { Component } from "@odoo/owl";
+import { Rect } from "../../../types";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+export interface Props {
+    anchorRect: Rect;
+    content: string;
+}
+export declare class SpeechBubble extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        content: StringConstructor;
+        anchorRect: ObjectConstructor;
+    };
+    static components: {};
+    private spreadsheetRect;
+    private bubbleRef;
+    setup(): void;
+}

package/dist/types/components/composer/standalone_composer/standalone_composer.d.ts

@@ -0,0 +1,83 @@
+import { Component } from "@odoo/owl";
+import { Token } from "../../../formulas/tokenizer";
+import { AutoCompleteProviderDefinition } from "../../../registries/auto_completes";
+import { Color, ComposerFocusType, UID } from "../../../types/index";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { ComposerSelection } from "../composer/abstract_composer_store";
+import { Composer } from "../composer/composer";
+interface Props {
+    onConfirm: (content: string) => void;
+    composerContent: string;
+    defaultRangeSheetId: UID;
+    defaultStatic?: boolean;
+    contextualAutocomplete?: AutoCompleteProviderDefinition;
+    placeholder?: string;
+    title?: string;
+    class?: string;
+    invalid?: boolean;
+    autofocus?: boolean;
+    getContextualColoredSymbolToken?: (token: Token) => Color;
+}
+export declare class StandaloneComposer extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        composerContent: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        defaultRangeSheetId: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        defaultStatic: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        onConfirm: FunctionConstructor;
+        contextualAutocomplete: {
+            type: ObjectConstructor;
+            optional: boolean;
+        };
+        placeholder: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        title: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        invalid: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        autofocus: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        getContextualColoredSymbolToken: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        Composer: typeof Composer;
+    };
+    static defaultProps: {
+        composerContent: string;
+        defaultStatic: boolean;
+    };
+    private composerFocusStore;
+    private standaloneComposerStore;
+    private composerInterface;
+    readonly spreadsheetRect: import("../../..").Rect;
+    setup(): void;
+    get focus(): ComposerFocusType;
+    get composerStyle(): string;
+    get containerClass(): string;
+    onFocus(selection: ComposerSelection): void;
+}
+export {};

package/dist/types/components/composer/standalone_composer/standalone_composer_store.d.ts

@@ -0,0 +1,34 @@
+import { EnrichedToken } from "../../../formulas/composer_tokenizer";
+import { Token } from "../../../formulas/tokenizer";
+import { AutoCompleteProviderDefinition } from "../../../registries/auto_completes";
+import { Get } from "../../../store_engine";
+import { Color, UID, UnboundedZone, Zone } from "../../../types";
+import { AbstractComposerStore } from "../composer/abstract_composer_store";
+export interface StandaloneComposerArgs {
+    onConfirm: (content: string) => void;
+    content: string;
+    /**
+     * the sheet id to which unqualified references (A1 vs Sheet1!A1)
+     * will be resolved.
+     */
+    defaultStatic?: boolean;
+    defaultRangeSheetId: UID;
+    contextualAutocomplete?: AutoCompleteProviderDefinition;
+    getContextualColoredSymbolToken?: (token: Token) => Color;
+}
+export declare class StandaloneComposerStore extends AbstractComposerStore {
+    private args;
+    constructor(get: Get, args: () => StandaloneComposerArgs);
+    protected getAutoCompleteProviders(): AutoCompleteProviderDefinition[];
+    /**
+     * Replace the current reference selected by the new one.
+     * */
+    protected getZoneReference(zone: Zone | UnboundedZone): string;
+    protected getComposerContent(): {
+        text: string;
+    };
+    stopEdition(): void;
+    protected confirmEdition(content: string): void;
+    protected getTokenColor(token: EnrichedToken): string;
+    hoverToken(): void;
+}

package/dist/types/components/composer/top_bar_composer/top_bar_composer.d.ts

@@ -0,0 +1,20 @@
+import { Component } from "@odoo/owl";
+import { ComposerFocusType } from "../../../types/index";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { ComposerSelection } from "../composer/abstract_composer_store";
+import { Composer } from "../composer/composer";
+export declare class TopBarComposer extends Component<any, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {};
+    static components: {
+        Composer: typeof Composer;
+    };
+    private composerFocusStore;
+    private composerStore;
+    private composerInterface;
+    setup(): void;
+    get focus(): ComposerFocusType;
+    get showFxIcon(): boolean;
+    get composerStyle(): string;
+    onFocus(selection: ComposerSelection): void;
+}

package/dist/types/components/dashboard/clickable_cell_sort_icon/clickable_cell_sort_icon.d.ts

@@ -0,0 +1,20 @@
+import { Component } from "@odoo/owl";
+import { CellPosition, SortDirection } from "../../../types";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+interface Props {
+    position: CellPosition;
+    sortDirection: SortDirection | "none";
+}
+export declare class ClickableCellSortIcon extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        position: ObjectConstructor;
+        sortDirection: StringConstructor;
+    };
+    private hoveredTableStore;
+    setup(): void;
+    get style(): string;
+    get verticalJustifyClass(): "justify-content-start" | "justify-content-center" | "justify-content-end";
+    private getBackgroundColor;
+}
+export {};

package/dist/types/components/dashboard/clickable_cell_store.d.ts

@@ -0,0 +1,21 @@
+import { ComponentConstructor } from "@odoo/owl";
+import { SpreadsheetStore } from "../../stores/spreadsheet_store";
+import { CellPosition, Command, Rect } from "../../types";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export interface ClickableCell {
+    coordinates: Rect;
+    position: CellPosition;
+    title: string;
+    action: (position: CellPosition, env: SpreadsheetChildEnv, isMiddleClick?: boolean) => void;
+    component: ComponentConstructor | undefined;
+    componentProps: Record<string, unknown>;
+}
+export declare class ClickableCellsStore extends SpreadsheetStore {
+    private _clickableCells;
+    private _registryItems;
+    handle(cmd: Command): void;
+    private getClickableItem;
+    private findClickableItem;
+    get clickableCells(): ClickableCell[];
+    private getClickableCellRect;
+}

package/dist/types/components/dashboard/dashboard.d.ts

@@ -0,0 +1,52 @@
+import { Component } from "@odoo/owl";
+import { Store } from "../../store_engine";
+import { DOMCoordinates, DOMDimension, Rect } from "../../types/index";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { DelayedHoveredCellStore } from "../grid/delayed_hovered_cell_store";
+import { GridOverlay } from "../grid_overlay/grid_overlay";
+import { GridPopover } from "../grid_popover/grid_popover";
+import { CellPopoverStore } from "../popover";
+import { Popover } from "../popover/popover";
+import { HorizontalScrollBar, VerticalScrollBar } from "../scrollbar/";
+import { ClickableCell, ClickableCellsStore } from "./clickable_cell_store";
+interface Props {
+    getGridSize: () => DOMDimension;
+}
+export declare class SpreadsheetDashboard extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        getGridSize: FunctionConstructor;
+    };
+    static components: {
+        GridOverlay: typeof GridOverlay;
+        GridPopover: typeof GridPopover;
+        Popover: typeof Popover;
+        VerticalScrollBar: typeof VerticalScrollBar;
+        HorizontalScrollBar: typeof HorizontalScrollBar;
+    };
+    protected cellPopovers: Store<CellPopoverStore>;
+    onMouseWheel: (ev: WheelEvent) => void;
+    canvasPosition: DOMCoordinates;
+    hoveredCell: Store<DelayedHoveredCellStore>;
+    clickableCellsStore: Store<ClickableCellsStore>;
+    private gridRef;
+    setup(): void;
+    get gridContainer(): string;
+    get gridOverlayDimensions(): string;
+    getCellClickableStyle(coordinates: Rect): string;
+    /**
+     * Get all the boxes for the cell in the sheet view that are clickable.
+     * This function is used to render an overlay over each clickable cell in
+     * order to display a pointer cursor.
+     *
+     */
+    getClickableCells(): ClickableCell[];
+    selectClickableCell(ev: MouseEvent, clickableCell: ClickableCell): void;
+    onClosePopover(): void;
+    onGridResized(): void;
+    private moveCanvas;
+    private getGridRect;
+    private getMaxSheetWidth;
+    get dashboardStyle(): string;
+}
+export {};

package/dist/types/components/date_input/date_input.d.ts

@@ -0,0 +1,4 @@
+import { NumberInput } from "../number_input/number_input";
+export declare class DateInput extends NumberInput {
+    static template: string;
+}

package/dist/types/components/error_tooltip/error_tooltip.d.ts

@@ -0,0 +1,40 @@
+import { Component } from "@odoo/owl";
+import { CellPosition } from "../../types";
+import { PopoverBuilders } from "../../types/cell_popovers";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+interface ErrorToolTipProps {
+    cellPosition: CellPosition;
+    onClosed?: () => void;
+}
+export declare class ErrorToolTip extends Component<ErrorToolTipProps, SpreadsheetChildEnv> {
+    static maxSize: {
+        maxHeight: number;
+    };
+    static template: string;
+    static props: {
+        cellPosition: ObjectConstructor;
+        onClosed: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    };
+    get dataValidationErrorMessage(): string | undefined;
+    get evaluationError(): import("../..").EvaluatedCell | undefined;
+    get errorOriginPositionString(): string;
+    selectCell(): void;
+    get isSpillErrorBecauseOfMissingHeaders(): boolean;
+    getMissingHeadersForSpread(): {
+        missingRows: number;
+        missingCols: number;
+    } | undefined;
+    addMissingHeaders({ missingCols, missingRows }: {
+        missingCols: number;
+        missingRows: number;
+    }): void;
+    getAddMissingHeadersButtonText(missingHeaders: {
+        missingCols: number;
+        missingRows: number;
+    }): string;
+}
+export declare const ErrorToolTipPopoverBuilder: PopoverBuilders;
+export {};

package/dist/types/components/figures/chart/chartJs/chartjs.d.ts

@@ -0,0 +1,39 @@
+import { Component } from "@odoo/owl";
+import { Chart, ChartConfiguration } from "chart.js/auto";
+import { Store } from "../../../../store_engine";
+import { UID } from "../../../../types";
+import { ChartJSRuntime } from "../../../../types/chart/chart";
+import { SpreadsheetChildEnv } from "../../../../types/spreadsheet_env";
+import { ChartAnimationStore } from "./chartjs_animation_store";
+interface Props {
+    chartId: UID;
+    isFullScreen?: boolean;
+}
+export declare class ChartJsComponent extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        chartId: StringConstructor;
+        isFullScreen: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+    };
+    protected canvas: {
+        el: HTMLElement | null;
+    };
+    protected chart?: Chart;
+    protected currentRuntime: ChartJSRuntime;
+    protected animationStore: Store<ChartAnimationStore> | undefined;
+    private currentDevicePixelRatio;
+    get chartRuntime(): ChartJSRuntime;
+    setup(): void;
+    protected unmount(): void;
+    private get shouldAnimate();
+    protected createChart(chartRuntime: ChartJSRuntime): void;
+    protected updateChartJs(chartRuntime: ChartJSRuntime): void;
+    private hasChartDataChanged;
+    protected enableAnimationInChartData(chartData: ChartConfiguration<any>): ChartConfiguration<any>;
+    private getChartDataInRuntime;
+    get animationChartId(): string;
+}
+export {};

package/dist/types/components/figures/chart/chartJs/chartjs_animation_store.d.ts

@@ -0,0 +1,8 @@
+import { SpreadsheetStore } from "../../../../stores/spreadsheet_store";
+import { ChartType, UID } from "../../../../types";
+export declare class ChartAnimationStore extends SpreadsheetStore {
+    mutators: readonly ["disableAnimationForChart", "enableAnimationForChart"];
+    animationPlayed: {};
+    disableAnimationForChart(chartId: UID, chartType: ChartType): string;
+    enableAnimationForChart(chartId: UID): string;
+}

package/dist/types/components/figures/chart/chartJs/chartjs_background_plugin.d.ts

@@ -0,0 +1,11 @@
+import { ChartType, Plugin } from "chart.js";
+export interface ChartBackgroundPluginOptions {
+    color: string | undefined;
+}
+declare module "chart.js" {
+    interface PluginOptionsByType<TType extends ChartType> {
+        background?: ChartBackgroundPluginOptions;
+    }
+}
+/** This is a chartJS plugin that will draw a background of a chart */
+export declare const chartBackgroundPlugin: Plugin;

package/dist/types/components/figures/chart/chartJs/chartjs_calendar_chart.d.ts

@@ -0,0 +1,19 @@
+import { BarController, BarControllerChartOptions, BarControllerDatasetOptions, CartesianParsedData, CartesianScaleTypeRegistry, Chart, ChartComponent } from "chart.js";
+export declare function getCalendarChartController(): ChartComponent & {
+    prototype: BarController;
+    new (chart: Chart, datasetIndex: number): BarController;
+};
+declare module "chart.js" {
+    interface ChartTypeRegistry {
+        calendar: {
+            chartOptions: BarControllerChartOptions;
+            datasetOptions: BarControllerDatasetOptions & {
+                values: number[];
+            };
+            defaultDataPoint: number | null;
+            metaExtensions: {};
+            parsedDataType: CartesianParsedData;
+            scales: keyof CartesianScaleTypeRegistry;
+        };
+    }
+}

package/dist/types/components/figures/chart/chartJs/chartjs_colorscale_plugin.d.ts

@@ -0,0 +1,17 @@
+import { ChartType, Plugin } from "chart.js";
+import { Color, Locale } from "../../../..";
+export interface ChartColorScalePluginOptions {
+    position: "left" | "right" | "none";
+    colorScale: Color[];
+    fontColor?: Color;
+    minValue: number;
+    maxValue: number;
+    locale: Locale;
+}
+declare module "chart.js" {
+    interface PluginOptionsByType<TType extends ChartType> {
+        chartColorScalePlugin?: ChartColorScalePluginOptions;
+    }
+}
+/** This is a chartJS plugin that will draw the heatmap colorscale at the chart legend position */
+export declare const chartColorScalePlugin: Plugin;

package/dist/types/components/figures/chart/chartJs/chartjs_funnel_chart.d.ts

@@ -0,0 +1,29 @@
+import { BarController, BarControllerChartOptions, BarControllerDatasetOptions, BarElement, CartesianParsedData, CartesianScaleTypeRegistry, Chart, ChartComponent, TooltipPositionerFunction } from "chart.js";
+export declare function getFunnelChartController(): ChartComponent & {
+    prototype: BarController;
+    new (chart: Chart, datasetIndex: number): BarController;
+};
+export declare function getFunnelChartElement(): ChartComponent & {
+    prototype: BarElement;
+    new (cfg: Record<string, unknown>): BarElement;
+};
+/**
+ * Position the tooltip inside the trapezoid.
+ * The default position for tooltips of bar elements is at the end of rectangle, which is not ideal for trapezoids.
+ */
+export declare const funnelTooltipPositioner: TooltipPositionerFunction<"funnel">;
+declare module "chart.js" {
+    interface ChartTypeRegistry {
+        funnel: {
+            chartOptions: BarControllerChartOptions;
+            datasetOptions: BarControllerDatasetOptions;
+            defaultDataPoint: number | [number, number] | null;
+            metaExtensions: {};
+            parsedDataType: CartesianParsedData;
+            scales: keyof CartesianScaleTypeRegistry;
+        };
+    }
+    interface TooltipPositionerMap {
+        funnelTooltipPositioner: TooltipPositionerFunction<"funnel"> | undefined;
+    }
+}

package/dist/types/components/figures/chart/chartJs/chartjs_minor_grid_plugin.d.ts

@@ -0,0 +1,5 @@
+import type { Chart } from "chart.js";
+export declare const chartMinorGridPlugin: {
+    id: string;
+    beforeDatasetsDraw(chart: Chart): void;
+};

package/dist/types/components/figures/chart/chartJs/chartjs_show_values_plugin.d.ts

@@ -0,0 +1,17 @@
+import type { ChartMeta, ChartType, Plugin } from "chart.js";
+import { Color } from "../../../../types";
+import type { ChartType as AllChartType } from "../../../../types/chart";
+export interface ChartShowValuesPluginOptions {
+    type: AllChartType;
+    showValues: boolean;
+    background: (value: number | string, dataset: ChartMeta, index: number) => Color | undefined;
+    horizontal?: boolean;
+    callback: (value: number | string, dataset: ChartMeta, index: number) => string;
+}
+declare module "chart.js" {
+    interface PluginOptionsByType<TType extends ChartType> {
+        chartShowValuesPlugin?: ChartShowValuesPluginOptions;
+    }
+}
+/** This is a chartJS plugin that will draw the values of each data next to the point/bar/pie slice */
+export declare const chartShowValuesPlugin: Plugin;

package/dist/types/components/figures/chart/chartJs/chartjs_sunburst_hover_plugin.d.ts

@@ -0,0 +1,14 @@
+import { ChartType, Plugin } from "chart.js";
+export interface ChartSunburstHoverPluginOptions {
+    enabled: boolean;
+}
+declare module "chart.js" {
+    interface PluginOptionsByType<TType extends ChartType> {
+        sunburstHoverPlugin?: ChartSunburstHoverPluginOptions;
+    }
+}
+/**
+ * When a chart element is hovered (active), this plugin also activates all of its child elements and
+ * lightens the color of the other elements.
+ */
+export declare const sunburstHoverPlugin: Plugin;

package/dist/types/components/figures/chart/chartJs/chartjs_sunburst_labels_plugin.d.ts

@@ -0,0 +1,14 @@
+import { ChartType, Plugin } from "chart.js";
+import { Style } from "../../../../types";
+export interface ChartSunburstLabelsPluginOptions {
+    showValues: boolean;
+    showLabels: boolean;
+    style: Style;
+    callback: (value: number, axisId?: string) => string;
+}
+declare module "chart.js" {
+    interface PluginOptionsByType<TType extends ChartType> {
+        sunburstLabelsPlugin?: ChartSunburstLabelsPluginOptions;
+    }
+}
+export declare const sunburstLabelsPlugin: Plugin;

package/dist/types/components/figures/chart/chartJs/chartjs_waterfall_plugin.d.ts

@@ -0,0 +1,12 @@
+import { ChartType, Plugin } from "chart.js";
+interface WaterfallPluginOptions {
+    showConnectorLines: boolean;
+}
+declare module "chart.js" {
+    interface PluginOptionsByType<TType extends ChartType> {
+        waterfallLinesPlugin?: WaterfallPluginOptions;
+    }
+}
+/** This is a chartJS plugin that will draw connector lines between the bars of a Waterfall chart */
+export declare const waterfallLinesPlugin: Plugin;
+export {};

package/dist/types/components/figures/chart/chartJs/zoomable_chart/zoomable_chart_store.d.ts

@@ -0,0 +1,30 @@
+import { Command, UID } from "../../../../..";
+import { SpreadsheetStore } from "../../../../../stores";
+declare const ZOOMABLE_AXIS_IDS: readonly ["x", "x1", "xMovingAverage"];
+type AxisId = (typeof ZOOMABLE_AXIS_IDS)[number];
+export interface Boundaries {
+    min: number;
+    max: number;
+}
+export type AxesLimits = {
+    [chartId: UID]: {
+        [axisId in AxisId]?: Boundaries;
+    } & {
+        x: Boundaries;
+    };
+};
+export declare class ZoomableChartStore extends SpreadsheetStore {
+    mutators: readonly ["resetAxisLimits", "updateAxisLimits", "updateTrendLineConfiguration", "clearAxisLimits"];
+    originalAxisLimits: AxesLimits;
+    currentAxesLimits: AxesLimits;
+    private idConversion;
+    private axisDesignBoundaries;
+    handle(cmd: Command): void;
+    clearAxisLimits(chartId: UID): string;
+    resetAxisLimits(chartId: UID, limits: {
+        [key: string]: Boundaries;
+    }): string;
+    updateAxisLimits(chartId: UID, limits: Boundaries): string;
+    updateTrendLineConfiguration(chartId: UID): string;
+}
+export {};