@odoo/o-spreadsheet 19.2.11 → 19.3.2

package/dist/types/plugins/ui_stateful/filter_evaluation.d.ts

@@ -0,0 +1,29 @@
+import { Command, CommandResult, LocalCommand } from "../../types/commands";
+import { CellPosition, UID } from "../../types/misc";
+import { CriterionFilter, DataFilterValue, Table } from "../../types/table";
+import { ExcelWorkbookData } from "../../types/workbook_data";
+import { UIPlugin } from "../ui_plugin";
+export declare class FilterEvaluationPlugin extends UIPlugin {
+    static getters: readonly ["getFilterValue", "getFilterHiddenValues", "getFilterCriterionValue", "getFirstTableInSelection", "isRowFiltered", "isFilterActive"];
+    private filterValues;
+    hiddenRows: Record<UID, Set<number> | undefined>;
+    isEvaluationDirty: boolean;
+    allowDispatch(cmd: LocalCommand): CommandResult;
+    handle(cmd: Command): void;
+    finalize(): void;
+    isRowFiltered(sheetId: UID, row: number): boolean;
+    getFilterValue(position: CellPosition): DataFilterValue | undefined;
+    getFilterHiddenValues(position: CellPosition): string[];
+    getFilterCriterionValue(position: CellPosition): CriterionFilter;
+    isFilterActive(position: CellPosition): boolean;
+    getFirstTableInSelection(): Table | undefined;
+    private updateFilter;
+    private updateHiddenRows;
+    private getCellValueAsString;
+    exportForExcel(data: ExcelWorkbookData): void;
+    /**
+     * Get an unique column name for the column at colIndex. If the column name is already in the array of used column names,
+     * concatenate a number to the name until we find a new unique name (eg. "ColName" => "ColName1" => "ColName2" ...)
+     */
+    private getUniqueColNameForExcel;
+}

package/dist/types/plugins/ui_stateful/header_positions.d.ts

@@ -0,0 +1,28 @@
+import { Command } from "../../types/commands";
+import { Dimension, HeaderDimensions, HeaderIndex, Pixel, UID } from "../../types/misc";
+import { UIPlugin } from "../ui_plugin";
+export declare class HeaderPositionsUIPlugin extends UIPlugin {
+    static getters: readonly ["getColDimensions", "getRowDimensions", "getColRowOffset"];
+    private headerPositions;
+    private isDirty;
+    handle(cmd: Command): void;
+    finalize(): void;
+    /**
+     * Returns the size, start and end coordinates of a column on an unfolded sheet
+     */
+    getColDimensions(sheetId: UID, col: HeaderIndex): HeaderDimensions;
+    /**
+     * Returns the size, start and end coordinates of a row an unfolded sheet
+     */
+    getRowDimensions(sheetId: UID, row: HeaderIndex): HeaderDimensions;
+    /**
+     * Returns the offset of a header (determined by the dimension) at the given index
+     * based on the referenceIndex given. If start === 0, this method will return
+     * the start attribute of the header.
+     *
+     * i.e. The size from A to B is the distance between A.start and B.end
+     */
+    getColRowOffset(dimension: Dimension, referenceIndex: HeaderIndex, index: HeaderIndex, sheetId: UID): Pixel;
+    private computeHeaderPositionsOfSheet;
+    private computePositions;
+}

package/dist/types/plugins/ui_stateful/selection.d.ts

