@odoo/o-spreadsheet 18.0.55 → 18.0.68

package/dist/types/helpers/pivot/spreadsheet_pivot/spreadsheet_pivot.d.ts

@@ -0,0 +1,96 @@
+import { ModelConfig } from "../../../model";
+import { FunctionResultObject, Maybe } from "../../../types";
+import { PivotDimension, PivotDomain, PivotFields, PivotMeasure, SpreadsheetPivotCoreDefinition } from "../../../types/pivot";
+import { InitPivotParams, Pivot } from "../../../types/pivot_runtime";
+import { PivotParams } from "../pivot_registry";
+import { SpreadsheetPivotTable } from "../table_spreadsheet_pivot";
+import { SpreadsheetPivotRuntimeDefinition } from "./runtime_definition_spreadsheet_pivot";
+interface SpreadsheetPivotParams extends PivotParams {
+    definition: SpreadsheetPivotCoreDefinition;
+}
+declare enum ReloadType {
+    NONE = 0,
+    TABLE = 1,
+    DATA = 2,
+    DEFINITION = 3,
+    ALL = 4
+}
+/**
+ * This class represents a pivot table that is created from a range of cells.
+ * It will extract the fields from the first row of the range and the data from
+ * the rest of the rows.
+ */
+export declare class SpreadsheetPivot implements Pivot<SpreadsheetPivotRuntimeDefinition> {
+    readonly type = "SPREADSHEET";
+    private getters;
+    private _definition;
+    private coreDefinition;
+    private metaData;
+    /**
+     * This array contains the data entries of the pivot. Each entry is an object
+     * that contains the values of the fields for a row.
+     */
+    private dataEntries;
+    /**
+     * This object contains the pivot table structure. It is created from the
+     * data entries and the pivot definition.
+     */
+    private table;
+    /**
+     * This error is set when the range is invalid. It is used to show an error
+     * message to the user.
+     */
+    private invalidRangeError;
+    /**
+     * This flag is used to know when the pivot needs to be reloaded. It's only
+     * used in the evaluation process. At the end of each cycle, the flag is set
+     * to true so the pivot is reloaded in the next cycle.
+     */
+    needsReevaluation: boolean;
+    constructor(custom: ModelConfig["custom"], params: SpreadsheetPivotParams);
+    init(params?: InitPivotParams): void;
+    reload(type: ReloadType): void;
+    onDefinitionChange(nextDefinition: SpreadsheetPivotCoreDefinition): void;
+    private computeShouldReload;
+    get isInvalidRange(): boolean;
+    get invalidRangeMessage(): string | undefined;
+    get definition(): SpreadsheetPivotRuntimeDefinition;
+    isValid(): boolean;
+    assertIsValid({ throwOnError }: {
+        throwOnError: boolean;
+    }): FunctionResultObject | undefined;
+    areDomainArgsFieldsValid(args: Maybe<FunctionResultObject>[]): boolean;
+    parseArgsToPivotDomain(args: Maybe<FunctionResultObject>[]): PivotDomain;
+    markAsDirtyForEvaluation(): void;
+    getMeasure(id: string): PivotMeasure;
+    getPivotMeasureValue(id: string): FunctionResultObject;
+    getPivotHeaderValueAndFormat(domain: PivotDomain): FunctionResultObject;
+    getPivotCellValueAndFormat(measureId: string, domain: PivotDomain): FunctionResultObject;
+    getPossibleFieldValues(dimension: PivotDimension): {
+        value: string | number | boolean;
+        label: string;
+    }[];
+    getTableStructure(): SpreadsheetPivotTable;
+    getFields(): PivotFields;
+    get fields(): PivotFields;
+    private loadMetaData;
+    private loadRuntimeDefinition;
+    private loadData;
+    private getTypeOfDimension;
+    private filterDataEntriesFromDomain;
+    private filterDataEntriesFromDomainNode;
+    private getDimension;
+    private getTypeFromZone;
+    private assertCellIsValidField;
+    /**
+     * Create the fields from the given range. It will extract all the fields from
+     * the first row of the range.
+     */
+    private extractFieldsFromRange;
+    /**
+     * Take cares of double names
+     */
+    private findName;
+    private extractDataEntriesFromRange;
+}
+export {};

