@odoo/o-spreadsheet 17.0.84 → 17.0.96

package/dist/types/plugins/ui_core_views/cell_evaluation/evaluator.d.ts

@@ -0,0 +1,90 @@
+import { ModelConfig } from "../../../model";
+import { CellPosition, EvaluatedCell, Getters, Matrix, UID, ValueAndFormat } from "../../../types";
+import { RTreeBoundingBox } from "./r_tree";
+/**
+ * A CellPosition encoded as an integer
+ */
+export type PositionId = bigint;
+export declare class Evaluator {
+    private readonly context;
+    private readonly getters;
+    private compilationParams;
+    private readonly encoder;
+    private evaluatedCells;
+    private formulaDependencies;
+    private blockedArrayFormulas;
+    private spreadingRelations;
+    constructor(context: ModelConfig["custom"], getters: Getters);
+    getEvaluatedCell(position: CellPosition): EvaluatedCell;
+    getSpreadPositionsOf(position: CellPosition): CellPosition[];
+    getArrayFormulaSpreadingOn(position: CellPosition): CellPosition | undefined;
+    getEvaluatedPositions(): CellPosition[];
+    private getArrayFormulaSpreadingOnId;
+    updateDependencies(position: CellPosition): void;
+    private updateCompilationParameters;
+    evaluateCells(positions: CellPosition[]): void;
+    private getArrayFormulasImpactedByChangesOf;
+    buildDependencyGraph(): void;
+    evaluateAllCells(): void;
+    evaluateFormulaResult(sheetId: UID, formulaString: string): ValueAndFormat | Matrix<ValueAndFormat>;
+    private getAllCells;
+    /**
+     * Return the position of formulas blocked by the given position
+     * as well as all their dependencies.
+     */
+    private getArrayFormulasBlockedBy;
+    private nextPositionsToUpdate;
+    private cellsBeingComputed;
+    private evaluate;
+    private setEvaluatedCell;
+    private computeCell;
+    private computeAndSave;
+    private handleError;
+    private computeFormulaCell;
+    private invalidatePositionsDependingOnSpread;
+    private assertSheetHasEnoughSpaceToSpreadFormulaResult;
+    private updateSpreadRelation;
+    private checkCollision;
+    private spreadValues;
+    private invalidateSpreading;
+    private getDirectDependencies;
+    private getCellsDependingOn;
+    private getCell;
+}
+/**
+ * Encode (and decode) cell positions { sheetId, col, row }
+ * to a single integer.
+ *
+ * `col` and `row` values are encoded on 21 bits each (max 2^21 = 2_097_152),
+ * An incremental integer id is assigned to each different sheet id, starting at 0.
+ *
+ * e.g.
+ * Given { col: 10, row: 4, sheetId: "abcde" }
+ * we have:
+ *  - row "4" encoded on 21 bits:  000000000000000000100
+ *  - col "10" encoded on 21 bits: 000000000000000001010
+ *  - sheetId: let's say it's the 4th sheetId met, encoded to: 11
+ *
+ * The final encoded value is found by concatenating the 3 bit sequences:
+ *
+ * sheetId: 11
+ * col:       000000000000000001010
+ * row:                            000000000000000000100
+ * =>       11000000000000000001010000000000000000000100
+ *
+ * this binary sequence is the integer 13194160504836
+ */
+export declare class PositionBitsEncoder {
+    private readonly sheetMapping;
+    private readonly inverseSheetMapping;
+    constructor();
+    /**
+     * Encode a cell position to a single integer.
+     */
+    encode({ sheetId, col, row }: CellPosition): PositionId;
+    encodeBoundingBox({ sheetId, zone }: RTreeBoundingBox): PositionId[];
+    decode(id: PositionId): CellPosition;
+    decodeToBoundingBox(id: PositionId): RTreeBoundingBox;
+    private encodeSheet;
+    private decodeSheet;
+}

package/dist/types/plugins/ui_core_views/cell_evaluation/formula_dependency_graph.d.ts