@@ -0,0 +1,99 @@
+import { EvaluatedCell } from "../../types/cells";
+import { Command, CommandResult, LocalCommand } from "../../types/commands";
+import { CellPosition, Dimension, Selection, Sheet, Style, UID, UnboundedZone, Zone } from "../../types/misc";
+import { Range } from "../../types/range";
+import { GridRenderingContext } from "../../types/rendering";
+import { UIPlugin, UIPluginConfig } from "../ui_plugin";
+export interface SelectionState {
+    sheetId: UID;
+    selectedZones: Zone[];
+    activeCols: Set<number>;
+    activeRows: Set<number>;
+    activePosition: CellPosition | undefined;
+}
+/**
+ * SelectionPlugin
+ */
+export declare class GridSelectionPlugin extends UIPlugin {
+    static layers: readonly ["Selection"];
+    static getters: readonly ["getActiveSheet", "getActiveSheetId", "getActiveSheetName", "getActiveCell", "getActiveCols", "getActiveRows", "getCurrentStyle", "getSelectedZones", "getSelectedZone", "getSelectedCells", "getSelectedFigureId", "getSelection", "getActivePosition", "getSheetPosition", "isSingleColSelected", "getElementsFromSelection", "tryGetActiveSheetId", "isGridSelectionActive", "getSelectecUnboundedZone", "getSelectionRangeString", "getSelectionState"];
+    private gridSelection;
+    private selectedFigureId;
+    private sheetsData;
+    private moveClient;
+    private isUnbounded;
+    activeSheet: Sheet;
+    constructor(config: UIPluginConfig);
+    allowDispatch(cmd: LocalCommand): CommandResult;
+    private handleEvent;
+    handle(cmd: Command): void;
+    finalize(): void;
+    isGridSelectionActive(): boolean;
+    getActiveSheet(): Readonly<Sheet>;
+    getActiveSheetId(): UID;
+    getActiveSheetName(): string;
+    tryGetActiveSheetId(): UID | undefined;
+    getActiveCell(): EvaluatedCell;
+    getActiveCols(): Set<number>;
+    getActiveRows(): Set<number>;
+    getCurrentStyle(): Style;
+    getSelectedZones(): Zone[];
+    getSelectedZone(): Zone;
+    getSelectecUnboundedZone(): UnboundedZone;
+    getSelection(): Selection;
+    getSelectedCells(): EvaluatedCell[];
+    getSelectedFigureId(): UID | null;
+    getActivePosition(): CellPosition;
+    getSheetPosition(sheetId: UID): CellPosition;
+    isSingleColSelected(): boolean;
+    /**
+     * Returns a sorted array of indexes of all columns (respectively rows depending
+     * on the dimension parameter) intersected by the currently selected zones.
+     *
+     * example:
+     * assume selectedZones: [{left:0, right: 2, top :2, bottom: 4}, {left:5, right: 6, top :3, bottom: 5}]
+     *
+     * if dimension === "COL" => [0,1,2,5,6]
+     * if dimension === "ROW" => [2,3,4,5]
+     */
+    getElementsFromSelection(dimension: Dimension): number[];
+    /**
+     * Same as `getRangeString` but add:
+     * - all necessary merge to the range to make it a valid selection
+     * - the "#" suffix if the range is a spilled reference if `allowSpilledReferences` is true
+     */
+    getSelectionRangeString(range: Range, forSheetId: UID, { allowSpilledReferences }?: {
+        allowSpilledReferences: boolean;
+    }): string;
+    private activateSheet;
+    /**
+     * Ensure selections are not outside sheet boundaries.
+     * They are clipped to fit inside the sheet if needed.
+     */
+    private setSelectionMixin;
+    /**
+     * Change the anchor of the selection active cell to an absolute col and row index.
+     *
+     * This is a non trivial task. We need to stop the editing process and update
+     * properly the current selection.  Also, this method can optionally create a new
+     * range in the selection.
+     */
+    private selectCell;
+    private setActiveSheet;
+    private activateNextSheet;
+    private onColumnsRemoved;
+    private onRowsRemoved;
+    private onAddElements;
+    private onMoveElements;
+    private getFiguresUpdates;
+    private applyFigureUpdates;
+    private isMoveElementAllowed;
+    private isTableRowMoveAllowed;
+    private fallbackToVisibleSheet;
+    /**
+     * Clip the selection if it spans outside the sheet
+     */
+    private clipSelection;
+    drawLayer(renderingContext: GridRenderingContext): void;
+    getSelectionState(): SelectionState;
+}

package/dist/types/plugins/ui_stateful/sheetview.d.ts

