@odoo/o-spreadsheet 17.0.84 → 17.0.96

package/dist/types/components/translations_terms.d.ts

@@ -0,0 +1,104 @@
+export declare const CfTerms: {
+    Errors: {
+        InvalidRange: string;
+        FirstArgMissing: string;
+        SecondArgMissing: string;
+        MinNaN: string;
+        MidNaN: string;
+        MaxNaN: string;
+        ValueUpperInflectionNaN: string;
+        ValueLowerInflectionNaN: string;
+        MinBiggerThanMax: string;
+        MinBiggerThanMid: string;
+        MidBiggerThanMax: string;
+        LowerBiggerThanUpper: string;
+        MinInvalidFormula: string;
+        MaxInvalidFormula: string;
+        MidInvalidFormula: string;
+        ValueUpperInvalidFormula: string;
+        ValueLowerInvalidFormula: string;
+        EmptyRange: string;
+        Unexpected: string;
+    };
+    ColorScale: string;
+    IconSet: string;
+};
+export declare const CellIsOperators: {
+    IsEmpty: string;
+    IsNotEmpty: string;
+    ContainsText: string;
+    NotContains: string;
+    BeginsWith: string;
+    EndsWith: string;
+    Equal: string;
+    NotEqual: string;
+    GreaterThan: string;
+    GreaterThanOrEqual: string;
+    LessThan: string;
+    LessThanOrEqual: string;
+    Between: string;
+    NotBetween: string;
+};
+export declare const ChartTerms: {
+    Series: string;
+    Errors: {
+        Unexpected: string;
+        InvalidDataSet: string;
+        InvalidLabelRange: string;
+        InvalidScorecardKeyValue: string;
+        InvalidScorecardBaseline: string;
+        InvalidGaugeDataRange: string;
+        EmptyGaugeRangeMin: string;
+        GaugeRangeMinNaN: string;
+        EmptyGaugeRangeMax: string;
+        GaugeRangeMaxNaN: string;
+        GaugeRangeMinBiggerThanRangeMax: string;
+        GaugeLowerInflectionPointNaN: string;
+        GaugeUpperInflectionPointNaN: string;
+    };
+};
+export declare const CustomCurrencyTerms: {
+    Custom: string;
+};
+export declare const MergeErrorMessage: string;
+export declare const SplitToColumnsTerms: {
+    Errors: {
+        Unexpected: string;
+        NoSplitSeparatorInSelection: string;
+        MoreThanOneColumnSelected: string;
+        SplitWillOverwriteContent: string;
+    };
+};
+export declare const RemoveDuplicateTerms: {
+    Errors: {
+        Unexpected: string;
+        MoreThanOneRangeSelected: string;
+        EmptyTarget: string;
+        NoColumnsProvided: string;
+        WillRemoveExistingMerge: string;
+    };
+};
+export declare const DVTerms: {
+    DateIs: {
+        today: string;
+        yesterday: string;
+        tomorrow: string;
+        lastWeek: string;
+        lastMonth: string;
+        lastYear: string;
+    };
+    DateIsBefore: {
+        today: string;
+        yesterday: string;
+        tomorrow: string;
+        lastWeek: string;
+        lastMonth: string;
+        lastYear: string;
+    };
+    CriterionError: {
+        notEmptyValue: string;
+        numberValue: string;
+        dateValue: string;
+        validRange: string;
+    };
+};

package/dist/types/components/validation_messages/validation_messages.d.ts

@@ -0,0 +1,11 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../types/index";
+interface Props {
+    messages: string[];
+    msgType: "warning" | "error";
+}
+export declare class ValidationMessages extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    get divClasses(): "o-validation-warning text-warning" | "o-validation-error text-danger";
+}
+export {};

package/dist/types/constants.d.ts

