@odoo/o-spreadsheet 17.0.85 → 17.0.96

package/dist/types/helpers/figures/charts/scorecard_chart_config_builder.d.ts

@@ -0,0 +1,35 @@
+import { Color } from "chart.js";
+import { DOMDimension, Pixel, PixelPosition } from "../../../types";
+import { BaselineArrowDirection, ScorecardChartRuntime } from "../../../types/chart";
+type ScorecardChartElement = {
+    text: string;
+    style: {
+        font: string;
+        color: Color;
+        strikethrough?: boolean;
+        underline?: boolean;
+    };
+    position: PixelPosition;
+};
+export type ScorecardChartConfig = {
+    canvas: {
+        width: number;
+        height: number;
+        backgroundColor: Color;
+    };
+    title?: ScorecardChartElement;
+    baselineArrow?: {
+        direction: BaselineArrowDirection;
+        style: {
+            size: Pixel;
+            color: Color;
+        };
+        position: PixelPosition;
+    };
+    baseline?: ScorecardChartElement;
+    baselineDescr?: ScorecardChartElement;
+    key?: ScorecardChartElement;
+};
+export declare function formatBaselineDescr(baselineDescr: string | undefined, baseline: string | undefined): string;
+export declare function getScorecardConfiguration({ width, height }: DOMDimension, runtime: ScorecardChartRuntime): ScorecardChartConfig;
+export {};

package/dist/types/helpers/figures/figure/figure.d.ts

@@ -0,0 +1,6 @@
+import { FigureSize, Getters } from "../../../types";
+export declare function centerFigurePosition(getters: Getters, size: FigureSize): {
+    x: number;
+    y: number;
+};
+export declare function getMaxFigureSize(getters: Getters, figureSize: FigureSize): FigureSize;

package/dist/types/helpers/figures/images/image_provider.d.ts

@@ -0,0 +1,10 @@
+import { FigureSize } from "../../../types";
+import { FileStore, ImageProviderInterface } from "../../../types/files";
+import { type Image } from "../../../types/image";
+export declare class ImageProvider implements ImageProviderInterface {
+    private fileStore;
+    constructor(fileStore: FileStore);
+    requestImage(): Promise<Image>;
+    private getImageFromUser;
+    getImageOriginalSize(path: string): Promise<FigureSize>;
+}

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

@@ -0,0 +1,19 @@
+import { Cloneable, FilterTableId, UID, Zone } from "../types/misc";
+export declare class FilterTable implements Cloneable<FilterTable> {
+    readonly id: FilterTableId;
+    readonly zone: Zone;
+    readonly filters: Filter[];
+    constructor(zone: Zone);
+    /** Get zone of the table without the headers */
+    get contentZone(): Zone | undefined;
+    getFilterId(col: number): string | undefined;
+    clone(): FilterTable;
+}
+export declare class Filter {
+    readonly id: UID;
+    readonly zoneWithHeaders: Zone;
+    constructor(id: UID, zone: Zone);
+    get col(): import("../types").HeaderIndex;
+    /** Filtered zone, ie. zone of the filter without the header */
+    get filteredZone(): Zone | undefined;
+}

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

@@ -0,0 +1,5 @@
+export declare class FocusableElement {
+    private focusableElement;
+    setFocusableElement(element: HTMLElement): void;
+    focus(): void;
+}

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

