@odoo/o-spreadsheet 19.0.5 → 19.0.7

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.5
- * @date 2025-10-07T10:04:06.400Z
- * @hash 86fc442
+ * @version 19.0.7
+ * @date 2025-10-23T08:19:01.764Z
+ * @hash 1c1d1ec
  */
 
 (function (exports, owl) {
@@ -1892,6 +1892,29 @@
           removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex);
       }
   }
+  function profilesContainsZone(profilesStartingPosition, profiles, zone) {
+      const leftValue = zone.left;
+      const rightValue = zone.right;
+      const topValue = zone.top;
+      const bottomValue = zone.bottom + 1;
+      const leftIndex = binaryPredecessorSearch(profilesStartingPosition, leftValue, 0);
+      const rightIndex = binaryPredecessorSearch(profilesStartingPosition, rightValue, leftIndex);
+      if (leftIndex === -1 || rightIndex === -1) {
+          return false;
+      }
+      for (let i = leftIndex; i <= rightIndex; i++) {
+          const profile = profiles.get(profilesStartingPosition[i]);
+          const topPredIndex = binaryPredecessorSearch(profile, topValue, 0, true);
+          const bottomSuccIndex = binarySuccessorSearch(profile, bottomValue, 0, true);
+          if (topPredIndex === -1 || topPredIndex % 2 !== 0) {
+              return false;
+          }
+          if (topValue < profile[topPredIndex] || bottomValue > profile[bottomSuccIndex]) {
+              return false;
+          }
+      }
+      return true;
+  }
   function findIndexAndCreateProfile(profilesStartingPosition, profiles, value, searchLeft, startIndex) {
       if (value === undefined) {
           // this is only the case when the value correspond to a bottom value that could be undefined
@@ -1976,7 +1999,18 @@
       }
       // add the top and bottom value to the profile and
       // remove all information between the top and bottom index
-      profile.splice(topPredIndex + 1, bottomSuccIndex - topPredIndex - 1, ...newPoints);
+      const toDelete = bottomSuccIndex - topPredIndex - 1;
+      const toInsert = newPoints.length;
+      const start = topPredIndex + 1;
+      // fast path and slow path
+      if (start === profile.length - 1 && toDelete === 1 && toInsert === 1) {
+          // fast path: we just need to replace the last element
+          profile[start] = newPoints[0] ?? newPoints[1];
+      }
+      else {
+          // equivalent but slower and with memory allocation
+          profile.splice(start, toDelete, ...newPoints);
+      }
   }
   function removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex) {
       const start = leftIndex - 1 === -1 ? 0 : leftIndex - 1;
@@ -2015,8 +2049,10 @@
                   left,
                   bottom,
                   right,
-                  hasHeader: (bottom === undefined && top !== 0) || (right === undefined && left !== 0),
               };
+              if ((bottom === undefined && top !== 0) || (right === undefined && left !== 0)) {
+                  profileZone.hasHeader = true;
+              }
               let findCorrespondingZone = false;
               for (let j = pendingZones.length - 1; j >= 0; j--) {
                   const pendingZone = pendingZones[j];
@@ -2501,17 +2537,6 @@
       }
       return [leftColumnZone, rightPartZone];
   }
-  function aggregatePositionsToZones(positions) {
-      const result = {};
-      for (const position of positions) {
-          result[position.sheetId] ??= [];
-          result[position.sheetId].push(positionToZone(position));
-      }
-      for (const sheetId in result) {
-          result[sheetId] = recomputeZones(result[sheetId]);
-      }
-      return result;
-  }
   /**
    * Array of all positions in the zone.
    */
@@ -4514,7 +4539,17 @@
       return toMatrix(data).map((row) => {
           return row.map((cell) => {
               if (typeof cell.value !== "number") {
-                  throw new EvaluationError(_t("Function [[FUNCTION_NAME]] expects number values for %s, but got a %s.", argName, typeof cell.value));
+                  let message = "";
+                  if (typeof cell === "object") {
+                      message = _t("Function [[FUNCTION_NAME]] expects number values for %s, but got an empty value.", argName);
+                  }
+                  else if (typeof cell === "string") {
+                      message = _t("Function [[FUNCTION_NAME]] expects number values for %s, but got a string.", argName);
+                  }
+                  else if (typeof cell === "boolean") {
+                      message = _t("Function [[FUNCTION_NAME]] expects number values for %s, but got a boolean.", argName);
+                  }
+                  throw new EvaluationError(message);
               }
               return cell.value;
           });
@@ -6933,6 +6968,10 @@
       }
       return parts;
   }