@@ -0,0 +1,137 @@
+import { BorderDescr, Color } from "./types";
+import { CellErrorType } from "./types/errors";
+export declare const CANVAS_SHIFT = 0.5;
+export declare const BACKGROUND_GRAY_COLOR = "#f5f5f5";
+export declare const BACKGROUND_HEADER_COLOR = "#F8F9FA";
+export declare const BACKGROUND_HEADER_SELECTED_COLOR = "#E8EAED";
+export declare const BACKGROUND_HEADER_ACTIVE_COLOR = "#595959";
+export declare const TEXT_HEADER_COLOR = "#666666";
+export declare const FIGURE_BORDER_COLOR = "#c9ccd2";
+export declare const SELECTION_BORDER_COLOR = "#3266ca";
+export declare const HEADER_BORDER_COLOR = "#C0C0C0";
+export declare const CELL_BORDER_COLOR = "#E2E3E3";
+export declare const BACKGROUND_CHART_COLOR = "#FFFFFF";
+export declare const BG_HOVER_COLOR = "#EBEBEB";
+export declare const DISABLED_TEXT_COLOR = "#CACACA";
+export declare const DEFAULT_COLOR_SCALE_MIDPOINT_COLOR = 11982760;
+export declare const LINK_COLOR = "#01666b";
+export declare const FILTERS_COLOR = "#188038";
+export declare const BACKGROUND_HEADER_FILTER_COLOR = "#E6F4EA";
+export declare const BACKGROUND_HEADER_SELECTED_FILTER_COLOR = "#CEEAD6";
+export declare const SEPARATOR_COLOR = "#E0E2E4";
+export declare const ICONS_COLOR = "#4A4F59";
+export declare const HEADER_GROUPING_BACKGROUND_COLOR = "#F5F5F5";
+export declare const HEADER_GROUPING_BORDER_COLOR = "#999";
+export declare const GRID_BORDER_COLOR = "#E2E3E3";
+export declare const FROZEN_PANE_HEADER_BORDER_COLOR = "#BCBCBC";
+export declare const FROZEN_PANE_BORDER_COLOR = "#DADFE8";
+export declare const COMPOSER_ASSISTANT_COLOR = "#9B359B";
+export declare const COLOR_PICKER_DEFAULTS: Color[];
+export declare const MIN_ROW_HEIGHT = 10;
+export declare const MIN_COL_WIDTH = 5;
+export declare const HEADER_HEIGHT = 26;
+export declare const HEADER_WIDTH = 48;
+export declare const TOPBAR_HEIGHT = 63;
+export declare const TOPBAR_TOOLBAR_HEIGHT = 34;
+export declare const BOTTOMBAR_HEIGHT = 36;
+export declare const DEFAULT_CELL_WIDTH = 96;
+export declare const DEFAULT_CELL_HEIGHT = 23;
+export declare const SCROLLBAR_WIDTH = 15;
+export declare const AUTOFILL_EDGE_LENGTH = 8;
+export declare const ICON_EDGE_LENGTH = 18;
+export declare const UNHIDE_ICON_EDGE_LENGTH = 14;
+export declare const MIN_CF_ICON_MARGIN = 4;
+export declare const MIN_CELL_TEXT_MARGIN = 4;
+export declare const CF_ICON_EDGE_LENGTH = 15;
+export declare const PADDING_AUTORESIZE_VERTICAL = 3;
+export declare const PADDING_AUTORESIZE_HORIZONTAL = 4;
+export declare const GROUP_LAYER_WIDTH = 21;
+export declare const GRID_ICON_MARGIN = 2;
+export declare const GRID_ICON_EDGE_LENGTH = 17;
+export declare const FILTER_ICON_MARGIN = 2;
+export declare const FILTER_ICON_EDGE_LENGTH = 17;
+export declare const FOOTER_HEIGHT: number;
+export declare const MENU_WIDTH = 250;
+export declare const MENU_VERTICAL_PADDING = 6;
+export declare const MENU_ITEM_HEIGHT = 26;
+export declare const MENU_ITEM_PADDING_HORIZONTAL = 11;
+export declare const MENU_ITEM_PADDING_VERTICAL = 4;
+export declare const MENU_SEPARATOR_BORDER_WIDTH = 1;
+export declare const MENU_SEPARATOR_PADDING = 5;
+export declare const MENU_SEPARATOR_HEIGHT: number;
+export declare const DEFAULT_STYLE: {
+    align: "left";
+    verticalAlign: "bottom";
+    wrapping: "overflow";
+    bold: false;
+    italic: false;
+    strikethrough: false;
+    underline: false;
+    fontSize: number;
+    fillColor: string;
+    textColor: string;
+};
+export declare const DEFAULT_NUMBER_STYLE: {
+    align: "right";
+    verticalAlign: "bottom";
+    wrapping: "overflow";
+    bold: false;
+    italic: false;
+    strikethrough: false;
+    underline: false;
+    fontSize: number;
+    fillColor: string;
+    textColor: string;
+};
+export declare const DEFAULT_VERTICAL_ALIGN: "bottom";
+export declare const DEFAULT_WRAPPING_MODE: "overflow";
+export declare const DEFAULT_FONT_WEIGHT = "400";
+export declare const DEFAULT_FONT_SIZE: number;
+export declare const HEADER_FONT_SIZE = 11;
+export declare const DEFAULT_FONT = "'Roboto', arial";
+export declare const DEFAULT_BORDER_DESC: BorderDescr;
+export declare const DEFAULT_FILTER_BORDER_DESC: BorderDescr;
+export declare const INCORRECT_RANGE_STRING = CellErrorType.InvalidReference;
+export declare const MAX_HISTORY_STEPS = 99;
+export declare const DEFAULT_REVISION_ID = "START_REVISION";
+export declare const DEFAULT_FIGURE_HEIGHT = 335;
+export declare const DEFAULT_FIGURE_WIDTH = 536;
+export declare const FIGURE_BORDER_WIDTH = 1;
+export declare const ACTIVE_BORDER_WIDTH = 2;
+export declare const MIN_FIG_SIZE = 80;
+export declare const MAX_CHAR_LABEL = 20;
+export declare const FIGURE_ID_SPLITTER = "??";
+export declare const DEFAULT_GAUGE_LOWER_COLOR = "#cc0000";
+export declare const DEFAULT_GAUGE_MIDDLE_COLOR = "#f1c232";
+export declare const DEFAULT_GAUGE_UPPER_COLOR = "#6aa84f";
+export declare const DEFAULT_SCORECARD_BASELINE_MODE = "difference";
+export declare const DEFAULT_SCORECARD_BASELINE_COLOR_UP = "#00A04A";
+export declare const DEFAULT_SCORECARD_BASELINE_COLOR_DOWN = "#DC6965";
+export declare const LINE_FILL_TRANSPARENCY = 0.4;
+export declare const DEBOUNCE_TIME = 200;
+export declare const MESSAGE_VERSION = 1;
+export declare const FORBIDDEN_SHEET_CHARS: readonly ["'", "*", "?", "/", "\\", "[", "]"];
+export declare const FORBIDDEN_IN_EXCEL_REGEX: RegExp;
+export declare const FORMULA_REF_IDENTIFIER = "|";
+export declare const LOADING = "Loading...";
+export declare const DEFAULT_ERROR_MESSAGE: string;
+export declare enum ComponentsImportance {
+    Grid = 0,
+    Highlight = 5,
+    HeaderGroupingButton = 6,
+    Figure = 10,
+    ScrollBar = 15,
+    GridPopover = 19,
+    GridComposer = 20,
+    Dropdown = 21,
+    IconPicker = 25,
+    TopBarComposer = 30,
+    Popover = 35,
+    FigureAnchor = 1000,
+    FigureSnapLine = 1001
+}
+export declare function getDefaultSheetViewSize(): number;
+export declare function setDefaultSheetViewSize(size: number): void;
+export declare const MAXIMAL_FREEZABLE_RATIO = 0.85;
+export declare const NEWLINE = "\n";
+export declare const FONT_SIZES: number[];