@@ -0,0 +1,123 @@
+import { ViewportCollection } from "../../helpers/viewport_collection";
+import { Command, CommandResult, LocalCommand } from "../../types/commands";
+import { AnchorOffset, Figure, FigureUI } from "../../types/figure";
+import { CellPosition, Dimension, HeaderDimensions, HeaderIndex, Pixel, PixelPosition, UID, Zone } from "../../types/misc";
+import { DOMCoordinates, DOMDimension, EdgeScrollInfo, Rect, SheetDOMScrollInfo, Viewport } from "../../types/rendering";
+import { UIPlugin } from "../ui_plugin";
+/**
+ * Viewport plugin.
+ *
+ * This plugin manages all things related to all viewport states.
+ *
+ */
+export declare class SheetViewPlugin extends UIPlugin {
+    static getters: readonly ["getColIndex", "getRowIndex", "getActiveMainViewport", "getSheetViewDimension", "getSheetViewDimensionWithHeaders", "getMainViewportRect", "isVisibleInViewport", "getEdgeScrollCol", "getEdgeScrollRow", "getVisibleFigures", "getVisibleRect", "getVisibleRectWithoutHeaders", "getVisibleRectWithZoom", "getVisibleCellPositions", "getColRowOffsetInViewport", "getMainViewportCoordinates", "getActiveSheetScrollInfo", "getSheetViewVisibleCols", "getSheetViewVisibleRows", "getFrozenSheetViewRatio", "isPixelPositionVisible", "getColDimensionsInViewport", "getRowDimensionsInViewport", "getRect", "getFigureUI", "getPositionAnchorOffset", "getGridOffset", "getViewportZoomLevel", "getScrollBarWidth", "getMaximumSheetOffset", "getViewportCollection"];
+    private viewports;
+    private sheetsWithDirtyViewports;
+    private shouldAdjustViewports;
+    allowDispatch(cmd: LocalCommand): CommandResult | CommandResult[];
+    private handleEvent;
+    handle(cmd: Command): void;
+    finalize(): void;
+    private setViewports;
+    private syncPaneDivision;
+    /**
+     * Return the index of a column given an offset x, based on the viewport left
+     * visible cell.
+     * It returns -1 if no column is found.
+     */
+    getColIndex(x: Pixel): HeaderIndex;
+    /**
+     * Return the index of a row given an offset y, based on the viewport top
+     * visible cell.
+     * It returns -1 if no row is found.
+     */
+    getRowIndex(y: Pixel): HeaderIndex;
+    getSheetViewDimensionWithHeaders(): DOMDimension;
+    getSheetViewDimension(): DOMDimension;
+    getGridOffset(): DOMCoordinates;
+    /** type as pane, not viewport but basically pane extends viewport */
+    getActiveMainViewport(): Viewport;
+    /**
+     * Return the DOM scroll info of the active sheet, ie. the offset between the viewport left/top side and
+     * the grid left/top side, corresponding to the scroll of the scrollbars and not snapped to the grid.
+     */
+    getActiveSheetScrollInfo(): SheetDOMScrollInfo;
+    getSheetViewVisibleCols(): HeaderIndex[];
+    getSheetViewVisibleRows(): HeaderIndex[];
+    /**
+     * Get the positions of all the cells that are visible in the viewport, taking merges into account.
+     */
+    getVisibleCellPositions(): CellPosition[];
+    /**
+     * Return the main viewport maximum size relative to the client size.
+     */
+    getMainViewportRect(): Rect;
+    getMaximumSheetOffset(): {
+        maxOffsetX: Pixel;
+        maxOffsetY: Pixel;
+    };
+    getColRowOffsetInViewport(dimension: Dimension, referenceHeaderIndex: HeaderIndex, targetHeaderIndex: HeaderIndex): Pixel;
+    /**
+     * Check if a given position is visible in the viewport.
+     */
+    isVisibleInViewport(cellPosition: CellPosition): boolean;
+    getScrollBarWidth(): Pixel;
+    getEdgeScrollCol(x: number, previousX: number, startingX: number): EdgeScrollInfo;
+    getEdgeScrollRow(y: number, previousY: number, startingY: number): EdgeScrollInfo;
+    /**
+     * Computes the coordinates and size to draw the zone on the canvas
+     */
+    getVisibleRect(zone: Zone): Rect;
+    /**
+     * Computes the coordinates and size to draw the zone on the canvas after it has been zoomed
+     */
+    getVisibleRectWithZoom(zone: Zone): Rect;
+    /**
+     * Computes the coordinates and size to draw the zone without taking the grid offset into account
+     */
+    getVisibleRectWithoutHeaders(zone: Zone): Rect;
+    /**
+     * Computes the actual size and position (:Rect) of the zone on the canvas
+     * regardless of the viewport dimensions.
+     */
+    getRect(zone: Zone): Rect;
+    /**
+     * Computes the actual size and position (:Rect) of the zone on the canvas
+     * regardless of the viewport dimensions.
+     */
+    getRectWithoutHeaders(zone: Zone): Rect;
+    /**
+     * Returns the position of the MainViewport relatively to the start of the grid (without headers)
+     * It corresponds to the summed dimensions of the visible cols/rows (in x/y respectively)
+     * situated before the pane divisions.
+     */
+    getMainViewportCoordinates(): DOMCoordinates;
+    /**
+     * Returns the size, start and end coordinates of a column relative to the left
+     * column of the current viewport
+     */
+    getColDimensionsInViewport(sheetId: UID, col: HeaderIndex): HeaderDimensions;
+    /**
+     * Returns the size, start and end coordinates of a row relative to the top row
+     * of the current viewport
+     */
+    getRowDimensionsInViewport(sheetId: UID, row: HeaderIndex): HeaderDimensions;
+    getViewportZoomLevel(): number;
+    /**
+     * Shift the viewport vertically and move the selection anchor
+     * such that it remains at the same place relative to the
+     * viewport top.
+     */
+    private shiftVertically;
+    getVisibleFigures(): FigureUI[];
+    getFigureUI(sheetId: UID, figure: Figure): FigureUI;
+    getPositionAnchorOffset(position: PixelPosition): AnchorOffset;
+    isPixelPositionVisible(position: PixelPosition): boolean;
+    getFrozenSheetViewRatio(sheetId: UID): {
+        xRatio: number;
+        yRatio: number;
+    };
+    getViewportCollection(): ViewportCollection;
+    private getPaneDivisions;
+}

