@odoo/o-spreadsheet 18.2.13 → 18.2.15

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 18.2.13
- * @date 2025-05-20T05:57:00.985Z
- * @hash 9872529
+ * @version 18.2.15
+ * @date 2025-05-30T08:45:53.952Z
+ * @hash 607492d
  */
 
 (function (exports, owl) {
@@ -4150,6 +4150,113 @@
       }
       return generateMatrix(matrix[0].length, matrix.length, (i, j) => matrix[j][i]);
   }
+  /**
+   * Enables a formula function to accept matrix or vector inputs instead of simple value, computing results across multiple dimensions.
+   *
+   * ```
+   *                    /         |‾                 ‾| \        |‾                                                    ‾|
+   *                   |          | [A]               |  |       | compute(A, D, E), compute(A, D, F), compute(A, D, G) |
+   * applyVectorization| compute, | [B], D, [E, F, G] |  |  <=>  | compute(B, D, E), compute(B, D, F), compute(B, D, G) |
+   *                   |          | [C]               |  |       | compute(C, D, E), compute(C, D, F), compute(C, D, G) |
+   *                    \         |_                 _| /        |_                                                    _|
+   * ```
+   *
+   * By default, all arguments are vectorized. To control which arguments are vectorized,
+   * pass an `acceptToVectorize` boolean array of the same length as `args`:
+   * - `true`  enables vectorization for that argument
+   * - `false` disables vectorization for that argument
+   *
+   * For example, with `[true, true, false]` on previous example you get:
+   *
+   * ```
+   * |‾                        ‾|
+   * | compute(A, D, [E, F, G]) |
+   * | compute(B, D, [E, F, G]) |
+   * | compute(C, D, [E, F, G]) |
+   * |_                        _|
+   * ```
+   *
+   * @remarks
+   * This helper is automatically applied (by default) to **all** `compute` functions
+   * across the various spreadsheet formula modules:
+   * - If an argument is declared **scalar** (not `"range"`), it is vectorized.
+   * - If **all** arguments are declared **ranges**, no vectorization occurs.
+   *   - e.g. `SUM(A1:B2)` returns a 1×1 sum over the range.
+   *   - e.g. `COS(A1:B2)` over `A1:B2` returns a 2×2 element-wise result.
+   * - For special behaviors (e.g. the `IF` function), you may declare all arguments
+   *   as ranges and invoke this helper directly within your `compute` implementation.
+   */
+  function applyVectorization(formula, args, acceptToVectorize = undefined) {
+      let countVectorizedCol = 1;
+      let countVectorizedRow = 1;
+      let vectorizedColLimit = Infinity;
+      let vectorizedRowLimit = Infinity;
+      let vectorArgsType = undefined;
+      for (let i = 0; i < args.length; i++) {
+          const arg = args[i];
+          if (isMatrix(arg) && (acceptToVectorize === undefined || acceptToVectorize[i])) {
+              const nColumns = arg.length;
+              const nRows = arg[0].length;
+              if (nColumns !== 1 || nRows !== 1) {
+                  vectorArgsType ??= new Array(args.length);
+                  if (nColumns !== 1 && nRows !== 1) {
+                      vectorArgsType[i] = "matrix";
+                      countVectorizedCol = Math.max(countVectorizedCol, nColumns);
+                      countVectorizedRow = Math.max(countVectorizedRow, nRows);
+                      vectorizedColLimit = Math.min(vectorizedColLimit, nColumns);
+                      vectorizedRowLimit = Math.min(vectorizedRowLimit, nRows);
+                  }
+                  else if (nColumns !== 1) {
+                      vectorArgsType[i] = "horizontal";
+                      countVectorizedCol = Math.max(countVectorizedCol, nColumns);
+                      vectorizedColLimit = Math.min(vectorizedColLimit, nColumns);
+                  }
+                  else if (nRows !== 1) {
+                      vectorArgsType[i] = "vertical";
+                      countVectorizedRow = Math.max(countVectorizedRow, nRows);
+                      vectorizedRowLimit = Math.min(vectorizedRowLimit, nRows);
+                  }
+              }
+              else {
+                  args[i] = arg[0][0];
+              }
+          }
+      }
+      if (countVectorizedCol === 1 && countVectorizedRow === 1) {
+          // either this function is not vectorized or it ends up with a 1x1 dimension
+          return formula(...args);
+      }
+      const getArgOffset = (i, j) => args.map((arg, index) => {
+          switch (vectorArgsType?.[index]) {
+              case "matrix":
+                  return arg[i][j];
+              case "horizontal":
+                  return arg[i][0];
+              case "vertical":
+                  return arg[0][j];
+              case undefined:
+                  return arg;
+          }
+      });
+      return generateMatrix(countVectorizedCol, countVectorizedRow, (col, row) => {
+          if (col > vectorizedColLimit - 1 || row > vectorizedRowLimit - 1) {
+              return new NotAvailableError(_t("Array arguments to [[FUNCTION_NAME]] are of different size."));
+          }
+          const singleCellComputeResult = formula(...getArgOffset(col, row));
+          // In the case where the user tries to vectorize arguments of an array formula, we will get an
+          // array for every combination of the vectorized arguments, which will lead to a 3D matrix and
+          // we won't be able to return the values.
+          // In this case, we keep the first element of each spreading part, just as Excel does, and
+          // create an array with these parts.
+          // For exemple, we have MUNIT(x) that return an unitary matrix of x*x. If we use it with a
+          // range, like MUNIT(A1:A2), we will get two unitary matrices (one for the value in A1 and one
+          // for the value in A2). In this case, we will simply take the first value of each matrix and
+          // return the array [First value of MUNIT(A1), First value of MUNIT(A2)].
+          return isMatrix(singleCellComputeResult)
+              ? singleCellComputeResult[0][0]
+              : singleCellComputeResult;
+      });
+  }
   // -----------------------------------------------------------------------------
   // CONDITIONAL EXPLORE FUNCTIONS
   // -----------------------------------------------------------------------------
