@odoo/o-spreadsheet 19.0.11 → 19.0.15

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 19.0.11
- * @date 2025-11-24T07:46:47.685Z
- * @hash f5bdbcc
+ * @version 19.0.15
+ * @date 2025-12-26T10:19:23.408Z
+ * @hash fe625c9
  */
 
 (function (exports, owl) {
@@ -182,7 +182,6 @@
       "REDO",
       "ADD_MERGE",
       "REMOVE_MERGE",
-      "DUPLICATE_SHEET",
       "UPDATE_LOCALE",
       "ADD_PIVOT",
       "UPDATE_PIVOT",
@@ -1895,21 +1894,25 @@
   function profilesContainsZone(profilesStartingPosition, profiles, zone) {
       const leftValue = zone.left;
       const rightValue = zone.right;
-      const topValue = zone.top;
-      const bottomValue = zone.bottom + 1;
       const leftIndex = binaryPredecessorSearch(profilesStartingPosition, leftValue, 0);
-      const rightIndex = binaryPredecessorSearch(profilesStartingPosition, rightValue, leftIndex);
-      if (leftIndex === -1 || rightIndex === -1) {
-          return false;
-      }
+      const rightIndex = rightValue === undefined
+          ? profilesStartingPosition.length - 1
+          : binaryPredecessorSearch(profilesStartingPosition, rightValue, leftIndex);
+      /**
+       * The `profilesStartingPosition` array always contains at least the value `0` at its first position,
+       * ensuring that applying `binaryPredecessorSearch` will always return a valid index.
+       * Therefore, it is not necessary to check if the result of `binaryPredecessorSearch` equals `-1`.
+       */
+      const topValue = zone.top;
+      const bottomValue = zone.bottom === undefined ? undefined : zone.bottom + 1;
       for (let i = leftIndex; i <= rightIndex; i++) {
           const profile = profiles.get(profilesStartingPosition[i]);
-          const topPredIndex = binaryPredecessorSearch(profile, topValue, 0, true);
-          const bottomSuccIndex = binarySuccessorSearch(profile, bottomValue, 0, true);
+          const topPredIndex = binaryPredecessorSearch(profile, topValue, 0);
           if (topPredIndex === -1 || topPredIndex % 2 !== 0) {
               return false;
           }
-          if (topValue < profile[topPredIndex] || bottomValue > profile[bottomSuccIndex]) {
+          const bottomSuccIndex = bottomValue === undefined ? profile.length : binarySuccessorSearch(profile, bottomValue, 0);
+          if (topPredIndex + 1 !== bottomSuccIndex) {
               return false;
           }
       }
@@ -6595,17 +6598,41 @@
       const today = DateTime.now();
       switch (dateValue) {
           case "today":
-              return jsDateToNumber(today);
-          case "yesterday":
-              return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() - 1)));
-          case "tomorrow":
-              return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() + 1)));
+              return Math.floor(jsDateToNumber(today));
+          case "yesterday": {
+              today.setDate(today.getDate() - 1);
+              return Math.floor(jsDateToNumber(today));
+          }
+          case "tomorrow": {
+              today.setDate(today.getDate() + 1);
+              return Math.floor(jsDateToNumber(today));
+          }
           case "lastWeek":
-              return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() - 7)));
-          case "lastMonth":
-              return jsDateToNumber(DateTime.fromTimestamp(today.setMonth(today.getMonth() - 1)));
+              today.setDate(today.getDate() - 6);
+              return Math.floor(jsDateToNumber(today));
+          case "lastMonth": {
+              const lastMonth = today.getMonth() === 0 ? 11 : today.getMonth() - 1;
+              const dateInLastMonth = new DateTime(today.getFullYear(), lastMonth, 1);
+              if (today.getDate() > getDaysInMonth(dateInLastMonth)) {
+                  today.setDate(1);
+              }
+              else {
+                  today.setDate(today.getDate() + 1);
+                  today.setMonth(today.getMonth() - 1);
+              }
+              return Math.floor(jsDateToNumber(today));
+          }
           case "lastYear":
-              return jsDateToNumber(DateTime.fromTimestamp(today.setFullYear(today.getFullYear() - 1)));
+              // Handle leap year case
+              if (today.getMonth() === 1 && today.getDate() === 29) {
+                  today.setDate(28);
+                  today.setFullYear(today.getFullYear() - 1);
+              }
+              else {
+                  today.setDate(today.getDate() + 1);
+                  today.setFullYear(today.getFullYear() - 1);
+              }
+              return Math.floor(jsDateToNumber(today));
       }
   }
   /** Get all the dates values of a criterion converted to numbers, converting date values such as "today" to actual dates  */
@@ -6778,67 +6805,6 @@
       return sheetName !== undefined ? `${getCanonicalSymbolName(sheetName)}!${xc}` : xc;
   }
 