package/dist/types/registries/auto_completes/auto_complete_registry.d.ts

@@ -0,0 +1,59 @@
+import { HtmlContent } from "../../components/composer/composer/composer";
+import { EnrichedToken } from "../../formulas/composer_tokenizer";
+import { CellPosition, Getters } from "../../types";
+import { Registry } from "../registry";
+export interface AutoCompleteProposal {
+    /**
+     * Text to auto complete.
+     */
+    text: string;
+    description?: string;
+    /**
+     * Version of the text but displayed using html to highlight part of it.
+     */
+    htmlContent?: HtmlContent[];
+    /**
+     * Key to use for fuzzy search.
+     */
+    fuzzySearchKey?: string;
+    alwaysExpanded?: boolean;
+    staticDescription?: boolean;
+    icon?: string;
+}
+export interface AutoCompleteProvider {
+    proposals: AutoCompleteProposal[];
+    selectProposal(proposal: AutoCompleteProposal): void;
+    autoSelectFirstProposal: boolean;
+    canBeToggled?: boolean;
+}
+interface ComposerStoreInterface {
+    currentEditedCell?: CellPosition;
+    changeComposerCursorSelection(start: number, end: number): void;
+    replaceComposerCursorSelection(text: string): void;
+    setCurrentContent(content: string): void;
+    stopEdition(): void;
+    currentContent: string;
+    currentTokens: EnrichedToken[];
+}
+/**
+ * We declare the providers in the registry as an object (rather than a class)
+ * to allow a type-safe way to declare the provider.
+ * We still want to be able to use `this` for the getters and dispatch for simplicity.
+ * Binding happens at runtime in the composer store.
+ */
+export interface AutoCompleteProviderDefinition {
+    sequence?: number;
+    autoSelectFirstProposal?: boolean;
+    canBeToggled?: boolean;
+    displayAllOnInitialContent?: boolean;
+    maxDisplayedProposals?: number;
+    getProposals(this: {
+        composer: ComposerStoreInterface;
+        getters: Getters;
+    }, tokenAtCursor: EnrichedToken, content: string): AutoCompleteProposal[] | Promise<AutoCompleteProposal[]> | undefined;
+    selectProposal(this: {
+        composer: ComposerStoreInterface;
+    }, tokenAtCursor: EnrichedToken, propsal: AutoCompleteProposal): void;
+}
+export declare const autoCompleteProviders: Registry<AutoCompleteProviderDefinition>;
+export {};

