@odoo/o-spreadsheet 19.2.11 → 19.3.2

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

@@ -0,0 +1,230 @@
+import { Cell } from "../types/cells";
+import { ChartStyle } from "../types/chart";
+import { SearchOptions } from "../types/find_and_replace";
+import { Getters } from "../types/getters";
+import { CellPosition, ConsecutiveIndexes, DebouncedFunction, Lazy, Style, UID } from "../types/misc";
+/**
+ * Escapes a string to use as a literal string in a RegExp.
+ * @url https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
+ */
+export declare function escapeRegExp(str: string): string;
+/**
+ * Deep copy arrays, plain objects and primitive values.
+ * Throws an error for other types such as class instances.
+ * Sparse arrays remain sparse.
+ */
+export declare function deepCopy<T>(obj: T): T;
+/**
+ * Sanitize the name of a sheet, by eventually removing quotes.
+ */
+export declare function getUnquotedSheetName(sheetName: string): string;
+/**
+ * Remove quotes from a quoted string.
+ */
+export declare function unquote(string: string, quoteChar?: "'" | '"'): string;
+/**
+ * Add quotes around the sheet name or any symbol name if it contains at least one non alphanumeric character.
+ */
+export declare function getCanonicalSymbolName(symbolName: string): string;
+/** Replace the excel-excluded characters of a sheetName */
+export declare function sanitizeSheetName(sheetName: string, replacementChar?: string): string;
+export declare function clip(val: number, min: number, max: number): number;
+/**
+ * Create a range from start (included) to end (excluded).
+ * range(10, 13) => [10, 11, 12]
+ * range(2, 8, 2) => [2, 4, 6]
+ */
+export declare function range(start: number, end: number, step?: number): number[];
+/**
+ * Groups consecutive numbers.
+ * The input array is assumed to be sorted
+ * @param numbers
+ */
+export declare function groupConsecutive(numbers: number[]): ConsecutiveIndexes[];
+/**
+ * Create one generator from two generators by linking
+ * each item of the first generator to the next item of
+ * the second generator.
+ *
+ * Let's say generator G1 yields A, B, C and generator G2 yields X, Y, Z.
+ * The resulting generator of `linkNext(G1, G2)` will yield A', B', C'
+ * where `A' = A & {next: Y}`, `B' = B & {next: Z}` and `C' = C & {next: undefined}`
+ * @param generator
+ * @param nextGenerator
+ */
+export declare function linkNext<T>(generator: Generator<T>, nextGenerator: Generator<T>): Generator<T & {
+    next?: T;
+}>;
+export declare function isBoolean(str: string): boolean;
+export declare function isMarkdownLink(str: string): boolean;
+/**
+ * Check if the string is a web link.
+ * e.g. http://odoo.com
+ */
+export declare function isWebLink(str: string): boolean;
+/**
+ * Build a markdown link from a label and an url
+ */
+export declare function markdownLink(label: string, url: string): string;
+export declare function parseMarkdownLink(str: string): {
+    url: string;
+    label: string;
+};
+export declare function isSheetUrl(url: string): boolean;
+export declare function buildSheetLink(sheetId: UID): string;
+/**
+ * Parse a sheet link and return the sheet id
+ */
+export declare function parseSheetUrl(sheetLink: string): string;
+/**
+ * This helper function can be used as a type guard when filtering arrays.
+ * const foo: number[] = [1, 2, undefined, 4].filter(isDefined)
+ */
+export declare function isDefined<T>(argument: T | undefined): argument is T;
+export declare function isNotNull<T>(argument: T | null): argument is T;
+/**
+ * Check if all the values of an object, and all the values of the objects inside of it, are undefined.
+ */
+export declare function isObjectEmptyRecursive<T extends object>(argument: T | undefined): boolean;
+/**
+ * Returns a function, that, as long as it continues to be invoked, will not
+ * be triggered. The function will be called after it stops being called for
+ * N milliseconds. If `immediate` is passed,  the function is called is called
+ * immediately on the first call and the debouncing is triggered starting the second
+ * call in the defined time window.
+ *
+ * Example:
+ * debouncedFunction = debounce(() => console.log('Hello!'), 250);
+ * debouncedFunction(); debouncedFunction(); // Will log 'Hello!' after 250ms
+ *
+ * debouncedFunction = debounce(() => console.log('Hello!'), 250, true);
+ * debouncedFunction(); debouncedFunction(); // Will log 'Hello!' and relog it after 250ms
+ *
+ *
+ * Also decorate the argument function with two methods: stopDebounce and isDebouncePending.
+ *
+ * Inspired by https://davidwalsh.name/javascript-debounce-function
+ */
+export declare function debounce<T extends (...args: any) => void>(func: T, wait: number, immediate?: boolean): DebouncedFunction<T>;
+/**
+ * Creates a batched version of a callback so that all calls to it in the same
+ * microtick will only call the original callback once.
+ *
+ * @param callback the callback to batch
+ * @returns a batched version of the original callback
+ *
+ * Copied from odoo/owl repo.
+ */
+export declare function batched(callback: () => void): () => void;
+/** Returns a copy of the function `callback` that can only be called
+ * at most once every `delay` milliseconds.
+ */
+export declare function throttle<T extends (...args: any[]) => any>(callback: T, delay: number): (...args: Parameters<T>) => ReturnType<T>;
+export declare function concat(chars: string[]): string;
+/**
+ * Lazy value computed by the provided function.
+ */
+export declare function lazy<T>(fn: (() => T) | T): Lazy<T>;
+/**
+ * Find the next defined value after the given index in an array of strings. If there is no defined value
+ * after the index, return the closest defined value before the index. Return an empty string if no
+ * defined value was found.
+ *
+ */
+export declare function findNextDefinedValue(arr: string[], index: number): string;
+/** Get index of first header added by an ADD_COLUMNS_ROWS command */
+export declare function getAddHeaderStartIndex(position: "before" | "after", base: number): number;
+/**
+ * Compares n objects.
+ */
+export declare function deepEquals(...o: any[]): boolean;
+/**
+ * Compares two arrays.
+ * For performance reasons, this function is to be preferred
+ * to 'deepEquals' in the case we know that the inputs are arrays.
+ */
+export declare function deepEqualsArray(arr1: unknown[], arr2: unknown[]): boolean;
+/**
+ * Check if the given array contains all the values of the other array.
+ * It makes the assumption that both array do not contain duplicates.
+ */
+export declare function includesAll<T>(arr: T[], values: T[]): boolean;
+/**
+ * Return an object with all the keys in the object that have a falsy value removed.
+ */
+export declare function removeFalsyAttributes<T extends Object | undefined | null>(obj: T): T;
+export declare const specialWhiteSpaceRegexp: RegExp;
+export declare const whiteSpaceCharacters: string[];
+/**
+ * Replace all different newlines characters by \n.
+ */
+export declare function replaceNewLines(text: string | undefined): string;
+/**
+ * Determine if the numbers are consecutive.
+ */
+export declare function isConsecutive(iterable: Iterable<number>): boolean;
+/**
+ * Creates a version of the function that's memoized on the value of its first argument, if any.
+ */
+export declare function memoize<T extends any[], U>(func: (...args: T) => U): (...args: T) => U;
+/**
+ * Removes the specified indexes from the array.
+ * Sparse (empty) elements are transformed to undefined (unless their index is explicitly removed).
+ */
+export declare function removeIndexesFromArray<T>(array: readonly T[], indexes: number[]): T[];
+export declare function insertItemsAtIndex<T>(array: readonly T[], items: T[], index: number): T[];
+export declare function replaceItemAtIndex<T>(array: readonly T[], newItem: T, index: number): T[];
+export declare function trimContent(content: string): string;
+export declare function isNumberBetween(value: number, min: number, max: number): boolean;
+/**
+ * Get a Regex for the find & replace that matches the given search string and options.
+ */
+export declare function getSearchRegex(searchStr: string, searchOptions: SearchOptions): RegExp;
+/**
+ * Alternative to Math.max that works with large arrays.
+ * Typically useful for arrays bigger than 100k elements.
+ */
+export declare function largeMax(array: number[]): number;
+/**
+ * Alternative to Math.min that works with large arrays.
+ * Typically useful for arrays bigger than 100k elements.
+ */
+export declare function largeMin(array: number[]): number;
+export declare class TokenizingChars {
+    private readonly text;
+    private currentIndex;
+    current: string;
+    constructor(text: string);
+    shift(): string;
+    advanceBy(length: number): void;
+    isOver(): boolean;
+    remaining(): string;
+    currentStartsWith(str: string): boolean;
+}
+/**
+ * Remove duplicates from an array.
+ *
+ * @param array The array to remove duplicates from.
+ * @param cb A callback to get an element value.
+ */
+export declare function removeDuplicates<T>(array: T[], cb?: (a: T) => any): T[];
+/**
+ * Similar to transposing and array, but with POJOs instead of arrays. Useful, for example, when manipulating
+ * a POJO grid[col][row] and you want to transpose it to grid[row][col].
+ *
+ * The resulting object is created such as result[key1][key2] = pojo[key2][key1]
+ */
+export declare function transpose2dPOJO<T>(pojo: Record<string, Record<string, T>>): Record<string, Record<string, T>>;
+export declare function getUniqueText(text: string, texts: string[], options?: {
+    compute?: (text: string, increment: number) => string;
+    start?: number;
+    computeFirstOne?: boolean;
+}): string;
+export declare function isFormula(content: string): boolean;
+export declare function chartStyleToCellStyle(style: ChartStyle): Style;
+export declare function doesCellContainFunction(cell: Cell, formula: string): boolean;
+/** Return the number of cols/rows missing for result of the formula to be able to spread */
+export declare function getMissingHeadersForSpreadResult(getters: Getters, position: CellPosition, formula: string): {
+    missingRows: number;
+    missingCols: number;
+} | undefined;

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