package/dist/types/helpers/pivot/table_spreadsheet_pivot.d.ts

@@ -0,0 +1,80 @@
+import { DimensionTree, PivotTableCell, PivotTableColumn, PivotTableRow } from "../../types/pivot";
+/**
+ * Class used to ease the construction of a pivot table.
+ * Let's consider the following example, with:
+ * - columns groupBy: [sales_team, create_date]
+ * - rows groupBy: [continent, city]
+ * - measures: [revenues]
+ * _____________________________________________________________________________________|   ----|
+ * |                |   Sale Team 1             |  Sale Team 2            |             |       |
+ * |                |___________________________|_________________________|_____________|       |
+ * |                |   May 2020   | June 2020  |  May 2020  | June 2020  |   Total     |       |<---- `cols`
+ * |                |______________|____________|____________|____________|_____________|       |   ----|
+ * |                |   Revenues   |  Revenues  |  Revenues  |  Revenues  |   Revenues  |       |       |<--- `measureRow`
+ * |________________|______________|____________|____________|____________|_____________|   ----|   ----|
+ * |Europe          |     25       |     35     |     40     |     30     |     65      |   ----|
+ * |    Brussels    |      0       |     15     |     30     |     30     |     30      |       |
+ * |    Paris       |     25       |     20     |     10     |     0      |     35      |       |
+ * |North America   |     60       |     75     |            |            |     60      |       |<---- `body`
+ * |    Washington  |     60       |     75     |            |            |     60      |       |
+ * |Total           |     85       |     110    |     40     |     30     |     125     |       |
+ * |________________|______________|____________|____________|____________|_____________|   ----|
+ *
+ * |                |
+ * |----------------|
+ *         |
+ *         |
+ *       `rows`
+ *
+ * `rows` is an array of cells, each cells contains the indent level, the fields used for the group by and the values for theses fields.
+ * For example:
+ *   `Europe`: { indent: 1, fields: ["continent"], values: ["id_of_Europe"]}
+ *   `Brussels`: { indent: 2, fields: ["continent", "city"], values: ["id_of_Europe", "id_of_Brussels"]}
+ *   `Total`: { indent: 0, fields: [], values: []}
+ *
+ * `columns` is an double array, first by row and then by cell. So, in this example, it looks like:
+ *   [[row1], [row2], [measureRow]]
+ *   Each cell of a column's row contains the width (span) of the cells, the fields used for the group by and the values for theses fields.
+ * For example:
+ *   `Sale Team 1`: { width: 2, fields: ["sales_team"], values: ["id_of_SaleTeam1"]}
+ *   `May 2020` (the one under Sale Team 2): { width: 1, fields: ["sales_team", "create_date"], values: ["id_of_SaleTeam2", "May 2020"]}
+ *   `Revenues` (the one under Total): { width: 1, fields: ["measure"], values: ["revenues"]}
+ *
+ */
+export declare class SpreadsheetPivotTable {
+    readonly columns: PivotTableColumn[][];
+    readonly rows: PivotTableRow[];
+    readonly measures: string[];
+    readonly fieldsType: Record<string, string | undefined>;
+    readonly maxIndent: number;
+    readonly pivotCells: {
+        [key: string]: PivotTableCell[][];
+    };
+    private rowTree;
+    private colTree;
+    constructor(columns: PivotTableColumn[][], rows: PivotTableRow[], measures: string[], fieldsType: Record<string, string | undefined>);
+    /**
+     * Get the number of columns leafs (i.e. the number of the last row of columns)
+     */
+    getNumberOfDataColumns(): number;
+    getPivotCells(includeTotal?: boolean, includeColumnHeaders?: boolean): PivotTableCell[][];
+    getRowTree(): DimensionTree;
+    getColTree(): DimensionTree;
+    private isTotalRow;
+    private getPivotCell;
+    private getColHeaderDomain;
+    private getColDomain;
+    private getColMeasure;
+    private getRowDomain;
+    buildRowsTree(): DimensionTree;
+    buildColumnsTree(): DimensionTree;
+    export(): {
+        cols: PivotTableColumn[][];
+        rows: PivotTableRow[];
+        measures: string[];
+        fieldsType: Record<string, string | undefined>;
+    };
+}
+export declare const EMPTY_PIVOT_CELL: {
+    readonly type: "EMPTY";
+};

