@odoo/o-spreadsheet 19.2.0-alpha.4 → 19.3.2

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

@@ -0,0 +1,20 @@
+import { CommonPivotCoreDefinition, PivotCollapsedDomains, PivotCustomGroupedField, PivotDimension, PivotFields, PivotMeasure, PivotSortedColumn } from "../../types/pivot";
+/**
+ * Represent a pivot runtime definition. A pivot runtime definition is a pivot
+ * definition that has been enriched to include the display name of its attributes
+ * (measures, columns, rows).
+ */
+export declare class PivotRuntimeDefinition {
+    readonly measures: PivotMeasure[];
+    readonly columns: PivotDimension[];
+    readonly rows: PivotDimension[];
+    readonly sortedColumn?: PivotSortedColumn;
+    readonly collapsedDomains?: PivotCollapsedDomains;
+    readonly customFields?: Record<string, PivotCustomGroupedField>;
+    constructor(definition: CommonPivotCoreDefinition, fields: PivotFields);
+    getDimension(nameWithGranularity: string): PivotDimension;
+    getMeasure(id: string): PivotMeasure;
+    get invalidAggregatorsForCustomField(): string[];
+    private createMeasure;
+    private createPivotDimension;
+}

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

@@ -0,0 +1,6 @@
+import { Component } from "@odoo/owl";
+import { Registry } from "../../registries/registry";
+export interface PivotRegistryItem {
+    editor: new (...args: any) => Component;
+}
+export declare const pivotSidePanelRegistry: Registry<PivotRegistryItem>;

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

@@ -0,0 +1,10 @@
+import { Registry } from "../../registries/registry";
+import { CellValue } from "../../types/cells";
+import { Granularity, PivotTimeAdapter } from "../../types/pivot";
+/**
+ * Converts "period/year" (e.g. "48/2026", "03/2025", "1/2020")
+ * into a numeric value that preserves chronological ordering.
+ */
+export declare function periodYearToComparable(value: string): number;
+export declare const pivotTimeAdapterRegistry: Registry<PivotTimeAdapter<CellValue>>;
+export declare function pivotTimeAdapter(granularity: Granularity): PivotTimeAdapter<CellValue>;

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

@@ -0,0 +1,20 @@
+import { EvaluatedCell } from "../../../types/cells";
+import { PivotDimension } from "../../../types/pivot";
+import { SpreadsheetPivotTable } from "../table_spreadsheet_pivot";
+import { SpreadsheetPivotRuntimeDefinition } from "./runtime_definition_spreadsheet_pivot";
+export type FieldName = string;
+export type FieldValue = Pick<EvaluatedCell, "type" | "format" | "value" | "formattedValue">;
+export type DataEntry = Record<FieldName, FieldValue | undefined>;
+export type DataEntries = DataEntry[];
+/**
+ * This function converts a list of data entry into a spreadsheet pivot table.
+ */
+export declare function dataEntriesToSpreadsheetPivotTable(dataEntries: DataEntries, definition: SpreadsheetPivotRuntimeDefinition, mode: "collapsed" | "expanded"): SpreadsheetPivotTable;
+/**
+ * Group the dataEntries based on the given dimension
+ */
+export declare function groupPivotDataEntriesBy(dataEntries: DataEntries, dimension: PivotDimension): Partial<Record<string, DataEntry[]>>;
+/**
+ * Order the keys of the given data entries, based on the given dimension
+ */
+export declare function orderDataEntriesKeys(groups: Partial<Record<string, DataEntries>>, dimension: PivotDimension): string[];

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

@@ -0,0 +1,8 @@
+import { CellValue } from "../../../types/cells";
+import { Locale } from "../../../types/locale";
+import { PivotDimension } from "../../../types/pivot";
+export declare function createDate(dimension: Pick<PivotDimension, "type" | "displayName" | "granularity">, value: CellValue, locale: Locale): CellValue;
+/**
+ * Reset the cache of the pivot date values.
+ */
+export declare function resetMapValueDimensionDate(): void;

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

@@ -0,0 +1,8 @@
+import { Getters } from "../../../types/getters";
+import { PivotFields, SpreadsheetPivotCoreDefinition } from "../../../types/pivot";
+import { Range } from "../../../types/range";
+import { PivotRuntimeDefinition } from "../pivot_runtime_definition";
+export declare class SpreadsheetPivotRuntimeDefinition extends PivotRuntimeDefinition {
+    readonly range?: Range;
+    constructor(definition: SpreadsheetPivotCoreDefinition, fields: PivotFields, getters: Getters);
+}

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