@@ -0,0 +1,32 @@
+import { CellValue, Currency, Format, FormattedValue, Locale, LocaleFormat } from "../types";
+/**
+ * Formats a cell value with its format.
+ */
+export declare function formatValue(value: CellValue, { format, locale }: LocaleFormat): FormattedValue;
+/** Convert a number into a string, without scientific notation */
+export declare function numberToString(number: number, decimalSeparator: string): string;
+/**
+ * Check if the given format is a time, date or date time format.
+ */
+export declare function isDateTimeFormat(format: Format): boolean;
+export declare function applyDateTimeFormat(value: number, format: Format): FormattedValue;
+/**
+ * Get a regex matching decimal number based on the locale's thousand separator
+ *
+ * eg. if the locale's thousand separator is a comma, this will return a regex /[0-9]+,[0-9]/
+ */
+export declare const getDecimalNumberRegex: (locale: Locale) => RegExp;
+/**
+ * Create a default format for a number.
+ *
+ * If possible this will try round the number to have less than DEFAULT_FORMAT_NUMBER_OF_DIGITS characters
+ * in the number. This is obviously only possible for number with a big decimal part. For number with a lot
+ * of digits in the integer part, keep the number as it is.
+ */
+export declare function createDefaultFormat(value: number): Format;
+export declare function detectDateFormat(content: string, locale: Locale): Format | undefined;
+export declare function detectNumberFormat(content: string): Format | undefined;
+export declare function createCurrencyFormat(currency: Partial<Currency>): Format;
+export declare function roundFormat(format: Format): Format;
+export declare function createLargeNumberFormat(format: Format | undefined, magnitude: number, postFix: string, locale: Locale): Format;
+export declare function changeDecimalPlaces(format: Format, step: number, locale: Locale): Format;

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

@@ -0,0 +1,15 @@
+export * from "./color";
+export * from "./coordinates";
+export * from "./data_validation_helpers";
+export * from "./dates";
+export * from "./edge_scrolling";
+export * from "./format";
+export * from "./misc";
+export * from "./numbers";
+export * from "./range";
+export * from "./references";
+export * from "./search";
+export * from "./sheet";
+export * from "./text_helper";
+export * from "./uuid";
+export * from "./zones";

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

@@ -0,0 +1,83 @@
+import { DOMDimension, Getters, HeaderIndex, Pixel, Position, Rect, UID, Zone } from "../types";
+export declare class InternalViewport {
+    private getters;
+    private sheetId;
+    private boundaries;
+    top: HeaderIndex;
+    bottom: HeaderIndex;
+    left: HeaderIndex;
+    right: HeaderIndex;
+    offsetX: Pixel;
+    offsetY: Pixel;
+    offsetScrollbarX: Pixel;
+    offsetScrollbarY: Pixel;
+    canScrollVertically: boolean;
+    canScrollHorizontally: boolean;
+    viewportWidth: Pixel;
+    viewportHeight: Pixel;
+    offsetCorrectionX: Pixel;
+    offsetCorrectionY: Pixel;
+    constructor(getters: Getters, sheetId: UID, boundaries: Zone, sizeInGrid: {
+        width: Pixel;
+        height: Pixel;
+    }, options: {
+        canScrollVertically: boolean;
+        canScrollHorizontally: boolean;
+    }, offsets: {
+        x: Pixel;
+        y: Pixel;
+    });
+    /** Returns the maximum size (in Pixels) of the viewport relative to its allocated client size
+     * When the viewport grid size is smaller than its client width (resp. height), it will return
+     * the client width (resp. height).
+     */
+    getMaxSize(): DOMDimension;
+    /**
+     * Return the index of a column given an offset x, based on the pane left
+     * visible cell.
+     * It returns -1 if no column is found.
+     */
+    getColIndex(x: Pixel): HeaderIndex;
+    /**
+     * Return the index of a row given an offset y, based on the pane top
+     * visible cell.
+     * It returns -1 if no row is found.
+     */
+    getRowIndex(y: Pixel): HeaderIndex;
+    /**
+     * This function will make sure that the provided cell position (or current selected position) is part of
+     * the pane that is actually displayed on the client. We therefore adjust the offset of the pane
+     * until it contains the cell completely.
+     */
+    adjustPosition(position?: Position): void;
+    adjustPositionX(targetCol: HeaderIndex): void;
+    adjustPositionY(targetRow: HeaderIndex): void;
+    setViewportOffset(offsetX: Pixel, offsetY: Pixel): void;
+    adjustViewportZone(): void;
+    /**
+     *
+     * @param zone
+     * @returns Computes the absolute coordinate of a given zone inside the viewport
+     */
+    getVisibleRect(zone: Zone): Rect | undefined;
+    getFullRect(zone: Zone): Rect | undefined;
+    isVisible(col: HeaderIndex, row: HeaderIndex): boolean;
+    private searchHeaderIndex;
+    private get zone();
+    private setViewportOffsetX;
+    private setViewportOffsetY;
+    /** Corrects the viewport's horizontal offset based on the current structure
+     *  To make sure that at least one column is visible inside the viewport.
+     */
+    private adjustViewportOffsetX;
+    /** Corrects the viewport's vertical offset based on the current structure
+     *  To make sure that at least one row is visible inside the viewport.
+     */
+    private adjustViewportOffsetY;
+    /** Updates the pane zone and snapped offset based on its horizontal
+     * offset (will find Left) and its width (will find Right) */
+    private adjustViewportZoneX;
+    /** Updates the pane zone and snapped offset based on its vertical
+     * offset (will find Top) and its width (will find Bottom) */
+    private adjustViewportZoneY;
+}

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

