@odoo/o-spreadsheet 18.0.27 → 18.0.29

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.0.27
- * @date 2025-05-12T05:25:47.149Z
- * @hash 9b36340
+ * @version 18.0.29
+ * @date 2025-05-20T05:54:57.329Z
+ * @hash 8213c0e
  */
 
 (function (exports, owl) {
@@ -1453,18 +1453,53 @@
       let result = 0;
       const l = letters.length;
       for (let i = 0; i < l; i++) {
-          const charCode = letters.charCodeAt(i);
-          const colIndex = charCode >= 65 && charCode <= 90 ? charCode - 64 : charCode - 96;
+          const colIndex = charToNumber(letters[i]);
           result = result * 26 + colIndex;
       }
       return result - 1;
   }
+  function charToNumber(char) {
+      const charCode = char.charCodeAt(0);
+      return charCode >= 65 && charCode <= 90 ? charCode - 64 : charCode - 96;
+  }
   function isCharALetter(char) {
       return (char >= "A" && char <= "Z") || (char >= "a" && char <= "z");
   }
   function isCharADigit(char) {
       return char >= "0" && char <= "9";
   }
+  // we limit the max column to 3 letters and max row to 7 digits for performance reasons
+  const MAX_COL = lettersToNumber("ZZZ");
+  const MAX_ROW = 9999998;
+  function consumeSpaces(chars) {
+      while (chars.current === " ") {
+          chars.advanceBy(1);
+      }
+  }
+  function consumeLetters(chars) {
+      if (chars.current === "$")
+          chars.advanceBy(1);
+      if (!chars.current || !isCharALetter(chars.current)) {
+          return -1;
+      }
+      let colCoordinate = 0;
+      while (chars.current && isCharALetter(chars.current)) {
+          colCoordinate = colCoordinate * 26 + charToNumber(chars.shift());
+      }
+      return colCoordinate;
+  }
+  function consumeDigits(chars) {
+      if (chars.current === "$")
+          chars.advanceBy(1);
+      if (!chars.current || !isCharADigit(chars.current)) {
+          return -1;
+      }
+      let num = 0;
+      while (chars.current && isCharADigit(chars.current)) {
+          num = num * 10 + Number(chars.shift());
+      }
+      return num;
+  }
   /**
    * Convert a "XC" coordinate to cartesian coordinates.
    *
@@ -1475,33 +1510,17 @@
    * Note: it also accepts lowercase coordinates, but not fixed references
    */
   function toCartesian(xc) {
-      xc = xc.trim();
-      let letterPart = "";
-      let numberPart = "";
-      let i = 0;
-      // Process letter part
-      if (xc[i] === "$")
-          i++;
-      while (i < xc.length && isCharALetter(xc[i])) {
-          letterPart += xc[i++];
-      }
-      if (letterPart.length === 0 || letterPart.length > 3) {
-          // limit to max 3 letters for performance reasons
+      const chars = new TokenizingChars(xc);
+      consumeSpaces(chars);
+      const letterPart = consumeLetters(chars);
+      if (letterPart === -1 || !chars.current) {
           throw new Error(`Invalid cell description: ${xc}`);
       }
-      // Process number part
-      if (xc[i] === "$")
-          i++;
-      while (i < xc.length && isCharADigit(xc[i])) {
-          numberPart += xc[i++];
-      }
-      if (i !== xc.length || numberPart.length === 0 || numberPart.length > 7) {
-          // limit to max 7 numbers for performance reasons
-          throw new Error(`Invalid cell description: ${xc}`);
-      }
-      const col = lettersToNumber(letterPart);
-      const row = Number(numberPart) - 1;
-      if (isNaN(row)) {
+      const num = consumeDigits(chars);
+      consumeSpaces(chars);
+      const col = letterPart - 1;
+      const row = num - 1;
+      if (!chars.isOver() || col > MAX_COL || row > MAX_ROW) {
           throw new Error(`Invalid cell description: ${xc}`);
       }
       return { col, row };
@@ -1913,67 +1932,6 @@
       }
   }
 
-  /** Reference of a cell (eg. A1, $B$5) */
-  const cellReference = new RegExp(/\$?([A-Z]{1,3})\$?([0-9]{1,7})/, "i");
-  // Same as above, but matches the exact string (nothing before or after)
-  const singleCellReference = new RegExp(/^\$?([A-Z]{1,3})\$?([0-9]{1,7})$/, "i");
-  /** Reference of a column header (eg. A, AB, $A) */
-  const colHeader = new RegExp(/^\$?([A-Z]{1,3})+$/, "i");
-  /** Reference of a row header (eg. 1, $1) */
-  const rowHeader = new RegExp(/^\$?([0-9]{1,7})+$/, "i");
-  /** Reference of a column (eg. A, $CA, Sheet1!B) */
-  const colReference = new RegExp(/^\s*('.+'!|[^']+!)?\$?([A-Z]{1,3})$/, "i");
-  /** Reference of a row (eg. 1, 59, Sheet1!9) */
-  const rowReference = new RegExp(/^\s*('.+'!|[^']+!)?\$?([0-9]{1,7})$/, "i");
-  /** Reference of a normal range or a full row range (eg. A1:B1, 1:$5, $A2:5) */
-  const fullRowXc = /(\$?[A-Z]{1,3})?\$?[0-9]{1,7}\s*:\s*(\$?[A-Z]{1,3})?\$?[0-9]{1,7}\s*/i;
-  /** Reference of a normal range or a column row range (eg. A1:B1, A:$B, $A1:C) */
-  const fullColXc = /\$?[A-Z]{1,3}(\$?[0-9]{1,7})?\s*:\s*\$?[A-Z]{1,3}(\$?[0-9]{1,7})?\s*/i;
-  /** Reference of a cell or a range, it can be a bounded range, a full row or a full column */
-  const rangeReference = new RegExp(/^\s*('.+'!|[^']+!)?/.source +
-      "(" +
-      [cellReference.source, fullRowXc.source, fullColXc.source].join("|") +
-      ")" +
-      /$/.source, "i");
-  /**
-   * Return true if the given xc is the reference of a column (e.g. A or AC or Sheet1!A)
-   */
-  function isColReference(xc) {
-      return colReference.test(xc);
-  }
-  /**
-   * Return true if the given xc is the reference of a column (e.g. 1 or Sheet1!1)
-   */
-  function isRowReference(xc) {
-      return rowReference.test(xc);
-  }
-  function isColHeader(str) {
-      return colHeader.test(str);
-  }
-  function isRowHeader(str) {
-      return rowHeader.test(str);
-  }
-  /**
-   * Return true if the given xc is the reference of a single cell,
-   * without any specified sheet (e.g. A1)
-   */
-  function isSingleCellReference(xc) {
-      return singleCellReference.test(xc);
-  }
-  function splitReference(ref) {
-      if (!ref.includes("!")) {
-          return { xc: ref };
-      }
-      const parts = ref.split("!");
-      const xc = parts.pop();
-      const sheetName = getUnquotedSheetName(parts.join("!")) || undefined;
-      return { sheetName, xc };
-  }
-  /** Return a reference SheetName!xc from the given arguments */
-  function getFullReference(sheetName, xc) {
-      return sheetName !== undefined ? `${getCanonicalSymbolName(sheetName)}!${xc}` : xc;
-  }
-
   /**
    * Convert from a cartesian reference to a Zone
    * The range boundaries will be kept in the same order as the
@@ -1991,63 +1949,55 @@
    *
    */
   function toZoneWithoutBoundaryChanges(xc) {
-      if (xc.includes("!")) {
-          xc = xc.split("!").at(-1);
-      }
-      if (xc.includes("$")) {
-          xc = xc.replaceAll("$", "");
-      }
-      let firstRangePart = "";
-      let secondRangePart;
-      if (xc.includes(":")) {
-          [firstRangePart, secondRangePart] = xc.split(":");
-          firstRangePart = firstRangePart.trim();
-          secondRangePart = secondRangePart.trim();
-      }
-      else {
-          firstRangePart = xc.trim();
-      }
+      const chars = new TokenizingChars(xc);
+      consumeSpaces(chars);
+      const sheetSeparatorIndex = xc.indexOf("!");
+      if (sheetSeparatorIndex !== -1) {
+          chars.advanceBy(sheetSeparatorIndex + 1);
+      }
+      const leftLetters = consumeLetters(chars);
+      const leftNumbers = consumeDigits(chars);
       let top, bottom, left, right;
       let fullCol = false;
       let fullRow = false;
       let hasHeader = false;
-      if (isColReference(firstRangePart)) {
-          left = right = lettersToNumber(firstRangePart);
+      if (leftNumbers === -1) {
+          left = right = leftLetters - 1;
           top = bottom = 0;
           fullCol = true;
       }
-      else if (isRowReference(firstRangePart)) {
-          top = bottom = parseInt(firstRangePart, 10) - 1;
+      else if (leftLetters === -1) {
+          top = bottom = leftNumbers - 1;
           left = right = 0;
           fullRow = true;
       }
       else {
-          const c = toCartesian(firstRangePart);
-          left = right = c.col;
-          top = bottom = c.row;
+          left = right = leftLetters - 1;
+          top = bottom = leftNumbers - 1;
           hasHeader = true;
       }
-      if (secondRangePart) {
-          if (isColReference(secondRangePart)) {
-              right = lettersToNumber(secondRangePart);
+      consumeSpaces(chars);
+      if (chars.current === ":") {
+          chars.advanceBy(1);
+          consumeSpaces(chars);
+          const rightLetters = consumeLetters(chars);
+          const rightNumbers = consumeDigits(chars);
+          if (rightNumbers === -1) {
+              right = rightLetters - 1;
               fullCol = true;
           }
-          else if (isRowReference(secondRangePart)) {
-              bottom = parseInt(secondRangePart, 10) - 1;
+          else if (rightLetters === -1) {
+              bottom = rightNumbers - 1;
               fullRow = true;
           }
           else {
-              const c = toCartesian(secondRangePart);
-              right = c.col;
-              bottom = c.row;
+              right = rightLetters - 1;
+              bottom = rightNumbers - 1;
               top = fullCol ? bottom : top;
               left = fullRow ? right : left;
               hasHeader = true;
           }
       }
-      if (fullCol && fullRow) {
-          throw new Error("Wrong zone xc. The zone cannot be at the same time a full column and a full row");
-      }
       const zone = {
           top,
           left,
@@ -2076,7 +2026,16 @@
    */
   function toUnboundedZone(xc) {
       const zone = toZoneWithoutBoundaryChanges(xc);
-      return reorderZone(zone);
+      const orderedZone = reorderZone(zone);
+      const bottom = orderedZone.bottom;
+      const right = orderedZone.right;
+      if ((bottom !== undefined && bottom > MAX_ROW) || (right !== undefined && right > MAX_COL)) {
+          throw new Error(`Range string out of bounds: ${xc}`); // limit the size of the zone for performance
+      }
+      if (bottom === undefined && right === undefined) {
+          throw new Error("Wrong zone xc. The zone cannot be at the same time a full column and a full row");
+      }
+      return orderedZone;
   }
   /**
    * Convert from a cartesian reference to a Zone.
@@ -3181,7 +3140,7 @@
    */
   const getFormulaNumberRegex = memoize(function getFormulaNumberRegex(decimalSeparator) {
       decimalSeparator = escapeRegExp(decimalSeparator);
-      return new RegExp(`(?:^-?\\d+(?:${decimalSeparator}?\\d*(?:e\\d+)?)?|^-?${decimalSeparator}\\d+)(?!\\w|!)`);
+      return new RegExp(`(?:^-?\\d+(?:${decimalSeparator}?\\d*(?:e(\\+|-)?\\d+)?)?|^-?${decimalSeparator}\\d+)(?!\\w|!)`);
   });
   const getNumberRegex = memoize(function getNumberRegex(locale) {
       const decimalSeparator = escapeRegExp(locale.decimalSeparator);
@@ -5797,6 +5756,67 @@
       return MIN_DELAY + (MAX_DELAY - MIN_DELAY) * Math.exp(-ACCELERATION * (value - 1));
   }
 
+  /** Reference of a cell (eg. A1, $B$5) */
+  const cellReference = new RegExp(/\$?([A-Z]{1,3})\$?([0-9]{1,7})/, "i");
+  // Same as above, but matches the exact string (nothing before or after)
+  const singleCellReference = new RegExp(/^\$?([A-Z]{1,3})\$?([0-9]{1,7})$/, "i");
+  /** Reference of a column header (eg. A, AB, $A) */
+  const colHeader = new RegExp(/^\$?([A-Z]{1,3})+$/, "i");
+  /** Reference of a row header (eg. 1, $1) */
+  const rowHeader = new RegExp(/^\$?([0-9]{1,7})+$/, "i");
+  /** Reference of a column (eg. A, $CA, Sheet1!B) */
+  const colReference = new RegExp(/^\s*('.+'!|[^']+!)?\$?([A-Z]{1,3})$/, "i");
+  /** Reference of a row (eg. 1, 59, Sheet1!9) */
+  const rowReference = new RegExp(/^\s*('.+'!|[^']+!)?\$?([0-9]{1,7})$/, "i");
+  /** Reference of a normal range or a full row range (eg. A1:B1, 1:$5, $A2:5) */
+  const fullRowXc = /(\$?[A-Z]{1,3})?\$?[0-9]{1,7}\s*:\s*(\$?[A-Z]{1,3})?\$?[0-9]{1,7}\s*/i;
+  /** Reference of a normal range or a column row range (eg. A1:B1, A:$B, $A1:C) */
+  const fullColXc = /\$?[A-Z]{1,3}(\$?[0-9]{1,7})?\s*:\s*\$?[A-Z]{1,3}(\$?[0-9]{1,7})?\s*/i;
+  /** Reference of a cell or a range, it can be a bounded range, a full row or a full column */
+  const rangeReference = new RegExp(/^\s*('.+'!|[^']+!)?/.source +
+      "(" +
+      [cellReference.source, fullRowXc.source, fullColXc.source].join("|") +
+      ")" +
+      /$/.source, "i");
+  /**
+   * Return true if the given xc is the reference of a column (e.g. A or AC or Sheet1!A)
+   */
+  function isColReference(xc) {
+      return colReference.test(xc);
+  }
+  /**
+   * Return true if the given xc is the reference of a column (e.g. 1 or Sheet1!1)
+   */
+  function isRowReference(xc) {
+      return rowReference.test(xc);
+  }
+  function isColHeader(str) {
+      return colHeader.test(str);
+  }
+  function isRowHeader(str) {
+      return rowHeader.test(str);
+  }
+  /**
+   * Return true if the given xc is the reference of a single cell,
+   * without any specified sheet (e.g. A1)
+   */
+  function isSingleCellReference(xc) {
+      return singleCellReference.test(xc);
+  }
+  function splitReference(ref) {
+      if (!ref.includes("!")) {
+          return { xc: ref };
+      }
+      const parts = ref.split("!");
+      const xc = parts.pop();
+      const sheetName = getUnquotedSheetName(parts.join("!")) || undefined;
+      return { sheetName, xc };
+  }
+  /** Return a reference SheetName!xc from the given arguments */
+  function getFullReference(sheetName, xc) {
+      return sheetName !== undefined ? `${getCanonicalSymbolName(sheetName)}!${xc}` : xc;
+  }
+
   class RangeImpl {
       getSheetSize;
       _zone;
@@ -6122,6 +6142,13 @@
       }
       return name;
   }
+  function isSheetNameEqual(name1, name2) {
+      if (name1 === undefined || name2 === undefined) {
+          return false;
+      }
+      return (getUnquotedSheetName(name1.trim().toUpperCase()) ===
+          getUnquotedSheetName(name2.trim().toUpperCase()));
+  }
 
   function computeTextLinesHeight(textLineHeight, numberOfLines = 1) {
       return numberOfLines * (textLineHeight + MIN_CELL_TEXT_MARGIN) - MIN_CELL_TEXT_MARGIN;
@@ -7975,10 +8002,9 @@
       avg: _t("Average"),
       sum: _t("Sum"),
   };
-  const NUMBER_CHAR_AGGREGATORS = ["max", "min", "avg", "sum", "count_distinct", "count"];
   const AGGREGATORS_BY_FIELD_TYPE = {
-      integer: NUMBER_CHAR_AGGREGATORS,
-      char: NUMBER_CHAR_AGGREGATORS,
+      integer: ["max", "min", "avg", "sum", "count_distinct", "count"],
+      char: ["count_distinct", "count"],
       boolean: ["count_distinct", "count", "bool_and", "bool_or"],
   };
   const AGGREGATORS = {};
@@ -9311,7 +9337,10 @@ stores.inject(MyMetaStore, storeInstance);
                   const functionProxy = new Proxy(value, {
                       // trap the function call
                       apply(target, thisArg, argArray) {
-                          Reflect.apply(target, thisStore, argArray);
+                          const res = Reflect.apply(target, thisStore, argArray);
+                          if (res === "noStateChange") {
+                              return;
+                          }
                           callback();
                       },
                   });
@@ -9333,7 +9362,7 @@ stores.inject(MyMetaStore, storeInstance);
   const ModelStore = createAbstractStore("Model");
 
   class RendererStore {
-      mutators = ["register", "unRegister"];
+      mutators = ["register", "unRegister", "drawLayer"];
       renderers = {};
       register(renderer) {
           if (!renderer.renderingLayers.length) {
@@ -9353,14 +9382,14 @@ stores.inject(MyMetaStore, storeInstance);
       }
       drawLayer(context, layer) {
           const renderers = this.renderers[layer];
-          if (!renderers) {
-              return;
-          }
-          for (const renderer of renderers) {
-              context.ctx.save();
-              renderer.drawLayer(context, layer);
-              context.ctx.restore();
+          if (renderers) {
+              for (const renderer of renderers) {
+                  context.ctx.save();
+                  renderer.drawLayer(context, layer);
+                  context.ctx.restore();
+              }
           }
+          return "noStateChange";
       }
   }
 
@@ -9413,16 +9442,17 @@ stores.inject(MyMetaStore, storeInstance);
       focusComposer(listener, args) {
           this.activeComposer = listener;
           if (this.getters.isReadonly()) {
-              return;
+              return "noStateChange";
           }
           this._focusMode = args.focusMode || "contentFocus";
           if (this._focusMode !== "inactive") {
               this.setComposerContent(args);
           }
+          return;
       }
       focusActiveComposer(args) {
           if (this.getters.isReadonly()) {
-              return;
+              return "noStateChange";
           }
           if (!this.activeComposer) {
               throw new Error("No composer is registered");
@@ -9431,6 +9461,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (this._focusMode !== "inactive") {
               this.setComposerContent(args);
           }
+          return;
       }
       /**
        * Start the edition or update the content if it's already started.
@@ -11745,7 +11776,7 @@ stores.inject(MyMetaStore, storeInstance);
       ({ xc, sheetName } = splitReference(reference));
       let rangeSheetIndex;
       if (sheetName) {
-          const index = data.sheets.findIndex((sheet) => sheet.name === sheetName);
+          const index = data.sheets.findIndex((sheet) => isSheetNameEqual(sheet.name, sheetName));
           if (index < 0) {
               throw new Error("Unable to find a sheet with the name " + sheetName);
           }
@@ -12086,7 +12117,7 @@ stores.inject(MyMetaStore, storeInstance);
       formula = formula.replace(externalReferenceRegex, (match, externalRefId, sheetName, cellRef) => {
           externalRefId = Number(externalRefId) - 1;
           cellRef = cellRef.replace(/\$/g, "");
-          const sheetIndex = data.externalBooks[externalRefId].sheetNames.findIndex((name) => name === sheetName);
+          const sheetIndex = data.externalBooks[externalRefId].sheetNames.findIndex((name) => isSheetNameEqual(name, sheetName));
           if (sheetIndex === -1) {
               return match;
           }
@@ -12749,7 +12780,7 @@ stores.inject(MyMetaStore, storeInstance);
    */
   function convertTableFormulaReferences(convertedSheets, xlsxSheets) {
       for (let tableSheet of convertedSheets) {
-          const tables = xlsxSheets.find((s) => s.sheetName === tableSheet.name).tables;
+          const tables = xlsxSheets.find((s) => isSheetNameEqual(s.sheetName, tableSheet.name)).tables;
           for (let table of tables) {
               const tabRef = table.name + "[";
               for (let sheet of convertedSheets) {
@@ -25072,6 +25103,9 @@ stores.inject(MyMetaStore, storeInstance);
               };
           }
           const domain = pivot.parseArgsToPivotDomain(domainArgs);
+          if (this.getters.getActiveSheetId() === this.__originSheetId) {
+              this.getters.getPivotPresenceTracker(pivotId)?.trackValue(_measure, domain);
+          }
           return pivot.getPivotCellValueAndFormat(_measure, domain);
       },
   };
@@ -25103,6 +25137,9 @@ stores.inject(MyMetaStore, storeInstance);
               };
           }
           const domain = pivot.parseArgsToPivotDomain(domainArgs);
+          if (this.getters.getActiveSheetId() === this.__originSheetId) {
+              this.getters.getPivotPresenceTracker(_pivotId)?.trackHeader(domain);
+          }
           const lastNode = domain.at(-1);
           if (lastNode?.field === "measure") {
               return pivot.getPivotMeasureValue(toString(lastNode.value), domain);
@@ -25325,6 +25362,9 @@ stores.inject(MyMetaStore, storeInstance);
       return data === undefined || data.value === null;
   }
   const getNeutral = { number: 0, string: "", boolean: false };
+  function areAlmostEqual(value1, value2, epsilon = 2e-16) {
+      return Math.abs(value1 - value2) < epsilon;
+  }
   const EQ = {
       description: _t("Equal."),
       args: [
@@ -25340,6 +25380,9 @@ stores.inject(MyMetaStore, storeInstance);
           if (typeof _value2 === "string") {
               _value2 = _value2.toUpperCase();
           }
+          if (typeof _value1 === "number" && typeof _value2 === "number") {
+              return areAlmostEqual(_value1, _value2);
+          }
           return _value1 === _value2;
       },
   };
@@ -25379,6 +25422,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (value1, value2) {
           return applyRelationalOperator(value1, value2, (v1, v2) => {
+              if (typeof v1 === "number" && typeof v2 === "number") {
+                  return !areAlmostEqual(v1, v2) && v1 > v2;
+              }
               return v1 > v2;
           });
       },
@@ -25394,6 +25440,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (value1, value2) {
           return applyRelationalOperator(value1, value2, (v1, v2) => {
+              if (typeof v1 === "number" && typeof v2 === "number") {
+                  return areAlmostEqual(v1, v2) || v1 > v2;
+              }
               return v1 >= v2;
           });
       },
@@ -26516,10 +26565,18 @@ stores.inject(MyMetaStore, storeInstance);
   });
 
   class DOMFocusableElementStore {
-      mutators = ["setFocusableElement"];
+      mutators = ["setFocusableElement", "focus"];
       focusableElement = undefined;
       setFocusableElement(element) {
           this.focusableElement = element;
+          return "noStateChange";
+      }
+      focus() {
+          if (this.focusableElement === document.activeElement) {
+              return "noStateChange";
+          }
+          this.focusableElement?.focus();
+          return;
       }
   }
 
@@ -27362,7 +27419,7 @@ stores.inject(MyMetaStore, storeInstance);
               if (document.activeElement === this.contentHelper.el &&
                   this.props.composerStore.editionMode === "inactive" &&
                   !this.props.isDefaultFocus) {
-                  this.DOMFocusableElementStore.focusableElement?.focus();
+                  this.DOMFocusableElementStore.focus();
               }
           });
           owl.useEffect(() => {
@@ -31834,12 +31891,20 @@ stores.inject(MyMetaStore, storeInstance);
           }
       }
       hover(position) {
+          if (position.col === this.col && position.row === this.row) {
+              return "noStateChange";
+          }
           this.col = position.col;
           this.row = position.row;
+          return;
       }
       clear() {
+          if (this.col === undefined && this.row === undefined) {
+              return "noStateChange";
+          }
           this.col = undefined;
           this.row = undefined;
+          return;
       }
   }
 
@@ -31861,7 +31926,11 @@ stores.inject(MyMetaStore, storeInstance);
           this.persistentPopover = { col, row, sheetId, type };
       }
       close() {
+          if (!this.persistentPopover) {
+              return "noStateChange";
+          }
           this.persistentPopover = undefined;
+          return;
       }
       get persistentCellPopover() {
           return ((this.persistentPopover && { isOpen: true, ...this.persistentPopover }) || { isOpen: false });
@@ -39214,7 +39283,7 @@ stores.inject(MyMetaStore, storeInstance);
               .find((token) => {
               const { xc, sheetName: sheet } = splitReference(token.value);
               const sheetName = sheet || this.getters.getSheetName(this.sheetId);
-              if (this.getters.getSheetName(activeSheetId) !== sheetName) {
+              if (!isSheetNameEqual(this.getters.getSheetName(activeSheetId), sheetName)) {
                   return false;
               }
               const refRange = this.getters.getRangeFromSheetXC(activeSheetId, xc);
@@ -39445,12 +39514,13 @@ stores.inject(MyMetaStore, storeInstance);
           return providersDefinitions;
       }
       getComposerContent() {
+          let content = this._currentContent;
           if (this.editionMode === "inactive") {
               // References in the content might not be linked to the current active sheet
               // We here force the sheet name prefix for all references that are not in
               // the current active sheet
               const defaultRangeSheetId = this.args().defaultRangeSheetId;
-              return rangeTokenize(this.args().content)
+              content = rangeTokenize(this.args().content)
                   .map((token) => {
                   if (token.type === "REFERENCE") {
                       const range = this.getters.getRangeFromSheetXC(defaultRangeSheetId, token.value);
@@ -39460,7 +39530,7 @@ stores.inject(MyMetaStore, storeInstance);
               })
                   .join("");
           }
-          return this._currentContent;
+          return localizeContent(content, this.getters.getLocale());
       }
       stopEdition() {
           this._stopEdition();
@@ -43063,6 +43133,9 @@ stores.inject(MyMetaStore, storeInstance);
               measure: this.props.measure,
           });
       }
+      get isCalculatedMeasureInvalid() {
+          return this.env.model.getters.getMeasureCompiledFormula(this.props.measure).isBadExpression;
+      }
   }
 
   css /* scss */ `
@@ -44511,7 +44584,12 @@ stores.inject(MyMetaStore, storeInstance);
                       entry[field.name] = { value: null, type: CellValueType.empty, formattedValue: "" };
                   }
                   else {
-                      entry[field.name] = cell;
+                      if (field.type === "char") {
+                          entry[field.name] = { ...cell, value: cell.formattedValue || null };
+                      }
+                      else {
+                          entry[field.name] = cell;
+                      }
                   }
               }
               entry["__count"] = { value: 1, type: CellValueType.number, formattedValue: "1" };
@@ -49507,10 +49585,6 @@ stores.inject(MyMetaStore, storeInstance);
           ctx.scale(dpr, dpr);
           for (const layer of OrderedLayers()) {
               model.drawLayer(renderingContext, layer);
-              // @ts-ignore 'drawLayer' is not declated as a mutator because:
-              // it does not mutate anything. Most importantly it's used
-              // during rendering. Invoking a mutator during rendering would
-              // trigger another rendering, ultimately resulting in an infinite loop.
               rendererStore.drawLayer(renderingContext, layer);
           }
       }
@@ -50200,7 +50274,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.cellPopovers = useStore(CellPopoverStore);
           owl.useEffect(() => {
               if (!this.sidePanel.isOpen) {
-                  this.DOMFocusableElementStore.focusableElement?.focus();
+                  this.DOMFocusableElementStore.focus();
               }
           }, () => [this.sidePanel.isOpen]);
           useTouchScroll(this.gridRef, this.moveCanvas.bind(this), () => {
@@ -50408,7 +50482,7 @@ stores.inject(MyMetaStore, storeInstance);
       focusDefaultElement() {
           if (!this.env.model.getters.getSelectedFigureId() &&
               this.composerFocusStore.activeComposer.editionMode === "inactive") {
-              this.DOMFocusableElementStore.focusableElement?.focus();
+              this.DOMFocusableElementStore.focus();
           }
       }
       get gridEl() {
@@ -50778,6 +50852,322 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  css /* scss */ `
+  .o_pivot_html_renderer {
+    width: 100%;
+    border-collapse: collapse;
+
+    &:hover {
+      cursor: pointer;
+    }
+
+    td,
+    th {
+      border: 1px solid #dee2e6;
+      background-color: #fff;
+      padding: 0.3rem;
+      white-space: nowrap;
+
+      &:hover {
+        filter: brightness(0.9);
+      }
+    }
+
+    td {
+      text-align: right;
+    }
+
+    th {
+      background-color: #f5f5f5;
+      font-weight: bold;
+      color: black;
+    }
+
+    .o_missing_value {
+      color: #46646d;
+      background: #e7f2f6;
+    }
+  }
+`;
+  class PivotHTMLRenderer extends owl.Component {
+      static template = "o_spreadsheet.PivotHTMLRenderer";
+      static components = { Checkbox };
+      static props = {
+          pivotId: String,
+          onCellClicked: Function,
+      };
+      pivot = this.env.model.getters.getPivot(this.props.pivotId);
+      data = {
+          columns: [],
+          rows: [],
+          values: [],
+      };
+      state = owl.useState({
+          showMissingValuesOnly: false,
+      });
+      setup() {
+          const table = this.pivot.getTableStructure();
+          const formulaId = this.env.model.getters.getPivotFormulaId(this.props.pivotId);
+          this.data = {
+              columns: this._buildColHeaders(formulaId, table),
+              rows: this._buildRowHeaders(formulaId, table),
+              values: this._buildValues(formulaId, table),
+          };
+      }
+      get tracker() {
+          return this.env.model.getters.getPivotPresenceTracker(this.props.pivotId);
+      }
+      // ---------------------------------------------------------------------
+      // Missing values building
+      // ---------------------------------------------------------------------
+      /**
+       * Retrieve the data to display in the Pivot Table
+       * In the case when showMissingValuesOnly is false, the returned value
+       * is the complete data
+       * In the case when showMissingValuesOnly is true, the returned value is
+       * the data which contains only missing values in the rows and cols. In
+       * the rows, we also return the parent rows of rows which contains missing
+       * values, to give context to the user.
+       *
+       */
+      getTableData() {
+          if (!this.state.showMissingValuesOnly) {
+              return this.data;
+          }
+          const colIndexes = this.getColumnsIndexes();
+          const rowIndexes = this.getRowsIndexes();
+          const columns = this.buildColumnsMissing(colIndexes);
+          const rows = this.buildRowsMissing(rowIndexes);
+          const values = this.buildValuesMissing(colIndexes, rowIndexes);
+          return { columns, rows, values };
+      }
+      /**
+       * Retrieve the parents of the given row
+       * ex:
+       *  Australia
+       *    January
+       *    February
+       * The parent of "January" is "Australia"
+       */
+      addRecursiveRow(index) {
+          const rows = this.pivot.getTableStructure().rows;
+          const row = [...rows[index].values];
+          if (row.length <= 1) {
+              return [index];
+          }
+          row.pop();
+          const parentRowIndex = rows.findIndex((r) => JSON.stringify(r.values) === JSON.stringify(row));
+          return [index].concat(this.addRecursiveRow(parentRowIndex));
+      }
+      /**
+       * Create the columns to be used, based on the indexes of the columns in
+       * which a missing value is present
+       *
+       */
+      buildColumnsMissing(indexes) {
+          // columnsMap explode the columns in an array of array of the same
+          // size with the index of each column, repeated 'span' times.
+          // ex:
+          //  | A     | B |
+          //  | 1 | 2 | 3 |
+          // => [
+          //      [0, 0, 1]
+          //      [0, 1, 2]
+          //    ]
+          const columnsMap = [];
+          for (const column of this.data.columns) {
+              const columnMap = [];
+              for (const index in column) {
+                  for (let i = 0; i < column[index].span; i++) {
+                      columnMap.push(parseInt(index, 10));
+                  }
+              }
+              columnsMap.push(columnMap);
+          }
+          // Remove the columns that are not present in indexes
+          for (let i = columnsMap[columnsMap.length - 1].length; i >= 0; i--) {
+              if (!indexes.includes(i)) {
+                  for (const columnMap of columnsMap) {
+                      columnMap.splice(i, 1);
+                  }
+              }
+          }
+          // Build the columns
+          const columns = [];
+          for (const mapIndex in columnsMap) {
+              const column = [];
+              let index = undefined;
+              let span = 1;
+              for (let i = 0; i < columnsMap[mapIndex].length; i++) {
+                  if (index !== columnsMap[mapIndex][i]) {
+                      if (index !== undefined) {
+                          column.push(Object.assign({}, this.data.columns[mapIndex][index], { span }));
+                      }
+                      index = columnsMap[mapIndex][i];
+                      span = 1;
+                  }
+                  else {
+                      span++;
+                  }
+              }
+              if (index !== undefined) {
+                  column.push(Object.assign({}, this.data.columns[mapIndex][index], { span }));
+              }
+              columns.push(column);
+          }
+          return columns;
+      }
+      /**
+       * Create the rows to be used, based on the indexes of the rows in
+       * which a missing value is present.
+       */
+      buildRowsMissing(indexes) {
+          return indexes.map((index) => this.data.rows[index]);
+      }
+      /**
+       * Create the value to be used, based on the indexes of the columns and
+       * rows in which a missing value is present.
+       */
+      buildValuesMissing(colIndexes, rowIndexes) {
+          const values = colIndexes.map(() => []);
+          for (const row of rowIndexes) {
+              for (const col in colIndexes) {
+                  values[col].push(this.data.values[colIndexes[col]][row]);
+              }
+          }
+          return values;
+      }
+      getColumnsIndexes() {
+          const indexes = new Set();
+          for (let i = 0; i < this.data.columns.length; i++) {
+              const exploded = [];
+              for (let y = 0; y < this.data.columns[i].length; y++) {
+                  for (let x = 0; x < this.data.columns[i][y].span; x++) {
+                      exploded.push(this.data.columns[i][y]);
+                  }
+              }
+              for (let y = 0; y < exploded.length; y++) {
+                  if (exploded[y].isMissing) {
+                      indexes.add(y);
+                  }
+              }
+          }
+          for (let i = 0; i < this.data.columns[this.data.columns.length - 1].length; i++) {
+              const values = this.data.values[i];
+              if (values.find((x) => x.isMissing)) {
+                  indexes.add(i);
+              }
+          }
+          return Array.from(indexes).sort((a, b) => a - b);
+      }
+      getRowsIndexes() {
+          const rowIndexes = new Set();
+          for (let i = 0; i < this.data.rows.length; i++) {
+              if (this.data.rows[i].isMissing) {
+                  rowIndexes.add(i);
+              }
+              for (const col of this.data.values) {
+                  if (col[i].isMissing) {
+                      this.addRecursiveRow(i).forEach((x) => rowIndexes.add(x));
+                  }
+              }
+          }
+          return Array.from(rowIndexes).sort((a, b) => a - b);
+      }
+      // ---------------------------------------------------------------------
+      // Data table creation
+      // ---------------------------------------------------------------------
+      _buildColHeaders(id, table) {
+          const headers = [];
+          for (const row of table.columns) {
+              const current = [];
+              for (const cell of row) {
+                  const args = [];
+                  for (let i = 0; i < cell.fields.length; i++) {
+                      args.push({ value: cell.fields[i] }, { value: cell.values[i] });
+                  }
+                  const domain = this.pivot.parseArgsToPivotDomain(args);
+                  const locale = this.env.model.getters.getLocale();
+                  if (domain.at(-1)?.field === "measure") {
+                      const { value, format } = this.pivot.getPivotMeasureValue(toString(domain.at(-1).value), domain);
+                      current.push({
+                          formula: `=PIVOT.HEADER(${generatePivotArgs(id, domain).join(",")})`,
+                          value: formatValue(value, { format, locale }),
+                          span: cell.width,
+                          isMissing: !this.tracker?.isHeaderPresent(domain),
+                      });
+                  }
+                  else {
+                      const { value, format } = this.pivot.getPivotHeaderValueAndFormat(domain);
+                      current.push({
+                          formula: `=PIVOT.HEADER(${generatePivotArgs(id, domain).join(",")})`,
+                          value: formatValue(value, { format, locale }),
+                          span: cell.width,
+                          isMissing: !this.tracker?.isHeaderPresent(domain),
+                      });
+                  }
+              }
+              headers.push(current);
+          }
+          const last = headers[headers.length - 1];
+          headers[headers.length - 1] = last.map((cell) => {
+              if (!cell.isMissing) {
+                  cell.style = "color: #756f6f;";
+              }
+              return cell;
+          });
+          return headers;
+      }
+      _buildRowHeaders(id, table) {
+          const headers = [];
+          for (const row of table.rows) {
+              const args = [];
+              for (let i = 0; i < row.fields.length; i++) {
+                  args.push({ value: row.fields[i] }, { value: row.values[i] });
+              }
+              const domain = this.pivot.parseArgsToPivotDomain(args);
+              const { value, format } = this.pivot.getPivotHeaderValueAndFormat(domain);
+              const locale = this.env.model.getters.getLocale();
+              const cell = {
+                  formula: `=PIVOT.HEADER(${generatePivotArgs(id, domain).join(",")})`,
+                  value: formatValue(value, { format, locale }),
+                  isMissing: !this.tracker?.isHeaderPresent(domain),
+              };
+              if (row.indent > 1) {
+                  cell.style = `padding-left: ${row.indent - 1 * 10}px`;
+              }
+              headers.push(cell);
+          }
+          return headers;
+      }
+      _buildValues(id, table) {
+          const values = [];
+          for (const col of table.columns.at(-1) || []) {
+              const current = [];
+              const measure = toString(col.values[col.values.length - 1]);
+              for (const row of table.rows) {
+                  const args = [];
+                  for (let i = 0; i < row.fields.length; i++) {
+                      args.push({ value: row.fields[i] }, { value: row.values[i] });
+                  }
+                  for (let i = 0; i < col.fields.length - 1; i++) {
+                      args.push({ value: col.fields[i] }, { value: col.values[i] });
+                  }
+                  const domain = this.pivot.parseArgsToPivotDomain(args);
+                  const { value, format } = this.pivot.getPivotCellValueAndFormat(measure, domain);
+                  const locale = this.env.model.getters.getLocale();
+                  current.push({
+                      formula: `=PIVOT.VALUE(${generatePivotArgs(id, domain, measure).join(",")})`,
+                      value: formatValue(value, { format, locale }),
+                      isMissing: !this.tracker?.isValuePresent(measure, domain),
+                  });
+              }
+              values.push(current);
+          }
+          return values;
+      }
+  }
+
   /**
    * BasePlugin
    *
@@ -54286,7 +54676,7 @@ stores.inject(MyMetaStore, storeInstance);
                       if (range.sheetId === cmd.sheetId) {
                           return { changeType: "CHANGE", range };
                       }
-                      if (cmd.name && range.invalidSheetName === cmd.name) {
+                      if (isSheetNameEqual(range.invalidSheetName, cmd.name)) {
                           const invalidSheetName = undefined;
                           const sheetId = cmd.sheetId;
                           const newRange = range.clone({ sheetId, invalidSheetName });
@@ -54871,7 +55261,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (name) {
               const unquotedName = getUnquotedSheetName(name);
               for (const key in this.sheetIdsMapName) {
-                  if (key.toUpperCase() === unquotedName.toUpperCase()) {
+                  if (isSheetNameEqual(key, unquotedName)) {
                       return this.sheetIdsMapName[key];
                   }
               }
@@ -55119,7 +55509,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const { orderedSheetIds, sheets } = this;
           const name = cmd.name && cmd.name.trim().toLowerCase();
-          if (orderedSheetIds.find((id) => sheets[id]?.name.toLowerCase() === name && id !== cmd.sheetId)) {
+          if (orderedSheetIds.find((id) => isSheetNameEqual(sheets[id]?.name, name) && id !== cmd.sheetId)) {
               return "DuplicatedSheetName" /* CommandResult.DuplicatedSheetName */;
           }
           if (FORBIDDEN_SHEETNAME_CHARS_IN_EXCEL_REGEX.test(name)) {
@@ -58080,10 +58470,9 @@ stores.inject(MyMetaStore, storeInstance);
           return this.evaluatedCells.keysForSheet(sheetId);
       }
       getArrayFormulaSpreadingOn(position) {
-          const hasArrayFormulaResult = this.getEvaluatedCell(position).type !== CellValueType.empty &&
-              !this.getters.getCell(position)?.isFormula;
-          if (!hasArrayFormulaResult) {
-              return this.spreadingRelations.isArrayFormula(position) ? position : undefined;
+          const isEmpty = this.getEvaluatedCell(position).type === CellValueType.empty;
+          if (isEmpty) {
+              return undefined;
           }
           const arrayFormulas = this.spreadingRelations.searchFormulaPositionsSpreadingOn(position.sheetId, positionToZone(position));
           return Array.from(arrayFormulas).find((position) => !this.blockedArrayFormulas.has(position));
@@ -64006,6 +64395,55 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class PivotPresenceTracker {
+      trackedValues = new Set();
+      domainToArray(domain) {
+          return domain.flatMap((node) => [node.field, toString(node.value)]);
+      }
+      isValuePresent(measure, domain) {
+          const key = JSON.stringify({ measure, domain: this.domainToArray(domain) });
+          return this.trackedValues.has(key);
+      }
+      isHeaderPresent(domain) {
+          const key = JSON.stringify({ domain: this.domainToArray(domain) });
+          return this.trackedValues.has(key);
+      }
+      trackValue(measure, domain) {
+          const key = JSON.stringify({ measure, domain: this.domainToArray(domain) });
+          this.trackedValues.add(key);
+      }
+      trackHeader(domain) {
+          const key = JSON.stringify({ domain: this.domainToArray(domain) });
+          this.trackedValues.add(key);
+      }
+  }
+
+  class PivotPresencePlugin extends UIPlugin {
+      static getters = ["getPivotPresenceTracker"];
+      trackPresencePivotId;
+      tracker;
+      handle(cmd) {
+          switch (cmd.type) {
+              case "PIVOT_START_PRESENCE_TRACKING":
+                  this.tracker = new PivotPresenceTracker();
+                  this.trackPresencePivotId = cmd.pivotId;
+                  break;
+              case "PIVOT_STOP_PRESENCE_TRACKING":
+                  this.trackPresencePivotId = undefined;
+                  break;
+          }
+      }
+      getPivotPresenceTracker(pivotId) {
+          if (this.trackPresencePivotId !== pivotId) {
+              return undefined;
+          }
+          if (!this.tracker) {
+              throw new Error("Tracker not initialized");
+          }
+          return this.tracker;
+      }
+  }
+
   class SplitToColumnsPlugin extends UIPlugin {
       static getters = ["getAutomaticSeparator"];
       allowDispatch(cmd) {
@@ -66789,6 +67227,7 @@ stores.inject(MyMetaStore, storeInstance);
       .add("automatic_sum", AutomaticSumPlugin)
       .add("format", FormatPlugin)
       .add("insert_pivot", InsertPivotPlugin)
+      .add("pivot_presence", PivotPresencePlugin)
       .add("split_to_columns", SplitToColumnsPlugin)
       .add("collaborative", CollaborativePlugin)
       .add("history", HistoryPlugin)
@@ -67168,11 +67607,11 @@ stores.inject(MyMetaStore, storeInstance);
           if (ev.key === "Enter") {
               ev.preventDefault();
               this.stopEdition();
-              this.DOMFocusableElementStore.focusableElement?.focus();
+              this.DOMFocusableElementStore.focus();
           }
           if (ev.key === "Escape") {
               this.cancelEdition();
-              this.DOMFocusableElementStore.focusableElement?.focus();
+              this.DOMFocusableElementStore.focus();
           }
       }
       onMouseEventSheetName(ev) {
@@ -73782,6 +74221,7 @@ stores.inject(MyMetaStore, storeInstance);
       PivotDimensionOrder,
       PivotDimension,
       PivotLayoutConfigurator,
+      PivotHTMLRenderer,
       EditableName,
       PivotDeferUpdate,
       PivotTitleSection,
@@ -73875,9 +74315,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.0.27";
-  __info__.date = "2025-05-12T05:25:47.149Z";
-  __info__.hash = "9b36340";
+  __info__.version = "18.0.29";
+  __info__.date = "2025-05-20T05:54:57.329Z";
+  __info__.hash = "8213c0e";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);