@odoo/o-spreadsheet 19.1.0-alpha.7 → 19.1.0-alpha.9

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.1.0-alpha.7
- * @date 2025-10-17T11:09:35.690Z
- * @hash a11279d
+ * @version 19.1.0-alpha.9
+ * @date 2025-10-23T11:12:55.400Z
+ * @hash bd756dd
  */
 
 (function (exports, owl) {
@@ -488,8 +488,17 @@
     /**
      * Returns a function, that, as long as it continues to be invoked, will not
      * be triggered. The function will be called after it stops being called for
-     * N milliseconds. If `immediate` is passed, trigger the function on the
-     * leading edge, instead of the trailing.
+     * N milliseconds. If `immediate` is passed,  the function is called is called
+     * immediately on the first call and the debouncing is triggered starting the second
+     * call in the defined time window.
+     *
+     * Example:
+     * debouncedFunction = debounce(() => console.log('Hello!'), 250);
+     * debouncedFunction(); debouncedFunction(); // Will log 'Hello!' after 250ms
+     *
+     * debouncedFunction = debounce(() => console.log('Hello!'), 250, true);
+     * debouncedFunction(); debouncedFunction(); // Will log 'Hello!' and relog it after 250ms
+     *
      *
      * Also decorate the argument function with two methods: stopDebounce and isDebouncePending.
      *
@@ -497,21 +506,21 @@
      */
     function debounce(func, wait, immediate) {
         let timeout = undefined;
+        let firstCalled = false;
         const debounced = function () {
             const context = this;
             const args = Array.from(arguments);
+            if (!firstCalled && immediate) {
+                firstCalled = true;
+                return func.apply(context, args);
+            }
             function later() {
                 timeout = undefined;
-                if (!immediate) {
-                    func.apply(context, args);
-                }
+                firstCalled = false;
+                func.apply(context, args);
             }
-            const callNow = immediate && !timeout;
             clearTimeout(timeout);
             timeout = setTimeout(later, wait);
-            if (callNow) {
-                func.apply(context, args);
-            }
         };
         debounced.isDebouncePending = () => timeout !== undefined;
         debounced.stopDebounce = () => {
@@ -1154,6 +1163,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
@@ -1238,7 +1270,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;
@@ -1277,8 +1320,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];
@@ -1763,17 +1808,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.
      */
@@ -14882,6 +14916,13 @@
         .add("minute_number", nullHandlerDecorator(minuteNumberAdapter))
         .add("second_number", nullHandlerDecorator(secondNumberAdapter));
 
+    const DEFAULT_PIVOT_STYLE = {
+        displayTotals: true,
+        displayColumnHeaders: true,
+        displayMeasuresRow: true,
+        numberOfRows: Number.MAX_VALUE,
+        numberOfColumns: Number.MAX_VALUE,
+    };
     const AGGREGATOR_NAMES = {
         count: _t$1("Count"),
         count_distinct: _t$1("Count Distinct"),
@@ -15215,6 +15256,25 @@
             pivot: { ...definition, collapsedDomains: newDomains },
         });
     }
+    function getPivotStyleFromFnArgs(definition, rowCountArg, includeTotalArg, includeColumnHeadersArg, columnCountArg, includeMeasuresRowArg, locale) {
+        const style = definition.style;
+        const numberOfRows = rowCountArg !== undefined
+            ? toNumber(rowCountArg, locale)
+            : style?.numberOfRows ?? DEFAULT_PIVOT_STYLE.numberOfRows;
+        const numberOfColumns = columnCountArg !== undefined
+            ? toNumber(columnCountArg, locale)
+            : style?.numberOfColumns ?? DEFAULT_PIVOT_STYLE.numberOfColumns;
+        const displayTotals = includeTotalArg !== undefined
+            ? toBoolean(includeTotalArg)
+            : style?.displayTotals ?? DEFAULT_PIVOT_STYLE.displayTotals;
+        const displayColumnHeaders = includeColumnHeadersArg !== undefined
+            ? toBoolean(includeColumnHeadersArg)
+            : style?.displayColumnHeaders ?? DEFAULT_PIVOT_STYLE.displayColumnHeaders;
+        const displayMeasuresRow = includeMeasuresRowArg !== undefined
+            ? toBoolean(includeMeasuresRowArg)
+            : style?.displayMeasuresRow ?? DEFAULT_PIVOT_STYLE.displayMeasuresRow;
+        return { numberOfRows, numberOfColumns, displayTotals, displayColumnHeaders, displayMeasuresRow };
+    }
 
     /**
      * Get the pivot ID from the formula pivot ID.
@@ -15829,24 +15889,18 @@
             arg("column_count (number, optional)", _t$1("number of columns")),
             arg("include_measure_titles (boolean, default=TRUE)", _t$1("Whether to include the measure titles row or not.")),
         ],
-        compute: function (pivotFormulaId, rowCount = { value: 10000 }, includeTotal = { value: true }, includeColumnHeaders = { value: true }, columnCount = { value: Number.MAX_VALUE }, includeMeasureTitles = { value: true }) {
+        compute: function (pivotFormulaId, rowCount, includeTotal, includeColumnHeaders, columnCount, includeMeasureTitles) {
             const _pivotFormulaId = toString(pivotFormulaId);
-            const _rowCount = toNumber(rowCount, this.locale);
-            if (_rowCount < 0) {
+            const pivotId = getPivotId(_pivotFormulaId, this.getters);
+            const pivot = this.getters.getPivot(pivotId);
+            const coreDefinition = this.getters.getPivotCoreDefinition(pivotId);
+            const pivotStyle = getPivotStyleFromFnArgs(coreDefinition, rowCount, includeTotal, includeColumnHeaders, columnCount, includeMeasureTitles, this.locale);
+            if (pivotStyle.numberOfRows < 0) {
                 return new EvaluationError(_t$1("The number of rows must be positive."));
             }
-            const _columnCount = toNumber(columnCount, this.locale);
-            if (_columnCount < 0) {
+            if (pivotStyle.numberOfColumns < 0) {
                 return new EvaluationError(_t$1("The number of columns must be positive."));
             }
-            const visibilityOptions = {
-                displayColumnHeaders: toBoolean(includeColumnHeaders),
-                displayTotals: toBoolean(includeTotal),
-                displayMeasuresRow: toBoolean(includeMeasureTitles),
-            };
-            const pivotId = getPivotId(_pivotFormulaId, this.getters);
-            const pivot = this.getters.getPivot(pivotId);
-            const coreDefinition = this.getters.getPivotCoreDefinition(pivotId);
             addPivotDependencies(this, coreDefinition, coreDefinition.measures);
             pivot.init({ reload: pivot.needsReevaluation });
             const error = pivot.assertIsValid({ throwOnError: false });
@@ -15857,20 +15911,20 @@
             if (table.numberOfCells > PIVOT_MAX_NUMBER_OF_CELLS) {
                 return new EvaluationError(getPivotTooBigErrorMessage$1(table.numberOfCells, this.locale));
             }
-            const cells = table.getPivotCells(visibilityOptions);
+            const cells = table.getPivotCells(pivotStyle);
             let headerRows = 0;
-            if (visibilityOptions.displayColumnHeaders) {
+            if (pivotStyle.displayColumnHeaders) {
                 headerRows = table.columns.length - 1;
             }
-            if (visibilityOptions.displayMeasuresRow) {
+            if (pivotStyle.displayMeasuresRow) {
                 headerRows++;
             }
             const pivotTitle = this.getters.getPivotName(pivotId);
-            const tableHeight = Math.min(headerRows + _rowCount, cells[0].length);
+            const tableHeight = Math.min(headerRows + pivotStyle.numberOfRows, cells[0].length);
             if (tableHeight === 0) {
                 return [[{ value: pivotTitle }]];
             }
-            const tableWidth = Math.min(1 + _columnCount, cells.length);
+            const tableWidth = Math.min(1 + pivotStyle.numberOfColumns, cells.length);
             const result = [];
             for (const col of range$1(0, tableWidth)) {
                 result[col] = [];
@@ -15893,7 +15947,7 @@
                     }
                 }
             }
-            if (visibilityOptions.displayColumnHeaders || visibilityOptions.displayMeasuresRow) {
+            if (pivotStyle.displayColumnHeaders || pivotStyle.displayMeasuresRow) {
                 result[0][0] = { value: pivotTitle };
             }
             return result;
@@ -19495,6 +19549,10 @@ stores.inject(MyMetaStore, storeInstance);
         }
         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.
@@ -21361,6 +21419,9 @@ stores.inject(MyMetaStore, storeInstance);
                 backgroundColor,
                 yAxisID: definition.horizontal ? "y" : definition.dataSets?.[index].yAxisId || "y",
                 xAxisID: "x",
+                barPercentage: 0.9,
+                categoryPercentage: dataSetsValues.length > 1 ? 0.8 : 1,
+                borderRadius: 2,
             };
             dataSets.push(dataset);
             const trendConfig = definition.dataSets?.[index].trend;
@@ -21489,6 +21550,7 @@ stores.inject(MyMetaStore, storeInstance);
         const dataSets = [];
         const colors = getChartColorsGenerator(definition, dataSetsValues.length);
         const trendDatasets = [];
+        const barDatasets = dataSetsValues.filter((_, i) => (definition.dataSets?.[i].type ?? "line") === "bar");
         for (let index = 0; index < dataSetsValues.length; index++) {
             let { label, data, hidden } = dataSetsValues[index];
             label = definition.dataSets?.[index].label || label;
@@ -21507,6 +21569,11 @@ stores.inject(MyMetaStore, storeInstance);
                 order: type === "bar" ? dataSetsValues.length + index : index,
                 pointRadius: definition.hideDataMarkers ? 0 : LINE_DATA_POINT_RADIUS,
             };
+            if (dataset.type === "bar") {
+                dataset.barPercentage = 0.9;
+                dataset.categoryPercentage = barDatasets.length > 1 ? 0.8 : 1;
+                dataset.borderRadius = 2;
+            }
             dataSets.push(dataset);
             const trendConfig = definition.dataSets?.[index].trend;
             const trendData = args.trendDataSetsValues?.[index];
@@ -33489,6 +33556,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 || []) {
@@ -33496,6 +33564,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;
@@ -33863,11 +33937,6 @@ stores.inject(MyMetaStore, storeInstance);
          * @param sheetName couple of old and new sheet names to adapt ranges pointing to that sheet
          */
         adaptRanges(applyChange, sheetId, sheetName) { }
-        /**
-         * Implement this method to clean unused external resources, such as images
-         * stored on a server which have been deleted.
-         */
-        garbageCollectExternalResources() { }
     }
 
     class BordersPlugin extends CorePlugin {
@@ -37711,17 +37780,6 @@ stores.inject(MyMetaStore, storeInstance);
                     break;
             }
         }
