@odoo/o-spreadsheet 19.0.10 → 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.10
- * @date 2025-11-12T14:15:51.076Z
- * @hash 18ac688
+ * @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",
@@ -863,7 +862,7 @@
   };
   const PIVOT_INDENT = 15;
   const PIVOT_COLLAPSE_ICON_SIZE = 12;
-  const PIVOT_MAX_NUMBER_OF_CELLS = 1e5;
+  const PIVOT_MAX_NUMBER_OF_CELLS = 5e5;
   const DEFAULT_CURRENCY = {
       symbol: "$",
       position: "before",
@@ -13349,7 +13348,7 @@ stores.inject(MyMetaStore, storeInstance);
                   if (!acceptHiddenCells && this.getters.isRowHiddenByUser(sheetId, row))
                       continue;
                   for (let col = left; col <= right; col++) {
-                      const cell = this.getters.getCell({ sheetId, col, row });
+                      const cell = this.getters.getCorrespondingFormulaCell({ sheetId, col, row });
                       if (!cell || !isSubtotalCell(cell)) {
                           evaluatedCellToKeep.push(this.getters.getEvaluatedCell({ sheetId, col, row }));
                       }
@@ -19345,7 +19344,7 @@ stores.inject(MyMetaStore, storeInstance);
   function setXcToFixedReferenceType(xc, referenceType) {
       let sheetName;
       ({ sheetName, xc } = splitReference(xc));
-      sheetName = sheetName ? sheetName + "!" : "";
+      sheetName = sheetName ? getCanonicalSymbolName(sheetName) + "!" : "";
       xc = xc.replace(/\$/g, "");
       const splitIndex = xc.indexOf(":");
       if (splitIndex >= 0) {
@@ -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
@@ -34524,16 +34569,12 @@ stores.inject(MyMetaStore, storeInstance);
       processTabKey(ev, direction) {
           ev.preventDefault();
           ev.stopPropagation();
-          if (!this.assistant.forcedClosed) {
-              this.props.composerStore.autoCompleteOrStop(direction);
-          }
+          this.props.composerStore.autoCompleteOrStop(direction, this.assistant.forcedClosed);
       }
       processEnterKey(ev, direction) {
           ev.preventDefault();
           ev.stopPropagation();
-          if (!this.assistant.forcedClosed) {
-              this.props.composerStore.autoCompleteOrStop(direction);
-          }
+          this.props.composerStore.autoCompleteOrStop(direction, this.assistant.forcedClosed);
       }
       processNewLineEvent(ev) {
           ev.preventDefault();
@@ -34709,7 +34750,6 @@ stores.inject(MyMetaStore, storeInstance);
               return;
           }
           const newSelection = this.contentHelper.getCurrentSelection();
-          this.props.composerStore.stopComposerRangeSelection();
           const isCurrentlyInactive = this.props.composerStore.editionMode === "inactive";
           this.props.onComposerContentFocused(newSelection);
           if (!isCurrentlyInactive) {
@@ -35200,6 +35240,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           this.selectionStart = start;
           this.selectionEnd = end;
+          this.stopComposerRangeSelection();
           this.computeFormulaCursorContext();
           this.computeParenthesisRelatedToCursor();
           this.updateAutoCompleteProvider();
@@ -35870,10 +35911,13 @@ stores.inject(MyMetaStore, storeInstance);
       hideHelp() {
           this.autoComplete.hide();
       }
-      autoCompleteOrStop(direction) {
+      autoCompleteOrStop(direction, assistantForcedClosed = false) {
           if (this.editionMode !== "inactive") {
               const autoComplete = this.autoComplete;
-              if (autoComplete.provider && autoComplete.selectedIndex !== undefined) {
+              const suppressAutocomplete = assistantForcedClosed && this.canBeToggled;
+              if (!suppressAutocomplete &&
+                  autoComplete.provider &&
+                  autoComplete.selectedIndex !== undefined) {
                   const autoCompleteValue = autoComplete.provider.proposals[autoComplete.selectedIndex]?.text;
                   if (autoCompleteValue) {
                       this.autoComplete.provider?.selectProposal(autoCompleteValue);
@@ -44193,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;
               }
           });
       }
@@ -47787,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",
@@ -51564,10 +51611,11 @@ stores.inject(MyMetaStore, storeInstance);
           this.state.waitingForMove = false;
       }
       onMouseMove(ev) {
-          if (this.env.isMobile()) {
-              return;
-          }
-          if (this.state.isResizing || this.state.isMoving || this.state.isSelecting) {
+          if (this.env.isMobile() ||
+              this.env.model.getters.isReadonly() ||
+              this.state.isResizing ||
+              this.state.isMoving ||
+              this.state.isSelecting) {
               return;
           }
           this._computeHandleDisplay(ev);
@@ -51634,6 +51682,10 @@ stores.inject(MyMetaStore, storeInstance);
           if (index < 0) {
               return;
           }
+          if (this.env.model.getters.isReadonly()) {
+              this._selectElement(index, false);
+              return;
+          }
           if (this.state.waitingForMove) {
               if (!this.env.model.getters.isGridSelectionActive()) {
                   this._selectElement(index, false);
@@ -52995,7 +53047,7 @@ stores.inject(MyMetaStore, storeInstance);
   const verticalScrollFactor = 1;
   const horizontalScrollFactor = 1;
   const resetTimeoutDuration = 100;
-  function useTouchScroll(ref, updateScroll, canMoveUp) {
+  function useTouchScroll(ref, updateScroll, canMoveUp, canMoveDown) {
       let lastX = 0;
       let lastY = 0;
       let velocityX = 0;
@@ -53032,7 +53084,7 @@ stores.inject(MyMetaStore, storeInstance);
           lastX = clientX;
           lastY = clientY;
           lastTime = currentTime;
-          if (canMoveUp()) {
+          if ((deltaY < 0 && canMoveUp()) || (deltaY > 0 && canMoveDown())) {
               if (event.cancelable) {
                   event.preventDefault();
               }
@@ -53818,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() {
@@ -53872,6 +53926,13 @@ stores.inject(MyMetaStore, storeInstance);
               }
               this.props.onToggle?.();
           }
+          if (ev.key === "Tab") {
+              ev.preventDefault();
+              ev.stopPropagation();
+              this.closeFontList();
+              this.DOMFocusableElementStore.focus();
+              return;
+          }
       }
   }
 
@@ -55207,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 = {
@@ -55233,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 = {
@@ -56161,7 +56229,7 @@ stores.inject(MyMetaStore, storeInstance);
   })
       .add("bar", {
       configuration: BarConfigPanel,
-      design: GenericZoomableChartDesignPanel,
+      design: BarChartDesignPanel,
   })
       .add("combo", {
       configuration: GenericChartConfigPanel,
@@ -59270,7 +59338,6 @@ stores.inject(MyMetaStore, storeInstance);
           // replace the whole token
           start = tokenAtCursor.start;
       }
-      this.composer.stopComposerRangeSelection();
       this.composer.changeComposerCursorSelection(start, end);
       this.composer.replaceComposerCursorSelection(value);
   }
@@ -59288,7 +59355,6 @@ stores.inject(MyMetaStore, storeInstance);
           // replace the whole token
           start = tokenAtCursor.start;
       }
-      this.composer.stopComposerRangeSelection();
       this.composer.changeComposerCursorSelection(start, end);
       this.composer.replaceComposerCursorSelection(value);
   }
@@ -60749,6 +60815,7 @@ stores.inject(MyMetaStore, storeInstance);
       getPanelProps(panelInfo) {
           const state = this.computeState(panelInfo);
           if (state.isOpen) {
+              panelInfo.currentPanelProps = state.props ?? panelInfo.currentPanelProps;
               return state.props ?? {};
           }
           return {};
@@ -60760,11 +60827,11 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return undefined;
       }
-      open(componentTag, initialPanelProps = {}) {
+      open(componentTag, currentPanelProps = {}) {
           if (this.screenWidthStore.isSmall) {
               return;
           }
-          const newPanelInfo = { initialPanelProps, componentTag, size: DEFAULT_SIDE_PANEL_SIZE };
+          const newPanelInfo = { currentPanelProps, componentTag, size: DEFAULT_SIDE_PANEL_SIZE };
           const state = this.computeState(newPanelInfo);
           if (!state.isOpen) {
               return;
@@ -60788,8 +60855,8 @@ stores.inject(MyMetaStore, storeInstance);
           }
           this._openPanel("secondaryPanel", newPanelInfo, state);
       }
-      replace(componentTag, currentPanelKey, initialPanelProps = {}) {
-          const newPanelInfo = { initialPanelProps, componentTag, size: DEFAULT_SIDE_PANEL_SIZE };
+      replace(componentTag, currentPanelKey, currentPanelProps = {}) {
+          const newPanelInfo = { currentPanelProps, componentTag, size: DEFAULT_SIDE_PANEL_SIZE };
           const state = this.computeState(newPanelInfo);
           if (!state.isOpen) {
               return;
@@ -60819,10 +60886,10 @@ stores.inject(MyMetaStore, storeInstance);
       _openPanel(panel, newPanel, state) {
           const currentPanel = this[panel];
           if (currentPanel && newPanel.componentTag !== currentPanel.componentTag) {
-              currentPanel.initialPanelProps?.onCloseSidePanel?.();
+              currentPanel.currentPanelProps?.onCloseSidePanel?.();
           }
           this[panel] = {
-              initialPanelProps: state.props ?? {},
+              currentPanelProps: state.props ?? {},
               componentTag: newPanel.componentTag,
               size: currentPanel?.size || DEFAULT_SIDE_PANEL_SIZE,
               isCollapsed: currentPanel?.isCollapsed || false,
@@ -60844,16 +60911,16 @@ stores.inject(MyMetaStore, storeInstance);
       close() {
           if (this.mainPanel?.isPinned) {
               if (this.secondaryPanel) {
-                  this.secondaryPanel.initialPanelProps.onCloseSidePanel?.();
+                  this.secondaryPanel.currentPanelProps.onCloseSidePanel?.();
                   this.secondaryPanel = undefined;
               }
               return;
           }
-          this.mainPanel?.initialPanelProps.onCloseSidePanel?.();
+          this.mainPanel?.currentPanelProps.onCloseSidePanel?.();
           this.mainPanel = undefined;
       }
       closeMainPanel() {
-          this.mainPanel?.initialPanelProps.onCloseSidePanel?.();
+          this.mainPanel?.currentPanelProps.onCloseSidePanel?.();
           this.mainPanel = this.secondaryPanel || undefined;
           this.secondaryPanel = undefined;
       }
@@ -60885,7 +60952,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           this.mainPanel.isPinned = !this.mainPanel.isPinned;
           if (!this.mainPanel.isPinned && this.secondaryPanel) {
-              this.secondaryPanel?.initialPanelProps.onCloseSidePanel?.();
+              this.secondaryPanel?.currentPanelProps.onCloseSidePanel?.();
               this.mainPanel = this.secondaryPanel;
               this.secondaryPanel = undefined;
           }
@@ -60904,7 +60971,7 @@ stores.inject(MyMetaStore, storeInstance);
               panelInfo.size = COLLAPSED_SIDE_PANEL_SIZE;
           }
       }
-      computeState({ componentTag, initialPanelProps }) {
+      computeState({ componentTag, currentPanelProps: initialPanelProps, }) {
           const customComputeState = sidePanelRegistry.get(componentTag).computeState;
           const state = customComputeState
               ? customComputeState(this.getters, initialPanelProps)
@@ -60914,7 +60981,7 @@ stores.inject(MyMetaStore, storeInstance);
       changeSpreadsheetWidth(width) {
           this.availableWidth = width - MIN_SHEET_VIEW_WIDTH;
           if (this.secondaryPanel && width - this.totalPanelSize < MIN_SHEET_VIEW_WIDTH) {
-              this.secondaryPanel?.initialPanelProps.onCloseSidePanel?.();
+              this.secondaryPanel?.currentPanelProps.onCloseSidePanel?.();
               this.secondaryPanel = undefined;
           }
           if (this.mainPanel && width - this.totalPanelSize < MIN_SHEET_VIEW_WIDTH) {
@@ -61074,6 +61141,10 @@ stores.inject(MyMetaStore, storeInstance);
           useTouchScroll(this.gridRef, this.moveCanvas.bind(this), () => {
               const { scrollY } = this.env.model.getters.getActiveSheetScrollInfo();
               return scrollY > 0;
+          }, () => {
+              const { maxOffsetY } = this.env.model.getters.getMaximumSheetOffset();
+              const { scrollY } = this.env.model.getters.getActiveSheetScrollInfo();
+              return scrollY < maxOffsetY;
           });
       }
       get highlights() {
@@ -62366,22 +62437,34 @@ stores.inject(MyMetaStore, storeInstance);
       addBorder(sheetId, zone, newBorder, force = false) {
           const borders = [];
           const plannedBorder = newBorder ? { zone, style: newBorder } : undefined;
-          const sideToClear = {
-              left: force || !!newBorder?.left,
-              right: force || !!newBorder?.right,
-              top: force || !!newBorder?.top,
-              bottom: force || !!newBorder?.bottom,
+          // For each side, decide if we must clear the border on the *adjacent*
+          // existing cell when we draw on the opposite side of the new zone.
+          //
+          // Example:
+          //  - newBorder.right is set → we draw border on the RIGHT side of `zone`
+          //  - the cell on the right may already have a LEFT border on that edge
+          // In that case we clear that LEFT border, so only the new RIGHT border
+          // remains on the shared edge.
+          //
+          // 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,
           };
           let editingZone = [zone];
           for (const existingBorder of this.borders[sheetId] ?? []) {
               const inter = intersection(existingBorder.zone, zone);
               if (!inter) {
-                  // Clear adjacent borders on which you write
+                  // Check if the existing border is adjacent to the new zone
                   const adjacentEdge = adjacent(existingBorder.zone, zone);
-                  if (adjacentEdge && sideToClear[adjacentEdge.position]) {
+                  if (adjacentEdge && existingBorderSideToClear[adjacentEdge.position]) {
                       for (const newZone of splitIfAdjacent(existingBorder.zone, zone)) {
                           const border = this.computeBorderFromZone(newZone, existingBorder);
                           const adjacentEdge = adjacent(newZone, zone);
+                          // Clear the existing border on the side that touches the new zone
                           switch (adjacentEdge?.position) {
                               case "left":
                                   border.style.left = undefined;
@@ -64238,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;
@@ -67716,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 });
                   }
               }
           }
@@ -67880,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,
@@ -72199,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) {
@@ -72423,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 });
@@ -78675,6 +78767,7 @@ stores.inject(MyMetaStore, storeInstance);
           "getFigureUI",
           "getPositionAnchorOffset",
           "getGridOffset",
+          "getMaximumSheetOffset",
       ];
       viewports = {};
       /**
@@ -81929,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 || "",
@@ -81948,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 */ `
@@ -81986,6 +82106,10 @@ stores.inject(MyMetaStore, storeInstance);
           useTouchScroll(this.gridRef, this.moveCanvas.bind(this), () => {
               const { scrollY } = this.env.model.getters.getActiveSheetScrollInfo();
               return scrollY > 0;
+          }, () => {
+              const { maxOffsetY } = this.env.model.getters.getMaximumSheetOffset();
+              const { scrollY } = this.env.model.getters.getActiveSheetScrollInfo();
+              return scrollY < maxOffsetY;
           });
       }
       get gridContainer() {
@@ -82701,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,
           };
       }
@@ -84030,7 +84154,7 @@ stores.inject(MyMetaStore, storeInstance);
     border-radius: 4px;
     font-weight: 500;
     font-size: 14px;
-    height: 32px;
+    min-height: 32px;
     line-height: 16px;
     flex-grow: 1;
     background-color: ${BUTTON_BG};
@@ -88983,9 +89107,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "19.0.10";
-  __info__.date = "2025-11-12T14:15:51.076Z";
-  __info__.hash = "18ac688";
+  __info__.version = "19.0.12";
+  __info__.date = "2025-12-02T05:34:17.495Z";
+  __info__.hash = "32203f1";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);