@odoo/o-spreadsheet 14.0.1 → 14.0.2

package/src/functions/module_text.ts

@@ -1,370 +0,0 @@
-import { _lt } from "../translation";
-import { FunctionDescription } from "../types";
-import { args } from "./arguments";
-import { reduceArgs, toBoolean, toNumber, toString } from "./helpers";
-
-// -----------------------------------------------------------------------------
-// CHAR
-// -----------------------------------------------------------------------------
-export const CHAR: FunctionDescription = {
-  description: _lt("Gets character associated with number."),
-  args: args(`
-      table_number (number) ${_lt(
-        "The number of the character to look up from the current Unicode table in decimal format."
-      )}
-  `),
-  returns: ["STRING"],
-  compute: function (table_number: any): string {
-    const _tableNumber = Math.trunc(toNumber(table_number));
-    if (_tableNumber < 1) {
-      throw new Error(
-        _lt("Function CHAR parameter 1 value %s is out of range.", _tableNumber.toString())
-      );
-    }
-    return String.fromCharCode(_tableNumber);
-  },
-};
-
-// -----------------------------------------------------------------------------
-// CONCATENATE
-// -----------------------------------------------------------------------------
-export const CONCATENATE: FunctionDescription = {
-  description: _lt("Appends strings to one another."),
-  args: args(`
-      string1 (string, range<string>) ${_lt("The initial string.")}
-      string2 (string, range<string>, optional, repeating) ${_lt(
-        "More strings to append in sequence."
-      )}
-  `),
-  returns: ["STRING"],
-  compute: function (): string {
-    return reduceArgs(arguments, (acc, a) => acc + toString(a), "");
-  },
-};
-
-// -----------------------------------------------------------------------------
-// EXACT
-// -----------------------------------------------------------------------------
-export const EXACT: FunctionDescription = {
-  description: _lt("Tests whether two strings are identical."),
-  args: args(`
-      string1 (string) ${_lt("The first string to compare.")}
-      string2 (string) ${_lt("The second string to compare.")}
-  `),
-  returns: ["BOOLEAN"],
-  compute: function (string1: any, string2: any): boolean {
-    return toString(string1) === toString(string2);
-  },
-};
-
-// -----------------------------------------------------------------------------
-// FIND
-// -----------------------------------------------------------------------------
-export const FIND: FunctionDescription = {
-  description: _lt("First position of string found in text, case-sensitive."),
-  args: args(`
-      search_for (string) ${_lt("The string to look for within text_to_search.")}
-      text_to_search (string) ${_lt("The text to search for the first occurrence of search_for.")}
-      starting_at (number, optional, default=1 ) ${_lt(
-        "The character within text_to_search at which to start the search."
-      )}
-  `),
-  returns: ["NUMBER"],
-  compute: function (search_for: any, text_to_search: any, starting_at: any = 1): number {
-    const _textToSearch = toString(text_to_search);
-    if (_textToSearch === "") {
-      throw new Error(_lt(`Function FIND parameter 2 value should be non-empty.`));
-    }
-
-    const _startingAt = toNumber(starting_at);
-    if (_startingAt === 0) {
-      throw new Error(
-        _lt(`Function FIND parameter 3 value is 0. It should be greater than or equal to 1.`)
-      );
-    }
-
-    const _searchFor = toString(search_for);
-    const result = _textToSearch.indexOf(_searchFor, _startingAt - 1);
-    if (result < 0) {
-      throw new Error(
-        _lt(
-          "In FIND evaluation, cannot find '%s' within '%s'.",
-          _searchFor.toString(),
-          _textToSearch
-        )
-      );
-    }
-    return result + 1;
-  },
-};
-
-// -----------------------------------------------------------------------------
-// JOIN
-// -----------------------------------------------------------------------------
-export const JOIN: FunctionDescription = {
-  description: _lt("Concatenates elements of arrays with delimiter."),
-  args: args(`
-      delimiter (string) ${_lt("The character or string to place between each concatenated value.")}
-      value_or_array1 (string, range<string>) ${_lt(
-        "The value or values to be appended using delimiter."
-      )}
-      value_or_array2 (string, range<string>, optional, repeating) ${_lt(
-        "More values to be appended using delimiter."
-      )}
-  `),
-  returns: ["STRING"],
-  compute: function (delimiter: any, ...values_or_arrays: any): string {
-    const _delimiter = toString(delimiter);
-    return reduceArgs(
-      values_or_arrays,
-      (acc, a) => (acc ? acc + _delimiter : "") + toString(a),
-      ""
-    );
-  },
-};
-
-// -----------------------------------------------------------------------------
-// LEFT
-// -----------------------------------------------------------------------------
-export const LEFT: FunctionDescription = {
-  description: _lt("Substring from beginning of specified string."),
-  args: args(`
-      text (string) ${_lt("The string from which the left portion will be returned.")}
-      number_of_characters (number, optional, default=1) ${_lt(
-        "The number of characters to return from the left side of string."
-      )}
-  `),
-  returns: ["STRING"],
-  compute: function (text: any, number_of_characters: any = 1): string {
-    const _numberOfCharacters = toNumber(number_of_characters);
-    if (_numberOfCharacters < 0) {
-      throw new Error(
-        _lt(`Function LEFT parameter 2 value is negative. It should be positive or zero.`)
-      );
-    }
-    return toString(text).substring(0, _numberOfCharacters);
-  },
-};
-
-// -----------------------------------------------------------------------------
-// LEN
-// -----------------------------------------------------------------------------
-export const LEN: FunctionDescription = {
-  description: _lt("Length of a string."),
-  args: args(`
-      text (string) ${_lt("The string whose length will be returned.")}
-  `),
-  returns: ["NUMBER"],
-  compute: function (text: any): number {
-    return toString(text).length;
-  },
-};
-
-// -----------------------------------------------------------------------------
-// LOWER
-// -----------------------------------------------------------------------------
-export const LOWER: FunctionDescription = {
-  description: _lt("Converts a specified string to lowercase."),
-  args: args(`
-      text (string) ${_lt("The string to convert to lowercase.")}
-  `),
-  returns: ["STRING"],
-  compute: function (text: any): string {
-    return toString(text).toLowerCase();
-  },
-};
-
-// -----------------------------------------------------------------------------
-// REPLACE
-// -----------------------------------------------------------------------------
-export const REPLACE: FunctionDescription = {
-  description: _lt("Replaces part of a text string with different text."),
-  args: args(`
-      text (string) ${_lt("The text, a part of which will be replaced.")}
-      position (number) ${_lt("The position where the replacement will begin (starting from 1).")}
-      length (number) ${_lt("The number of characters in the text to be replaced.")}
-      new_text (string) ${_lt("The text which will be inserted into the original text.")}
-  `),
-  returns: ["STRING"],
-  compute: function (text: any, position: any, length: any, new_text: any): string {
-    const _position = toNumber(position);
-    if (_position < 1) {
-      throw new Error(
-        _lt(
-          "Function REPLACE parameter 2 value is %s. It should be greater than or equal to 1.",
-          toString(_position)
-        )
-      );
-    }
-
-    const _text = toString(text);
-    const _length = toNumber(length);
-    const _newText = toString(new_text);
-    return _text.substring(0, _position - 1) + _newText + _text.substring(_position - 1 + _length);
-  },
-};
-
-// -----------------------------------------------------------------------------
-// RIGHT
-// -----------------------------------------------------------------------------
-export const RIGHT: FunctionDescription = {
-  description: _lt("A substring from the end of a specified string."),
-  args: args(`
-      text (string) ${_lt("The string from which the right portion will be returned.")}
-      number_of_characters (number, optional, default=1) ${_lt(
-        "The number of characters to return from the right side of string."
-      )}
-  `),
-  returns: ["STRING"],
-  compute: function (text: any, number_of_characters: any = 1): string {
-    const _numberOfCharacters = toNumber(number_of_characters);
-    if (_numberOfCharacters < 0) {
-      throw new Error(
-        _lt(`Function RIGHT parameter 2 value is negative. It should be positive or zero.`)
-      );
-    }
-    const _text = toString(text);
-    const stringLength = _text.length;
-    return _text.substring(stringLength - _numberOfCharacters, stringLength);
-  },
-};
-
-// -----------------------------------------------------------------------------
-// SEARCH
-// -----------------------------------------------------------------------------
-export const SEARCH: FunctionDescription = {
-  description: _lt("First position of string found in text, ignoring case."),
-  args: args(`
-      search_for (string) ${_lt("The string to look for within text_to_search.")}
-      text_to_search (string) ${_lt("The text to search for the first occurrence of search_for.")}
-      starting_at (number, optional, default=1 ) ${_lt(
-        "The character within text_to_search at which to start the search."
-      )}
-  `),
-  returns: ["NUMBER"],
-  compute: function (search_for: any, text_to_search: any, starting_at: any = 1): number {
-    const _textToSearch = toString(text_to_search).toLowerCase();
-    if (_textToSearch === "") {
-      throw new Error(_lt(`Function SEARCH parameter 2 value should be non-empty.`));
-    }
-
-    const _startingAt = toNumber(starting_at);
-    if (_startingAt === 0) {
-      throw new Error(
-        _lt(`Function SEARCH parameter 3 value is 0. It should be greater than or equal to 1.`)
-      );
-    }
-
-    const _searchFor = toString(search_for).toLowerCase();
-    const result = _textToSearch.indexOf(_searchFor, _startingAt - 1);
-    if (result < 0) {
-      throw new Error(
-        _lt("In SEARCH evaluation, cannot find '%s' within '%s'.", _searchFor, _textToSearch)
-      );
-    }
-    return result + 1;
-  },
-};
-
-// -----------------------------------------------------------------------------
-// SUBSTITUTE
-// -----------------------------------------------------------------------------
-export const SUBSTITUTE: FunctionDescription = {
-  description: _lt("Replaces existing text with new text in a string."),
-  args: args(`
-      text_to_search (string) ${_lt("The text within which to search and replace.")}
-      search_for (string) ${_lt("The string to search for within text_to_search.")}
-      replace_with (string) ${_lt("The string that will replace search_for.")}
-      occurrence_number (number, optional) ${_lt(
-        "The instance of search_for within text_to_search to replace with replace_with. By default, all occurrences of search_for are replaced; however, if occurrence_number is specified, only the indicated instance of search_for is replaced."
-      )}
-  `),
-  returns: ["NUMBER"],
-  compute: function (
-    text_to_search: any,
-    search_for: any,
-    replace_with: any,
-    occurrence_number: any = undefined
-  ): string {
-    const _occurrenceNumber = toNumber(occurrence_number);
-    if (_occurrenceNumber < 0) {
-      throw new Error(
-        _lt(`Function SUBSTITUTE parameter 4 value is negative. It should be positive or zero.`)
-      );
-    }
-
-    const _textToSearch = toString(text_to_search);
-    const _searchFor = toString(search_for);
-    if (_searchFor === "") {
-      return _textToSearch;
-    }
-
-    const _replaceWith = toString(replace_with);
-    const reg = new RegExp(_searchFor, "g");
-    if (_occurrenceNumber === 0) {
-      return _textToSearch.replace(reg, _replaceWith);
-    }
-
-    let n = 0;
-    return _textToSearch.replace(reg, (text) => (++n === _occurrenceNumber ? _replaceWith : text));
-  },
-};
-
-// -----------------------------------------------------------------------------
-// TEXTJOIN
-// -----------------------------------------------------------------------------
-export const TEXTJOIN: FunctionDescription = {
-  description: _lt("Combines text from multiple strings and/or arrays."),
-  args: args(`
-      delimiter (string) ${_lt(
-        " A string, possible empty, or a reference to a valid string. If empty, the text will be simply concatenated."
-      )}
-      ignore_empty (boolean) ${_lt(
-        "A boolean; if TRUE, empty cells selected in the text arguments won't be included in the result."
-      )}
-      text1 (string, range<string>) ${_lt(
-        "Any text item. This could be a string, or an array of strings in a range."
-      )}
-      text2 (string, range<string>, optional, repeating) ${_lt("Additional text item(s).")}
-  `),
-  returns: ["STRING"],
-  compute: function (delimiter: any, ignore_empty: any, ...texts_or_arrays: any): string {
-    const _delimiter = toString(delimiter);
-    const _ignoreEmpty = toBoolean(ignore_empty);
-    let n = 0;
-    return reduceArgs(
-      texts_or_arrays,
-      (acc, a) =>
-        !(_ignoreEmpty && toString(a) === "") ? (n++ ? acc + _delimiter : "") + toString(a) : acc,
-      ""
-    );
-  },
-};
-
-// -----------------------------------------------------------------------------
-// TRIM
-// -----------------------------------------------------------------------------
-export const TRIM: FunctionDescription = {
-  description: _lt("Removes space characters."),
-  args: args(`
-      text (string) ${_lt("The text or reference to a cell containing text to be trimmed.")}
-  `),
-  returns: ["STRING"],
-  compute: function (text: any): string {
-    return toString(text).trim();
-  },
-};
-
-// -----------------------------------------------------------------------------
-// UPPER
-// -----------------------------------------------------------------------------
-export const UPPER: FunctionDescription = {
-  description: _lt("Converts a specified string to uppercase."),
-  args: args(`
-      text (string) ${_lt("The string to convert to uppercase.")}
-  `),
-  returns: ["STRING"],
-  compute: function (text: any): string {
-    return toString(text).toUpperCase();
-  },
-};