@@ -0,0 +1,2 @@
+import { CoreCommand } from "../types";
+export declare function inverseCommand(cmd: CoreCommand): CoreCommand[];

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

@@ -0,0 +1,23 @@
+import { Registry } from "../registries/registry";
+import { CellValue, Getters, Link, SpreadsheetChildEnv } from "../types";
+/**
+ * Add the `https` prefix to the url if it's missing
+ */
+export declare function withHttps(url: string): string;
+export interface LinkSpec {
+    readonly match: (url: string) => boolean;
+    readonly createLink: (url: string, label: string) => Link;
+    /**
+     * String used to display the URL in components.
+     * Particularly useful for special links (sheet, etc.)
+     * - a simple web link displays the raw url
+     * - a link to a sheet displays the sheet name
+     */
+    readonly urlRepresentation: (url: string, getters: Getters) => string;
+    readonly open: (url: string, env: SpreadsheetChildEnv) => void;
+    readonly sequence: number;
+}
+export declare const urlRegistry: Registry<LinkSpec>;
+export declare function urlRepresentation(link: Link, getters: Getters): string;
+export declare function openLink(link: Link, env: SpreadsheetChildEnv): void;
+export declare function detectLink(value: CellValue | null): Link | undefined;

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

@@ -0,0 +1,58 @@
+import { ConditionalFormatRule, DataValidationRule, Locale } from "../types";
+export declare function isValidLocale(locale: any): locale is Locale;
+/**
+ * Change a content string from the given locale to its canonical form (en_US locale). Don't convert date string.
+ *
+ * @example
+ * canonicalizeNumberContent("=SUM(1,5; 02/12/2012)", FR_LOCALE) // "=SUM(1.5, 02/12/2012)"
+ * canonicalizeNumberContent("125,9", FR_LOCALE) // "125.9"
+ * canonicalizeNumberContent("02/12/2012", FR_LOCALE) // "02/12/2012"
+ */
+export declare function canonicalizeNumberContent(content: string, locale: Locale): string;
+/**
+ * Change a content string from the given locale to its canonical form (en_US locale). Also convert date string.
+ * This is destructive and won't preserve the original format.
+ *
+ * @example
+ * canonicalizeContent("=SUM(1,5; 5)", FR_LOCALE) // "=SUM(1.5, 5)"
+ * canonicalizeContent("125,9", FR_LOCALE) // "125.9"
+ * canonicalizeContent("02/12/2012", FR_LOCALE) // "12/02/2012"
+ * canonicalizeContent("02-12-2012", FR_LOCALE) // "12/02/2012"
+ */
+export declare function canonicalizeContent(content: string, locale: Locale): string;
+/**
+ * Change a content string from its canonical form (en_US locale) to the given locale. Don't convert date string.
+ * This is destructive and won't preserve the original format.
+ *
+ * @example
+ * localizeNumberContent("=SUM(1.5, 5)", FR_LOCALE) // "=SUM(1,5; 5)"
+ * localizeNumberContent("125.9", FR_LOCALE) // "125,9"
+ * localizeNumberContent("02/12/2012", FR_LOCALE) // "12/02/2012"
+ * localizeNumberContent("02-12-2012", FR_LOCALE) // "12/02/2012"
+ */
+export declare function localizeNumberContent(content: string, locale: Locale): string;
+/**
+ * Change a content string from its canonical form (en_US locale) to the given locale. Also convert date string.
+ *
+ * @example
+ * localizeContent("=SUM(1.5, 5)", FR_LOCALE) // "=SUM(1,5; 5)"
+ * localizeContent("125.9", FR_LOCALE) // "125,9"
+ * localizeContent("12/02/2012", FR_LOCALE) // "02/12/2012"
+ */
+export declare function localizeContent(content: string, locale: Locale): string;
+/** Change a number string to its canonical form (en_US locale) */
+export declare function canonicalizeNumberValue(content: string, locale: Locale): string;
+/** Change a formula from the canonical form to the given locale */
+export declare function localizeFormula(formula: string, locale: Locale): string;
+/**
+ * Change a literal string from the given locale to its canonical form (en_US locale). Don't convert date string.
+ *
+ * @example
+ * canonicalizeNumberLiteral("125,9", FR_LOCALE) // "125.9"
+ * canonicalizeNumberLiteral("02/12/2012", FR_LOCALE) // "02/12/2012"
+ */
+export declare function canonicalizeNumberLiteral(content: string, locale: Locale): string;
+export declare function canonicalizeCFRule(cf: ConditionalFormatRule, locale: Locale): ConditionalFormatRule;
+export declare function localizeCFRule(cf: ConditionalFormatRule, locale: Locale): ConditionalFormatRule;
+export declare function localizeDataValidationRule(rule: DataValidationRule, locale: Locale): DataValidationRule;
+export declare function getDateTimeFormat(locale: Locale): string;

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

