@odoo/o-spreadsheet 14.0.1 → 14.0.3

package/src/functions/module_info.ts

@@ -1,69 +0,0 @@
-import { _lt } from "../translation";
-import { FunctionDescription } from "../types";
-import { args } from "./arguments";
-
-// -----------------------------------------------------------------------------
-// ISERROR
-// -----------------------------------------------------------------------------
-export const ISERROR: FunctionDescription = {
-  description: _lt("Whether a value is an error."),
-  args: args(`value (any, lazy) ${_lt("The value to be verified as an error type.")}`),
-  returns: ["BOOLEAN"],
-  compute: function (value: () => any): boolean {
-    try {
-      value();
-      return false;
-    } catch (e) {
-      return true;
-    }
-  },
-};
-
-// -----------------------------------------------------------------------------
-// ISLOGICAL
-// -----------------------------------------------------------------------------
-export const ISLOGICAL: FunctionDescription = {
-  description: _lt("Whether a value is `true` or `false`."),
-  args: args(`value (any) ${_lt("The value to be verified as a logical TRUE or FALSE.")}`),
-  returns: ["BOOLEAN"],
-  compute: function (value: any): boolean {
-    return typeof value === "boolean";
-  },
-};
-
-// -----------------------------------------------------------------------------
-// ISNONTEXT
-// -----------------------------------------------------------------------------
-export const ISNONTEXT: FunctionDescription = {
-  description: _lt("Whether a value is non-textual."),
-  args: args(`value (any) ${_lt("The value to be checked.")}`),
-  returns: ["BOOLEAN"],
-  compute: function (value: any): boolean {
-    return typeof value !== "string";
-  },
-};
-
-// -----------------------------------------------------------------------------
-// ISNUMBER
-// -----------------------------------------------------------------------------
-
-export const ISNUMBER: FunctionDescription = {
-  description: _lt("Whether a value is a number."),
-  args: args(`value (any) ${_lt("The value to be verified as a number.")}`),
-  returns: ["BOOLEAN"],
-  compute: function (value: any): boolean {
-    return typeof value === "number";
-  },
-};
-
-// -----------------------------------------------------------------------------
-// ISTEXT
-// -----------------------------------------------------------------------------
-export const ISTEXT: FunctionDescription = {
-  description: _lt("Whether a value is text."),
-  args: args(`value (any) ${_lt("The value to be verified as text.")}`),
-  returns: ["BOOLEAN"],
-  compute: function (value: any): boolean {
-    return typeof value === "string";
-  },
-};

package/src/functions/module_logical.ts