package/dist/types/formulas/code_builder.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Block of code that produces a value.
+ */
+export interface FunctionCode {
+    readonly returnExpression: string;
+    /**
+     * Return the same function code but wrapped in a closure.
+     */
+    wrapInClosure(): FunctionCode;
+    /**
+     * Return the same function code but with the return expression assigned to a variable.
+     */
+    assignResultToVariable(): FunctionCode;
+}
+export declare class FunctionCodeBuilder {
+    private scope;
+    private code;
+    constructor(scope?: Scope);
+    append(...lines: (string | FunctionCode)[]): void;
+    return(expression: string): FunctionCode;
+    toString(): string;
+}
+export declare class Scope {
+    private nextId;
+    private declaredVariables;
+    nextVariableName(): string;
+    isAlreadyDeclared(name: string): boolean;
+}

package/dist/types/formulas/compiler.d.ts

@@ -0,0 +1,7 @@
+import { Token } from ".";
+import { CompiledFormula } from "../types";
+export declare const functionCache: {
+    [key: string]: Omit<CompiledFormula, "dependencies" | "tokens">;
+};
+export declare function compile(formula: string): CompiledFormula;
+export declare function compileTokens(tokens: Token[]): CompiledFormula;

package/dist/types/formulas/composer_tokenizer.d.ts