@@ -0,0 +1,25 @@
+import { Locale } from "../types/locale";
+/**
+ * This function returns a regexp that is supposed to be as close as possible as the numberRegexp,
+ * but its purpose is to be used by the tokenizer.
+ *
+ * - it tolerates extra characters at the end. This is useful because the tokenizer
+ *   only needs to find the number at the start of a string
+ * - it does not support % symbol, in formulas % is an operator
+ */
+export declare const getFormulaNumberRegex: (decimalSeparator: string) => RegExp;
+/**
+ * Return true if the argument is a "number string".
+ *
+ * Note that "" (empty string) does not count as a number string
+ */
+export declare function isNumber(value: string | undefined, locale: Locale): boolean;
+/**
+ * Convert a string into a number. It assumes that the string actually represents
+ * a number (as determined by the isNumber function)
+ *
+ * Note that it accepts "" (empty string), even though it does not count as a
+ * number from the point of view of the isNumber function.
+ */
+export declare function parseNumber(str: string, locale: Locale): number;
+export declare function percentile(values: number[], percent: number, isInclusive: boolean): number;

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

@@ -0,0 +1,63 @@
+import { CellComposerStore } from "../../components/composer/composer/cell_composer_store";
+import { CompiledFormula } from "../../formulas/compiler";
+import { EnrichedToken } from "../../formulas/composer_tokenizer";
+import { AutoCompleteProposal } from "../../registries/auto_completes";
+import { CoreGetters } from "../../types/core_getters";
+import { Granularity, PivotField, PivotMeasure } from "../../types/pivot";
+/**
+ * Get the first Pivot function description of the given formula.
+ */
+export declare function getFirstPivotFunction(compiledFormula: CompiledFormula, getters: CoreGetters): {
+    functionName: string;
+    args: import("../..").AST[];
+};
+/**
+ * Parse a spreadsheet formula and detect the number of PIVOT functions that are
+ * present in the given formula.
+ */
+export declare function getNumberOfPivotFunctions(compiledFormula: CompiledFormula, getters: CoreGetters): number;
+/**
+ * Create a proposal entry for the composer autocomplete
+ * to insert a field name string in a formula.
+ */
+export declare function makeFieldProposal(field: PivotField, granularity?: Granularity): {
+    text: string;
+    description: string;
+    htmlContent: {
+        value: string;
+        color: "#00a82d";
+    }[];
+    fuzzySearchKey: string;
+};
+export declare function makeMeasureProposal(measure: PivotMeasure): {
+    text: string;
+    description: string;
+    htmlContent: {
+        value: string;
+        color: "#00a82d";
+    }[];
+    fuzzySearchKey: string;
+};
+/**
+ * Perform the autocomplete of the composer by inserting the value
+ * at the cursor position, replacing the current token if necessary.
+ * Must be bound to the autocomplete provider.
+ */
+export declare function insertTokenAfterArgSeparator(this: {
+    composer: CellComposerStore;
+}, tokenAtCursor: EnrichedToken, proposal: AutoCompleteProposal): void;
+/**
+ * Perform the autocomplete of the composer by inserting the value
+ * at the cursor position, replacing the current token if necessary.
+ * Must be bound to the autocomplete provider.
+ * @param {EnrichedToken} tokenAtCursor
+ * @param {AutoCompleteProposal} proposal
+ */
+export declare function insertTokenAfterLeftParenthesis(this: {
+    composer: CellComposerStore;
+}, tokenAtCursor: EnrichedToken, proposal: AutoCompleteProposal): void;
+/**
+ * Extract the pivot id (always the first argument) from the function
+ * context of the given token.
+ */
+export declare function extractFormulaIdFromToken(tokenAtCursor: EnrichedToken): any;

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

