@odoo/o-spreadsheet 18.0.55 → 18.0.68

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_core_views/pivot_ui.d.ts

@@ -0,0 +1,49 @@
+import { Token } from "../../formulas";
+import { CellPosition, Command, PivotCoreMeasure, PivotTableCell, UID } from "../../types";
+import { Pivot } from "../../types/pivot_runtime";
+import { UIPlugin, UIPluginConfig } from "../ui_plugin";
+export declare const UNDO_REDO_PIVOT_COMMANDS: string[];
+export declare class PivotUIPlugin extends UIPlugin {
+    static getters: readonly ["getPivot", "getFirstPivotFunction", "getPivotIdFromPosition", "getPivotCellFromPosition", "generateNewCalculatedMeasureName", "isPivotUnused", "isSpillPivotFormula"];
+    private pivots;
+    private unusedPivots?;
+    private custom;
+    constructor(config: UIPluginConfig);
+    beforeHandle(cmd: Command): void;
+    handle(cmd: Command): void;
+    /**
+     * Get the id of the pivot at the given position. Returns undefined if there
+     * is no pivot at this position
+     */
+    getPivotIdFromPosition(position: CellPosition): "" | UID | undefined;
+    isSpillPivotFormula(position: CellPosition): boolean;
+    getFirstPivotFunction(sheetId: UID, tokens: Token[]): {
+        functionName: string;
+        args: (import("../..").CellValue | import("../..").Matrix<import("../..").CellValue> | undefined)[];
+    } | undefined;
+    /**
+     * Returns the domain args of a pivot formula from a position.
+     * For all those formulas:
+     *
+     * =PIVOT.VALUE(1,"expected_revenue","stage_id",2,"city","Brussels")
+     * =PIVOT.HEADER(1,"stage_id",2,"city","Brussels")
+     * =PIVOT.HEADER(1,"stage_id",2,"city","Brussels","measure","expected_revenue")
+     *
+     * the result is the same: ["stage_id", 2, "city", "Brussels"]
+     *
+     * If the cell is the result of PIVOT, the result is the domain of the cell
+     * as if it was the individual pivot formula
+     */
+    getPivotCellFromPosition(position: CellPosition): PivotTableCell;
+    generateNewCalculatedMeasureName(measures: PivotCoreMeasure[]): string;
+    getPivot(pivotId: UID): Pivot<import("../..").PivotRuntimeDefinition>;
+    isPivotUnused(pivotId: UID): boolean;
+    /**
+     * Refresh the cache of a pivot
+     */
+    private refreshPivot;
+    setupPivot(pivotId: UID, { recreate }?: {
+        recreate: boolean;
+    }): void;
+    _getUnusedPivots(): UID[];
+}

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

@@ -0,0 +1,61 @@
+import { Command, CommandResult, GridRenderingContext, LocalCommand, Tooltip } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+/**
+ * Autofill Plugin
+ *
+ */
+export declare class AutofillPlugin extends UIPlugin {
+    static layers: readonly ["Autofill"];
+    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;
+    private getAutofillAutoLastRow;
+    /**
+     * 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;
+    drawLayer(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_computed_style.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "../../types";
+import { Border, CellPosition, Style } from "../../types/misc";
+import { UIPlugin } from "../ui_plugin";
+export declare class CellComputedStylePlugin extends UIPlugin {
+    static getters: readonly ["getCellComputedBorder", "getCellComputedStyle"];
+    private styles;
+    private borders;
+    handle(cmd: Command): void;
+    getCellComputedBorder(position: CellPosition): Border | null;
+    getCellComputedStyle(position: CellPosition): Style;
+    private computeCellBorder;
+    private computeCellStyle;
+}

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

@@ -0,0 +1,25 @@
+import { Client, Color, GridRenderingContext } 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: readonly ["Selection"];
+    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[];
+    drawLayer(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;
+}

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

@@ -0,0 +1,5 @@
+import { Command } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export declare class DataValidationInsertionPlugin extends UIPlugin {
+    handle(cmd: Command): void;
+}

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

@@ -0,0 +1,25 @@
+import { Command } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export declare class FormatPlugin extends UIPlugin {
+    handle(cmd: Command): void;
+    private setContextualFormat;
+    private isSpilledPivotValueFormula;
+    /**
+     * This function allows to adjust the quantity of decimal places after a decimal
+     * point on cells containing number value. It does this by changing the cells
+     * format. Values aren't modified.
+     *
+     * The change of the decimal quantity is done one by one, the sign of the step
+     * variable indicates whether we are increasing or decreasing.
+     *
+     * If several cells are in the zone, each cell's format will be individually
+     * evaluated and updated with the number type.
+     */
+    private setDecimal;
+    /**
+     * Take a range of cells and return the format of the first cell containing a
+     * number value. Returns a default format if the cell hasn't format. Returns
+     * undefined if no number value in the range.
+     */
+    private getCellNumberFormat;
+}

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