-        /**
-         * Delete unused images from the file store
-         */
-        garbageCollectExternalResources() {
-            const images = new Set(this.getAllImages().map((image) => image.path));
-            for (const path of this.syncedImages) {
-                if (!images.has(path)) {
-                    this.fileStore?.delete(path);
-                }
-            }
-        }
         // ---------------------------------------------------------------------------
         // Getters
         // ---------------------------------------------------------------------------
@@ -37783,13 +37841,6 @@ stores.inject(MyMetaStore, storeInstance);
                 sheet.images = [...sheet.images, ...images];
             }
         }
-        getAllImages() {
-            const images = [];
-            for (const sheetId in this.images) {
-                images.push(...Object.values(this.images[sheetId] || {}).filter(isDefined$1));
-            }
-            return images;
-        }
     }
 
     class MergePlugin extends CorePlugin {
@@ -38562,26 +38613,22 @@ stores.inject(MyMetaStore, storeInstance);
         getNumberOfDataColumns() {
             return this.columns.at(-1)?.length || 0;
         }
-        getSkippedRows(visibilityOptions) {
+        getSkippedRows(pivotStyle) {
             const skippedRows = new Set();
-            if (!visibilityOptions.displayColumnHeaders) {
+            if (!pivotStyle.displayColumnHeaders) {
                 for (let i = 0; i < this.columns.length - 1; i++) {
                     skippedRows.add(i);
                 }
             }
-            if (!visibilityOptions.displayMeasuresRow) {
+            if (!pivotStyle.displayMeasuresRow) {
                 skippedRows.add(this.columns.length - 1);
             }
             return skippedRows;
         }
-        getPivotCells(visibilityOptions = {
-            displayColumnHeaders: true,
-            displayTotals: true,
-            displayMeasuresRow: true,
-        }) {
-            const key = JSON.stringify(visibilityOptions);
+        getPivotCells(pivotStyle = DEFAULT_PIVOT_STYLE) {
+            const key = JSON.stringify(pivotStyle);
             if (!this.pivotCells[key]) {
-                const { displayTotals } = visibilityOptions;
+                const { displayTotals } = pivotStyle;
                 const numberOfDataRows = this.rows.length;
                 const numberOfDataColumns = this.getNumberOfDataColumns();
                 let pivotHeight = this.columns.length + numberOfDataRows;
@@ -38593,7 +38640,7 @@ stores.inject(MyMetaStore, storeInstance);
                     pivotWidth -= this.measures.length;
                 }
                 const domainArray = [];
-                const skippedRows = this.getSkippedRows(visibilityOptions);
+                const skippedRows = this.getSkippedRows(pivotStyle);
                 for (let col = 0; col < pivotWidth; col++) {
                     domainArray.push([]);
                     for (let row = 0; row < pivotHeight; row++) {
@@ -41685,6 +41732,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
@@ -41693,12 +42015,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);
@@ -41712,7 +42032,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,
@@ -41730,46 +42053,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, ignore) {
-            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) && !ignore.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;
         }
@@ -42046,7 +42343,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) {
@@ -42081,7 +42378,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
@@ -42125,57 +42422,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) {
@@ -42199,48 +42511,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));
@@ -42249,6 +42560,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) {
@@ -42321,9 +42642,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 })), this.nextPositionsToUpdate);
-            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);
@@ -42398,7 +42719,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
@@ -42433,13 +42754,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, this.nextPositionsToUpdate);
+        getCellsDependingOn(ranges) {
+            return this.formulaDependencies().getCellsDependingOn(ranges, this.nextRangesToUpdate);
         }
     }
     function forEachSpreadPositionInMatrix(nbColumns, nbRows, callback) {
@@ -46106,18 +46422,8 @@ stores.inject(MyMetaStore, storeInstance);
                 return EMPTY_PIVOT_CELL;
             }
             if (functionName === "PIVOT") {
-                const includeTotal = toScalar(args[2]);
-                const shouldIncludeTotal = includeTotal === undefined ? true : toBoolean(includeTotal);
-                const includeColumnHeaders = toScalar(args[3]);
-                const includeMeasures = toScalar(args[5]);
-                const shouldIncludeMeasures = includeMeasures === undefined ? true : toBoolean(includeMeasures);
-                const shouldIncludeColumnHeaders = includeColumnHeaders === undefined ? true : toBoolean(includeColumnHeaders);
-                const visibilityOptions = {
-                    displayColumnHeaders: shouldIncludeColumnHeaders,
-                    displayTotals: shouldIncludeTotal,
-                    displayMeasuresRow: shouldIncludeMeasures,
-                };
-                const pivotCells = pivot.getCollapsedTableStructure().getPivotCells(visibilityOptions);
+                const pivotStyle = getPivotStyleFromFnArgs(this.getters.getPivotCoreDefinition(pivotId), toScalar(args[1]), toScalar(args[2]), toScalar(args[3]), toScalar(args[4]), toScalar(args[5]), this.getters.getLocale());
+                const pivotCells = pivot.getCollapsedTableStructure().getPivotCells(pivotStyle);
                 const pivotCol = position.col - mainPosition.col;
                 const pivotRow = position.row - mainPosition.row;
                 return pivotCells[pivotCol][pivotRow];
@@ -55832,7 +56138,6 @@ stores.inject(MyMetaStore, storeInstance);
                 const startSnapshot = performance.now();
                 console.debug("Snapshot requested");
                 this.session.snapshot(this.exportData());
-                this.garbageCollectExternalResources();
                 console.debug("Snapshot taken in", performance.now() - startSnapshot, "ms");
             }
             console.debug("Model created in", performance.now() - start, "ms");