package/dist/types/helpers/range.d.ts

@@ -0,0 +1,59 @@
+import { CellPosition, CoreGetters, CustomizedDataSet, Getters, Range, RangeData, RangePart, UID, UnboundedZone, Zone, ZoneDimension } from "../types";
+interface ConstructorArgs {
+    readonly zone: Readonly<Zone | UnboundedZone>;
+    readonly parts: readonly RangePart[];
+    readonly invalidXc?: string;
+    /** true if the user provided the range with the sheet name */
+    readonly prefixSheet: boolean;
+    /** the name of any sheet that is invalid */
+    readonly invalidSheetName?: string;
+    /** the sheet on which the range is defined */
+    readonly sheetId: UID;
+}
+export declare class RangeImpl implements Range {
+    private getSheetSize;
+    private readonly _zone;
+    readonly parts: Range["parts"];
+    readonly invalidXc?: string;
+    readonly prefixSheet: boolean;
+    readonly sheetId: UID;
+    readonly invalidSheetName?: string;
+    constructor(args: ConstructorArgs, getSheetSize: (sheetId: UID) => ZoneDimension);
+    static fromRange(range: Range, getters: CoreGetters): RangeImpl;
+    get unboundedZone(): UnboundedZone;
+    get zone(): Readonly<Zone>;
+    static getRangeParts(xc: string, zone: UnboundedZone): RangePart[];
+    get isFullCol(): boolean;
+    get isFullRow(): boolean;
+    get rangeData(): RangeData;
+    /**
+     * Check that a zone is valid regarding the order of top-bottom and left-right.
+     * Left should be smaller than right, top should be smaller than bottom.
+     * If it's not the case, simply invert them, and invert the linked parts
+     */
+    orderZone(): RangeImpl;
+    /**
+     *
+     * @param rangeParams optional, values to put in the cloned range instead of the current values of the range
+     */
+    clone(rangeParams?: Partial<ConstructorArgs>): RangeImpl;
+}
+/**
+ * Copy a range. If the range is on the sheetIdFrom, the range will target
+ * sheetIdTo.
+ */
+export declare function copyRangeWithNewSheetId(sheetIdFrom: UID, sheetIdTo: UID, range: Range): Range;
+/**
+ * Create a range from a xc. If the xc is empty, this function returns undefined.
+ */
+export declare function createValidRange(getters: CoreGetters, sheetId: UID, xc?: string): Range | undefined;
+/**
+ * Spread multiple colrows zone to one row/col zone and add a many new input range as needed.
+ * For example, A1:B4 will become [A1:A4, B1:B4]
+ */
+export declare function spreadRange(getters: Getters, dataSets: CustomizedDataSet[]): CustomizedDataSet[];
+/**
+ * Get all the cell positions in the given ranges. If a cell is in multiple ranges, it will be returned multiple times.
+ */
+export declare function getCellPositionsInRanges(ranges: Range[]): CellPosition[];
+export {};

package/dist/types/helpers/recompute_zones.d.ts