package/src/helpers/color.ts

@@ -1,30 +0,0 @@
-export const colors = [
-  "#ff851b",
-  "#0074d9",
-  "#ffdc00",
-  "#7fdbff",
-  "#b10dc9",
-  "#0ecc40",
-  "#39cccc",
-  "#f012be",
-  "#3d9970",
-  "#111111",
-  "#01ff70",
-  "#ff4136",
-  "#aaaaaa",
-  "#85144b",
-  "#001f3f",
-];
-
-/*
- * transform a color number (R * 256^2 + G * 256 + B) into classic RGB
- * */
-export function colorNumberString(color: number): string {
-  return color.toString(16).padStart(6, "0");
-}
-
-let colorIndex = 0;
-export function getNextColor() {
-  colorIndex = ++colorIndex % colors.length;
-  return colors[colorIndex];
-}

package/src/helpers/coordinates.ts

@@ -1,71 +0,0 @@
-//------------------------------------------------------------------------------
-// Coordinate
-//------------------------------------------------------------------------------
-
-/**
- * Convert a (col) number to the corresponding letter.
- *
- * Examples:
- *     0 => 'A'
- *     25 => 'Z'
- *     26 => 'AA'
- *     27 => 'AB'
- */
-export function numberToLetters(n: number): string {
-  if (n < 26) {
-    return String.fromCharCode(65 + n);
-  } else {
-    return numberToLetters(Math.floor(n / 26) - 1) + numberToLetters(n % 26);
-  }
-}
-
-/**
- * Convert a string (describing a column) to its number value.
- *
- * Examples:
- *     'A' => 0
- *     'Z' => 25
- *     'AA' => 26
- */
-export function lettersToNumber(letters: string): number {
-  let result = 0;
-  const l = letters.length;
-  for (let i = 0; i < l; i++) {
-    let n = letters.charCodeAt(i) - 65 + (i < l - 1 ? 1 : 0);
-    result += n * 26 ** (l - i - 1);
-  }
-  return result;
-}
-
-/**
- * Convert a "XC" coordinate to cartesian coordinates.
- *
- * Examples:
- *   A1 => [0,0]
- *   B3 => [1,2]
- *
- * Note: it also accepts lowercase coordinates, but not fixed references
- */
-export function toCartesian(xc: string): [number, number] {
-  xc = xc.toUpperCase();
-  const [m, letters, numbers] = xc.match(/\$?([A-Z]*)\$?([0-9]*)/)!;
-  if (m !== xc) {
-    throw new Error(`Invalid cell description: ${xc}`);
-  }
-  const col = lettersToNumber(letters);
-  const row = parseInt(numbers, 10) - 1;
-  return [col, row];
-}
-
-/**
- * Convert from cartesian coordinate to the "XC" coordinate system.
- *
- * Examples:
- *   [0,0] => A1
- *   [1,2] => B3
- *
- * Note: it does not support fixed references
- */
-export function toXC(col: number, row: number): string {
-  return numberToLetters(col) + String(row + 1);
-}