@@ -0,0 +1,21 @@
+import { CellPosition, Dimension, ExcelWorkbookData, HeaderIndex, UID } from "../../types";
+import { UIPlugin } from "../ui_plugin";
+export declare class HeaderVisibilityUIPlugin extends UIPlugin {
+    static getters: readonly ["getNextVisibleCellPosition", "findVisibleHeader", "findLastVisibleColRowIndex", "findFirstVisibleColRowIndex", "isRowHidden", "isColHidden", "isHeaderHidden"];
+    isRowHidden(sheetId: UID, index: number): boolean;
+    isColHidden(sheetId: UID, index: number): boolean;
+    isHeaderHidden(sheetId: UID, dimension: Dimension, index: number): boolean;
+    getNextVisibleCellPosition({ sheetId, col, row }: CellPosition): CellPosition;
+    /**
+     * Find the first visible header in the range [`from` => `to`].
+     *
+     * Both `from` and `to` are inclusive.
+     */
+    findVisibleHeader(sheetId: UID, dimension: Dimension, from: number, to: number): number | undefined;
+    findLastVisibleColRowIndex(sheetId: UID, dimension: Dimension, { last, first }: {
+        first: HeaderIndex;
+        last: HeaderIndex;
+    }): HeaderIndex;
+    findFirstVisibleColRowIndex(sheetId: UID, dimension: Dimension): number | undefined;
+    exportForExcel(data: ExcelWorkbookData): void;
+}

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

@@ -0,0 +1,10 @@
+export * from "./autofill";
+export * from "./automatic_sum";
+export * from "./collaborative";
+export * from "./data_cleanup";
+export * from "./format";
+export * from "./header_visibility_ui";
+export * from "./insert_pivot";
+export * from "./sort";
+export * from "./ui_options";
+export * from "./ui_sheet";

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

@@ -0,0 +1,14 @@
+import { HeaderIndex, PivotTableData, UID } from "../../types";
+import { Command, CommandResult } from "../../types/commands";
+import { UIPlugin } from "../ui_plugin";
+export declare class InsertPivotPlugin extends UIPlugin {
+    static getters: readonly [];
+    allowDispatch(cmd: Command): CommandResult.Success | CommandResult.PivotIdNotFound | CommandResult.PivotInError;
+    handle(cmd: Command): void;
+    private insertNewPivot;
+    private duplicatePivotInNewSheet;
+    private getPivotDuplicateSheetName;
+    insertPivotWithTable(sheetId: UID, col: HeaderIndex, row: HeaderIndex, pivotId: UID, table: PivotTableData, mode: "static" | "dynamic"): void;
+    private resizeSheet;
+    splitPivotFormula(sheetId: UID, col: HeaderIndex, row: HeaderIndex, pivotId: UID): void;
+}

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

@@ -0,0 +1,36 @@
+import { Command, CommandResult } from "../../types";
+import { UIPlugin, UIPluginConfig } from "../ui_plugin";
+/**
+ * Local History
+ *
+ * The local history is responsible of tracking the locally state updates
+ * It maintains the local undo and redo stack to allow to undo/redo only local
+ * changes
+ */
+export declare class HistoryPlugin extends UIPlugin {
+    static getters: readonly ["canUndo", "canRedo"];
+    /**
+     * Ids of the revisions which can be undone
+     */
+    private undoStack;
+    /**
+     * Ids of the revisions which can be redone
+     */
+    private redoStack;
+    private session;
+    constructor(config: UIPluginConfig);
+    allowDispatch(cmd: Command): CommandResult;
+    handle(cmd: Command): void;
+    finalize(): void;
+    private requestHistoryChange;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    private onNewLocalStateUpdate;
+    /**
+     * Fetch the last revision which is not empty and not a repeated command
+     *
+     * Ignore repeated commands (REQUEST_REDO command as root command)
+     * Ignore standard undo/redo revisions (that are empty)
+     */
+    private getPossibleRevisionToRepeat;
+}

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

@@ -0,0 +1,10 @@
+import { PivotPresenceTracker } from "../../helpers/pivot/pivot_presence_tracker";
+import { Command, UID } from "../../types";
+import { UIPlugin } from "../ui_plugin";
+export declare class PivotPresencePlugin extends UIPlugin {
+    static getters: readonly ["getPivotPresenceTracker"];
+    private trackPresencePivotId?;
+    private tracker?;
+    handle(cmd: Command): void;
+    getPivotPresenceTracker(pivotId: UID): PivotPresenceTracker | undefined;
+}

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

