@odoo/o-spreadsheet 18.1.18 → 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.18
- * @date 2025-05-02T12:30:47.822Z
- * @hash 29c21c6
+ * @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);
@@ -6272,6 +6272,32 @@
       })
           .filter(isDefined);
   }
+  function getNextSheetName(existingNames, baseName = "Sheet") {
+      let i = 1;
+      let name = `${baseName}${i}`;
+      while (existingNames.includes(name)) {
+          name = `${baseName}${i}`;
+          i++;
+      }
+      return name;
+  }
+  function getDuplicateSheetName(nameToDuplicate, existingNames) {
+      let i = 1;
+      const baseName = _t("Copy of %s", nameToDuplicate);
+      let name = baseName.toString();
+      while (existingNames.includes(name)) {
+          name = `${baseName} (${i})`;
+          i++;
+      }
+      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;
@@ -7970,6 +7996,24 @@
           return `${normalizedValue}`;
       },
   };
+  /**
+   * normalizes month number + year
+   */
+  const monthAdapter = {
+      normalizeFunctionValue(value) {
+          const date = toNumber(value, DEFAULT_LOCALE);
+          return formatValue(date, { locale: DEFAULT_LOCALE, format: "mm/yyyy" });
+      },
+      toValueAndFormat(normalizedValue) {
+          return {
+              value: toNumber(normalizedValue, DEFAULT_LOCALE),
+              format: "mmmm yyyy",
+          };
+      },
+      toFunctionValue(normalizedValue) {
+          return `"${normalizedValue}"`;
+      },
+  };
   /**
    * normalizes quarter number
    */
@@ -8100,6 +8144,7 @@
       .add("day_of_month", nullHandlerDecorator(dayOfMonthAdapter))
       .add("iso_week_number", nullHandlerDecorator(isoWeekNumberAdapter))
       .add("month_number", nullHandlerDecorator(monthNumberAdapter))
+      .add("month", nullHandlerDecorator(monthAdapter))
       .add("quarter_number", nullHandlerDecorator(quarterNumberAdapter))
       .add("day_of_week", nullHandlerDecorator(dayOfWeekAdapter))
       .add("hour_number", nullHandlerDecorator(hourNumberAdapter))
@@ -8116,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 = {};
@@ -8279,10 +8323,7 @@
       return normalizer(groupValueString, dimension.granularity);
   }
   function normalizeDateTime(value, granularity) {
-      if (!granularity) {
-          throw new Error("Missing granularity");
-      }
-      return pivotTimeAdapter(granularity).normalizeFunctionValue(value);
+      return pivotTimeAdapter(granularity ?? "month").normalizeFunctionValue(value);
   }
   function toFunctionPivotValue(value, dimension) {
       if (value === null) {
@@ -8294,10 +8335,7 @@
       return pivotToFunctionValueRegistry.get(dimension.type)(value, dimension.granularity);
   }
   function toFunctionValueDateTime(value, granularity) {
-      if (!granularity) {
-          throw new Error("Missing granularity");
-      }
-      return pivotTimeAdapter(granularity).toFunctionValue(value);
+      return pivotTimeAdapter(granularity ?? "month").toFunctionValue(value);
   }
   const pivotNormalizationValueRegistry = new Registry();
   pivotNormalizationValueRegistry
@@ -9477,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();
                       },
                   });
@@ -9499,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) {
@@ -9519,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";
       }
   }
 
@@ -9579,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");
@@ -9597,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.
@@ -9612,12 +9655,24 @@ stores.inject(MyMetaStore, storeInstance);
   }
 
   const chartJsExtensionRegistry = new Registry();