@@ -0,0 +1,130 @@
+import { UnboundedZone, Zone } from "../types";
+/**
+ * ####################################################
+ * # INTRODUCTION
+ * ####################################################
+ *
+ * This file contain the function recomputeZones.
+ * This function try to recompute in a performant way
+ * an ensemble of zones possibly overlapping to avoid
+ * overlapping and to reduce the number of zones.
+ *
+ * It also allows to remove some zones from the ensemble.
+ *
+ * In the following example, 2 zones are overlapping.
+ * Applying recomputeZones will return zones without
+ * overlapping:
+ *
+ * ["B3:D4", "D2:E3"]         ["B3:C4", "D2:D4", "E2:E3"]
+ *
+ *      A B C D E                    A B C D E
+ *    1       ___                  1       ___
+ *    2   ___|_  |                 2   ___| | |
+ *    3  |   |_|_|      --->       3  |   | |_|
+ *    4  |_____|                   4  |___|_|
+ *    6                            6
+ *    7                            7
+ *
+ *
+ * In the following example, 2 zones are contiguous.
+ * Applying recomputeZones will return only one zone:
+ *
+ *  ["B2:B3", "C2:D3"]               ["B2:D3"]
+ *
+ *       A B C D E                   A B C D E
+ *     1   _ ___                   1   _____
+ *     2  | |   |        --->      2  |     |
+ *     3  |_|___|                  3  |_____|
+ *     4                           4
+ *
+ *
+ * In the following example, we want to remove a zone
+ * from the ensemble. Applying recomputeZones will
+ * return the ensemble without the zone to remove:
+ *
+ *    remove ["C3:D3"]           ["B2:B4", "C2:D2",
+ *                                "C4:D4", "E2:E4"]
+ *
+ *       A B C D E F                 A B C D E F
+ *     1   _______                 1   _______
+ *     2  |       |       --->     2  | |___| |
+ *     3  |  xxx  |                3  | |___| |
+ *     4  |_______|                4  |_|___|_|
+ *     5                           5
+ *
+ *
+ * The exercise seems simple when we have only 2 zones.
+ * But with n zones and in a performant way, we want to
+ * avoid comparing each zone with all the others.
+ *
+ *
+ * ####################################################
+ * # Methodological approach
+ * ####################################################
+ *
+ * The methodological approach to avoid comparing each
+ * zone with all the others is to use a data structure
+ * that allow to quickly find which zones are
+ * overlapping with any other given zone.
+ *
+ * Here the idea is to profile the zones at the columns level.
+ *
+ * To do that, we propose to use a data structure
+ * composed of 2 parts:
+ * - profilesStartingPosition: a sorted number array
+ * indicating on which columns a new profile begins.
+ * - profiles: a map where the key is a column
+ * position (from profilesStartingPosition) and the
+ * value is a sorted number array representing a
+ * profile.
+ *
+ *
+ * See the following example:    here profileStartingPosition
+ *                               corresponds to [A,C,E,G,K]
+ *    A B C D E F G H I J K      so with number [0,2,4,6,10]
+ *  1    '   '   '       '
+ *  2    '   '   '_______'       here profile correspond
+ *  3    '___'   |_______|       for A to []
+ *  4    |   |                   for C to [3, 5]
+ *  5    |___|                   for E to []
+ *  6                            for G to [2, 3]
+ *  7                            for K to []
+ *
+ *
+ * Now we can easily find which zones are overlapping
+ * with a given zone. Suppose we want to add a new zone
+ * D5:H6 to the ensemble:
+ *
+ *                              With a binary search of left and right
+ *    A B C D E F G H I J K     on profilesStartingPosition, we can
+ *  1    '   '   '       '      find the indexes of the profiles on which
+ *  2    '   '   '_______'      to apply a modification.
+ *  3    '___'   |_______|
+ *  4    |  _|_______           Here we will:
+ *  5    |_|_|       |          - add a new profile in D   --> become [3, 6]
+ *  6      |_________|          - modify the profile in E  --> become [4, 6]
+ *  7                           - modify the profile in G  --> become [2, 3, 4, 6]
+ *                              - add a new profile in I   --> become [8, 10]
+ *
+ *  See below the result:
+ *
+ *                              Note the particularity of the profile
+ *    A B C D E F G H I J K     for G: it will correspond to [2, 3, 4, 6]
+ *  1    ' ' '   '   '   '
+ *  2    ' ' '   '___'___'      To know how to modify the profile (add a
+ *  3    '_'_'   |___|___|      zone or remove it) we do a binary
+ *  4    | | |___ ___           search of the top and bottom value on the
+ *  5    |_| |   |   |          profile array. Depending on the result index
+ *  6      |_|___|___|          parity (odd or even), because zone boundaries
+ *  7                           go by pairs, we know if we are in a zone or
+ *                              not and how operate.
+ */
+/**
+ * Recompute the zone without the cells in toRemoveZones and avoid overlapping.
+ * This compute is particularly useful because after this function:
+ * - you will find coordinate of a cell only once among all the zones
+ * - the number of zones will be reduced to the minimum
+ */
+export declare function recomputeZones<T extends UnboundedZone | Zone>(zones: T[], zonesToRemove?: (UnboundedZone | Zone)[]): T[];
+export declare function modifyProfiles<T extends Zone | UnboundedZone>(// export for testing only
+profilesStartingPosition: number[], profiles: Map<number, number[]>, zones: T[], toRemove?: boolean): void;