@@ -0,0 +1,91 @@
+import { FunctionResultObject, Maybe, ValueAndLabel } from "../../../types/misc";
+import { ModelConfig } from "../../../types/model";
+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 collapsedTable;
+    private expandedTable;
+    /**
+     * 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): ValueAndLabel<string | number | boolean>[];
+    getCollapsedTableStructure(): SpreadsheetPivotTable;
+    getExpandedTableStructure(): 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;
+    private extractDataEntriesFromRange;
+}
+export {};

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

@@ -0,0 +1,111 @@
+import { FunctionResultObject } from "../../types/misc";
+import { DimensionTree, PivotCollapsedDomains, PivotDomain, PivotSortedColumn, PivotStyle, PivotTableCell, PivotTableColumn, PivotTableRow } from "../../types/pivot";
+interface CollapsiblePivotTableColumn extends PivotTableColumn {
+    collapsedHeader?: boolean;
+}
+/**
+ * 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: CollapsiblePivotTableColumn[][];
+    rows: PivotTableRow[];
+    readonly rowFields: string[];
+    readonly measures: string[];
+    readonly fieldsType: Record<string, string | undefined>;
+    readonly maxIndent: number;
+    readonly pivotCells: {
+        [key: string]: PivotTableCell[][];
+    };
+    private rowTree;
+    private colTree;
+    isSorted: boolean;
+    constructor(columns: CollapsiblePivotTableColumn[][], rows: PivotTableRow[], measures: string[], fieldsType: Record<string, string | undefined>, collapsedDomains?: PivotCollapsedDomains);
+    private removeCollapsedColumns;
+    private isParentCollapsed;
+    /**
+     * Get the number of columns leafs (i.e. the number of the last row of columns)
+     */
+    getNumberOfDataColumns(): number;
+    private getSkippedRows;
+    getPivotCells(pivotStyle?: Required<PivotStyle>): PivotTableCell[][];
+    getRowTree(): DimensionTree;
+    getColTree(): DimensionTree;
+    private isTotalRow;
+    private getPivotCell;
+    private getColHeaderDomain;
+    private getDomain;
+    private getColDomain;
+    private getColMeasure;
+    private getRowHeadersWidth;
+    private getColHeadersHeight;
+    buildRowsTree(): DimensionTree;
+    buildColumnsTree(): DimensionTree;
+    export(): {
+        cols: CollapsiblePivotTableColumn[][];
+        rows: PivotTableRow[];
+        measures: string[];
+        fieldsType: Record<string, string | undefined>;
+    };
+    sort(measure: string, sortedColumn: PivotSortedColumn, getValue: (measure: string, domain: PivotDomain) => FunctionResultObject): void;
+    private rowTreeToRows;
+    get numberOfCells(): number;
+    getColumnDomainsAtDepth(depth: number): {
+        type: string;
+        field: string;
+        value: import("../..").CellValue;
+    }[][];
+    getRowDomainsAtDepth(depth: number): {
+        type: string;
+        field: string;
+        value: import("../..").CellValue;
+    }[][];
+    getPivotTableDimensions(pivotStyle: Required<PivotStyle>): {
+        numberOfCols: number;
+        numberOfRows: number;
+        numberOfHeaderRows: number;
+    };
+    getNumberOfRowGroupBys(): number;
+}
+export declare const EMPTY_PIVOT_CELL: {
+    readonly type: "EMPTY";
+};
+export {};

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

@@ -0,0 +1,3 @@
+import { TableStyle } from "../types/table";
+export declare const PIVOT_TABLE_PRESETS: Record<string, TableStyle>;
+export declare function pivotTableStyleIdToTableStyleId(pivotStyleId: string): string;

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

