@odoo/o-spreadsheet 19.1.0-alpha.13 → 19.1.0-alpha.14

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.13
- * @date 2025-11-24T07:53:14.109Z
- * @hash e232982
+ * @version 19.1.0-alpha.14
+ * @date 2025-12-02T05:34:46.718Z
+ * @hash 04cf666
  */
 
 (function (exports, owl) {
@@ -2148,6 +2148,47 @@
                 return newZones;
         }
     }
+    /**
+     * Splits zone z2 by removing the overlapping zone z1 (fully inside z2).
+     * Returns the remaining parts of z2 that don't overlap with z1.
+     *
+     * Diagram:
+     * ┌──────────── z2 ─────────────┐
+     * │              1              │
+     * │--------─────────────--------│
+     * │  2    |     z1      |    3  │
+     * │--------─────────────--------│
+     * │              4              │
+     * └─────────────────────────────┘
+     *
+     * Input:
+     *   z1 = { top: 2, bottom: 3, left: 2, right: 3 }
+     *   z2 = { top: 1, bottom: 4, left: 1, right: 4 }
+     *
+     * Output:
+     * [
+     *   { top: 4, bottom: 4, left: 1, right: 4 },  // bottom
+     *   { top: 2, bottom: 3, left: 4, right: 4 },  // right
+     *   { top: 2, bottom: 3, left: 1, right: 1 },  // left
+     *   { top: 1, bottom: 1, left: 1, right: 4 }   // top
+     * ]
+     */
+    function splitZone(z1, z2) {
+        const zones = [];
+        if (z1.bottom < z2.bottom) {
+            zones.push({ ...z2, top: z1.bottom + 1 });
+        }
+        if (z1.right < z2.right) {
+            zones.push({ ...z2, left: z1.right + 1, top: z1.top, bottom: z1.bottom });
+        }
+        if (z1.left > z2.left) {
+            zones.push({ ...z2, right: z1.left - 1, top: z1.top, bottom: z1.bottom });
+        }
+        if (z1.top > z2.top) {
+            zones.push({ ...z2, bottom: z1.top - 1 });
+        }
+        return zones;
+    }
 
     function transformZone(zone, executed) {
         if (executed.type === "REMOVE_COLUMNS_ROWS") {
@@ -4385,8 +4426,56 @@
         return isMatrix(arg) && !isSingleElementMatrix(arg);
     }
 
+    function stackHorizontally(ranges, options) {
+        const matrices = ranges.map(toMatrix);
+        const nbRowsArr = matrices.map((m) => m?.[0]?.length ?? 0);
+        const nbRows = Math.max(...nbRowsArr);
+        if (options?.requireSameRowCount) {
+            const firstLength = nbRowsArr[0];
+            if (nbRowsArr.some((len) => len !== firstLength)) {
+                return new EvaluationError(_t$1("All ranges in [[FUNCTION_NAME]] must have the same number of columns (got %s).", nbRowsArr.join(", ")));
+            }
+        }
+        const result = [];
+        for (const matrix of matrices) {
+            for (let col = 0; col < matrix.length; col++) {
+                // Fill with nulls if needed
+                const array = Array(nbRows).fill({ value: null });
+                for (let row = 0; row < matrix[col].length; row++) {
+                    array[row] = matrix[col][row];
+                }
+                result.push(array);
+            }
+        }
+        return result;
+    }
+    function stackVertically(ranges, options) {
+        const matrices = ranges.map(toMatrix);
+        const nbColsArr = matrices.map((m) => m?.length ?? 0);
+        const nbCols = Math.max(...nbColsArr);
+        if (options?.requireSameColCount) {
+            const firstLength = nbColsArr[0];
+            if (nbColsArr.some((len) => len !== firstLength)) {
+                return new EvaluationError(_t$1("All ranges in [[FUNCTION_NAME]] must have the same number of columns (got %s).", nbColsArr.join(", ")));
+            }
+        }
+        const nbRows = matrices.reduce((acc, m) => acc + (m?.[0]?.length ?? 0), 0);
+        const result = generateMatrix(nbCols, nbRows, () => ({
+            value: null,
+        }));
+        let currentRow = 0;
+        for (const matrix of matrices) {
+            for (let col = 0; col < matrix.length; col++) {
+                for (let row = 0; row < matrix[col].length; row++) {
+                    result[col][currentRow + row] = matrix[col][row];
+                }
+            }
+            currentRow += matrix[0]?.length ?? 0;
+        }
+        return result;
+    }
     // -----------------------------------------------------------------------------
-    // ARRAY_CONSTRAIN
+    // ARRAY.CONSTRAIN
     // -----------------------------------------------------------------------------
     const ARRAY_CONSTRAIN = {
         description: _t$1("Returns a result array constrained to a specific width and height."),
@@ -4412,6 +4501,30 @@
         isExported: false,
     };
     // -----------------------------------------------------------------------------
+    // ARRAY.LITERAL
+    // -----------------------------------------------------------------------------
+    const ARRAY_LITERAL = {
+        description: _t$1("Appends ranges vertically and in sequence to return a larger array. All ranges must have the same number of columns."),
+        args: [arg("range (any, range<any>, repeating)", _t$1("The range to be appended."))],
+        compute: function (...ranges) {
+            return stackVertically(ranges, { requireSameColCount: true });
+        },
+        isExported: false,
+        hidden: true,
+    };
+    // -----------------------------------------------------------------------------
+    // ARRAY.ROW
+    // -----------------------------------------------------------------------------
+    const ARRAY_ROW = {
+        description: _t$1("Appends ranges horizontally and in sequence to return a larger array. All ranges must have the same number of rows."),
+        args: [arg("range (any, range<any>, repeating)", _t$1("The range to be appended."))],
+        compute: function (...ranges) {
+            return stackHorizontally(ranges, { requireSameRowCount: true });
+        },
+        isExported: false,
+        hidden: true,
+    };
+    // -----------------------------------------------------------------------------
     // CHOOSECOLS
     // -----------------------------------------------------------------------------
     const CHOOSECOLS = {
@@ -4557,20 +4670,7 @@
         description: _t$1("Appends ranges horizontally and in sequence to return a larger array."),
         args: [arg("range (any, range<any>, repeating)", _t$1("The range to be appended."))],
         compute: function (...ranges) {
-            const nbRows = Math.max(...ranges.map((r) => r?.[0]?.length ?? 0));
-            const result = [];
-            for (const range of ranges) {
-                const _range = toMatrix(range);
-                for (let col = 0; col < _range.length; col++) {
-                    //TODO: fill with #N/A for unavailable values instead of zeroes
-                    const array = Array(nbRows).fill({ value: null });
-                    for (let row = 0; row < _range[col].length; row++) {
-                        array[row] = _range[col][row];
-                    }
-                    result.push(array);
-                }
-            }
-            return result;
+            return stackHorizontally(ranges);
         },
         isExported: true,
     };
@@ -4829,22 +4929,7 @@
         description: _t$1("Appends ranges vertically and in sequence to return a larger array."),
         args: [arg("range (any, range<any>, repeating)", _t$1("The range to be appended."))],
         compute: function (...ranges) {
-            const nbColumns = Math.max(...ranges.map((range) => toMatrix(range).length));
-            const nbRows = ranges.reduce((acc, range) => acc + toMatrix(range)[0].length, 0);
-            const result = Array(nbColumns)
-                .fill([])
-                .map(() => Array(nbRows).fill({ value: 0 })); // TODO fill with #N/A
-            let currentRow = 0;
-            for (const range of ranges) {
-                const _array = toMatrix(range);
-                for (let col = 0; col < _array.length; col++) {
-                    for (let row = 0; row < _array[col].length; row++) {
-                        result[col][currentRow + row] = _array[col][row];
-                    }
-                }
-                currentRow += _array[0].length;
-            }
-            return result;
+            return stackVertically(ranges);
         },
         isExported: true,
     };