package/dist/types/helpers/rectangle.d.ts

@@ -0,0 +1,7 @@
+import { Rect } from "../types";
+/**
+ * Compute the intersection of two rectangles. Returns nothing if the two rectangles don't overlap
+ */
+export declare function rectIntersection(rect1: Rect, rect2: Rect): Rect | undefined;
+/** Compute the union of the rectangles, ie. the smallest rectangle that contain them all */
+export declare function rectUnion(...rects: Rect[]): Rect;

package/dist/types/helpers/reference_type.d.ts

@@ -0,0 +1,29 @@
+import { Token } from "../formulas";
+import { Locale } from "../types";
+type FixedReferenceType = "col" | "row" | "colrow" | "none";
+/**
+ * Change the reference types inside the given token, if the token represent a range or a cell
+ *
+ * Eg. :
+ *   A1 => $A$1 => A$1 => $A1 => A1
+ *   A1:$B$1 => $A$1:B$1 => A$1:$B1 => $A1:B1 => A1:$B$1
+ */
+export declare function loopThroughReferenceType(token: Readonly<Token>): Token;
+/**
+ * Returns the given XC with the given reference type. The XC string should not contain a sheet name.
+ */
+export declare function setXcToFixedReferenceType(xc: string, referenceType: FixedReferenceType): string;
+/**
+ * Return the cycled reference if any (A1 -> $A$1 -> A$1 -> $A1 -> A1)
+ */
+export declare function cycleFixedReference(selection: {
+    start: number;
+    end: number;
+}, content: string, locale: Locale): {
+    content: string;
+    selection: {
+        start: number;
+        end: number;
+    };
+} | undefined;
+export {};

package/dist/types/helpers/references.d.ts

@@ -0,0 +1,25 @@
+/** Reference of a cell (eg. A1, $B$5) */
+export declare const cellReference: RegExp;
+/** Reference of a cell or a range, it can be a bounded range, a full row or a full column */
+export declare const rangeReference: RegExp;
+/**
+ * Return true if the given xc is the reference of a column (e.g. A or AC or Sheet1!A)
+ */
+export declare function isColReference(xc: string): boolean;
+/**
+ * Return true if the given xc is the reference of a column (e.g. 1 or Sheet1!1)
+ */
+export declare function isRowReference(xc: string): boolean;
+export declare function isColHeader(str: string): boolean;
+export declare function isRowHeader(str: string): boolean;
+/**
+ * Return true if the given xc is the reference of a single cell,
+ * without any specified sheet (e.g. A1)
+ */
+export declare function isSingleCellReference(xc: string): boolean;
+export declare function splitReference(ref: string): {
+    sheetName?: string;
+    xc: string;
+};
+/** Return a reference SheetName!xc from the given arguments */
+export declare function getFullReference(sheetName: string | undefined, xc: string): string;

package/dist/types/helpers/rendering.d.ts

@@ -0,0 +1,2 @@
+import { GridRenderingContext, Highlight, Rect } from "../types";
+export declare function drawHighlight(renderingContext: GridRenderingContext, highlight: Highlight, rect: Rect): void;

package/dist/types/helpers/search.d.ts