package/dist/types/registries/auto_completes/data_validation_auto_complete.d.ts

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

package/dist/types/registries/auto_completes/function_auto_complete.d.ts

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

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

@@ -0,0 +1,5 @@
+export * from "./auto_complete_registry";
+import "./data_validation_auto_complete";
+import "./function_auto_complete";
+import "./pivot_auto_complete";
+import "./sheet_name_auto_complete";

package/dist/types/registries/auto_completes/pivot_auto_complete.d.ts

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

package/dist/types/registries/auto_completes/pivot_dimension_auto_complete.d.ts

@@ -0,0 +1,4 @@
+import { PivotRuntimeDefinition } from "../../helpers/pivot/pivot_runtime_definition";
+import { PivotMeasure } from "../../types";
+import { AutoCompleteProviderDefinition } from "./auto_complete_registry";
+export declare function createMeasureAutoComplete(pivot: PivotRuntimeDefinition, forComputedMeasure: PivotMeasure): AutoCompleteProviderDefinition;

package/dist/types/registries/auto_completes/sheet_name_auto_complete.d.ts

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

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

@@ -0,0 +1,7 @@
+import { AutofillModifierImplementation } from "../types/autofill";
+import { Registry } from "./registry";
+/**
+ * An AutofillModifierImplementation is used to describe how to handle a
+ * AutofillModifier.
+ */
+export declare const autofillModifiersRegistry: Registry<AutofillModifierImplementation>;

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

@@ -0,0 +1,22 @@
+import { AutofillModifier } from "../types/autofill";
+import { Cell } from "../types/cells";
+import { DIRECTION } from "../types/misc";
+import { Registry } from "./registry";
+/**
+ * An AutofillRule is used to generate what to do when we need to autofill
+ * a cell. (In a AutofillGenerator, see plugins/autofill.ts)
+ *
+ * When we generate the rules to autofill, we take the first matching rule
+ * (ordered by sequence), and we generate the AutofillModifier with generateRule
+ */
+export interface AutofillRule {
+    condition: (cell: Cell, cells: (Cell | undefined)[]) => boolean;
+    generateRule: (cell: Cell, cells: (Cell | undefined)[], direction: DIRECTION) => AutofillModifier;
+    sequence: number;
+}
+export interface CalendarDateInterval {
+    years: number;
+    months: number;
+    days: number;
+}
+export declare const autofillRulesRegistry: Registry<AutofillRule>;

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

@@ -0,0 +1,28 @@
+import { Box, RenderingBox } from "../types/rendering";
+import { Registry } from "./registry";
+interface CellAnimationItem {
+    id: string;
+    easingFn: keyof typeof EASING_FN;
+    /**
+     * Checks if the changes between the oldBox and newBox require an animation.
+     */
+    hasAnimation: (oldBox?: RenderingBox, newBox?: RenderingBox) => boolean;
+    /**
+     * Updates in place the given animatedBox with the animation progress.
+     *
+     * @param progress - The progress of the animation, from 0 to 1.
+     * @returns might return new boxes to be rendered for the animation
+     */
+    updateAnimation: (progress: number, animatedBox: RenderingBox, oldBox: RenderingBox, newBox: Box) => {
+        newBoxes: Box[];
+    } | void;
+}
+export declare const cellAnimationRegistry: Registry<CellAnimationItem>;
+export declare const EASING_FN: {
+    readonly linear: (t: number) => number;
+    readonly easeInCubic: (t: number) => number;
+    readonly easeOutCubic: (t: number) => number;
+    readonly easeInOutCubic: (t: number) => number;
+    readonly easeOutQuart: (t: number) => number;
+};
+export {};

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