@@ -0,0 +1,31 @@
+import { Locale } from "../types";
+import { Token } from "./index";
+interface FunctionContext {
+    parent: string;
+    argPosition: number;
+}
+/**
+ * Enriched Token is used by the composer to add information on the tokens that
+ * are only needed during the edition of a formula.
+ *
+ * The information added are:
+ * - start, end and length of each token
+ * - range detection (replaces the tokens that composes the range with 1 token)
+ * - parenthesis matching (only for parenthesis tokens)
+ * - parent function (only for tokens surrounded by a function)
+ * - arg position (only for tokens surrounded by a function)
+ */
+export interface EnrichedToken extends Token {
+    start: number;
+    end: number;
+    length: number;
+    parenIndex?: number;
+    functionContext?: FunctionContext;
+}
+/**
+ * Take the result of the tokenizer and transform it to be usable in the composer.
+ *
+ * @param formula
+ */
+export declare function composerTokenize(formula: string, locale: Locale): EnrichedToken[];
+export {};

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

@@ -0,0 +1,2 @@
+import { Token } from "./tokenizer";
+export declare function isExportableToExcel(tokens: Token[]): boolean;

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

@@ -0,0 +1,16 @@
+/**
+ * The formulas module provides all functionality related to manipulating
+ * formulas:
+ *
+ * - tokenization (transforming a string into a list of tokens)
+ * - parsing (same, but into an AST (Abstract Syntax Tree))
+ * - compiler (getting an executable function representing a formula)
+ */
+export { compile } from "./compiler";
+export { composerTokenize } from "./composer_tokenizer";
+export type { EnrichedToken } from "./composer_tokenizer";
+export * from "./helpers";
+export { parse } from "./parser";
+export { rangeTokenize } from "./range_tokenizer";
+export { tokenize } from "./tokenizer";
+export type { Token } from "./tokenizer";

package/dist/types/formulas/parser.d.ts

