@odoo/o-spreadsheet 18.3.1 → 18.3.3

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.3.1
- * @date 2025-05-02T12:33:27.384Z
- * @hash 7b9574b
+ * @version 18.3.3
+ * @date 2025-05-13T17:54:43.312Z
+ * @hash b79924a
  */
 
 (function (exports, owl) {
@@ -3320,7 +3320,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);
@@ -6001,6 +6001,67 @@
       return MIN_DELAY + (MAX_DELAY - MIN_DELAY) * Math.exp(-ACCELERATION * (value - 1));
   }
 
+  function createDefaultRows(rowNumber) {
+      const rows = [];
+      for (let i = 0; i < rowNumber; i++) {
+          const row = {
+              cells: {},
+          };
+          rows.push(row);
+      }
+      return rows;
+  }
+  function moveHeaderIndexesOnHeaderAddition(indexHeaderAdded, numberAdded, headers) {
+      return headers.map((header) => {
+          if (header >= indexHeaderAdded) {
+              return header + numberAdded;
+          }
+          return header;
+      });
+  }
+  function moveHeaderIndexesOnHeaderDeletion(deletedHeaders, headers) {
+      deletedHeaders = [...deletedHeaders].sort((a, b) => b - a);
+      return headers
+          .map((header) => {
+          for (const deletedHeader of deletedHeaders) {
+              if (header > deletedHeader) {
+                  header--;
+              }
+              else if (header === deletedHeader) {
+                  return undefined;
+              }
+          }
+          return header;
+      })
+          .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 createRange(args, getSheetSize) {
       const unboundedZone = args.zone;
       const zone = boundUnboundedZone(unboundedZone, getSheetSize(args.sheetId));
@@ -6291,7 +6352,7 @@
       elements.sort((a, b) => b - a);
       const groups = groupConsecutive(elements);
       return (range) => {
-          if (range.sheetId !== cmd.sheetId) {
+          if (!isSheetNameEqual(range.sheetId, cmd.sheetId)) {
               return { changeType: "NONE" };
           }
           let newRange = range;
@@ -6498,41 +6559,6 @@
       return results.map((r) => r.elem);
   }
 
-  function createDefaultRows(rowNumber) {
-      const rows = [];
-      for (let i = 0; i < rowNumber; i++) {
-          const row = {
-              cells: {},
-          };
-          rows.push(row);
-      }
-      return rows;
-  }
-  function moveHeaderIndexesOnHeaderAddition(indexHeaderAdded, numberAdded, headers) {
-      return headers.map((header) => {
-          if (header >= indexHeaderAdded) {
-              return header + numberAdded;
-          }
-          return header;
-      });
-  }
-  function moveHeaderIndexesOnHeaderDeletion(deletedHeaders, headers) {
-      deletedHeaders = [...deletedHeaders].sort((a, b) => b - a);
-      return headers
-          .map((header) => {
-          for (const deletedHeader of deletedHeaders) {
-              if (header > deletedHeader) {
-                  header--;
-              }
-              else if (header === deletedHeader) {
-                  return undefined;
-              }
-          }
-          return header;
-      })
-          .filter(isDefined);
-  }
-
   function computeTextLinesHeight(textLineHeight, numberOfLines = 1) {
       return numberOfLines * (textLineHeight + MIN_CELL_TEXT_MARGIN) - MIN_CELL_TEXT_MARGIN;
   }
@@ -8274,6 +8300,25 @@
           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) {
+          const jsDate = toJsDate(normalizedValue, DEFAULT_LOCALE);
+          return `DATE(${jsDate.getFullYear()},${jsDate.getMonth() + 1},1)`;
+      },
+  };
   /**
    * normalizes quarter number
    */
@@ -8409,6 +8454,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))
@@ -8425,10 +8471,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"],
       datetime: ["max", "min", "count_distinct", "count"],
   };
@@ -8589,10 +8634,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) {
@@ -8604,10 +8646,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
@@ -9802,7 +9841,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();
                       },
                   });
@@ -9824,7 +9866,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) {
@@ -9844,14 +9886,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";
       }
   }
 
@@ -9904,16 +9946,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");
@@ -9922,6 +9965,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.
@@ -10081,20 +10125,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")) {
-          const extensions = chartJsExtensionRegistry.getAll();
-          for (const extension of extensions) {
-              if (typeof extension === "function") {
-                  extension(window.Chart);
-              }
-              else {
-                  window.Chart.register(extension);
-              }
-          }
+  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;
   }
 
   function getFunnelChartController() {
@@ -10521,7 +10569,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);
       };
   }
