@odoo/o-spreadsheet 1.0.1

package/src/functions/module_text.ts

@@ -0,0 +1,370 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+// 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

@@ -0,0 +1,68 @@
+/*
+ * 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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,76 @@
+//------------------------------------------------------------------------------
+// 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 } = {};