@@ -0,0 +1,23 @@
+import { PositionBitsEncoder, PositionId } from "./evaluator";
+import { RTreeBoundingBox, RTreeItem } from "./r_tree";
+/**
+ * Implementation of a dependency Graph.
+ * The graph is used to evaluate the cells in the correct
+ * order, and should be updated each time a cell's content is modified
+ *
+ * It uses an R-Tree data structure to efficiently find dependent cells.
+ */
+export declare class FormulaDependencyGraph {
+    private readonly encoder;
+    private readonly dependencies;
+    private readonly rTree;
+    constructor(encoder: PositionBitsEncoder, data?: RTreeItem<PositionId>[]);
+    removeAllDependencies(formulaPositionId: PositionId): void;
+    addDependencies(formulaPositionId: PositionId, dependencies: RTreeBoundingBox[]): void;
+    /**
+     * Return all the cells that depend on the provided ranges,
+     * in the correct order they should be evaluated.
+     * This is called a topological ordering (excluding cycles)
+     */
+    getCellsDependingOn(ranges: RTreeBoundingBox[]): Set<PositionId>;
+}

package/dist/types/plugins/ui_core_views/cell_evaluation/index.d.ts

@@ -0,0 +1 @@
+export * from "./evaluation_plugin";

package/dist/types/plugins/ui_core_views/cell_evaluation/r_tree.d.ts

@@ -0,0 +1,108 @@
+import { UID, Zone } from "../../../types";
+/**
+ * R-Tree Data Structure
+ *
+ * R-Tree is a spatial data structure used for efficient indexing and querying
+ * of multi-dimensional objects, particularly in geometric and spatial applications.
+ *
+ * It organizes objects into a tree hierarchy, grouping nearby objects together
+ * in bounding boxes. Each node in the tree represents a bounding box that
+ * contains its child nodes or leaf objects. This hierarchical structure allows
+ * for faster spatial queries.
+ *
+ * @see https://en.wikipedia.org/wiki/R-tree
+ *
+ * Consider a 2D Space with four zones: A, B, C, D
+ * +--------------------------+
+ * |                          |
+ * |   +---+     +-------+    |
+ * |   | A |     |   B   |    |
+ * |   +---+     +-------+    |
+ * |                          |
+ * |                          |
+ * |          +---+           |
+ * |          | C |           |
+ * |          +---+           |
+ * |      +-----------+       |
+ * |      |     D     |       |
+ * |      +-----------+       |
+ * |                          |
+ * +--------------------------+
+ *
+ * It groups together zones that are spatially close into a minimum bounding box.
+ * For example, A and B are grouped together in rectangle R1, and C and D are grouped
+ * in R2.
+ *
+ * R0
+ * +--------------------------+
+ * |   R1                     |
+ * |   +-----------------+    |
+ * |   | A |     |   B   |    |
+ * |   +-----------------+    |
+ * |                          |
+ * |      R2                  |
+ * |      +---+---+---+       |
+ * |      |   | C |   |       |
+ * |      |   +---+   |       |
+ * |      +-----------+       |
+ * |      |     D     |       |
+ * |      +-----------+       |
+ * |                          |
+ * +--------------------------+
+ *
+ * The tree would look like this:
+ *          R0
+ *         /  \
+ *        /    \
+ *       R1     R2
+ *       |      |
+ *      A,B    C,D
+
+ * Choosing how to group the zones is crucial for the performance of the tree.
+ * Key considerations include avoiding excessive empty space coverage and minimizing overlap
+ * to reduce the number of subtrees processed during searches.
+ *
+ * Various heuristics exist for determining the optimal grouping strategy, such as "least enlargement"
+ * which prioritizes grouping nodes resulting in the smallest increase in bounding box size. In cases where
+ * the choice cannot be made based on this criterion due to the same enlargement for different groupings,
+ * we then evaluate "least area," aiming to minimize the overall area of bounding boxes.
+ *
+ * This implementation is tailored for spreadsheet use, indexing objects associated
+ * with a zone and a sheet.
+ *
+ * It uses the RBush library under the hood. One 2D RBush R-tree per sheet.
+ * @see https://github.com/mourner/rbush
+ */
+export declare class SpreadsheetRTree<T> {
+    /**
+     * One 2D R-tree per sheet
+     */
+    private rTrees;
+    /**
+     * Bulk-inserts the given items into the tree. Bulk insertion is usually ~2-3 times
+     * faster than inserting items one by one. After bulk loading (bulk insertion into
+     * an empty tree), subsequent query performance is also ~20-30% better.
+     */
+    constructor(items?: RTreeItem[]);
+    insert(item: RTreeItem<T>): void;
+    search({ zone, sheetId }: RTreeBoundingBox): RTreeItem<T>[];
+    remove(item: RTreeItem<T>): void;
+    rtreeItemComparer(left: RTreeItem<T>, right: RTreeItem<T>): boolean;
+}
+/**
+ * Data associated with a range to be indexed in a R-tree
+ */
+export interface RTreeItem<T = unknown> {
+    /**
+     * A bounding box to locate the item in the space
+     */
+    boundingBox: RTreeBoundingBox;
+    /**
+     * Any arbitrary data associated with the bounding box
+     */
+    data: T;
+}
+export interface RTreeBoundingBox {
+    sheetId: UID;
+    zone: Zone;
+}