@@ -0,0 +1,70 @@
+import { CellValue } from "../../types/cells";
+import { DimensionTree, NEXT_VALUE, PivotColRowDomain, PivotDomain, PivotNode, PREVIOUS_VALUE } from "../../types/pivot";
+import { Pivot } from "../../types/pivot_runtime";
+export declare function getDomainOfParentRow(pivot: Pivot, domain: PivotDomain): PivotDomain;
+export declare function getDomainOfParentCol(pivot: Pivot, domain: PivotDomain): PivotDomain;
+/**
+ * Split a pivot domain into the part related to the rows of the pivot, and the part related to the columns.
+ */
+export declare function domainToColRowDomain(pivot: Pivot, domain: PivotDomain): PivotColRowDomain;
+export declare function getDimensionDomain(pivot: Pivot, dimension: "column" | "row", domain: PivotDomain): PivotDomain;
+export declare function isDomainIsInPivot(pivot: Pivot, domain: PivotDomain): boolean;
+/**
+ * Get the domain parent of the given domain with the field `parentFieldName` as leaf of the domain.
+ *
+ * In practice, if the `parentFieldName` is a row in the pivot, the helper will return a domain with the same column
+ * domain, and with a row domain all groupBys children to `parentFieldName` removed.
+ */
+export declare function getFieldParentDomain(pivot: Pivot, parentFieldName: string, domain: PivotDomain): PivotDomain;
+/**
+ * Replace in the domain the value of the field `fieldNameWithGranularity` with the given `value`
+ */
+export declare function replaceFieldValueInDomain(domain: PivotDomain, fieldNameWithGranularity: string, value: CellValue): PivotDomain;
+export declare function isFieldInDomain(nameWithGranularity: string, domain: PivotDomain): boolean;
+/**
+ * Check if the field is in the rows or columns of the pivot
+ */
+export declare function getFieldDimensionType(pivot: Pivot, nameWithGranularity: string): "row" | "column";
+/**
+ * Replace in the given domain the value of the field `fieldNameWithGranularity` with the previous or next value.
+ */
+export declare function getPreviousOrNextValueDomain(pivot: Pivot, domain: PivotDomain, fieldNameWithGranularity: string, direction: typeof PREVIOUS_VALUE | typeof NEXT_VALUE): PivotDomain | undefined;
+export declare function domainToString(domain: PivotDomain | undefined): string;
+export declare function domainNodeToString(domainNode: PivotNode | undefined): string;
+/**
+ *
+ * For the ranking, the pivot cell values of a column (or row) at the same depth are grouped together before being sorted
+ * and ranked.
+ *
+ * The grouping of a pivot cell is done with both the value of the domain nodes that are parent of the field
+ * `fieldNameWithGranularity` and the value of the last node of the domain of the pivot cell, if it's not the field
+ * `fieldNameWithGranularity`.
+ *
+ * For example, let's take a pivot grouped by (Date:year, Stage, User, Product), where we want to rank by "Stage" field.
+ * The domain nodes parents of the "Stage" are [Date:year]. The pivot cell with domain:
+ * - [Date:year=2021] is not ranked because it does not contain the "Stage" field
+ * - [Date:year=2021, Stage=Lead] is grouped with the cells [Date:year=2021, Stage=*, User=None, Product=None],
+ *      and then ranked within the group
+ * - [Date:year=2021, Stage=Lead, User=Bob] is grouped with the cells [Date:year=2021, Stage=*, User=Bob, Product=None],
+ *      and then ranked within the group
+ * - [Date:year=2021, Stage=Lead, User=Bob, Product=Table] is grouped with the cells [Date:year=2021, Stage=*, User=*, Product=Table],
+ *      and then ranked within the group
+ *
+ * If we rank the pivot on "User" instead, the parent domain becomes [Date:year, Sage] .The cell with domain:
+ * - [Date:year=2021] is not ranked because it does not contain the "Stage" field
+ * - [Date:year=2021, Stage=Lead] is not ranked because it does not contain the "User" field
+ * - [Date:year=2021, Stage=Lead, User=Bob] is grouped with the cells [Date:year=2021, Stage=Lead, User=Bob, Product=None],
+ *      and then ranked within the group
+ * - [Date:year=2021, Stage=Lead, User=Bob, Product=Table] is grouped with the cells with [Date:year=2021, Stage=Lead, User=*, Product=Table],
+ *     and then ranked within the group
+ *
+ */
+export declare function getRankingDomainKey(domain: PivotDomain, fieldNameWithGranularity: string): string;
+/**
+ * The running total domain is the domain without the field `fieldNameWithGranularity`, ie. we do the running total of
+ * all the pivot cells of the column that have any value for the field `fieldNameWithGranularity` and the same value for
+ * the other fields.
+ */
+export declare function getRunningTotalDomainKey(domain: PivotDomain, fieldNameWithGranularity: string): string;
+export declare function sortPivotTree(tree: DimensionTree, baseDomain: PivotDomain, sortFn: (a: PivotDomain, b: PivotDomain) => number): import("../..").DimensionTreeNode[];
+export declare function isParentDomain(domain: PivotDomain, parentDomain: PivotDomain): boolean;

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