@@ -0,0 +1,19 @@
+/** Methods from Odoo Web Utils  */
+/**
+ * This function computes a score that represent the fact that the
+ * string contains the pattern, or not
+ *
+ * - If the score is 0, the string does not contain the letters of the pattern in
+ *   the correct order.
+ * - if the score is > 0, it actually contains the letters.
+ *
+ * Better matches will get a higher score: consecutive letters are better,
+ * and a match closer to the beginning of the string is also scored higher.
+ */
+export declare function fuzzyMatch(pattern: string, str: string): number;
+/**
+ * Return a list of things that matches a pattern, ordered by their 'score' (
+ * higher score first). An higher score means that the match is better. For
+ * example, consecutive letters are considered a better match.
+ */
+export declare function fuzzyLookup<T>(pattern: string, list: T[], fn: (t: T) => string): T[];

package/dist/types/helpers/sheet.d.ts

@@ -0,0 +1,7 @@
+import { HeaderIndex, Row } from "../types";
+export declare function createDefaultRows(rowNumber: number): Row[];
+export declare function moveHeaderIndexesOnHeaderAddition(indexHeaderAdded: HeaderIndex, numberAdded: number, headers: HeaderIndex[]): HeaderIndex[];
+export declare function moveHeaderIndexesOnHeaderDeletion(deletedHeaders: HeaderIndex[], headers: HeaderIndex[]): HeaderIndex[];
+export declare function getNextSheetName(existingNames: string[], baseName?: string): string;
+export declare function getDuplicateSheetName(nameToDuplicate: string, existingNames: string[]): string;
+export declare function isSheetNameEqual(name1: string | undefined, name2: string | undefined): boolean;

package/dist/types/helpers/sort.d.ts

@@ -0,0 +1,16 @@
+import { CellValue, CellValueType, EvaluatedCell, Position, SortDirection, SpreadsheetChildEnv, UID, Zone } from "../types";
+type CellWithIndex = {
+    index: number;
+    type: CellValueType;
+    value: any;
+};
+export declare function cellsSortingCriterion(sortingOrder: string): (left: {
+    type: CellValueType;
+    value: CellValue;
+}, right: {
+    type: CellValueType;
+    value: CellValue;
+}) => number;
+export declare function sortCells(cells: EvaluatedCell[], sortDirection: SortDirection, emptyCellAsZero: boolean): CellWithIndex[];
+export declare function interactiveSortSelection(env: SpreadsheetChildEnv, sheetId: UID, anchor: Position, zone: Zone, sortDirection: SortDirection): void;
+export {};

package/dist/types/helpers/state_manager_helpers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Create an empty structure according to the type of the node key:
+ * string: object
+ * number: array
+ */
+export declare function createEmptyStructure(node: string | number | any): {};

package/dist/types/helpers/table_helpers.d.ts

@@ -0,0 +1,9 @@
+import { CellPosition, Range, UID, Zone } from "../types";
+import { CoreTable, Filter, StaticTable, Table, TableConfig, TableStyle } from "../types/table";
+import { ComputedTableStyle } from "./../types/table";
+/** Return the content zone of the table, ie. the table zone without the headers */
+export declare function getTableContentZone(tableZone: Zone, tableConfig: TableConfig): Zone | undefined;
+export declare function getTableTopLeft(table: Table | CoreTable): CellPosition;
+export declare function createFilter(id: UID, range: Range, config: TableConfig, createRange: (sheetId: UID, zone: Zone) => Range): Filter;
+export declare function isStaticTable(table: CoreTable): table is StaticTable;
+export declare function getComputedTableStyle(tableConfig: TableConfig, style: TableStyle, numberOfCols: number, numberOfRows: number): ComputedTableStyle;

package/dist/types/helpers/table_presets.d.ts

