@odoo/o-spreadsheet 19.0.5 → 19.0.7

package/dist/o-spreadsheet.cjs.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
  */
 
 'use strict';
@@ -1893,6 +1893,29 @@ profilesStartingPosition, profiles, zones, toRemove = false) {
         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
@@ -1977,7 +2000,18 @@ function modifyProfile(profile, zone, toRemove = false) {
     }
     // 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;
@@ -2016,8 +2050,10 @@ function constructZonesFromProfiles(profilesStartingPosition, profiles) {
                 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];
@@ -2502,17 +2538,6 @@ function excludeTopLeft(zone) {
     }
     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.
  */
@@ -4515,7 +4540,17 @@ function toNumberMatrix(data, argName) {
     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;
         });
@@ -6934,6 +6969,10 @@ function getRangeParts(xc, zone) {
     }
     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.
@@ -9530,7 +9569,7 @@ class CellClipboardHandler extends AbstractCellClipboardHandler {
     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,
@@ -13903,7 +13942,7 @@ const GROWTH = {
         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)));
     },
 };
 // -----------------------------------------------------------------------------
@@ -13976,7 +14015,7 @@ const LINEST = {
         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,
 };
@@ -13995,7 +14034,7 @@ const LOGEST = {
         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]);
         }
@@ -14616,7 +14655,7 @@ const TREND = {
         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));
     },
 };
 // -----------------------------------------------------------------------------
@@ -23137,6 +23176,10 @@ const chartShowValuesPlugin = {
         }
         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
@@ -24180,7 +24223,7 @@ class ChartJsComponent extends owl.Component {
         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 {
@@ -24188,6 +24231,17 @@ class ChartJsComponent extends owl.Component {
             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;
     }
@@ -25611,6 +25665,7 @@ function getChartTimeOptions(labels, labelFormat, locale) {
         parser: luxonFormat,
         displayFormats,
         unit: timeUnit ?? false,
+        tooltipFormat: luxonFormat,
     };
 }
 /**
@@ -26679,6 +26734,7 @@ function getLineChartScales(definition, args) {
         };
         Object.assign(scales.x, axis);
         scales.x.ticks.maxTicksLimit = 15;
+        delete scales?.x?.ticks?.callback;
     }
     else if (axisType === "linear") {
         scales.x.type = "linear";
@@ -32364,7 +32420,7 @@ class ChartDashboardMenu extends owl.Component {
     }
     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);
     }
@@ -32396,6 +32452,7 @@ class CarouselFigure extends owl.Component {
         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");
@@ -32529,6 +32586,12 @@ class CarouselFigure extends owl.Component {
     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 {
@@ -32538,6 +32601,7 @@ class ChartFigure extends owl.Component {
         onFigureDeleted: Function,
         editFigureStyle: { type: Function, optional: true },
         isFullScreen: { type: Boolean, optional: true },
+        openContextMenu: { type: Function, optional: true },
     };
     static components = { ChartDashboardMenu };
     onDoubleClick() {
@@ -32570,6 +32634,7 @@ class ImageFigure extends owl.Component {
         figureUI: Object,
         onFigureDeleted: Function,
         editFigureStyle: { type: Function, optional: true },
+        openContextMenu: { type: Function, optional: true },
     };
     static components = {};
     // ---------------------------------------------------------------------------
@@ -34621,8 +34686,11 @@ class Composer extends owl.Component {
         }
         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() {
@@ -35117,13 +35185,6 @@ class AbstractComposerStore extends SpreadsheetStore {
         }
     }
     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 });
@@ -35180,7 +35241,7 @@ class AbstractComposerStore extends SpreadsheetStore {
     // ---------------------------------------------------------------------------
     get currentContent() {
         if (this.editionMode === "inactive") {
-            return this.getComposerContent(this.getters.getActivePosition());
+            return this.getComposerContent(this.getters.getActivePosition()).text;
         }
         return this._currentContent;
     }
@@ -35379,8 +35440,9 @@ class AbstractComposerStore extends SpreadsheetStore {
         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);
@@ -35857,7 +35919,7 @@ class StandaloneComposerStore extends AbstractComposerStore {
     constructor(get, args) {
         super(get);
         this.args = args;
-        this._currentContent = this.getComposerContent();
+        this._currentContent = this.getComposerContent().text;
     }
     getAutoCompleteProviders() {
         const providersDefinitions = super.getAutoCompleteProviders();
@@ -35894,7 +35956,7 @@ class StandaloneComposerStore extends AbstractComposerStore {
             })
                 .join("");
         }
-        return localizeContent(content, this.getters.getLocale());
+        return { text: localizeContent(content, this.getters.getLocale()) };
     }
     stopEdition() {
         this._stopEdition();
@@ -38664,12 +38726,23 @@ cellPopoverRegistry
     .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));
@@ -38708,43 +38781,19 @@ function detectColumnType(cells) {
     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) {
@@ -38755,167 +38804,191 @@ function isDatasetTitled(getters, column) {
     });
     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({
@@ -38938,22 +39011,18 @@ function buildScorecard(zone, getters) {
  */
 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);
     }
 }
 
