@odoo/o-spreadsheet 17.4.0-alpha.12 → 17.4.0-alpha.13

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 17.4.0-alpha.12
- * @date 2024-07-08T05:43:07.933Z
- * @hash 7cfe14a
+ * @version 17.4.0-alpha.13
+ * @date 2024-07-11T06:36:58.556Z
+ * @hash e0f506b
  */
 
 (function (exports, owl) {
@@ -591,7 +591,7 @@
   /**
    * Compares two objects.
    */
-  function deepEquals(o1, o2, ignoreFunctions) {
+  function deepEquals(o1, o2) {
       if (o1 === o2)
           return true;
       if ((o1 && !o2) || (o2 && !o1))
@@ -607,17 +607,13 @@
           }
       }
       for (const key in o1) {
-          const typeOfO1Key = typeof o1[key];
-          if (typeOfO1Key !== typeof o2[key])
+          if (typeof o1[key] !== typeof o2[key])
               return false;
-          if (typeOfO1Key === "object") {
-              if (!deepEquals(o1[key], o2[key], ignoreFunctions))
+          if (typeof o1[key] === "object") {
+              if (!deepEquals(o1[key], o2[key]))
                   return false;
           }
           else {
-              if (ignoreFunctions && typeOfO1Key === "function") {
-                  continue;
-              }
               if (o1[key] !== o2[key])
                   return false;
           }
@@ -2640,11 +2636,11 @@
       }
       return returned;
   }
-  function matrixMap(matrix, fn) {
+  function matrixMap(matrix, callback) {
       if (matrix.length === 0) {
           return [];
       }
-      return generateMatrix(matrix.length, matrix[0].length, (col, row) => fn(matrix[col][row]));
+      return generateMatrix(matrix.length, matrix[0].length, (col, row) => callback(matrix[col][row]));
   }
   function matrixForEach(matrix, fn) {
       const numberOfCols = matrix.length;
@@ -2744,6 +2740,9 @@
    * If the character is a special regular expression character, it is escaped with "\\".
    */
   const wildcardToRegExp = memoize(function wildcardToRegExp(operand) {
+      if (operand === "*") {
+          return /.+/;
+      }
       let exp = "";
       let predecessor = "";
       for (let char of operand) {
@@ -2767,9 +2766,9 @@
       }
       return new RegExp("^" + exp + "$", "i");
   });
-  function evaluatePredicate(value, criterion) {
+  function evaluatePredicate(value = "", criterion) {
       const { operator, operand } = criterion;
-      if (value === undefined || operand === undefined || value === null || operand === null) {
+      if (operand === undefined || value === null || operand === null) {
           return false;
       }
       if (typeof operand === "number" && operator === "=") {
@@ -8072,8 +8071,8 @@
 
   function evaluateLiteral(literalCell, localeFormat) {
       const value = localeFormat.format === PLAIN_TEXT_FORMAT ? literalCell.content : literalCell.parsedValue;
-      const fPayload = { value, format: localeFormat.format };
-      return createEvaluatedCell(fPayload, localeFormat.locale);
+      const functionResult = { value, format: localeFormat.format };
+      return createEvaluatedCell(functionResult, localeFormat.locale);
   }
   function parseLiteral(content, locale) {
       if (content.startsWith("=")) {
@@ -8094,13 +8093,13 @@
       }
       return content;
   }
-  function createEvaluatedCell(fPayload, locale = DEFAULT_LOCALE, cell) {
-      const link = detectLink(fPayload.value);
+  function createEvaluatedCell(functionResult, locale = DEFAULT_LOCALE, cell) {
+      const link = detectLink(functionResult.value);
       if (!link) {
-          return _createEvaluatedCell(fPayload, locale, cell);
+          return _createEvaluatedCell(functionResult, locale, cell);
       }
       const value = parseLiteral(link.label, locale);
-      const format = fPayload.format ||
+      const format = functionResult.format ||
           (typeof value === "number"
               ? detectDateFormat(link.label, locale) || detectNumberFormat(link.label)
               : undefined);
@@ -8113,8 +8112,8 @@
           link,
       };
   }
-  function _createEvaluatedCell(fPayload, locale, cell) {
-      let { value, format, message } = fPayload;
+  function _createEvaluatedCell(functionResult, locale, cell) {
+      let { value, format, message } = functionResult;
       format = cell?.format || format;
       const formattedValue = formatValue(value, { format, locale });
       if (isEvaluationError(value)) {
@@ -10301,7 +10300,6 @@ stores.inject(MyMetaStore, storeInstance);
       return bars.find((bar, i) => i > startIndex && bar.height !== 0);
   }
 
-  // @ts-ignore
   window.Chart?.register(waterfallLinesPlugin);
   class ChartJsComponent extends owl.Component {
       static template = "o-spreadsheet-ChartJsComponent";
@@ -10334,7 +10332,7 @@ stores.inject(MyMetaStore, storeInstance);
           owl.onWillUnmount(() => this.chart?.destroy());
           owl.useEffect(() => {
               const runtime = this.chartRuntime;
-              if (!deepEquals(runtime, this.currentRuntime, "ignoreFunctions")) {
+              if (runtime !== this.currentRuntime) {
                   if (runtime.chartJsConfig.type !== this.currentRuntime.chartJsConfig.type) {
                       this.chart?.destroy();
                       this.createChart(deepCopy(runtime.chartJsConfig));
@@ -10349,7 +10347,6 @@ stores.inject(MyMetaStore, storeInstance);
       createChart(chartData) {
           const canvas = this.canvas.el;
           const ctx = canvas.getContext("2d");
-          // @ts-ignore
           this.chart = new window.Chart(ctx, chartData);
       }
       updateChartJs(chartRuntime) {
@@ -19101,7 +19098,7 @@ stores.inject(MyMetaStore, storeInstance);
           arg("include_column_titles (boolean, default=TRUE)", _t("Whether to include the column titles or not.")),
           arg("column_count (number, optional)", _t("number of columns")),
       ],
-      compute: function (pivotFormulaId, rowCount = { value: Number.MAX_VALUE }, includeTotal = { value: true }, includeColumnHeaders = { value: true }, columnCount = { value: Number.MAX_VALUE }) {
+      compute: function (pivotFormulaId, rowCount = { value: 10000 }, includeTotal = { value: true }, includeColumnHeaders = { value: true }, columnCount = { value: Number.MAX_VALUE }) {
           const _pivotFormulaId = toString(pivotFormulaId);
           const _rowCount = toNumber(rowCount, this.locale);
           if (_rowCount < 0) {
@@ -19525,6 +19522,320 @@ stores.inject(MyMetaStore, storeInstance);
     UPLUS: UPLUS
   });
 
+  const transformFromFactor = (factor) => ({
+      transform: (x) => x * factor,
+      inverseTransform: (x) => x / factor,
+  });
+  const standard = { transform: (x) => x, inverseTransform: (x) => x };
+  const ANG2M = 1e-10;
+  const IN2M = 0.0254;
+  const PICAPT2M = IN2M / 72;
+  const FT2M = 0.3048;
+  const YD2M = 0.9144;
+  const MI2M = 1609.34;
+  const NMI2M = 1852;
+  const LY2M = 9.46073047258e15;
+  const UNITS = {
+      // WEIGHT UNITs : Standard = gramme
+      g: { ...standard, category: "weight" },
+      u: { ...transformFromFactor(1.66053e-24), category: "weight" },
+      grain: { ...transformFromFactor(0.0647989), category: "weight" },
+      ozm: { ...transformFromFactor(28.3495), category: "weight" },
+      lbm: { ...transformFromFactor(453.592), category: "weight" },
+      stone: { ...transformFromFactor(6350.29), category: "weight" },
+      sg: { ...transformFromFactor(14593.90294), category: "weight" },
+      cwt: { ...transformFromFactor(45359.237), category: "weight" },
+      uk_cwt: { ...transformFromFactor(50802.3), category: "weight" },
+      ton: { ...transformFromFactor(907184.74), category: "weight" },
+      uk_ton: { ...transformFromFactor(1016046.9), category: "weight" },
+      // DISTANCE UNITS : Standard = meter
+      m: { ...standard, category: "distance" },
+      km: { ...transformFromFactor(1000), category: "distance" },
+      ang: { ...transformFromFactor(ANG2M), category: "distance" },
+      Picapt: { ...transformFromFactor(PICAPT2M), category: "distance" },
+      pica: { ...transformFromFactor(IN2M / 6), category: "distance" },
+      in: { ...transformFromFactor(IN2M), category: "distance" },
+      ft: { ...transformFromFactor(FT2M), category: "distance" },
+      yd: { ...transformFromFactor(YD2M), category: "distance" },
+      ell: { ...transformFromFactor(1.143), category: "distance" },
+      mi: { ...transformFromFactor(MI2M), category: "distance" },
+      survey_mi: { ...transformFromFactor(1609.34), category: "distance" },
+      Nmi: { ...transformFromFactor(NMI2M), category: "distance" },
+      ly: { ...transformFromFactor(LY2M), category: "distance" },
+      parsec: { ...transformFromFactor(3.0856775814914e16), category: "distance" },
+      // TIME UNITS : Standard = second
+      sec: { ...standard, category: "time" },
+      min: { ...transformFromFactor(60), category: "time" },
+      hr: { ...transformFromFactor(3600), category: "time" },
+      day: { ...transformFromFactor(86400), category: "time" },
+      yr: { ...transformFromFactor(31556952), category: "time" },
+      // PRESSURE UNITS : Standard = Pascal
+      Pa: { ...standard, category: "pressure" },
+      bar: { ...transformFromFactor(100000), category: "pressure" },
+      mmHg: { ...transformFromFactor(133.322), category: "pressure" },
+      Torr: { ...transformFromFactor(133.322), category: "pressure" },
+      psi: { ...transformFromFactor(6894.76), category: "pressure" },
+      atm: { ...transformFromFactor(101325), category: "pressure" },
+      // FORCE UNITS : Standard = Newton
+      N: { ...standard, category: "force" },
+      dyn: { ...transformFromFactor(1e-5), category: "force" },
+      pond: { ...transformFromFactor(0.00980665), category: "force" },
+      lbf: { ...transformFromFactor(4.44822), category: "force" },
+      // ENERGY UNITS : Standard = Joule
+      J: { ...standard, category: "energy" },
+      eV: { ...transformFromFactor(1.60218e-19), category: "energy" },
+      e: { ...transformFromFactor(1e-7), category: "energy" },
+      flb: { ...transformFromFactor(1.3558179483), category: "energy" },
+      c: { ...transformFromFactor(4.184), category: "energy" },
+      cal: { ...transformFromFactor(4.1868), category: "energy" },
+      BTU: { ...transformFromFactor(1055.06), category: "energy" },
+      Wh: { ...transformFromFactor(3600), category: "energy" },
+      HPh: { ...transformFromFactor(2684520), category: "energy" },
+      // POWER UNITS : Standard = Watt
+      W: { ...standard, category: "power" },
+      PS: { ...transformFromFactor(735.499), category: "power" },
+      HP: { ...transformFromFactor(745.7), category: "power" },
+      // MAGNETISM UNITS : Standard = Tesla
+      T: { ...standard, category: "magnetism" },
+      ga: { ...transformFromFactor(1e-4), category: "magnetism" },
+      // TEMPERATURE UNITS : Standard = Kelvin
+      K: { ...standard, category: "temperature" },
+      C: {
+          transform: (T) => T + 273.15,
+          inverseTransform: (T) => T - 273.15,
+          category: "temperature",
+      },
+      F: {
+          transform: (T) => ((T - 32) * 5) / 9 + 273.15,
+          inverseTransform: (T) => ((T - 273.15) * 9) / 5 + 32,
+          category: "temperature",
+      },
+      Rank: { ...transformFromFactor(5 / 9), category: "temperature" },
+      Reau: {
+          transform: (T) => T * 1.25 + 273.15,
+          inverseTransform: (T) => (T - 273.15) / 1.25,
+          category: "temperature",
+      },
+      // VOLUME UNITS : Standard = cubic meter
+      "m^3": { ...standard, category: "volume", order: 3 },
+      "ang^3": { ...transformFromFactor(Math.pow(ANG2M, 3)), category: "volume", order: 3 },
+      "Picapt^3": { ...transformFromFactor(Math.pow(PICAPT2M, 3)), category: "volume", order: 3 },
+      tsp: { ...transformFromFactor(4.92892e-6), category: "volume" },
+      tspm: { ...transformFromFactor(5e-6), category: "volume" },
+      tbs: { ...transformFromFactor(1.4786764825785619e-5), category: "volume" },
+      "in^3": { ...transformFromFactor(Math.pow(IN2M, 3)), category: "volume", order: 3 },
+      oz: { ...transformFromFactor(2.95735295625e-5), category: "volume" },
+      cup: { ...transformFromFactor(0.000237), category: "volume" },
+      pt: { ...transformFromFactor(0.0004731765), category: "volume" },
+      uk_pt: { ...transformFromFactor(0.000568261), category: "volume" },
+      qt: { ...transformFromFactor(0.0009463529), category: "volume" },
+      l: { ...transformFromFactor(1e-3), category: "volume" },
+      uk_qt: { ...transformFromFactor(0.0011365225), category: "volume" },
+      gal: { ...transformFromFactor(0.0037854118), category: "volume" },
+      uk_gal: { ...transformFromFactor(0.00454609), category: "volume" },
+      "ft^3": { ...transformFromFactor(Math.pow(FT2M, 3)), category: "volume", order: 3 },
+      bushel: { ...transformFromFactor(0.0352390704), category: "volume" },
+      barrel: { ...transformFromFactor(0.158987295), category: "volume" },
+      "yd^3": { ...transformFromFactor(Math.pow(YD2M, 3)), category: "volume", order: 3 },
+      MTON: { ...transformFromFactor(1.13267386368), category: "volume" },
+      GRT: { ...transformFromFactor(2.83168), category: "volume" },
+      "mi^3": { ...transformFromFactor(Math.pow(MI2M, 3)), category: "volume", order: 3 },
+      "Nmi^3": { ...transformFromFactor(Math.pow(NMI2M, 3)), category: "volume", order: 3 },
+      "ly^3": { ...transformFromFactor(Math.pow(LY2M, 3)), category: "volume", order: 3 },
+      // AREA UNITS : Standard = square meter
+      "m^2": { ...standard, category: "area", order: 2 },
+      "ang^2": { ...transformFromFactor(Math.pow(ANG2M, 2)), category: "area", order: 2 },
+      "Picapt^2": { ...transformFromFactor(Math.pow(PICAPT2M, 2)), category: "area", order: 2 },
+      "in^2": { ...transformFromFactor(Math.pow(IN2M, 2)), category: "area", order: 2 },
+      "ft^2": { ...transformFromFactor(Math.pow(FT2M, 2)), category: "area", order: 2 },
+      "yd^2": { ...transformFromFactor(Math.pow(YD2M, 2)), category: "area", order: 2 },
+      ar: { ...transformFromFactor(100), category: "area" },
+      Morgen: { ...transformFromFactor(2500), category: "area" },
+      uk_acre: { ...transformFromFactor(4046.8564224), category: "area" },
+      us_acre: { ...transformFromFactor(4046.8726098743), category: "area" },
+      ha: { ...transformFromFactor(1e4), category: "area" },
+      "mi^2": { ...transformFromFactor(Math.pow(MI2M, 2)), category: "area", order: 2 },
+      "Nmi^2": { ...transformFromFactor(Math.pow(NMI2M, 2)), category: "area", order: 2 },
+      "ly^2": { ...transformFromFactor(Math.pow(LY2M, 2)), category: "area", order: 2 },
+      // INFORMATION UNITS : Standard = bit
+      bit: { ...standard, category: "information" },
+      byte: { ...transformFromFactor(8), category: "information" },
+      // SPEED UNITS : Standard = m/s
+      "m/s": { ...standard, category: "speed" },
+      "m/hr": { ...transformFromFactor(1 / 3600), category: "speed" },
+      "km/hr": { ...transformFromFactor(1 / 3.6), category: "speed" },
+      mph: { ...transformFromFactor(0.44704), category: "speed" },
+      kn: { ...transformFromFactor(0.5144444444), category: "speed" },
+      admkn: { ...transformFromFactor(0.5147733333), category: "speed" },
+  };
+  const UNITS_ALIASES = {
+      shweight: "cwt",
+      lcwt: "uk_cwt",
+      hweight: "uk_cwt",
+      LTON: "uk_ton",
+      brton: "uk_ton",
+      pc: "parsec",
+      Pica: "Picapt",
+      d: "day",
+      mn: "min",
+      s: "sec",
+      p: "Pa",
+      at: "atm",
+      dy: "dyn",
+      ev: "eV",
+      hh: "HPh",
+      wh: "Wh",
+      btu: "BTU",
+      h: "HP",
+      cel: "C",
+      fah: "F",
+      kel: "K",
+      us_pt: "pt",
+      L: "l",
+      lt: "l",
+      ang3: "ang^3",
+      ft3: "ft^3",
+      in3: "in^3",
+      ly3: "ly^3",
+      m3: "m^3",
+      mi3: "mi^3",
+      yd3: "yd^3",
+      Nmi3: "Nmi^3",
+      Picapt3: "Picapt^3",
+      "Pica^3": "Picapt^3",
+      Pica3: "Picapt^3",
+      regton: "GRT",
+      ang2: "ang^2",
+      ft2: "ft^2",
+      in2: "in^2",
+      ly2: "ly^2",
+      m2: "m^2",
+      mi2: "mi^2",
+      Nmi2: "Nmi^2",
+      Picapt2: "Picapt^2",
+      "Pica^2": "Picapt^2",
+      Pica2: "Picapt^2",
+      yd2: "yd^2",
+      "m/h": "m/hr",
+      "m/sec": "m/s",
+  };
+  const UNIT_PREFIXES = {
+      "": 1,
+      Y: 1e24,
+      Z: 1e21,
+      E: 1e18,
+      P: 1e15,
+      T: 1e12,
+      G: 1e9,
+      M: 1e6,
+      k: 1e3,
+      h: 1e2,
+      da: 1e1,
+      e: 1e1,
+      d: 1e-1,
+      c: 1e-2,
+      m: 1e-3,
+      u: 1e-6,
+      n: 1e-9,
+      p: 1e-12,
+      f: 1e-15,
+      a: 1e-18,
+      z: 1e-21,
+      y: 1e-21,
+      Yi: Math.pow(2, 80),
+      Zi: Math.pow(2, 70),
+      Ei: Math.pow(2, 60),
+      Pi: Math.pow(2, 50),
+      Ti: Math.pow(2, 40),
+      Gi: Math.pow(2, 30),
+      Mi: Math.pow(2, 20),
+      ki: Math.pow(2, 10),
+  };
+  const TRANSLATED_CATEGORIES = {
+      weight: _t("Weight"),
+      distance: _t("Distance"),
+      time: _t("Time"),
+      pressure: _t("Pressure"),
+      force: _t("Force"),
+      energy: _t("Energy"),
+      power: _t("Power"),
+      magnetism: _t("Magnetism"),
+      temperature: _t("Temperature"),
+      volume: _t("Volume"),
+      area: _t("Area"),
+      information: _t("Information"),
+      speed: _t("Speed"),
+  };
+  function getTranslatedCategory(key) {
+      return TRANSLATED_CATEGORIES[key] ?? "";
+  }
+  function getTransformation(key) {
+      for (const [prefix, value] of Object.entries(UNIT_PREFIXES)) {
+          if (prefix && !key.startsWith(prefix))
+              continue;
+          const _key = key.slice(prefix.length);
+          let conversion = UNITS[_key];
+          if (!conversion && UNITS_ALIASES[_key]) {
+              conversion = UNITS[UNITS_ALIASES[_key]];
+          }
+          if (conversion) {
+              return {
+                  ...conversion,
+                  factor: conversion.order ? Math.pow(value, conversion.order) : value,
+              };
+          }
+      }
+      return;
+  }
+
+  // -----------------------------------------------------------------------------
+  // CONVERT
+  // -----------------------------------------------------------------------------
+  const CONVERT = {
+      description: _t("Converts a numeric value to a different unit of measure."),
+      args: [
+          arg("value (number)", _t("the numeric value in start_unit to convert to end_unit")),
+          arg("start_unit (string)", _t("The starting unit, the unit currently assigned to value")),
+          arg("end_unit (string)", _t("The unit of measure into which to convert value")),
+      ],
+      compute: function (value, startUnit, endUnit) {
+          const _value = toNumber(value, this.locale);
+          const _startUnit = toString(startUnit);
+          const _endUnit = toString(endUnit);
+          const startConversion = getTransformation(_startUnit);
+          const endConversion = getTransformation(_endUnit);
+          if (!startConversion) {
+              return {
+                  value: CellErrorType.GenericError,
+                  message: _t("Invalid units of measure ('%s')", _startUnit),
+              };
+          }
+          if (!endConversion) {
+              return {
+                  value: CellErrorType.GenericError,
+                  message: _t("Invalid units of measure ('%s')", _endUnit),
+              };
+          }
+          if (startConversion.category !== endConversion.category) {
+              return {
+                  value: CellErrorType.GenericError,
+                  message: _t("Incompatible units of measure ('%s' vs '%s')", getTranslatedCategory(startConversion.category), getTranslatedCategory(endConversion.category)),
+              };
+          }
+          return {
+              value: endConversion.inverseTransform(startConversion.factor * startConversion.transform(_value)) /
+                  endConversion.factor,
+              format: value?.format,
+          };
+      },
+      isExported: true,
+  };
+
+  var parser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CONVERT: CONVERT
+  });
+
   const DEFAULT_STARTING_AT = 1;
   /** Regex matching all the words in a string */
   const wordRegex = /[A-Za-zÀ-ÖØ-öø-ÿ]+/g;
@@ -19942,6 +20253,7 @@ stores.inject(MyMetaStore, storeInstance);
       { name: _t("Text"), functions: text },
       { name: _t("Engineering"), functions: engineering },
       { name: _t("Web"), functions: web },
+      { name: _t("Parser"), functions: parser },
   ];
   const functionNameRegex = /^[A-Z0-9\_\.]+$/;
   class FunctionRegistry extends Registry {
@@ -19953,41 +20265,127 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const descr = addMetaInfoFromArg(addDescr);
           validateArguments(descr.args);
-          this.mapping[name] = addErrorHandling(addResultHandling(addInputHandling(descr), name), name);
+          this.mapping[name] = createComputeFunction(descr, name);
           super.add(name, descr);
           return this;
       }
   }
-  function addInputHandling(descr) {
-      function computeWithInputHandling(...args) {
+  const functionRegistry = new FunctionRegistry();
+  for (let category of categories) {
+      const fns = category.functions;
+      for (let name in fns) {
+          const addDescr = fns[name];
+          addDescr.category = addDescr.category || category.name;
+          name = name.replace(/_/g, ".");
+          functionRegistry.add(name, { isExported: false, ...addDescr });
+      }
+  }
+  const notAvailableError = new NotAvailableError(_t("Array arguments to [[FUNCTION_NAME]] are of different size."));
+  function createComputeFunction(descr, functionName) {
+      function runtimeCompute(...args) {
+          try {
+              return vectorizedCompute.apply(this, args);
+          }
+          catch (e) {
+              return handleError(e, functionName);
+          }
+      }
+      function vectorizedCompute(...args) {
+          let countVectorizableCol = 1;
+          let countVectorizableRow = 1;
+          let vectorizableColLimit = Infinity;
+          let vectorizableRowLimit = Infinity;
+          let vectorArgsType = undefined;
+          //#region Compute vectorisation limits
           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 (arg.length !== 1 || arg[0].length !== 1) {
-                      throw new EvaluationError(_t("Function [[FUNCTION_NAME]] expects the parameter '%s' to be a single value or a single cell reference, not a range.", argDefinition.name));
+                  // 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];
                   }
-                  args[i] = arg[0][0];
               }
               if (!isMatrix(arg) && argDefinition.acceptMatrixOnly) {
                   throw new BadExpressionError(_t("Function [[FUNCTION_NAME]] expects the parameter '%s' to be reference to a cell or range.", (i + 1).toString()));
               }
           }
-          return descr.compute.apply(this, args);
+          //#endregion
+          if (countVectorizableCol === 1 && countVectorizableRow === 1) {
+              // either this function is not vectorized or it ends up with a 1x1 dimension
+              return computeFunctionToObject.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 = computeFunctionToObject.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 computeWithInputHandling;
-  }
-  function addErrorHandling(compute, functionName) {
-      return function (...args) {
-          try {
-              return compute.apply(this, args);
+      function computeFunctionToObject(...args) {
+          const result = descr.compute.apply(this, args);
+          if (!isMatrix(result)) {
+              if (typeof result === "object" && result !== null && "value" in result) {
+                  replaceFunctionNamePlaceholder(result, functionName);
+                  return result;
+              }
+              return { value: result };
           }
-          catch (e) {
-              return handleError(e, functionName);
+          if (typeof result[0][0] === "object" && result[0][0] !== null && "value" in result[0][0]) {
+              matrixForEach(result, (result) => replaceFunctionNamePlaceholder(result, functionName));
+              return result;
           }
-      };
+          return matrixMap(result, (row) => ({ value: row }));
+      }
+      return runtimeCompute;
   }
-  const implementationErrorMessage = _t("An unexpected error occurred. Submit a support ticket at odoo.com/help.");
   function handleError(e, functionName) {
       // the error could be an user error (instance of EvaluationError)
       // or a javascript error (instance of Error)
@@ -20006,42 +20404,16 @@ stores.inject(MyMetaStore, storeInstance);
       return (obj?.value !== undefined &&
           typeof obj.value === "string");
   }
-  function hasStringMessage(obj) {
-      return (obj?.message !== undefined &&
-          typeof obj.message === "string");
-  }
-  function addResultHandling(compute, functionName) {
-      return function computeWithResultHandling(...args) {
-          const result = compute.apply(this, args);
-          if (!isMatrix(result)) {
-              if (typeof result === "object" && result !== null && "value" in result) {
-                  replaceFunctionNamePlaceholder(result, functionName);
-                  return result;
-              }
-              return { value: result };
-          }
-          if (typeof result[0][0] === "object" && result[0][0] !== null && "value" in result[0][0]) {
-              matrixForEach(result, (result) => replaceFunctionNamePlaceholder(result, functionName));
-              return result;
-          }
-          return matrixMap(result, (row) => ({ value: row }));
-      };
-  }
-  function replaceFunctionNamePlaceholder(fPayload, functionName) {
+  function replaceFunctionNamePlaceholder(functionResult, functionName) {
       // for performance reasons: change in place and only if needed
-      if (fPayload.message?.includes("[[FUNCTION_NAME]]")) {
-          fPayload.message = fPayload.message.replace("[[FUNCTION_NAME]]", functionName);
+      if (functionResult.message?.includes("[[FUNCTION_NAME]]")) {
+          functionResult.message = functionResult.message.replace("[[FUNCTION_NAME]]", functionName);
       }
   }
-  const functionRegistry = new FunctionRegistry();
-  for (let category of categories) {
-      const fns = category.functions;
-      for (let name in fns) {
-          const addDescr = fns[name];
-          addDescr.category = addDescr.category || category.name;
-          name = name.replace(/_/g, ".");
-          functionRegistry.add(name, { isExported: false, ...addDescr });
-      }
+  const implementationErrorMessage = _t("An unexpected error occurred. Submit a support ticket at odoo.com/help.");
+  function hasStringMessage(obj) {
+      return (obj?.message !== undefined &&
+          typeof obj.message === "string");
   }
 
   autoCompleteProviders.add("functions", {
@@ -21490,6 +21862,7 @@ stores.inject(MyMetaStore, storeInstance);
 
   const functions$1 = functionRegistry.content;
   const OPERATOR_MAP = {
+      // export for test
       "=": "EQ",
       "+": "ADD",
       "-": "MINUS",
@@ -21504,6 +21877,7 @@ stores.inject(MyMetaStore, storeInstance);
       "&": "CONCATENATE",
   };
   const UNARY_OPERATOR_MAP = {
+      // export for test
       "-": "UMINUS",
       "+": "UPLUS",
       "%": "UNARY.PERCENT",
@@ -22792,8 +23166,7 @@ stores.inject(MyMetaStore, storeInstance);
   /**
    * Get a default chart js configuration
    */
-  function getDefaultChartJsRuntime(chart, labels, fontColor, args) {
-      const { format, locale, truncateLabels, horizontalChart } = args;
+  function getDefaultChartJsRuntime(chart, labels, fontColor, { format, locale, truncateLabels = true, horizontalChart, }) {
       const chartTitle = chart.title.text ? chart.title : { ...chart.title, content: "" };
       const options = {
           // https://www.chartjs.org/docs/latest/general/responsive.html
@@ -22969,7 +23342,6 @@ stores.inject(MyMetaStore, storeInstance);
       if ("chartJsConfig" in runtime) {
           const config = deepCopy(runtime.chartJsConfig);
           config.plugins = [backgroundColorChartJSPlugin];
-          // @ts-ignore
           const chart = new window.Chart(canvas, config);
           const imgContent = chart.toBase64Image();
           chart.destroy();
@@ -23890,13 +24262,11 @@ stores.inject(MyMetaStore, storeInstance);
   }
   let missingTimeAdapterAlreadyWarned = false;
   function isLuxonTimeAdapterInstalled() {
-      // @ts-ignore
       if (!window.Chart) {
           return false;
       }
       // @ts-ignore
       const adapter = new window.Chart._adapters._date({});
-      // @ts-ignore
       const isInstalled = adapter._id === "luxon";
       if (!isInstalled && !missingTimeAdapterAlreadyWarned) {
           missingTimeAdapterAlreadyWarned = true;
@@ -23913,9 +24283,7 @@ stores.inject(MyMetaStore, storeInstance);
               generateLabels(chart) {
                   // color the legend labels with the dataset color, without any transparency
                   const { data } = chart;
-                  /** @ts-ignore */
-                  const labels = window.Chart.defaults.plugins.legend.labels
-                      .generateLabels(chart);
+                  const labels = window.Chart.defaults.plugins.legend.labels.generateLabels(chart);
                   for (const [index, label] of labels.entries()) {
                       label.fillStyle = data.datasets[index].borderColor;
                   }
@@ -33157,21 +33525,25 @@ stores.inject(MyMetaStore, storeInstance);
 
   function useHighlightsOnHover(ref, highlightProvider) {
       const hoverState = useHoveredElement(ref);
-      const stores = useStoreProvider();
       useHighlights({
           get highlights() {
               return hoverState.hovered ? highlightProvider.highlights : [];
           },
       });
-      owl.useEffect(() => {
-          stores.trigger("store-updated");
-      }, () => [hoverState.hovered]);
   }
   function useHighlights(highlightProvider) {
+      const stores = useStoreProvider();
       const store = useLocalStore(HighlightStore);
       owl.onMounted(() => {
           store.register(highlightProvider);
       });
+      let currentHighlights = highlightProvider.highlights;
+      owl.useEffect((highlights) => {
+          if (!deepEquals(highlights, currentHighlights)) {
+              currentHighlights = highlights;
+              stores.trigger("store-updated");
+          }
+      }, () => [highlightProvider.highlights]);
   }
 
   css /* scss */ `
@@ -45765,7 +46137,7 @@ stores.inject(MyMetaStore, storeInstance);
       return relsFile;
   }
 
-  const EXCEL_IMPORT_VERSION = 16;
+  const EXCEL_IMPORT_VERSION = 17;
   class XlsxReader {
       warningManager;
       xmls;
@@ -45897,7 +46269,7 @@ stores.inject(MyMetaStore, storeInstance);
    * a breaking change is made in the way the state is handled, and an upgrade
    * function should be defined
    */
-  const CURRENT_VERSION = 16;
+  const CURRENT_VERSION = 17;
   const INITIAL_SHEET_ID = "Sheet1";
   /**
    * This function tries to load anything that could look like a valid
@@ -49234,10 +49606,12 @@ stores.inject(MyMetaStore, storeInstance);
           if (!sheetMap)
               return [];
           const mergeIds = new Set();
-          for (const { col, row } of positions(zone)) {
-              const mergeId = sheetMap[col]?.[row];
-              if (mergeId) {
-                  mergeIds.add(mergeId);
+          for (let col = zone.left; col <= zone.right; col++) {
+              for (let row = zone.top; row <= zone.bottom; row++) {
+                  const mergeId = sheetMap[col]?.[row];
+                  if (mergeId) {
+                      mergeIds.add(mergeId);
+                  }
               }
           }
           return Array.from(mergeIds)
@@ -53105,7 +53479,13 @@ stores.inject(MyMetaStore, storeInstance);
           const queue = Array.from(ranges).reverse();
           while (queue.length > 0) {
               const range = queue.pop();
-              visited.addMany(positions(range.zone).map((position) => ({ sheetId: range.sheetId, ...position })));
+              const zone = range.zone;
+              const sheetId = range.sheetId;
+              for (let col = zone.left; col <= zone.right; col++) {
+                  for (let row = zone.top; row <= zone.bottom; row++) {
+                      visited.add({ sheetId, col, row });
+                  }
+              }
               const impactedPositions = this.rTree.search(range).map((dep) => dep.data);
               const nextInQueue = {};
               for (const position of impactedPositions) {
@@ -53121,7 +53501,16 @@ stores.inject(MyMetaStore, storeInstance);
                   queue.push(...zones.map((zone) => ({ sheetId, zone })));
               }
           }
-          visited.deleteMany(ranges.flatMap((r) => positions(r.zone).map((position) => ({ sheetId: r.sheetId, ...position }))));
+          // remove initial ranges
+          for (const range of ranges) {
+              const zone = range.zone;
+              const sheetId = range.sheetId;
+              for (let col = zone.left; col <= zone.right; col++) {
+                  for (let row = zone.top; row <= zone.bottom; row++) {
+                      visited.delete({ sheetId, col, row });
+                  }
+              }
+          }
           return visited;
       }
   }
@@ -53252,7 +53641,7 @@ stores.inject(MyMetaStore, storeInstance);
           return this.sheets[position.sheetId].getValue(position) === 1;
       }
       clear() {
-          const insertions = this.insertions;
+          const insertions = [...this];
           this.insertions = [];
           for (const sheetId in this.sheets) {
               this.sheets[sheetId].clear();
@@ -53596,6 +53985,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           finally {
               this.cellsBeingComputed.delete(cellId);
+              this.nextPositionsToUpdate.delete(position);
           }
       }
       computeAndSave(position) {
@@ -53622,8 +54012,33 @@ stores.inject(MyMetaStore, storeInstance);
           forEachSpreadPositionInMatrix(nbColumns, nbRows, 
           // thanks to the isMatrix check above, we know that formulaReturn is MatrixFunctionReturn
           this.spreadValues(formulaPosition, formulaReturn));
+          this.invalidatePositionsDependingOnSpread(formulaPosition, nbColumns, nbRows);
           return createEvaluatedCell(nullValueToZeroValue(formulaReturn[0][0]), this.getters.getLocale(), cellData);
       }
+      invalidatePositionsDependingOnSpread(arrayFormulaPosition, nbColumns, nbRows) {
+          // the result matrix is split in 2 zones to exclude the array formula position
+          const top = arrayFormulaPosition.row;
+          const left = arrayFormulaPosition.col;
+          const bottom = top + nbRows - 1;
+          const leftColumnZone = {
+              top: top + 1,
+              bottom,
+              left,
+              right: left,
+          };
+          const rightPartZone = {
+              top,
+              bottom,
+              left: left + 1,
+              right: left + nbColumns - 1,
+          };
+          const sheetId = arrayFormulaPosition.sheetId;
+          const invalidatedPositions = this.formulaDependencies().getCellsDependingOn([
+              { sheetId, zone: rightPartZone },
+              { sheetId, zone: leftColumnZone },
+          ]);
+          this.nextPositionsToUpdate.addMany(invalidatedPositions);
+      }
       assertSheetHasEnoughSpaceToSpreadFormulaResult({ sheetId, col, row }, matrixResult) {
           const numberOfCols = this.getters.getNumberCols(sheetId);
           const numberOfRows = this.getters.getNumberRows(sheetId);
@@ -53654,14 +54069,15 @@ stores.inject(MyMetaStore, storeInstance);
       }
       updateSpreadRelation({ sheetId, col, row, }) {
           const arrayFormulaPosition = { sheetId, col, row };
-          return (i, j) => {
+          const updateSpreadRelation = (i, j) => {
               const position = { sheetId, col: i + col, row: j + row };
               this.spreadingRelations.addRelation({ resultPosition: position, arrayFormulaPosition });
           };
+          return updateSpreadRelation;
       }
       checkCollision(formulaPosition) {
           const { sheetId, col, row } = formulaPosition;
-          return (i, j) => {
+          const checkCollision = (i, j) => {
               const position = { sheetId: sheetId, col: i + col, row: j + row };
               const rawCell = this.getters.getCell(position);
               if (rawCell?.content ||
@@ -53671,17 +54087,16 @@ stores.inject(MyMetaStore, storeInstance);
               }
               this.blockedArrayFormulas.delete(formulaPosition);
           };
+          return checkCollision;
       }
       spreadValues({ sheetId, col, row }, matrixResult) {
-          return (i, j) => {
+          const spreadValues = (i, j) => {
               const position = { sheetId, col: i + col, row: j + row };
               const cell = this.getters.getCell(position);
               const evaluatedCell = createEvaluatedCell(nullValueToZeroValue(matrixResult[i][j]), this.getters.getLocale(), cell);
               this.evaluatedCells.set(position, evaluatedCell);
-              // check if formula dependencies present in the spread zone
-              // if so, they need to be recomputed
-              this.nextPositionsToUpdate.addMany(this.getCellsDependingOn([position]));
           };
+          return spreadValues;
       }
       invalidateSpreading(position) {
           if (!this.spreadingRelations.isArrayFormula(position)) {
@@ -53736,12 +54151,12 @@ stores.inject(MyMetaStore, storeInstance);
    * rather than appearing empty. This indicates that the
    * cell is the result of a non-empty content.
    */
-  function nullValueToZeroValue(fPayload) {
-      if (fPayload.value === null || fPayload.value === undefined) {
-          // 'fPayload.value === undefined' is supposed to never happen, it's a safety net for javascript use
-          return { ...fPayload, value: 0 };
+  function nullValueToZeroValue(functionResult) {
+      if (functionResult.value === null || functionResult.value === undefined) {
+          // 'functionResult.value === undefined' is supposed to never happen, it's a safety net for javascript use
+          return { ...functionResult, value: 0 };
       }
-      return fPayload;
+      return functionResult;
   }
   function updateEvalContextAndExecute(compiledFormula, compilationParams, sheetId, cellId) {
       compilationParams.evalContext.__originCellXC = lazy(() => {
@@ -67832,9 +68247,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "17.4.0-alpha.12";
-  __info__.date = "2024-07-08T05:43:07.933Z";
-  __info__.hash = "7cfe14a";
+  __info__.version = "17.4.0-alpha.13";
+  __info__.date = "2024-07-11T06:36:58.556Z";
+  __info__.hash = "e0f506b";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);