package/dist/types/plugins/ui_core_views/cell_evaluation/spreading_relation.d.ts

@@ -0,0 +1,60 @@
+import { PositionId } from "./evaluator";
+/**
+ * Contains, for each cell, the array
+ * formulas that could potentially spread on it
+ * This is essentially a two way mapping between array formulas
+ * and their results.
+ *
+ * As we don't allow two array formulas to spread on the same cell, this structure
+ * is used to force the reevaluation of the potential spreaders of a cell when the
+ * content of this cell is modified. This structure should be updated each time
+ * an array formula is evaluated and try to spread on another cell.
+ *
+ */
+export declare class SpreadingRelation {
+    /**
+     * Internal structure:
+     * For something like
+     * - A2:'=SPLIT("KAYAK", "A")'
+     * - B1:'=TRANSPOSE(SPLIT("COYOTE", "O"))'
+     *
+     * Resulting in:
+     * ```
+     * -----------------
+     * |   | A | B | C |
+     * |---+---+---+---|
+     * | 1 |   | C |   |
+     * | 2 | K | Y | K |
+     * | 3 |   | T |   |
+     * | 4 |   | E |   |
+     * -----------------
+     * ```
+     * We will have `resultsToArrayFormulas` looking like:
+     * - (B2) --> (A2, B1)  meaning B2 can be the result of A2 OR B1
+     * - (C2) --> (A2)      meaning C2 is the result of A2
+     * - (B3) --> (B1)      meaning B3 is the result of B1
+     * - (B4) --> (B1)      meaning B4 is the result of B1
+     *
+     * We will have `arrayFormulasToResults` looking like:
+     * - (A2) --> (B2, C2)      meaning A2 spreads on B2 and C2
+     * - (B1) --> (B2, B3, B4)  meaning B1 spreads on B2, B3 and B4
+     *
+     */
+    private readonly resultsToArrayFormulas;
+    private readonly arrayFormulasToResults;
+    getFormulaPositionsSpreadingOn(resultPositionId: PositionId): Iterable<PositionId>;
+    getArrayResultPositionIds(formulasPositionId: PositionId): Iterable<PositionId>;
+    /**
+     * Remove a node, also remove it from other nodes adjacency list
+     */
+    removeNode(positionId: PositionId): void;
+    /**
+     * Create a spreading relation between two cells
+     */
+    addRelation({ arrayFormulaPositionId, resultPositionId, }: {
+        arrayFormulaPositionId: PositionId;
+        resultPositionId: PositionId;
+    }): void;
+    hasArrayFormulaResult(positionId: PositionId): boolean;
+    isArrayFormula(positionId: PositionId): boolean;
+}

package/dist/types/plugins/ui_core_views/custom_colors.d.ts