@@ -0,0 +1,23 @@
+import { Color } from "../types";
+import { TableConfig, TableStyle, TableStyleTemplateName } from "../types/table";
+export declare const TABLE_STYLE_CATEGORIES: {
+    light: string;
+    medium: string;
+    dark: string;
+    custom: string;
+};
+export declare const DEFAULT_TABLE_CONFIG: TableConfig;
+interface ColorSet {
+    name: string;
+    coloredText: Color;
+    light: Color;
+    medium: Color;
+    dark: Color;
+    mediumBorder: Color;
+    highlight: Color;
+}
+export type TableStyleTemplate = (colorSet: ColorSet) => Omit<TableStyle, "displayName">;
+export declare const TABLE_PRESETS: Record<string, TableStyle>;
+export declare const TABLE_STYLES_TEMPLATES: Record<TableStyleTemplateName, TableStyleTemplate>;
+export declare function buildTableStyle(name: string, templateName: TableStyleTemplateName, primaryColor: Color): TableStyle;
+export {};

package/dist/types/helpers/text_helper.d.ts

@@ -0,0 +1,35 @@
+import { Cell, Locale, Pixel, PixelPosition, Style } from "../types";
+export declare function computeTextLinesHeight(textLineHeight: number, numberOfLines?: number): number;
+/**
+ * Get the default height of the cell given its style.
+ */
+export declare function getDefaultCellHeight(ctx: CanvasRenderingContext2D, cell: Cell | undefined, locale: Locale, colSize: number): number;
+export declare function getCellContentHeight(ctx: CanvasRenderingContext2D, content: string, style: Style | undefined, colSize: number): number;
+export declare function getDefaultContextFont(fontSize: number, bold?: boolean | undefined, italic?: boolean | undefined): string;
+export declare function computeTextWidth(context: CanvasRenderingContext2D, text: string, style: Style, fontUnit?: "px" | "pt"): number;
+export declare function computeCachedTextWidth(context: CanvasRenderingContext2D, text: string): number;
+export declare function computeTextDimension(context: CanvasRenderingContext2D, text: string, style: Style, fontUnit?: "px" | "pt"): {
+    width: number;
+    height: number;
+};
+export declare function fontSizeInPixels(fontSize: number): number;
+export declare function computeTextFont(style: Style, fontUnit?: "px" | "pt"): string;
+export declare function computeTextFontSizeInPixels(style?: Style): number;
+/**
+ * Return the given text, 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.
+ */
+export declare function splitTextToWidth(ctx: CanvasRenderingContext2D, text: string, style: Style | undefined, width: number | undefined): string[];
+/**
+ * Return the font size that makes the width of a text match the given line width.
+ * Minimum font size is 1.
+ *
+ * @param getTextWidth function that takes a fontSize as argument, and return the width of the text with this font size.
+ */
+export declare function getFontSizeMatchingWidth(lineWidth: number, maxFontSize: number, getTextWidth: (fontSize: number) => number, precision?: number): number;
+export declare function computeIconWidth(style: Style): number;
+/** Transform a string to lower case. If the string is undefined, return an empty string */
+export declare function toLowerCase(str: string | undefined): string;
+export declare function getContextFontSize(font: string): Pixel;
+export declare function clipTextWithEllipsis(ctx: CanvasRenderingContext2D, text: string, maxWidth: number): string;
+export declare function drawDecoratedText(context: CanvasRenderingContext2D, text: string, position: PixelPosition, underline?: boolean | undefined, strikethrough?: boolean | undefined, strokeWidth?: number): void;

package/dist/types/helpers/ui/cut_interactive.d.ts

@@ -0,0 +1,2 @@
+import { SpreadsheetChildEnv } from "../../types";
+export declare function interactiveCut(env: SpreadsheetChildEnv): void;

package/dist/types/helpers/ui/freeze_interactive.d.ts

@@ -0,0 +1,2 @@
+import { Dimension, HeaderIndex, SpreadsheetChildEnv } from "../../types";
+export declare function interactiveFreezeColumnsRows(env: SpreadsheetChildEnv, dimension: Dimension, base: HeaderIndex): void;

package/dist/types/helpers/ui/merge_interactive.d.ts