+  function positionToBoundedRange(position) {
+      const zone = { left: position.col, top: position.row, right: position.col, bottom: position.row };
+      return { sheetId: position.sheetId, zone };
+  }
   /**
    * Check that a zone is valid regarding the order of top-bottom and left-right.
    * Left should be smaller than right, top should be smaller than bottom.
@@ -9529,7 +9568,7 @@
       pasteCell(origin, target, clipboardOption) {
           const { sheetId, col, row } = target;
           const targetCell = this.getters.getEvaluatedCell(target);
-          const originFormat = origin?.format ?? origin.evaluatedCell.format;
+          const originFormat = origin?.format || origin.evaluatedCell.format;
           if (clipboardOption?.pasteOption === "asValue") {
               this.dispatch("UPDATE_CELL", {
                   ...target,
@@ -13902,7 +13941,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (knownDataY.length === 0 || knownDataY[0].length === 0) {
               return new EvaluationError(emptyDataErrorMessage("known_data_y"));
           }
-          return expM(predictLinearValues(logM(toNumberMatrix(knownDataY, "the first argument (known_data_y)")), toNumberMatrix(knownDataX, "the second argument (known_data_x)"), toNumberMatrix(newDataX, "the third argument (new_data_y)"), toBoolean(b)));
+          return expM(predictLinearValues(logM(toNumberMatrix(knownDataY, "known_data_y")), toNumberMatrix(knownDataX, "known_data_x"), toNumberMatrix(newDataX, "new_data_y"), toBoolean(b)));
       },
   };
   // -----------------------------------------------------------------------------
@@ -13975,7 +14014,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (dataY.length === 0 || dataY[0].length === 0) {
               return new EvaluationError(emptyDataErrorMessage("data_y"));
           }
-          return fullLinearRegression(toNumberMatrix(dataX, "the first argument (data_y)"), toNumberMatrix(dataY, "the second argument (data_x)"), toBoolean(calculateB), toBoolean(verbose));
+          return fullLinearRegression(toNumberMatrix(dataX, "data_x"), toNumberMatrix(dataY, "data_y"), toBoolean(calculateB), toBoolean(verbose));
       },
       isExported: true,
   };
@@ -13994,7 +14033,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (dataY.length === 0 || dataY[0].length === 0) {
               return new EvaluationError(emptyDataErrorMessage("data_y"));
           }
-          const coeffs = fullLinearRegression(toNumberMatrix(dataX, "the second argument (data_x)"), logM(toNumberMatrix(dataY, "the first argument (data_y)")), toBoolean(calculateB), toBoolean(verbose));
+          const coeffs = fullLinearRegression(toNumberMatrix(dataX, "data_x"), logM(toNumberMatrix(dataY, "data_y")), toBoolean(calculateB), toBoolean(verbose));
           for (let i = 0; i < coeffs.length; i++) {
               coeffs[i][0] = Math.exp(coeffs[i][0]);
           }
@@ -14615,7 +14654,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (knownDataY.length === 0 || knownDataY[0].length === 0) {
               return new EvaluationError(emptyDataErrorMessage("known_data_y"));
           }
-          return predictLinearValues(toNumberMatrix(knownDataY, "the first argument (known_data_y)"), toNumberMatrix(knownDataX, "the second argument (known_data_x)"), toNumberMatrix(newDataX, "the third argument (new_data_y)"), toBoolean(b));
+          return predictLinearValues(toNumberMatrix(knownDataY, "known_data_y"), toNumberMatrix(knownDataX, "known_data_x"), toNumberMatrix(newDataX, "new_data_y"), toBoolean(b));
       },
   };
   // -----------------------------------------------------------------------------
@@ -23136,6 +23175,10 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const ctx = chart.ctx;
           ctx.save();
+          const { left, top, height, width } = chart.chartArea;
+          ctx.beginPath();
+          ctx.rect(left, top, width, height);
+          ctx.clip();
           ctx.textAlign = "center";
           ctx.textBaseline = "middle";
           ctx.miterLimit = 1; // Avoid sharp artifacts on strokeText
@@ -24179,7 +24222,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.chart.update();
       }
       hasChartDataChanged() {
-          return !deepEquals(this.currentRuntime.chartJsConfig.data, this.chartRuntime.chartJsConfig.data);
+          return !deepEquals(this.getChartDataInRuntime(this.currentRuntime), this.getChartDataInRuntime(this.chartRuntime));
       }
       enableAnimationInChartData(chartData) {
           return {
@@ -24187,6 +24230,17 @@ stores.inject(MyMetaStore, storeInstance);
               options: { ...chartData.options, animation: { animateRotate: true } },
           };
       }
+      getChartDataInRuntime(runtime) {
+          const data = runtime.chartJsConfig.data;
+          return {
+              labels: data.labels,
+              dataset: data.datasets.map((dataset) => ({
+                  data: dataset.data,
+                  label: dataset.label,
+                  tree: dataset.tree,
+              })),
+          };
+      }
       get animationChartId() {
           return this.props.isFullScreen ? this.props.chartId + "-fullscreen" : this.props.chartId;
       }
@@ -25610,6 +25664,7 @@ stores.inject(MyMetaStore, storeInstance);
           parser: luxonFormat,
           displayFormats,
           unit: timeUnit ?? false,
+          tooltipFormat: luxonFormat,
       };
   }
   /**
@@ -26678,6 +26733,7 @@ stores.inject(MyMetaStore, storeInstance);
           };
           Object.assign(scales.x, axis);
           scales.x.ticks.maxTicksLimit = 15;
+          delete scales?.x?.ticks?.callback;
       }
       else if (axisType === "linear") {
           scales.x.type = "linear";
@@ -32363,7 +32419,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       openContextMenu(ev) {
           this.menuState.isOpen = true;
-          this.menuState.anchorRect = { x: ev.clientX, y: ev.clientY, width: 0, height: 0 };
+          this.menuState.anchorRect = getBoundingRectAsPOJO(ev.currentTarget);
           const figureId = this.env.model.getters.getFigureIdFromChartId(this.props.chartId);
           this.menuState.menuItems = getChartMenuActions(figureId, () => { }, this.env);
       }
@@ -32395,6 +32451,7 @@ stores.inject(MyMetaStore, storeInstance);
           onFigureDeleted: Function,
           editFigureStyle: { type: Function, optional: true },
           isFullScreen: { type: Boolean, optional: true },
+          openContextMenu: { type: Function, optional: true },
       };
       static components = { ChartDashboardMenu, MenuPopover };
       carouselTabsRef = owl.useRef("carouselTabs");
@@ -32528,6 +32585,12 @@ stores.inject(MyMetaStore, storeInstance);
       get visibleCarouselItems() {
           return this.carousel.items.filter((item) => item.type === "carouselDataView" && this.props.isFullScreen ? false : true);
       }
+      openContextMenu(event) {
+          const target = event.currentTarget;
+          if (target) {
+              this.props.openContextMenu?.(getBoundingRectAsPOJO(target));
+          }
+      }
   }
 
   class ChartFigure extends owl.Component {
@@ -32537,6 +32600,7 @@ stores.inject(MyMetaStore, storeInstance);
           onFigureDeleted: Function,
           editFigureStyle: { type: Function, optional: true },
           isFullScreen: { type: Boolean, optional: true },
+          openContextMenu: { type: Function, optional: true },
       };
       static components = { ChartDashboardMenu };
       onDoubleClick() {
@@ -32569,6 +32633,7 @@ stores.inject(MyMetaStore, storeInstance);
           figureUI: Object,
           onFigureDeleted: Function,
           editFigureStyle: { type: Function, optional: true },
+          openContextMenu: { type: Function, optional: true },
       };
       static components = {};
       // ---------------------------------------------------------------------------
@@ -34620,8 +34685,11 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const newSelection = this.contentHelper.getCurrentSelection();
           this.props.composerStore.stopComposerRangeSelection();
-          this.props.onComposerContentFocused();
-          this.props.composerStore.changeComposerCursorSelection(newSelection.start, newSelection.end);
+          const isCurrentlyInactive = this.props.composerStore.editionMode === "inactive";
+          this.props.onComposerContentFocused(newSelection);
+          if (!isCurrentlyInactive) {
+              this.props.composerStore.changeComposerCursorSelection(newSelection.start, newSelection.end);
+          }
           this.processTokenAtCursor();
       }
       onDblClick() {
@@ -35116,13 +35184,6 @@ stores.inject(MyMetaStore, storeInstance);
           }
       }
       startEdition(text, selection) {
-          if (selection) {
-              const content = text || this.getComposerContent(this.getters.getActivePosition());
-              const validSelection = this.isSelectionValid(content.length, selection.start, selection.end);
-              if (!validSelection) {
-                  return;
-              }
-          }
           const { col, row } = this.getters.getActivePosition();
           this.model.dispatch("SELECT_FIGURE", { figureId: null });
           this.model.dispatch("SCROLL_TO_CELL", { col, row });
@@ -35179,7 +35240,7 @@ stores.inject(MyMetaStore, storeInstance);
       // ---------------------------------------------------------------------------
       get currentContent() {
           if (this.editionMode === "inactive") {
-              return this.getComposerContent(this.getters.getActivePosition());
+              return this.getComposerContent(this.getters.getActivePosition()).text;
           }
           return this._currentContent;
       }
@@ -35378,8 +35439,9 @@ stores.inject(MyMetaStore, storeInstance);
           this.sheetId = sheetId;
           this.row = row;
           this.editionMode = "editing";
-          this.initialContent = this.getComposerContent({ sheetId, col, row });
-          this.setContent(str || this.initialContent, selection);
+          const { text, adjustedSelection } = this.getComposerContent({ sheetId, col, row }, selection);
+          this.initialContent = text;
+          this.setContent(str || this.initialContent, adjustedSelection ?? selection);
           this.colorIndexByRange = {};
           const zone = positionToZone({ col: this.col, row: this.row });
           this.captureSelection(zone, col, row);
@@ -35856,7 +35918,7 @@ stores.inject(MyMetaStore, storeInstance);
       constructor(get, args) {
           super(get);
           this.args = args;
-          this._currentContent = this.getComposerContent();
+          this._currentContent = this.getComposerContent().text;
       }
       getAutoCompleteProviders() {
           const providersDefinitions = super.getAutoCompleteProviders();
@@ -35893,7 +35955,7 @@ stores.inject(MyMetaStore, storeInstance);
               })
                   .join("");
           }
-          return localizeContent(content, this.getters.getLocale());
+          return { text: localizeContent(content, this.getters.getLocale()) };
       }
       stopEdition() {
           this._stopEdition();
@@ -38663,12 +38725,23 @@ stores.inject(MyMetaStore, storeInstance);
       .add("LinkEditor", LinkEditorPopoverBuilder)
       .add("FilterMenu", FilterMenuPopoverBuilder);
 
-  const CHART_LIMITS = {
-      MAX_PIE_CATEGORIES: 7,
-      MAX_PIE_CATEGORIES_NO_TITLE: 6,
-      MIN_RADAR_CATEGORIES: 3,
-      MAX_RADAR_CATEGORIES: 12,
-      PERCENTAGE_THRESHOLD: 100,
+  const DEFAULT_BAR_CHART_CONFIG = {
+      type: "bar",
+      title: {},
+      dataSets: [],
+      legendPosition: "none",
+      dataSetsHaveTitle: false,
+      stacked: false,
+  };
+  const DEFAULT_LINE_CHART_CONFIG = {
+      type: "line",
+      title: {},
+      dataSets: [],
+      legendPosition: "none",
+      dataSetsHaveTitle: false,
+      stacked: false,
+      cumulative: false,
+      labelsAsText: false,
   };
   function getUnboundRange(getters, zone) {
       return zoneToXc(getters.getUnboundedZone(getters.getActiveSheetId(), zone));
@@ -38707,43 +38780,19 @@ stores.inject(MyMetaStore, storeInstance);
       return detectedType;
   }
   function categorizeColumns(zones, getters) {
-      const columns = {
-          number: [],
-          text: [],
-          date: [],
-      };
+      const columns = [];
       for (const zone of getZonesByColumns(zones)) {
           const cells = getters.getEvaluatedCellsInZone(getters.getActiveSheetId(), zone);
-          const type = detectColumnType(cells);
-          if (type !== "empty") {
-              const targetType = type === "percentage" ? "number" : type;
-              columns[targetType].push({ zone, type });
-          }
+          columns.push({ zone, type: detectColumnType(cells) });
       }
       return columns;
   }
   function getCellStats(getters, zone) {
       const cells = getters.getEvaluatedCellsInZone(getters.getActiveSheetId(), zone);
-      const uniqueValues = new Set();
-      let totalCount = 0;
-      let percentageSum = 0;
-      for (let i = 0; i < cells.length; i++) {
-          const { value } = cells[i];
-          const str = value?.toString().trim();
-          if (!str) {
-              continue;
-          }
-          uniqueValues.add(str);
-          totalCount++;
-          const num = Number(value);
-          if (!isNaN(num)) {
-              percentageSum += Math.abs(num) * 100;
-          }
-      }
+      const values = cells.map((c) => c.value?.toString().trim() || "").filter((s) => s);
       return {
-          uniqueCount: uniqueValues.size,
-          totalCount,
-          percentageSum,
+          uniqueCount: new Set(values).size,
+          totalCount: values.length,
       };
   }
   function isDatasetTitled(getters, column) {
@@ -38754,167 +38803,191 @@ stores.inject(MyMetaStore, storeInstance);
       });
       return ![CellValueType.number, CellValueType.empty].includes(titleCell.type);
   }
-  function createBaseChart(type, dataSets, options = {}) {
-      return {
-          type,
-          title: {},
-          dataSets,
-          legendPosition: "none",
-          ...options,
-      };
-  }
+  /**
+   * Builds a chart definition for a single column selection. The logic to detect the chart type is as follows:
+   * - If the column contains a single cell, create a scorecard.
+   * - If the column type is "percentage", create a pie chart.
+   * - If the column type is "text", create a pie chart
+   * - If the column type is "date", create a line chart.
+   * - Otherwise, create a bar chart.
+   */
   function buildSingleColumnChart(column, getters) {
       const { type, zone } = column;
       const sheetId = getters.getActiveSheetId();
       const dataSetsHaveTitle = isDatasetTitled(getters, column);
       const dataRange = getUnboundRange(getters, zone);
       const titleCell = getters.getEvaluatedCell({ sheetId, col: zone.left, row: zone.top });
+      if (getZoneArea(zone) === 1) {
+          return buildScorecard(zone, getters);
+      }
       switch (type) {
           case "percentage":
-              const { percentageSum } = getCellStats(getters, zone);
-              return createBaseChart("pie", [{ dataRange }], {
+              return {
+                  type: "pie",
                   title: dataSetsHaveTitle ? { text: String(titleCell.value) } : {},
+                  dataSets: [{ dataRange }],
+                  legendPosition: "none",
                   dataSetsHaveTitle,
-                  isDoughnut: percentageSum < CHART_LIMITS.PERCENTAGE_THRESHOLD,
-              });
+              };
           case "text":
               const cells = getters.getEvaluatedCellsInZone(sheetId, zone);
               const titleCount = cells.reduce((count, cell) => (cell.value === titleCell.value ? count + 1 : count), 0);
               const hasUniqueTitle = titleCell.value !== null && titleCount === 1;
-              return createBaseChart("pie", [{ dataRange }], {
+              return {
+                  type: "pie",
                   title: hasUniqueTitle ? { text: String(titleCell.value) } : {},
+                  dataSets: [{ dataRange }],
                   labelRange: dataRange,
                   dataSetsHaveTitle: hasUniqueTitle,
-                  isDoughnut: false,
                   aggregated: true,
                   legendPosition: "top",
-              });
-          // TODO: Handle date column with matrix chart when matrix chart is supported
+              };
           case "date":
-              return createBaseChart("line", [{ dataRange }], {
-                  labelRange: dataRange,
+              return {
+                  ...DEFAULT_LINE_CHART_CONFIG,
+                  type: "line",
+                  title: dataSetsHaveTitle ? { text: String(titleCell.value) } : {},
+                  dataSets: [{ dataRange }],
                   dataSetsHaveTitle,
-                  cumulative: false,
-                  labelsAsText: false,
-              });
+              };
       }
-      return createBaseChart("bar", [{ dataRange }], { dataSetsHaveTitle });
+      return {
+          ...DEFAULT_BAR_CHART_CONFIG,
+          title: dataSetsHaveTitle ? { text: String(titleCell.value) } : {},
+          dataSets: [{ dataRange }],
+          dataSetsHaveTitle,
+      };
   }