@@ -0,0 +1,13 @@
+import { ComponentConstructor } from "@odoo/owl";
+import { CellPosition, Getters } from "../types";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+import { Registry } from "./registry";
+export interface CellClickableItem {
+    condition: (position: CellPosition, getters: Getters) => boolean;
+    execute: (position: CellPosition, env: SpreadsheetChildEnv, isMiddleClick?: boolean) => void;
+    title?: string | ((position: CellPosition, getters: Getters) => string);
+    sequence: number;
+    component?: ComponentConstructor;
+    componentProps?: (position: CellPosition, getters: Getters) => Record<string, unknown>;
+}
+export declare const clickableCellRegistry: Registry<CellClickableItem>;

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

@@ -0,0 +1,3 @@
+import { PopoverBuilders } from "../types/cell_popovers";
+import { Registry } from "./registry";
+export declare const cellPopoverRegistry: Registry<PopoverBuilders>;

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

@@ -0,0 +1,3 @@
+import { Component } from "@odoo/owl";
+import { Registry } from "./registry";
+export declare const chartComponentRegistry: Registry<new (...args: any) => Component>;

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

@@ -0,0 +1,3 @@
+import { ComponentConstructor } from "@odoo/owl";
+import { Registry } from "./registry";
+export declare const chartDataSourceSidePanelComponentRegistry: Registry<ComponentConstructor>;

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

@@ -0,0 +1,28 @@
+import { ChartCreationContext, ChartData, ChartDataSource, ChartDataSourceType, ChartType, DataSetStyle, ExcelChartDefinition } from "../types/chart";
+import { CommandResult } from "../types/commands";
+import { CoreGetters } from "../types/core_getters";
+import { Getters } from "../types/getters";
+import { RangeAdapterFunctions, UID } from "../types/misc";
+import { Validator } from "../types/validator";
+import { Registry } from "./registry";
+export interface ChartDataSourceBuilder<TExternal, TInternal> {
+    supportedChartTypes: readonly ChartType[];
+    fromExternalDefinition: (dataSource: TExternal, defaultSheetId: UID, getters: CoreGetters) => TInternal;
+    fromContextCreation: (context: ChartCreationContext) => ChartDataSource<string>;
+    fromHierarchicalContextCreation: (context: ChartCreationContext) => ChartDataSource<string>;
+    validate: (dataSource: TExternal, validator: Validator) => CommandResult | CommandResult[];
+    transform(dataSource: TExternal, defaultSheetId: UID, rangeAdapters: RangeAdapterFunctions): TExternal;
+    extractData(dataSource: TInternal, chartId: UID, getters: Getters): ChartData;
+    extractHierarchicalData(dataSource: TInternal, chartId: UID, getters: Getters): ChartData;
+    adaptRanges(dataSource: TInternal, rangeAdapters: RangeAdapterFunctions): TInternal;
+    duplicateInDuplicatedSheet(dataSource: TInternal, sheetIdFrom: UID, sheetIdTo: UID, getters: CoreGetters): TInternal;
+    getDefinition(dataSource: TInternal, defaultSheetId: UID, getters: CoreGetters): TExternal;
+    getContextCreation(dataSource: TExternal): ChartCreationContext;
+    getHierarchicalContextCreation(dataSource: TExternal): ChartCreationContext;
+    toExcelDataSets(dataSource: TInternal, dataSetStyles: DataSetStyle, getters: CoreGetters): Pick<ExcelChartDefinition, "dataSets" | "labelRange"> | undefined;
+    onDataSetClick?: (chartType: ChartType, chartId: UID, event: unknown, items: unknown, chartJsChart: unknown, getters: Getters) => void;
+}
+export interface ChartDataSourceRegistry extends Registry<ChartDataSourceBuilder<unknown, unknown>> {
+    add<T extends ChartDataSourceType>(type: T, builder: ChartDataSourceBuilder<unknown, unknown>): this;
+}
+export declare const chartDataSourceRegistry: ChartDataSourceRegistry;

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