@@ -39572,6 +39641,74 @@ function getPath2D(svgPath) {
     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
  */
@@ -40094,66 +40231,6 @@ function hexaToInt(hex) {
  */
 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
@@ -40368,9 +40445,9 @@ function convertConditionalFormats(xlsxCfs, dxfs, warningManager) {
                 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;
         }
@@ -40528,11 +40605,6 @@ function convertIcons(xlsxIconSet, index) {
             ? 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
 // ---------------------------------------------------------------------------
@@ -41008,7 +41080,7 @@ function convertDataValidationRules(xlsxDataValidations, warningManager) {
                 dvRules.push(decimalRule);
                 break;
             case "list":
-                const listRule = convertListrule(dvId++, dv);
+                const listRule = convertListRule(dvId++, dv);
                 dvRules.push(listRule);
                 break;
             case "date":
@@ -41028,9 +41100,9 @@ function convertDataValidationRules(xlsxDataValidations, warningManager) {
     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(),
@@ -41042,7 +41114,7 @@ function convertDecimalRule(id, dv) {
         },
     };
 }
-function convertListrule(id, dv) {
+function convertListRule(id, dv) {
     const formula1 = dv.formula1.toString();
     const isRangeRule = rangeReference.test(formula1);
     return {
@@ -41058,9 +41130,9 @@ function convertListrule(id, dv) {
 }
 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),
@@ -41087,7 +41159,7 @@ function convertCustomRule(id, dv) {
         isBlocking: dv.errorStyle !== "warning",
         criterion: {
             type: "customFormula",
-            values: [`=${dv.formula1.toString()}`],
+            values: [prefixFormulaWithEqual(dv.formula1.toString())],
         },
     };
 }
@@ -43991,6 +44063,7 @@ function forceUnicityOfFigure(data) {
         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 || []) {
@@ -43998,6 +44071,12 @@ function forceUnicityOfFigure(data) {
                 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;
@@ -49751,39 +49830,63 @@ class CellComposerStore extends AbstractComposerStore {
         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) {
@@ -49952,8 +50055,9 @@ class GridComposer extends owl.Component {
             },
             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",
@@ -57359,12 +57463,13 @@ class DataValidationEditor extends owl.Component {
         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;
         }
@@ -57398,7 +57503,6 @@ class DataValidationEditor extends owl.Component {
         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())
@@ -57406,8 +57510,8 @@ class DataValidationEditor extends owl.Component {
             .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,
         };
     }
@@ -57934,6 +58038,7 @@ css /* scss */ `
       .o-button {
         height: 19px;
         width: 19px;
+        box-sizing: content-box;
         .o-icon {
           height: 14px;
           width: 14px;
@@ -68707,6 +68812,281 @@ class ZoneRBush extends RBush {
     }
 }
 
+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
@@ -68715,12 +69095,10 @@ class ZoneRBush extends RBush {
  * 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);
@@ -68734,7 +69112,10 @@ class FormulaDependencyGraph {
     }
     addDependencies(formulaPosition, dependencies) {
         const rTreeItems = dependencies.map(({ sheetId, zone }) => ({
-            data: formulaPosition,
+            data: {
+                sheetId: formulaPosition.sheetId,
+                zone: positionToZone(formulaPosition),
+            },
             boundingBox: {
                 zone,
                 sheetId,
@@ -68752,46 +69133,20 @@ class FormulaDependencyGraph {
         }
     }
     /**
-     * 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;
     }
@@ -69054,7 +69409,7 @@ class Evaluator {
     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) {
@@ -69089,7 +69444,7 @@ class Evaluator {
             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
@@ -69133,57 +69488,72 @@ class Evaluator {
     }
     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) {
@@ -69207,48 +69577,47 @@ class Evaluator {
             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));
@@ -69257,6 +69626,16 @@ class Evaluator {
             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) {
@@ -69329,9 +69708,9 @@ class Evaluator {
     }
     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);
@@ -69406,7 +69785,7 @@ class Evaluator {
         }
         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
@@ -69441,13 +69820,8 @@ class Evaluator {
         }
         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) {
@@ -70958,7 +71332,8 @@ class DynamicTablesPlugin extends CoreViewPlugin {
         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;
@@ -82130,6 +82505,7 @@ class RibbonMenu extends owl.Component {
     static components = { Menu };
     rootItems = topbarMenuRegistry.getMenuItems();
     menuRef = owl.useRef("menu");
+    containerRef = owl.useRef("container");
     state = owl.useState({
         menuItems: this.rootItems,
         title: _t("Menu Bar"),
@@ -82137,6 +82513,7 @@ class RibbonMenu extends owl.Component {
     });
     setup() {
         owl.useExternalListener(window, "click", this.onExternalClick, { capture: true });
+        owl.onMounted(this.updateShadows);
     }
     onExternalClick(ev) {
         if (!this.menuRef.el?.contains(ev.target)) {
@@ -82149,6 +82526,7 @@ class RibbonMenu extends owl.Component {
             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;
@@ -82170,6 +82548,19 @@ class RibbonMenu extends owl.Component {
             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();
@@ -82178,6 +82569,7 @@ class RibbonMenu extends owl.Component {
         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");
@@ -82234,7 +82626,9 @@ class SmallBottomBar extends owl.Component {
             : "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
@@ -82251,8 +82645,9 @@ class SmallBottomBar extends owl.Component {
             },
             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({
@@ -82260,6 +82655,7 @@ class SmallBottomBar extends owl.Component {
                 "max-height": `130px`,
             }),
             showAssistant: !isIOS(), // Hide assistant on iOS as it breaks visually
+            placeholder: this.composerStore.placeholder,
         };
     }
     get symbols() {
@@ -82322,7 +82718,9 @@ class TopBarComposer extends owl.Component {
             : "inactive";
     }
     get showFxIcon() {
-        return this.focus === "inactive" && !this.composerStore.currentContent;
+        return (this.focus === "inactive" &&
+            !this.composerStore.currentContent &&
+            !this.composerStore.placeholder);
     }
     get composerStyle() {
         const style = {
@@ -88538,6 +88936,6 @@ exports.tokenColors = tokenColors;
 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";