@odoo/o-spreadsheet 18.1.19 → 18.1.20

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.1.19
- * @date 2025-05-12T05:26:05.861Z
- * @hash 44cc170
+ * @version 18.1.20
+ * @date 2025-05-13T17:52:28.174Z
+ * @hash 3e43a46
  */
 
 (function (exports, owl) {
@@ -3347,7 +3347,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);
@@ -6291,6 +6291,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;
@@ -8154,10 +8161,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 = {};
@@ -9509,7 +9515,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();
                       },
                   });
@@ -9531,7 +9540,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) {
@@ -9551,14 +9560,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";
       }
   }
 
@@ -9611,16 +9620,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");
@@ -9629,6 +9639,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.
@@ -9978,7 +9989,7 @@ stores.inject(MyMetaStore, storeInstance);
   }
   function formatChartDatasetValue(axisFormats, locale) {
       return (value, axisId) => {
-          const format = axisId ? axisFormats?.[axisId] : undefined;
+          const format = axisFormats?.[axisId];
           return formatTickValue({ format, locale })(value);
       };
   }
@@ -10142,7 +10153,7 @@ stores.inject(MyMetaStore, storeInstance);
               const y = bar.y + midRadius * Math.sin(midAngle) + 7;
               ctx.fillStyle = chartFontColor(options.background);
               ctx.strokeStyle = options.background || "#ffffff";
-              const displayValue = options.callback(value);
+              const displayValue = options.callback(value, "y");
               drawTextWithBackground(displayValue, x, y, ctx);
           }
       }
@@ -19032,6 +19043,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);
       },
   };
@@ -19063,6 +19077,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);
@@ -19285,6 +19302,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: [
@@ -19306,6 +19326,9 @@ stores.inject(MyMetaStore, storeInstance);
           if (typeof _value2 === "string") {
               _value2 = _value2.toUpperCase();
           }
+          if (typeof _value1 === "number" && typeof _value2 === "number") {
+              return { value: areAlmostEqual(_value1, _value2) };
+          }
           return { value: _value1 === _value2 };
       },
   };
@@ -19345,6 +19368,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;
           });
       },
@@ -19360,6 +19386,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;
           });
       },
@@ -20966,7 +20995,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);
@@ -24577,7 +24606,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);
           }
@@ -24918,7 +24947,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;
           }
@@ -25569,7 +25598,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) {
@@ -32404,12 +32433,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;
       }
   }
 
@@ -32431,7 +32468,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 });
@@ -40263,10 +40304,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;
       }
   }
 
@@ -40856,7 +40905,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(() => {
@@ -46603,7 +46652,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" };
@@ -51632,10 +51686,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);
           }
       }
@@ -52325,7 +52375,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), () => {
@@ -52535,7 +52585,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() {
@@ -52880,6 +52930,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
    *
@@ -56317,7 +56683,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 });
@@ -56902,7 +57268,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];
                   }
               }
@@ -57150,7 +57516,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)) {
@@ -66053,6 +66419,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) {
@@ -68840,6 +69255,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)
@@ -69220,11 +69636,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) {
@@ -75815,6 +76231,7 @@ stores.inject(MyMetaStore, storeInstance);
       PivotDimensionOrder,
       PivotDimension,
       PivotLayoutConfigurator,
+      PivotHTMLRenderer,
       PivotDeferUpdate,
       PivotTitleSection,
       CogWheelMenu,
@@ -75908,9 +76325,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.1.19";
-  __info__.date = "2025-05-12T05:26:05.861Z";
-  __info__.hash = "44cc170";
+  __info__.version = "18.1.20";
+  __info__.date = "2025-05-13T17:52:28.174Z";
+  __info__.hash = "3e43a46";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);