@@ -0,0 +1,64 @@
+import { Getters, Range } from "../types";
+import { ChartCreationContext, ChartData, ChartRuntime, ChartType, ChartTypeDefinition, ExcelChartDefinition } from "../types/chart";
+import { CommandResult } from "../types/commands";
+import { CoreGetters } from "../types/core_getters";
+import { RangeAdapterFunctions, UID } from "../types/misc";
+import { Validator } from "../types/validator";
+import { ChartDataSourceBuilder } from "./chart_data_source_registry";
+import { Registry } from "./registry";
+/**
+ * Instantiate a chart object based on a definition
+ */
+export interface ChartTypeBuilder<T extends ChartType> {
+    /**
+     * Returns the definition with parsed ranges (Range instead of string).
+     * Do not need handle the data source.
+     */
+    fromStrDefinition(definition: ChartTypeDefinition<T, string>, sheetId: UID, getters: CoreGetters): Omit<ChartTypeDefinition<T, Range>, "dataSource">;
+    /**
+     * Returns the definition with ranges as string.
+     * Do not need handle the data source.
+     */
+    toStrDefinition(definition: ChartTypeDefinition<T, Range>, sheetId: UID, getters: CoreGetters): Omit<ChartTypeDefinition<T, string>, "dataSource">;
+    validateDefinition: (validator: Validator, definition: ChartTypeDefinition<NoInfer<T>, string>) => CommandResult | CommandResult[];
+    transformDefinition(definition: ChartTypeDefinition<T, string>, sheetId: UID, rangeAdapters: RangeAdapterFunctions): ChartTypeDefinition<T, string>;
+    /**
+     * Update all ranges of the chart after
+     * a grid change (add/remove col/row, rename sheet, ...)
+     */
+    updateRanges(definition: ChartTypeDefinition<T, Range>, rangeAdapters: RangeAdapterFunctions, sheetId: UID): ChartTypeDefinition<T, Range>;
+    /**
+     * Duplicate the chart when a sheet is duplicated.
+     * The ranges that are in the same sheet as the chart are adapted to the new sheetId.
+     */
+    duplicateInDuplicatedSheet(definition: ChartTypeDefinition<T, Range>, sheetIdFrom: UID, sheetIdTo: UID, getters: CoreGetters): ChartTypeDefinition<T, Range>;
+    /**
+     * Get a copy a the chart in the given sheetId.
+     * The ranges of the chart will stay the same as the copied chart.
+     */
+    copyInSheetId(definition: ChartTypeDefinition<T, Range>, sheetIdFrom: UID, sheetIdTo: UID, getters: CoreGetters): ChartTypeDefinition<T, Range>;
+    getContextCreation(definition: ChartTypeDefinition<T, string>, dataSourceBuilder: ChartDataSourceBuilder<unknown, unknown>, dataSource: ChartTypeDefinition<T, string>["dataSource"]): ChartCreationContext;
+    getDefinitionFromContextCreation(context: ChartCreationContext, dataSourceBuilder: ChartDataSourceBuilder<unknown, unknown>): ChartTypeDefinition<T, string>;
+    /**
+     * Get the definition of the chart used for excel export.
+     * If the chart is not supported by Excel, this function returns undefined.
+     */
+    getDefinitionForExcel(getters: Getters, definition: ChartTypeDefinition<T, Range>, params: Pick<ExcelChartDefinition, "dataSets" | "labelRange">): ExcelChartDefinition | undefined;
+    getRuntime(getters: Getters, definition: ChartTypeDefinition<T, Range>, chartDataExtractors: ChartDataExtractors, sheetId: UID, eventHandlers: ChartJsEventHandlers): ChartRuntime;
+    allowedDefinitionKeys: readonly string[];
+    sequence: number;
+    dataSeriesLimit?: number;
+}
+interface ChartDataExtractors {
+    extractData(): ChartData;
+    extractHierarchicalData(): ChartData;
+}
+interface ChartJsEventHandlers {
+    onClick?: (event: unknown, items: unknown, chartJsChart: unknown) => void;
+    onHover?: (event: unknown, items: unknown, chartJsChart: unknown) => void;
+}
+export interface ChartTypeRegistry extends Registry<ChartTypeBuilder<any>> {
+    add<T extends ChartType>(type: T, builder: ChartTypeBuilder<T>): this;
+}
+export declare const chartTypeRegistry: ChartTypeRegistry;
+export {};

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