@@ -7441,14 +7548,20 @@
   /**
    * Return the input if it's a scalar or the first element of the input if it's a matrix.
    */
-  function toScalar(matrix) {
-      if (!isMatrix(matrix)) {
-          return matrix;
+  function toScalar(arg) {
+      if (!isMatrix(arg)) {
+          return arg;
       }
-      if (matrix.length !== 1 || matrix[0].length !== 1) {
+      if (!isSingleElementMatrix(arg)) {
           throw new EvaluationError(_t("The value should be a scalar or a 1x1 matrix"));
       }
-      return matrix[0][0];
+      return arg[0][0];
+  }
+  function isSingleElementMatrix(matrix) {
+      return matrix.length === 1 && matrix[0].length === 1;
+  }
+  function isMultipleElementMatrix(arg) {
+      return isMatrix(arg) && !isSingleElementMatrix(arg);
   }
 
   function assertSameNumberOfElements(...args) {
@@ -8190,9 +8303,10 @@
       avg: _t("Average"),
       sum: _t("Sum"),
   };
+  const NUMBER_CHAR_AGGREGATORS = ["max", "min", "avg", "sum", "count_distinct", "count"];
   const AGGREGATORS_BY_FIELD_TYPE = {
-      integer: ["max", "min", "avg", "sum", "count_distinct", "count"],
-      char: ["count_distinct", "count"],
+      integer: NUMBER_CHAR_AGGREGATORS,
+      char: NUMBER_CHAR_AGGREGATORS,
       boolean: ["count_distinct", "count", "bool_and", "bool_or"],
       datetime: ["max", "min", "count_distinct", "count"],
   };
@@ -15456,7 +15570,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return mode === "row" ? transposeMatrix(result) : result;
       },
-      isExported: true,
+      isExported: false,
   };
   // -----------------------------------------------------------------------------
   // SORT
@@ -18587,16 +18701,23 @@ stores.inject(MyMetaStore, storeInstance);
   const IF = {
       description: _t("Returns value depending on logical expression."),
       args: [
-          arg("logical_expression (boolean)", _t("An expression or reference to a cell containing an expression that represents some logical value, i.e. TRUE or FALSE.")),
-          arg("value_if_true (any)", _t("The value the function returns if logical_expression is TRUE.")),
-          arg("value_if_false (any, default=FALSE)", _t("The value the function returns if logical_expression is FALSE.")),
+          arg("logical_expression (boolean, range<boolean>)", _t("An expression or reference to a cell containing an expression that represents some logical value, i.e. TRUE or FALSE.")),
+          arg("value_if_true (any, range)", _t("The value the function returns if logical_expression is TRUE.")),
+          arg("value_if_false (any, range, default=FALSE)", _t("The value the function returns if logical_expression is FALSE.")),
       ],
       compute: function (logicalExpression, valueIfTrue, valueIfFalse) {
-          const result = toBoolean(logicalExpression?.value) ? valueIfTrue : valueIfFalse;
+          if (isMultipleElementMatrix(logicalExpression)) {
+              return applyVectorization(IF.compute, [logicalExpression, valueIfTrue, valueIfFalse]);
+          }
+          let result = toBoolean(toScalar(logicalExpression)) ? valueIfTrue : valueIfFalse;
+          // useful for interpreting empty cell references as empty strings. But must be removed to make empty cell references equal to zero
+          if (!isMultipleElementMatrix(result)) {
+              result = toScalar(result);
+          }
           if (result === undefined) {
               return { value: "" };
           }
-          if (result.value === null) {
+          if (!isMatrix(result) && result.value === null) {
               return { ...result, value: "" };
           }
           return result;
@@ -18609,15 +18730,22 @@ stores.inject(MyMetaStore, storeInstance);
   const IFERROR = {
       description: _t("Value if it is not an error, otherwise 2nd argument."),
       args: [
-          arg("value (any)", _t("The value to return if value itself is not an error.")),
-          arg(`value_if_error (any, default="empty")`, _t("The value the function returns if value is an error.")),
+          arg("value (any, range)", _t("The value to return if value itself is not an error.")),
+          arg(`value_if_error (any, range, default="empty")`, _t("The value the function returns if value is an error.")),
       ],
-      compute: function (value, valueIfError = { value: "" }) {
-          const result = isEvaluationError(value?.value) ? valueIfError : value;
+      compute: function (value, valueIfError) {
+          if (isMultipleElementMatrix(value)) {
+              return applyVectorization(IFERROR.compute, [value, valueIfError]);
+          }
+          let result = isEvaluationError(toScalar(value)?.value) ? valueIfError : value;
+          // useful for interpreting empty cell references as empty strings. But must be removed to make empty cell references equal to zero
+          if (!isMultipleElementMatrix(result)) {
+              result = toScalar(result);
+          }
           if (result === undefined) {
               return { value: "" };
           }
-          if (result.value === null) {
+          if (!isMatrix(result) && result.value === null) {
               return { ...result, value: "" };
           }
           return result;
@@ -18630,15 +18758,22 @@ stores.inject(MyMetaStore, storeInstance);
   const IFNA = {
       description: _t("Value if it is not an #N/A error, otherwise 2nd argument."),
       args: [
-          arg("value (any)", _t("The value to return if value itself is not #N/A an error.")),
-          arg(`value_if_error (any, default="empty")`, _t("The value the function returns if value is an #N/A error.")),
+          arg("value (any, range)", _t("The value to return if value itself is not #N/A an error.")),
+          arg(`value_if_error (any, range, default="empty")`, _t("The value the function returns if value is an #N/A error.")),
       ],
-      compute: function (value, valueIfError = { value: "" }) {
-          const result = value?.value === CellErrorType.NotAvailable ? valueIfError : value;
+      compute: function (value, valueIfError) {
+          if (isMultipleElementMatrix(value)) {
+              return applyVectorization(IFNA.compute, [value, valueIfError]);
+          }
+          let result = toScalar(value)?.value === CellErrorType.NotAvailable ? valueIfError : value;
+          // useful for interpreting empty cell references as empty strings. But must be removed to make empty cell references equal to zero
+          if (!isMultipleElementMatrix(result)) {
+              result = toScalar(result);
+          }
           if (result === undefined) {
               return { value: "" };
           }
-          if (result.value === null) {
+          if (!isMatrix(result) && result.value === null) {
               return { ...result, value: "" };
           }
           return result;
@@ -18651,23 +18786,31 @@ stores.inject(MyMetaStore, storeInstance);
   const IFS = {
       description: _t("Returns a value depending on multiple logical expressions."),
       args: [
-          arg("condition1 (boolean)", _t("The first condition to be evaluated. This can be a boolean, a number, an array, or a reference to any of those.")),
-          arg("value1 (any)", _t("The returned value if condition1 is TRUE.")),
-          arg("condition2 (boolean, any, repeating)", _t("Additional conditions to be evaluated if the previous ones are FALSE.")),
-          arg("value2 (any, repeating)", _t("Additional values to be returned if their corresponding conditions are TRUE.")),
+          arg("condition1 (boolean, range<boolean>)", _t("The first condition to be evaluated. This can be a boolean, a number, an array, or a reference to any of those.")),
+          arg("value1 (any, range)", _t("The returned value if condition1 is TRUE.")),
+          arg("condition2 (boolean, any, range, repeating)", _t("Additional conditions to be evaluated if the previous ones are FALSE.")),
+          arg("value2 (any, range, repeating)", _t("Additional values to be returned if their corresponding conditions are TRUE.")),
       ],
       compute: function (...values) {
           assert(() => values.length % 2 === 0, _t("Wrong number of arguments. Expected an even number of arguments."));
-          for (let n = 0; n < values.length - 1; n += 2) {
-              if (toBoolean(values[n]?.value)) {
-                  const result = values[n + 1];
-                  if (result === undefined) {
+          while (values.length > 0) {
+              if (isMultipleElementMatrix(values[0])) {
+                  return applyVectorization(IFS.compute, values);
+              }
+              const condition = toBoolean(toScalar(values.shift()));
+              let valueIfTrue = values.shift();
+              if (condition) {
+                  // useful for interpreting empty cell references as empty strings. But must be removed to make empty cell references equal to zero
+                  if (!isMultipleElementMatrix(valueIfTrue)) {
+                      valueIfTrue = toScalar(valueIfTrue);
+                  }
+                  if (valueIfTrue === undefined) {
                       return { value: "" };
                   }
-                  if (result.value === null) {
-                      return { ...result, value: "" };
+                  if (!isMatrix(valueIfTrue) && valueIfTrue.value === null) {
+                      return { ...valueIfTrue, value: "" };
                   }
-                  return result;
+                  return valueIfTrue;
               }
           }
           return new EvaluationError(_t("No match."));
@@ -20329,7 +20472,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return transposeMatrix([result]);
       },
-      isExported: true,
+      isExported: false,
   };
   // -----------------------------------------------------------------------------
   // SUBSTITUTE
@@ -20522,86 +20665,21 @@ stores.inject(MyMetaStore, storeInstance);
           functionRegistry.add(name, { isExported: false, ...addDescr });
       }
   }
-  const notAvailableError = new NotAvailableError(_t("Array arguments to [[FUNCTION_NAME]] are of different size."));
+  //------------------------------------------------------------------------------
+  // CREATE COMPUTE FUNCTION
+  //------------------------------------------------------------------------------
   function createComputeFunction(descr, functionName) {
       function vectorizedCompute(...args) {
-          let countVectorizableCol = 1;
-          let countVectorizableRow = 1;
-          let vectorizableColLimit = Infinity;
-          let vectorizableRowLimit = Infinity;
-          let vectorArgsType = undefined;
-          //#region Compute vectorisation limits
+          const acceptToVectorize = [];
           for (let i = 0; i < args.length; i++) {
               const argDefinition = descr.args[descr.getArgToFocus(i + 1) - 1];
               const arg = args[i];
-              if (isMatrix(arg) && !argDefinition.acceptMatrix) {
-                  // if argDefinition does not accept a matrix but arg is still a matrix
-                  // --> triggers the arguments vectorization
-                  const nColumns = arg.length;
-                  const nRows = arg[0].length;
-                  if (nColumns !== 1 || nRows !== 1) {
-                      vectorArgsType ??= new Array(args.length);
-                      if (nColumns !== 1 && nRows !== 1) {
-                          vectorArgsType[i] = "matrix";
-                          countVectorizableCol = Math.max(countVectorizableCol, nColumns);
-                          countVectorizableRow = Math.max(countVectorizableRow, nRows);
-                          vectorizableColLimit = Math.min(vectorizableColLimit, nColumns);
-                          vectorizableRowLimit = Math.min(vectorizableRowLimit, nRows);
-                      }
-                      else if (nColumns !== 1) {
-                          vectorArgsType[i] = "horizontal";
-                          countVectorizableCol = Math.max(countVectorizableCol, nColumns);
-                          vectorizableColLimit = Math.min(vectorizableColLimit, nColumns);
-                      }
-                      else if (nRows !== 1) {
-                          vectorArgsType[i] = "vertical";
-                          countVectorizableRow = Math.max(countVectorizableRow, nRows);
-                          vectorizableRowLimit = Math.min(vectorizableRowLimit, nRows);
-                      }
-                  }
-                  else {
-                      args[i] = arg[0][0];
-                  }
-              }
               if (!isMatrix(arg) && argDefinition.acceptMatrixOnly) {
                   throw new BadExpressionError(_t("Function %s expects the parameter '%s' to be reference to a cell or range.", functionName, (i + 1).toString()));
               }
+              acceptToVectorize.push(!argDefinition.acceptMatrix);
           }
-          //#endregion
-          if (countVectorizableCol === 1 && countVectorizableRow === 1) {
-              // either this function is not vectorized or it ends up with a 1x1 dimension
-              return errorHandlingCompute.apply(this, args);
-          }
-          const getArgOffset = (i, j) => args.map((arg, index) => {
-              switch (vectorArgsType?.[index]) {
-                  case "matrix":
-                      return arg[i][j];
-                  case "horizontal":
-                      return arg[i][0];
-                  case "vertical":
-                      return arg[0][j];
-                  case undefined:
-                      return arg;
-              }
-          });
-          return generateMatrix(countVectorizableCol, countVectorizableRow, (col, row) => {
-              if (col > vectorizableColLimit - 1 || row > vectorizableRowLimit - 1) {
-                  return notAvailableError;
-              }
-              const singleCellComputeResult = errorHandlingCompute.apply(this, getArgOffset(col, row));
-              // In the case where the user tries to vectorize arguments of an array formula, we will get an
-              // array for every combination of the vectorized arguments, which will lead to a 3D matrix and
-              // we won't be able to return the values.
-              // In this case, we keep the first element of each spreading part, just as Excel does, and
-              // create an array with these parts.
-              // For exemple, we have MUNIT(x) that return an unitary matrix of x*x. If we use it with a
-              // range, like MUNIT(A1:A2), we will get two unitary matrices (one for the value in A1 and one
-              // for the value in A2). In this case, we will simply take the first value of each matrix and
-              // return the array [First value of MUNIT(A1), First value of MUNIT(A2)].
-              return isMatrix(singleCellComputeResult)
-                  ? singleCellComputeResult[0][0]
-                  : singleCellComputeResult;
-          });
+          return applyVectorization(errorHandlingCompute.bind(this), args, acceptToVectorize);
       }
       function errorHandlingCompute(...args) {
           for (let i = 0; i < args.length; i++) {
@@ -21446,7 +21524,7 @@ stores.inject(MyMetaStore, storeInstance);
                   proposals &&
                   !["ARG_SEPARATOR", "LEFT_PAREN", "OPERATOR"].includes(tokenAtCursor.type)) {
                   const filteredProposals = fuzzyLookup(searchTerm, proposals, (p) => p.fuzzySearchKey || p.text);
-                  if (!exactMatch || filteredProposals.length > 1) {
+                  if (!exactMatch || filteredProposals.length) {
                       proposals = filteredProposals;
                   }
               }
@@ -46482,7 +46560,9 @@ stores.inject(MyMetaStore, storeInstance);
           return dimension.order === "asc" ? -1 : 1;
       }
       if (dimension.type === "integer" || dimension.type === "datetime") {
-          return dimension.order === "asc" ? Number(a) - Number(b) : Number(b) - Number(a);
+          return dimension.order === "asc"
+              ? toNumber(a, DEFAULT_LOCALE) - toNumber(b, DEFAULT_LOCALE)
+              : toNumber(b, DEFAULT_LOCALE) - toNumber(a, DEFAULT_LOCALE);
       }
       return dimension.order === "asc" ? a.localeCompare(b) : b.localeCompare(a);
   }
@@ -47016,12 +47096,7 @@ stores.inject(MyMetaStore, storeInstance);
                       entry[field.name] = { value: null, type: CellValueType.empty, formattedValue: "" };
                   }
                   else {
-                      if (field.type === "char") {
-                          entry[field.name] = { ...cell, value: cell.formattedValue || null };
-                      }
-                      else {
-                          entry[field.name] = cell;
-                      }
+                      entry[field.name] = cell;
                   }
               }
               entry["__count"] = { value: 1, type: CellValueType.number, formattedValue: "1" };
@@ -49245,8 +49320,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (!spreader) {
               return undefined;
           }
-          const cell = this.getters.getCell(spreader);
-          return cell?.content;
+          return this.getters.getCellText(spreader, { showFormula: true });
       }
       get currentEditedCell() {
           return {
@@ -52167,6 +52241,7 @@ stores.inject(MyMetaStore, storeInstance);
   const friction = 0.95;
   const verticalScrollFactor = 1;
   const horizontalScrollFactor = 1;
+  const resetTimeoutDuration = 100;
   function useTouchScroll(ref, updateScroll, canMoveUp) {
       let lastX = 0;
       let lastY = 0;
@@ -52174,6 +52249,7 @@ stores.inject(MyMetaStore, storeInstance);
       let velocityY = 0;
       let isMouseDown = false;
       let lastTime = 0;
+      let resetTimeout = null;
       useRefListener(ref, "touchstart", onTouchStart, { capture: false });
       useRefListener(ref, "touchmove", onTouchMove, { capture: false });
       useRefListener(ref, "touchend", onTouchEnd, { capture: false });
@@ -52186,6 +52262,10 @@ stores.inject(MyMetaStore, storeInstance);
       function onTouchMove(event) {
           if (!isMouseDown)
               return;
+          if (resetTimeout) {
+              clearTimeout(resetTimeout);
+              resetTimeout = null;
+          }
           const currentTime = Date.now();
           const { clientX, clientY } = event.touches[0];
           let deltaX = lastX - clientX;
@@ -52202,6 +52282,10 @@ stores.inject(MyMetaStore, storeInstance);
               }
               event.stopPropagation();
           }
+          resetTimeout = setTimeout(() => {
+              velocityX = 0;
+              velocityY = 0;
+          }, resetTimeoutDuration);
           updateScroll(deltaX * horizontalScrollFactor, deltaY * verticalScrollFactor);
       }
       function onTouchEnd(ev) {
@@ -76826,9 +76910,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.2.13";
-  __info__.date = "2025-05-20T05:57:00.985Z";
-  __info__.hash = "9872529";
+  __info__.version = "18.2.15";
+  __info__.date = "2025-05-30T08:45:53.952Z";
+  __info__.hash = "607492d";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);