@@ -1,208 +0,0 @@
-import { _lt } from "../translation";
-import { FunctionDescription } from "../types";
-import { args } from "./arguments";
-import { toBoolean, visitBooleans } from "./helpers";
-
-// -----------------------------------------------------------------------------
-// WAIT
-// -----------------------------------------------------------------------------
-export const WAIT: FunctionDescription = {
-  description: _lt("Wait"),
-  args: args(`ms (number) ${_lt("wait time in milliseconds")}`),
-  returns: ["ANY"],
-  async: true,
-  compute: function (delay) {
-    return new Promise(function (resolve, reject) {
-      setTimeout(function () {
-        resolve(delay);
-      }, delay);
-    });
-  },
-};
-
-// -----------------------------------------------------------------------------
-// AND
-// -----------------------------------------------------------------------------
-export const AND: FunctionDescription = {
-  description: _lt("Logical `and` operator."),
-  args: args(`
-      logical_expression1 (boolean, range<boolean>) ${_lt(
-        "An expression or reference to a cell containing an expression that represents some logical value, i.e. TRUE or FALSE, or an expression that can be coerced to a logical value."
-      )}
-      logical_expression2 (boolean, range<boolean>, optional, repeating) ${_lt(
-        "More expressions that represent logical values."
-      )}
-    `),
-  returns: ["BOOLEAN"],
-  compute: function (): boolean {
-    let result = true;
-    let foundBoolean = false;
-    visitBooleans(arguments, (b) => {
-      result = result && b;
-      foundBoolean = true;
-      return result;
-    });
-    if (!foundBoolean) {
-      throw new Error(_lt(`AND has no valid input data.`));
-    }
-    return result;
-  },
-};
-
-// -----------------------------------------------------------------------------
-// IF
-// -----------------------------------------------------------------------------
-export const IF: FunctionDescription = {
-  description: _lt("Returns value depending on logical expression."),
-  args: args(`
-      logical_expression (boolean) ${_lt(
-        "An expression or reference to a cell containing an expression that represents some logical value, i.e. TRUE or FALSE."
-      )}
-      value_if_true (any, lazy) ${_lt(
-        "The value the function returns if logical_expression is TRUE."
-      )}
-      value_if_false (any, lazy, optional, default=FALSE) ${_lt(
-        "The value the function returns if logical_expression is FALSE."
-      )}
-    `),
-  returns: ["ANY"],
-  compute: function (
-    logical_expression: any,
-    value_if_true: () => any,
-    value_if_false: () => any = () => false
-  ): any {
-    const result = toBoolean(logical_expression) ? value_if_true() : value_if_false();
-    return result === null ? "" : result;
-  },
-};
-
-// -----------------------------------------------------------------------------
-// IFERROR
-// -----------------------------------------------------------------------------
-export const IFERROR: FunctionDescription = {
-  description: _lt("Value if it is not an error, otherwise 2nd argument."),
-  args: args(`
-    value (any, lazy) ${_lt("The value to return if value itself is not an error.")}
-    value_if_error (any, lazy, optional, default="") ${_lt(
-      "The value the function returns if value is an error."
-    )}
-  `),
-  returns: ["ANY"],
-  compute: function (value: () => any, value_if_error: () => any = () => ""): any {
-    let result;
-    try {
-      result = value();
-    } catch (e) {
-      result = value_if_error();
-    }
-    return result === null ? "" : result;
-  },
-};
-
-// -----------------------------------------------------------------------------
-// IFS
-// -----------------------------------------------------------------------------
-export const IFS: FunctionDescription = {
-  description: _lt("Returns a value depending on multiple logical expressions."),
-  args: args(`
-      condition1 (boolean, lazy) ${_lt(
-        "The first condition to be evaluated. This can be a boolean, a number, an array, or a reference to any of those."
-      )}
-      value1 (any, lazy) ${_lt("The returned value if condition1 is TRUE.")}
-      additional_values (any, lazy, optional, repeating) ${_lt(
-        "Additional conditions and values to be evaluated if the previous ones are FALSE."
-      )}
-    `),
-  // @compatibility: on google sheets, args definitions are next:
-  // condition1 (boolean) The first condition to be evaluated. This can be a boolean, a number, an array, or a reference to any of those.
-  // value1 (any) The returned value if condition1 is TRUE.
-  // condition2 (boolean, optional, repeating) Additional conditions to be evaluated if the previous ones are FALSE.
-  // value2 (any, optional, repeating) Additional values to be returned if their corresponding conditions are TRUE.
-  returns: ["ANY"],
-  compute: function (): any {
-    if (arguments.length % 2 === 1) {
-      throw new Error(_lt(`Wrong number of arguments. Expected an even number of arguments.`));
-    }
-    for (let n = 0; n < arguments.length - 1; n += 2) {
-      if (toBoolean(arguments[n]())) {
-        return arguments[n + 1]();
-      }
-    }
-    throw new Error(_lt(`No match.`));
-  },
-};
-
-// -----------------------------------------------------------------------------
-// NOT
-// -----------------------------------------------------------------------------
-export const NOT: FunctionDescription = {
-  description: _lt("Returns opposite of provided logical value."),
-  args: args(
-    `logical_expression (boolean) ${_lt(
-      "An expression or reference to a cell holding an expression that represents some logical value."
-    )}
-    `
-  ),
-  returns: ["BOOLEAN"],
-  compute: function (logical_expression: any): boolean {
-    return !toBoolean(logical_expression);
-  },
-};
-
-// -----------------------------------------------------------------------------
-// OR
-// -----------------------------------------------------------------------------
-export const OR: FunctionDescription = {
-  description: _lt("Logical `or` operator."),
-  args: args(`
-      logical_expression1 (boolean, range<boolean>) ${_lt(
-        "An expression or reference to a cell containing an expression that represents some logical value, i.e. TRUE or FALSE, or an expression that can be coerced to a logical value."
-      )}
-      logical_expression2 (boolean, range<boolean>, optional, repeating) ${_lt(
-        "More expressions that evaluate to logical values."
-      )}
-    `),
-  returns: ["BOOLEAN"],
-  compute: function (): boolean {
-    let result = false;
-    let foundBoolean = false;
-    visitBooleans(arguments, (b) => {
-      result = result || b;
-      foundBoolean = true;
-      return !result;
-    });
-    if (!foundBoolean) {
-      throw new Error(_lt(`OR has no valid input data.`));
-    }
-    return result;
-  },
-};
-
-// -----------------------------------------------------------------------------
-// XOR
-// -----------------------------------------------------------------------------
-export const XOR: FunctionDescription = {
-  description: _lt("Logical `xor` operator."),
-  args: args(`
-      logical_expression1 (boolean, range<boolean>) ${_lt(
-        "An expression or reference to a cell containing an expression that represents some logical value, i.e. TRUE or FALSE, or an expression that can be coerced to a logical value."
-      )}
-      logical_expression2 (boolean, range<boolean>, optional, repeating) ${_lt(
-        "More expressions that evaluate to logical values."
-      )}
-    `),
-  returns: ["BOOLEAN"],
-  compute: function (): boolean {
-    let result = false;
-    let foundBoolean = false;
-    visitBooleans(arguments, (b) => {
-      result = result ? !b : b;
-      foundBoolean = true;
-      return true;
-    });
-    if (!foundBoolean) {
-      throw new Error(_lt(`XOR has no valid input data.`));
-    }
-    return result;
-  },
-};