@@ -0,0 +1,3 @@
+import { ChartSubtypeProperties } from "../types/chart_subtype_properties";
+import { Registry } from "./registry";
+export declare const chartSubtypeRegistry: Registry<ChartSubtypeProperties>;

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

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

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

@@ -0,0 +1,7 @@
+import { AbstractCellClipboardHandler } from "../clipboard_handlers/abstract_cell_clipboard_handler";
+import { AbstractFigureClipboardHandler } from "../clipboard_handlers/abstract_figure_clipboard_handler";
+import { Registry } from "./registry";
+export declare const clipboardHandlersRegistries: {
+    figureHandlers: Registry<typeof AbstractFigureClipboardHandler<any>>;
+    cellHandlers: Registry<typeof AbstractCellClipboardHandler<any, any>>;
+};

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

@@ -0,0 +1,13 @@
+import { ComponentConstructor } from "@odoo/owl";
+import { GenericCriterionType, ValueAndLabel } from "../types";
+import { Registry } from "./registry";
+export type CriterionCategory = "text" | "date" | "number" | "misc" | "list" | "relative";
+export declare const criterionCategoriesSequences: Record<CriterionCategory, number>;
+export type DataValidationCriterionItem = {
+    type: GenericCriterionType;
+    component: ComponentConstructor | undefined;
+    sequence: number;
+    category: CriterionCategory;
+};
+export declare const criterionComponentRegistry: Registry<DataValidationCriterionItem>;
+export declare function getCriterionValueAndLabels(availableTypes: Set<GenericCriterionType>): ValueAndLabel[];

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

@@ -0,0 +1,44 @@
+import { CellValue } from "../types/cells";
+import { EvaluatedCriterion, GenericCriterion, GenericCriterionType } from "../types/generic_criterion";
+import { Getters } from "../types/getters";
+import { UID } from "../types/misc";
+import { Range } from "../types/range";
+import { Registry } from "./registry";
+export type CriterionEvaluator<T = unknown> = {
+    type: GenericCriterionType;
+    /**
+     * Checks if a value is valid for the given criterion.
+     *
+     * The value and the criterion values should be in canonical form (non-localized), and formulas should
+     * be evaluated.
+     *
+     * For more complex criteria (like "top10"), a computation cache may be returned to avoid recomputing the entire criterion
+     * on every value it applies to.
+     */
+    isValueValid: (value: CellValue, criterion: EvaluatedCriterion, preComputedCriterion?: T) => boolean;
+    /**
+     * For more complex criteria (like "top10"), we might want to pre-compute some data before evaluating the criterion for
+     * each cell, to avoid recomputing everything each time.
+     */
+    preComputeCriterion?: (criterion: GenericCriterion, criterionRanges: Range[], getters: Getters) => T;
+    /**
+     * Returns the error string to display when the value is not valid.
+     *
+     * The criterion values should be in canonical form (non-localized), and formulas should be evaluated.
+     */
+    getErrorString: (criterion: EvaluatedCriterion, getters: Getters, sheetId: UID) => string;
+    /**
+     * Checks if a criterion value is valid.
+     *
+     * The value should be in canonical form (non-localized).
+     */
+    isCriterionValueValid: (value: string) => boolean;
+    /** Return the number of values that the criterion must contains. Return undefined if the criterion can have any number of values */
+    numberOfValues: (criterion: GenericCriterion) => number | undefined;
+    name: string;
+    getPreview: (criterion: GenericCriterion, getters: Getters) => string;
+    /** Error string when a criterion value is invalid */
+    criterionValueErrorString: string;
+    allowedValues?: "onlyLiterals" | "onlyFormulas";
+};
+export declare const criterionEvaluatorRegistry: Registry<CriterionEvaluator<unknown>>;

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

@@ -0,0 +1,7 @@
+import { Currency } from "../types";
+import { Registry } from "./registry";
+/**
+ * Registry intended to support usual currencies. It is mainly used to create
+ * currency formats that can be selected or modified when customizing formats.
+ */
+export declare const currenciesRegistry: Registry<Currency>;