@@ -4904,6 +4989,8 @@
     var array = /*#__PURE__*/Object.freeze({
         __proto__: null,
         ARRAY_CONSTRAIN: ARRAY_CONSTRAIN,
+        ARRAY_LITERAL: ARRAY_LITERAL,
+        ARRAY_ROW: ARRAY_ROW,
         CHOOSECOLS: CHOOSECOLS,
         CHOOSEROWS: CHOOSEROWS,
         EXPAND: EXPAND,
@@ -6370,7 +6457,6 @@
         "REDO",
         "ADD_MERGE",
         "REMOVE_MERGE",
-        "DUPLICATE_SHEET",
         "UPDATE_LOCALE",
         "ADD_PIVOT",
         "UPDATE_PIVOT",
@@ -9875,7 +9961,9 @@
         while (!chars.isOver()) {
             let token = tokenizeNewLine(chars) ||
                 tokenizeSpace(chars) ||
+                tokenizeArrayRowSeparator(chars, locale) ||
                 tokenizeArgsSeparator(chars, locale) ||
+                tokenizeBraces(chars) ||
                 tokenizeParenthesis(chars) ||
                 tokenizeOperator(chars) ||
                 tokenizeString$1(chars) ||
@@ -9908,6 +9996,17 @@
         }
         return null;
     }
+    const braces = {
+        "{": { type: "LEFT_BRACE", value: "{" },
+        "}": { type: "RIGHT_BRACE", value: "}" },
+    };
+    function tokenizeBraces(chars) {
+        if (chars.current === "{" || chars.current === "}") {
+            const value = chars.shift();
+            return braces[value];
+        }
+        return null;
+    }
     function tokenizeArgsSeparator(chars, locale) {
         if (chars.current === locale.formulaArgSeparator) {
             const value = chars.shift();
@@ -9916,6 +10015,20 @@
         }
         return null;
     }
+    function tokenizeArrayRowSeparator(chars, locale) {
+        // The array row separator is used in array literals to separate rows.
+        // It is not explicitly defined in locales, but depends on the formulaArgSeparator.
+        // Example: {1,2,3;4,5,6} — here, ';' separates rows and ',' separates columns.
+        const rowSeparator = locale.formulaArgSeparator === ";" ? "\\" : ";";
+        if (!rowSeparator) {
+            return null;
+        }
+        if (chars.current === rowSeparator) {
+            chars.shift();
+            return { type: "ARRAY_ROW_SEPARATOR", value: rowSeparator };
+        }
+        return null;
+    }
     function tokenizeOperator(chars) {
         for (const op of OPERATORS) {
             if (chars.currentStartsWith(op)) {
@@ -10157,6 +10270,9 @@
             else if (token.type === "ARG_SEPARATOR") {
                 localizedFormula += toLocale.formulaArgSeparator;
             }
+            else if (token.type === "ARRAY_ROW_SEPARATOR") {
+                localizedFormula += toLocale.formulaArgSeparator === ";" ? "\\" : ";";
+            }
             else {
                 localizedFormula += token.value;
             }
@@ -11400,7 +11516,6 @@
     // -----------------------------------------------------------------------------
     const FILTER = {
         description: _t$1("Returns a filtered version of the source range, returning only rows or columns that meet the specified conditions."),
-        // TODO modify args description when vectorization on formulas is available
         args: [
             arg("range (any, range<any>)", _t$1("The data to be filtered.")),
             arg("condition (boolean, range<boolean>, repeating)", _t$1("Column or row containing true or false values corresponding to the range.")),
@@ -17638,6 +17753,8 @@
                     tokenStartIndex: current.tokenIndex,
                     tokenEndIndex: rightParen.tokenIndex,
                 };
+            case "LEFT_BRACE":
+                return parseArrayLiteral(tokens, current);
             case "OPERATOR":
                 const operator = current.value;
                 if (UNARY_OPERATORS_PREFIX.includes(operator)) {
@@ -17691,6 +17808,34 @@
         }
         return token;
     }
+    function parseArrayLiteral(tokens, leftBrace) {
+        const rows = [];
+        let currentRow = [parseExpression(tokens)]; // there must be at least one element
+        while (tokens.current?.type !== "RIGHT_BRACE") {
+            const nextToken = tokens.shift();
+            if (!nextToken) {
+                throw new BadExpressionError(_t$1("Missing closing brace"));
+            }
+            else if (nextToken.type === "ARG_SEPARATOR") {
+                currentRow.push(parseExpression(tokens));
+            }
+            else if (nextToken.type === "ARRAY_ROW_SEPARATOR") {
+                rows.push(currentRow);
+                currentRow = [parseExpression(tokens)];
+            }
+            else {
+                throw new BadExpressionError(_t$1("Unexpected token: %s", nextToken.value));
+            }
+        }
+        const rightBrace = consumeOrThrow(tokens, "RIGHT_BRACE", _t$1("Missing closing brace"));
+        rows.push(currentRow);
+        return {
+            type: "ARRAY",
+            value: rows,
+            tokenStartIndex: leftBrace.tokenIndex,
+            tokenEndIndex: rightBrace.tokenIndex,
+        };
+    }
     function parseExpression(tokens, parent_priority = 0) {
         if (tokens.length === 0) {
             throw new BadExpressionError();
@@ -17781,6 +17926,13 @@
                     yield* astIterator(arg);
                 }
                 break;
+            case "ARRAY":
+                for (const row of ast.value) {
+                    for (const cell of row) {
+                        yield* astIterator(cell);
+                    }
+                }
+                break;
             case "UNARY_OPERATION":
                 yield* astIterator(ast.operand);
                 break;
@@ -17798,6 +17950,11 @@
                     ...ast,
                     args: ast.args.map((child) => mapAst(child, fn)),
                 };
+            case "ARRAY":
+                return {
+                    ...ast,
+                    value: ast.value.map((row) => row.map((cell) => mapAst(cell, fn))),
+                };
             case "UNARY_OPERATION":
                 return {
                     ...ast,
@@ -20253,6 +20410,30 @@ stores.inject(MyMetaStore, storeInstance);
         }
     }
 
+    function getCalendarChartController() {
+        return class CalendarChartController extends window.Chart.BarController {
+            static id = "calendar";
+            static defaults = {
+                ...window.Chart?.BarController.defaults,
+                dataElementType: "bar",
+                animations: {
+                    numbers: { type: "number", properties: [] }, // Disable number animations (width, height, ...)
+                },
+            };
+            updateElements(rects, start, count, mode) {
+                super.updateElements(rects, start, count, mode);
+                // Remove the element background at the start of an animation
+                const chartBackground = this.chart.config.options?.chartBackground;
+                const backgroundColor = chartBackground || "#ffffff";
+                for (let i = start; i < start + count; i++) {
+                    if (mode === "reset") {
+                        this.updateElement(rects[i], i, { options: { backgroundColor } }, mode);
+                    }
+                }
+            }
+        };
+    }
+
     /** This is a chartJS plugin that will draw the heatmap colorscale at the chart legend position */
     const chartColorScalePlugin = {
         id: "chartColorScalePlugin",
@@ -31588,6 +31769,9 @@ stores.inject(MyMetaStore, storeInstance);
         }));
     }
     function getTreeMapColorScale(tree, coloringOption) {
+        if (tree.length === 0) {
+            return undefined;
+        }
         const treeNodesByLevel = pyramidizeTree(tree);
         const nodes = treeNodesByLevel[treeNodesByLevel.length - 1];
         const minValue = Math.min(...nodes.map((node) => node.value));
@@ -31843,6 +32027,10 @@ stores.inject(MyMetaStore, storeInstance);
         register: (Chart) => Chart.register(chartColorScalePlugin),
         unregister: (Chart) => Chart.unregister(chartColorScalePlugin),
     });