@@ -10698,7 +10746,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);
           }
       }
@@ -11460,13 +11508,35 @@ stores.inject(MyMetaStore, storeInstance);
     }
   }
 `;
-  chartJsExtensionRegistry.add("chartShowValuesPlugin", chartShowValuesPlugin);
-  chartJsExtensionRegistry.add("waterfallLinesPlugin", waterfallLinesPlugin);
-  chartJsExtensionRegistry.add("funnelController", (Chart) => Chart.register(getFunnelChartController()));
-  chartJsExtensionRegistry.add("funnelElement", (Chart) => Chart.register(getFunnelChartElement()));
-  chartJsExtensionRegistry.add("funnelTooltipPositioner", (Chart) => (Chart.Tooltip.positioners.funnelTooltipPositioner = funnelTooltipPositioner));
-  chartJsExtensionRegistry.add("sunburstLabelsPlugin", sunburstLabelsPlugin);
-  chartJsExtensionRegistry.add("sunburstHoverPlugin", sunburstHoverPlugin);
+  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),
+  });
+  chartJsExtensionRegistry.add("funnelController", {
+      register: (Chart) => Chart.register(getFunnelChartController()),
+      unregister: (Chart) => Chart.unregister(getFunnelChartController()),
+  });
+  chartJsExtensionRegistry.add("funnelElement", {
+      register: (Chart) => Chart.register(getFunnelChartElement()),
+      unregister: (Chart) => Chart.unregister(getFunnelChartElement()),
+  });
+  chartJsExtensionRegistry.add("funnelTooltipPositioner", {
+      register: (Chart) => (Chart.Tooltip.positioners.funnelTooltipPositioner = funnelTooltipPositioner),
+      // @ts-expect-error
+      unregister: (Chart) => (Chart.Tooltip.positioners.funnelTooltipPositioner = undefined),
+  });
+  chartJsExtensionRegistry.add("sunburstLabelsPlugin", {
+      register: (Chart) => Chart.register(sunburstLabelsPlugin),
+      unregister: (Chart) => Chart.unregister(sunburstLabelsPlugin),
+  });
+  chartJsExtensionRegistry.add("sunburstHoverPlugin", {
+      register: (Chart) => Chart.register(sunburstHoverPlugin),
+      unregister: (Chart) => Chart.unregister(sunburstHoverPlugin),
+  });
   class ChartJsComponent extends owl.Component {
       static template = "o-spreadsheet-ChartJsComponent";
       static props = {
@@ -11518,8 +11588,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) {
@@ -19824,7 +19893,7 @@ stores.inject(MyMetaStore, storeInstance);
               return { value: "" };
           }
           if (result.value === null) {
-              result.value = "";
+              return { ...result, value: "" };
           }
           return result;
       },
@@ -19845,7 +19914,7 @@ stores.inject(MyMetaStore, storeInstance);
               return { value: "" };
           }
           if (result.value === null) {
-              result.value = "";
+              return { ...result, value: "" };
           }
           return result;
       },
@@ -19866,7 +19935,7 @@ stores.inject(MyMetaStore, storeInstance);
               return { value: "" };
           }
           if (result.value === null) {
-              result.value = "";
+              return { ...result, value: "" };
           }
           return result;
       },
@@ -19892,7 +19961,7 @@ stores.inject(MyMetaStore, storeInstance);
                       return { value: "" };
                   }
                   if (result.value === null) {
-                      result.value = "";
+                      return { ...result, value: "" };
                   }
                   return result;
               }
@@ -20039,6 +20108,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) {
@@ -20481,6 +20555,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);
       },
   };
@@ -20512,6 +20589,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);
@@ -20734,6 +20814,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: [
@@ -20755,6 +20838,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 };
       },
   };
@@ -20794,6 +20880,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;
           });
       },
@@ -20809,6 +20898,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;
           });
       },
@@ -22501,7 +22593,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);
@@ -24398,6 +24490,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
       },
       animation: false,
+      events: ["mousemove", "mouseout", "click", "touchstart", "touchmove", "mouseup"],
   };
   function chartToImageUrl(runtime, figure, type) {
       // wrap the canvas in a div with a fixed size because chart.js would
@@ -24437,6 +24530,8 @@ stores.inject(MyMetaStore, storeInstance);
       const div = document.createElement("div");
       div.style.width = `${figure.width}px`;
       div.style.height = `${figure.height}px`;
+      div.style.position = "fixed";
+      div.style.opacity = "0";
       const canvas = document.createElement("canvas");
       div.append(canvas);
       canvas.setAttribute("width", figure.width.toString());
@@ -24447,8 +24542,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);
           chartBlob = await new Promise((resolve) => canvas.toBlob(resolve, "image/png"));
           chart.destroy();
       }
@@ -25200,11 +25294,10 @@ stores.inject(MyMetaStore, storeInstance);
   }
   let missingTimeAdapterAlreadyWarned = false;
   function isLuxonTimeAdapterInstalled() {
-      const Chart = getChartJSConstructor();
-      if (!Chart) {
+      if (!window.Chart) {
           return false;
       }
-      const adapter = new Chart._adapters._date({});
+      const adapter = new window.Chart._adapters._date({});
       // @ts-ignore
       const isInstalled = adapter._id === "luxon";
       if (!isInstalled && !missingTimeAdapterAlreadyWarned) {
@@ -25702,6 +25795,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;
@@ -29638,10 +29734,15 @@ stores.inject(MyMetaStore, storeInstance);
                   const imageUrl = chartToImageUrl(runtime, figure, chartType);
                   const innerHTML = `<img src="${xmlEscape(imageUrl)}" />`;
                   const blob = await chartToImageFile(runtime, figure, chartType);
-                  env.clipboard.write({
+                  await env.clipboard.write({
                       "text/html": innerHTML,
                       "image/png": blob,
                   });
+                  env.notifyUser({
+                      text: _t("The chart was copied to your clipboard"),
+                      sticky: false,
+                      type: "info",
+                  });
               },
           },
           {
@@ -31491,7 +31592,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);
           }
@@ -31848,7 +31949,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;
           }
@@ -32499,7 +32600,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) {
@@ -34848,6 +34949,7 @@ stores.inject(MyMetaStore, storeInstance);
       initialMessages = dropCommands(initialMessages, "SET_DECIMAL");
       initialMessages = fixChartDefinitions(data, initialMessages);
       initialMessages = fixFigureOffset(data, initialMessages);
+      initialMessages = fixTranslatedDuplicateSheetName(data, initialMessages);
       return initialMessages;
   }
   /**
@@ -34980,6 +35082,42 @@ 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":
+                          sheetNames[cmd.sheetId] = cmd.name || getNextSheetName(Object.values(sheetNames));
+                          break;
+                      case "RENAME_SHEET":
+                          sheetNames[cmd.sheetId] = cmd.newName || getNextSheetName(Object.values(sheetNames));
+                          break;
+                  }
+                  commands.push(cmd);
+              }
+              messages.push({
+                  ...message,
+                  commands,
+              });
+          }
+          else {
+              messages.push(message);
+          }
+      }
+      return initialMessages;
+  }
   // -----------------------------------------------------------------------------
   // Helpers
   // -----------------------------------------------------------------------------
@@ -35117,12 +35255,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;
       }
   }
 
@@ -35144,7 +35290,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 });
@@ -36038,10 +36188,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 });
       },
@@ -40682,7 +40835,7 @@ stores.inject(MyMetaStore, storeInstance);
           const cancelledReasons = [
               ...(this.state.datasetDispatchResult?.reasons || []),
               ...(this.state.labelsDispatchResult?.reasons || []),
-          ];
+          ].filter((reason) => reason !== "NoChanges" /* CommandResult.NoChanges */);
           return cancelledReasons.map((error) => ChartTerms.Errors[error] || ChartTerms.Errors.Unexpected);
       }
       get isDatasetInvalid() {
@@ -42259,10 +42412,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;
       }
   }
 
@@ -42934,7 +43095,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(() => {
@@ -43214,6 +43375,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
       // ---------------------------------------------------------------------------
@@ -48938,8 +49106,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;
@@ -48958,6 +49126,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;
@@ -49051,6 +49222,10 @@ stores.inject(MyMetaStore, storeInstance);
           set: new Set(),
           values: {},
       },
+      month: {
+          set: new Set(),
+          values: {},
+      },
       iso_week_number: {
           set: new Set(),
           values: {},
@@ -49261,7 +49436,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) {
@@ -49379,7 +49554,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)) {
@@ -49458,7 +49633,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" };
@@ -49472,7 +49652,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,
@@ -49492,6 +49672,7 @@ stores.inject(MyMetaStore, storeInstance);
       "year",
       "quarter_number",
       "month_number",
+      "month",
       "iso_week_number",
       "day_of_month",
       "day",
@@ -49742,7 +49923,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;
       }
@@ -52082,6 +52263,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: {
@@ -52099,6 +52282,7 @@ stores.inject(MyMetaStore, storeInstance);
               }),
               onInputContextMenu: this.props.onInputContextMenu,
               composerStore: this.composerStore,
+              inputStyle: `max-height: ${maxHeight}px;`,
           };
       }
       get containerStyle() {
@@ -53179,9 +53363,13 @@ 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;
           this.computeOverlay();
+          return;
       }
       clear() {
           this.col = undefined;
@@ -54813,10 +55001,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);
           }
       }
@@ -55510,7 +55694,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), () => {
@@ -55719,7 +55903,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() {
@@ -56068,6 +56252,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
    *
@@ -57420,7 +57920,7 @@ stores.inject(MyMetaStore, storeInstance);
               case "CREATE_CHART":
                   return this.checkValidations(cmd, this.chainValidations(this.validateChartDefinition, this.checkChartDuplicate));
               case "UPDATE_CHART":
-                  return this.checkValidations(cmd, this.chainValidations(this.validateChartDefinition, this.checkChartExists));
+                  return this.checkValidations(cmd, this.chainValidations(this.validateChartDefinition, this.checkChartExists, this.checkChartChanged));
               default:
                   return "Success" /* CommandResult.Success */;
           }
@@ -57574,10 +58074,15 @@ stores.inject(MyMetaStore, storeInstance);
               : "Success" /* CommandResult.Success */;
       }
       checkChartExists(cmd) {
-          return this.getters.getFigureSheetId(cmd.figureId)
+          return this.isChartDefined(cmd.figureId)
               ? "Success" /* CommandResult.Success */
               : "ChartDoesNotExist" /* CommandResult.ChartDoesNotExist */;
       }
+      checkChartChanged(cmd) {
+          return deepEquals(this.getChartDefinition(cmd.figureId), cmd.definition)
+              ? "NoChanges" /* CommandResult.NoChanges */
+              : "Success" /* CommandResult.Success */;
+      }
   }
 
   // -----------------------------------------------------------------------------
@@ -59835,6 +60340,7 @@ stores.inject(MyMetaStore, storeInstance);
           "getCommandZones",
           "getUnboundedZone",
           "checkElementsIncludeAllNonFrozenHeaders",
+          "getDuplicateSheetName",
       ];
       sheetIdsMapName = {};
       orderedSheetIds = [];
@@ -59859,7 +60365,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 {
@@ -59936,7 +60446,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]);
@@ -60077,7 +60587,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];
                   }
               }
@@ -60143,10 +60653,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       getNextSheetName(baseName = "Sheet") {
           const names = this.orderedSheetIds.map(this.getSheetName.bind(this));
-          return getUniqueText(baseName, names, {
-              compute: (name, i) => `${name}${i}`,
-              computeFirstOne: true,
-          });
+          return getNextSheetName(names, baseName);
       }
       getSheetSize(sheetId) {
           return {
@@ -60329,7 +60836,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const { orderedSheetIds, sheets } = this;
           const name = sheetName && sheetName.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)) {
@@ -60393,9 +60900,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;
@@ -60428,8 +60934,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       getDuplicateSheetName(sheetName) {
           const names = this.orderedSheetIds.map(this.getSheetName.bind(this));
-          const baseName = _t("Copy of %s", sheetName);
-          return getUniqueText(baseName.toString(), names);
+          return getDuplicateSheetName(sheetName, names);
       }
       deleteSheet(sheet) {
           const name = sheet.name;
@@ -63233,8 +63738,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;
@@ -69415,6 +69920,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) {
@@ -72383,6 +72937,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)
@@ -72772,11 +73327,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) {
@@ -75337,11 +75892,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();
@@ -79783,6 +80340,7 @@ stores.inject(MyMetaStore, storeInstance);
       PivotDimensionOrder,
       PivotDimension,
       PivotLayoutConfigurator,
+      PivotHTMLRenderer,
       PivotDeferUpdate,
       PivotTitleSection,
       CogWheelMenu,
@@ -79880,9 +80438,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.3.1";
-  __info__.date = "2025-05-02T12:33:27.384Z";
-  __info__.hash = "7b9574b";
+  __info__.version = "18.3.3";
+  __info__.date = "2025-05-13T17:54:43.312Z";
+  __info__.hash = "b79924a";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);