@@ -0,0 +1,83 @@
+import { Registry } from "../../registries/registry";
+import { CellValue } from "../../types/cells";
+import { Locale } from "../../types/locale";
+import { CellPosition, FunctionResultObject, Matrix, Maybe } from "../../types/misc";
+import { Granularity, PivotCoreDefinition, PivotCoreDimension, PivotCoreMeasure, PivotCustomGroupedField, PivotDimension, PivotDomain, PivotField, PivotFields, PivotSortedColumn, PivotStyle, PivotTableCell } from "../../types/pivot";
+import { Pivot } from "../../types/pivot_runtime";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { PivotRuntimeDefinition } from "./pivot_runtime_definition";
+export declare const DEFAULT_PIVOT_STYLE: Required<PivotStyle>;
+export declare const AGGREGATORS: {};
+type AggregatorFN = (args: Matrix<FunctionResultObject>, locale?: Locale) => FunctionResultObject;
+export declare const AGGREGATORS_FN: Record<string, AggregatorFN | undefined>;
+/**
+ * Given an object of form {"1": {...}, "2": {...}, ...} get the maximum ID used
+ * in this object
+ * If the object has no keys, return 0
+ *
+ */
+export declare function getMaxObjectId(o: object): number;
+export declare const ALL_PERIODS: {
+    year: string;
+    quarter: string;
+    month: string;
+    week: string;
+    day: string;
+    quarter_number: string;
+    month_number: string;
+    iso_week_number: string;
+    day_of_month: string;
+    day_of_week: string;
+    hour_number: string;
+    minute_number: string;
+    second_number: string;
+};
+/**
+ * Parse a dimension string into a pivot dimension definition.
+ * e.g "create_date:month" => { name: "create_date", granularity: "month" }
+ */
+export declare function parseDimension(dimension: string): PivotCoreDimension;
+export declare function isDateOrDatetimeField(field: PivotField): boolean;
+export declare function generatePivotArgs(formulaId: string, domain: PivotDomain, measure?: string): string[];
+/**
+ * Check if the fields in the domain part of
+ * a pivot function are valid according to the pivot definition.
+ * e.g. =PIVOT.VALUE(1,"revenue","country_id",...,"create_date:month",...,"source_id",...)
+ */
+export declare function areDomainArgsFieldsValid(dimensions: string[], definition: PivotRuntimeDefinition): boolean;
+export declare function createPivotFormula(formulaId: string, cell: PivotTableCell): string;
+/**
+ * Parses the value defining a pivot group in a PIVOT formula
+ * e.g. given the following formula PIVOT.VALUE("1", "stage_id", "42", "status", "won"),
+ * the two group values are "42" and "won".
+ */
+export declare function toNormalizedPivotValue(dimension: Pick<PivotDimension, "type" | "displayName" | "granularity">, groupValue: Maybe<CellValue | FunctionResultObject>): CellValue;
+export declare function toFunctionPivotValue(value: CellValue, dimension: Pick<PivotDimension, "type" | "granularity">): string;
+export declare const pivotNormalizationValueRegistry: Registry<(value: string, granularity?: Granularity | string) => CellValue>;
+export declare const pivotToFunctionValueRegistry: Registry<(value: CellValue, granularity?: string) => string>;
+export declare function getFieldDisplayName(field: PivotDimension): string;
+export declare function addAlignFormatToPivotHeader(domain: PivotDomain, functionResult: FunctionResultObject): FunctionResultObject;
+export declare function isSortedColumnValid(sortedColumn: PivotSortedColumn, pivot: Pivot): boolean;
+export declare function getUniquePivotGroupName(baseName: string, field: PivotCustomGroupedField): string;
+export declare function getUniquePivotFieldName(baseName: string, fields: PivotFields): string;
+export declare function createCustomFields(definition: PivotCoreDefinition, fields: PivotFields): PivotFields;
+export declare function removePivotGroupsContainingValues(valuesToRemove: CellValue[], customField: PivotCustomGroupedField): void;
+/**
+ * Adds a new dimension to the pivot definition before a specified base dimension.
+ * If the new dimension already exists, it does nothing.
+ */
+export declare function addDimensionToPivotDefinition(definition: PivotCoreDefinition, baseDimension: string, newDimension: string): PivotCoreDefinition;
+export declare function getCustomFieldWithParentField(definition: PivotCoreDefinition, parentField: PivotField, fields: PivotFields): PivotCustomGroupedField;
+export declare function togglePivotCollapse(position: CellPosition, env: SpreadsheetChildEnv): void;
+export declare function getPivotStyleFromFnArgs(definition: PivotCoreDefinition, rowCountArg: Maybe<FunctionResultObject | CellValue>, includeTotalArg: Maybe<FunctionResultObject | CellValue>, includeColumnHeadersArg: Maybe<FunctionResultObject | CellValue>, columnCountArg: Maybe<FunctionResultObject | CellValue>, includeMeasuresRowArg: Maybe<FunctionResultObject | CellValue>, locale: Locale): Required<PivotStyle>;
+/**
+ * Collapse a hierarchical display name by keeping only the first and last parts.
+ * Example: "Sales > Europe > France" → "Sales > … > France"
+ */
+export declare function collapseHierarchicalDisplayName(displayName: string, splitter?: string): string;
+/**
+ * Change the pivot measures when a measure changes. This helper will replace the old measure by the new one in the
+ * measure list, and adapt the formulas of the related calculated that were using the old measure.
+ */
+export declare function changeCalculatedMeasuresOnMeasureChange(oldMeasure: PivotCoreMeasure, newMeasure: PivotCoreMeasure, measures: PivotCoreMeasure[]): PivotCoreMeasure[];
+export {};

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