-  /** Return window.Chart, making sure all our extensions are loaded in ChartJS */
-  function getChartJSConstructor() {
-      if (window.Chart && !window.Chart?.registry.plugins.get("chartShowValuesPlugin")) {
-          window.Chart.register(...chartJsExtensionRegistry.getAll());
+  function areChartJSExtensionsLoaded() {
+      return !!window.Chart.registry.plugins.get("chartShowValuesPlugin");
+  }
+  function registerChartJSExtensions() {
+      if (!window.Chart || areChartJSExtensionsLoaded()) {
+          return;
+      }
+      for (const registryItem of chartJsExtensionRegistry.getAll()) {
+          registryItem.register(window.Chart);
+      }
+  }
+  function unregisterChartJsExtensions() {
+      if (!window.Chart) {
+          return;
+      }
+      for (const registryItem of chartJsExtensionRegistry.getAll()) {
+          registryItem.unregister(window.Chart);
       }
-      return window.Chart;
   }
 
   const TREND_LINE_XAXIS_ID = "x1";
@@ -9934,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);
       };
   }
@@ -10098,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);
           }
       }
@@ -10158,8 +10213,14 @@ stores.inject(MyMetaStore, storeInstance);
       return bars.find((bar, i) => i > startIndex && bar.height !== 0);
   }
 
-  chartJsExtensionRegistry.add("chartShowValuesPlugin", chartShowValuesPlugin);
-  chartJsExtensionRegistry.add("waterfallLinesPlugin", waterfallLinesPlugin);
+  chartJsExtensionRegistry.add("chartShowValuesPlugin", {
+      register: (Chart) => Chart.register(chartShowValuesPlugin),
+      unregister: (Chart) => Chart.unregister(chartShowValuesPlugin),
+  });
+  chartJsExtensionRegistry.add("waterfallLinesPlugin", {
+      register: (Chart) => Chart.register(waterfallLinesPlugin),
+      unregister: (Chart) => Chart.unregister(waterfallLinesPlugin),
+  });
   class ChartJsComponent extends owl.Component {
       static template = "o-spreadsheet-ChartJsComponent";
       static props = {
@@ -10211,8 +10272,7 @@ stores.inject(MyMetaStore, storeInstance);
       createChart(chartData) {
           const canvas = this.canvas.el;
           const ctx = canvas.getContext("2d");
-          const Chart = getChartJSConstructor();
-          this.chart = new Chart(ctx, chartData);
+          this.chart = new window.Chart(ctx, chartData);
       }
       updateChartJs(chartData) {
           if (chartData.data && chartData.data.datasets) {
@@ -18344,7 +18404,7 @@ stores.inject(MyMetaStore, storeInstance);
               return { value: "" };
           }
           if (result.value === null) {
-              result.value = "";
+              return { ...result, value: "" };
           }
           return result;
       },
@@ -18365,7 +18425,7 @@ stores.inject(MyMetaStore, storeInstance);
               return { value: "" };
           }
           if (result.value === null) {
-              result.value = "";
+              return { ...result, value: "" };
           }
           return result;
       },
@@ -18386,7 +18446,7 @@ stores.inject(MyMetaStore, storeInstance);
               return { value: "" };
           }
           if (result.value === null) {
-              result.value = "";
+              return { ...result, value: "" };
           }
           return result;
       },
@@ -18412,7 +18472,7 @@ stores.inject(MyMetaStore, storeInstance);
                       return { value: "" };
                   }
                   if (result.value === null) {
-                      result.value = "";
+                      return { ...result, value: "" };
                   }
                   return result;
               }
@@ -18530,6 +18590,11 @@ stores.inject(MyMetaStore, storeInstance);
           if (range === undefined || range.invalidXc || range.invalidSheetName) {
               throw new InvalidReferenceError();
           }
+          if (evalContext.__originCellPosition &&
+              range.sheetId === evalContext.__originSheetId &&
+              isZoneInside(positionToZone(evalContext.__originCellPosition), zone)) {
+              throw new CircularDependencyError();
+          }
           dependencies.push(range);
       }
       for (const measure of forMeasures) {
@@ -18978,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);
       },
   };
@@ -19009,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);
@@ -19231,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: [
@@ -19252,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 };
       },
   };