+    chartJsExtensionRegistry.add("calendarController", {
+        register: (Chart) => Chart.register(getCalendarChartController()),
+        unregister: (Chart) => Chart.unregister(getCalendarChartController()),
+    });
     class ChartJsComponent extends owl.Component {
         static template = "o-spreadsheet-ChartJsComponent";
         static props = {
@@ -33859,6 +34047,23 @@ stores.inject(MyMetaStore, storeInstance);
                         code.append(...args);
                         const fnName = ast.value.toUpperCase();
                         return code.return(`ctx['${fnName}'](${args.map((arg) => arg.returnExpression)})`);
+                    case "ARRAY": {
+                        // a literal array is compiled into function calls
+                        const arrayFunctionCall = {
+                            type: "FUNCALL",
+                            value: "ARRAY.LITERAL",
+                            args: ast.value.map((row) => ({
+                                type: "FUNCALL",
+                                value: "ARRAY.ROW",
+                                args: row,
+                                tokenStartIndex: 0,
+                                tokenEndIndex: 0,
+                            })),
+                            tokenStartIndex: 0,
+                            tokenEndIndex: 0,
+                        };
+                        return compileAST(arrayFunctionCall);
+                    }
                     case "UNARY_OPERATION": {
                         const fnName = UNARY_OPERATOR_MAP[ast.value];
                         const operand = compileAST(ast.operand, false, false).assignResultToVariable();
@@ -40336,6 +40541,26 @@ stores.inject(MyMetaStore, storeInstance);
         }
     }
 
+    function schemeToColorScale(scheme) {
+        const colors = COLORSCHEMES[scheme];
+        return colors === undefined
+            ? undefined
+            : {
+                minColor: colors[0],
+                midColor: colors.length === 3 ? colors[1] : undefined,
+                maxColor: colors[colors.length - 1],
+            };
+    }
+
+    const SunburstChartDefaults = {
+        showValues: false,
+        showLabels: true,
+        valuesDesign: {
+            align: "center",
+            fontSize: 13,
+        },
+    };
+
     /**
      * parses a formula (as a string) into the same formula,
      * but with the references to other cells extracted
@@ -40980,13 +41205,22 @@ stores.inject(MyMetaStore, storeInstance);
             return data;
         },
     })
-        .add("19.2", {
+        .add("19.1.0", {
         migrate(data) {
             for (const sheet of data.sheets || []) {
                 for (const figure of sheet.figures || []) {
                     if (figure.tag === "chart" && figure.data.type === "geo") {
                         if ("colorScale" in figure.data && typeof figure.data.colorScale === "string") {
-                            figure.data.colorScale = COLORSCHEMES[figure.data.colorScale];
+                            figure.data.colorScale = schemeToColorScale(figure.data.colorScale);
+                        }
+                    }
+                    if (figure.tag === "carousel") {
+                        for (const definition of Object.values(figure.data.chartDefinitions) || []) {
+                            if (definition.type === "geo") {
+                                if ("colorScale" in definition && typeof definition.colorScale === "string") {
+                                    definition.colorScale = schemeToColorScale(definition.colorScale);
+                                }
+                            }
                         }
                     }
                 }
@@ -41249,18 +41483,22 @@ stores.inject(MyMetaStore, storeInstance);
         return messages;
     }
     function fixChartDefinitions(data, initialMessages) {
+        /**
+         * Revisions created after version 18.5.1 contain the full chart definition in the command
+         * if the data was alreay updated to 18.5.1, then those older revision cannot (by definition) be reaplied
+         * and should not be replayed.
+         * FIXME: every command should be versionned when upgraded to allow finer tuning.
+         */
+        if (!data.version || compareVersions(String(data.version), "18.5.1") >= 0) {
+            return initialMessages;
+        }
         const messages = [];
         const map = {};
         for (const sheet of data.sheets || []) {
             sheet.figures?.forEach((figure) => {
                 if (figure.tag === "chart") {
                     // chart definition
-                    if (data.version && compareVersions(String(data.version), "18.5.1") <= 0) {
-                        map[figure.data.chartId] = figure.data;
-                    }
-                    else {
-                        map[figure.id] = figure.data;
-                    }
+                    map[figure.id] = figure.data;
                 }
             });
         }
@@ -44300,7 +44538,8 @@ stores.inject(MyMetaStore, storeInstance);
                     }
                     break;
                 case "DUPLICATE_SHEET": {
-                    for (const figureId in this.figures[cmd.sheetId]) {
+                    for (const figure of this.getFigures(cmd.sheetId)) {
+                        const figureId = figure.id;
                         const fig = this.figures[cmd.sheetId]?.[figureId];
                         if (!fig) {
                             continue;
@@ -46633,10 +46872,17 @@ stores.inject(MyMetaStore, storeInstance);
                 if (!pivot) {
                     continue;
                 }
-                for (const measure of pivot.definition.measures) {
+                const def = deepCopy$1(pivot.definition);
+                for (const measure of def.measures) {
                     if (measure.computedBy?.formula === formulaString) {
-                        const measureIndex = pivot.definition.measures.indexOf(measure);
-                        this.history.update("pivots", pivotId, "definition", "measures", measureIndex, "computedBy", { formula: newFormulaString, sheetId });
+                        const measureIndex = def.measures.indexOf(measure);
+                        if (measureIndex !== -1) {
+                            def.measures[measureIndex].computedBy = {
+                                formula: newFormulaString,
+                                sheetId,
+                            };
+                        }
+                        this.dispatch("UPDATE_PIVOT", { pivotId, pivot: def });
                     }
                 }
             }
@@ -47668,6 +47914,9 @@ stores.inject(MyMetaStore, storeInstance);
                     const { sheetId, zone } = definition.dataSet;
                     const range = this.getters.getRangeFromZone(sheetId, zone);
                     const adaptedRange = adaptPivotRange(range, applyChange);
+                    if (adaptedRange === range) {
+                        return;
+                    }
                     const dataSet = adaptedRange && {
                         sheetId: adaptedRange.sheetId,
                         zone: adaptedRange.zone,
@@ -52473,6 +52722,11 @@ stores.inject(MyMetaStore, storeInstance);
                     }
                 }
                 return wrapInParentheses(concat(splitArgsWithCommas(docs)), ast.value);
+            case "ARRAY": {
+                const rowDocs = ast.value.map((row) => concat(row.map((value, index) => index === 0 ? astToDoc(value) : concat([", ", line(), astToDoc(value)]))));
+                const body = concat(rowDocs.map((doc, index) => (index === 0 ? group(doc) : concat(["; ", line(), group(doc)]))));
+                return wrapInBraces(body);
+            }
             case "UNARY_OPERATION":
                 const operandDoc = astToDoc(ast.operand);
                 const needParenthesis = ast.postfix
@@ -52516,6 +52770,9 @@ stores.inject(MyMetaStore, storeInstance);
         }
         return group(concat(docToConcat));
     }
+    function wrapInBraces(doc) {
+        return group(concat(["{", nest(1, concat([line(), doc])), line(), "}"]));
+    }
     /**
      * Converts an ast formula to the corresponding string
      */
@@ -52543,6 +52800,10 @@ stores.inject(MyMetaStore, storeInstance);
                     ? `(${astToFormula(ast.operand)})`
                     : astToFormula(ast.operand);
                 return ast.value + rightOperand;
+            case "ARRAY":
+                return ("{" +
+                    ast.value.map((row) => row.map((cell) => astToFormula(cell)).join(",")).join(";") +
+                    "}");
             case "BIN_OPERATION":
                 const leftOperation = leftOperandNeedsParenthesis(ast)
                     ? `(${astToFormula(ast.left)})`
@@ -54107,7 +54368,6 @@ stores.inject(MyMetaStore, storeInstance);
     pivotRegistry.add("SPREADSHEET", {
         ui: SpreadsheetPivot,
         definition: SpreadsheetPivotRuntimeDefinition,
-        externalData: false,
         dateGranularities: [...dateGranularities],
         datetimeGranularities: [...dateGranularities, "hour_number", "minute_number", "second_number"],
         isMeasureCandidate: (field) => field.type !== "boolean",
@@ -54149,9 +54409,7 @@ stores.inject(MyMetaStore, storeInstance);
         handle(cmd) {
             if (invalidateEvaluationCommands.has(cmd.type)) {
                 for (const pivotId of this.getters.getPivotIds()) {
-                    if (!pivotRegistry.get(this.getters.getPivotCoreDefinition(pivotId).type).externalData) {
-                        this.setupPivot(pivotId, { recreate: true });
-                    }
+                    this.setupPivot(pivotId, { recreate: true });
                 }
             }
             switch (cmd.type) {
@@ -54365,7 +54623,7 @@ stores.inject(MyMetaStore, storeInstance);
             pivot.init({ reload: true });
         }
         setupPivot(pivotId, { recreate } = { recreate: false }) {
-            const definition = this.getters.getPivotCoreDefinition(pivotId);
+            const definition = deepCopy$1(this.getters.getPivotCoreDefinition(pivotId));
             if (!(pivotId in this.pivots)) {
                 const Pivot = withPivotPresentationLayer(pivotRegistry.get(definition.type).ui);
                 this.pivots[pivotId] = new Pivot(this.custom, { definition, getters: this.getters });
@@ -57459,6 +57717,15 @@ stores.inject(MyMetaStore, storeInstance);
                         return "InvalidFigureId" /* CommandResult.InvalidFigureId */;
                     }
                     return "Success" /* CommandResult.Success */;
+                case "DUPLICATE_CAROUSEL_CHART":
+                    if (!this.getters.doesCarouselExist(cmd.carouselId) ||
+                        !this.getters
+                            .getCarousel(cmd.carouselId)
+                            .items.some((item) => item.type === "chart" && item.chartId === cmd.chartId) ||
+                        this.getters.getChart(cmd.duplicatedChartId)) {
+                        return "InvalidFigureId" /* CommandResult.InvalidFigureId */;
+                    }
+                    return "Success" /* CommandResult.Success */;
                 case "ADD_NEW_CHART_TO_CAROUSEL":
                     if (!this.getters.doesCarouselExist(cmd.figureId)) {
                         return "InvalidFigureId" /* CommandResult.InvalidFigureId */;
@@ -57483,6 +57750,9 @@ stores.inject(MyMetaStore, storeInstance);
                 case "ADD_FIGURE_CHART_TO_CAROUSEL":
                     this.addFigureChartToCarousel(cmd.carouselFigureId, cmd.chartFigureId, cmd.sheetId);
                     break;
+                case "DUPLICATE_CAROUSEL_CHART":
+                    this.duplicateCarouselChart(cmd);
+                    break;
                 case "UPDATE_CAROUSEL_ACTIVE_ITEM":
                     this.carouselStates[cmd.figureId] = this.getCarouselItemId(cmd.item);
                     break;
@@ -57621,6 +57891,29 @@ stores.inject(MyMetaStore, storeInstance);
             });
             this.dispatch("DELETE_FIGURE", { sheetId, figureId: chartFigureId });
         }
+        duplicateCarouselChart({ carouselId, chartId, sheetId, duplicatedChartId, }) {
+            const chart = this.getters.getChart(chartId);
+            if (!chart) {
+                return;
+            }
+            const carousel = this.getters.getCarousel(carouselId);
+            const duplicatedItemIndex = carousel.items.findIndex((item) => item.type === "chart" && item.chartId === chartId);
+            if (duplicatedItemIndex === -1) {
+                return;
+            }
+            this.dispatch("CREATE_CHART", {
+                chartId: duplicatedChartId,
+                figureId: carouselId,
+                sheetId,
+                definition: chart.getDefinition(),
+            });
+            const carouselItems = insertItemsAtIndex(carousel.items, [{ type: "chart", chartId: duplicatedChartId }], duplicatedItemIndex + 1);
+            this.dispatch("UPDATE_CAROUSEL", {
+                sheetId,
+                figureId: carouselId,
+                definition: { ...carousel, items: carouselItems },
+            });
+        }
         getCarouselItemId(item) {
             return item.type === "chart" ? item.chartId : "carouselDataView";
         }
@@ -58833,25 +59126,43 @@ stores.inject(MyMetaStore, storeInstance);
             return "Success" /* CommandResult.Success */;
         }
         handleEvent(event) {
-            const anchor = event.anchor;
-            let zones = [];
+            let anchor = event.anchor;
+            let zones = [...this.gridSelection.zones];
             this.isUnbounded = event.options?.unbounded || false;
             switch (event.mode) {
                 case "overrideSelection":
                     zones = [anchor.zone];
                     break;
                 case "updateAnchor":
-                    zones = [...this.gridSelection.zones];
                     const index = zones.findIndex((z) => isEqual(z, event.previousAnchor.zone));
                     if (index >= 0) {
                         zones[index] = anchor.zone;
                     }
                     break;
                 case "newAnchor":
-                    zones = [...this.gridSelection.zones, anchor.zone];
+                    zones.push(anchor.zone);
+                    break;
+                case "commitSelection":
+                    const zoneToSplit = zones.find((zone) => isZoneInside(anchor.zone, zone) && !isEqual(anchor.zone, zone));
+                    const removeFullAnchor = zones.filter((zone) => isEqual(anchor.zone, zone)).length > 1;
+                    if (removeFullAnchor && zones.length > 2) {
+                        zones = zones.filter((zone) => !isEqual(zone, anchor.zone));
+                    }
+                    else if (zoneToSplit) {
+                        const splittedZones = splitZone(anchor.zone, zoneToSplit);
+                        zones = zones
+                            .filter((z) => !isEqual(z, anchor.zone) && !isEqual(z, zoneToSplit))
+                            .concat(splittedZones);
+                    }
+                    zones = uniqueZones(zones);
+                    const lastZone = zones[zones.length - 1];
+                    anchor = {
+                        cell: { col: lastZone.left, row: lastZone.top },
+                        zone: lastZone,
+                    };
                     break;
             }
-            this.setSelectionMixin(event.anchor, zones);
+            this.setSelectionMixin(anchor, zones);
             /** Any change to the selection has to be reflected in the selection processor. */
             this.selection.resetDefaultAnchor(this, deepCopy$1(this.gridSelection.anchor));
             const { col, row } = this.gridSelection.anchor.cell;
@@ -59131,7 +59442,7 @@ stores.inject(MyMetaStore, storeInstance);
         setSelectionMixin(anchor, zones) {
             const { anchor: clippedAnchor, zones: clippedZones } = this.clipSelection(this.getters.getActiveSheetId(), { anchor, zones });
             this.gridSelection.anchor = clippedAnchor;
-            this.gridSelection.zones = uniqueZones(clippedZones);
+            this.gridSelection.zones = clippedZones;
         }
         /**
          * Change the anchor of the selection active cell to an absolute col and row index.
@@ -61089,6 +61400,9 @@ stores.inject(MyMetaStore, storeInstance);
                 bottom: Math.max(anchorRow, row),
             };
             const expandedZone = this.getters.expandZone(sheetId, zone);
+            if (isEqual(this.anchor.zone, expandedZone)) {
+                return new DispatchResult("NoChanges" /* CommandResult.NoChanges */);
+            }
             const anchor = { zone: expandedZone, cell: { col: anchorCol, row: anchorRow } };
             return this.processEvent({
                 mode: "updateAnchor",
@@ -61109,6 +61423,22 @@ stores.inject(MyMetaStore, storeInstance);
                 mode: "newAnchor",
             });
         }