@@ -0,0 +1,2 @@
+import { Getters, Highlight, UID } from "../../types";
+export declare function getPivotHighlights(getters: Getters, pivotId: UID): Highlight[];

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

@@ -0,0 +1,16 @@
+import { CellPosition, Getters, SortDirection } from "../..";
+import { ActionSpec } from "../../actions/action";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export declare const pivotProperties: ActionSpec;
+export declare const pivotSortingAsc: ActionSpec;
+export declare const pivotSortingDesc: ActionSpec;
+export declare const noPivotSorting: ActionSpec;
+export declare const FIX_FORMULAS: ActionSpec;
+export declare const groupPivotHeaders: ActionSpec;
+export declare const groupRemainingPivotHeadersAction: ActionSpec;
+export declare const ungroupPivotHeadersAction: ActionSpec;
+export declare const toggleCollapsePivotGroupAction: ActionSpec;
+export declare const collapseAllPivotGroupAction: ActionSpec;
+export declare const expandAllPivotGroupAction: ActionSpec;
+export declare function canSortPivot(getters: Getters, position: CellPosition): boolean;
+export declare function sortPivot(env: SpreadsheetChildEnv, position: CellPosition, order: SortDirection | "none"): void;

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

@@ -0,0 +1,7 @@
+import { Registry } from "../../registries/registry";
+/**
+ * Registry to enable or disable the support of positional arguments
+ * (with a leading #) in pivot functions
+ * e.g. =PIVOT.VALUE(1,"probability","#stage",1)
+ */
+export declare const supportedPivotPositionalFormulaRegistry: Registry<boolean>;

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

