@odoo/o-spreadsheet 18.2.13 → 18.2.15

package/dist/o-spreadsheet.cjs.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
  */
 
 'use strict';
@@ -4151,6 +4151,113 @@ function transposeMatrix(matrix) {
     }
     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
 // -----------------------------------------------------------------------------
@@ -7442,14 +7549,20 @@ function multiplyMatrices(matrix1, matrix2) {
 /**
  * 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) {
@@ -8191,9 +8304,10 @@ const AGGREGATOR_NAMES = {
     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"],
 };
@@ -15457,7 +15571,7 @@ const FILTER = {
         }
         return mode === "row" ? transposeMatrix(result) : result;
     },
-    isExported: true,
+    isExported: false,
 };
 // -----------------------------------------------------------------------------
 // SORT
@@ -18588,16 +18702,23 @@ const FALSE = {
 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;
@@ -18610,15 +18731,22 @@ const IF = {
 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;
@@ -18631,15 +18759,22 @@ const IFERROR = {
 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;
@@ -18652,23 +18787,31 @@ const IFNA = {
 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."));
@@ -20330,7 +20473,7 @@ const SPLIT = {
         }
         return transposeMatrix([result]);
     },
-    isExported: true,
+    isExported: false,
 };
 // -----------------------------------------------------------------------------
 // SUBSTITUTE
@@ -20523,86 +20666,21 @@ for (let category of categories) {
         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++) {
@@ -21447,7 +21525,7 @@ class AbstractComposerStore extends SpreadsheetStore {
                 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;
                 }
             }
@@ -46483,7 +46561,9 @@ function compareDimensionValues(dimension, a, b) {
         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);
 }
@@ -47017,12 +47097,7 @@ class SpreadsheetPivot {
                     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" };
@@ -49246,8 +49321,7 @@ class CellComposerStore extends AbstractComposerStore {
         if (!spreader) {
             return undefined;
         }
-        const cell = this.getters.getCell(spreader);
-        return cell?.content;
+        return this.getters.getCellText(spreader, { showFormula: true });
     }
     get currentEditedCell() {
         return {
@@ -52168,6 +52242,7 @@ function useGridDrawing(refName, model, canvasSize) {
 const friction = 0.95;
 const verticalScrollFactor = 1;
 const horizontalScrollFactor = 1;
+const resetTimeoutDuration = 100;
 function useTouchScroll(ref, updateScroll, canMoveUp) {
     let lastX = 0;
     let lastY = 0;
@@ -52175,6 +52250,7 @@ function useTouchScroll(ref, updateScroll, canMoveUp) {
     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 });
@@ -52187,6 +52263,10 @@ function useTouchScroll(ref, updateScroll, canMoveUp) {
     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;
@@ -52203,6 +52283,10 @@ function useTouchScroll(ref, updateScroll, canMoveUp) {
             }
             event.stopPropagation();
         }
+        resetTimeout = setTimeout(() => {
+            velocityX = 0;
+            velocityY = 0;
+        }, resetTimeoutDuration);
         updateScroll(deltaX * horizontalScrollFactor, deltaY * verticalScrollFactor);
     }
     function onTouchEnd(ev) {
@@ -76827,6 +76911,6 @@ exports.tokenColors = tokenColors;
 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";