+        /**
+         * Triggered on mouse up to finalize the selection.
+         * - If the current anchor zone already exists in the selection, it will be removed.
+         * - If the anchor zone overlaps with existing zones, it will be split into
+         *   multiple non-overlapping parts.
+         */
+        commitSelection() {
+            return this.processEvent({
+                options: {
+                    scrollIntoView: false,
+                    unbounded: true,
+                },
+                anchor: this.anchor,
+                mode: "commitSelection",
+            });
+        }
         /**
          * Increase or decrease the size of the current anchor zone.
          * The anchor cell remains where it is. It's the opposite side
@@ -64473,17 +64803,6 @@ stores.inject(MyMetaStore, storeInstance);
         return command;
     }
 
-    function schemeToColorScale(scheme) {
-        const colors = COLORSCHEMES[scheme];
-        return colors === undefined
-            ? undefined
-            : {
-                minColor: colors[0],
-                midColor: colors.length === 3 ? colors[1] : undefined,
-                maxColor: colors[colors.length - 1],
-            };
-    }
-
     const availableConditionalFormatOperators = new Set([
         "containsText",
         "notContainsText",
@@ -65634,15 +65953,6 @@ stores.inject(MyMetaStore, storeInstance);
         };
     }
 
-    const SunburstChartDefaults = {
-        showValues: false,
-        showLabels: true,
-        valuesDesign: {
-            align: "center",
-            fontSize: 13,
-        },
-    };
-
     function getChartShowValues(definition, args) {
         const { axisFormats, locale } = args;
         return {
@@ -68646,10 +68956,16 @@ stores.inject(MyMetaStore, storeInstance);
             return menu.children(this.env).some((child) => child.isVisible(this.env));
         }
         isEnabled(menu) {
-            if (menu.isEnabled(this.env)) {
-                return this.env.model.getters.isReadonly() ? menu.isReadonlyAllowed : true;
+            const children = menu.children?.(this.env);
+            if (children.length) {
+                return children.some((child) => this.isEnabled(child));
+            }
+            else {
+                if (menu.isEnabled(this.env)) {
+                    return this.env.model.getters.isReadonly() ? menu.isReadonlyAllowed : true;
+                }
+                return false;
             }
-            return false;
         }
         get menuStyle() {
             return this.props.width ? cssPropertiesToCss({ width: this.props.width + "px" }) : "";
@@ -69154,17 +69470,15 @@ stores.inject(MyMetaStore, storeInstance);
             }
         }
         onMouseOver(menu, ev) {
-            if (this.isEnabled(menu)) {
-                if (this.isParentMenu(this.subMenu, menu)) {
-                    this.openingTimeOut.clear();
-                    return;
-                }
-                const currentTarget = ev.currentTarget;
-                if (this.isRoot(menu)) {
-                    this.openingTimeOut.schedule(() => {
-                        this.openSubMenu(menu, currentTarget);
-                    }, TIMEOUT_DELAY);
-                }
+            if (this.isParentMenu(this.subMenu, menu)) {
+                this.openingTimeOut.clear();
+                return;
+            }
+            const currentTarget = ev.currentTarget;
+            if (this.isRoot(menu)) {
+                this.openingTimeOut.schedule(() => {
+                    this.openSubMenu(menu, currentTarget);
+                }, TIMEOUT_DELAY);
             }
         }
         onMouseOverMainMenu() {
@@ -71591,16 +71905,19 @@ stores.inject(MyMetaStore, storeInstance);
                     if (displayBrackets) {
                         result.push({ content: "]" });
                     }
-                    result.push({ content: argSeparator + "[" });
-                    for (let idx = 0; idx < repeatingArgNames.length; idx++) {
-                        const name = repeatingArgNames[idx];
-                        result.push({ content: name + ((repeatingArgGroupIndex ?? 0) + 2) });
-                        // Add separator after each element except the last
-                        if (idx < repeatingArgNames.length - 1) {
-                            result.push({ content: argSeparator });
+                    if (functionDescription.nbrArgRepeating <= 1) {
+                        result.push({ content: argSeparator + "[" });
+                        for (let idx = 0; idx < repeatingArgNames.length; idx++) {
+                            const name = repeatingArgNames[idx];
+                            result.push({ content: name + ((repeatingArgGroupIndex ?? 0) + 2) });
+                            // Add separator after each element except the last
+                            if (idx < repeatingArgNames.length - 1) {
+                                result.push({ content: argSeparator });
+                            }
                         }
+                        result.push({ content: "]" });
                     }
-                    result.push({ content: "]" + argSeparator + "... " });
+                    result.push({ content: argSeparator + "... " });
                     // Skip the processed repeating args
                     i += functionDescription.nbrArgRepeating - 1;
                 }
@@ -71677,6 +71994,7 @@ stores.inject(MyMetaStore, storeInstance);
         };
         DOMFocusableElementStore;
         composerRef = owl.useRef("o_composer");
+        containerRef = owl.useRef("composerContainer");
         contentHelper = new ContentEditableHelper(this.composerRef.el);
         composerState = owl.useState({
             positionStart: 0,
@@ -71725,7 +72043,8 @@ stores.inject(MyMetaStore, storeInstance);
                     assistantStyle["max-height"] = `${availableSpaceAbove - CLOSE_ICON_RADIUS}px`;
                     // render top
                     // We compensate 2 px of margin on the assistant style + 1px for design reasons
-                    assistantStyle.transform = `translate(0, calc(-100% - ${cellHeight + 3}px))`;
+                    assistantStyle.top = `-3px`;
+                    assistantStyle.transform = `translate(0, -100%)`;
                 }
                 if (cellX + ASSISTANT_WIDTH > this.props.delimitation.width) {
                     // render left
@@ -71984,6 +72303,9 @@ stores.inject(MyMetaStore, storeInstance);
                 this.props.composerStore.stopEdition();
                 return;
             }
+            if (this.containerRef.el?.contains(ev.relatedTarget)) {
+                return;
+            }
             if (target.attributes.getNamedItem("composerFocusableElement")) {
                 this.contentHelper.el.focus();
                 return;
@@ -72730,7 +73052,7 @@ stores.inject(MyMetaStore, storeInstance);
             }
             this.selectionStart = start;
             this.selectionEnd = end;
-            this.editionMode = "editing";
+            this.stopComposerRangeSelection();
             this.computeFormulaCursorContext();
             this.computeParenthesisRelatedToCursor();
             this.updateAutoCompleteProvider();
@@ -73443,7 +73765,7 @@ stores.inject(MyMetaStore, storeInstance);
                 let count = tokenIdex;
                 let currentToken = tokenAtCursor;
                 // check previous token
-                while (!["ARG_SEPARATOR", "LEFT_PAREN", "OPERATOR"].includes(currentToken.type) ||
+                while (!["ARG_SEPARATOR", "ARRAY_ROW_SEPARATOR", "LEFT_PAREN", "LEFT_BRACE", "OPERATOR"].includes(currentToken.type) ||
                     POSTFIX_UNARY_OPERATORS.includes(currentToken.value)) {
                     if (currentToken.type !== "SPACE" || count < 1) {
                         return false;
@@ -73455,7 +73777,13 @@ stores.inject(MyMetaStore, storeInstance);
                 currentToken = this.currentTokens[count];
                 // check next token
                 while (currentToken &&
-                    !["ARG_SEPARATOR", "RIGHT_PAREN", "OPERATOR"].includes(currentToken.type)) {
+                    ![
+                        "ARG_SEPARATOR",
+                        "ARRAY_ROW_SEPARATOR",
+                        "RIGHT_PAREN",
+                        "RIGHT_BRACE",
+                        "OPERATOR",
+                    ].includes(currentToken.type)) {
                     if (currentToken.type !== "SPACE") {
                         return false;
                     }
@@ -77094,18 +77422,15 @@ stores.inject(MyMetaStore, storeInstance);
         execute: (env) => env.model.dispatch("UNFREEZE_ROWS", {
             sheetId: env.model.getters.getActiveSheetId(),
         }),
-        isReadonlyAllowed: true,
         isVisible: (env) => !!env.model.getters.getPaneDivisions(env.model.getters.getActiveSheetId()).ySplit,
     };
     const freezeFirstRow = {
         name: _t$1("1 row"),
         execute: (env) => interactiveFreezeColumnsRows(env, "ROW", 1),
-        isReadonlyAllowed: true,
     };
     const freezeSecondRow = {
         name: _t$1("2 rows"),
         execute: (env) => interactiveFreezeColumnsRows(env, "ROW", 2),
-        isReadonlyAllowed: true,
     };
     const freezeCurrentRow = {
         name: _t$1("Up to current row"),
@@ -77113,25 +77438,21 @@ stores.inject(MyMetaStore, storeInstance);
             const { bottom } = env.model.getters.getSelectedZone();
             interactiveFreezeColumnsRows(env, "ROW", bottom + 1);
         },
-        isReadonlyAllowed: true,
     };
     const unFreezeCols = {
         name: _t$1("No columns"),
         execute: (env) => env.model.dispatch("UNFREEZE_COLUMNS", {
             sheetId: env.model.getters.getActiveSheetId(),
         }),
-        isReadonlyAllowed: true,
         isVisible: (env) => !!env.model.getters.getPaneDivisions(env.model.getters.getActiveSheetId()).xSplit,
     };
     const freezeFirstCol = {
         name: _t$1("1 column"),
         execute: (env) => interactiveFreezeColumnsRows(env, "COL", 1),
-        isReadonlyAllowed: true,
     };
     const freezeSecondCol = {
         name: _t$1("2 columns"),
         execute: (env) => interactiveFreezeColumnsRows(env, "COL", 2),
-        isReadonlyAllowed: true,
     };
     const freezeCurrentCol = {
         name: _t$1("Up to current column"),
@@ -77139,7 +77460,6 @@ stores.inject(MyMetaStore, storeInstance);
             const { right } = env.model.getters.getSelectedZone();
             interactiveFreezeColumnsRows(env, "COL", right + 1);
         },
-        isReadonlyAllowed: true,
     };
     const viewGridlines = {
         name: _t$1("Gridlines"),
@@ -79299,6 +79619,8 @@ stores.inject(MyMetaStore, storeInstance);
         let startingY;
         let scrollDirection = "all";
         const getters = env.model.getters;
+        const blockKeyboard = (ev) => ev.preventDefault();
+        const cleanUpBlockKeyboard = () => removeEventListener("keydown", blockKeyboard, { capture: true });
         let cleanUpFns = [];
         const cleanUp = () => {
             clearTimeout(timeOutId);
@@ -79411,7 +79733,9 @@ stores.inject(MyMetaStore, storeInstance);
             };
             pointerMoveCallback = onPointerMove;
             pointerUpCallback = onPointerUp;
-            cleanUpFns.push(startDnd(pointerMoveHandler, pointerUpHandler));
+            // block keyboard events during pointer interaction to avoid conflicts
+            addEventListener("keydown", blockKeyboard, { capture: true });
+            cleanUpFns.push(startDnd(pointerMoveHandler, pointerUpHandler), cleanUpBlockKeyboard);
         };
         owl.onWillUnmount(() => {
             cleanUp();
@@ -81292,6 +81616,10 @@ stores.inject(MyMetaStore, storeInstance);
             }
         }
         _computeGrabDisplay(zoomedMouseEvent) {
+            if (isCtrlKey(zoomedMouseEvent.ev)) {
+                this.state.waitingForMove = false;
+                return;
+            }
             const index = this._getElementIndex(this._getEvOffset(zoomedMouseEvent));
             const activeElements = this._getActiveElements();
             const selectedZoneStart = this._getSelectedZoneStart();
@@ -81385,7 +81713,7 @@ stores.inject(MyMetaStore, storeInstance);
                 this._selectElement(index, false);
                 return;
             }
-            if (this.state.waitingForMove) {
+            if (!isCtrlKey(ev) && this.state.waitingForMove) {
                 if (!this.env.model.getters.isGridSelectionActive()) {
                     this._selectElement(index, false);
                 }
@@ -81467,15 +81795,13 @@ stores.inject(MyMetaStore, storeInstance);
                 }
             };
             const mouseUpSelect = () => {
+                this.env.model.selection.commitSelection();
                 this.state.isSelecting = false;
                 this.lastSelectedElementIndex = null;
                 this._computeGrabDisplay(zoomedMouseEvent);
             };
             this.dragNDropGrid.start(zoomedMouseEvent, mouseMoveSelect, mouseUpSelect);
         }
-        onMouseUp(ev) {
-            this.lastSelectedElementIndex = null;
-        }
         onContextMenu(ev) {
             ev.preventDefault();
             const index = this._getElementIndex(this._getEvOffset(withZoom(this.env, ev)));
@@ -83211,14 +83537,14 @@ stores.inject(MyMetaStore, storeInstance);
         }
         onMouseDown(ev) {
             // Stop the event if the input is not focused, we handle everything in onMouseUp
-            if (ev.target !== document.activeElement) {
+            if (ev.target !== document.activeElement && this.props.selectContentOnFocus) {
                 ev.preventDefault();
                 ev.stopPropagation();
             }
         }
         onMouseUp(ev) {
             const target = ev.target;
-            if (target !== document.activeElement) {
+            if (target !== document.activeElement && this.props.selectContentOnFocus) {
                 target.focus();
                 if (this.props.selectContentOnFocus) {
                     target.select();
@@ -83354,7 +83680,9 @@ stores.inject(MyMetaStore, storeInstance);
         inputRef = owl.useRef("inputNumber");
         rootEditorRef = owl.useRef("NumberEditor");
         valueListRef = owl.useRef("numberList");
+        DOMFocusableElementStore;
         setup() {
+            this.DOMFocusableElementStore = useStore(DOMFocusableElementStore);
             owl.useExternalListener(window, "click", this.onExternalClick, { capture: true });
             owl.onWillUpdateProps((nextProps) => {
                 if (this.inputRef.el && document.activeElement !== this.inputRef.el) {
@@ -83421,6 +83749,13 @@ stores.inject(MyMetaStore, storeInstance);
                 }
                 this.props.onToggle?.();
             }
+            if (ev.key === "Tab") {
+                ev.preventDefault();
+                ev.stopPropagation();
+                this.closeList();
+                this.DOMFocusableElementStore.focus();
+                return;
+            }
         }
     }
 
@@ -83710,6 +84045,16 @@ stores.inject(MyMetaStore, storeInstance);
                 chartId: item.chartId,
             });
         }
+        duplicateCarouselChart(item) {
+            if (item.type !== "chart")
+                return;
+            this.env.model.dispatch("DUPLICATE_CAROUSEL_CHART", {
+                sheetId: this.carouselSheetId,
+                carouselId: this.props.figureId,
+                chartId: item.chartId,
+                duplicatedChartId: this.env.model.uuidGenerator.smallUuid(),
+            });
+        }
         onDragHandleMouseDown(item, event) {
             if (event.button !== 0)
                 return;
@@ -83795,6 +84140,11 @@ stores.inject(MyMetaStore, storeInstance);
                     execute: () => this.popOutCarouselItem(item),
                     icon: "o-spreadsheet-Icon.EXTERNAL",
                 });
+                actions.push({
+                    name: _t$1("Duplicate chart"),
+                    execute: () => this.duplicateCarouselChart(item),
+                    icon: "o-spreadsheet-Icon.COPY",
+                });
             }
             actions.push({
                 name: _t$1("Delete item"),
@@ -86206,8 +86556,9 @@ stores.inject(MyMetaStore, storeInstance);
                     : baseString + minColor + ", " + maxColor + ")";
             }
             else if (rule.type === "DataBarRule") {
-                const color = colorNumberToHex(rule.color);
-                return `background-image: linear-gradient(to right, ${color} 50%, white 50%)`;
+                const barColor = colorNumberToHex(rule.color);
+                const gradient = `background-image: linear-gradient(to right, ${barColor} 50%, white 50%)`;
+                return `${gradient}; color: ${TEXT_BODY};`;
             }
             return "";
         }
@@ -90657,6 +91008,7 @@ stores.inject(MyMetaStore, storeInstance);
                 }
             };
             const onMouseUp = () => {
+                this.env.model.selection.commitSelection();
                 if (this.paintFormatStore.isActive) {
                     this.paintFormatStore.pasteFormat(this.env.model.getters.getSelectedZones());
                 }
@@ -92513,7 +92865,7 @@ stores.inject(MyMetaStore, storeInstance);
                 if (customFormats.length > 0) {
                     customFormats[customFormats.length - 1].separator = true;
                 }
-                return createActions([...numberFormatMenuRegistry.getAll(), ...customFormats]);
+                return [...numberFormatMenuRegistry.getAll(), ...customFormats];
             },
         ],
     };
@@ -92562,7 +92914,6 @@ stores.inject(MyMetaStore, storeInstance);
         .add("file", {
         name: _t$1("File"),
         sequence: 10,
-        isReadonlyAllowed: true,
     })
         .addChild("settings", ["file"], {
         name: _t$1("Settings"),
@@ -92577,7 +92928,6 @@ stores.inject(MyMetaStore, storeInstance);
         .add("edit", {
         name: _t$1("Edit"),
         sequence: 20,
-        isReadonlyAllowed: true,
     })
         .addChild("undo", ["edit"], {
         ...undo,
@@ -92662,7 +93012,6 @@ stores.inject(MyMetaStore, storeInstance);
         .add("view", {
         name: _t$1("View"),
         sequence: 30,
-        isReadonlyAllowed: true,
     })
         .addChild("unfreeze_panes", ["view"], {
         ...unFreezePane,
@@ -92759,7 +93108,6 @@ stores.inject(MyMetaStore, storeInstance);
         .add("insert", {
         name: _t$1("Insert"),
         sequence: 40,
-        isReadonlyAllowed: true,
     })
         .addChild("insert_row", ["insert"], {
         ...insertRow,
@@ -92874,7 +93222,6 @@ stores.inject(MyMetaStore, storeInstance);
         .add("format", {
         name: _t$1("Format"),
         sequence: 50,
-        isReadonlyAllowed: true,
     })
         .addChild("format_number", ["format"], {
         ...formatNumberMenuItemSpec,
@@ -92967,7 +93314,6 @@ stores.inject(MyMetaStore, storeInstance);
         .add("data", {
         name: _t$1("Data"),
         sequence: 60,
-        isReadonlyAllowed: true,
     })
         .addChild("sort_range", ["data"], {
         ...sortRange,
@@ -94037,16 +94383,18 @@ stores.inject(MyMetaStore, storeInstance);
         get clickableCells() {
             const cells = [];
             const getters = this.getters;
-            const sheetId = getters.getActiveSheetId();
             for (const position of this.getters.getVisibleCellPositions()) {
                 const item = this.getClickableItem(position);
                 if (!item) {
                     continue;
                 }
                 const title = typeof item.title === "function" ? item.title(position, getters) : item.title;
-                const zone = getters.expandZone(sheetId, positionToZone(position));
+                const rect = this.getClickableCellRect(position);
+                if (!rect) {
+                    continue;
+                }
                 cells.push({
-                    coordinates: getters.getVisibleRect(zone),
+                    coordinates: rect,
                     position,
                     action: item.execute,
                     title: title || "",
@@ -94056,6 +94404,31 @@ stores.inject(MyMetaStore, storeInstance);
             }
             return cells;
         }
+        getClickableCellRect(position) {
+            const zone = this.getters.expandZone(position.sheetId, positionToZone(position));
+            const clickableRect = this.getters.getVisibleRect(zone);
+            const icons = this.getters.getCellIcons(position);
+            const iconsAtPosition = {
+                center: icons.find((icon) => icon.horizontalAlign === "center"),
+                left: icons.find((icon) => icon.horizontalAlign === "left"),
+                right: icons.find((icon) => icon.horizontalAlign === "right"),
+            };
+            if (iconsAtPosition.center?.onClick) {
+                return undefined;
+            }
+            if (iconsAtPosition.right?.onClick) {
+                const cellRect = this.getters.getRect(zone);
+                const iconRect = this.getters.getCellIconRect(iconsAtPosition.right, cellRect);
+                clickableRect.width -= iconRect.width + iconsAtPosition.right.margin;
+            }
+            if (iconsAtPosition.left?.onClick) {
+                const cellRect = this.getters.getRect(zone);
+                const iconRect = this.getters.getCellIconRect(iconsAtPosition.left, cellRect);
+                clickableRect.x += iconRect.width + iconsAtPosition.left.margin;
+                clickableRect.width -= iconRect.width + iconsAtPosition.left.margin;
+            }
+            return clickableRect;
+        }
     }
 
     class SpreadsheetDashboard extends owl.Component {
@@ -94647,7 +95020,7 @@ stores.inject(MyMetaStore, storeInstance);
                     height: this.focus === "inactive" ? "26px" : "fit-content",
                     "max-height": `130px`,
                 }),
-                showAssistant: !isIOS(), // Hide assistant on iOS as it breaks visually
+                showAssistant: false, // Hide assistant in small composer as it gets cropped ATM
                 placeholder: this.composerStore.placeholder,
             };
         }
@@ -95887,12 +96260,10 @@ stores.inject(MyMetaStore, storeInstance);
     }
 
     function checkDateGranularity(definition) {
-        if (definition.horizontalGroupBy &&
-            !CALENDAR_CHART_GRANULARITIES.includes(definition.horizontalGroupBy)) {
+        if (!CALENDAR_CHART_GRANULARITIES.includes(definition.horizontalGroupBy)) {
             return "InvalidChartDefinition" /* CommandResult.InvalidChartDefinition */;
         }