package/src/functions/module_lookup.ts

@@ -1,185 +0,0 @@
-import { _lt } from "../translation";
-import { FunctionDescription } from "../types";
-import { args } from "./arguments";
-import { formatDateTime } from "./dates";
-import {
-  dichotomicPredecessorSearch,
-  dichotomicSuccessorSearch,
-  extractDateValue,
-  toBoolean,
-  toNumber,
-} from "./helpers";
-
-/**
- * Perform a linear search and return the index of the perfect 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
- */
-function linearSearch(range: any[], target: any): number {
-  for (let i = 0; i < range.length; i++) {
-    if (range[i] === target) {
-      return i;
-    }
-  }
-  // no value is found, -1 is returned
-  return -1;
-}
-
-// -----------------------------------------------------------------------------
-// LOOKUP
-// -----------------------------------------------------------------------------
-
-export const LOOKUP: FunctionDescription = {
-  description: _lt(`Look up a value.`),
-  args: args(`
-      search_key (any) ${_lt("The value to search for. For example, 42, 'Cats', or I24.")}
-      search_array (any, range) ${_lt(
-        "One method of using this function is to provide a single sorted row or column search_array to look through for the search_key with a second argument result_range. The other way is to combine these two arguments into one search_array where the first row or column is searched and a value is returned from the last row or column in the array. If search_key is not found, a non-exact match may be returned."
-      )}
-      result_range (any, range, optional) ${_lt(
-        "The range from which to return a result. The value returned corresponds to the location where search_key is found in search_range. This range must be only a single row or column and should not be used if using the search_result_array method."
-      )}
-  `),
-  returns: ["ANY"],
-  compute: function (search_key: any, search_array: any, result_range: any = undefined): any {
-    const verticalSearch = search_array[0].length >= search_array.length;
-    const searchRange = (verticalSearch ? search_array[0] : search_array.map((c) => c[0])).map(
-      (el) => extractDateValue(el)
-    );
-
-    const key = extractDateValue(search_key);
-    const index = dichotomicPredecessorSearch(searchRange, key);
-    if (index === -1) {
-      const value =
-        typeof search_key === "object" && search_key.jsDate
-          ? formatDateTime(search_key)
-          : search_key;
-      throw new Error(_lt("Did not find value '%s' in LOOKUP evaluation.", value));
-    }
-    if (result_range === undefined) {
-      return verticalSearch ? search_array.pop()[index] : search_array[index].pop();
-    }
-
-    const nbCol = result_range.length;
-    const nbRow = result_range[0].length;
-    if (nbCol > 1 && nbRow > 1) {
-      throw new Error(_lt(`LOOKUP range must be a single row or a single column.`));
-    }
-
-    if (nbCol > 1) {
-      if (nbCol - 1 < index) {
-        throw new Error(
-          _lt("LOOKUP evaluates to an out of range row value %s.", (index + 1).toString())
-        );
-      }
-      return result_range[index][0];
-    }
-
-    if (nbRow - 1 < index) {
-      throw new Error(
-        _lt("LOOKUP evaluates to an out of range column value %s.", (index + 1).toString())
-      );
-    }
-    return result_range[0][index];
-  },
-};
-
-// -----------------------------------------------------------------------------
-// MATCH
-// -----------------------------------------------------------------------------
-
-export const MATCH: FunctionDescription = {
-  description: _lt(`Position of item in range that matches value.`),
-  args: args(`
-      search_key (any) ${_lt("The value to search for. For example, 42, 'Cats', or I24.")}
-      range (any, range) ${_lt("The one-dimensional array to be searched.")}
-      search_type (number, optional, default=1) ${_lt(
-        "The search method. 1 (default) finds the largest value less than or equal to search_key when range is sorted in ascending order. 0 finds the exact value when range is unsorted. -1 finds the smallest value greater than or equal to search_key when range is sorted in descending order."
-      )}
-  `),
-  returns: ["NUMBER"],
-  compute: function (search_key: any, range: any[], search_type: any = 1): number {
-    let _searchType = toNumber(search_type);
-    const nbCol = range.length;
-    const nbRow = range[0].length;
-    if (nbCol > 1 && nbRow > 1) {
-      throw new Error(_lt(`MATCH range must be a single row or a single column.`));
-    }
-    let index = -1;
-    range = range.flat().map((el) => extractDateValue(el));
-    const key = extractDateValue(search_key);
-    _searchType = Math.sign(_searchType);
-    switch (_searchType) {
-      case 1:
-        index = dichotomicPredecessorSearch(range, key);
-        break;
-      case 0:
-        index = linearSearch(range, key);
-        break;
-      case -1:
-        index = dichotomicSuccessorSearch(range, key);
-        break;
-    }
-    if (index > -1) {
-      return index + 1;
-    } else {
-      const value =
-        typeof search_key === "object" && search_key.jsDate
-          ? formatDateTime(search_key)
-          : search_key;
-      throw new Error(_lt("Did not find value '%s' in MATCH evaluation.", value));
-    }
-  },
-};
-
-// -----------------------------------------------------------------------------
-// VLOOKUP
-// -----------------------------------------------------------------------------
-
-export const VLOOKUP: FunctionDescription = {
-  description: _lt(`Vertical lookup.`),
-  args: args(`
-      search_key (any) ${_lt("The value to search for. For example, 42, 'Cats', or I24.")}
-      range (any, range) ${_lt(
-        "The range to consider for the search. The first column in the range is searched for the key specified in search_key."
-      )}
-      index (number) ${_lt(
-        "The column index of the value to be returned, where the first column in range is numbered 1."
-      )}
-      is_sorted (boolean, optional, default = TRUE) ${_lt(
-        "Indicates whether the column to be searched [the first column of the specified range] is sorted, in which case the closest match for search_key will be returned."
-      )}
-  `),
-  returns: ["ANY"],
-  compute: function (search_key: any, range: any[], index: any, is_sorted: any = true): any {
-    const _index = Math.trunc(toNumber(index));
-    if (_index < 1 || range.length < _index) {
-      throw new Error(_lt(`VLOOKUP evaluates to an out of bounds range.`));
-    }
-
-    const _isSorted = toBoolean(is_sorted);
-    const firstCol = range[0].map((el) => extractDateValue(el));
-    const key = extractDateValue(search_key);
-    let lineIndex;
-    if (_isSorted) {
-      lineIndex = dichotomicPredecessorSearch(firstCol, key);
-    } else {
-      lineIndex = linearSearch(firstCol, key);
-    }
-
-    if (lineIndex > -1) {
-      return range[_index - 1][lineIndex];
-    } else {
-      const value =
-        typeof search_key === "object" && search_key.jsDate
-          ? formatDateTime(search_key)
-          : search_key;
-      throw new Error(_lt("Did not find value '%s' in VLOOKUP evaluation.", value));
-    }
-  },
-};