@@ -0,0 +1,72 @@
+import { Token } from "./tokenizer";
+interface ASTBase {
+    debug?: boolean;
+}
+interface ASTNumber extends ASTBase {
+    type: "NUMBER";
+    value: number;
+}
+interface ASTReference extends ASTBase {
+    type: "REFERENCE";
+    value: string;
+}
+export interface ASTString extends ASTBase {
+    type: "STRING";
+    value: string;
+}
+interface ASTBoolean extends ASTBase {
+    type: "BOOLEAN";
+    value: boolean;
+}
+interface ASTUnaryOperation extends ASTBase {
+    type: "UNARY_OPERATION";
+    value: any;
+    operand: AST;
+    postfix?: boolean;
+}
+interface ASTOperation extends ASTBase {
+    type: "BIN_OPERATION";
+    value: any;
+    left: AST;
+    right: AST;
+}
+export interface ASTFuncall extends ASTBase {
+    type: "FUNCALL";
+    value: string;
+    args: AST[];
+}
+interface ASTEmpty extends ASTBase {
+    type: "EMPTY";
+    value: "";
+}
+export type AST = ASTOperation | ASTUnaryOperation | ASTFuncall | ASTNumber | ASTBoolean | ASTString | ASTReference | ASTEmpty;
+/**
+ * Parse an expression (as a string) into an AST.
+ */
+export declare function parse(str: string): AST;
+export declare function parseTokens(tokens: Token[]): AST;
+/**
+ * Allows to visit all nodes of an AST and apply a mapping function
+ * to nodes of a specific type.
+ * Useful if you want to convert some part of a formula.
+ *
+ * @example
+ * convertAstNodes(ast, "FUNCALL", convertFormulaToExcel)
+ *
+ * function convertFormulaToExcel(ast: ASTFuncall) {
+ *   // ...
+ *   return modifiedAst
+ * }
+ */
+export declare function convertAstNodes<T extends AST["type"]>(ast: AST, type: T, fn: (ast: Extract<AST, {
+    type: T;
+}>) => AST): AST;
+export declare function iterateAstNodes(ast: AST): AST[];
+export declare function mapAst<T extends AST["type"]>(ast: AST, fn: (ast: Extract<AST, {
+    type: T;
+}>) => AST): AST;
+/**
+ * Converts an ast formula to the corresponding string
+ */
+export declare function astToFormula(ast: AST): string;
+export {};

package/dist/types/formulas/range_tokenizer.d.ts

@@ -0,0 +1,8 @@
+import { Token } from "./tokenizer";
+/**
+ * Take the result of the tokenizer and transform it to be usable in the
+ * manipulations of range
+ *
+ * @param formula
+ */
+export declare function rangeTokenize(formula: string, locale?: import("../types").Locale): Token[];

package/dist/types/formulas/tokenizer.d.ts

@@ -0,0 +1,25 @@
+import { Locale } from "../types";
+/**
+ * Tokenizer
+ *
+ * A tokenizer is a piece of code whose job is to transform a string into a list
+ * of "tokens". For example, "(12+" is converted into:
+ *   [{type: "LEFT_PAREN", value: "("},
+ *    {type: "NUMBER", value: "12"},
+ *    {type: "OPERATOR", value: "+"}]
+ *
+ * As the example shows, a tokenizer does not care about the meaning behind those
+ * tokens. It only cares about the structure.
+ *
+ * The tokenizer is usually the first step in a compilation pipeline.  Also, it
+ * is useful for the composer, which needs to be able to work with incomplete
+ * formulas.
+ */
+export declare const POSTFIX_UNARY_OPERATORS: string[];
+type TokenType = "OPERATOR" | "NUMBER" | "STRING" | "SYMBOL" | "SPACE" | "DEBUGGER" | "ARG_SEPARATOR" | "LEFT_PAREN" | "RIGHT_PAREN" | "REFERENCE" | "INVALID_REFERENCE" | "UNKNOWN";
+export interface Token {
+    readonly type: TokenType;
+    readonly value: string;
+}
+export declare function tokenize(str: string, locale?: Locale): Token[];
+export {};

package/dist/types/functions/arguments.d.ts

@@ -0,0 +1,10 @@
+import { AddFunctionDescription, ArgDefinition, FunctionDescription } from "../types";
+export declare function arg(definition: string, description?: string): ArgDefinition;
+/**
+ * This function adds on description more general information derived from the
+ * arguments.
+ *
+ * This information is useful during compilation.
+ */
+export declare function addMetaInfoFromArg(addDescr: AddFunctionDescription): FunctionDescription;
+export declare function validateArguments(args: ArgDefinition[]): void;

package/dist/types/functions/helper_assert.d.ts

@@ -0,0 +1,6 @@
+import { ArgValue, CellValue, Matrix } from "../types";
+export declare function assertSingleColOrRow(errorStr: string, arg: Matrix): void;
+export declare function assertSameDimensions(errorStr: string, ...args: ArgValue[]): void;
+export declare function assertPositive(errorStr: string, arg: number): void;
+export declare function assertSquareMatrix(errorStr: string, arg: Matrix<CellValue>): void;
+export declare function isNumberMatrix(arg: Matrix<CellValue>): arg is Matrix<number>;