-        if (definition.verticalGroupBy &&
-            !CALENDAR_CHART_GRANULARITIES.includes(definition.verticalGroupBy)) {
+        if (!CALENDAR_CHART_GRANULARITIES.includes(definition.verticalGroupBy)) {
             return "InvalidChartDefinition" /* CommandResult.InvalidChartDefinition */;
         }
         return "Success" /* CommandResult.Success */;
@@ -95917,8 +96288,8 @@ stores.inject(MyMetaStore, storeInstance);
             this.showValues = definition.showValues;
             this.colorScale = definition.colorScale;
             this.axesDesign = definition.axesDesign;
-            this.horizontalGroupBy = definition.horizontalGroupBy ?? "day_of_week";
-            this.verticalGroupBy = definition.verticalGroupBy ?? "month_number";
+            this.horizontalGroupBy = definition.horizontalGroupBy;
+            this.verticalGroupBy = definition.verticalGroupBy;
             this.legendPosition = definition.legendPosition;
             this.missingValueColor = definition.missingValueColor;
         }
@@ -95943,6 +96314,8 @@ stores.inject(MyMetaStore, storeInstance);
                 showValues: context.showValues,
                 axesDesign: context.axesDesign,
                 legendPosition,
+                horizontalGroupBy: "day_of_week",
+                verticalGroupBy: "month_number",
             };
         }
         getContextCreation() {
@@ -96009,7 +96382,7 @@ stores.inject(MyMetaStore, storeInstance);
         const chartData = getCalendarChartData(definition, chart.dataSets, chart.labelRange, getters);
         const { labels, datasets } = getCalendarChartDatasetAndLabels(definition, chartData);
         const config = {
-            type: "bar",
+            type: "calendar",
             data: {
                 labels,
                 datasets,
@@ -96026,6 +96399,7 @@ stores.inject(MyMetaStore, storeInstance);
                     chartShowValuesPlugin: getCalendarChartShowValues(definition, chartData),
                     chartColorScalePlugin: getCalendarColorScale(definition, chartData),
                 },
+                chartBackground: definition.background || BACKGROUND_CHART_COLOR,
             },
         };
         return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
@@ -98430,6 +98804,7 @@ stores.inject(MyMetaStore, storeInstance);
         isNumber: isNumber$1,
         isDateTime,
         createCustomFields,
+        schemeToColorScale,
     };
     const links = {
         isMarkdownLink,
@@ -98599,9 +98974,9 @@ stores.inject(MyMetaStore, storeInstance);
     exports.tokenize = tokenize;
 
 
-    __info__.version = "19.1.0-alpha.13";
-    __info__.date = "2025-11-24T07:53:14.109Z";
-    __info__.hash = "e232982";
+    __info__.version = "19.1.0-alpha.14";
+    __info__.date = "2025-12-02T05:34:46.718Z";
+    __info__.hash = "04cf666";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);