+  /**
+   * Builds a chart definition for a selection of two columns. The logic to detect the chart type always consider the
+   * columns left to right, and is as follows:
+   * - any type + percentage columns: pie chart
+   * - number + number columns: scatter chart
+   * - date + number columns: line chart
+   * - text + number columns: treemap if repetition in labels
+   * - any other combination: bar chart
+   */
   function buildTwoColumnChart(columns, getters) {
-      const { number: numberColumns, text: textColumns, date: dateColumns } = columns;
-      if (numberColumns.length === 2) {
-          return createBaseChart("scatter", [{ dataRange: getUnboundRange(getters, numberColumns[1].zone) }], {
-              labelRange: getUnboundRange(getters, numberColumns[0].zone),
-              dataSetsHaveTitle: isDatasetTitled(getters, numberColumns[1]),
-              labelsAsText: false,
-          });
+      if (columns.length !== 2) {
+          throw new Error("buildTwoColumnChart expects exactly two columns");
       }
-      // TODO: Handle date + number with matrix chart when matrix chart is supported
-      if (dateColumns.length === 1 && numberColumns.length === 1) {
-          return createBaseChart("line", [{ dataRange: getUnboundRange(getters, numberColumns[0].zone) }], {
-              labelRange: getUnboundRange(getters, dateColumns[0].zone),
-              dataSetsHaveTitle: isDatasetTitled(getters, numberColumns[0]),
-              aggregated: false,
-              cumulative: false,
+      if (columns[1].type === "percentage") {
+          return {
+              type: "pie",
+              title: {},
+              dataSets: [{ dataRange: getUnboundRange(getters, columns[1].zone) }],
+              labelRange: getUnboundRange(getters, columns[0].zone),
+              dataSetsHaveTitle: isDatasetTitled(getters, columns[1]),
+              aggregated: true,
+              legendPosition: "none",
+          };
+      }
+      if (columns[0].type === "number" && columns[1].type === "number") {
+          return {
+              type: "scatter",
+              title: {},
+              dataSets: [{ dataRange: getUnboundRange(getters, columns[1].zone) }],
+              labelRange: getUnboundRange(getters, columns[0].zone),
+              dataSetsHaveTitle: isDatasetTitled(getters, columns[1]),
               labelsAsText: false,
-          });
+              legendPosition: "none",
+          };
+      }
+      // TODO: Handle date + number with calendar chart when implemented (and change the docstring)
+      if (columns[0].type === "date" && columns[1].type === "number") {
+          return {
+              ...DEFAULT_LINE_CHART_CONFIG,
+              type: "line",
+              dataSets: [{ dataRange: getUnboundRange(getters, columns[1].zone) }],
+              labelRange: getUnboundRange(getters, columns[0].zone),
+              dataSetsHaveTitle: isDatasetTitled(getters, columns[0]),
+          };
       }
-      if (textColumns.length === 1 && numberColumns.length === 1) {
-          const [textColumn] = textColumns;
-          const [numberColumn] = numberColumns;
+      if (columns[0].type === "text" && columns[1].type === "number") {
+          const textColumn = columns[0];
+          const numberColumn = columns[1];
           const { uniqueCount, totalCount } = getCellStats(getters, textColumn.zone);
           const dataSetsHaveTitle = isDatasetTitled(getters, numberColumn);
-          const maxCategories = dataSetsHaveTitle
-              ? CHART_LIMITS.MAX_PIE_CATEGORIES
-              : CHART_LIMITS.MAX_PIE_CATEGORIES_NO_TITLE;
-          const labelRange = getUnboundRange(getters, textColumn.zone);
-          const dataRange = getUnboundRange(getters, numberColumn.zone);
-          if (uniqueCount <= maxCategories) {
-              const { percentageSum } = getCellStats(getters, numberColumn.zone);
-              return createBaseChart("pie", [{ dataRange }], {
-                  labelRange,
-                  dataSetsHaveTitle,
-                  isDoughnut: numberColumn.type === "percentage" && percentageSum < CHART_LIMITS.PERCENTAGE_THRESHOLD,
-                  aggregated: true,
-                  legendPosition: "top",
-              });
-          }
-          // Use treemap when categories repeat, as pie chart would be cluttered
           if (uniqueCount !== totalCount) {
-              return createBaseChart("treemap", [{ dataRange: labelRange }], {
-                  labelRange: dataRange,
+              return {
+                  type: "treemap",
+                  title: {},
+                  dataSets: [{ dataRange: getUnboundRange(getters, textColumn.zone) }],
+                  labelRange: getUnboundRange(getters, numberColumn.zone),
                   dataSetsHaveTitle,
-              });
+                  legendPosition: "none",
+              };
           }
-          return createBaseChart("bar", [{ dataRange }], {
-              labelRange,
-              dataSetsHaveTitle,
-          });
       }
-      const labelColumn = textColumns[0] || dateColumns[0] || numberColumns[0];
-      const dataColumn = numberColumns[0] || textColumns[0] || dateColumns[0];
-      return createBaseChart("line", [{ dataRange: getUnboundRange(getters, dataColumn.zone) }], {
-          labelRange: getUnboundRange(getters, labelColumn.zone),
-          dataSetsHaveTitle: isDatasetTitled(getters, dataColumn),
-          cumulative: false,
-          labelsAsText: true,
-      });
+      return {
+          ...DEFAULT_BAR_CHART_CONFIG,
+          dataSets: [{ dataRange: getUnboundRange(getters, columns[1].zone) }],
+          labelRange: getUnboundRange(getters, columns[0].zone),
+          dataSetsHaveTitle: isDatasetTitled(getters, columns[1]),
+      };
   }
+  /**
+   * Builds a chart definition for a selection more than two columns. The logic to detect the chart type always consider
+   * the columns left to right, and is as follows:
+   * - multiple text + single number/percentage columns: sunburst if 3+ text columns, treemap otherwise
+   * - any type + multiple percentage columns: pie chart
+   * - date + multiple number columns: line chart
+   * - any other combination: bar chart
+   */
   function buildMultiColumnChart(columns, getters) {
-      const { number: numberColumns, text: textColumns, date: dateColumns } = columns;
-      const dataSetsHaveTitle = numberColumns.some((col) => isDatasetTitled(getters, col));
-      if (textColumns.length >= 2 && numberColumns.length === 1) {
-          const sortedTextColumns = textColumns.sort((colA, colB) => getCellStats(getters, colA.zone).uniqueCount - getCellStats(getters, colB.zone).uniqueCount);
-          const dataSets = sortedTextColumns.map(({ zone }) => ({
+      if (columns.length < 3) {
+          throw new Error("buildMultiColumnChart expects at least three columns");
+      }
+      const dataSetsHaveTitle = columns.some((col) => col.type !== "text" && isDatasetTitled(getters, col));
+      const lastColumn = columns[columns.length - 1];
+      const columnsExceptLast = columns.slice(0, columns.length - 1);
+      if ((lastColumn.type === "percentage" || lastColumn.type === "number") &&
+          columnsExceptLast.every((col) => col.type === "text")) {
+          const dataSets = columnsExceptLast.map(({ zone }) => ({
               dataRange: getUnboundRange(getters, zone),
           }));
-          return createBaseChart(textColumns.length >= 3 ? "sunburst" : "treemap", dataSets, {
-              labelRange: getUnboundRange(getters, numberColumns[0].zone),
+          return {
+              type: columnsExceptLast.length >= 3 ? "sunburst" : "treemap",
+              title: {},
+              dataSets,
+              labelRange: getUnboundRange(getters, lastColumn.zone),
               dataSetsHaveTitle,
-          });
+              legendPosition: "none",
+          };
       }
-      const dataSets = recomputeZones(numberColumns.map((col) => col.zone)).map((zone) => ({
+      const firstColumn = columns[0];
+      const columnsExceptFirst = columns.slice(1);
+      const rangesOfColumnsExceptFirst = columnsExceptFirst.map(({ zone }) => ({
           dataRange: getUnboundRange(getters, zone),
       }));
-      if (dateColumns.length === 1 && numberColumns.length > 1) {
-          return createBaseChart("line", dataSets, {
-              labelRange: getUnboundRange(getters, dateColumns[0].zone),
+      if (columnsExceptFirst.every((col) => col.type === "percentage")) {
+          return {
+              type: "pie",
+              title: {},
+              dataSets: rangesOfColumnsExceptFirst,
+              labelRange: getUnboundRange(getters, firstColumn.zone),
               dataSetsHaveTitle,
-              cumulative: false,
-              labelsAsText: false,
+              aggregated: false,
               legendPosition: "top",
-          });
+          };
       }
-      if (textColumns.length === 1 && numberColumns.length >= 2) {
-          const [textColumn] = textColumns;
-          const firstCell = getters.getEvaluatedCell({
-              sheetId: getters.getActiveSheetId(),
-              row: textColumn.zone.top,
-              col: textColumn.zone.left,
-          });
-          const { uniqueCount, totalCount } = getCellStats(getters, textColumn.zone);
-          const categoryCount = dataSetsHaveTitle && firstCell.value ? uniqueCount - 1 : uniqueCount;
-          const expectedDataCount = categoryCount * numberColumns.length + (dataSetsHaveTitle ? numberColumns.length : 0);
-          const actualDataCount = numberColumns.reduce((sum, dataCol) => sum + getCellStats(getters, dataCol.zone).totalCount, 0);
-          if (uniqueCount === totalCount &&
-              uniqueCount >= CHART_LIMITS.MIN_RADAR_CATEGORIES &&
-              uniqueCount <= CHART_LIMITS.MAX_RADAR_CATEGORIES &&
-              expectedDataCount === actualDataCount) {
-              return createBaseChart("radar", dataSets, {
-                  title: dataSetsHaveTitle && firstCell.value ? { text: String(firstCell.value) } : {},
-                  labelRange: getUnboundRange(getters, textColumn.zone),
-                  dataSetsHaveTitle,
-                  legendPosition: "top",
-              });
-          }
+      if (firstColumn.type === "date" && columnsExceptFirst.every((col) => col.type === "number")) {
+          return {
+              ...DEFAULT_LINE_CHART_CONFIG,
+              type: "line",
+              dataSets: rangesOfColumnsExceptFirst,
+              labelRange: getUnboundRange(getters, firstColumn.zone),
+              dataSetsHaveTitle,
+              legendPosition: "top",
+          };
       }
-      const labelColumn = textColumns[0] || dateColumns[0] || numberColumns[0];
-      return createBaseChart("bar", dataSets, {
-          labelRange: dataSets.length ? getUnboundRange(getters, labelColumn.zone) : "",
+      return {
+          ...DEFAULT_BAR_CHART_CONFIG,
+          dataSets: rangesOfColumnsExceptFirst,
+          labelRange: getUnboundRange(getters, firstColumn.zone),
           dataSetsHaveTitle,
-          aggregated: true,
           legendPosition: "top",
-      });
+      };
   }
   function buildScorecard(zone, getters) {
       const cell = getters.getCell({
@@ -38937,22 +39010,18 @@ stores.inject(MyMetaStore, storeInstance);
    */
   function getSmartChartDefinition(zones, getters) {
       const columns = categorizeColumns(zones, getters);
-      const { number: numberColumns, text: textColumns, date: dateColumns } = columns;
-      const columnCount = numberColumns.length + textColumns.length + dateColumns.length;
-      switch (columnCount) {
-          case 0:
-              return createBaseChart("bar", [{ dataRange: getUnboundRange(getters, zones[0]) }], {
-                  dataSetsHaveTitle: false,
-              });
+      if (columns.length === 0 || columns.every((col) => col.type === "empty")) {
+          const dataSets = columns.map(({ zone }) => ({ dataRange: getUnboundRange(getters, zone) }));
+          return { ...DEFAULT_BAR_CHART_CONFIG, dataSets };
+      }
+      const nonEmptyColumns = columns.filter((col) => col.type !== "empty");
+      switch (nonEmptyColumns.length) {
           case 1:
-              const singleColumn = numberColumns[0] || textColumns[0] || dateColumns[0];
-              return getZoneArea(singleColumn.zone) === 1
-                  ? buildScorecard(singleColumn.zone, getters)
-                  : buildSingleColumnChart(singleColumn, getters);
+              return buildSingleColumnChart(nonEmptyColumns[0], getters);
           case 2:
-              return buildTwoColumnChart(columns, getters);
+              return buildTwoColumnChart(nonEmptyColumns, getters);
           default:
-              return buildMultiColumnChart(columns, getters);
+              return buildMultiColumnChart(nonEmptyColumns, getters);
       }
   }
 
@@ -39571,6 +39640,74 @@ stores.inject(MyMetaStore, storeInstance);
       return path2D;
   }
 
+  /**
+   * Get the relative path between two files
+   *
+   * Eg.:
+   * from "folder1/file1.txt" to "folder2/file2.txt" => "../folder2/file2.txt"
+   */
+  function getRelativePath(from, to) {
+      const fromPathParts = from.split("/");
+      const toPathParts = to.split("/");
+      let relPath = "";
+      let startIndex = 0;
+      for (let i = 0; i < fromPathParts.length - 1; i++) {
+          if (fromPathParts[i] === toPathParts[i]) {
+              startIndex++;
+          }
+          else {
+              relPath += "../";
+          }
+      }
+      relPath += toPathParts.slice(startIndex).join("/");
+      return relPath;
+  }
+  /**
+   * Convert an array of element into an object where the objects keys were the elements position in the array.
+   * Can give an offset as argument, and all the array indexes will we shifted by this offset in the returned object.
+   *
+   * eg. : ["a", "b"] => {0:"a", 1:"b"}
+   */
+  function arrayToObject(array, indexOffset = 0) {
+      const obj = {};
+      for (let i = 0; i < array.length; i++) {
+          if (array[i]) {
+              obj[i + indexOffset] = array[i];
+          }
+      }
+      return obj;
+  }
+  /**
+   * In xlsx we can have string with unicode characters with the format _x00fa_.
+   * Replace with characters understandable by JS
+   */
+  function fixXlsxUnicode(str) {
+      return str.replace(/_x([0-9a-zA-Z]{4})_/g, (match, code) => {
+          return String.fromCharCode(parseInt(code, 16));
+      });
+  }
+  /** Get a header in the SheetData. Create the header if it doesn't exist in the SheetData */
+  function getSheetDataHeader(sheetData, dimension, index) {
+      if (dimension === "COL") {
+          if (!sheetData.cols[index]) {
+              sheetData.cols[index] = {};
+          }
+          return sheetData.cols[index];
+      }
+      if (!sheetData.rows[index]) {
+          sheetData.rows[index] = {};
+      }
+      return sheetData.rows[index];
+  }
+  /** Prefix the string by "=" if the string looks like a formula */
+  function prefixFormulaWithEqual(formula) {
+      if (formula[0] === "=") {
+          return formula;
+      }
+      const tokens = tokenize(formula);
+      return tokens.length === 1 && tokens[0].type !== "REFERENCE" ? formula : "=" + formula;
+  }
+
   /**
    * Map of the different types of conversions warnings and their name in error messages
    */
@@ -40093,66 +40230,6 @@ stores.inject(MyMetaStore, storeInstance);
    */
   const DEFAULT_SYSTEM_COLOR = "FF000000";
 
-  /**
-   * Get the relative path between two files
-   *
-   * Eg.:
-   * from "folder1/file1.txt" to "folder2/file2.txt" => "../folder2/file2.txt"
-   */
-  function getRelativePath(from, to) {
-      const fromPathParts = from.split("/");
-      const toPathParts = to.split("/");
-      let relPath = "";
-      let startIndex = 0;
-      for (let i = 0; i < fromPathParts.length - 1; i++) {
-          if (fromPathParts[i] === toPathParts[i]) {
-              startIndex++;
-          }
-          else {
-              relPath += "../";
-          }
-      }
-      relPath += toPathParts.slice(startIndex).join("/");
-      return relPath;
-  }
-  /**
-   * Convert an array of element into an object where the objects keys were the elements position in the array.
-   * Can give an offset as argument, and all the array indexes will we shifted by this offset in the returned object.
-   *
-   * eg. : ["a", "b"] => {0:"a", 1:"b"}
-   */
-  function arrayToObject(array, indexOffset = 0) {
-      const obj = {};
-      for (let i = 0; i < array.length; i++) {
-          if (array[i]) {
-              obj[i + indexOffset] = array[i];
-          }
-      }
-      return obj;
-  }
-  /**
-   * In xlsx we can have string with unicode characters with the format _x00fa_.
-   * Replace with characters understandable by JS
-   */
-  function fixXlsxUnicode(str) {
-      return str.replace(/_x([0-9a-zA-Z]{4})_/g, (match, code) => {
-          return String.fromCharCode(parseInt(code, 16));
-      });
-  }
-  /** Get a header in the SheetData. Create the header if it doesn't exist in the SheetData */
-  function getSheetDataHeader(sheetData, dimension, index) {
-      if (dimension === "COL") {
-          if (!sheetData.cols[index]) {
-              sheetData.cols[index] = {};
-          }
-          return sheetData.cols[index];
-      }
-      if (!sheetData.rows[index]) {
-          sheetData.rows[index] = {};
-      }
-      return sheetData.rows[index];
-  }
-
   const XLSX_DATE_FORMAT_REGEX = /^(yy|yyyy|m{1,5}|d{1,4}|h{1,2}|s{1,2}|am\/pm|a\/m|\s|-|\/|\.|:)+$/i;
   /**
    * Convert excel format to o_spreadsheet format
@@ -40367,9 +40444,9 @@ stores.inject(MyMetaStore, storeInstance);
                   if (!rule.operator || !rule.formula || rule.formula.length === 0)
                       continue;
                   operator = CF_OPERATOR_TYPE_CONVERSION_MAP[rule.operator];
-                  values.push(prefixFormula(rule.formula[0]));
+                  values.push(prefixFormulaWithEqual(rule.formula[0]));
                   if (rule.formula.length === 2) {
-                      values.push(prefixFormula(rule.formula[1]));
+                      values.push(prefixFormulaWithEqual(rule.formula[1]));
                   }
                   break;
           }
@@ -40527,11 +40604,6 @@ stores.inject(MyMetaStore, storeInstance);
               ? ICON_SETS[iconSet].neutral
               : ICON_SETS[iconSet].good;
   }
-  /** Prefix the string by "=" if the string looks like a formula */
-  function prefixFormula(formula) {
-      const tokens = tokenize(formula);
-      return tokens.length === 1 && tokens[0].type !== "REFERENCE" ? formula : "=" + formula;
-  }
   // ---------------------------------------------------------------------------
   // Warnings
   // ---------------------------------------------------------------------------
@@ -41007,7 +41079,7 @@ stores.inject(MyMetaStore, storeInstance);
                   dvRules.push(decimalRule);
                   break;
               case "list":
-                  const listRule = convertListrule(dvId++, dv);
+                  const listRule = convertListRule(dvId++, dv);
                   dvRules.push(listRule);
                   break;
               case "date":
@@ -41027,9 +41099,9 @@ stores.inject(MyMetaStore, storeInstance);
       return dvRules;
   }
   function convertDecimalRule(id, dv) {
-      const values = [dv.formula1.toString()];
+      const values = [prefixFormulaWithEqual(dv.formula1.toString())];
       if (dv.formula2) {
-          values.push(dv.formula2.toString());
+          values.push(prefixFormulaWithEqual(dv.formula2.toString()));
       }
       return {
           id: id.toString(),
@@ -41041,7 +41113,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
       };
   }
-  function convertListrule(id, dv) {
+  function convertListRule(id, dv) {
       const formula1 = dv.formula1.toString();
       const isRangeRule = rangeReference.test(formula1);
       return {
@@ -41057,9 +41129,9 @@ stores.inject(MyMetaStore, storeInstance);
   }
   function convertDateRule(id, dv) {
       let criterion;
-      const values = [dv.formula1.toString()];
+      const values = [prefixFormulaWithEqual(dv.formula1.toString())];
       if (dv.formula2) {
-          values.push(dv.formula2.toString());
+          values.push(prefixFormulaWithEqual(dv.formula2.toString()));
           criterion = {
               type: XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING[dv.operator],
               values: getDateCriterionFormattedValues(values, DEFAULT_LOCALE),
@@ -41086,7 +41158,7 @@ stores.inject(MyMetaStore, storeInstance);
           isBlocking: dv.errorStyle !== "warning",
           criterion: {
               type: "customFormula",
-              values: [`=${dv.formula1.toString()}`],
+              values: [prefixFormulaWithEqual(dv.formula1.toString())],
           },
       };
   }
@@ -43990,6 +44062,7 @@ stores.inject(MyMetaStore, storeInstance);
           return data;
       }
       const figureIds = new Set();
+      const chartIds = new Set();
       const uuidGenerator = new UuidGenerator();
       for (const sheet of data.sheets || []) {
           for (const figure of sheet.figures || []) {
@@ -43997,6 +44070,12 @@ stores.inject(MyMetaStore, storeInstance);
                   figure.id += uuidGenerator.smallUuid();
               }
               figureIds.add(figure.id);
+              if (figure.tag === "chart") {
+                  if (chartIds.has(figure.data?.chartId)) {
+                      figure.data.chartId += uuidGenerator.smallUuid();
+                  }
+                  chartIds.add(figure.data?.chartId);
+              }
           }
       }
       data.uniqueFigureIds = true;
@@ -49750,39 +49829,63 @@ stores.inject(MyMetaStore, storeInstance);
           this.model.dispatch("AUTOFILL_TABLE_COLUMN", { ...this.currentEditedCell });
           this.setContent("");
       }
-      getComposerContent(position) {
+      getComposerContent(position, selection) {
           const locale = this.getters.getLocale();
           const cell = this.getters.getCell(position);
           if (cell?.isFormula) {
               const prettifiedContent = this.getPrettifiedFormula(cell);
-              return localizeFormula(prettifiedContent, locale);
+              // when a formula is prettified (multi lines, indented), adapt the cursor position
+              // to take into account line breaks and tabs
+              function adjustCursorIndex(targetIndex) {
+                  let adjustedIndex = 0;
+                  let originalIndex = 0;
+                  while (originalIndex < targetIndex) {
+                      adjustedIndex++;
+                      const char = prettifiedContent[adjustedIndex];
+                      if (char !== "\n" && char !== "\t") {
+                          originalIndex++;
+                      }
+                  }
+                  return adjustedIndex;
+              }
+              let adjustedSelection = selection;
+              if (selection) {
+                  adjustedSelection = {
+                      start: adjustCursorIndex(selection.start),
+                      end: adjustCursorIndex(selection.end),
+                  };
+              }
+              return {
+                  text: localizeFormula(prettifiedContent, locale),
+                  adjustedSelection,
+              };
           }
           const spreader = this.model.getters.getArrayFormulaSpreadingOn(position);
           if (spreader) {
-              return "";
+              return { text: "" };
           }
           const { format, value, type, formattedValue } = this.getters.getEvaluatedCell(position);
           switch (type) {
               case CellValueType.empty:
-                  return "";
+                  return { text: "" };
               case CellValueType.text:
               case CellValueType.error:
-                  return value;
+                  return { text: value };
               case CellValueType.boolean:
-                  return formattedValue;
+                  return { text: formattedValue };
               case CellValueType.number:
                   if (format && isDateTimeFormat(format)) {
                       if (parseDateTime(formattedValue, locale) !== null) {
                           // formatted string can be parsed again
-                          return formattedValue;
+                          return { text: formattedValue };
                       }
                       // display a simplified and parsable string otherwise
                       const timeFormat = Number.isInteger(value)
                           ? locale.dateFormat
                           : getDateTimeFormat(locale);
-                      return formatValue(value, { locale, format: timeFormat });
+                      return { text: formatValue(value, { locale, format: timeFormat }) };
                   }
-                  return this.numberComposerContent(value, format, locale);
+                  return { text: this.numberComposerContent(value, format, locale) };
           }
       }
       getPrettifiedFormula(cell) {
@@ -49951,8 +50054,9 @@ stores.inject(MyMetaStore, storeInstance);
               },
               focus: this.focus,
               isDefaultFocus: true,
-              onComposerContentFocused: () => this.composerFocusStore.focusComposer(this.composerInterface, {
+              onComposerContentFocused: (selection) => this.composerFocusStore.focusComposer(this.composerInterface, {
                   focusMode: "contentFocus",
+                  selection,
               }),
               onComposerCellFocused: (content) => this.composerFocusStore.focusComposer(this.composerInterface, {
                   focusMode: "cellFocus",
@@ -57358,12 +57462,13 @@ stores.inject(MyMetaStore, storeInstance);
           onCloseSidePanel: { type: Function, optional: true },
       };
       state = owl.useState({ rule: this.defaultDataValidationRule, errors: [] });
+      editingSheetId;
       setup() {
+          this.editingSheetId = this.env.model.getters.getActiveSheetId();
           if (this.props.rule) {
-              const sheetId = this.env.model.getters.getActiveSheetId();
               this.state.rule = {
                   ...this.props.rule,
-                  ranges: this.props.rule.ranges.map((range) => this.env.model.getters.getRangeString(range, sheetId)),
+                  ranges: this.props.rule.ranges.map((range) => this.env.model.getters.getRangeString(range, this.editingSheetId)),
               };
               this.state.rule.criterion.type = this.props.rule.criterion.type;
           }
@@ -57397,7 +57502,6 @@ stores.inject(MyMetaStore, storeInstance);
           const locale = this.env.model.getters.getLocale();
           const criterion = rule.criterion;
           const criterionEvaluator = criterionEvaluatorRegistry.get(criterion.type);
-          const sheetId = this.env.model.getters.getActiveSheetId();
           const values = criterion.values
               .slice(0, criterionEvaluator.numberOfValues(criterion))
               .map((value) => value?.trim())
@@ -57405,8 +57509,8 @@ stores.inject(MyMetaStore, storeInstance);
               .map((value) => canonicalizeContent(value, locale));
           rule.criterion = { ...criterion, values };
           return {
-              sheetId,
-              ranges: this.state.rule.ranges.map((xc) => this.env.model.getters.getRangeDataFromXc(sheetId, xc)),
+              sheetId: this.editingSheetId,
+              ranges: this.state.rule.ranges.map((xc) => this.env.model.getters.getRangeDataFromXc(this.editingSheetId, xc)),
               rule,
           };
       }
@@ -57933,6 +58037,7 @@ stores.inject(MyMetaStore, storeInstance);
       .o-button {
         height: 19px;
         width: 19px;
+        box-sizing: content-box;
         .o-icon {
           height: 14px;
           width: 14px;
@@ -68706,6 +68811,281 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class ZoneSet {
+      profilesStartingPosition = [0];
+      profiles = new Map([[0, []]]);
+      constructor(zones = []) {
+          for (const zone of zones) {
+              this.add(zone);
+          }
+      }
+      isEmpty() {
+          return this.profiles.size === 1 && this.profiles.get(0)?.length === 0;
+      }
+      add(zone) {
+          modifyProfiles(this.profilesStartingPosition, this.profiles, [zone]);
+      }
+      delete(zone) {
+          modifyProfiles(this.profilesStartingPosition, this.profiles, [zone], true);
+      }
+      has(zone) {
+          return profilesContainsZone(this.profilesStartingPosition, this.profiles, zone);
+      }
+      difference(other) {
+          const result = this.copy();
+          for (const zone of other) {
+              result.delete(zone);
+          }
+          return result;
+      }
+      copy() {
+          const result = new ZoneSet();
+          result.profilesStartingPosition = [...this.profilesStartingPosition];
+          result.profiles = new Map();
+          for (const [key, value] of this.profiles) {
+              result.profiles.set(key, [...value]);
+          }
+          return result;
+      }
+      size() {
+          let size = 0;
+          for (const profile of this.profiles.values()) {
+              size += profile.length;
+          }
+          return size / 2;
+      }
+      /**
+       * iterator of all the zones in the ZoneSet
+       */
+      [Symbol.iterator]() {
+          return constructZonesFromProfiles(this.profilesStartingPosition, this.profiles)[Symbol.iterator]();
+      }
+  }
+
+  class RangeSet {
+      setsBySheetId = {};
+      constructor(ranges = []) {
+          for (const range of ranges) {
+              this.add(range);
+          }
+      }
+      add(range) {
+          if (!this.setsBySheetId[range.sheetId]) {
+              this.setsBySheetId[range.sheetId] = new ZoneSet();
+          }
+          this.setsBySheetId[range.sheetId].add(range.zone);
+      }
+      addMany(ranges) {
+          for (const range of ranges) {
+              this.add(range);
+          }
+      }
+      addPosition(position) {
+          this.add(positionToBoundedRange(position));
+      }
+      addManyPositions(positions) {
+          for (const position of positions) {
+              this.addPosition(position);
+          }
+      }
+      has(range) {
+          if (!this.setsBySheetId[range.sheetId]) {
+              return false;
+          }
+          return this.setsBySheetId[range.sheetId].has(range.zone);
+      }
+      hasPosition(position) {
+          return this.has(positionToBoundedRange(position));
+      }
+      delete(range) {
+          if (!this.setsBySheetId[range.sheetId]) {
+              return;
+          }
+          this.setsBySheetId[range.sheetId].delete(range.zone);
+      }
+      deleteMany(ranges) {
+          for (const range of ranges) {
+              this.delete(range);
+          }
+      }
+      deleteManyPositions(positions) {
+          for (const position of positions) {
+              this.delete(positionToBoundedRange(position));
+          }
+      }
+      difference(other) {
+          const result = new RangeSet();
+          for (const sheetId in this.setsBySheetId) {
+              result.setsBySheetId[sheetId] = this.setsBySheetId[sheetId];
+          }
+          for (const sheetId in other.setsBySheetId) {
+              if (result.setsBySheetId[sheetId]) {
+                  result.setsBySheetId[sheetId] = result.setsBySheetId[sheetId].difference(other.setsBySheetId[sheetId]);
+              }
+          }
+          return result;
+      }
+      copy() {
+          const result = new RangeSet();
+          for (const sheetId in this.setsBySheetId) {
+              result.setsBySheetId[sheetId] = this.setsBySheetId[sheetId].copy();
+          }
+          return result;
+      }
+      clear() {
+          this.setsBySheetId = {};
+      }
+      size() {
+          let size = 0;
+          for (const sheetId in this.setsBySheetId) {
+              size += this.setsBySheetId[sheetId].size();
+          }
+          return size;
+      }
+      isEmpty() {
+          for (const sheetId in this.setsBySheetId) {
+              if (!this.setsBySheetId[sheetId].isEmpty()) {
+                  return false;
+              }
+          }
+          return true;
+      }
+      /**
+       * iterator of all the ranges in the RangeSet
+       */
+      [Symbol.iterator]() {
+          const result = [];
+          for (const sheetId in this.setsBySheetId) {
+              for (const zone of this.setsBySheetId[sheetId]) {
+                  result.push({ sheetId: sheetId, zone });
+              }
+          }
+          return result[Symbol.iterator]();
+      }
+  }
+
+  /**
+   * R-Tree of ranges, mapping zones (r-tree bounding boxes) to ranges (data of the r-tree item).
+   * Ranges associated to the exact same bounding box are grouped together
+   * to reduce the number of nodes in the R-tree.
+   */
+  class DependenciesRTree {
+      rTree;
+      constructor(items = []) {
+          const compactedBoxes = groupSameBoundingBoxes(items);
+          this.rTree = new SpreadsheetRTree(compactedBoxes);
+      }
+      insert(item) {
+          const data = this.rTree.search(item.boundingBox);
+          const itemBoundingBox = item.boundingBox;
+          const exactBoundingBox = data.find(({ boundingBox }) => boundingBox.sheetId === itemBoundingBox.sheetId &&
+              boundingBox.zone.left === itemBoundingBox.zone.left &&
+              boundingBox.zone.top === itemBoundingBox.zone.top &&
+              boundingBox.zone.right === itemBoundingBox.zone.right &&
+              boundingBox.zone.bottom === itemBoundingBox.zone.bottom);
+          if (exactBoundingBox) {
+              exactBoundingBox.data.add(item.data);
+          }
+          else {
+              this.rTree.insert({ ...item, data: new RangeSet([item.data]) });
+          }
+      }
+      search({ zone, sheetId }) {
+          const results = new RangeSet();
+          for (const { data } of this.rTree.search({ zone, sheetId })) {
+              results.addMany(data);
+          }
+          return results;
+      }
+      remove(item) {
+          const data = this.rTree.search(item.boundingBox);
+          const itemBoundingBox = item.boundingBox;
+          const exactBoundingBox = data.find(({ boundingBox }) => boundingBox.sheetId === itemBoundingBox.sheetId &&
+              boundingBox.zone.left === itemBoundingBox.zone.left &&
+              boundingBox.zone.top === itemBoundingBox.zone.top &&
+              boundingBox.zone.right === itemBoundingBox.zone.right &&
+              boundingBox.zone.bottom === itemBoundingBox.zone.bottom);
+          if (exactBoundingBox) {
+              exactBoundingBox.data.delete(item.data);
+          }
+          else {
+              this.rTree.remove({ ...item, data: new RangeSet([item.data]) });
+          }
+      }
+  }
+  /**
+   * Group together all formulas pointing to the exact same dependency (bounding box).
+   * The goal is to optimize the following case:
+   * - if any cell in B1:B1000 changes, C1 must be recomputed
+   * - if any cell in B1:B1000 changes, C2 must be recomputed
+   * - if any cell in B1:B1000 changes, C3 must be recomputed
+   * ...
+   * - if any cell in B1:B1000 changes, C1000 must be recomputed
+   *
+   * Instead of having 1000 entries in the R-tree, we want to have a single entry
+   * with B1:B1000 (bounding box) pointing to C1:C1000 (formulas).
+   */
+  function groupSameBoundingBoxes(items) {
+      // Important: this function must be as fast as possible. It is on the evaluation hot path.
+      let maxCol = 0;
+      let maxRow = 0;
+      for (let i = 0; i < items.length; i++) {
+          const zone = items[i].boundingBox.zone;
+          if (zone.right > maxCol) {
+              maxCol = zone.right;
+          }
+          if (zone.bottom > maxRow) {
+              maxRow = zone.bottom;
+          }
+      }
+      maxCol += 1;
+      maxRow += 1;
+      // in most real-world cases, we can use a fast numeric key
+      // but if the zones are too far right or bottom, we fallback to a slower string key
+      const maxPossibleKey = (((maxRow + 1) * maxCol + 1) * maxRow + 1) * maxCol;
+      const useFastKey = maxPossibleKey <= Number.MAX_SAFE_INTEGER;
+      if (!useFastKey) {
+          console.warn("Max col/row size exceeded, using slow zone key");
+      }
+      const groupedByBBox = {};
+      for (const item of items) {
+          const sheetId = item.boundingBox.sheetId;
+          if (!groupedByBBox[sheetId]) {
+              groupedByBBox[sheetId] = {};
+          }
+          const bBox = item.boundingBox.zone;
+          let bBoxKey = 0;
+          if (useFastKey) {
+              bBoxKey =
+                  bBox.left +
+                      bBox.top * maxCol +
+                      bBox.right * maxCol * maxRow +
+                      bBox.bottom * maxCol * maxRow * maxCol;
+          }
+          else {
+              bBoxKey = `${bBox.left},${bBox.top},${bBox.right},${bBox.bottom}`;
+          }
+          if (groupedByBBox[sheetId][bBoxKey]) {
+              const ranges = groupedByBBox[sheetId][bBoxKey].data;
+              ranges.add(item.data);
+          }
+          else {
+              groupedByBBox[sheetId][bBoxKey] = {
+                  boundingBox: item.boundingBox,
+                  data: new RangeSet([item.data]),
+              };
+          }
+      }
+      const result = [];
+      for (const sheetId in groupedByBBox) {
+          const map = groupedByBBox[sheetId];
+          for (const key in map) {
+              result.push(map[key]);
+          }
+      }
+      return result;
+  }
+
   /**
    * Implementation of a dependency Graph.
    * The graph is used to evaluate the cells in the correct
@@ -68714,12 +69094,10 @@ stores.inject(MyMetaStore, storeInstance);
    * It uses an R-Tree data structure to efficiently find dependent cells.
    */
   class FormulaDependencyGraph {
-      createEmptyPositionSet;
       dependencies = new PositionMap();
       rTree;
-      constructor(createEmptyPositionSet, data = []) {
-          this.createEmptyPositionSet = createEmptyPositionSet;
-          this.rTree = new SpreadsheetRTree(data);
+      constructor(data = []) {
+          this.rTree = new DependenciesRTree(data);
       }
       removeAllDependencies(formulaPosition) {
           const ranges = this.dependencies.get(formulaPosition);
@@ -68733,7 +69111,10 @@ stores.inject(MyMetaStore, storeInstance);
       }
       addDependencies(formulaPosition, dependencies) {
           const rTreeItems = dependencies.map(({ sheetId, zone }) => ({
-              data: formulaPosition,
+              data: {
+                  sheetId: formulaPosition.sheetId,
+                  zone: positionToZone(formulaPosition),
+              },
               boundingBox: {
                   zone,
                   sheetId,
@@ -68751,46 +69132,20 @@ stores.inject(MyMetaStore, storeInstance);
           }
       }
       /**
-       * Return all the cells that depend on the provided ranges,
-       * in the correct order they should be evaluated.
-       * This is called a topological ordering (excluding cycles)
+       * Return all the cells that depend on the provided ranges.
        */
-      getCellsDependingOn(ranges) {
-          const visited = this.createEmptyPositionSet();
+      getCellsDependingOn(ranges, visited = new RangeSet()) {
+          visited = visited.copy();
           const queue = Array.from(ranges).reverse();
           while (queue.length > 0) {
               const range = queue.pop();
-              const zone = range.zone;
-              const sheetId = range.sheetId;
-              for (let col = zone.left; col <= zone.right; col++) {
-                  for (let row = zone.top; row <= zone.bottom; row++) {
-                      visited.add({ sheetId, col, row });
-                  }
-              }
-              const impactedPositions = this.rTree.search(range).map((dep) => dep.data);
-              const nextInQueue = {};
-              for (const position of impactedPositions) {
-                  if (!visited.has(position)) {
-                      if (!nextInQueue[position.sheetId]) {
-                          nextInQueue[position.sheetId] = [];
-                      }
-                      nextInQueue[position.sheetId].push(positionToZone(position));
-                  }
-              }
-              for (const sheetId in nextInQueue) {
-                  const zones = recomputeZones(nextInQueue[sheetId], []);
-                  queue.push(...zones.map((zone) => ({ sheetId, zone })));
-              }
+              visited.add(range);
+              const impactedRanges = this.rTree.search(range);
+              queue.push(...impactedRanges.difference(visited));
           }
           // remove initial ranges
           for (const range of ranges) {
-              const zone = range.zone;
-              const sheetId = range.sheetId;
-              for (let col = zone.left; col <= zone.right; col++) {
-                  for (let row = zone.top; row <= zone.bottom; row++) {
-                      visited.delete({ sheetId, col, row });
-                  }
-              }
+              visited.delete(range);
           }
           return visited;
       }
@@ -69053,7 +69408,7 @@ stores.inject(MyMetaStore, storeInstance);
       getters;
       compilationParams;
       evaluatedCells = new PositionMap();
-      formulaDependencies = lazy(new FormulaDependencyGraph(this.createEmptyPositionSet.bind(this)));
+      formulaDependencies = lazy(new FormulaDependencyGraph());
       blockedArrayFormulas = new PositionSet({});
       spreadingRelations = new SpreadingRelation();
       constructor(context, getters) {
@@ -69088,7 +69443,7 @@ stores.inject(MyMetaStore, storeInstance);
               return undefined;
           }
           const arrayFormulas = this.spreadingRelations.searchFormulaPositionsSpreadingOn(position.sheetId, positionToZone(position));
-          return Array.from(arrayFormulas).find((position) => !this.blockedArrayFormulas.has(position));
+          return arrayFormulas.find((position) => !this.blockedArrayFormulas.has(position));
       }
       updateDependencies(position) {
           // removing dependencies is slow because it requires
@@ -69132,57 +69487,72 @@ stores.inject(MyMetaStore, storeInstance);
       }
       evaluateCells(positions) {
           const start = performance.now();
-          const cellsToCompute = this.createEmptyPositionSet();
-          cellsToCompute.addMany(positions);
+          const rangesToCompute = new RangeSet();
+          rangesToCompute.addManyPositions(positions);
           const arrayFormulasPositions = this.getArrayFormulasImpactedByChangesOf(positions);
-          cellsToCompute.addMany(this.getCellsDependingOn(positions));
-          cellsToCompute.addMany(arrayFormulasPositions);
-          cellsToCompute.addMany(this.getCellsDependingOn(arrayFormulasPositions));
-          this.evaluate(cellsToCompute);
+          rangesToCompute.addMany(this.getCellsDependingOn(rangesToCompute));
+          rangesToCompute.addMany(arrayFormulasPositions);
+          rangesToCompute.addMany(this.getCellsDependingOn(arrayFormulasPositions));
+          this.evaluate(rangesToCompute);
           console.debug("evaluate Cells", performance.now() - start, "ms");
       }
       getArrayFormulasImpactedByChangesOf(positions) {
-          const impactedPositions = this.createEmptyPositionSet();
+          const impactedRanges = new RangeSet();
           for (const position of positions) {
               const content = this.getters.getCell(position)?.content;
               const arrayFormulaPosition = this.getArrayFormulaSpreadingOn(position);
               if (arrayFormulaPosition !== undefined) {
                   // take into account new collisions.
-                  impactedPositions.add(arrayFormulaPosition);
+                  impactedRanges.addPosition(arrayFormulaPosition);
               }
               if (!content) {
                   // The previous content could have blocked some array formulas
-                  impactedPositions.add(position);
+                  impactedRanges.addPosition(position);
               }
           }
-          const zonesBySheetIds = aggregatePositionsToZones(impactedPositions);
-          for (const sheetId in zonesBySheetIds) {
-              for (const zone of zonesBySheetIds[sheetId]) {
-                  impactedPositions.addMany(this.getArrayFormulasBlockedBy(sheetId, zone));
-              }
+          for (const range of [...impactedRanges]) {
+              impactedRanges.addMany(this.getArrayFormulasBlockedBy(range.sheetId, range.zone));
           }
-          return impactedPositions;
+          return impactedRanges;
       }
       buildDependencyGraph() {
           this.blockedArrayFormulas = this.createEmptyPositionSet();
           this.spreadingRelations = new SpreadingRelation();
           this.formulaDependencies = lazy(() => {
-              const dependencies = [...this.getAllCells()].flatMap((position) => this.getDirectDependencies(position)
-                  .filter((range) => !range.invalidSheetName && !range.invalidXc)
-                  .map((range) => ({
-                  data: position,
-                  boundingBox: {
-                      zone: range.zone,
-                      sheetId: range.sheetId,
-                  },
-              })));
-              return new FormulaDependencyGraph(this.createEmptyPositionSet.bind(this), dependencies);
+              const rTreeItems = [];
+              for (const sheetId of this.getters.getSheetIds()) {
+                  const cells = this.getters.getCells(sheetId);
+                  for (const cellId in cells) {
+                      const cell = cells[cellId];
+                      if (cell.isFormula) {
+                          const directDependencies = cell.compiledFormula.dependencies;
+                          for (const range of directDependencies) {
+                              if (range.invalidSheetName || range.invalidXc) {
+                                  continue;
+                              }
+                              rTreeItems.push({
+                                  data: {
+                                      sheetId,
+                                      zone: positionToZone(this.getters.getCellPosition(cellId)),
+                                  },
+                                  boundingBox: { sheetId: range.sheetId, zone: range.zone },
+                              });
+                          }
+                      }
+                  }
+              }
+              return new FormulaDependencyGraph(rTreeItems);
           });
       }
       evaluateAllCells() {
           const start = performance.now();
           this.evaluatedCells = new PositionMap();
-          this.evaluate(this.getAllCells());
+          const ranges = [];
+          for (const sheetId of this.getters.getSheetIds()) {
+              const zone = this.getters.getSheetZone(sheetId);
+              ranges.push({ sheetId, zone });
+          }
+          this.evaluate(ranges);
           console.debug("evaluate all cells", performance.now() - start, "ms");
       }
       evaluateFormulaResult(sheetId, formulaString) {
@@ -69206,48 +69576,47 @@ stores.inject(MyMetaStore, storeInstance);
               return handleError(error, "");
           }
       }
-      getAllCells() {
-          const positions = this.createEmptyPositionSet();
-          positions.fillAllPositions();
-          return positions;
-      }
       /**
        * Return the position of formulas blocked by the given positions
        * as well as all their dependencies.
        */
       getArrayFormulasBlockedBy(sheetId, zone) {
-          const arrayFormulaPositions = this.createEmptyPositionSet();
+          const arrayFormulaPositions = new RangeSet();
           const arrayFormulas = this.spreadingRelations.searchFormulaPositionsSpreadingOn(sheetId, zone);
-          arrayFormulaPositions.addMany(arrayFormulas);
+          arrayFormulaPositions.addManyPositions(arrayFormulas);
           const spilledPositions = [...arrayFormulas].filter((position) => !this.blockedArrayFormulas.has(position));
           if (spilledPositions.length) {
               // ignore the formula spreading on the position. Keep only the blocked ones
-              arrayFormulaPositions.deleteMany(spilledPositions);
+              arrayFormulaPositions.deleteManyPositions(spilledPositions);
           }
           arrayFormulaPositions.addMany(this.getCellsDependingOn(arrayFormulaPositions));
           return arrayFormulaPositions;
       }
-      nextPositionsToUpdate = new PositionSet({});
+      nextRangesToUpdate = new RangeSet();
       cellsBeingComputed = new Set();
       symbolsBeingComputed = new Set();
-      evaluate(positions) {
+      evaluate(ranges) {
           this.cellsBeingComputed = new Set();
-          this.nextPositionsToUpdate = positions;
+          this.nextRangesToUpdate = new RangeSet(ranges);
           let currentIteration = 0;
-          while (!this.nextPositionsToUpdate.isEmpty() && currentIteration++ < MAX_ITERATION) {
+          while (!this.nextRangesToUpdate.isEmpty() && currentIteration++ < MAX_ITERATION) {
               this.updateCompilationParameters();
-              const positions = this.nextPositionsToUpdate.clear();
-              for (let i = 0; i < positions.length; ++i) {
-                  this.evaluatedCells.delete(positions[i]);
-              }
-              for (let i = 0; i < positions.length; ++i) {
-                  const position = positions[i];
-                  if (this.nextPositionsToUpdate.has(position)) {
-                      continue;
-                  }
-                  const evaluatedCell = this.computeCell(position);
-                  if (evaluatedCell !== EMPTY_CELL) {
-                      this.evaluatedCells.set(position, evaluatedCell);
+              const ranges = [...this.nextRangesToUpdate];
+              this.nextRangesToUpdate.clear();
+              this.clearEvaluatedRanges(ranges);
+              for (const range of ranges) {
+                  const { left, bottom, right, top } = range.zone;
+                  for (let col = left; col <= right; col++) {
+                      for (let row = top; row <= bottom; row++) {
+                          const position = { sheetId: range.sheetId, col, row };
+                          if (this.nextRangesToUpdate.hasPosition(position)) {
+                              continue;
+                          }
+                          const evaluatedCell = this.computeCell(position);
+                          if (evaluatedCell !== EMPTY_CELL) {
+                              this.evaluatedCells.set(position, evaluatedCell);
+                          }
+                      }
                   }
               }
               onIterationEndEvaluationRegistry.getAll().forEach((callback) => callback(this.getters));
@@ -69256,6 +69625,16 @@ stores.inject(MyMetaStore, storeInstance);
               console.warn("Maximum iteration reached while evaluating cells");
           }
       }
+      clearEvaluatedRanges(ranges) {
+          for (const range of ranges) {
+              const { left, bottom, right, top } = range.zone;
+              for (let col = left; col <= right; col++) {
+                  for (let row = top; row <= bottom; row++) {
+                      this.evaluatedCells.delete({ sheetId: range.sheetId, col, row });
+                  }
+              }
+          }
+      }
       computeCell(position) {
           const evaluation = this.evaluatedCells.get(position);
           if (evaluation) {
@@ -69328,9 +69707,9 @@ stores.inject(MyMetaStore, storeInstance);
       }
       invalidatePositionsDependingOnSpread(sheetId, resultZone) {
           // the result matrix is split in 2 zones to exclude the array formula position
-          const invalidatedPositions = this.formulaDependencies().getCellsDependingOn(excludeTopLeft(resultZone).map((zone) => ({ sheetId, zone })));
-          invalidatedPositions.delete({ sheetId, col: resultZone.left, row: resultZone.top });
-          this.nextPositionsToUpdate.addMany(invalidatedPositions);
+          const invalidatedPositions = this.getCellsDependingOn(excludeTopLeft(resultZone).map((zone) => ({ sheetId, zone })));
+          invalidatedPositions.delete({ sheetId, zone: resultZone });
+          this.nextRangesToUpdate.addMany(invalidatedPositions);
       }
       assertSheetHasEnoughSpaceToSpreadFormulaResult({ sheetId, col, row }, matrixResult) {
           const numberOfCols = this.getters.getNumberCols(sheetId);
@@ -69405,7 +69784,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const sheetId = position.sheetId;
           this.invalidatePositionsDependingOnSpread(sheetId, zone);
-          this.nextPositionsToUpdate.addMany(this.getArrayFormulasBlockedBy(sheetId, zone));
+          this.nextRangesToUpdate.addMany(this.getArrayFormulasBlockedBy(sheetId, zone));
       }
       /**
        * Wraps a GetSymbolValue function to add cycle detection
@@ -69440,13 +69819,8 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return cell.compiledFormula.dependencies;
       }
-      getCellsDependingOn(positions) {
-          const ranges = [];
-          const zonesBySheetIds = aggregatePositionsToZones(positions);
-          for (const sheetId in zonesBySheetIds) {
-              ranges.push(...zonesBySheetIds[sheetId].map((zone) => ({ sheetId, zone })));
-          }
-          return this.formulaDependencies().getCellsDependingOn(ranges);
+      getCellsDependingOn(ranges) {
+          return this.formulaDependencies().getCellsDependingOn(ranges, this.nextRangesToUpdate);
       }
   }
   function forEachSpreadPositionInMatrix(nbColumns, nbRows, callback) {
@@ -70957,7 +71331,8 @@ stores.inject(MyMetaStore, storeInstance);
           const topLeft = { col: unionZone.left, row: unionZone.top, sheetId };
           const parentSpreadingCell = this.getters.getArrayFormulaSpreadingOn(topLeft);
           if (!parentSpreadingCell) {
-              return false;
+              const evaluatedCell = this.getters.getEvaluatedCell(topLeft);
+              return (evaluatedCell.value === CellErrorType.SpilledBlocked && !evaluatedCell.errorOriginPosition);
           }
           else if (deepEquals(parentSpreadingCell, topLeft) && getZoneArea(unionZone) === 1) {
               return true;
@@ -82129,6 +82504,7 @@ stores.inject(MyMetaStore, storeInstance);
       static components = { Menu };
       rootItems = topbarMenuRegistry.getMenuItems();
       menuRef = owl.useRef("menu");
+      containerRef = owl.useRef("container");
       state = owl.useState({
           menuItems: this.rootItems,
           title: _t("Menu Bar"),
@@ -82136,6 +82512,7 @@ stores.inject(MyMetaStore, storeInstance);
       });
       setup() {
           owl.useExternalListener(window, "click", this.onExternalClick, { capture: true });
+          owl.onMounted(this.updateShadows);
       }
       onExternalClick(ev) {
           if (!this.menuRef.el?.contains(ev.target)) {
@@ -82148,6 +82525,7 @@ stores.inject(MyMetaStore, storeInstance);
               this.state.parentState = { ...this.state };
               this.state.menuItems = children;
               this.state.title = menu.name(this.env);
+              this.containerRef.el?.scrollTo({ top: 0 });
           }
           else {
               this.state.menuItems = this.rootItems;
@@ -82169,6 +82547,19 @@ stores.inject(MyMetaStore, storeInstance);
               height: `${this.props.height}px`,
           });
       }
+      updateShadows() {
+          if (!this.containerRef.el) {
+              return;
+          }
+          this.containerRef.el.classList.remove("scroll-top", "scroll-bottom");
+          const maxScroll = this.containerRef.el.scrollHeight - this.containerRef.el.clientHeight || 0;
+          if (this.containerRef.el.scrollTop < maxScroll - 1) {
+              this.containerRef.el.classList.add("scroll-bottom");
+          }
+          if (this.containerRef.el.scrollTop > 0) {
+              this.containerRef.el.classList.add("scroll-top");
+          }
+      }
       onClickBack() {
           if (!this.state.parentState) {
               this.props.onClose();
@@ -82177,6 +82568,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.state.menuItems = this.state.parentState.menuItems;
           this.state.title = this.state.parentState.title;
           this.state.parentState = this.state.parentState.parentState;
+          this.containerRef.el?.scrollTo({ top: 0 });
       }
       get backTitle() {
           return this.state.parentState ? _t("Go to previous menu") : _t("Close menu bar");
@@ -82233,7 +82625,9 @@ stores.inject(MyMetaStore, storeInstance);
               : "inactive";
       }
       get showFxIcon() {
-          return this.focus === "inactive" && !this.composerStore.currentContent;
+          return (this.focus === "inactive" &&
+              !this.composerStore.currentContent &&
+              !this.composerStore.placeholder);
       }
       get rect() {
           return this.composerRef.el
@@ -82250,8 +82644,9 @@ stores.inject(MyMetaStore, storeInstance);
               },
               focus: this.focus,
               composerStore: this.composerStore,
-              onComposerContentFocused: () => this.composerFocusStore.focusComposer(this.composerInterface, {
+              onComposerContentFocused: (selection) => this.composerFocusStore.focusComposer(this.composerInterface, {
                   focusMode: "contentFocus",
+                  selection,
               }),
               isDefaultFocus: false,
               inputStyle: cssPropertiesToCss({
@@ -82259,6 +82654,7 @@ stores.inject(MyMetaStore, storeInstance);
                   "max-height": `130px`,
               }),
               showAssistant: !isIOS(), // Hide assistant on iOS as it breaks visually
+              placeholder: this.composerStore.placeholder,
           };
       }
       get symbols() {
@@ -82321,7 +82717,9 @@ stores.inject(MyMetaStore, storeInstance);
               : "inactive";
       }
       get showFxIcon() {
-          return this.focus === "inactive" && !this.composerStore.currentContent;
+          return (this.focus === "inactive" &&
+              !this.composerStore.currentContent &&
+              !this.composerStore.placeholder);
       }
       get composerStyle() {
           const style = {
@@ -88537,9 +88935,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "19.0.5";
-  __info__.date = "2025-10-07T10:04:06.400Z";
-  __info__.hash = "86fc442";
+  __info__.version = "19.0.7";
+  __info__.date = "2025-10-23T08:19:01.764Z";
+  __info__.hash = "1c1d1ec";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);