package/dist/types/functions/helper_financial.d.ts

@@ -0,0 +1,49 @@
+import { Locale } from "../types";
+/** Assert maturity date > settlement date */
+export declare function assertMaturityAndSettlementDatesAreValid(settlement: number, maturity: number): void;
+/** Assert settlement date > issue date */
+export declare function assertSettlementAndIssueDatesAreValid(settlement: number, issue: number): void;
+/** Assert coupon frequency is in [1, 2, 4] */
+export declare function assertCouponFrequencyIsValid(frequency: number): void;
+/** Assert dayCountConvention is between 0 and 4 */
+export declare function assertDayCountConventionIsValid(dayCountConvention: number): void;
+export declare function assertRedemptionStrictlyPositive(redemption: number): void;
+export declare function assertPriceStrictlyPositive(price: number): void;
+export declare function assertNumberOfPeriodsStrictlyPositive(nPeriods: number): void;
+export declare function assertRateStrictlyPositive(rate: number): void;
+export declare function assertLifeStrictlyPositive(life: number): void;
+export declare function assertCostStrictlyPositive(cost: number): void;
+export declare function assertCostPositiveOrZero(cost: number): void;
+export declare function assertPeriodStrictlyPositive(period: number): void;
+export declare function assertPeriodPositiveOrZero(period: number): void;
+export declare function assertSalvagePositiveOrZero(salvage: number): void;
+export declare function assertSalvageSmallerOrEqualThanCost(salvage: number, cost: number): void;
+export declare function assertPresentValueStrictlyPositive(pv: number): void;
+export declare function assertPeriodSmallerOrEqualToLife(period: number, life: number): void;
+export declare function assertInvestmentStrictlyPositive(investment: number): void;
+export declare function assertDiscountStrictlyPositive(discount: number): void;
+export declare function assertDiscountStrictlySmallerThanOne(discount: number): void;
+export declare function assertDeprecationFactorStrictlyPositive(factor: number): void;
+export declare function assertSettlementLessThanOneYearBeforeMaturity(settlement: number, maturity: number, locale: Locale): void;
+/**
+ * Check if the given periods are valid. This will assert :
+ *
+ * - 0 < numberOfPeriods
+ * - 0 < firstPeriod <= lastPeriod
+ * - 0 < lastPeriod <= numberOfPeriods
+ *
+ */
+export declare function assertFirstAndLastPeriodsAreValid(firstPeriod: number, lastPeriod: number, numberOfPeriods: number): void;
+/**
+ * Check if the given periods are valid. This will assert :
+ *
+ * - 0 < life
+ * - 0 <= startPeriod <= endPeriod
+ * - 0 <= endPeriod <= life
+ *
+ */
+export declare function assertStartAndEndPeriodAreValid(startPeriod: number, endPeriod: number, life: number): void;
+export declare function assertRateGuessStrictlyGreaterThanMinusOne(guess: number): void;
+export declare function assertCashFlowsAndDatesHaveSameDimension(cashFlows: any[][], dates: any[][]): void;
+export declare function assertCashFlowsHavePositiveAndNegativesValues(cashFlow: number[]): void;
+export declare function assertEveryDateGreaterThanFirstDateOfCashFlowDates(dates: number[]): void;

package/dist/types/functions/helper_matrices.d.ts

@@ -0,0 +1,23 @@
+import { Matrix } from "../types";
+export declare function getUnitMatrix(n: number): Matrix<number>;
+/**
+ * Invert a matrix and compute its determinant using Gaussian Elimination.
+ *
+ * The Matrix should be a square matrix, and should be indexed [col][row] instead of the
+ * standard mathematical indexing [row][col].
+ */
+export declare function invertMatrix(M: Matrix<number>): {
+    inverted?: Matrix<number>;
+    determinant: number;
+};
+/**
+ * Matrix multiplication of 2 matrices.
+ * ex: matrix1 : n x l, matrix2 : m x n => result : m x l
+ *
+ * Note: we use indexing [col][row] instead of the standard mathematical notation [row][col]
+ */
+export declare function multiplyMatrices(matrix1: Matrix<number>, matrix2: Matrix<number>): Matrix<number>;
+/**
+ * Return the input if it's a scalar or the first element of the input if it's a matrix.
+ */
+export declare function toScalar<T>(matrix: Matrix<T> | T): T;

