@odoo/o-spreadsheet 18.0.55 → 18.0.67

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

@@ -0,0 +1,58 @@
+import { MinimalClipboardData, OSClipboardContent } from "../../types/clipboard";
+import { Command, CommandResult, GridRenderingContext, LocalCommand } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export interface SpreadsheetClipboardData extends MinimalClipboardData {
+    version?: number;
+    clipboardId?: string;
+}
+/**
+ * Clipboard Plugin
+ *
+ * This clipboard manages all cut/copy/paste interactions internal to the
+ * application, and with the OS clipboard as well.
+ */
+export declare class ClipboardPlugin extends UIPlugin {
+    static layers: readonly ["Clipboard"];
+    static getters: readonly ["getClipboardContent", "getClipboardId", "getClipboardTextContent", "isCutOperation"];
+    private status;
+    private originSheetId?;
+    private copiedData?;
+    private _isCutOperation;
+    private clipboardId;
+    allowDispatch(cmd: LocalCommand): CommandResult;
+    handle(cmd: Command): void;
+    private convertTextToClipboardData;
+    private selectClipboardHandlers;
+    private isCutAllowedOn;
+    private isPasteAllowed;
+    private isColRowDirtyingClipboard;
+    private copy;
+    private paste;
+    /**
+     * Add columns and/or rows to ensure that col + width and row + height are still
+     * in the sheet
+     */
+    private addMissingDimensions;
+    /**
+     * Format the current clipboard to a string suitable for being pasted in other
+     * programs.
+     *
+     * - add a tab character between each consecutive cells
+     * - add a newline character between each line
+     *
+     * Note that it returns \t if the clipboard is empty. This is necessary for the
+     * clipboard copy event to add it as data, otherwise an empty string is not
+     * considered as a copy content.
+     */
+    getClipboardTextContent(): string;
+    getClipboardId(): string;
+    getClipboardContent(): OSClipboardContent;
+    private getSheetData;
+    private getPlainTextContent;
+    private getHTMLContent;
+    isCutOperation(): boolean;
+    private getDeleteCellsTargets;
+    private getInsertCellsTargets;
+    private getClipboardData;
+    drawLayer(renderingContext: GridRenderingContext): void;
+}

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