@@ -0,0 +1,29 @@
+import { Command, CommandResult, LocalCommand } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export declare class SortPlugin extends UIPlugin {
+    allowDispatch(cmd: LocalCommand): CommandResult | CommandResult[];
+    handle(cmd: Command): void;
+    private checkMerge;
+    private checkMergeSizes;
+    /**
+     * This function evaluates if the top row of a provided zone can be considered as a `header`
+     * by checking the following criteria:
+     * * If the left-most column top row value (topLeft) is empty, we ignore it while evaluating the criteria.
+     * 1 - Apart from the left-most column, every element of the top row must be non-empty, i.e. a cell should be present in the sheet.
+     * 2 - There should be at least one column in which the type (CellValueType) of the rop row cell differs from the type of the cell below.
+     *  For the second criteria, we ignore columns on which the cell below is empty.
+     *
+     */
+    private hasHeader;
+    private sortZone;
+    /**
+     * Return the distances between main merge cells in the zone.
+     * (1 if there are no merges).
+     * Note: it is assumed all merges are the same in the zone.
+     */
+    private mainCellsSteps;
+    /**
+     * Return a 2D array of cells in the zone (main merge cells if there are merges)
+     */
+    private mainCells;
+}

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

@@ -0,0 +1,21 @@
+import { Command, CommandResult } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export declare class SplitToColumnsPlugin extends UIPlugin {
+    static getters: readonly ["getAutomaticSeparator"];
+    allowDispatch(cmd: Command): CommandResult | CommandResult[];
+    handle(cmd: Command): void;
+    getAutomaticSeparator(): string;
+    private getAutoSeparatorForString;
+    private splitIntoColumns;
+    private getSplittedCols;
+    private splitAndRemoveTrailingEmpty;
+    private willSplittedColsOverwriteContent;
+    private removeMergesInSplitZone;
+    private addColsToAvoidCollisions;
+    private getColsToAddToAvoidCollision;
+    private addColumnsToNotOverflowSheet;
+    private checkSingleColSelected;
+    private checkNonEmptySelector;
+    private checkNotOverwritingContent;
+    private checkSeparatorInSelection;
+}

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

@@ -0,0 +1,6 @@
+import { Command } from "../../types";
+import { UIPlugin } from "../ui_plugin";
+export declare class TableAutofillPlugin extends UIPlugin {
+    handle(cmd: Command): void;
+    private autofillTableZone;
+}

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

@@ -0,0 +1,26 @@
+import { Border, CellPosition, Command, Style } from "../../types";
+import { UIPlugin } from "../ui_plugin";
+export declare class TableComputedStylePlugin extends UIPlugin {
+    static getters: readonly ["getCellTableStyle", "getCellTableBorder"];
+    private tableStyles;
+    handle(cmd: Command): void;
+    finalize(): void;
+    getCellTableStyle(position: CellPosition): Style | undefined;
+    getCellTableBorder(position: CellPosition): Border | undefined;
+    private computeTableStyle;
+    /**
+     * Get the actual table config that will be used to compute the table style. It is different from
+     * the config of the table because of hidden rows and columns in the sheet. For example remove the
+     * hidden rows from config.numberOfHeaders.
+     */
+    private getTableRuntimeConfig;
+    /**
+     * Get a mapping: relative col/row position in the table <=> col/row in the sheet
+     */
+    private getTableMapping;
+}
+declare const invalidateTableStyleCommands: readonly ["HIDE_COLUMNS_ROWS", "UNHIDE_COLUMNS_ROWS", "UNFOLD_HEADER_GROUP", "UNGROUP_HEADERS", "FOLD_HEADER_GROUP", "FOLD_ALL_HEADER_GROUPS", "UNFOLD_ALL_HEADER_GROUPS", "FOLD_HEADER_GROUPS_IN_ZONE", "UNFOLD_HEADER_GROUPS_IN_ZONE", "CREATE_TABLE", "UPDATE_TABLE", "UPDATE_FILTER", "REMOVE_TABLE", "RESIZE_TABLE", "CREATE_TABLE_STYLE", "REMOVE_TABLE_STYLE"];
+export declare function doesCommandInvalidatesTableStyle(cmd: Command): cmd is {
+    type: (typeof invalidateTableStyleCommands)[number];
+} & Command;
+export {};

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

