@odoo/o-spreadsheet 18.0.27 → 18.0.29

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.0.27
- * @date 2025-05-12T05:25:47.149Z
- * @hash 9b36340
+ * @version 18.0.29
+ * @date 2025-05-20T05:54:57.329Z
+ * @hash 8213c0e
  */
 
 'use strict';
@@ -1454,18 +1454,53 @@ function lettersToNumber(letters) {
     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.
  *
@@ -1476,33 +1511,17 @@ function isCharADigit(char) {
  * 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 };
@@ -1914,67 +1933,6 @@ class LazyTranslatedString extends String {
     }
 }
 
-/** 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
@@ -1992,63 +1950,55 @@ function getFullReference(sheetName, xc) {
  *
  */
 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,
@@ -2077,7 +2027,16 @@ function toZoneWithoutBoundaryChanges(xc) {
  */
 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.
@@ -3182,7 +3141,7 @@ function isDateAfter(date, dateAfter) {
  */
 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);
@@ -5798,6 +5757,67 @@ function scrollDelay(value) {
     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;
@@ -6123,6 +6143,13 @@ function getDuplicateSheetName(nameToDuplicate, existingNames) {
     }
     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;
@@ -7976,10 +8003,9 @@ 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: 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 = {};
@@ -9312,7 +9338,10 @@ function proxifyStoreMutation(store, callback) {
                 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();
                     },
                 });
@@ -9334,7 +9363,7 @@ function getDependencyContainer(env) {
 const ModelStore = createAbstractStore("Model");
 
 class RendererStore {
-    mutators = ["register", "unRegister"];
+    mutators = ["register", "unRegister", "drawLayer"];
     renderers = {};
     register(renderer) {
         if (!renderer.renderingLayers.length) {
@@ -9354,14 +9383,14 @@ class RendererStore {
     }
     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";
     }
 }
 
@@ -9414,16 +9443,17 @@ class ComposerFocusStore extends SpreadsheetStore {
     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");
@@ -9432,6 +9462,7 @@ class ComposerFocusStore extends SpreadsheetStore {
         if (this._focusMode !== "inactive") {
             this.setComposerContent(args);
         }
+        return;
     }
     /**
      * Start the edition or update the content if it's already started.
@@ -11746,7 +11777,7 @@ function getRangeSize(reference, defaultSheetIndex, data) {
     ({ 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);
         }
@@ -12087,7 +12118,7 @@ function convertFormula(formula, data) {
     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;
         }
@@ -12750,7 +12781,7 @@ function convertPivotTableConfig(pivotTable) {
  */
 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) {
@@ -25073,6 +25104,9 @@ const PIVOT_VALUE = {
             };
         }
         const domain = pivot.parseArgsToPivotDomain(domainArgs);
+        if (this.getters.getActiveSheetId() === this.__originSheetId) {
+            this.getters.getPivotPresenceTracker(pivotId)?.trackValue(_measure, domain);
+        }
         return pivot.getPivotCellValueAndFormat(_measure, domain);
     },
 };
@@ -25104,6 +25138,9 @@ const PIVOT_HEADER = {
             };
         }
         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);
@@ -25326,6 +25363,9 @@ function isEmpty(data) {
     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: [
@@ -25341,6 +25381,9 @@ const EQ = {
         if (typeof _value2 === "string") {
             _value2 = _value2.toUpperCase();
         }
+        if (typeof _value1 === "number" && typeof _value2 === "number") {
+            return areAlmostEqual(_value1, _value2);
+        }
         return _value1 === _value2;
     },
 };
@@ -25380,6 +25423,9 @@ const GT = {
     ],
     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;
         });
     },
@@ -25395,6 +25441,9 @@ const GTE = {
     ],
     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;
         });
     },
@@ -26517,10 +26566,18 @@ autoCompleteProviders.add("functions", {
 });
 
 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;
     }
 }
 
@@ -27363,7 +27420,7 @@ class Composer extends owl.Component {
             if (document.activeElement === this.contentHelper.el &&
                 this.props.composerStore.editionMode === "inactive" &&
                 !this.props.isDefaultFocus) {
-                this.DOMFocusableElementStore.focusableElement?.focus();
+                this.DOMFocusableElementStore.focus();
             }
         });
         owl.useEffect(() => {
@@ -31835,12 +31892,20 @@ class HoveredCellStore extends SpreadsheetStore {
         }
     }
     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;
     }
 }
 
@@ -31862,7 +31927,11 @@ class CellPopoverStore extends SpreadsheetStore {
         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 });
@@ -39215,7 +39284,7 @@ class AbstractComposerStore extends SpreadsheetStore {
             .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);
@@ -39446,12 +39515,13 @@ class StandaloneComposerStore extends AbstractComposerStore {
         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);
@@ -39461,7 +39531,7 @@ class StandaloneComposerStore extends AbstractComposerStore {
             })
                 .join("");
         }
-        return this._currentContent;
+        return localizeContent(content, this.getters.getLocale());
     }
     stopEdition() {
         this._stopEdition();
@@ -43064,6 +43134,9 @@ class PivotMeasureEditor extends owl.Component {
             measure: this.props.measure,
         });
     }
+    get isCalculatedMeasureInvalid() {
+        return this.env.model.getters.getMeasureCompiledFormula(this.props.measure).isBadExpression;
+    }
 }
 
 css /* scss */ `
@@ -44512,7 +44585,12 @@ class SpreadsheetPivot {
                     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" };
@@ -49508,10 +49586,6 @@ function useGridDrawing(refName, model, canvasSize) {
         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);
         }
     }
@@ -50201,7 +50275,7 @@ class Grid extends owl.Component {
         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), () => {
@@ -50409,7 +50483,7 @@ class Grid extends owl.Component {
     focusDefaultElement() {
         if (!this.env.model.getters.getSelectedFigureId() &&
             this.composerFocusStore.activeComposer.editionMode === "inactive") {
-            this.DOMFocusableElementStore.focusableElement?.focus();
+            this.DOMFocusableElementStore.focus();
         }
     }
     get gridEl() {
@@ -50779,6 +50853,322 @@ class EditableName extends owl.Component {
     }
 }
 
+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
  *
@@ -54287,7 +54677,7 @@ class RangeAdapter {
                     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 });
@@ -54872,7 +55262,7 @@ class SheetPlugin extends CorePlugin {
         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];
                 }
             }
@@ -55120,7 +55510,7 @@ class SheetPlugin extends CorePlugin {
         }
         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)) {
@@ -58081,10 +58471,9 @@ class Evaluator {
         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));
@@ -64007,6 +64396,55 @@ class HistoryPlugin extends UIPlugin {
     }
 }
 
+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) {
@@ -66790,6 +67228,7 @@ const featurePluginRegistry = new Registry()
     .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)
@@ -67169,11 +67608,11 @@ class BottomBarSheet extends owl.Component {
         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) {
@@ -73783,6 +74222,7 @@ const components = {
     PivotDimensionOrder,
     PivotDimension,
     PivotLayoutConfigurator,
+    PivotHTMLRenderer,
     EditableName,
     PivotDeferUpdate,
     PivotTitleSection,
@@ -73876,6 +74316,6 @@ exports.tokenColors = tokenColors;
 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";