-  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));
@@ -7086,7 +7052,7 @@
       elements.sort((a, b) => b - a);
       const groups = groupConsecutive(elements);
       return (range) => {
-          if (!isSheetNameEqual(range.sheetId, cmd.sheetId)) {
+          if (range.sheetId !== cmd.sheetId) {
               return { changeType: "NONE" };
           }
           let newRange = range;
@@ -7293,6 +7259,69 @@
       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 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;
+  }
+  const toStandardizedSheetName = memoize(function toStandardizedSheetName(name) {
+      return getUnquotedSheetName(name.trim().toUpperCase());
+  });
+  function isSheetNameEqual(name1, name2) {
+      if (name1 === undefined || name2 === undefined) {
+          return false;
+      }
+      return toStandardizedSheetName(name1) === toStandardizedSheetName(name2);
+  }
+
   function computeTextLinesHeight(textLineHeight, numberOfLines = 1) {
       return numberOfLines * (textLineHeight + MIN_CELL_TEXT_MARGIN) - MIN_CELL_TEXT_MARGIN;
   }
@@ -23878,6 +23907,9 @@ stores.inject(MyMetaStore, storeInstance);
       }));
   }
   function getTreeMapColorScale(tree, coloringOption) {
+      if (tree.length === 0) {
+          return undefined;
+      }
       const treeNodesByLevel = pyramidizeTree(tree);
       const nodes = treeNodesByLevel[treeNodesByLevel.length - 1];
       const minValue = Math.min(...nodes.map((node) => node.value));
@@ -25563,11 +25595,18 @@ stores.inject(MyMetaStore, storeInstance);
       // we have to add the canvas to the DOM otherwise it won't be rendered
       document.body.append(div);
       if ("chartJsConfig" in runtime) {
+          const extensionsLoaded = areChartJSExtensionsLoaded();
+          if (!extensionsLoaded) {
+              registerChartJSExtensions();
+          }
           const config = deepCopy(runtime.chartJsConfig);
           config.plugins = [backgroundColorChartJSPlugin];
           const chart = new window.Chart(canvas, config);
           imageContent = chart.toBase64Image();
           chart.destroy();
+          if (!extensionsLoaded) {
+              unregisterChartJsExtensions();
+          }
       }
       else if (type === "scorecard") {
           const design = getScorecardConfiguration(figure, runtime);
@@ -25597,11 +25636,18 @@ stores.inject(MyMetaStore, storeInstance);
       document.body.append(div);
       let chartBlob = null;
       if ("chartJsConfig" in runtime) {
+          const extensionsLoaded = areChartJSExtensionsLoaded();
+          if (!extensionsLoaded) {
+              registerChartJSExtensions();
+          }
           const config = deepCopy(runtime.chartJsConfig);
           config.plugins = [backgroundColorChartJSPlugin];
           const chart = new window.Chart(canvas, config);
           chartBlob = await new Promise((resolve) => canvas.toBlob(resolve, "image/png"));
           chart.destroy();
+          if (!extensionsLoaded) {
+              unregisterChartJsExtensions();
+          }
       }
       else if (type === "scorecard") {
           const design = getScorecardConfiguration(figure, runtime);
@@ -27727,29 +27773,19 @@ stores.inject(MyMetaStore, storeInstance);
       }
       resetAxisLimits(chartId, limits) {
           for (const axisId of ZOOMABLE_AXIS_IDS) {
-              if (limits?.[axisId]) {
-                  if (!this.originalAxisLimits[chartId]?.[axisId]) {
-                      this.originalAxisLimits[chartId] = {
-                          ...this.originalAxisLimits[chartId],
-                          [axisId]: {},
-                      };
-                  }
-                  this.originalAxisLimits[chartId][axisId]["min"] = limits[axisId].min;
-                  this.originalAxisLimits[chartId][axisId]["max"] = limits[axisId].max;
+              if (limits[axisId]) {
+                  this.originalAxisLimits[chartId] = {
+                      ...this.originalAxisLimits[chartId],
+                      [axisId]: { ...limits[axisId] },
+                  };
               }
-              else {
-                  if (this.originalAxisLimits[chartId]?.[axisId]) {
-                      delete this.originalAxisLimits[chartId][axisId];
-                  }
+              else if (this.originalAxisLimits[chartId]?.[axisId]) {
+                  delete this.originalAxisLimits[chartId][axisId];
               }
           }
           return "noStateChange";
       }
       updateAxisLimits(chartId, limits) {
-          if (limits === undefined) {
-              delete this.currentAxesLimits[chartId];
-              return "noStateChange";
-          }
           let { min, max } = limits;
           if (min > max) {
               [min, max] = [max, min];
@@ -27765,26 +27801,14 @@ stores.inject(MyMetaStore, storeInstance);
        * for the current trend line axes.
        */
       updateTrendLineConfiguration(chartId) {
-          if (!this.originalAxisLimits[chartId]) {
+          if (!this.originalAxisLimits[chartId]?.x || !this.currentAxesLimits[chartId]?.x) {
               return "noStateChange";
           }
           const chartLimits = this.originalAxisLimits[chartId].x;
-          if (chartLimits === undefined) {
-              return "noStateChange";
-          }
           for (const axisId of TREND_LINE_AXES_IDS) {
               if (!this.originalAxisLimits[chartId][axisId]) {
                   continue;
               }
-              if (!this.currentAxesLimits[chartId]?.[axisId]) {
-                  this.currentAxesLimits[chartId] = {
-                      ...this.currentAxesLimits[chartId],
-                      [axisId]: {},
-                  };
-              }
-              if (this.currentAxesLimits[chartId]?.x === undefined) {
-                  return "noStateChange";
-              }
               const realRange = chartLimits.max - chartLimits.min;
               const trendingLimits = this.originalAxisLimits[chartId][axisId];
               const trendingRange = trendingLimits.max - trendingLimits.min;
@@ -27792,8 +27816,10 @@ stores.inject(MyMetaStore, storeInstance);
               const intercept = trendingLimits.min - chartLimits.min * slope;
               const newXMin = this.currentAxesLimits[chartId].x.min;
               const newXMax = this.currentAxesLimits[chartId].x.max;
-              this.currentAxesLimits[chartId][axisId].min = newXMin * slope + intercept;
-              this.currentAxesLimits[chartId][axisId].max = newXMax * slope + intercept;
+              this.currentAxesLimits[chartId][axisId] = {
+                  min: newXMin * slope + intercept,
+                  max: newXMax * slope + intercept,
+              };
           }
           return "noStateChange";
       }
@@ -27862,8 +27888,9 @@ stores.inject(MyMetaStore, storeInstance);
       hasLinearScale;
       isBarChart;
       chartId = "";
-      datasetBoundaries = { xMin: 0, xMax: 0 };
+      datasetBoundaries = { min: 0, max: 0 };
       removeEventListeners = () => { };
+      isMasterChartAllowed = false;
       setup() {
           this.store = useStore(ZoomableChartStore);
           super.setup();
@@ -27879,12 +27906,19 @@ stores.inject(MyMetaStore, storeInstance);
       height:${height};
     `;
       }
+      get masterChartContainerStyle() {
+          const runtime = this.env.model.getters.getChartRuntime(this.props.chartId);
+          if (runtime && !runtime.chartJsConfig.data.datasets.some((ds) => ds.data.length > 1)) {
+              return "opacity: 0.3;";
+          }
+          return "";
+      }
       get sliceable() {
           if (this.props.isFullScreen) {
               return true;
           }
           const definition = this.env.model.getters.getChartDefinition(this.props.chartId);
-          return ("zoomable" in definition && definition?.zoomable) ?? false;
+          return ("zoomable" in definition && definition.zoomable) ?? false;
       }
       get axisOffset() {
           return !this.hasLinearScale && this.isBarChart ? 0.5 : 0;
@@ -27909,15 +27943,13 @@ stores.inject(MyMetaStore, storeInstance);
           if (!this.sliceable) {
               return chartData;
           }
-          const xAxis = this.store.currentAxesLimits[this.chartId]?.x;
-          const xScale = {
-              ...chartData.options.scales?.x,
-          };
-          if (xAxis?.min !== undefined) {
-              xScale.min = this.hasLinearScale ? xAxis.min : Math.ceil(xAxis.min) - this.axisOffset;
-          }
-          if (xAxis?.max !== undefined) {
-              xScale.max = this.hasLinearScale ? xAxis.max : Math.floor(xAxis.max) - this.axisOffset;
+          let x = chartData.options.scales.x;
+          const limits = this.store.currentAxesLimits[this.chartId]?.x;
+          if (limits) {
+              x = {
+                  ...x,
+                  ...this.getStoredBoundaries(),
+              };
           }
           return {
               ...chartData,
@@ -27925,7 +27957,7 @@ stores.inject(MyMetaStore, storeInstance);
                   ...chartData.options,
                   scales: {
                       ...chartData.options.scales,
-                      x: xScale,
+                      x,
                   },
                   layout: {
                       ...chartData.options.layout,
@@ -27940,9 +27972,19 @@ stores.inject(MyMetaStore, storeInstance);
       getAxisLimitsFromDataset(chartData) {
           const data = chartData.data.datasets.map((ds) => ds.data).flat();
           const xValues = data.map((d, i) => (typeof d === "object" && d !== null ? d.x : i));
-          const xMin = Math.min(...xValues);
-          const xMax = Math.max(...xValues);
-          return { xMin, xMax };
+          const min = Math.min(...xValues);
+          const max = Math.max(...xValues);
+          return { min, max };
+      }
+      setMasterChartCursor(runtime) {
+          const masterElement = this.masterChartCanvas?.el;
+          if (runtime && !runtime.chartJsConfig.data.datasets.some((ds) => ds.data.length > 1)) {
+              masterElement.style.cursor = "not-allowed";
+              this.isMasterChartAllowed = false;
+              return;
+          }
+          masterElement.style.cursor = "default";
+          this.isMasterChartAllowed = true;
       }
       createChart(chartRuntime) {
           const chartData = chartRuntime.chartJsConfig;
@@ -27954,12 +27996,14 @@ stores.inject(MyMetaStore, storeInstance);
               chartRuntime.chartJsConfig = updatedData;
           }
           super.createChart(chartRuntime);
-          this.hasLinearScale = this.chart?.scales?.x.type === "linear";
+          this.hasLinearScale = this.chart?.scales?.x?.type === "linear";
           if (!this.sliceable || !("masterChartConfig" in chartRuntime)) {
+              this.isMasterChartAllowed = false;
               return;
           }
           this.masterChart?.destroy();
-          const masterChartCtx = this.masterChartCanvas.el.getContext("2d");
+          const masterChartCtx = (this.masterChartCanvas?.el).getContext("2d");
+          this.setMasterChartCursor(chartRuntime);
           this.masterChart = new window.Chart(masterChartCtx, this.getMasterChartConfiguration(chartRuntime["masterChartConfig"]));
           this.resetAxesLimits();
           if (this.chart?.options) {
@@ -27968,11 +28012,10 @@ stores.inject(MyMetaStore, storeInstance);
       }
       updateChartJs(chartRuntime) {
           const chartData = chartRuntime.chartJsConfig;
-          const newDatasetBoundaries = this.getAxisLimitsFromDataset(chartData);
-          if (this.datasetBoundaries.xMin !== newDatasetBoundaries.xMin ||
-              this.datasetBoundaries.xMax !== newDatasetBoundaries.xMax) {
+          const { min, max } = this.getAxisLimitsFromDataset(chartData);
+          if (this.datasetBoundaries.min !== min || this.datasetBoundaries.max !== max) {
               this.store.clearAxisLimits(this.chartId);
-              this.datasetBoundaries = newDatasetBoundaries;
+              this.datasetBoundaries = { min, max };
           }
           this.isBarChart = chartData?.type === "bar";
           this.chartId = `${chartData.type}-${this.props.chartId}`;
@@ -27981,9 +28024,10 @@ stores.inject(MyMetaStore, storeInstance);
               chartRuntime.chartJsConfig = updatedData;
           }
           super.updateChartJs(chartRuntime);
-          this.hasLinearScale = this.chart?.scales?.x.type === "linear";
+          this.hasLinearScale = this.chart?.scales?.x?.type === "linear";
           if (!this.sliceable || !("masterChartConfig" in chartRuntime)) {
               this.masterChart = undefined;
+              this.isMasterChartAllowed = false;
           }
           else {
               const masterChartConfig = this.getMasterChartConfiguration(chartRuntime["masterChartConfig"]);
@@ -27996,6 +28040,7 @@ stores.inject(MyMetaStore, storeInstance);
                   this.masterChart.config.options = masterChartConfig.options;
                   this.masterChart.update();
               }
+              this.setMasterChartCursor(chartRuntime);
           }
           this.resetAxesLimits();
           if (this.chart?.options) {
@@ -28006,18 +28051,15 @@ stores.inject(MyMetaStore, storeInstance);
           if (!this.chart) {
               return;
           }
-          const previousAxisLimits = this.store.originalAxisLimits[this.chartId];
-          if (previousAxisLimits?.x?.min === undefined && previousAxisLimits?.x?.max === undefined) {
+          const storedLimits = this.store.originalAxisLimits[this.chartId]?.x;
+          if (!storedLimits) {
               let scales = this.masterChart
                   ? this.masterChart.scales
                   : this.chart.scales;
-              if (!this.hasLinearScale && scales?.x) {
+              if (!this.hasLinearScale && scales.x) {
                   scales = {
                       ...scales,
-                      x: {
-                          min: Math.ceil(scales.x.min) - this.axisOffset,
-                          max: Math.floor(scales.x.max) + this.axisOffset,
-                      },
+                      x: this.adjustBoundaries(scales.x),
                   };
               }
               this.store.resetAxisLimits(this.chartId, scales);
@@ -28032,13 +28074,13 @@ stores.inject(MyMetaStore, storeInstance);
       }
       updateTrendingLineAxes() {
           this.store.updateTrendLineConfiguration(this.chartId);
-          const config = this.store.currentAxesLimits[this.chartId];
+          const limits = this.store.currentAxesLimits[this.chartId];
           for (const axisId of [TREND_LINE_XAXIS_ID, MOVING_AVERAGE_TREND_LINE_XAXIS_ID]) {
-              if (!this.chart?.config.options?.scales?.[axisId] || !config?.[axisId]) {
+              if (!this.chart?.config?.options?.scales?.[axisId] || !limits?.[axisId]) {
                   continue;
               }
-              this.chart.config.options.scales[axisId].min = config[axisId].min;
-              this.chart.config.options.scales[axisId].max = config[axisId].max;
+              this.chart.config.options.scales[axisId].min = limits[axisId].min;
+              this.chart.config.options.scales[axisId].max = limits[axisId].max;
           }
       }
       get upperBound() {
@@ -28081,29 +28123,71 @@ stores.inject(MyMetaStore, storeInstance);
               offset +
               ((scale.max + 2 * offset - scale.min) * (position - left)) / (right - left));
       }
-      updateAxisLimits(xMin, xMax) {
+      /**
+       * Compute min and max from the store, adjusting them if needed for non linear scales.
+       * Getting the value from the store, we have to ensure that the values are integers for
+       * non linear scales (bar and category). To select a bar in the chart, we have to include
+       * the whole bar, which means that for the i-th bar, the selected min should be <= i and
+       * the selected max should be >= i, so using the Math.floor and Math.ceil functions is
+       * the right way to do it.
+       * Sometimes, we can get a minimal value > the maximal value, which arise when the user
+       * select a very small area in the master chart, and hasn't selected the middle of a bar
+       * or a group of bars (in case of more than one data series).
+       * Assuming we have to select the middle of a bar/a groupe of bars, we will reject the
+       * coming value afterward. In this case, we do not update the chart because it would lead
+       * to an empty chart.
+       */
+      getStoredBoundaries() {
+          let { min, max } = this.store.currentAxesLimits[this.chartId].x;
           if (!this.hasLinearScale) {
-              this.chart.config.options.scales.x.min = Math.ceil(xMin);
-              this.chart.config.options.scales.x.max = Math.floor(xMax);
+              min = Math.ceil(min);
+              max = Math.floor(max);
           }
-          else {
-              this.chart.config.options.scales.x.min = xMin;
-              this.chart.config.options.scales.x.max = xMax;
+          return { min, max };
+      }
+      /**
+       * Adjust the min and max values of an axis if needed for non linear scales.
+       * Here, after rounding (see docstring of getStoredBoundaries), we adjust the min by
+       * substracting the axis offset, and we add it to the max, because when computing from the
+       * scale, chartJs use integer values as the limits for non linear scales. If we have a min
+       * value of 1, it means we want to start displaying from 0.5, and if we have a max value of
+       * 4, it means we want to display until 4.5.
+       * Here, we don't have to check if min > max because we are computing from the scale, and
+       * chartJs ensures that this won't happen, even after our adjustments.
+       */
+      adjustBoundaries({ min, max }) {
+          if (!this.hasLinearScale) {
+              min = Math.ceil(min) - this.axisOffset;
+              max = Math.floor(max) + this.axisOffset;
+          }
+          return { min, max };
+      }
+      updateAxisLimits(xMin, xMax) {
+          if (xMin === xMax) {
+              return;
+          }
+          if (!this.chart) {
+              return;
           }
           this.store.updateAxisLimits(this.chartId, { min: xMin, max: xMax });
-          this.updateTrendingLineAxes();
+          const { min, max } = this.getStoredBoundaries();
+          if (max > min || (this.isBarChart && max === min)) {
+              this.chart.config.options.scales.x.min = min;
+              this.chart.config.options.scales.x.max = max;
+              this.updateTrendingLineAxes();
+              this.chart.update();
+          }
           this.masterChart?.update();
-          this.chart?.update();
       }
-      onPointerDownInMasterChart(ev) {
+      onMasterChartPointerDown(ev) {
           this.removeEventListeners();
           const position = ev.offsetX;
           if (!this.masterChart?.chartArea || !this.chart?.scales?.x) {
               return;
           }
           const { left, right, top, bottom } = this.masterChart.chartArea;
-          const xMax = this.upperBound ?? right;
-          const xMin = this.lowerBound ?? left;
+          const upperBound = this.upperBound ?? right;
+          const lowerBound = this.lowerBound ?? left;
           if (position < left - 5 || position > right + 5 || ev.offsetY < top || ev.offsetY > bottom) {
               return;
           }
@@ -28111,8 +28195,10 @@ stores.inject(MyMetaStore, storeInstance);
           ev.stopPropagation();
           let startingPositionOnChart, windowSize, startX;
           const startingEventPosition = ev.clientX - (this.masterChartCanvas.el?.getBoundingClientRect().left ?? 0);
-          if ((xMin !== left || xMax !== right) && position > xMin + 5 && position < xMax - 5) {
-              startingPositionOnChart = ev.offsetX - xMin;
+          if ((lowerBound !== left || upperBound !== right) &&
+              position > lowerBound + 5 &&
+              position < upperBound - 5) {
+              startingPositionOnChart = ev.offsetX - lowerBound;
               this.mode = "moveInMaster";
               const currentLimits = this.store.currentAxesLimits[this.chartId]?.x;
               windowSize =
@@ -28121,31 +28207,29 @@ stores.inject(MyMetaStore, storeInstance);
           }
           else {
               this.mode = "selectInMaster";
-              if (Math.abs(position - xMin) < 5) {
-                  startingPositionOnChart = xMax;
+              if (Math.abs(position - lowerBound) < 5) {
+                  startingPositionOnChart = upperBound;
               }
-              else if (Math.abs(position - xMax) < 5) {
-                  startingPositionOnChart = xMin;
+              else if (Math.abs(position - upperBound) < 5) {
+                  startingPositionOnChart = lowerBound;
               }
               else {
                   startingPositionOnChart = clip(position, left, right);
               }
               startX = this.computeCoordinate(startingPositionOnChart);
           }
-          const originalXMin = this.store.originalAxisLimits[this.chartId].x.min;
-          const originalXMax = this.store.originalAxisLimits[this.chartId].x.max;
+          const storedMin = this.store.originalAxisLimits[this.chartId].x.min;
+          const storedMax = this.store.originalAxisLimits[this.chartId].x.max;
           const computeNewAxisLimits = (position) => {
-              let xMin, xMax;
-              const { left, right } = this.masterChart.chartArea;
               if (this.mode === "moveInMaster") {
-                  xMin = this.computeCoordinate(position - startingPositionOnChart);
-                  if (xMin < originalXMin) {
-                      xMin = originalXMin;
+                  let min = this.computeCoordinate(position - startingPositionOnChart);
+                  if (min < storedMin) {
+                      min = storedMin;
                   }
-                  else if (xMin > originalXMax - windowSize) {
-                      xMin = originalXMax - windowSize;
+                  else if (min > storedMax - windowSize) {
+                      min = storedMax - windowSize;
                   }
-                  xMax = xMin + windowSize;
+                  return { min, max: min + windowSize };
               }
               else if (this.mode === "selectInMaster") {
                   const upperBound = clip(position, left, right);
@@ -28154,54 +28238,52 @@ stores.inject(MyMetaStore, storeInstance);
                       if (startX === undefined || endX === undefined) {
                           return {};
                       }
-                      xMin = Math.min(startX, endX);
-                      xMax = Math.max(startX, endX);
+                      return {
+                          min: Math.min(startX, endX),
+                          max: Math.max(startX, endX),
+                      };
                   }
               }
-              return { min: xMin, max: xMax };
+              return {};
           };
-          const onDragFromMasterChart = (ev) => {
+          const onMasterChartDrag = (ev) => {
               const position = ev.clientX - (this.masterChartCanvas.el?.getBoundingClientRect().left ?? 0);
               if (Math.abs(position - startingEventPosition) < 5) {
                   return;
               }
-              const { min: xMin, max: xMax } = computeNewAxisLimits(position);
-              if (xMin !== undefined && xMax !== undefined) {
-                  this.updateAxisLimits(xMin, xMax);
+              const { min, max } = computeNewAxisLimits(position);
+              if (min !== undefined && max !== undefined) {
+                  this.updateAxisLimits(min, max);
               }
           };
-          const onPointerUpInMasterChart = (ev) => {
+          const onMasterChartPointerUp = (ev) => {
               this.removeEventListeners();
-              const position = ev.clientX - (this.masterChartCanvas.el?.getBoundingClientRect().left ?? 0);
-              if (Math.abs(position - startingEventPosition) > 5) {
-                  let { min: xMin, max: xMax } = computeNewAxisLimits(position);
-                  if (xMin !== undefined && xMax !== undefined) {
-                      if (!this.hasLinearScale) {
-                          if (this.mode === "moveInMaster" && windowSize && !this.isBarChart) {
-                              xMin = Math.round(xMin) - this.axisOffset;
-                              xMax = xMin + windowSize;
-                          }
-                          else {
-                              xMin = Math.ceil(xMin) - this.axisOffset;
-                              xMax = Math.floor(xMax) + this.axisOffset;
-                          }
-                      }
-                      this.updateAxisLimits(xMin, xMax);
+              let { min, max } = this.chart.scales.x;
+              if (!this.hasLinearScale) {
+                  if (this.mode === "moveInMaster") {
+                      min = Math.round(min) - this.axisOffset;
+                      max = min + windowSize;
+                  }
+                  else {
+                      ({ min, max } = this.adjustBoundaries({ min, max }));
                   }
               }
+              this.updateAxisLimits(min, max);
               this.mode = undefined;
           };
           this.removeEventListeners = () => {
-              window.removeEventListener("pointermove", onDragFromMasterChart, true);
-              window.removeEventListener("pointerup", onPointerUpInMasterChart, true);
+              window.removeEventListener("pointermove", onMasterChartDrag, true);
+              window.removeEventListener("pointerup", onMasterChartPointerUp, true);
           };
-          window.addEventListener("pointermove", onDragFromMasterChart, true);
-          window.addEventListener("pointerup", onPointerUpInMasterChart, true);
+          window.addEventListener("pointermove", onMasterChartDrag, true);
+          window.addEventListener("pointerup", onMasterChartPointerUp, true);
       }
-      onPointerMoveInMasterChart(ev) {
-          const { offsetX: x, offsetY: y } = ev;
+      onMasterChartPointerMove(ev) {
+          const { offsetX: x, offsetY: y, target } = ev;
+          if (!target || !this.isMasterChartAllowed) {
+              return;
+          }
           if (this.mode === undefined) {
-              const target = ev.target;
               if (!this.masterChart?.chartArea) {
                   target["style"].cursor = "default";
                   return;
@@ -28223,14 +28305,14 @@ stores.inject(MyMetaStore, storeInstance);
               }
           }
       }
-      onMouseLeaveMasterChart(ev) {
+      onMasterChartMouseLeave(ev) {
           const target = ev.target;
-          if (!target) {
+          if (!target || !this.isMasterChartAllowed) {
               return;
           }
           target["style"].cursor = "default";
       }
-      onDoubleClickInMasterChart(ev) {
+      onMasterChartDoubleClick(ev) {
           this.mode = undefined;
           const position = ev.offsetX;
           if (!this.masterChart?.chartArea || !this.chart?.scales.x) {
@@ -28247,33 +28329,25 @@ stores.inject(MyMetaStore, storeInstance);
           }
           ev.preventDefault();
           ev.stopPropagation();
-          let { min: xMin, max: xMax } = this.store.currentAxesLimits[this.chartId]?.x ?? this.chart.scales.x;
+          let { min, max } = this.store.currentAxesLimits[this.chartId]?.x ?? this.chart.scales.x;
           const originalAxisLimits = this.store.originalAxisLimits[this.chartId].x;
           if (!originalAxisLimits) {
               return;
           }
-          let originalXMin = originalAxisLimits.min;
-          let originalXMax = originalAxisLimits.max;
-          if (this.hasLinearScale) {
-              originalXMin = Math.ceil(originalXMin) - this.axisOffset;
-              originalXMax = Math.floor(originalXMax) + this.axisOffset;
-          }
           if (Math.abs(position - lowerBound) < 5) {
-              // Reset to original min
-              xMin = originalXMin;
+              min = originalAxisLimits.min;
           }
           else if (Math.abs(position - upperBound) < 5) {
-              xMax = originalXMax;
+              max = originalAxisLimits.max;
           }
           else if (lowerBound < position && position < upperBound) {
-              // Reset to original limits
-              xMin = originalXMin;
-              xMax = originalXMax;
+              min = originalAxisLimits.min;
+              max = originalAxisLimits.max;
           }
           else {
               return;
           }
-          this.updateAxisLimits(xMin, xMax);
+          this.updateAxisLimits(min, max);
       }
   }
 
@@ -31376,7 +31450,7 @@ stores.inject(MyMetaStore, storeInstance);
       return query.replaceAll(/([a-zA-Z0-9]+):([a-zA-Z0-9]+)/g, "NAMESPACE" + "$1" + "NAMESPACE" + "$2");
   }
 
-  function getChartMenuActions(figureId, onFigureDeleted, env) {
+  function getChartMenuActions(figureId, env) {
       const chartId = env.model.getters.getChartIdFromFigureId(figureId);
       if (!chartId) {
           return [];
@@ -31396,11 +31470,11 @@ stores.inject(MyMetaStore, storeInstance);
           getCutMenuItem(figureId, env),
           getCopyAsImageMenuItem(figureId, env),
           getDownloadChartMenuItem(figureId, env),
-          getDeleteMenuItem(figureId, onFigureDeleted, env),
+          getDeleteMenuItem(figureId, env),
       ];
       return createActions(menuItemSpecs).filter((action) => env.model.getters.isReadonly() ? action.isReadonlyAllowed : true);
   }
-  function getImageMenuActions(figureId, onFigureDeleted, env) {
+  function getImageMenuActions(figureId, env) {
       const menuItemSpecs = [
           getCopyMenuItem(figureId, env, _t("Image copied to clipboard")),
           getCutMenuItem(figureId, env),
@@ -31443,11 +31517,11 @@ stores.inject(MyMetaStore, storeInstance);
               },
               icon: "o-spreadsheet-Icon.DOWNLOAD",
           },
-          getDeleteMenuItem(figureId, onFigureDeleted, env),
+          getDeleteMenuItem(figureId, env),
       ];
       return createActions(menuItemSpecs);
   }
-  function getCarouselMenuActions(figureId, onFigureDeleted, env) {
+  function getCarouselMenuActions(figureId, env) {
       const isChartSelected = (env) => env.model.getters.getSelectedCarouselItem(figureId)?.type === "chart";
       const menuItemSpecs = [
           {
@@ -31466,7 +31540,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           { ...getCutMenuItem(figureId, env), name: _t("Cut carousel") },
           {
-              ...getDeleteMenuItem(figureId, onFigureDeleted, env),
+              ...getDeleteMenuItem(figureId, env),
               name: _t("Delete carousel"),
               separator: true,
           },
@@ -31609,7 +31683,7 @@ stores.inject(MyMetaStore, storeInstance);
           isReadonlyAllowed: true,
       };
   }
-  function getDeleteMenuItem(figureId, onFigureDeleted, env) {
+  function getDeleteMenuItem(figureId, env) {
       return {
           id: "delete",
           name: _t("Delete"),
@@ -31618,7 +31692,6 @@ stores.inject(MyMetaStore, storeInstance);
                   sheetId: env.model.getters.getActiveSheetId(),
                   figureId,
               });
-              onFigureDeleted();
           },
           icon: "o-spreadsheet-Icon.TRASH",
       };
@@ -32431,7 +32504,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.menuState.isOpen = true;
           this.menuState.anchorRect = getBoundingRectAsPOJO(ev.currentTarget);
           const figureId = this.env.model.getters.getFigureIdFromChartId(this.props.chartId);
-          this.menuState.menuItems = getChartMenuActions(figureId, () => { }, this.env);
+          this.menuState.menuItems = getChartMenuActions(figureId, this.env);
       }
       get fullScreenMenuItem() {
           if (!this.props.hasFullScreenButton) {
@@ -32458,7 +32531,6 @@ stores.inject(MyMetaStore, storeInstance);
       static template = "o-spreadsheet-CarouselFigure";
       static props = {
           figureUI: Object,
-          onFigureDeleted: Function,
           editFigureStyle: { type: Function, optional: true },
           isFullScreen: { type: Boolean, optional: true },
           openContextMenu: { type: Function, optional: true },
@@ -32607,7 +32679,6 @@ stores.inject(MyMetaStore, storeInstance);
       static template = "o-spreadsheet-ChartFigure";
       static props = {
           figureUI: Object,
-          onFigureDeleted: Function,
           editFigureStyle: { type: Function, optional: true },
           isFullScreen: { type: Boolean, optional: true },
           openContextMenu: { type: Function, optional: true },
@@ -32641,7 +32712,6 @@ stores.inject(MyMetaStore, storeInstance);
       static template = "o-spreadsheet-ImageFigure";
       static props = {
           figureUI: Object,
-          onFigureDeleted: Function,
           editFigureStyle: { type: Function, optional: true },
           openContextMenu: { type: Function, optional: true },
       };
@@ -32760,13 +32830,11 @@ stores.inject(MyMetaStore, storeInstance);
           figureUI: Object,
           style: { type: String, optional: true },
           class: { type: String, optional: true },
-          onFigureDeleted: { type: Function, optional: true },
           onMouseDown: { type: Function, optional: true },
           onClickAnchor: { type: Function, optional: true },
       };
       static components = { MenuPopover };
       static defaultProps = {
-          onFigureDeleted: () => { },
           onMouseDown: () => { },
           onClickAnchor: () => { },
       };
@@ -32844,9 +32912,6 @@ stores.inject(MyMetaStore, storeInstance);
               this.props.figureUI.id,
               this.figureRef.el,
           ]);
-          owl.onWillUnmount(() => {
-              this.props.onFigureDeleted();
-          });
       }
       clickAnchor(dirX, dirY, ev) {
           this.props.onClickAnchor(dirX, dirY, ev);
@@ -32870,7 +32935,6 @@ stores.inject(MyMetaStore, storeInstance);
                       sheetId: this.env.model.getters.getActiveSheetId(),
                       figureId: this.props.figureUI.id,
                   });
-                  this.props.onFigureDeleted();
                   ev.preventDefault();
                   ev.stopPropagation();
                   break;
@@ -32963,7 +33027,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.menuState.anchorRect = anchorRect;
           this.menuState.menuItems = figureRegistry
               .get(this.props.figureUI.tag)
-              .menuBuilder(this.props.figureUI.id, this.props.onFigureDeleted, this.env);
+              .menuBuilder(this.props.figureUI.id, this.env);
       }
       editWrapperStyle(properties) {
           if (this.figureWrapperRef.el) {
@@ -33335,7 +33399,7 @@ stores.inject(MyMetaStore, storeInstance);
               return false;
           }
           if (["lastWeek", "lastMonth", "lastYear"].includes(criterion.dateValue)) {
-              const today = jsDateToRoundNumber(DateTime.now());
+              const today = Math.floor(jsDateToNumber(DateTime.now()));
               return isDateBetween(dateValue, today, criterionValue);
           }
           return areDatesSameDay(dateValue, criterionValue);
@@ -34404,7 +34468,8 @@ stores.inject(MyMetaStore, storeInstance);
                   assistantStyle["max-height"] = `${availableSpaceAbove - CLOSE_ICON_RADIUS}px`;
                   // render top
                   // We compensate 2 px of margin on the assistant style + 1px for design reasons
-                  assistantStyle.transform = `translate(0, calc(-100% - ${cellHeight + 3}px))`;
+                  assistantStyle.top = `-3px`;
+                  assistantStyle.transform = `translate(0, -100%)`;
               }
               if (cellX + ASSISTANT_WIDTH > this.props.delimitation.width) {
                   // render left
@@ -35195,7 +35260,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           this.selectionStart = start;
           this.selectionEnd = end;
-          this.editionMode = "editing";
+          this.stopComposerRangeSelection();
           this.computeFormulaCursorContext();
           this.computeParenthesisRelatedToCursor();
           this.updateAutoCompleteProvider();
@@ -37448,6 +37513,12 @@ stores.inject(MyMetaStore, storeInstance);
       }
       setup() {
           owl.useEffect(() => this.focusedInput.el?.focus(), () => [this.focusedInput.el]);
+          owl.useEffect(() => {
+              // Check the offsetParent to know if the input or an ancestor is `display: none` (eg. when changing side panel tab)
+              if (this.store.hasFocus && this.selectionRef.el?.offsetParent === null) {
+                  this.reset();
+              }
+          });
           this.store = useLocalStore(SelectionInputStore, this.props.ranges, this.props.hasSingleRange || false, this.props.colors, this.props.disabledRanges);
           owl.onWillUpdateProps((nextProps) => {
               if (nextProps.ranges.join() !== this.store.selectionInputValues.join()) {
@@ -44192,18 +44263,22 @@ stores.inject(MyMetaStore, storeInstance);
       return messages;
   }
   function fixChartDefinitions(data, initialMessages) {
+      /**
+       * Revisions created after version 18.5.1 contain the full chart definition in the command
+       * if the data was alreay updated to 18.5.1, then those older revision cannot (by definition) be reaplied
+       * and should not be replayed.
+       * FIXME: every command should be versionned when upgraded to allow finer tuning.
+       */
+      if (!data.version || compareVersions(String(data.version), "18.5.1") >= 0) {
+          return initialMessages;
+      }
       const messages = [];
       const map = {};
       for (const sheet of data.sheets || []) {
           sheet.figures?.forEach((figure) => {
               if (figure.tag === "chart") {
                   // chart definition
-                  if (data.version && compareVersions(String(data.version), "18.5.1") <= 0) {
-                      map[figure.data.chartId] = figure.data;
-                  }
-                  else {
-                      map[figure.id] = figure.data;
-                  }
+                  map[figure.id] = figure.data;
               }
           });
       }
@@ -45227,7 +45302,7 @@ stores.inject(MyMetaStore, storeInstance);
               const leftOffset = isLeftUnbounded || left?.colFixed ? 0 : colCellOffset;
               const topOffset = isTopUnbounded || left?.rowFixed ? 0 : rowCellOffset;
               const isRightFixed = (!right && left?.colFixed) || right?.colFixed;
-              const isBottomFixed = (!right && left.rowFixed) || right?.rowFixed;
+              const isBottomFixed = (!right && left?.rowFixed) || right?.rowFixed;
               const isRightUnbounded = range.unboundedZone.right === undefined;
               const isBottomUnbounded = range.unboundedZone.bottom === undefined;
               const rightOffset = isRightUnbounded || isRightFixed ? 0 : colCellOffset;
@@ -47786,13 +47861,42 @@ stores.inject(MyMetaStore, storeInstance);
   pivotRegistry.add("SPREADSHEET", {
       ui: SpreadsheetPivot,
       definition: SpreadsheetPivotRuntimeDefinition,
-      externalData: false,
       dateGranularities: [...dateGranularities],
       datetimeGranularities: [...dateGranularities, "hour_number", "minute_number", "second_number"],
       isMeasureCandidate: (field) => field.type !== "boolean",
       isGroupable: () => true,
       canHaveCustomGroup: (field) => field.type === "char" && !field.isCustomField,
+      adaptRanges: (getters, definition, applyChange) => {
+          if (definition.type !== "SPREADSHEET" || !definition.dataSet) {
+              return definition;
+          }
+          const { sheetId, zone } = definition.dataSet;
+          const range = getters.getRangeFromZone(sheetId, zone);
+          const adaptedRange = adaptPivotRange(range, applyChange);
+          if (adaptedRange === range) {
+              return definition;
+          }
+          const dataSet = adaptedRange && {
+              sheetId: adaptedRange.sheetId,
+              zone: adaptedRange.zone,
+          };
+          return { ...definition, dataSet };
+      },
   });
+  function adaptPivotRange(range, applyChange) {
+      if (!range) {
+          return undefined;
+      }
+      const change = applyChange(range);
+      switch (change.changeType) {
+          case "NONE":
+              return range;
+          case "REMOVE":
+              return undefined;
+          default:
+              return change.range;
+      }
+  }
 
   const pivotProperties = {
       name: _t("See pivot properties"),
@@ -49063,7 +49167,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
       get highlights() {
           const position = this.model.getters.getActivePosition();
-          const cell = this.getters.getEvaluatedCell(position);
           const spreader = this.model.getters.getArrayFormulaSpreadingOn(position);
           const zone = spreader
               ? this.model.getters.getSpreadZone(spreader, { ignoreSpillError: true })
@@ -49071,10 +49174,11 @@ stores.inject(MyMetaStore, storeInstance);
           if (!zone) {
               return [];
           }
+          const isArrayFormulaBlocked = this.model.getters.isArrayFormulaSpillBlocked(spreader ?? position);
           return [
               {
                   range: this.model.getters.getRangeFromZone(position.sheetId, zone),
-                  dashed: cell.value === CellErrorType.SpilledBlocked,
+                  dashed: isArrayFormulaBlocked,
                   color: "#17A2B8",
                   noFill: true,
                   thinLine: true,
@@ -50481,9 +50585,7 @@ stores.inject(MyMetaStore, storeInstance);
    */
   class FiguresContainer extends owl.Component {
       static template = "o-spreadsheet-FiguresContainer";
-      static props = {
-          onFigureDeleted: Function,
-      };
+      static props = {};
       static components = { FigureComponent };
       dnd = owl.useState({
           draggedFigure: undefined,
@@ -50693,7 +50795,6 @@ stores.inject(MyMetaStore, storeInstance);
                       carouselFigureId: this.dnd.overlappingCarousel.id,
                       chartFigureId: figureUI.id,
                   });
-                  this.props.onFigureDeleted();
               }
               this.dnd.draggedFigure = undefined;
               this.dnd.horizontalSnap = undefined;
@@ -50919,16 +51020,16 @@ stores.inject(MyMetaStore, storeInstance);
 `;
   class GridAddRowsFooter extends owl.Component {
       static template = "o-spreadsheet-GridAddRowsFooter";
-      static props = {
-          focusGrid: Function,
-      };
+      static props = {};
       static components = { ValidationMessages };
+      DOMFocusableElementStore;
       inputRef = owl.useRef("inputRef");
       state = owl.useState({
           inputValue: "100",
           errorFlag: false,
       });
       setup() {
+          this.DOMFocusableElementStore = useStore(DOMFocusableElementStore);
           owl.useExternalListener(window, "click", this.onExternalClick, { capture: true });
       }
       get addRowsPosition() {
@@ -50946,7 +51047,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       onKeydown(ev) {
           if (ev.key.toUpperCase() === "ESCAPE") {
-              this.props.focusGrid();
+              this.focusDefaultElement();
           }
           else if (ev.key.toUpperCase() === "ENTER") {
               this.onConfirm();
@@ -50973,7 +51074,7 @@ stores.inject(MyMetaStore, storeInstance);
               quantity,
               dimension: "ROW",
           });
-          this.props.focusGrid();
+          this.focusDefaultElement();
           // After adding new rows, scroll down to the new last row
           const { scrollX } = this.env.model.getters.getActiveSheetScrollInfo();
           const { end } = this.env.model.getters.getRowDimensions(activeSheetId, rowNumber + quantity - 1);
@@ -50986,7 +51087,12 @@ stores.inject(MyMetaStore, storeInstance);
           if (this.inputRef.el !== document.activeElement || ev.target === this.inputRef.el) {
               return;
           }
-          this.props.focusGrid();
+          this.focusDefaultElement();
+      }
+      focusDefaultElement() {
+          if (document.activeElement === this.inputRef.el) {
+              this.DOMFocusableElementStore.focus();
+          }
       }
   }
 
@@ -51261,7 +51367,6 @@ stores.inject(MyMetaStore, storeInstance);
           onCellClicked: { type: Function, optional: true },
           onCellRightClicked: { type: Function, optional: true },
           onGridResized: { type: Function, optional: true },
-          onFigureDeleted: { type: Function, optional: true },
           onGridMoved: Function,
           gridOverlayDimensions: String,
           slots: { type: Object, optional: true },
@@ -51276,7 +51381,6 @@ stores.inject(MyMetaStore, storeInstance);
           onCellClicked: () => { },
           onCellRightClicked: () => { },
           onGridResized: () => { },
-          onFigureDeleted: () => { },
       };
       gridOverlay = owl.useRef("gridOverlay");
       cellPopovers;
@@ -53822,7 +53926,9 @@ stores.inject(MyMetaStore, storeInstance);
       inputRef = owl.useRef("inputFontSize");
       rootEditorRef = owl.useRef("FontSizeEditor");
       fontSizeListRef = owl.useRef("fontSizeList");
+      DOMFocusableElementStore;
       setup() {
+          this.DOMFocusableElementStore = useStore(DOMFocusableElementStore);
           owl.useExternalListener(window, "click", this.onExternalClick, { capture: true });
       }
       get popoverProps() {
@@ -53876,6 +53982,13 @@ stores.inject(MyMetaStore, storeInstance);
               }
               this.props.onToggle?.();
           }
+          if (ev.key === "Tab") {
+              ev.preventDefault();
+              ev.stopPropagation();
+              this.closeFontList();
+              this.DOMFocusableElementStore.focus();
+              return;
+          }
       }
   }
 
@@ -55211,19 +55324,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  class ChartShowDataMarkers extends owl.Component {
-      static template = "o-spreadsheet-ChartShowDataMarkers";
-      static components = {
-          Checkbox,
-      };
-      static props = {
-          chartId: String,
-          definition: Object,
-          updateChart: Function,
-          canUpdateChart: Function,
-      };
-  }
-
   class GenericZoomableChartDesignPanel extends ChartWithAxisDesignPanel {
       static template = "o-spreadsheet-GenericZoomableChartDesignPanel";
       static components = {
@@ -55237,6 +55337,26 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class BarChartDesignPanel extends GenericZoomableChartDesignPanel {
+      static template = "o-spreadsheet-BarChartDesignPanel";
+      get isZoomable() {
+          return !this.props.definition.horizontal;
+      }
+  }
+
+  class ChartShowDataMarkers extends owl.Component {
+      static template = "o-spreadsheet-ChartShowDataMarkers";
+      static components = {
+          Checkbox,
+      };
+      static props = {
+          chartId: String,
+          definition: Object,
+          updateChart: Function,
+          canUpdateChart: Function,
+      };
+  }
+
   class ComboChartDesignPanel extends GenericZoomableChartDesignPanel {
       static template = "o-spreadsheet-ComboChartDesignPanel";
       static components = {
@@ -56165,7 +56285,7 @@ stores.inject(MyMetaStore, storeInstance);
   })
       .add("bar", {
       configuration: BarConfigPanel,
-      design: GenericZoomableChartDesignPanel,
+      design: BarChartDesignPanel,
   })
       .add("combo", {
       configuration: GenericChartConfigPanel,
@@ -56526,7 +56646,7 @@ stores.inject(MyMetaStore, storeInstance);
   }
 
   css /* scss */ `
-  .o-cf-preview {
+  .o-spreadsheet .o-cf-preview {
     &.o-cf-cursor-ptr {
       cursor: pointer;
     }
@@ -56534,6 +56654,7 @@ stores.inject(MyMetaStore, storeInstance);
     border-bottom: 1px solid ${GRAY_300};
     height: 80px;
     padding: 10px;
+    box-sizing: border-box;
     position: relative;
     cursor: pointer;
     &:hover,
@@ -56547,7 +56668,6 @@ stores.inject(MyMetaStore, storeInstance);
     .o-cf-preview-icon {
       border: 1px solid ${GRAY_300};
       background-color: #fff;
-      position: absolute;
       height: 50px;
       width: 50px;
       .o-icon {
@@ -56556,12 +56676,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
     }
     .o-cf-preview-description {
-      left: 65px;
-      margin-bottom: auto;
-      margin-right: 8px;
-      margin-top: auto;
-      position: relative;
-      width: 142px;
       .o-cf-preview-description-rule {
         margin-bottom: 4px;
         max-height: 2.8em;
@@ -56571,16 +56685,11 @@ stores.inject(MyMetaStore, storeInstance);
         font-size: 12px;
       }
     }
-    .o-cf-delete {
-      left: 90%;
-      top: 39%;
-      position: absolute;
-    }
     &:not(:hover):not(.o-cf-dragging) .o-cf-drag-handle {
       display: none !important;
     }
     .o-cf-drag-handle {
-      left: -8px;
+      left: 2px;
       cursor: move;
       .o-icon {
         width: 6px;
@@ -62385,10 +62494,10 @@ stores.inject(MyMetaStore, storeInstance);
           // existingBorderSideToClear[side] = true means we should clear the border on that
           // side of the existing adjacent zone before adding the new border.
           const existingBorderSideToClear = {
-              left: force || !!newBorder?.right,
-              right: force || !!newBorder?.left,
-              top: force || !!newBorder?.bottom,
-              bottom: force || !!newBorder?.top,
+              left: !!newBorder?.right,
+              right: !!newBorder?.left,
+              top: !!newBorder?.bottom,
+              bottom: !!newBorder?.top,
           };
           let editingZone = [zone];
           for (const existingBorder of this.borders[sheetId] ?? []) {
@@ -64257,7 +64366,8 @@ stores.inject(MyMetaStore, storeInstance);
                   }
                   break;
               case "DUPLICATE_SHEET": {
-                  for (const figureId in this.figures[cmd.sheetId]) {
+                  for (const figure of this.getFigures(cmd.sheetId)) {
+                      const figureId = figure.id;
                       const fig = this.figures[cmd.sheetId]?.[figureId];
                       if (!fig) {
                           continue;
@@ -65380,6 +65490,7 @@ stores.inject(MyMetaStore, storeInstance);
   class RangeAdapter {
       getters;
       providers = [];
+      isAdaptingRanges = false;
       constructor(getters) {
           this.getters = getters;
       }
@@ -65411,6 +65522,9 @@ stores.inject(MyMetaStore, storeInstance);
       }
       beforeHandle(command) { }
       handle(cmd) {
+          if (this.isAdaptingRanges) {
+              throw new Error("Plugins cannot dispatch commands during adaptRanges phase");
+          }
           const rangeAdapter = getRangeAdapter(cmd);
           if (rangeAdapter?.applyChange) {
               this.executeOnAllRanges(rangeAdapter.applyChange, rangeAdapter.sheetId, rangeAdapter.sheetName);
@@ -65433,10 +65547,12 @@ stores.inject(MyMetaStore, storeInstance);
           };
       }
       executeOnAllRanges(adaptRange, sheetId, sheetName) {
+          this.isAdaptingRanges = true;
           const func = this.verifyRangeRemoved(adaptRange);
           for (const provider of this.providers) {
               provider(func, sheetId, sheetName);
           }
+          this.isAdaptingRanges = false;
       }
       /**
        * Stores the functions bound to each plugin to be able to iterate over all ranges of the application,
@@ -65753,7 +65869,7 @@ stores.inject(MyMetaStore, storeInstance);
                   break;
               case "CREATE_SHEET":
                   const sheet = this.createSheet(cmd.sheetId, cmd.name || this.getNextSheetName(), cmd.cols || 26, cmd.rows || 100, cmd.position);
-                  this.history.update("sheetIdsMapName", sheet.name, sheet.id);
+                  this.history.update("sheetIdsMapName", toStandardizedSheetName(sheet.name), sheet.id);
                   break;
               case "MOVE_SHEET":
                   this.moveSheet(cmd.sheetId, cmd.delta);
@@ -65820,7 +65936,7 @@ stores.inject(MyMetaStore, storeInstance);
           // that depends on a sheet not already imported will not be able to be
           // compiled
           for (const sheet of data.sheets) {
-              this.sheetIdsMapName[sheet.name] = sheet.id;
+              this.sheetIdsMapName[toStandardizedSheetName(sheet.name)] = sheet.id;
           }
           for (const sheetData of data.sheets) {
               const name = sheetData.name || "Sheet" + (Object.keys(this.sheets).length + 1);
@@ -65910,12 +66026,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       getSheetIdByName(name) {
           if (name) {
-              const unquotedName = getUnquotedSheetName(name);
-              for (const key in this.sheetIdsMapName) {
-                  if (isSheetNameEqual(key, unquotedName)) {
-                      return this.sheetIdsMapName[key];
-                  }
-              }
+              return this.sheetIdsMapName[toStandardizedSheetName(name)];
           }
           return undefined;
       }
@@ -66215,8 +66326,8 @@ stores.inject(MyMetaStore, storeInstance);
           const oldName = sheet.name;
           this.history.update("sheets", sheet.id, "name", name.trim());
           const sheetIdsMapName = Object.assign({}, this.sheetIdsMapName);
-          delete sheetIdsMapName[oldName];
-          sheetIdsMapName[name] = sheet.id;
+          delete sheetIdsMapName[toStandardizedSheetName(oldName)];
+          sheetIdsMapName[toStandardizedSheetName(name)] = sheet.id;
           this.history.update("sheetIdsMapName", sheetIdsMapName);
       }
       hideSheet(sheetId) {
@@ -66254,7 +66365,7 @@ stores.inject(MyMetaStore, storeInstance);
               });
           }
           const sheetIdsMapName = Object.assign({}, this.sheetIdsMapName);
-          sheetIdsMapName[newSheet.name] = newSheet.id;
+          sheetIdsMapName[toStandardizedSheetName(newSheet.name)] = newSheet.id;
           this.history.update("sheetIdsMapName", sheetIdsMapName);
       }
       getDuplicateSheetName(sheetName) {
@@ -66271,7 +66382,7 @@ stores.inject(MyMetaStore, storeInstance);
           orderedSheetIds.splice(currentIndex, 1);
           this.history.update("orderedSheetIds", orderedSheetIds);
           const sheetIdsMapName = Object.assign({}, this.sheetIdsMapName);
-          delete sheetIdsMapName[name];
+          delete sheetIdsMapName[toStandardizedSheetName(name)];
           this.history.update("sheetIdsMapName", sheetIdsMapName);
       }
       /**
@@ -67591,6 +67702,18 @@ stores.inject(MyMetaStore, storeInstance);
           }
       }
       adaptRanges(applyChange) {
+          for (const pivotId in this.pivots) {
+              const definition = deepCopy(this.pivots[pivotId]?.definition);
+              if (!definition) {
+                  continue;
+              }
+              const newDefinition = pivotRegistry
+                  .get(definition.type)
+                  ?.adaptRanges?.(this.getters, definition, applyChange);
+              if (newDefinition && !deepEquals(definition, newDefinition)) {
+                  this.history.update("pivots", pivotId, "definition", newDefinition);
+              }
+          }
           for (const sheetId in this.compiledMeasureFormulas) {
               for (const formulaString in this.compiledMeasureFormulas[sheetId]) {
                   const compiledFormula = this.compiledMeasureFormulas[sheetId][formulaString];
@@ -67865,20 +67988,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  function adaptPivotRange(range, applyChange) {
-      if (!range) {
-          return undefined;
-      }
-      const change = applyChange(range);
-      switch (change.changeType) {
-          case "NONE":
-              return range;
-          case "REMOVE":
-              return undefined;
-          default:
-              return change.range;
-      }
-  }
   class SpreadsheetPivotCorePlugin extends CorePlugin {
       allowDispatch(cmd) {
           switch (cmd.type) {
@@ -67889,24 +67998,6 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return "Success" /* CommandResult.Success */;
       }
-      adaptRanges(applyChange) {
-          for (const pivotId of this.getters.getPivotIds()) {
-              const definition = this.getters.getPivotCoreDefinition(pivotId);
-              if (definition.type !== "SPREADSHEET") {
-                  continue;
-              }
-              if (definition.dataSet) {
-                  const { sheetId, zone } = definition.dataSet;
-                  const range = this.getters.getRangeFromZone(sheetId, zone);
-                  const adaptedRange = adaptPivotRange(range, applyChange);
-                  const dataSet = adaptedRange && {
-                      sheetId: adaptedRange.sheetId,
-                      zone: adaptedRange.zone,
-                  };
-                  this.dispatch("UPDATE_PIVOT", { pivotId, pivot: { ...definition, dataSet } });
-              }
-          }
-      }
       checkDataSetValidity(definition) {
           if (definition.type === "SPREADSHEET" && definition.dataSet) {
               const { zone, sheetId } = definition.dataSet;
@@ -68905,13 +68996,6 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return result;
       }
-      size() {
-          let size = 0;
-          for (const profile of this.profiles.values()) {
-              size += profile.length;
-          }
-          return size / 2;
-      }
       /**
        * iterator of all the zones in the ZoneSet
        */
@@ -68993,13 +69077,6 @@ stores.inject(MyMetaStore, storeInstance);
       clear() {
           this.setsBySheetId = {};
       }
-      size() {
-          let size = 0;
-          for (const sheetId in this.setsBySheetId) {
-              size += this.setsBySheetId[sheetId].size();
-          }
-          return size;
-      }
       isEmpty() {
           for (const sheetId in this.setsBySheetId) {
               if (!this.setsBySheetId[sheetId].isEmpty()) {
@@ -69503,6 +69580,9 @@ stores.inject(MyMetaStore, storeInstance);
           const arrayFormulas = this.spreadingRelations.searchFormulaPositionsSpreadingOn(position.sheetId, positionToZone(position));
           return arrayFormulas.find((position) => !this.blockedArrayFormulas.has(position));
       }
+      isArrayFormulaSpillBlocked(position) {
+          return this.blockedArrayFormulas.has(position);
+      }
       updateDependencies(position) {
           // removing dependencies is slow because it requires
           // to traverse the entire r-tree.
@@ -69514,13 +69594,8 @@ stores.inject(MyMetaStore, storeInstance);
       addDependencies(position, dependencies) {
           this.formulaDependencies().addDependencies(position, dependencies);
           for (const range of dependencies) {
-              const sheetId = range.sheetId;
-              const { left, bottom, right, top } = range.zone;
-              for (let col = left; col <= right; col++) {
-                  for (let row = top; row <= bottom; row++) {
-                      this.computeAndSave({ sheetId, col, row });
-                  }
-              }
+              // ensure that all ranges are computed
+              this.compilationParams.ensureRange(range, false);
           }
       }
       updateCompilationParameters() {
@@ -69748,6 +69823,10 @@ stores.inject(MyMetaStore, storeInstance);
           this.assertSheetHasEnoughSpaceToSpreadFormulaResult(formulaPosition, formulaReturn);
           const nbColumns = formulaReturn.length;
           const nbRows = formulaReturn[0].length;
+          if (nbRows === 0) {
+              // empty matrix
+              return createEvaluatedCell({ value: 0 }, this.getters.getLocale(), cellData);
+          }
           const resultZone = {
               top: formulaPosition.row,
               bottom: formulaPosition.row + nbRows - 1,
@@ -70018,6 +70097,7 @@ stores.inject(MyMetaStore, storeInstance);
           "getEvaluatedCellsPositions",
           "getSpreadZone",
           "getArrayFormulaSpreadingOn",
+          "isArrayFormulaSpillBlocked",
           "isEmpty",
       ];
       shouldRebuildDependenciesGraph = true;
@@ -70137,6 +70217,9 @@ stores.inject(MyMetaStore, storeInstance);
       getArrayFormulaSpreadingOn(position) {
           return this.evaluator.getArrayFormulaSpreadingOn(position);
       }
+      isArrayFormulaSpillBlocked(position) {
+          return this.evaluator.isArrayFormulaSpillBlocked(position);
+      }
       /**
        * Check if a zone only contains empty cells
        */
@@ -72218,9 +72301,7 @@ stores.inject(MyMetaStore, storeInstance);
       handle(cmd) {
           if (invalidateEvaluationCommands.has(cmd.type)) {
               for (const pivotId of this.getters.getPivotIds()) {
-                  if (!pivotRegistry.get(this.getters.getPivotCoreDefinition(pivotId).type).externalData) {
-                      this.setupPivot(pivotId, { recreate: true });
-                  }
+                  this.setupPivot(pivotId, { recreate: true });
               }
           }
           switch (cmd.type) {
@@ -72442,7 +72523,7 @@ stores.inject(MyMetaStore, storeInstance);
           pivot.init({ reload: true });
       }
       setupPivot(pivotId, { recreate } = { recreate: false }) {
-          const definition = this.getters.getPivotCoreDefinition(pivotId);
+          const definition = deepCopy(this.getters.getPivotCoreDefinition(pivotId));
           if (!(pivotId in this.pivots)) {
               const Pivot = withPivotPresentationLayer(pivotRegistry.get(definition.type).ui);
               this.pivots[pivotId] = new Pivot(this.custom, { definition, getters: this.getters });
@@ -81949,16 +82030,18 @@ stores.inject(MyMetaStore, storeInstance);
       get clickableCells() {
           const cells = [];
           const getters = this.getters;
-          const sheetId = getters.getActiveSheetId();
           for (const position of this.getters.getVisibleCellPositions()) {
               const item = this.getClickableItem(position);
               if (!item) {
                   continue;
               }
               const title = typeof item.title === "function" ? item.title(position, getters) : item.title;
-              const zone = getters.expandZone(sheetId, positionToZone(position));
+              const rect = this.getClickableCellRect(position);
+              if (!rect) {
+                  continue;
+              }
               cells.push({
-                  coordinates: getters.getVisibleRect(zone),
+                  coordinates: rect,
                   position,
                   action: item.execute,
                   title: title || "",
@@ -81968,6 +82051,31 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return cells;
       }
+      getClickableCellRect(position) {
+          const zone = this.getters.expandZone(position.sheetId, positionToZone(position));
+          const clickableRect = this.getters.getVisibleRect(zone);
+          const icons = this.getters.getCellIcons(position);
+          const iconsAtPosition = {
+              center: icons.find((icon) => icon.horizontalAlign === "center"),
+              left: icons.find((icon) => icon.horizontalAlign === "left"),
+              right: icons.find((icon) => icon.horizontalAlign === "right"),
+          };
+          if (iconsAtPosition.center?.onClick) {
+              return undefined;
+          }
+          if (iconsAtPosition.right?.onClick) {
+              const cellRect = this.getters.getRect(zone);
+              const iconRect = this.getters.getCellIconRect(iconsAtPosition.right, cellRect);
+              clickableRect.width -= iconRect.width + iconsAtPosition.right.margin;
+          }
+          if (iconsAtPosition.left?.onClick) {
+              const cellRect = this.getters.getRect(zone);
+              const iconRect = this.getters.getCellIconRect(iconsAtPosition.left, cellRect);
+              clickableRect.x += iconRect.width + iconsAtPosition.left.margin;
+              clickableRect.width -= iconRect.width + iconsAtPosition.left.margin;
+          }
+          return clickableRect;
+      }
   }
 
   css /* scss */ `
@@ -82725,7 +82833,7 @@ stores.inject(MyMetaStore, storeInstance);
                   height: this.focus === "inactive" ? "26px" : "fit-content",
                   "max-height": `130px`,
               }),
-              showAssistant: !isIOS(), // Hide assistant on iOS as it breaks visually
+              showAssistant: false, // Hide assistant in small composer as it gets cropped ATM
               placeholder: this.composerStore.placeholder,
           };
       }
@@ -84217,7 +84325,7 @@ stores.inject(MyMetaStore, storeInstance);
                   document.activeElement?.contains(this.spreadsheetRef.el)) {
                   this.focusGrid();
               }
-          }, () => [this.env.model.getters.getActiveSheetId()]);
+          });
           owl.useExternalListener(window, "resize", () => this.render(true));
           // For some reason, the wheel event is not properly registered inside templates
           // in Chromium-based browsers based on chromium 125
@@ -89007,9 +89115,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "19.0.11";
-  __info__.date = "2025-11-24T07:46:47.685Z";
-  __info__.hash = "f5bdbcc";
+  __info__.version = "19.0.15";
+  __info__.date = "2025-12-26T10:19:23.408Z";
+  __info__.hash = "fe625c9";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);