@@ -0,0 +1,63 @@
+import { Registry } from "../registries/registry";
+import { CoreCommand, CoreCommandTypes } from "../types/commands";
+import { CoreGetters } from "../types/core_getters";
+import { CellPosition, RangeAdapter, UID, UnboundedZone, ZoneDimension } from "../types/misc";
+import { BoundedRange, Range, RangePart, RangeStringOptions } from "../types/range";
+interface RangeArgs {
+    zone: Readonly<UnboundedZone>;
+    parts: readonly RangePart[];
+    /** true if the user provided the range with the sheet name */
+    prefixSheet: boolean;
+    /** the name of any sheet that is invalid */
+    invalidSheetName?: string;
+    /** the sheet on which the range is defined */
+    sheetId: UID;
+}
+interface RangeXcArgs {
+    xc: string;
+    /** the name of any sheet that is invalid */
+    invalidSheetName?: string;
+    /** the sheet on which the range is defined */
+    sheetId: UID;
+}
+export declare function createRange(args: RangeArgs, getSheetSize: (sheetId: UID) => ZoneDimension): Range;
+/**
+ * Create a range from a string XC: A1, Sheet1!A1
+ * The XC is expected to be valid.
+ */
+export declare function createRangeFromXc(args: RangeXcArgs, getSheetSize: (sheetId: UID) => ZoneDimension): Range;
+export declare function createInvalidRange(sheetXC: string): Range;
+export declare function isFullColRange(range: Range): boolean;
+export declare function isFullRowRange(range: Range): boolean;
+export declare function getRangeString(range: Range, forSheetId: UID | undefined, getSheetName: (sheetId: UID) => string, options?: RangeStringOptions): string;
+/**
+ * Duplicate a range. If the range is on the sheetIdFrom, the range will target
+ * sheetIdTo.
+ */
+export declare function duplicateRangeInDuplicatedSheet(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;
+/**
+ * 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 declare function positionToBoundedRange(position: CellPosition): BoundedRange;
+/**
+ * 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
+ */
+export declare function orderRange(range: Range): Range;
+type GetRangeAdapter<C extends CoreCommand> = (cmd: C) => RangeAdapter;
+declare class RangeAdapterRegistry extends Registry<GetRangeAdapter<CoreCommand>> {
+    add<C extends CoreCommandTypes>(cmdType: C, fn: GetRangeAdapter<Extract<CoreCommand, {
+        type: C;
+    }>>): this;
+    get<C extends CoreCommandTypes>(cmdType: C): GetRangeAdapter<Extract<CoreCommand, {
+        type: C;
+    }>>;
+}
+export declare const rangeAdapterRegistry: RangeAdapterRegistry;
+export {};

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

@@ -0,0 +1,2 @@
+import { CoreCommand, RangeAdapterFunctions } from "..";
+export declare function getRangeAdapterFunctions(executedCommand: CoreCommand): RangeAdapterFunctions | undefined;

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

@@ -0,0 +1,133 @@
+import { UnboundedZone, Zone } from "../types/misc";
+/**
+ * ####################################################
+ * # 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;
+export declare function profilesContainsZone(profilesStartingPosition: number[], profiles: Map<number, number[]>, zone: Zone | UnboundedZone): boolean;
+export declare function findIndexAndCreateProfile(profilesStartingPosition: number[], profiles: Map<number, number[]>, value: number | undefined, searchLeft: boolean, startIndex: number): number;
+export declare function constructZonesFromProfiles<T extends UnboundedZone | Zone>(profilesStartingPosition: number[], profiles: Map<number, number[]>): T[];

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

@@ -0,0 +1,8 @@
+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;
+export declare function isPointInsideRect(x: number, y: number, rect: Rect): boolean;

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

@@ -0,0 +1,14 @@
+import { Locale } from "../types/locale";
+/**
+ * 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;

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

@@ -0,0 +1,27 @@
+import { Token } from "../formulas/tokenizer";
+export declare const cellReference: RegExp;
+export declare const rangeReference: RegExp;
+export declare function isColReference(xc: string): boolean;
+export declare function isRowReference(xc: string): boolean;
+export declare function isColHeader(str: string): boolean;
+export declare function isRowHeader(str: string): boolean;
+export declare function isSingleCellReference(xc: string): boolean;
+export declare function splitReference(ref: string): {
+    sheetName?: string;
+    xc: string;
+};
+export declare function getFullReference(sheetName: string | undefined, xc: string): string;
+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.
+ */
+export declare function setXcToFixedReferenceType(xc: string, referenceType: FixedReferenceType): string;
+export {};

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

@@ -0,0 +1,14 @@
+import { CellValueType, EvaluatedCell, Lazy, Locale } from "../types";
+export interface StatisticFnResults {
+    [name: string]: {
+        value: Lazy<number | string> | undefined;
+        format?: string;
+    } | undefined;
+}
+export interface SelectionStatisticFunction {
+    name: string;
+    compute: (data: EvaluatedCell[], locale: Locale) => number | string;
+    types: CellValueType[];
+    format?: string;
+}
+export declare function computeStatisticFnResults(selectionStatisticFunctions: SelectionStatisticFunction[], cells: EvaluatedCell[], locale: Locale): StatisticFnResults;

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

@@ -0,0 +1,8 @@
+import { HeaderIndex, Row } from "../types/misc";
+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 const toStandardizedSheetName: (name: 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 } from "../types/cells";
+import { SortDirection } from "../types/misc";
+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 {};

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

@@ -0,0 +1,4 @@
+import { Position, SortDirection, SortOptions, UID, Zone } from "../types/misc";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+export declare function interactiveSortSelection(env: SpreadsheetChildEnv, sheetId: UID, anchor: Position, zone: Zone, sortDirection: SortDirection): void;
+export declare function interactiveSort(env: SpreadsheetChildEnv, sheetId: UID, anchor: Position, zone: Zone, sortDirection: SortDirection, sortOptions?: SortOptions): void;

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, UID, Zone } from "../types/misc";
+import { Range } from "../types/range";
+import { ComputedTableStyle, CoreTable, Filter, StaticTable, Table, TableConfig, TableMetaData, TableStyle } 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, tableMetaData: TableMetaData): ComputedTableStyle;