@@ -0,0 +1,24 @@
+import { Color, CoreViewCommand, Immutable } from "../../types";
+import { UIPlugin } from "../ui_plugin";
+interface CustomColorState {
+    readonly customColors: Immutable<Record<Color, true>>;
+    readonly shouldUpdateColors: boolean;
+}
+/**
+ * CustomColors plugin
+ * This plugins aims to compute and keep to custom colors used in the
+ * current spreadsheet
+ */
+export declare class CustomColorsPlugin extends UIPlugin<CustomColorState> {
+    private readonly customColors;
+    private readonly shouldUpdateColors;
+    static getters: readonly ["getCustomColors"];
+    handle(cmd: CoreViewCommand): void;
+    finalize(): void;
+    getCustomColors(): Color[];
+    private getColorsFromCells;
+    private getFormattingColors;
+    private getChartColors;
+    private tryToAddColor;
+}
+export {};

package/dist/types/plugins/ui_core_views/evaluation_chart.d.ts

@@ -0,0 +1,24 @@
+import { Color, ExcelWorkbookData, Range, UID } from "../../types";
+import { ChartRuntime } from "../../types/chart/chart";
+import { CoreViewCommand } from "../../types/commands";
+import { UIPlugin } from "../ui_plugin";
+interface EvaluationChartStyle {
+    background: Color;
+    fontColor: Color;
+}
+interface EvaluationChartState {
+    charts: Record<UID, ChartRuntime | undefined>;
+}
+export declare class EvaluationChartPlugin extends UIPlugin<EvaluationChartState> {
+    static getters: readonly ["getChartRuntime", "getStyleOfSingleCellChart"];
+    charts: Record<UID, ChartRuntime | undefined>;
+    private createRuntimeChart;
+    handle(cmd: CoreViewCommand): void;
+    getChartRuntime(figureId: UID): ChartRuntime;
+    /**
+     * Get the background and textColor of a chart based on the color of the first cell of the main range of the chart.
+     */
+    getStyleOfSingleCellChart(chartBackground: Color | undefined, mainRange: Range | undefined): EvaluationChartStyle;
+    exportForExcel(data: ExcelWorkbookData): void;
+}
+export {};

package/dist/types/plugins/ui_core_views/evaluation_conditional_format.d.ts

@@ -0,0 +1,37 @@
+import { CellPosition, Style } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+import { CoreViewCommand } from "./../../types/commands";
+export declare class EvaluationConditionalFormatPlugin extends UIPlugin {
+    static getters: readonly ["getConditionalIcon", "getCellComputedStyle"];
+    private isStale;
+    private computedStyles;
+    private computedIcons;
+    handle(cmd: CoreViewCommand): void;
+    finalize(): void;
+    getCellComputedStyle(position: CellPosition): Style;
+    getConditionalIcon({ sheetId, col, row }: CellPosition): string | undefined;
+    /**
+     * Compute the styles according to the conditional formatting.
+     * This computation must happen after the cell values are computed if they change
+     *
+     * This result of the computation will be in the state.cell[XC].conditionalStyle and will be the union of all the style
+     * properties of the rules applied (in order).
+     * So if a cell has multiple conditional formatting applied to it, and each affect a different value of the style,
+     * the resulting style will have the combination of all those values.
+     * If multiple conditional formatting use the same style value, they will be applied in order so that the last applied wins
+     */
+    private getComputedStyles;
+    private getComputedIcons;
+    private parsePoint;
+    /** Compute the CF icons for the given range and CF rule, and apply in in the given computedIcons object */
+    private applyIcon;
+    private computeIcon;
+    /** Compute the color scale for the given range and CF rule, and apply in in the given computedStyle object */
+    private applyColorScale;
+    private computeColorDiffUnits;
+    private colorCell;
+    /**
+     * Execute the predicate to know if a conditional formatting rule should be applied to a cell
+     */
+    private rulePredicate;
+}

package/dist/types/plugins/ui_core_views/evaluation_data_validation.d.ts