@@ -56218,11 +56523,6 @@ stores.inject(MyMetaStore, storeInstance);
             data = deepCopy$1(data);
             return getXLSX(data);
         }
-        garbageCollectExternalResources() {
-            for (const plugin of this.corePlugins) {
-                plugin.garbageCollectExternalResources();
-            }
-        }
     }
     function createCommand(type, payload = {}) {
         const command = deepCopy$1(payload);
@@ -65613,12 +65913,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));
@@ -65657,43 +65968,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) {
@@ -65704,167 +65991,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",
+            };
         }
-        if (textColumns.length === 1 && numberColumns.length === 1) {
-            const [textColumn] = textColumns;
-            const [numberColumn] = numberColumns;
+        // 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 (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({
@@ -65887,22 +66198,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);
         }
     }
 
@@ -66435,23 +66742,11 @@ stores.inject(MyMetaStore, storeInstance);
     //------------------------------------------------------------------------------
     // Image
     //------------------------------------------------------------------------------
-    async function requestImage(env) {
-        try {
-            return await env.imageProvider.requestImage();
-        }
-        catch {
-            env.raiseError(_t$1("An unexpected error occurred during the image transfer"));
-            return;
-        }
-    }
     const CREATE_IMAGE = async (env) => {
         if (env.imageProvider) {
             const sheetId = env.model.getters.getActiveSheetId();
             const figureId = env.model.uuidGenerator.smallUuid();
-            const image = await requestImage(env);
-            if (!image) {
-                return;
-            }
+            const image = await env.imageProvider.requestImage();
             const size = getMaxFigureSize(env.model.getters, image.size);
             const { col, row, offset } = centerFigurePosition(env.model.getters, size);
             env.model.dispatch("CREATE_IMAGE", {
@@ -72839,39 +73134,38 @@ stores.inject(MyMetaStore, storeInstance);
         }, () => [ref.el]);
     }
 
-    class TextInput extends owl.Component {
-        static template = "o-spreadsheet-TextInput";
+    class GenericInput extends owl.Component {
         static props = {
-            value: String,
+            value: [Number, String],
             onChange: Function,
-            class: {
-                type: String,
-                optional: true,
-            },
-            id: {
-                type: String,
-                optional: true,
-            },
-            placeholder: {
-                type: String,
-                optional: true,
-            },
-            autofocus: {
-                type: Boolean,
-                optional: true,
-            },
+            class: { type: String, optional: true },
+            id: { type: String, optional: true },
+            placeholder: { type: String, optional: true },
+            autofocus: { type: Boolean, optional: true },
             alwaysShowBorder: { type: Boolean, optional: true },
+            selectContentOnFocus: { type: Boolean, optional: true },
         };
-        inputRef = owl.useRef("input");
+        refName = "input";
+        inputRef;
         setup() {
+            this.inputRef = owl.useRef(this.refName);
             owl.useExternalListener(window, "click", (ev) => {
                 if (ev.target !== this.inputRef.el && this.inputRef.el?.value !== this.props.value) {
                     this.save();
                 }
             }, { capture: true });
             if (this.props.autofocus) {
-                useAutofocus({ refName: "input" });
+                useAutofocus({ refName: this.refName });
             }
+            owl.onWillUpdateProps((nextProps) => {
+                if (document.activeElement !== this.inputRef.el && this.inputRef.el) {
+                    this.inputRef.el.value = nextProps.value;
+                }
+            });
+            owl.onMounted(() => {
+                if (this.inputRef.el)
+                    this.inputRef.el.value = this.props.value.toString();
+            });
         }
         onKeyDown(ev) {
             switch (ev.key) {
@@ -72882,7 +73176,7 @@ stores.inject(MyMetaStore, storeInstance);
                     break;
                 case "Escape":
                     if (this.inputRef.el) {
-                        this.inputRef.el.value = this.props.value;
+                        this.inputRef.el.value = this.props.value.toString();
                         this.inputRef.el.blur();
                     }
                     ev.preventDefault();
@@ -72890,12 +73184,14 @@ stores.inject(MyMetaStore, storeInstance);
                     break;
             }
         }
-        save() {
+        save(keepFocus = false) {
             const currentValue = (this.inputRef.el?.value || "").trim();
-            if (currentValue !== this.props.value) {
+            if (currentValue !== this.props.value.toString()) {
                 this.props.onChange(currentValue);
             }
-            this.inputRef.el?.blur();
+            if (!keepFocus) {
+                this.inputRef.el?.blur();
+            }
         }
         onMouseDown(ev) {
             // Stop the event if the input is not focused, we handle everything in onMouseUp
@@ -72908,13 +73204,25 @@ stores.inject(MyMetaStore, storeInstance);
             const target = ev.target;
             if (target !== document.activeElement) {
                 target.focus();
-                target.select();
+                if (this.props.selectContentOnFocus) {
+                    target.select();
+                }
                 ev.preventDefault();
                 ev.stopPropagation();
             }
         }
+    }
+
+    class TextInput extends GenericInput {
+        static template = "o-spreadsheet-TextInput";
+        static components = {};
+        static props = GenericInput.props;
         get inputClass() {
-            return [this.props.class, this.props.alwaysShowBorder ? "o-input-border" : undefined]
+            return [
+                this.props.class,
+                "w-100 os-input",
+                this.props.alwaysShowBorder ? "o-input-border" : undefined,
+            ]
                 .filter(isDefined$1)
                 .join(" ");
         }
@@ -73024,6 +73332,16 @@ stores.inject(MyMetaStore, storeInstance);
         fontSizeListRef = owl.useRef("fontSizeList");
         setup() {
             owl.useExternalListener(window, "click", this.onExternalClick, { capture: true });
+            owl.onWillUpdateProps((nextProps) => {
+                if (this.inputRef.el && document.activeElement !== this.inputRef.el) {
+                    this.inputRef.el.value = nextProps.currentFontSize;
+                }
+            });
+            owl.onMounted(() => {
+                if (this.inputRef.el) {
+                    this.inputRef.el.value = this.props.currentFontSize.toString();
+                }
+            });
         }
         get popoverProps() {
             const { x, y, width, height } = this.rootEditorRef.el.getBoundingClientRect();
@@ -73917,7 +74235,7 @@ stores.inject(MyMetaStore, storeInstance);
 
     class ChartTitle extends owl.Component {
         static template = "o-spreadsheet.ChartTitle";
-        static components = { Section, TextStyler };
+        static components = { Section, TextStyler, TextInput };
         static props = {
             title: { type: String, optional: true },
             placeholder: { type: String, optional: true },
@@ -73931,8 +74249,8 @@ stores.inject(MyMetaStore, storeInstance);
             title: "",
             placeholder: "",
         };
-        updateTitle(ev) {
-            this.props.updateTitle(ev.target.value);
+        updateTitle(value) {
+            this.props.updateTitle(value);
         }
     }
 
@@ -74076,6 +74394,27 @@ stores.inject(MyMetaStore, storeInstance);
         }
     }
 
+    class NumberInput extends GenericInput {
+        static template = "o-spreadsheet-NumberInput";
+        static components = {};
+        static props = {
+            ...GenericInput.props,
+            min: { type: Number, optional: true },
+            max: { type: Number, optional: true },
+        };
+        // Very short debounce to prevent up/down arrow on number input to spam the onChange
+        debouncedOnChange = debounce(this.props.onChange.bind(this), 100, true);
+        save() {
+            const currentValue = (this.inputRef.el?.value || "").trim();
+            if (currentValue !== this.props.value.toString()) {
+                this.debouncedOnChange(currentValue);
+            }
+        }
+        get inputClass() {
+            return [this.props.class, "o-input"].join(" ");
+        }
+    }
+
     class SeriesDesignEditor extends owl.Component {
         static template = "o-spreadsheet-SeriesDesignEditor";
         static components = {
@@ -74147,6 +74486,7 @@ stores.inject(MyMetaStore, storeInstance);
             RadioSelection,
             Section,
             RoundColorPicker,
+            NumberInput,
         };
         static props = {
             chartId: String,
@@ -74238,9 +74578,8 @@ stores.inject(MyMetaStore, storeInstance);
         get defaultWindowSize() {
             return DEFAULT_WINDOW_SIZE;
         }
-        onChangeMovingAverageWindow(index, ev) {
-            const element = ev.target;
-            let window = parseInt(element.value) || DEFAULT_WINDOW_SIZE;
+        onChangeMovingAverageWindow(index, value) {
+            let window = parseInt(value) || DEFAULT_WINDOW_SIZE;
             if (window <= 1) {
                 window = DEFAULT_WINDOW_SIZE;
             }
@@ -74769,10 +75108,8 @@ stores.inject(MyMetaStore, storeInstance);
 
     class PieHoleSize extends owl.Component {
         static template = "o-spreadsheet.PieHoleSize";
-        static components = { Section };
+        static components = { Section, NumberInput };
         static props = { onValueChange: Function, value: Number };
-        // Very short debounce to prevent up/down arrow on number input to spam the onChange
-        debouncedOnChange = debounce(this.onChange.bind(this), 100);
         onChange(value) {
             if (!isNaN(Number(value))) {
                 this.props.onValueChange(clip(Number(value), 0, 95));
@@ -78050,16 +78387,18 @@ stores.inject(MyMetaStore, storeInstance);
 
     class PivotSidePanelStore extends SpreadsheetStore {
         pivotId;
+        updateMode;
         mutators = ["reset", "deferUpdates", "applyUpdate", "discardPendingUpdate", "update"];
-        updatesAreDeferred;
+        _updatesAreDeferred;
         draft = null;
         notification = this.get(NotificationStore);
         alreadyNotified = false;
         alreadyNotifiedForPivotSize = false;
-        constructor(get, pivotId) {
+        constructor(get, pivotId, updateMode = "canDefer") {
             super(get);
             this.pivotId = pivotId;
-            this.updatesAreDeferred =
+            this.updateMode = updateMode;
+            this._updatesAreDeferred =
                 this.getters.getPivotCoreDefinition(this.pivotId).deferUpdates ?? false;
         }
         handle(cmd) {
@@ -78070,6 +78409,9 @@ stores.inject(MyMetaStore, storeInstance);
                     }
             }
         }
+        get updatesAreDeferred() {
+            return this.updateMode === "neverDefer" ? false : this._updatesAreDeferred;
+        }
         get fields() {
             return this.pivot.getFields();
         }
@@ -78144,7 +78486,7 @@ stores.inject(MyMetaStore, storeInstance);
         }
         reset(pivotId) {
             this.pivotId = pivotId;
-            this.updatesAreDeferred = true;
+            this._updatesAreDeferred = true;
             this.draft = null;
         }
         deferUpdates(shouldDefer) {
@@ -78155,7 +78497,7 @@ stores.inject(MyMetaStore, storeInstance);
             else {
                 this.update({ deferUpdates: shouldDefer });
             }
-            this.updatesAreDeferred = shouldDefer;
+            this._updatesAreDeferred = shouldDefer;
         }
         applyUpdate() {
             if (this.draft) {
@@ -78409,6 +78751,26 @@ stores.inject(MyMetaStore, storeInstance);
         editor: PivotSpreadsheetSidePanel,
     });
 
+    class PivotDesignPanel extends owl.Component {
+        static template = "o-spreadsheet-PivotDesignPanel";
+        static props = { pivotId: String };
+        static components = { Section, Checkbox };
+        store;
+        setup() {
+            this.store = useLocalStore(PivotSidePanelStore, this.props.pivotId, "neverDefer");
+        }
+        updatePivotStyleProperty(key, value) {
+            this.store.update({ style: { ...this.pivotStyle, [key]: value } });
+        }
+        get pivotStyle() {
+            const pivot = this.env.model.getters.getPivotCoreDefinition(this.props.pivotId);
+            return pivot.style || {};
+        }
+        get defaultStyle() {
+            return DEFAULT_PIVOT_STYLE;
+        }
+    }
+
     class PivotSidePanel extends owl.Component {
         static template = "o-spreadsheet-PivotSidePanel";
         static props = {
@@ -78418,6 +78780,13 @@ stores.inject(MyMetaStore, storeInstance);
         static components = {
             PivotLayoutConfigurator,
             Section,
+            PivotDesignPanel,
+        };
+        state = owl.useState({ panel: "configuration" });
+        panelContentRef = owl.useRef("panelContent");
+        scrollPositions = {
+            configuration: 0,
+            design: 0,
         };
         setup() {
             useHighlights(this);
@@ -78432,6 +78801,13 @@ stores.inject(MyMetaStore, storeInstance);
         get highlights() {
             return getPivotHighlights(this.env.model.getters, this.props.pivotId);
         }
+        switchPanel(panel) {
+            const el = this.panelContentRef.el;
+            if (el) {
+                this.scrollPositions[this.state.panel] = el.scrollTop;
+            }
+            this.state.panel = panel;
+        }
     }
 
     class RemoveDuplicatesPanel extends owl.Component {
@@ -78937,7 +79313,14 @@ stores.inject(MyMetaStore, storeInstance);
 
     class TablePanel extends owl.Component {
         static template = "o-spreadsheet-TablePanel";
-        static components = { TableStylePicker, SelectionInput, ValidationMessages, Checkbox, Section };
+        static components = {
+            TableStylePicker,
+            SelectionInput,
+            ValidationMessages,
+            Checkbox,
+            Section,
+            NumberInput,
+        };
         static props = { onCloseSidePanel: Function, table: Object };
         state;
         setup() {
@@ -78987,13 +79370,9 @@ stores.inject(MyMetaStore, storeInstance);
                 this.state.tableZoneErrors = [];
             }
         }
-        onChangeNumberOfHeaders(ev) {
-            const input = ev.target;
-            const numberOfHeaders = parseInt(input.value);
-            const result = this.updateNumberOfHeaders(numberOfHeaders);
-            if (!result.isSuccessful) {
-                input.value = this.props.table.config.numberOfHeaders.toString();
-            }
+        onChangeNumberOfHeaders(value) {
+            const numberOfHeaders = parseInt(value);
+            this.updateNumberOfHeaders(numberOfHeaders);
         }
         updateNumberOfHeaders(numberOfHeaders) {
             const hasFilters = numberOfHeaders > 0 && (this.tableConfig.hasFilters || this.state.filtersEnabledIfPossible);
@@ -87478,6 +87857,7 @@ stores.inject(MyMetaStore, storeInstance);
         GeoChartRegionSelectSection,
         ChartDashboardMenu,
         FullScreenFigure,
+        NumberInput,
     };
     const hooks = {
         useDragAndDropListItems,
@@ -87581,9 +87961,9 @@ stores.inject(MyMetaStore, storeInstance);
     exports.tokenize = tokenize;
 
 
-    __info__.version = "19.1.0-alpha.7";
-    __info__.date = "2025-10-17T11:09:35.690Z";
-    __info__.hash = "a11279d";
+    __info__.version = "19.1.0-alpha.9";
+    __info__.date = "2025-10-23T11:12:55.400Z";
+    __info__.hash = "bd756dd";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);