package/dist/types/functions/helper_statistical.d.ts

@@ -0,0 +1,3 @@
+export declare function assertSameNumberOfElements(...args: any[][]): void;
+export declare function assertNonEmptyMatrix(matrix: any[][], argName: string): void;
+export declare function assertNonEmpty(...data: any[][]): void;

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

@@ -0,0 +1,101 @@
+import { DateTime } from "../helpers/dates";
+import { ArgValue, CellValue, Locale, Matrix, Maybe, ValueAndFormat } from "../types";
+export declare function assert(condition: () => boolean, message: string): void;
+export declare const expectNumberRangeError: (lowerBound: number, upperBound: number, value: number) => string;
+export declare const expectStringSetError: (stringSet: string[], value: string) => string;
+export declare function toNumber(value: string | number | boolean | null | undefined, locale: Locale): number;
+export declare function tryToNumber(value: string | number | boolean | null | undefined, locale: Locale): number | undefined;
+export declare function tryCastAsNumberMatrix(data: Matrix<any>, argName: string): Matrix<number>;
+export declare function strictToNumber(value: string | number | boolean | null | undefined, locale: Locale): number;
+export declare function toInteger(value: string | number | boolean | null | undefined, locale: Locale): number;
+export declare function strictToInteger(value: string | number | boolean | null | undefined, locale: Locale): number;
+export declare function assertNumberGreaterThanOrEqualToOne(value: number): void;
+export declare function toString(value: string | number | boolean | null | undefined): string;
+/**
+ * Normalize range by setting all the string in the range to lowercase and replacing
+ * accent letters with plain letters
+ */
+export declare function normalizeRange<T>(range: T[]): (string | T)[];
+export declare function toBoolean(value: string | number | boolean | null | undefined): boolean;
+export declare function toJsDate(value: string | number | boolean | null | undefined, locale: Locale): DateTime;
+export declare function visitAny<T extends ValueAndFormat | CellValue>(args: (T | Matrix<T> | undefined)[], cb: (a: T) => void): void;
+export declare function visitNumbers(args: ArgValue[], cb: (arg: number) => void, locale: Locale): void;
+export declare function reduceAny<T, M>(args: (T | Matrix<T>)[], cb: (acc: M, a: T) => M, initialValue: M, dir?: "rowFirst" | "colFirst"): M;
+export declare function reduceNumbers(args: ArgValue[], cb: (acc: number, a: number) => number, initialValue: number, locale: Locale): number;
+export declare function reduceNumbersTextAs0(args: ArgValue[], cb: (acc: number, a: number) => number, initialValue: number, locale: Locale): number;
+/**
+ * Generate a matrix of size nColumns x nRows and apply a callback on each position
+ */
+export declare function generateMatrix<T>(nColumns: number, nRows: number, callback: (col: number, row: number) => T): Matrix<T>;
+export declare function matrixMap<T, M>(matrix: Matrix<T>, fn: (value: T) => M): Matrix<M>;
+export declare function transposeMatrix<T>(matrix: Matrix<T>): Matrix<T>;
+export declare function conditionalVisitBoolean(args: ArgValue[], cb: (a: boolean) => boolean): void;
+/**
+ * Functions used especially for predicate evaluation on ranges.
+ *
+ * Take ranges with same dimensions and take predicates, one for each range.
+ * For (i, j) coordinates, if all elements with coordinates (i, j) of each
+ * range correspond to the associated predicate, then the function uses a callback
+ * function with the parameters "i" and "j".
+ *
+ * Syntax:
+ * visitMatchingRanges([range1, predicate1, range2, predicate2, ...], cb(i,j), likeSelection)
+ *
+ * - range1 (range): The range to check against predicate1.
+ * - predicate1 (string): The pattern or test to apply to range1.
+ * - range2: (range, repeatable) ranges to check.
+ * - predicate2 (string, repeatable): Additional pattern or test to apply to range2.
+ *
+ * - cb(i: number, j: number) => void: the callback function.
+ *
+ * - isQuery (boolean) indicates if the comparison with a string should be done as a SQL-like query.
+ * (Ex1 isQuery = true, predicate = "abc", element = "abcde": predicate match the element),
+ * (Ex2 isQuery = false, predicate = "abc", element = "abcde": predicate not match the element).
+ * (Ex3 isQuery = true, predicate = "abc", element = "abc": predicate match the element),
+ * (Ex4 isQuery = false, predicate = "abc", element = "abc": predicate match the element).
+ */
+export declare function visitMatchingRanges(args: ArgValue[], cb: (i: number, j: number) => void, locale: Locale, isQuery?: boolean): void;
+/**
+ * Perform a dichotomic search on an array and return the index of the nearest match.
+ *
+ * The array should be sorted, if not an incorrect value might be returned. In the case where multiple
+ * element of the array match the target, the method will return the first match if the array is sorted
+ * in descending order, and the last match if the array is in ascending order.
+ *
+ *
+ * @param data the array in which to search.
+ * @param target the value to search.
+ * @param mode "nextGreater/nextSmaller" : return next greater/smaller value if no exact match is found.
+ * @param sortOrder whether the array is sorted in ascending or descending order.
+ * @param rangeLength the number of elements to consider in the search array.
+ * @param getValueInData function returning the element at index i in the search array.
+ */
+export declare function dichotomicSearch<T>(data: T, target: Maybe<CellValue>, mode: "nextGreater" | "nextSmaller" | "strict", sortOrder: "asc" | "desc", rangeLength: number, getValueInData: (range: T, index: number) => CellValue | undefined): number;
+/**
+ * Perform a linear search and return the index of the match.
+ * -1 is returned if no value is found.
+ *
+ * Example:
+ * - [3, 6, 10], 3 => 0
+ * - [3, 6, 10], 6 => 1
+ * - [3, 6, 10], 9 => -1
+ * - [3, 6, 10], 2 => -1
+ *
+ * @param data the array to search in.
+ * @param target the value to search in the array.
+ * @param mode if "strict" return exact match index. "nextGreater" returns the next greater
+ * element from the target and "nextSmaller" the next smaller
+ * @param numberOfValues the number of elements to consider in the search array.
+ * @param getValueInData function returning the element at index i in the search array.
+ * @param reverseSearch if true, search in the array starting from the end.
+
+ */
+export declare function linearSearch<T>(data: T, target: Maybe<CellValue> | undefined, mode: "nextSmaller" | "nextGreater" | "strict", numberOfValues: number, getValueInData: (data: T, index: number) => CellValue | undefined, reverseSearch?: boolean): number;
+export declare function toMatrix<T>(data: T | Matrix<T> | undefined): Matrix<T>;
+/**
+ * Flatten an array of items, where each item can be a single value or a 2D array, and apply the
+ * callback to each element.
+ *
+ * The 2D array are flattened row first.
+ */
+export declare function flattenRowFirst<T, K>(items: Array<T | Matrix<T>>, callback: (val: T) => K): K[];

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

@@ -0,0 +1,10 @@
+import { Registry } from "../registries/registry";
+import { AddFunctionDescription, Arg, ComputeFunction, FunctionDescription, Matrix, ValueAndFormat } from "../types";
+export { arg } from "./arguments";
+declare class FunctionRegistry extends Registry<FunctionDescription> {
+    mapping: {
+        [key: string]: ComputeFunction<Arg, Matrix<ValueAndFormat> | ValueAndFormat>;
+    };
+    add(name: string, addDescr: AddFunctionDescription): this;
+}
+export declare const functionRegistry: FunctionRegistry;