@odoo/o-spreadsheet 19.0.11 → 19.0.12

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.12
+ * @date 2025-12-02T05:34:17.495Z
+ * @hash 32203f1
  */
 
 (function (exports, owl) {
@@ -182,7 +182,6 @@
       "REDO",
       "ADD_MERGE",
       "REMOVE_MERGE",
-      "DUPLICATE_SHEET",
       "UPDATE_LOCALE",
       "ADD_PIVOT",
       "UPDATE_PIVOT",
@@ -23878,6 +23877,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 +25565,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 +25606,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 +27743,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 +27771,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 +27786,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 +27858,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 +27876,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 +27913,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 +27927,7 @@ stores.inject(MyMetaStore, storeInstance);
                   ...chartData.options,
                   scales: {
                       ...chartData.options.scales,
-                      x: xScale,
+                      x,
                   },
                   layout: {
                       ...chartData.options.layout,
@@ -27940,9 +27942,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 +27966,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 +27982,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 +27994,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 +28010,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 +28021,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 +28044,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 +28093,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 +28165,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 +28177,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 +28208,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 +28275,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 +28299,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);
       }
   }
 
@@ -34404,7 +34448,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 +35240,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           this.selectionStart = start;
           this.selectionEnd = end;
-          this.editionMode = "editing";
+          this.stopComposerRangeSelection();
           this.computeFormulaCursorContext();
           this.computeParenthesisRelatedToCursor();
           this.updateAutoCompleteProvider();
@@ -44192,18 +44237,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;
               }
           });
       }
@@ -47786,7 +47835,6 @@ 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",
@@ -53822,7 +53870,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 +53926,13 @@ stores.inject(MyMetaStore, storeInstance);
               }
               this.props.onToggle?.();
           }
+          if (ev.key === "Tab") {
+              ev.preventDefault();
+              ev.stopPropagation();
+              this.closeFontList();
+              this.DOMFocusableElementStore.focus();
+              return;
+          }
       }
   }
 
@@ -55211,19 +55268,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 +55281,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 +56229,7 @@ stores.inject(MyMetaStore, storeInstance);
   })
       .add("bar", {
       configuration: BarConfigPanel,
-      design: GenericZoomableChartDesignPanel,
+      design: BarChartDesignPanel,
   })
       .add("combo", {
       configuration: GenericChartConfigPanel,
@@ -64257,7 +64321,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;
@@ -67735,10 +67800,17 @@ stores.inject(MyMetaStore, storeInstance);
               if (!pivot) {
                   continue;
               }
-              for (const measure of pivot.definition.measures) {
+              const def = deepCopy(pivot.definition);
+              for (const measure of def.measures) {
                   if (measure.computedBy?.formula === formulaString) {
-                      const measureIndex = pivot.definition.measures.indexOf(measure);
-                      this.history.update("pivots", pivotId, "definition", "measures", measureIndex, "computedBy", { formula: newFormulaString, sheetId });
+                      const measureIndex = def.measures.indexOf(measure);
+                      if (measureIndex !== -1) {
+                          def.measures[measureIndex].computedBy = {
+                              formula: newFormulaString,
+                              sheetId,
+                          };
+                      }
+                      this.dispatch("UPDATE_PIVOT", { pivotId, pivot: def });
                   }
               }
           }
@@ -67899,6 +67971,9 @@ stores.inject(MyMetaStore, storeInstance);
                   const { sheetId, zone } = definition.dataSet;
                   const range = this.getters.getRangeFromZone(sheetId, zone);
                   const adaptedRange = adaptPivotRange(range, applyChange);
+                  if (adaptedRange === range) {
+                      return;
+                  }
                   const dataSet = adaptedRange && {
                       sheetId: adaptedRange.sheetId,
                       zone: adaptedRange.zone,
@@ -72218,9 +72293,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 +72515,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 +82022,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 +82043,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 +82825,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,
           };
       }
@@ -89007,9 +89107,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.12";
+  __info__.date = "2025-12-02T05:34:17.495Z";
+  __info__.hash = "32203f1";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);