package/src/helpers/grid_manipulation.ts

@@ -1,68 +0,0 @@
-/*
- * Contains all method to update ranges with grid_manipulation
- */
-
-import { toXC } from "./coordinates";
-import { toZone } from "./zones";
-
-export function updateRemoveColumns(range: string, columns: number[]): string | null {
-  let { left, right, top, bottom } = toZone(range);
-  columns = columns.slice().sort((a, b) => b - a);
-  for (let column of columns) {
-    if (left > column) {
-      left -= 1;
-    }
-    if (left >= column || right >= column) {
-      right -= 1;
-    }
-  }
-  if (left > right) {
-    return null;
-  }
-  return toXC(left, top) + ":" + toXC(right, bottom);
-}
-
-export function updateRemoveRows(range: string, rows: number[]): string | null {
-  let { left, right, top, bottom } = toZone(range);
-  rows = rows.slice().sort((a, b) => b - a);
-  for (let row of rows) {
-    if (top > row) {
-      top -= 1;
-    }
-    if (top >= row || bottom >= row) {
-      bottom -= 1;
-    }
-  }
-  if (top > bottom) {
-    return null;
-  }
-  return toXC(left, top) + ":" + toXC(right, bottom);
-}
-
-export function updateAddColumns(range: string, column: number, step: number): string | null {
-  let { left, right, top, bottom } = toZone(range);
-  if (left >= column) {
-    left += step;
-  }
-  if (left >= column || right >= column) {
-    right += step;
-  }
-  if (left > right) {
-    return null;
-  }
-  return toXC(left, top) + ":" + toXC(right, bottom);
-}
-
-export function updateAddRows(range: string, row: number, step: number): string | null {
-  let { left, right, top, bottom } = toZone(range);
-  if (top >= row) {
-    top += step;
-  }
-  if (top >= row || bottom >= row) {
-    bottom += step;
-  }
-  if (top > bottom) {
-    return null;
-  }
-  return toXC(left, top) + ":" + toXC(right, bottom);
-}

