@odoo/o-spreadsheet 17.0.84 → 17.0.96

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

@@ -0,0 +1,26 @@
+import { Border, CellPosition, Command, CommandResult, ExcelWorkbookData, UID } from "../../types";
+import { LocalCommand } from "../../types/commands";
+import { UIPlugin } from "../ui_plugin";
+export declare class FilterEvaluationPlugin extends UIPlugin {
+    static getters: readonly ["getCellBorderWithFilterBorder", "getFilterValues", "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;
+    getCellBorderWithFilterBorder(position: CellPosition): Border | null;
+    getFilterValues(position: CellPosition): string[];
+    isFilterActive(position: CellPosition): boolean;
+    private intersectZoneWithViewport;
+    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,5 @@
+export * from "./clipboard";
+export * from "./edition";
+export * from "./filter_evaluation";
+export * from "./selection";
+export * from "./sheetview";

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

@@ -0,0 +1,78 @@
+import { CellPosition, Command, CommandResult, Dimension, EvaluatedCell, GridRenderingContext, LAYERS, LocalCommand, Selection, Sheet, Style, UID, Zone } from "../../types/index";
+import { UIPlugin, UIPluginConfig } from "../ui_plugin";
+/**
+ * SelectionPlugin
+ */
+export declare class GridSelectionPlugin extends UIPlugin {
+    static layers: LAYERS[];
+    static getters: readonly ["getActiveSheet", "getActiveSheetId", "getActiveCell", "getActiveCols", "getActiveRows", "getCurrentStyle", "getSelectedZones", "getSelectedZone", "getSelectedCells", "getStatisticFnResults", "getAggregate", "getSelectedFigureId", "getSelection", "getActivePosition", "getSheetPosition", "isSelected", "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;
+    getStatisticFnResults(): {
+        [name: string]: number | undefined;
+    };
+    getAggregate(): string | null;
+    isSelected(zone: Zone): boolean;
+    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 fallbackToVisibleSheet;
+    /**
+     * Clip the selection if it spans outside the sheet
+     */
+    private clipSelection;
+    drawGrid(renderingContext: GridRenderingContext): void;
+}

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

@@ -0,0 +1,164 @@
+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 { 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", "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;
+    getAllActiveViewportsZonesAndRect(): {
+        zone: Zone;
+        rect: Rect;
+    }[];
+    private ensureMainViewportExist;
+    private getSubViewports;
+    private checkPositiveDimension;
+    private checkValuesAreDifferent;
+    private checkScrollingDirection;
+    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/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,15 @@
+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 declare const autofillRulesRegistry: Registry<AutofillRule>;

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

@@ -0,0 +1,8 @@
+import { CellPosition, SpreadsheetChildEnv } from "../types";
+import { Registry } from "./registry";
+export interface CellClickableItem {
+    condition: (position: CellPosition, env: SpreadsheetChildEnv) => 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,28 @@
+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;
+    name: string;
+    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>;

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/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, onFigureDeleted: () => void, env: SpreadsheetChildEnv) => Action[];
+    SidePanelComponent?: string;
+    keepRatio?: boolean;
+    minFigSize?: number;
+    borderWidth?: number;
+}
+export declare const figureRegistry: Registry<FigureContent>;

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

@@ -0,0 +1,11 @@
+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 "./side_panel_registry";
+export * from "./topbar_component_registry";

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

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

@@ -0,0 +1,19 @@
+import { Action, ActionBuilder, ActionSpec } from "../actions/action";
+import { Registry } from "./registry";
+/**
+ * The class Registry is extended in order to add the function addChild
+ *
+ */
+export declare class MenuItemRegistry extends Registry<ActionSpec> {
+    /**
+     * @override
+     */
+    add(key: string, value: ActionSpec): MenuItemRegistry;
+    /**
+     * Add a subitem to an existing item
+     * @param path Path of items to add this subitem
+     * @param value Subitem to add
+     */
+    addChild(key: string, path: string[], value: ActionSpec | ActionBuilder): MenuItemRegistry;
+    getMenuItems(): Action[];
+}

package/dist/types/registries/menus/cell_menu_registry.d.ts

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

package/dist/types/registries/menus/col_menu_registry.d.ts

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

package/dist/types/registries/menus/header_group_registry.d.ts

@@ -0,0 +1,7 @@
+import { Action } from "../../actions/action";
+import { Dimension, UID } from "../../types";
+import { MenuItemRegistry } from "../menu_items_registry";
+export declare function createHeaderGroupContainerContextMenu(sheetId: UID, dimension: Dimension): Action[];
+export declare function getHeaderGroupContextMenu(sheetId: UID, dimension: Dimension, start: number, end: number): Action[];
+export declare const groupHeadersMenuRegistry: MenuItemRegistry;
+export declare const unGroupHeadersMenuRegistry: MenuItemRegistry;

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

@@ -0,0 +1,7 @@
+export * from "./cell_menu_registry";
+export * from "./col_menu_registry";
+export * from "./link_menu_registry";
+export * from "./number_format_menu_registry";
+export * from "./row_menu_registry";
+export * from "./sheet_menu_registry";
+export * from "./topbar_menu_registry";

package/dist/types/registries/menus/link_menu_registry.d.ts

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

package/dist/types/registries/menus/number_format_menu_registry.d.ts

@@ -0,0 +1,4 @@
+import { ActionSpec } from "../../actions/action";
+import { MenuItemRegistry } from "../menu_items_registry";
+export declare const numberFormatMenuRegistry: MenuItemRegistry;
+export declare const formatNumberMenuItemSpec: ActionSpec;

package/dist/types/registries/menus/row_menu_registry.d.ts

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

package/dist/types/registries/menus/sheet_menu_registry.d.ts

@@ -0,0 +1,4 @@
+import { MenuItemRegistry } from "../menu_items_registry";
+export declare function getSheetMenuRegistry(args: {
+    renameSheetCallback: () => void;
+}): MenuItemRegistry;

package/dist/types/registries/menus/topbar_menu_registry.d.ts

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

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

@@ -0,0 +1,21 @@
+import { CoreCommand, CoreCommandTypes } from "../types";
+import { Registry } from "./registry";
+export type TransformationFunction<U extends CoreCommandTypes, V extends CoreCommandTypes> = (toTransform: Extract<CoreCommand, {
+    type: U;
+}>, executed: Extract<CoreCommand, {
+    type: V;
+}>) => CoreCommand | undefined;
+export declare class OTRegistry extends Registry<Map<CoreCommandTypes, TransformationFunction<CoreCommandTypes, CoreCommandTypes>>> {
+    /**
+     * Add a transformation function to the registry. When the executed command
+     * happened, all the commands in toTransforms should be transformed using the
+     * transformation function given
+     */
+    addTransformation<U extends CoreCommandTypes, V extends CoreCommandTypes>(executed: U, toTransforms: V[], fn: TransformationFunction<CoreCommandTypes, CoreCommandTypes>): this;
+    /**
+     * Get the transformation function to transform the command toTransform, after
+     * that the executed command happened.
+     */
+    getTransformation<U extends CoreCommandTypes, V extends CoreCommandTypes>(toTransform: U, executed: V): TransformationFunction<CoreCommandTypes, CoreCommandTypes> | undefined;
+}
+export declare const otRegistry: OTRegistry;

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

@@ -0,0 +1,44 @@
+/**
+ * Registry
+ *
+ * The Registry class is basically just a mapping from a string key to an object.
+ * It is really not much more than an object. It is however useful for the
+ * following reasons:
+ *
+ * 1. it let us react and execute code when someone add something to the registry
+ *   (for example, the FunctionRegistry subclass this for this purpose)
+ * 2. it throws an error when the get operation fails
+ * 3. it provides a chained API to add items to the registry.
+ */
+export declare class Registry<T> {
+    content: {
+        [key: string]: T;
+    };
+    /**
+     * Add an item to the registry
+     *
+     * Note that this also returns the registry, so another add method call can
+     * be chained
+     */
+    add(key: string, value: T): Registry<T>;
+    /**
+     * Get an item from the registry
+     */
+    get(key: string): T;
+    /**
+     * Check if the key is already in the registry
+     */
+    contains(key: string): boolean;
+    /**
+     * Get a list of all elements in the registry
+     */
+    getAll(): T[];
+    /**
+     * Get a list of all keys in the registry
+     */
+    getKeys(): string[];
+    /**
+     * Remove an item from the registry
+     */
+    remove(key: string): void;
+}

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

@@ -0,0 +1,20 @@
+import { CoreCommand, Getters } from "../types";
+import { Command, LocalCommand } from "./../types/commands";
+import { Registry } from "./registry";
+type RepeatTransform = (getters: Getters, cmd: CoreCommand) => CoreCommand | undefined;
+type LocalRepeatTransform = (getters: Getters, cmd: LocalCommand, childCommands: readonly CoreCommand[]) => CoreCommand[] | LocalCommand | undefined;
+/**
+ *  Registry containing all the command that can be repeated on redo, and function to transform them
+ *  to the current state of the model.
+ *
+ * If the transform function is undefined, the command will be transformed using generic transformations.
+ * (change the sheetId, the row, the col, the target, the ranges, to the current active sheet & selection)
+ *
+ */
+export declare const repeatCommandTransformRegistry: Registry<RepeatTransform>;
+export declare const repeatLocalCommandTransformRegistry: Registry<LocalRepeatTransform>;
+export declare function genericRepeat<T extends Command>(getters: Getters, command: T): T;
+export declare function repeatCoreCommand(getters: Getters, command: CoreCommand | undefined): CoreCommand | undefined;
+export declare function repeatLocalCommand(getters: Getters, command: LocalCommand, childCommands: readonly CoreCommand[]): CoreCommand[] | LocalCommand | undefined;
+export declare function repeatLocalCommandChildren<T extends LocalCommand>(getters: Getters, cmd: T, childCommands: readonly CoreCommand[]): CoreCommand[] | undefined;
+export {};

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

@@ -0,0 +1,8 @@
+import { SpreadsheetChildEnv } from "../types";
+import { Registry } from "./registry";
+export interface SidePanelContent {
+    title: string | ((env: SpreadsheetChildEnv) => string);
+    Body: any;
+    Footer?: any;
+}
+export declare const sidePanelRegistry: Registry<SidePanelContent>;

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

@@ -0,0 +1,18 @@
+import { UuidGenerator } from "../helpers";
+import { UID } from "../types";
+import { SpreadsheetChildEnv } from "../types/env";
+import { Registry } from "./registry";
+export interface TopbarComponent {
+    id: UID;
+    component: any;
+    isVisible?: (env: SpreadsheetChildEnv) => boolean;
+}
+declare class TopBarComponentRegistry extends Registry<TopbarComponent> {
+    mapping: {
+        [key: string]: Function;
+    };
+    uuidGenerator: UuidGenerator;
+    add(name: string, value: Omit<TopbarComponent, "id">): Registry<TopbarComponent>;
+}
+export declare const topbarComponentRegistry: TopBarComponentRegistry;
+export {};