@@ -0,0 +1,9 @@
+import { PivotDomain } from "../../types/pivot";
+export declare class PivotPresenceTracker {
+    private trackedValues;
+    private domainToArray;
+    isValuePresent(measure: string, domain: PivotDomain): boolean;
+    isHeaderPresent(domain: PivotDomain): boolean;
+    trackValue(measure: string, domain: PivotDomain): void;
+    trackHeader(domain: PivotDomain): void;
+}

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

@@ -0,0 +1,98 @@
+import { PivotParams, PivotUIConstructor } from "./pivot_registry";
+import { CellValue } from "../../types/cells";
+import { Getters } from "../../types/getters";
+import { FunctionResultObject, SortDirection, UID } from "../../types/misc";
+import { ModelConfig } from "../../types/model";
+import { DimensionTree, NEXT_VALUE, PivotDimension, PivotDomain, PivotMeasure, PivotMeasureDisplay, PivotValueCell, PREVIOUS_VALUE } from "../../types/pivot";
+import { SpreadsheetPivotTable } from "./table_spreadsheet_pivot";
+type CacheForMeasureAndField<T> = {
+    [measureId: string]: {
+        [field: string]: T;
+    };
+};
+type DomainGroups<T> = {
+    [colDomain: string]: {
+        [rowDomain: string]: T;
+    };
+};
+/**
+ * Dynamically creates a presentation layer wrapper around a given pivot class.
+ *
+ * It allows to implement additional behaviors and features that can be applied
+ * to all pivots, regardless of the specific pivot implementation.
+ * Examples of such features include calculated measures or "Show value as" options.
+ */
+export default function (PivotClass: PivotUIConstructor): {
+    new (pivotId: any, custom: ModelConfig["custom"], params: PivotParams): {
+        getters: Getters;
+        pivotId: UID;
+        cache: Record<string, FunctionResultObject>;
+        rankAsc: CacheForMeasureAndField<DomainGroups<number> | undefined>;
+        rankDesc: CacheForMeasureAndField<DomainGroups<number> | undefined>;
+        runningTotal: CacheForMeasureAndField<DomainGroups<number | undefined> | undefined>;
+        runningTotalInPercent: CacheForMeasureAndField<DomainGroups<number | undefined> | undefined>;
+        markAsDirtyForEvaluation(): void;
+        getPivotCellValueAndFormat(measureName: string, domain: PivotDomain): FunctionResultObject;
+        _getPivotCellValueAndFormat(measureName: string, domain: PivotDomain): FunctionResultObject;
+        computeMeasure(measure: PivotMeasure, domain: PivotDomain): FunctionResultObject;
+        getValuesToAggregate(measure: PivotMeasure, domain: PivotDomain): FunctionResultObject[];
+        getSubTreeMatchingDomain(tree: DimensionTree, domain: PivotDomain, domainLevel?: number): DimensionTree;
+        treeToLeafDomains(tree: DimensionTree, parentDomain?: PivotDomain): PivotDomain[];
+        getMeasureDisplayValue(measureId: string, domain: PivotDomain): FunctionResultObject;
+        asPercentOfGrandTotal(rawValue: FunctionResultObject, measure: PivotMeasure): FunctionResultObject;
+        asPercentOfRowTotal(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain): FunctionResultObject;
+        asPercentOfColumnTotal(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain): FunctionResultObject;
+        asPercentOfParentRowTotal(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain): FunctionResultObject;
+        asPercentOfParentColumnTotal(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain): FunctionResultObject;
+        asPercentOfParentTotal(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain, display: PivotMeasureDisplay): FunctionResultObject;
+        asIndex(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain): FunctionResultObject;
+        asRunningTotal(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain, display: PivotMeasureDisplay, mode: "running_total" | "%_running_total"): FunctionResultObject;
+        asPercentOf(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain, display: PivotMeasureDisplay): FunctionResultObject;
+        asDifferenceFrom(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain, display: PivotMeasureDisplay): FunctionResultObject;
+        asDifferenceFromInPercent(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain, display: PivotMeasureDisplay): FunctionResultObject;
+        asRank(rawValue: FunctionResultObject, measure: PivotMeasure, domain: PivotDomain, display: PivotMeasureDisplay, order: SortDirection): FunctionResultObject;
+        computeRank(measure: PivotMeasure, fieldNameWithGranularity: string, order: SortDirection): DomainGroups<number>;
+        computeRunningTotal(measure: PivotMeasure, fieldNameWithGranularity: string, mode: "running_total" | "%_running_total"): DomainGroups<number | undefined>;
+        getPreviousRunningTotalValue(fieldNameWithGranularity: string, domain: PivotDomain, runningTotals: DomainGroups<number | undefined>): number | undefined;
+        compareRunningTotalValues(a: CellValue, b: CellValue, dimension: PivotDimension): number;
+        getRunningTotalComparableValue(value: CellValue, dimension: PivotDimension): number;
+        getGrandTotal(measureId: string): number;
+        getRowTotal(measureId: string, domain: PivotDomain): number;
+        getColumnTotal(measureId: string, domain: PivotDomain): number;
+        isFieldInPivot(nameWithGranularity: string): boolean;
+        /**
+         * With the given measure, fetch the value of the cell in the pivot that has the given domain with
+         * the value of the field `fieldNameWithGranularity` replaced by `valueToCompare`.
+         *
+         * @param valueToCompare either a value to replace the field value with, or "(previous)" or "(next)"
+         * @returns the value of the cell in the pivot with the new domain, or "sameValue" if the domain is the same
+         */
+        getComparisonValue(measure: PivotMeasure, domain: PivotDomain, fieldNameWithGranularity: string, valueToCompare: CellValue | typeof PREVIOUS_VALUE | typeof NEXT_VALUE): number | "sameValue" | undefined;
+        getPivotValueCells(measureId: string): PivotValueCell[][];
+        measureValueToNumber(result: FunctionResultObject): number;
+        strictMeasureValueToNumber(result: FunctionResultObject): number | undefined;
+        getCollapsedTableStructure(): SpreadsheetPivotTable;
+        getExpandedTableStructure(): SpreadsheetPivotTable;
+        sortTableStructure(table: SpreadsheetPivotTable): void;
+        type: import("../..").PivotCoreDefinition["type"];
+        definition: import("./pivot_runtime_definition").PivotRuntimeDefinition;
+        init(params?: import("../..").InitPivotParams): void;
+        isValid(): boolean;
+        onDefinitionChange(nextDefinition: import("../..").PivotCoreDefinition): void;
+        getFields(): import("../..").PivotFields;
+        getPivotHeaderValueAndFormat(domain: PivotDomain): FunctionResultObject;
+        getPivotMeasureValue(measure: string, domain: PivotDomain): FunctionResultObject;
+        getMeasure: (id: string) => PivotMeasure;
+        parseArgsToPivotDomain(args: import("../..").Maybe<FunctionResultObject>[]): PivotDomain;
+        areDomainArgsFieldsValid(args: import("../..").Maybe<FunctionResultObject>[]): boolean;
+        assertIsValid({ throwOnError }: {
+            throwOnError: boolean;
+        }): FunctionResultObject | undefined;
+        getPossibleFieldValues(dimension: PivotDimension): {
+            value: string | boolean | number;
+            label: string;
+        }[];
+        needsReevaluation: boolean;
+    };
+};
+export {};

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