@@ -0,0 +1,38 @@
+import { CellPosition, CellValue, DataValidationCriterionType, DataValidationRule, HeaderIndex, Lazy, UID } from "../../types";
+import { CoreViewCommand } from "../../types/commands";
+import { UIPlugin } from "../ui_plugin";
+interface InvalidValidationResult {
+    readonly isValid: false;
+    readonly rule: DataValidationRule;
+    readonly error: string;
+}
+interface ValidValidationResult {
+    readonly isValid: true;
+}
+type ValidationResult = ValidValidationResult | InvalidValidationResult;
+type SheetValidationResult = {
+    [col: HeaderIndex]: Array<Lazy<ValidationResult>>;
+};
+export declare class EvaluationDataValidationPlugin extends UIPlugin {
+    static getters: readonly ["getDataValidationInvalidCriterionValueMessage", "getInvalidDataValidationMessage", "getValidationResultForCellValue", "isCellValidCheckbox", "isDataValidationInvalid"];
+    validationResults: Record<UID, SheetValidationResult>;
+    handle(cmd: CoreViewCommand): void;
+    isDataValidationInvalid(cellPosition: CellPosition): boolean;
+    getInvalidDataValidationMessage(cellPosition: CellPosition): string | undefined;
+    /**
+     * Check if the value is valid for the given criterion, and return an error message if not.
+     *
+     * The value must be canonicalized.
+     */
+    getDataValidationInvalidCriterionValueMessage(criterionType: DataValidationCriterionType, value: string): string | undefined;
+    isCellValidCheckbox(cellPosition: CellPosition): boolean;
+    /** Get the validation result if the cell on the given position had the given value */
+    getValidationResultForCellValue(cellValue: CellValue, cellPosition: CellPosition): ValidationResult;
+    private getValidationResultForCell;
+    private computeSheetValidationResults;
+    private getRuleErrorForCellValue;
+    /** Get the offset of the cell inside the ranges of the rule. Throws an error if the cell isn't inside the rule. */
+    private getCellOffsetInRule;
+    private getEvaluatedCriterionValues;
+}
+export {};

package/dist/types/plugins/ui_core_views/header_sizes_ui.d.ts

@@ -0,0 +1,32 @@
+import { Command } from "../../types";
+import { CellPosition, Dimension, HeaderIndex, Immutable, Pixel, UID } from "../../types/misc";
+import { UIPlugin } from "../ui_plugin";
+interface HeaderSizeState {
+    tallestCellInRow: Immutable<Record<UID, Array<CellWithSize | undefined>>>;
+}
+interface CellWithSize {
+    cell: CellPosition;
+    size: Pixel;
+}
+export declare class HeaderSizeUIPlugin extends UIPlugin<HeaderSizeState> implements HeaderSizeState {
+    static getters: readonly ["getRowSize", "getHeaderSize"];
+    readonly tallestCellInRow: Immutable<Record<UID, Array<CellWithSize | undefined>>>;
+    private ctx;
+    beforeHandle(cmd: Command): void;
+    handle(cmd: Command): void;
+    getRowSize(sheetId: UID, row: HeaderIndex): Pixel;
+    getHeaderSize(sheetId: UID, dimension: Dimension, index: HeaderIndex): Pixel;
+    private updateRowSizeForCellChange;
+    private initializeSheet;
+    /**
+     * Return the height the cell should have in the sheet, which is either DEFAULT_CELL_HEIGHT if the cell is in a multi-row
+     * merge, or the height of the cell computed based on its style/content.
+     */
+    private getCellHeight;
+    private isInMultiRowMerge;
+    /**
+     * Get the tallest cell of a row and its size.
+     */
+    private getRowTallestCell;
+}
+export {};

package/dist/types/plugins/ui_core_views/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./cell_evaluation";
+export * from "./custom_colors";
+export * from "./evaluation_chart";
+export * from "./evaluation_conditional_format";
+export * from "./evaluation_data_validation";

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