@@ -19291,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;
           });
       },
@@ -19306,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;
           });
       },
@@ -20912,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);
@@ -22791,6 +22874,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
       },
       animation: false,
+      events: ["mousemove", "mouseout", "click", "touchstart", "touchmove", "mouseup"],
   };
   function truncateLabel(label) {
       if (!label) {
@@ -22816,8 +22900,7 @@ stores.inject(MyMetaStore, storeInstance);
       if ("chartJsConfig" in runtime) {
           const config = deepCopy(runtime.chartJsConfig);
           config.plugins = [backgroundColorChartJSPlugin];
-          const Chart = getChartJSConstructor();
-          const chart = new Chart(canvas, config);
+          const chart = new window.Chart(canvas, config);
           const imgContent = chart.toBase64Image();
           chart.destroy();
           div.remove();
@@ -24523,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);
           }
@@ -24864,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;
           }
@@ -25515,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) {
@@ -27949,6 +28032,7 @@ stores.inject(MyMetaStore, storeInstance);
       initialMessages = dropCommands(initialMessages, "SORT_CELLS");
       initialMessages = dropCommands(initialMessages, "SET_DECIMAL");
       initialMessages = fixChartDefinitions(data, initialMessages);
+      initialMessages = fixTranslatedDuplicateSheetName(data, initialMessages);
       return initialMessages;
   }
   /**
@@ -28048,6 +28132,40 @@ stores.inject(MyMetaStore, storeInstance);
       }
       return messages;
   }
+  function fixTranslatedDuplicateSheetName(data, initialMessages) {
+      const sheetNames = {};
+      for (const sheet of data.sheets || []) {
+          sheetNames[sheet.id] = sheet.name;
+      }
+      const messages = [];
+      for (const message of initialMessages) {
+          if (message.type === "REMOTE_REVISION") {
+              const commands = [];
+              for (const cmd of message.commands) {
+                  switch (cmd.type) {
+                      case "DUPLICATE_SHEET":
+                          cmd.sheetNameTo =
+                              cmd.sheetNameTo ??
+                                  getDuplicateSheetName(sheetNames[cmd.sheetId], Object.values(sheetNames));
+                          break;
+                      case "CREATE_SHEET":
+                      case "RENAME_SHEET":
+                          sheetNames[cmd.sheetId] = cmd.name || getNextSheetName(Object.values(sheetNames));
+                          break;
+                  }
+                  commands.push(cmd);
+              }
+              messages.push({
+                  ...message,
+                  commands,
+              });
+          }
+          else {
+              messages.push(message);
+          }
+      }
+      return initialMessages;
+  }
   // -----------------------------------------------------------------------------
   // Helpers
   // -----------------------------------------------------------------------------
@@ -28845,12 +28963,11 @@ stores.inject(MyMetaStore, storeInstance);
   }
   let missingTimeAdapterAlreadyWarned = false;
   function isLuxonTimeAdapterInstalled() {
-      const Chart = getChartJSConstructor();
-      if (!Chart) {
+      if (!window.Chart) {
           return false;
       }
       // @ts-ignore
-      const adapter = new Chart._adapters._date({});
+      const adapter = new window.Chart._adapters._date({});
       const isInstalled = adapter._id === "luxon";
       if (!isInstalled && !missingTimeAdapterAlreadyWarned) {
           missingTimeAdapterAlreadyWarned = true;
@@ -29488,6 +29605,9 @@ stores.inject(MyMetaStore, storeInstance);
           target.style.cursor = "default";
       },
       onClick: (event, legendItem, legend) => {
+          if (event.type !== "click") {
+              return;
+          }
           const index = legendItem.datasetIndex;
           if (!legend.legendItems || index === undefined) {
               return;
@@ -32313,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;
       }
   }
 
@@ -32340,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 });
@@ -33213,10 +33345,13 @@ stores.inject(MyMetaStore, storeInstance);
       name: _t("Duplicate"),
       execute: (env) => {
           const sheetIdFrom = env.model.getters.getActiveSheetId();
+          const sheetNameFrom = env.model.getters.getSheetName(sheetIdFrom);
           const sheetIdTo = env.model.uuidGenerator.smallUuid();
+          const sheetNameTo = env.model.getters.getDuplicateSheetName(sheetNameFrom);
           env.model.dispatch("DUPLICATE_SHEET", {
               sheetId: sheetIdFrom,
               sheetIdTo,
+              sheetNameTo,
           });
           env.model.dispatch("ACTIVATE_SHEET", { sheetIdFrom, sheetIdTo });
       },
@@ -40169,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;
       }
   }
 
@@ -40762,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(() => {
@@ -41036,6 +41179,13 @@ stores.inject(MyMetaStore, storeInstance);
       openAssistant() {
           this.assistant.forcedClosed = false;
       }
+      onWheel(event) {
+          // detect if scrollbar is available
+          if (this.composerRef.el &&
+              this.composerRef.el.scrollHeight > this.composerRef.el.clientHeight) {
+              event.stopPropagation();
+          }
+      }
       // ---------------------------------------------------------------------------
       // Private
       // ---------------------------------------------------------------------------
@@ -45973,8 +46123,8 @@ stores.inject(MyMetaStore, storeInstance);
 
   const NULL_SYMBOL = Symbol("NULL");
   function createDate(dimension, value, locale) {
-      const granularity = dimension.granularity;
-      if (!granularity || !(granularity in MAP_VALUE_DIMENSION_DATE)) {
+      const granularity = dimension.granularity || "month";
+      if (!(granularity in MAP_VALUE_DIMENSION_DATE)) {
           throw new Error(`Unknown date granularity: ${granularity}`);
       }
       const keyInMap = typeof value === "number" || typeof value === "string" ? value : NULL_SYMBOL;
@@ -45993,6 +46143,9 @@ stores.inject(MyMetaStore, storeInstance);
                   case "month_number":
                       number = date.getMonth() + 1;
                       break;
+                  case "month":
+                      number = Math.floor(toNumber(value, locale));
+                      break;
                   case "iso_week_number":
                       number = date.getIsoWeek();
                       break;
@@ -46086,6 +46239,10 @@ stores.inject(MyMetaStore, storeInstance);
           set: new Set(),
           values: {},
       },
+      month: {
+          set: new Set(),
+          values: {},
+      },
       iso_week_number: {
           set: new Set(),
           values: {},
@@ -46296,7 +46453,7 @@ stores.inject(MyMetaStore, storeInstance);
           const cells = this.filterDataEntriesFromDomain(this.dataEntries, domain);
           const finalCell = cells[0]?.[dimension.nameWithGranularity];
           if (dimension.type === "datetime") {
-              const adapter = pivotTimeAdapter(dimension.granularity);
+              const adapter = pivotTimeAdapter((dimension.granularity || "month"));
               return adapter.toValueAndFormat(lastNode.value, this.getters.getLocale());
           }
           if (!finalCell) {
@@ -46414,7 +46571,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (nonEmptyCells.length === 0) {
               return "integer";
           }
-          if (nonEmptyCells.every((cell) => cell.format && isDateTimeFormat(cell.format))) {
+          if (nonEmptyCells.every((cell) => cell.type === CellValueType.number && cell.format && isDateTimeFormat(cell.format))) {
               return "datetime";
           }
           if (nonEmptyCells.every((cell) => cell.type === CellValueType.boolean)) {
@@ -46495,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" };
@@ -46509,7 +46671,7 @@ stores.inject(MyMetaStore, storeInstance);
               for (const entry of dataEntries) {
                   for (const dimension of dateDimensions) {
                       const value = createDate(dimension, entry[dimension.fieldName]?.value || null, this.getters.getLocale());
-                      const adapter = pivotTimeAdapter(dimension.granularity);
+                      const adapter = pivotTimeAdapter((dimension.granularity || "month"));
                       const { format, value: valueToFormat } = adapter.toValueAndFormat(value, locale);
                       entry[dimension.nameWithGranularity] = {
                           value,
@@ -46529,6 +46691,7 @@ stores.inject(MyMetaStore, storeInstance);
       "year",
       "quarter_number",
       "month_number",
+      "month",
       "iso_week_number",
       "day_of_month",
       "day",
@@ -46776,7 +46939,7 @@ stores.inject(MyMetaStore, storeInstance);
                   : this.datetimeGranularities);
           }
           for (const field of dateFields) {
-              granularitiesPerFields[field.fieldName].delete(field.granularity);
+              granularitiesPerFields[field.fieldName].delete(field.granularity || "month");
           }
           return granularitiesPerFields;
       }
@@ -48951,6 +49114,8 @@ stores.inject(MyMetaStore, storeInstance);
       }
       get composerProps() {
           const { width, height } = this.env.model.getters.getSheetViewDimensionWithHeaders();
+          // Remove the wrapper border width
+          const maxHeight = this.props.gridDims.height - this.rect.y - 2 * COMPOSER_BORDER_WIDTH;
           return {
               rect: { ...this.rect },
               delimitation: {
@@ -48968,6 +49133,7 @@ stores.inject(MyMetaStore, storeInstance);
               }),
               onInputContextMenu: this.props.onInputContextMenu,
               composerStore: this.composerStore,
+              inputStyle: `max-height: ${maxHeight}px;`,
           };
       }
       get containerStyle() {
@@ -51520,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);
           }
       }
@@ -52213,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), () => {
@@ -52423,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() {
@@ -52768,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
    *
@@ -54258,9 +54736,7 @@ stores.inject(MyMetaStore, storeInstance);
               : "Success" /* CommandResult.Success */;
       }
       checkChartExists(cmd) {
-          return this.getters.getFigureSheetId(cmd.id)
-              ? "Success" /* CommandResult.Success */
-              : "ChartDoesNotExist" /* CommandResult.ChartDoesNotExist */;
+          return this.isChartDefined(cmd.id) ? "Success" /* CommandResult.Success */ : "ChartDoesNotExist" /* CommandResult.ChartDoesNotExist */;
       }
   }
 