@@ -0,0 +1,32 @@
+import { Registry } from "../../registry";
+import { CoreGetters } from "../../types/core_getters";
+import { Getters } from "../../types/getters";
+import { ApplyRangeChange, UID } from "../../types/misc";
+import { ModelConfig } from "../../types/model";
+import { PivotCoreDefinition, PivotField, PivotFields } from "../../types/pivot";
+import { Pivot } from "../../types/pivot_runtime";
+import { PivotRuntimeDefinition } from "./pivot_runtime_definition";
+export interface PivotParams {
+    definition: PivotCoreDefinition;
+    getters: Getters;
+}
+export interface PivotCoreParams {
+    definition: PivotCoreDefinition;
+    getters: CoreGetters;
+}
+export type PivotUIConstructor = new (custom: ModelConfig["custom"], params: PivotParams) => Pivot;
+type PivotDefinitionConstructor = new (definition: PivotCoreDefinition, fields: PivotFields, getters: Getters) => PivotRuntimeDefinition;
+export interface PivotRegistryItem {
+    ui: PivotUIConstructor;
+    definition: PivotDefinitionConstructor;
+    dateGranularities: string[];
+    datetimeGranularities: string[];
+    isMeasureCandidate: (field: PivotField) => boolean;
+    isGroupable: (field: PivotField) => boolean;
+    canHaveCustomGroup: (field: PivotField) => boolean;
+    isPivotUnused: (getters: Getters, pivotId: UID) => boolean;
+    adaptRanges?: (getters: CoreGetters, definition: PivotCoreDefinition, applyChange: ApplyRangeChange) => PivotCoreDefinition;
+}
+export declare const pivotRegistry: Registry<PivotRegistryItem>;
+export declare const datetimeGranularities: string[];
+export {};