package/src/helpers/index.ts

@@ -1,7 +0,0 @@
-export * from "./color";
-export * from "./coordinates";
-export * from "./grid_manipulation";
-export * from "./misc";
-export * from "./numbers";
-export * from "./uuid";
-export * from "./zones";

package/src/helpers/misc.ts

@@ -1,76 +0,0 @@
-//------------------------------------------------------------------------------
-// Miscellaneous
-//------------------------------------------------------------------------------
-
-/**
- * Stringify an object, like JSON.stringify, except that the first level of keys
- * is ordered.
- */
-export function stringify(obj: any): string {
-  return JSON.stringify(obj, Object.keys(obj).sort());
-}
-
-/**
- * Deep copy arrays, plain objects and primitive values.
- * Throws an error for other types such as class instances.
- * Sparse arrays remain sparse.
- */
-export function deepCopy<T>(obj: T): T {
-  const result: any = Array.isArray(obj) ? [] : {};
-  switch (typeof obj) {
-    case "object": {
-      if (obj === null) {
-        return obj;
-      } else if (!(isPlainObject(obj) || obj instanceof Array)) {
-        throw new Error("Unsupported type: only objects and arrays are supported");
-      }
-      for (const key in obj) {
-        result[key] = deepCopy(obj[key]);
-      }
-      return result;
-    }
-    case "number":
-    case "string":
-    case "boolean":
-    case "function":
-    case "undefined":
-      return obj;
-    default:
-      throw new Error(`Unsupported type: ${typeof obj}`);
-  }
-}
-
-/**
- * Check if the object is a plain old javascript object.
- */
-function isPlainObject(obj: unknown): boolean {
-  return typeof obj === "object" && obj?.constructor === Object;
-}
-
-/**
- * Sanitize the name of a sheet, by eventually removing quotes
- * @param sheetName name of the sheet, potentially quoted with single quotes
- */
-export function getUnquotedSheetName(sheetName: string): string {
-  if (sheetName.startsWith("'")) {
-    sheetName = sheetName.slice(1, -1).replace(/''/g, "'");
-  }
-  return sheetName;
-}
-
-/**
- * Add quotes around the sheet name if it contains a space
- * @param sheetName Name of the sheet
- */
-export function getComposerSheetName(sheetName: string): string {
-  if (sheetName.includes(" ")) {
-    sheetName = `'${sheetName}'`;
-  }
-  return sheetName;
-}
-
-export function clip(val: number, min: number, max: number): number {
-  return val < min ? min : val > max ? max : val;
-}
-
-export const DEBUG: { [key: string]: any } = {};