@@ -56207,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 });
@@ -56545,6 +57021,7 @@ stores.inject(MyMetaStore, storeInstance);
           "getCommandZones",
           "getUnboundedZone",
           "checkElementsIncludeAllNonFrozenHeaders",
+          "getDuplicateSheetName",
       ];
       sheetIdsMapName = {};
       orderedSheetIds = [];
@@ -56569,7 +57046,11 @@ stores.inject(MyMetaStore, storeInstance);
                   return this.checkValidations(cmd, this.checkSheetName, this.checkSheetPosition);
               }
               case "DUPLICATE_SHEET": {
-                  return this.sheets[cmd.sheetIdTo] ? "DuplicatedSheetId" /* CommandResult.DuplicatedSheetId */ : "Success" /* CommandResult.Success */;
+                  if (this.sheets[cmd.sheetIdTo])
+                      return "DuplicatedSheetId" /* CommandResult.DuplicatedSheetId */;
+                  if (this.orderedSheetIds.map(this.getSheetName.bind(this)).includes(cmd.sheetNameTo))
+                      return "DuplicatedSheetName" /* CommandResult.DuplicatedSheetName */;
+                  return "Success" /* CommandResult.Success */;
               }
               case "MOVE_SHEET":
                   try {
@@ -56646,7 +57127,7 @@ stores.inject(MyMetaStore, storeInstance);
                   this.showSheet(cmd.sheetId);
                   break;
               case "DUPLICATE_SHEET":
-                  this.duplicateSheet(cmd.sheetId, cmd.sheetIdTo);
+                  this.duplicateSheet(cmd.sheetId, cmd.sheetIdTo, cmd.sheetNameTo);
                   break;
               case "DELETE_SHEET":
                   this.deleteSheet(this.sheets[cmd.sheetId]);
@@ -56787,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];
                   }
               }