@@ -0,0 +1,6 @@
+import { Command, CommandResult } from "../../types";
+import { UIPlugin } from "../ui_plugin";
+export declare class TableResizeUI extends UIPlugin {
+    allowDispatch(cmd: Command): CommandResult | CommandResult[];
+    handle(cmd: Command): void;
+}

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

@@ -0,0 +1,8 @@
+import { Command } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export declare class UIOptionsPlugin extends UIPlugin {
+    static getters: readonly ["shouldShowFormulas"];
+    private showFormulas;
+    handle(cmd: Command): void;
+    shouldShowFormulas(): boolean;
+}

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

@@ -0,0 +1,48 @@
+import { Command, CommandResult, LocalCommand, UID } from "../../types";
+import { ImageSrc } from "../../types/image";
+import { CellPosition, Pixel, Style, Zone } from "../../types/misc";
+import { UIPlugin } from "../ui_plugin";
+export declare class SheetUIPlugin extends UIPlugin {
+    static getters: readonly ["doesCellHaveGridIcon", "getCellWidth", "getCellIconSrc", "getTextWidth", "getCellText", "getCellMultiLineText", "getContiguousZone"];
+    private ctx;
+    allowDispatch(cmd: LocalCommand): CommandResult | CommandResult[];
+    handle(cmd: Command): void;
+    getCellWidth(position: CellPosition): number;
+    getCellIconSrc(position: CellPosition): ImageSrc | undefined;
+    getTextWidth(text: string, style: Style): Pixel;
+    getCellText(position: CellPosition, args?: {
+        showFormula?: boolean;
+        availableWidth?: number;
+    }): string;
+    /**
+     * Return the text of a cell, split in multiple lines if needed. The text will be split in multiple
+     * line if it contains NEWLINE characters, or if it's longer than the given width.
+     */
+    getCellMultiLineText(position: CellPosition, args: {
+        wrapText: boolean;
+        maxWidth: number;
+        formatWidth?: number;
+    }): string[];
+    doesCellHaveGridIcon(position: CellPosition): boolean;
+    /**
+     * Expands the given zone until bordered by empty cells or reached the sheet boundaries.
+     */
+    getContiguousZone(sheetId: UID, zoneToExpand: Zone): Zone;
+    /**
+     * Checks if a cell is empty (i.e. does not have a content or a formula does not spread over it).
+     * If the cell is part of a merge, the check applies to the main cell of the merge.
+     */
+    private isCellEmpty;
+    private getColMaxWidth;
+    /**
+     * Check that any "sheetId" in the command matches an existing
+     * sheet.
+     */
+    private checkSheetExists;
+    /**
+     * Check if zones in the command are well formed and
+     * not outside the sheet.
+     */
+    private checkZonesAreInSheet;
+    private autoResizeRows;
+}

package/dist/types/plugins/ui_plugin.d.ts

@@ -0,0 +1,38 @@
+import { Session } from "../collaborative/session";
+import { ModelConfig } from "../model";
+import { SelectionStreamProcessor } from "../selection_stream/selection_stream_processor";
+import { StateObserver } from "../state_observer";
+import { ClientPosition, Color, Command, CommandDispatcher, Currency, Getters, GridRenderingContext, LayerName } from "../types/index";
+import { BasePlugin } from "./base_plugin";
+type UIActions = Pick<ModelConfig, "notifyUI" | "raiseBlockingErrorUI">;
+export interface UIPluginConfig {
+    readonly getters: Getters;
+    readonly stateObserver: StateObserver;
+    readonly dispatch: CommandDispatcher["dispatch"];
+    readonly canDispatch: CommandDispatcher["dispatch"];
+    readonly selection: SelectionStreamProcessor;
+    readonly moveClient: (position: ClientPosition) => void;
+    readonly uiActions: UIActions;
+    readonly custom: ModelConfig["custom"];
+    readonly session: Session;
+    readonly defaultCurrency?: Partial<Currency>;
+    readonly customColors: Color[];
+}
+export interface UIPluginConstructor {
+    new (config: UIPluginConfig): UIPlugin;
+    layers: Readonly<LayerName[]>;
+    getters: readonly string[];
+}
+/**
+ * UI plugins handle any transient data required to display a spreadsheet.
+ * They can draw on the grid canvas.
+ */
+export declare class UIPlugin<State = any> extends BasePlugin<State, Command> {
+    static layers: Readonly<LayerName[]>;
+    protected getters: Getters;
+    protected ui: UIActions;
+    protected selection: SelectionStreamProcessor;
+    constructor({ getters, stateObserver, dispatch, canDispatch, uiActions, selection, }: UIPluginConfig);
+    drawLayer(ctx: GridRenderingContext, layer: LayerName): void;
+}
+export {};