@@ -0,0 +1,178 @@
+import { ConsecutiveIndexes, Lazy, UID } from "../types";
+/**
+ * Remove quotes from a quoted string
+ * ```js
+ * removeStringQuotes('"Hello"')
+ * > 'Hello'
+ * ```
+ */
+export declare function removeStringQuotes(str: string): string;
+/**
+ * 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
+ * @param sheetName name of the sheet, potentially quoted with single quotes
+ */
+export declare function getUnquotedSheetName(sheetName: string): string;
+/**
+ * Add quotes around the sheet name if it contains at least one non alphanumeric character
+ * '\w' captures [0-9][a-z][A-Z] and _.
+ * @param sheetName Name of the sheet
+ */
+export declare function getCanonicalSheetName(sheetName: 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;
+/**
+ * Get the id of the given item (its key in the given dictionnary).
+ * If the given item does not exist in the dictionary, it creates one with a new id.
+ */
+export declare function getItemId<T>(item: T, itemsDic: {
+    [id: number]: T;
+}): number;
+/**
+ * This method comes from owl 1 as it was removed in owl 2
+ *
+ * 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, trigger the function on the
+ * leading edge, instead of the trailing.
+ *
+ * Inspired by https://davidwalsh.name/javascript-debounce-function
+ */
+export declare function debounce(func: Function, wait: number, immediate?: boolean): Function;
+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 two objects.
+ */
+export declare function deepEquals(o1: any, o2: 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(obj: Object): Object;
+export declare const specialWhiteSpaceRegexp: RegExp;
+/**
+ * Replace all different newlines characters by \n
+ */
+export declare function replaceNewLines(text: string | undefined): string;
+/** Move the item at the starting index to the target index in an array */
+export declare function moveItemToIndex<T>(array: T[], startIndex: number, targetIndex: number): T[];
+/**
+ * Determine if the numbers are consecutive.
+ */
+export declare function isConsecutive(iterable: Iterable<number>): boolean;
+export declare class JetSet<T> extends Set<T> {
+    addMany(iterable: Iterable<T>): this;
+    deleteMany(iterable: Iterable<T>): void;
+}
+/**
+ * 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 trimContent(content: string): string;
+export declare function isNumberBetween(value: number, min: number, max: number): boolean;
+/**
+ * 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;

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

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

@@ -0,0 +1,59 @@
+import { CellPosition, CoreGetters, 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, ranges: string[]): string[];
+/**
+ * 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 {};