@@ -56852,14 +57333,8 @@ stores.inject(MyMetaStore, storeInstance);
           return dimension === "COL" ? this.getNumberCols(sheetId) : this.getNumberRows(sheetId);
       }
       getNextSheetName(baseName = "Sheet") {
-          let i = 1;
           const names = this.orderedSheetIds.map(this.getSheetName.bind(this));
-          let name = `${baseName}${i}`;
-          while (names.includes(name)) {
-              name = `${baseName}${i}`;
-              i++;
-          }
-          return name;
+          return getNextSheetName(names, baseName);
       }
       getSheetSize(sheetId) {
           return {
@@ -57041,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)) {
@@ -57105,9 +57580,8 @@ stores.inject(MyMetaStore, storeInstance);
       showSheet(sheetId) {
           this.history.update("sheets", sheetId, "isVisible", true);
       }
-      duplicateSheet(fromId, toId) {
+      duplicateSheet(fromId, toId, toName) {
           const sheet = this.getSheet(fromId);
-          const toName = this.getDuplicateSheetName(sheet.name);
           const newSheet = deepCopy(sheet);
           newSheet.id = toId;
           newSheet.name = toName;
@@ -57139,15 +57613,8 @@ stores.inject(MyMetaStore, storeInstance);
           this.history.update("sheetIdsMapName", sheetIdsMapName);
       }
       getDuplicateSheetName(sheetName) {
-          let i = 1;
           const names = this.orderedSheetIds.map(this.getSheetName.bind(this));
-          const baseName = _t("Copy of %s", sheetName);
-          let name = baseName.toString();
-          while (names.includes(name)) {
-              name = `${baseName} (${i})`;
-              i++;
-          }
-          return name;
+          return getDuplicateSheetName(sheetName, names);
       }
       deleteSheet(sheet) {
           const name = sheet.name;
@@ -59974,8 +60441,8 @@ stores.inject(MyMetaStore, storeInstance);
   const EMPTY_ARRAY = [];
 
   const MAX_ITERATION = 30;
-  const ERROR_CYCLE_CELL = createEvaluatedCell(new CircularDependencyError());
-  const EMPTY_CELL = createEvaluatedCell({ value: null });
+  const ERROR_CYCLE_CELL = Object.freeze(createEvaluatedCell(new CircularDependencyError()));
+  const EMPTY_CELL = Object.freeze(createEvaluatedCell({ value: null }));
   class Evaluator {
       context;
       getters;
@@ -65952,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) {
@@ -68739,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)
@@ -69119,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) {
@@ -71307,11 +71824,13 @@ stores.inject(MyMetaStore, storeInstance);
               this.checkViewportSize();
               stores.on("store-updated", this, render);
               resizeObserver.observe(this.spreadsheetRef.el);
+              registerChartJSExtensions();
           });
           owl.onWillUnmount(() => {
               this.unbindModelEvents();
               stores.off("store-updated", this);
               resizeObserver.disconnect();
+              unregisterChartJsExtensions();
           });
           owl.onPatched(() => {
               this.checkViewportSize();
@@ -75712,6 +76231,7 @@ stores.inject(MyMetaStore, storeInstance);
       PivotDimensionOrder,
       PivotDimension,
       PivotLayoutConfigurator,
+      PivotHTMLRenderer,
       PivotDeferUpdate,
       PivotTitleSection,
       CogWheelMenu,
@@ -75805,9 +76325,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.1.18";
-  __info__.date = "2025-05-02T12:30:47.822Z";
-  __info__.hash = "29c21c6";
+  __info__.version = "18.1.20";
+  __info__.date = "2025-05-13T17:52:28.174Z";
+  __info__.hash = "3e43a46";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);