@@ -0,0 +1,25 @@
+import { CellPosition, Command, CommandResult, ExcelWorkbookData, Table, UID } from "../../types";
+import { LocalCommand } from "../../types/commands";
+import { UIPlugin } from "../ui_plugin";
+export declare class FilterEvaluationPlugin extends UIPlugin {
+    static getters: readonly ["getFilterHiddenValues", "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;
+    getFilterHiddenValues(position: CellPosition): string[];
+    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, UID } from "../../types";
+import { Dimension, HeaderDimensions, HeaderIndex, Pixel } 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/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./clipboard";
+export * from "./filter_evaluation";
+export * from "./selection";
+export * from "./sheetview";

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

@@ -0,0 +1,74 @@
+import { CellPosition, Command, CommandResult, Dimension, EvaluatedCell, GridRenderingContext, LocalCommand, Selection, Sheet, Style, UID, Zone } from "../../types/index";
+import { UIPlugin, UIPluginConfig } from "../ui_plugin";
+/**
+ * SelectionPlugin
+ */
+export declare class GridSelectionPlugin extends UIPlugin {
+    static layers: readonly ["Selection"];
+    static getters: readonly ["getActiveSheet", "getActiveSheetId", "getActiveCell", "getActiveCols", "getActiveRows", "getCurrentStyle", "getSelectedZones", "getSelectedZone", "getSelectedCells", "getSelectedFigureId", "getSelection", "getActivePosition", "getSheetPosition", "isSingleColSelected", "getElementsFromSelection", "tryGetActiveSheetId", "isGridSelectionActive"];
+    private gridSelection;
+    private selectedFigureId;
+    private sheetsData;
+    private moveClient;
+    activeSheet: Sheet;
+    constructor(config: UIPluginConfig);
+    allowDispatch(cmd: LocalCommand): CommandResult;
+    private handleEvent;
+    handle(cmd: Command): void;
+    finalize(): void;
+    isGridSelectionActive(): boolean;
+    getActiveSheet(): Readonly<Sheet>;
+    getActiveSheetId(): UID;
+    tryGetActiveSheetId(): UID | undefined;
+    getActiveCell(): EvaluatedCell;
+    getActiveCols(): Set<number>;
+    getActiveRows(): Set<number>;
+    getCurrentStyle(): Style;
+    getSelectedZones(): Zone[];
+    getSelectedZone(): Zone;
+    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[];
+    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 isMoveElementAllowed;
+    private isTableRowMoveAllowed;
+    private fallbackToVisibleSheet;
+    /**
+     * Clip the selection if it spans outside the sheet
+     */
+    private clipSelection;
+    drawLayer(renderingContext: GridRenderingContext): void;
+}

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

@@ -0,0 +1,175 @@
+import { InternalViewport } from "../../helpers/internal_viewport";
+import { CellPosition, Command, CommandResult, DOMCoordinates, DOMDimension, Dimension, EdgeScrollInfo, Figure, HeaderIndex, LocalCommand, Pixel, Rect, SheetDOMScrollInfo, SheetScrollInfo, UID, Viewport, Zone } from "../../types/index";
+import { HeaderDimensions, PixelPosition } from "../../types/misc";
+import { UIPlugin } from "../ui_plugin";
+/**
+ *   EdgeScrollCases Schema
+ *
+ *  The dots/double dots represent a freeze (= a split of viewports)
+ *  In this example, we froze vertically between columns D and E
+ *  and horizontally between rows 4 and 5.
+ *
+ *  One can see that we scrolled horizontally from column E to G and
+ *  vertically from row 5 to 7.
+ *
+ *     A  B  C  D   G  H  I  J  K  L  M  N  O  P  Q  R  S  T
+ *     _______________________________________________________
+ *  1 |           :                                           |
+ *  2 |           :                                           |
+ *  3 |           :        B   ↑                 6            |
+ *  4 |           :        |   |                 |            |
+ *     ····················+···+·················+············|
+ *  7 |           :        |   |                 |            |
+ *  8 |           :        ↓   2                 |            |
+ *  9 |           :                              |            |
+ * 10 |       A --+--→                           |            |
+ * 11 |           :                              |            |
+ * 12 |           :                              |            |
+ * 13 |        ←--+-- 1                          |            |
+ * 14 |           :                              |        3 --+--→
+ * 15 |           :                              |            |
+ * 16 |           :                              |            |
+ * 17 |       5 --+-------------------------------------------+--→
+ * 18 |           :                              |            |
+ * 19 |           :                  4           |            |
+ * 20 |           :                  |           |            |
+ *     ______________________________+___________| ____________
+ *                                   |           |
+ *                                   ↓           ↓
+ */
+/**
+ * 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", "getVisibleCellPositions", "getColRowOffsetInViewport", "getMainViewportCoordinates", "getActiveSheetScrollInfo", "getActiveSheetDOMScrollInfo", "getSheetViewVisibleCols", "getSheetViewVisibleRows", "getFrozenSheetViewRatio", "isPositionVisible", "getColDimensionsInViewport", "getRowDimensionsInViewport", "getAllActiveViewportsZonesAndRect", "getRect"];
+    private viewports;
+    /**
+     * The viewport dimensions are usually set by one of the components
+     * (i.e. when grid component is mounted) to properly reflect its state in the DOM.
+     * In the absence of a component (standalone model), is it mandatory to set reasonable default values
+     * to ensure the correct operation of this plugin.
+     */
+    private sheetViewWidth;
+    private sheetViewHeight;
+    private gridOffsetX;
+    private gridOffsetY;
+    private sheetsWithDirtyViewports;
+    private shouldAdjustViewports;
+    allowDispatch(cmd: LocalCommand): CommandResult | CommandResult[];
+    private handleEvent;
+    handle(cmd: Command): void;
+    finalize(): void;
+    private setViewports;
+    /**
+     * 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;
+    /** type as pane, not viewport but basically pane extends viewport */
+    getActiveMainViewport(): Viewport;
+    /**
+     * Return the scroll info of the active sheet, ie. the offset between the viewport left/top side and
+     * the grid left/top side, snapped to the columns/rows.
+     */
+    getActiveSheetScrollInfo(): SheetScrollInfo;
+    /**
+     * 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.
+     */
+    getActiveSheetDOMScrollInfo(): 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;
+    private getMaximumSheetOffset;
+    getColRowOffsetInViewport(dimension: Dimension, referenceHeaderIndex: HeaderIndex, targetHeaderIndex: HeaderIndex): Pixel;
+    /**
+     * Check if a given position is visible in the viewport.
+     */
+    isVisibleInViewport({ sheetId, col, row }: CellPosition): boolean;
+    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 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;
+    /**
+     * 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;
+    getAllActiveViewportsZonesAndRect(): {
+        zone: Zone;
+        rect: Rect;
+    }[];
+    private ensureMainViewportExist;
+    private getSubViewports;
+    private checkPositiveDimension;
+    private checkValuesAreDifferent;
+    private checkScrollingDirection;
+    private checkIfViewportsWillChange;
+    private getMainViewport;
+    private getMainInternalViewport;
+    /** gets rid of deprecated sheetIds */
+    private cleanViewports;
+    private resizeSheetView;
+    private recomputeViewports;
+    private setSheetViewOffset;
+    private getViewportOffset;
+    private resetViewports;
+    /**
+     * Adjust the viewport such that the anchor position is visible
+     */
+    private refreshViewport;
+    /**
+     * 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(): Figure[];
+    isPositionVisible(position: PixelPosition): boolean;
+    getFrozenSheetViewRatio(sheetId: UID): {
+        xRatio: number;
+        yRatio: number;
+    };
+    mapViewportsToRect(sheetId: UID, rectCallBack: (viewport: InternalViewport) => Rect | undefined): Rect;
+}

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

@@ -0,0 +1,56 @@
+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;
+}
+export interface AutoCompleteProvider {
+    proposals: AutoCompleteProposal[];
+    selectProposal(text: string): 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[] | undefined;
+    selectProposal(this: {
+        composer: ComposerStoreInterface;
+    }, tokenAtCursor: EnrichedToken, text: string): 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 @@
+import "./data_validation_auto_complete";
+import "./function_auto_complete";
+import "./pivot_auto_complete";
+import "./sheet_name_auto_complete";
+export * from "./auto_complete_registry";

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/index";
+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,20 @@
+import { AutofillModifier, Cell, DIRECTION } from "../types/index";
+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_clickable_registry.d.ts

@@ -0,0 +1,8 @@
+import { CellPosition, Getters, SpreadsheetChildEnv } from "../types";
+import { Registry } from "./registry";
+export interface CellClickableItem {
+    condition: (position: CellPosition, getters: Getters) => boolean;
+    execute: (position: CellPosition, env: SpreadsheetChildEnv) => void;
+    sequence: number;
+}
+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_types.d.ts

@@ -0,0 +1,52 @@
+import { Component } from "@odoo/owl";
+import { AbstractChart } from "../helpers/figures/charts/abstract_chart";
+import { AddColumnsRowsCommand, CommandResult, CoreGetters, Getters, RemoveColumnsRowsCommand, UID } from "../types";
+import { ChartCreationContext, ChartDefinition, ChartRuntime, ChartType } from "../types/chart/chart";
+import { Validator } from "../types/validator";
+import { Registry } from "./registry";
+/**
+ * Instantiate a chart object based on a definition
+ */
+export interface ChartBuilder {
+    /**
+     * Check if this factory should be used
+     */
+    match: (type: ChartType) => boolean;
+    createChart: (definition: ChartDefinition, sheetId: UID, getters: CoreGetters) => AbstractChart;
+    getChartRuntime: (chart: AbstractChart, getters: Getters) => ChartRuntime;
+    validateChartDefinition(validator: Validator, definition: ChartDefinition): CommandResult | CommandResult[];
+    transformDefinition(definition: ChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): ChartDefinition;
+    getChartDefinitionFromContextCreation(context: ChartCreationContext): ChartDefinition;
+    sequence: number;
+}
+/**
+ * This registry is intended to map a cell content (raw string) to
+ * an instance of a cell.
+ */
+export declare const chartRegistry: Registry<ChartBuilder>;
+export declare const chartComponentRegistry: Registry<new (...args: any) => Component>;
+type ChartUICategory = keyof typeof chartCategories;
+export declare const chartCategories: {
+    line: string;
+    column: string;
+    bar: string;
+    area: string;
+    pie: string;
+    misc: string;
+};
+export interface ChartSubtypeProperties {
+    /** Type shown in the chart side panel */
+    chartSubtype: string;
+    /** Translated name of the displayType */
+    displayName: string;
+    /** Type of the chart in the model */
+    chartType: ChartType;
+    /** Match the chart type with a chart display type. Optional if chartType === displayType  */
+    matcher?: (definition: ChartDefinition) => boolean;
+    /** Additional definition options to create a chart of type displayType */
+    subtypeDefinition?: Partial<ChartDefinition>;
+    category: ChartUICategory;
+    preview: string;
+}
+export declare const chartSubtypeRegistry: Registry<ChartSubtypeProperties>;
+export {};

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>;

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

@@ -0,0 +1,32 @@
+import { CellValue, DataValidationCriterion, DataValidationCriterionType, Getters, UID } from "../types";
+import { Registry } from "./registry";
+export type DataValidationCriterionEvaluator = {
+    type: DataValidationCriterionType;
+    /**
+     * 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.
+     */
+    isValueValid: (value: CellValue, criterion: DataValidationCriterion, getters: Getters, sheetId: UID) => boolean;
+    /**
+     * 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: DataValidationCriterion, 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: DataValidationCriterion) => number | undefined;
+    name: string;
+    getPreview: (criterion: DataValidationCriterion, getters: Getters) => string;
+    /** Error string when a criterion value is invalid */
+    criterionValueErrorString: string;
+    allowedValues?: "onlyLiterals" | "onlyFormulas";
+};
+export declare const dataValidationEvaluatorRegistry: Registry<DataValidationCriterionEvaluator>;

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { CellPosition, Getters } from "../types";
+import { ImageSrc } from "../types/image";
+import { Registry } from "./registry";
+type ImageSrcCallback = (getters: Getters, position: CellPosition) => ImageSrc | undefined;
+/**
+ * Registry to draw icons on cells
+ */
+export declare const iconsOnCellRegistry: Registry<ImageSrcCallback>;
+export {};

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

@@ -0,0 +1,12 @@
+export * from "./auto_completes/index";
+export * from "./autofill_modifiers";
+export * from "./autofill_rules";
+export * from "./cell_popovers_registry";
+export * from "./chart_types";
+export * from "./currencies_registry";
+export * from "./figure_registry";
+export * from "./inverse_command_registry";
+export * from "./menus/index";
+export * from "./ot_registry";
+export * from "./topbar_component_registry";
+import "./side_panel_registry_entries";

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

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