@@ -0,0 +1,6 @@
+import { SpreadsheetChildEnv, UID, Zone } from "../../types";
+export declare const AddMergeInteractiveContent: {
+    MergeIsDestructive: string;
+    MergeInFilter: string;
+};
+export declare function interactiveAddMerge(env: SpreadsheetChildEnv, sheetId: UID, target: Zone[]): void;

package/dist/types/helpers/ui/paste_interactive.d.ts

@@ -0,0 +1,10 @@
+import { ClipboardPasteOptions, DispatchResult, ParsedOSClipboardContent, SpreadsheetChildEnv, Zone } from "../../types";
+export declare const PasteInteractiveContent: {
+    wrongPasteSelection: string;
+    willRemoveExistingMerge: string;
+    wrongFigurePasteOption: string;
+    frozenPaneOverlap: string;
+};
+export declare function handlePasteResult(env: SpreadsheetChildEnv, result: DispatchResult): void;
+export declare function interactivePaste(env: SpreadsheetChildEnv, target: Zone[], pasteOption?: ClipboardPasteOptions): void;
+export declare function interactivePasteFromOS(env: SpreadsheetChildEnv, target: Zone[], clipboardContent: ParsedOSClipboardContent, pasteOption?: ClipboardPasteOptions): void;

package/dist/types/helpers/ui/sheet_interactive.d.ts

@@ -0,0 +1,2 @@
+import { SpreadsheetChildEnv, UID } from "../../types";
+export declare function interactiveRenameSheet(env: SpreadsheetChildEnv, sheetId: UID, name: string, errorCallback: () => void): void;

package/dist/types/helpers/ui/split_to_columns_interactive.d.ts

@@ -0,0 +1,6 @@
+import { SpreadsheetChildEnv } from "../../types";
+import { DispatchResult } from "./../../types/commands";
+export declare const SplitToColumnsInteractiveContent: {
+    SplitIsDestructive: string;
+};
+export declare function interactiveSplitToColumns(env: SpreadsheetChildEnv, separator: string, addNewColumns: boolean): DispatchResult;

package/dist/types/helpers/ui/table_interactive.d.ts

@@ -0,0 +1,7 @@
+import { DispatchResult, SpreadsheetChildEnv, UID } from "../../types";
+import { TableConfig } from "../../types/table";
+/**
+ * Create a table on the selected zone, with UI warnings to the user if the creation fails.
+ * If a single cell is selected, expand the selection to non-empty adjacent cells to create a table.
+ */
+export declare function interactiveCreateTable(env: SpreadsheetChildEnv, sheetId: UID, tableConfig?: TableConfig): DispatchResult;

package/dist/types/helpers/ui/toggle_group_interactive.d.ts

@@ -0,0 +1,6 @@
+import { Dimension, HeaderIndex, SpreadsheetChildEnv, UID } from "../../types";
+export declare const ToggleGroupInteractiveContent: {
+    CannotHideAllRows: string;
+    CannotHideAllColumns: string;
+};
+export declare function interactiveToggleGroup(env: SpreadsheetChildEnv, sheetId: UID, dimension: Dimension, start: HeaderIndex, end: HeaderIndex): void;

package/dist/types/helpers/uuid.d.ts

@@ -0,0 +1,20 @@
+export declare class UuidGenerator {
+    private isFastIdStrategy;
+    private fastIdStart;
+    setIsFastStrategy(isFast: boolean): void;
+    /**
+     * Generates a custom UUID using a simple 36^12 method (8-character alphanumeric string with lowercase letters)
+     * This has a higher chance of collision than a UUIDv4, but not only faster to generate than an UUIDV4,
+     * it also has a smaller size, which is preferable to alleviate the overall data size.
+     *
+     * This method is preferable when generating uuids for the core data (sheetId, figureId, etc)
+     * as they will appear several times in the revisions and local history.
+     *
+     */
+    smallUuid(): string;
+    /**
+     * Generates an UUIDV4, has astronomically low chance of collision, but is larger in size than the smallUuid.
+     * This method should be used when you need to avoid collisions at all costs, like the id of a revision.
+     */
+    uuidv4(): string;
+}