@@ -0,0 +1,60 @@
+import { Command, CommandResult, GridRenderingContext, LAYERS, LocalCommand, Tooltip } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+/**
+ * Autofill Plugin
+ *
+ */
+export declare class AutofillPlugin extends UIPlugin {
+    static layers: LAYERS[];
+    static getters: readonly ["getAutofillTooltip"];
+    private autofillZone;
+    private steps;
+    private lastCellSelected;
+    private direction;
+    private tooltip;
+    allowDispatch(cmd: LocalCommand): CommandResult;
+    handle(cmd: Command): void;
+    getAutofillTooltip(): Tooltip | undefined;
+    /**
+     * Autofill the autofillZone from the current selection
+     * @param apply Flag set to true to apply the autofill in the model. It's
+     *              useful to set it to false when we need to fill the tooltip
+     */
+    private autofill;
+    private collectBordersData;
+    private collectConditionalFormatsData;
+    private collectDataValidationsData;
+    private autofillCell;
+    private autofillBorders;
+    private autofillConditionalFormats;
+    private autofillDataValidations;
+    /**
+     * Select a cell which becomes the last cell of the autofillZone
+     */
+    private select;
+    /**
+     * Computes the autofillZone to autofill when the user double click on the
+     * autofiller
+     */
+    private autofillAuto;
+    /**
+     * Generate the next cell
+     */
+    private computeNewCell;
+    /**
+     * Get the rule associated to the current cell
+     */
+    private getRule;
+    /**
+     * Create the generator to be able to autofill the next cells.
+     */
+    private createGenerator;
+    private saveZone;
+    /**
+     * Compute the direction of the autofill from the last selected zone and
+     * a given cell (col, row)
+     */
+    private getDirection;
+    private autofillMerge;
+    drawGrid(renderingContext: GridRenderingContext): void;
+}

package/dist/types/plugins/ui_feature/automatic_sum.d.ts

@@ -0,0 +1,101 @@
+import { Command, Position, UID, Zone } from "../../types";
+import { UIPlugin } from "../ui_plugin";
+interface AutomaticSum {
+    position: Position;
+    zone: Zone;
+}
+export declare class AutomaticSumPlugin extends UIPlugin {
+    static getters: readonly ["getAutomaticSums"];
+    handle(cmd: Command): void;
+    getAutomaticSums(sheetId: UID, zone: Zone, anchor: Position): AutomaticSum[];
+    private sumData;
+    private sumAdjacentData;
+    /**
+     * Find a zone to automatically sum a column or row of numbers.
+     *
+     * We first decide which direction will be summed (column or row).
+     * Here is the strategy:
+     *  1. If the left cell is a number and the top cell is not: choose horizontal
+     *  2. Try to find a valid vertical zone. If it's valid: choose vertical
+     *  3. Try to find a valid horizontal zone. If it's valid: choose horizontal
+     *  4. Otherwise, no zone is returned
+     *
+     * Now, how to find a valid zone?
+     * The zone starts directly above or on the left of the starting point
+     * (depending on the direction).
+     * The zone ends where the first continuous sequence of numbers ends.
+     * Empty or text cells can be part of the zone while no number has been found.
+     * Other kind of cells (boolean, dates, etc.) are not valid in the zone and the
+     * search stops immediately if one is found.
+     *
+     *  -------                                       -------
+     * |   1   |                                     |   1   |
+     *  -------                                       -------
+     * |       |                                     |       |
+     *  -------  <= end of the sequence, stop here    -------
+     * |   2   |                                     |   2   |
+     *  -------                                       -------
+     * |   3   | <= start of the number sequence     |   3   |
+     *  -------                                       -------
+     * |       | <= ignored                          | FALSE | <= invalid, no zone is found
+     *  -------                                       -------
+     * |   A   | <= ignored                          |   A   | <= ignored
+     *  -------                                       -------
+     */
+    private findAdjacentData;
+    /**
+     * Return the zone to sum if a valid one is found.
+     * @see getAutomaticSumZone
+     */
+    private findSuitableZoneToSum;
+    private findVerticalZone;
+    private findHorizontalZone;
+    /**
+     * Reduces a column or row zone to a valid zone for the automatic sum.
+     * @see getAutomaticSumZone
+     * @param sheet
+     * @param zone one dimensional zone (a single row or a single column). The zone is
+     *             assumed to start at the beginning of the column (top=0) or the row (left=0)
+     * @param end end index of the zone (`bottom` or `right` depending on the dimension)
+     * @returns the starting position of the valid zone or Infinity if the zone is not valid.
+     */
+    private reduceZoneStart;
+    private shouldFindData;
+    private isNumber;
+    private isZoneValid;
+    private lastColIsEmpty;
+    private lastRowIsEmpty;
+    /**
+     * Decides which dimensions (columns or rows) should be summed
+     * based on its shape and what's inside the zone.
+     */
+    private dimensionsToSum;
+    /**
+     * Sum each column and/or row in the zone in the appropriate cells,
+     * depending on the available space.
+     */
+    private sumDimensions;
+    /**
+     * Sum the total of the zone in the bottom right cell, assuming
+     * the last row contains summed columns.
+     */
+    private sumTotal;
+    private sumColumns;
+    private sumRows;
+    private dispatchCellUpdates;
+    /**
+     * Find the first row where all cells below the zone are empty.
+     */
+    private nextEmptyRow;
+    /**
+     * Find the first column where all cells right of the zone are empty.
+     */
+    private nextEmptyCol;
+    /**
+     * Transpose the given dimensions.
+     * COL becomes ROW
+     * ROW becomes COL
+     */
+    private transpose;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { Command, CommandResult, LocalCommand, Position } from "../../types";
+import { CellPopoverType, ClosedCellPopover, PositionedCellPopover } from "../../types/cell_popovers";
+import { UIPlugin } from "../ui_plugin";
+/**
+ * Plugin managing the display of components next to cells.
+ */
+export declare class CellPopoverPlugin extends UIPlugin {
+    static getters: readonly ["getCellPopover", "getPersistentPopoverTypeAtPosition", "hasOpenedPopover"];
+    private persistentPopover?;
+    allowDispatch(cmd: LocalCommand): CommandResult;
+    handle(cmd: Command): void;
+    getCellPopover({ col, row }: Partial<Position>): ClosedCellPopover | PositionedCellPopover;
+    hasOpenedPopover(): boolean;
+    getPersistentPopoverTypeAtPosition({ col, row }: Position): CellPopoverType | undefined;
+    private computePopoverAnchorRect;
+}

package/dist/types/plugins/ui_feature/collaborative.d.ts

@@ -0,0 +1,25 @@
+import { Client, Color, GridRenderingContext, LAYERS } from "../../types";
+import { UIPlugin, UIPluginConfig } from "../ui_plugin";
+interface ClientToDisplay extends Required<Client> {
+    color: Color;
+}
+export declare class CollaborativePlugin extends UIPlugin {
+    static getters: readonly ["getClientsToDisplay", "getClient", "getConnectedClients", "isFullySynchronized"];
+    static layers: LAYERS[];
+    private availableColors;
+    private colors;
+    private session;
+    constructor(config: UIPluginConfig);
+    private isPositionValid;
+    private chooseNewColor;
+    getClient(): Client;
+    getConnectedClients(): Set<Client>;
+    isFullySynchronized(): boolean;
+    /**
+     * Get the list of others connected clients which are present in the same sheet
+     * and with a valid position
+     */
+    getClientsToDisplay(): ClientToDisplay[];
+    drawGrid(renderingContext: GridRenderingContext): void;
+}
+export {};

package/dist/types/plugins/ui_feature/data_cleanup.d.ts

@@ -0,0 +1,16 @@
+import { Command, CommandResult } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export declare class DataCleanupPlugin extends UIPlugin {
+    allowDispatch(cmd: Command): CommandResult | CommandResult[];
+    handle(cmd: Command): void;
+    private removeDuplicates;
+    private getUniqueRowsIndexes;
+    private notifyRowsRemovedAndRemaining;
+    private checkSingleRangeSelected;
+    private checkNoMergeInZone;
+    private checkRangeContainsValues;
+    private checkNoColumnProvided;
+    private checkColumnsIncludedInZone;
+    private checkColumnsAreUnique;
+    private trimWhitespace;
+}