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

package/dist/o-spreadsheet-engine.esm.js

@@ -3,8 +3,8 @@
  * 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.3
- * @date 2025-11-12T14:16:26.552Z
- * @hash 6fefc9c
+ * @date 2025-12-02T05:34:07.213Z
+ * @hash 04cf666
  */
 
 class FunctionCodeBuilder {
@@ -634,6 +634,7 @@ const DEFAULT_STYLE = {
     fontSize: 10,
     fillColor: "",
     textColor: "",
+    rotation: 0,
 };
 const DEFAULT_VERTICAL_ALIGN = DEFAULT_STYLE.verticalAlign;
 // Fonts
@@ -679,7 +680,7 @@ const PIVOT_TABLE_CONFIG = {
 };
 const PIVOT_INDENT = 15;
 const PIVOT_COLLAPSE_ICON_SIZE = 12;
-const PIVOT_MAX_NUMBER_OF_CELLS = 1e5;
+const PIVOT_MAX_NUMBER_OF_CELLS = 5e5;
 
 //------------------------------------------------------------------------------
 // Miscellaneous
@@ -3105,8 +3106,56 @@ function isMultipleElementMatrix(arg) {
     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("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("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("Returns a result array constrained to a specific width and height."),
@@ -3132,6 +3181,30 @@ const ARRAY_CONSTRAIN = {
     isExported: false,
 };
 // -----------------------------------------------------------------------------
+// ARRAY.LITERAL
+// -----------------------------------------------------------------------------
+const ARRAY_LITERAL = {
+    description: _t("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("The range to be appended."))],
+    compute: function (...ranges) {
+        return stackVertically(ranges, { requireSameColCount: true });
+    },
+    isExported: false,
+    hidden: true,
+};
+// -----------------------------------------------------------------------------
+// ARRAY.ROW
+// -----------------------------------------------------------------------------
+const ARRAY_ROW = {
+    description: _t("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("The range to be appended."))],
+    compute: function (...ranges) {
+        return stackHorizontally(ranges, { requireSameRowCount: true });
+    },
+    isExported: false,
+    hidden: true,
+};
+// -----------------------------------------------------------------------------
 // CHOOSECOLS
 // -----------------------------------------------------------------------------
 const CHOOSECOLS = {
@@ -3277,20 +3350,7 @@ const HSTACK = {
     description: _t("Appends ranges horizontally and in sequence to return a larger array."),
     args: [arg("range (any, range<any>, repeating)", _t("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,
 };
@@ -3549,22 +3609,7 @@ const VSTACK = {
     description: _t("Appends ranges vertically and in sequence to return a larger array."),
     args: [arg("range (any, range<any>, repeating)", _t("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,
 };
@@ -3624,6 +3669,8 @@ const WRAPROWS = {
 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,
@@ -3645,6 +3692,30 @@ var array = /*#__PURE__*/Object.freeze({
   WRAPROWS: WRAPROWS
 });
 
+const DEFAULT_LOCALES = [
+    {
+        name: "English (US)",
+        code: "en_US",
+        thousandsSeparator: ",",
+        decimalSeparator: ".",
+        weekStart: 7, // Sunday
+        dateFormat: "m/d/yyyy",
+        timeFormat: "hh:mm:ss a",
+        formulaArgSeparator: ",",
+    },
+    {
+        name: "French",
+        code: "fr_FR",
+        thousandsSeparator: " ",
+        decimalSeparator: ",",
+        weekStart: 1, // Monday
+        dateFormat: "dd/mm/yyyy",
+        timeFormat: "hh:mm:ss",
+        formulaArgSeparator: ";",
+    },
+];
+const DEFAULT_LOCALE = DEFAULT_LOCALES[0];
+
 function tokenizeFormat(str) {
     const chars = new TokenizingChars(str);
     const result = [];
@@ -3929,7 +4000,7 @@ function parseNumberFormatTokens(tokens) {
 }
 function parseDateFormatTokens(tokens) {
     const internalFormat = tokens && areValidDateFormatTokens(tokens) ? { type: "date", tokens } : undefined;
-    if (!internalFormat) {
+    if (!internalFormat || !tokens?.some((token) => token.type === "DATE_PART")) {
         return undefined;
     }
     if (internalFormat.tokens.length &&
@@ -4166,6 +4237,9 @@ function repeatCharToFitWidth(formattedValue, formatWidth) {
     return prefix + repeatedChar.repeat(timesToRepeat) + padding + suffix;
 }
 function applyInternalNumberFormat(value, format, locale) {
+    if (!format.integerPart.length && !format.decimalPart?.length) {
+        return "";
+    }
     if (value === Infinity) {
         return "∞" + (format.percentSymbols ? "%" : "");
     }
@@ -4772,7 +4846,7 @@ function getTokenNextReferenceType(xc) {
 function setXcToFixedReferenceType(xc, referenceType) {
     let sheetName;
     ({ sheetName, xc } = splitReference(xc));
-    sheetName = sheetName ? sheetName + "!" : "";
+    sheetName = sheetName ? getCanonicalSymbolName(sheetName) + "!" : "";
     xc = xc.replace(/\$/g, "");
     const splitIndex = xc.indexOf(":");
     if (splitIndex >= 0) {
@@ -6052,6 +6126,47 @@ function splitIfAdjacent(zone, zoneToRemove) {
             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 isSheetDependent(cmd) {
     return "sheetId" in cmd;
@@ -6082,7 +6197,6 @@ const invalidateEvaluationCommands = new Set([
     "REDO",
     "ADD_MERGE",
     "REMOVE_MERGE",
-    "DUPLICATE_SHEET",
     "UPDATE_LOCALE",
     "ADD_PIVOT",
     "UPDATE_PIVOT",
@@ -7649,7 +7763,7 @@ const SUBTOTAL = {
                 if (!acceptHiddenCells && this.getters.isRowHiddenByUser(sheetId, row))
                     continue;
                 for (let col = left; col <= right; col++) {
-                    const cell = this.getters.getCell({ sheetId, col, row });
+                    const cell = this.getters.getCorrespondingFormulaCell({ sheetId, col, row });
                     if (!cell || !isSubtotalCell(cell)) {
                         evaluatedCellToKeep.push(this.getters.getEvaluatedCell({ sheetId, col, row }));
                     }
@@ -9544,30 +9658,6 @@ var database = /*#__PURE__*/Object.freeze({
   DVARP: DVARP
 });
 
-const DEFAULT_LOCALES = [
-    {
-        name: "English (US)",
-        code: "en_US",
-        thousandsSeparator: ",",
-        decimalSeparator: ".",
-        weekStart: 7, // Sunday
-        dateFormat: "m/d/yyyy",
-        timeFormat: "hh:mm:ss a",
-        formulaArgSeparator: ",",
-    },
-    {
-        name: "French",
-        code: "fr_FR",
-        thousandsSeparator: " ",
-        decimalSeparator: ",",
-        weekStart: 1, // Monday
-        dateFormat: "dd/mm/yyyy",
-        timeFormat: "hh:mm:ss",
-        formulaArgSeparator: ";",
-    },
-];
-const DEFAULT_LOCALE = DEFAULT_LOCALES[0];
-
 /**
  * Tokenizer
  *
@@ -9596,7 +9686,9 @@ function tokenize(str, locale = DEFAULT_LOCALE) {
     while (!chars.isOver()) {
         let token = tokenizeNewLine(chars) ||
             tokenizeSpace(chars) ||
+            tokenizeArrayRowSeparator(chars, locale) ||
             tokenizeArgsSeparator(chars, locale) ||
+            tokenizeBraces(chars) ||
             tokenizeParenthesis(chars) ||
             tokenizeOperator(chars) ||
             tokenizeString(chars) ||
@@ -9629,6 +9721,17 @@ function tokenizeParenthesis(chars) {
     }
     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();
@@ -9637,6 +9740,20 @@ function tokenizeArgsSeparator(chars, locale) {
     }
     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)) {
@@ -9857,6 +9974,9 @@ function _localizeFormula(formula, fromLocale, toLocale) {
         else if (token.type === "ARG_SEPARATOR") {
             localizedFormula += toLocale.formulaArgSeparator;
         }
+        else if (token.type === "ARRAY_ROW_SEPARATOR") {
+            localizedFormula += toLocale.formulaArgSeparator === ";" ? "\\" : ";";
+        }
         else {
             localizedFormula += token.value;
         }
@@ -11020,7 +11140,6 @@ function sortMatrix(matrix, locale, ...criteria) {
 // -----------------------------------------------------------------------------
 const FILTER = {
     description: _t("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("The data to be filtered.")),
         arg("condition (boolean, range<boolean>, repeating)", _t("Column or row containing true or false values corresponding to the range.")),
@@ -13972,18 +14091,17 @@ var logical = /*#__PURE__*/Object.freeze({
         ["GaugeLowerInflectionPointNaN" /* CommandResult.GaugeLowerInflectionPointNaN */]: _t("The lower inflection point value must be a number"),
         ["GaugeUpperInflectionPointNaN" /* CommandResult.GaugeUpperInflectionPointNaN */]: _t("The upper inflection point value must be a number"),
     },
-    GeoChart: {
-        ColorScales: {
-            blues: _t("Blues"),
-            cividis: _t("Cividis"),
-            greens: _t("Greens"),
-            greys: _t("Greys"),
-            oranges: _t("Oranges"),
-            purples: _t("Purples"),
-            rainbow: _t("Rainbow"),
-            reds: _t("Reds"),
-            viridis: _t("Viridis"),
-        },
+    ColorScales: {
+        blues: _t("Blues"),
+        cividis: _t("Cividis"),
+        custom: _t("Custom"),
+        greens: _t("Greens"),
+        greys: _t("Greys"),
+        oranges: _t("Oranges"),
+        purples: _t("Purples"),
+        rainbow: _t("Rainbow"),
+        reds: _t("Reds"),
+        viridis: _t("Viridis"),
     },
 });
 ({
@@ -17221,6 +17339,8 @@ function parseOperand(tokens) {
                 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)) {
@@ -17274,6 +17394,34 @@ function consumeOrThrow(tokens, type, message) {
     }
     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("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("Unexpected token: %s", nextToken.value));
+        }
+    }
+    const rightBrace = consumeOrThrow(tokens, "RIGHT_BRACE", _t("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();
@@ -17364,6 +17512,13 @@ function* astIterator(ast) {
                 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;
@@ -17381,6 +17536,11 @@ function mapAst(ast, fn) {
                 ...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,
@@ -17539,6 +17699,23 @@ function compileTokensOrThrow(tokens) {
                     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();
@@ -18818,6 +18995,17 @@ class AlternatingColorMap {
         return this.colors[id];
     }
 }
+const COLORSCHEMES = {
+    greys: ["#ffffff", "#808080", "#000000"],
+    blues: ["#f7fbff", "#6aaed6", "#08306b"],
+    reds: ["#fff5f0", "#fb694a", "#67000d"],
+    greens: ["#f7fcf5", "#73c476", "#00441b"],
+    oranges: ["#fff5eb", "#fd8c3b", "#7f2704"],
+    purples: ["#fcfbfd", "#9e9ac8", "#3f007d"],
+    viridis: ["#440154", "#21918c", "#fde725"],
+    cividis: ["#00224e", "#7d7c78", "#fee838"],
+    rainbow: ["#B41DB4", "#FFFF00", "#00FFFF"],
+};
 /**
  * Returns a function that maps a value to a color using a color scale defined by the given
  * color/threshold values pairs.
@@ -25870,6 +26058,17 @@ class XlsxReader {
     }
 }
 
+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],
+        };
+}
+
 /**
  * parses a formula (as a string) into the same formula,
  * but with the references to other cells extracted
@@ -26513,6 +26712,29 @@ migrationStepRegistry
         }
         return data;
     },
+})
+    .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 = 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);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return data;
+    },
 });
 function fixOverlappingFilters(data) {
     for (const sheet of data.sheets || []) {
@@ -26769,18 +26991,22 @@ function dropCommands(initialMessages, commandType) {
     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;
             }
         });
     }
@@ -27313,22 +27539,34 @@ class BordersPlugin extends CorePlugin {
     addBorder(sheetId, zone, newBorder, force = false) {
         const borders = [];
         const plannedBorder = newBorder ? { zone, style: newBorder } : undefined;
-        const sideToClear = {
-            left: force || !!newBorder?.left,
-            right: force || !!newBorder?.right,
-            top: force || !!newBorder?.top,
-            bottom: force || !!newBorder?.bottom,
+        // For each side, decide if we must clear the border on the *adjacent*
+        // existing cell when we draw on the opposite side of the new zone.
+        //
+        // Example:
+        //  - newBorder.right is set → we draw border on the RIGHT side of `zone`
+        //  - the cell on the right may already have a LEFT border on that edge
+        // In that case we clear that LEFT border, so only the new RIGHT border
+        // remains on the shared edge.
+        //
+        // existingBorderSideToClear[side] = true means we should clear the border on that
+        // side of the existing adjacent zone before adding the new border.
+        const existingBorderSideToClear = {
+            left: force || !!newBorder?.right,
+            right: force || !!newBorder?.left,
+            top: force || !!newBorder?.bottom,
+            bottom: force || !!newBorder?.top,
         };
         let editingZone = [zone];
         for (const existingBorder of this.borders[sheetId] ?? []) {
             const inter = intersection(existingBorder.zone, zone);
             if (!inter) {
-                // Clear adjacent borders on which you write
+                // Check if the existing border is adjacent to the new zone
                 const adjacentEdge = adjacent(existingBorder.zone, zone);
-                if (adjacentEdge && sideToClear[adjacentEdge.position]) {
+                if (adjacentEdge && existingBorderSideToClear[adjacentEdge.position]) {
                     for (const newZone of splitIfAdjacent(existingBorder.zone, zone)) {
                         const border = this.computeBorderFromZone(newZone, existingBorder);
                         const adjacentEdge = adjacent(newZone, zone);
+                        // Clear the existing border on the side that touches the new zone
                         switch (adjacentEdge?.position) {
                             case "left":
                                 border.style.left = undefined;
@@ -29808,7 +30046,8 @@ class FigurePlugin extends CorePlugin {
                 }
                 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;
@@ -32141,10 +32380,17 @@ class PivotCorePlugin extends CorePlugin {
             if (!pivot) {
                 continue;
             }
-            for (const measure of pivot.definition.measures) {
+            const def = deepCopy(pivot.definition);
+            for (const measure of def.measures) {
                 if (measure.computedBy?.formula === formulaString) {
-                    const measureIndex = pivot.definition.measures.indexOf(measure);
-                    this.history.update("pivots", pivotId, "definition", "measures", measureIndex, "computedBy", { formula: newFormulaString, sheetId });
+                    const measureIndex = def.measures.indexOf(measure);
+                    if (measureIndex !== -1) {
+                        def.measures[measureIndex].computedBy = {
+                            formula: newFormulaString,
+                            sheetId,
+                        };
+                    }
+                    this.dispatch("UPDATE_PIVOT", { pivotId, pivot: def });
                 }
             }
         }
@@ -33176,6 +33422,9 @@ class SpreadsheetPivotCorePlugin extends CorePlugin {
                 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,
@@ -33215,6 +33464,13 @@ class StylePlugin extends CorePlugin {
         "getStyleColors",
     ];
     styles = {};
+    allowDispatch(cmd) {
+        switch (cmd.type) {
+            case "SET_FORMATTING":
+                return this.checkUselessSetFormatting(cmd);
+        }
+        return "Success" /* CommandResult.Success */;
+    }
     handle(cmd) {
         switch (cmd.type) {
             case "ADD_MERGE":
@@ -33439,6 +33695,28 @@ class StylePlugin extends CorePlugin {
     exportForExcel(data) {
         this.export(data);
     }
+    checkUselessSetFormatting(cmd) {
+        const { sheetId, target } = cmd;
+        const hasStyle = "style" in cmd;
+        const hasFormat = "format" in cmd;
+        if (!hasStyle && !hasFormat) {
+            return "NoChanges" /* CommandResult.NoChanges */;
+        }
+        for (const zone of recomputeZones(target)) {
+            for (let col = zone.left; col <= zone.right; col++) {
+                for (let row = zone.top; row <= zone.bottom; row++) {
+                    const position = { sheetId, col, row };
+                    const cell = this.getters.getCell(position);
+                    const style = this.getCellStyle(position);
+                    if ((hasStyle && !deepEquals(style, cmd.style)) ||
+                        (hasFormat && cell?.format !== cmd.format)) {
+                        return "Success" /* CommandResult.Success */;
+                    }
+                }
+            }
+        }
+        return "NoChanges" /* CommandResult.NoChanges */;
+    }
 }
 
 class TableStylePlugin extends CorePlugin {
@@ -36466,48 +36744,64 @@ function getDefaultCellHeight(ctx, cell, style, colSize) {
 }
 function getCellContentHeight(ctx, content, style, colSize) {
     const maxWidth = style?.wrapping === "wrap" ? colSize - 2 * MIN_CELL_TEXT_MARGIN : undefined;
-    const numberOfLines = splitTextToWidth(ctx, content, style, maxWidth).length;
-    const fontSize = computeTextFontSizeInPixels(style);
-    return computeTextLinesHeight(fontSize, numberOfLines) + 2 * PADDING_AUTORESIZE_VERTICAL;
+    const lines = splitTextToWidth(ctx, content, style, maxWidth);
+    return computeMultilineTextSize(ctx, lines, style).height + 2 * PADDING_AUTORESIZE_VERTICAL;
 }
 function getDefaultContextFont(fontSize, bold = false, italic = false) {
     const italicStr = italic ? "italic" : "";
     const weight = bold ? "bold" : "";
     return `${italicStr} ${weight} ${fontSize}px ${DEFAULT_FONT}`;
 }
-const textWidthCache = {};
-function computeTextWidth(context, text, style, fontUnit = "pt") {
+function computeMultilineTextSize(context, textLines, style = {}, fontUnit = "pt") {
+    if (!textLines.length)
+        return { width: 0, height: 0 };
     const font = computeTextFont(style, fontUnit);
-    return computeCachedTextWidth(context, text, font);
-}
-function computeCachedTextWidth(context, text, font) {
-    if (!textWidthCache[font]) {
-        textWidthCache[font] = {};
+    const sizes = textLines.map((line) => computeCachedTextDimension(context, line, font));
+    const height = computeTextLinesHeight(sizes[0].height, textLines.length);
+    const width = Math.max(...sizes.map((size) => size.width));
+    if (!style.rotation) {
+        return { height, width };
     }
-    if (textWidthCache[font][text] === undefined) {
-        const oldFont = context.font;
-        context.font = font;
-        textWidthCache[font][text] = context.measureText(text).width;
-        context.font = oldFont;
+    const cos = Math.abs(Math.cos(style.rotation));
+    const sin = Math.abs(Math.sin(style.rotation));
+    return { width: width * cos + height * sin, height: sin * width + cos * height };
+}
+function computeTextWidth(context, text, style = {}, fontUnit = "pt") {
+    const font = computeTextFont(style, fontUnit);
+    return computeCachedTextWidth(context, text, font, style.rotation);
+}
+function computeCachedTextWidth(context, text, font, rotation) {
+    const size = computeCachedTextDimension(context, text, font);
+    if (!rotation) {
+        return size.width;
     }
-    return textWidthCache[font][text];
+    const cos = Math.abs(Math.cos(rotation));
+    const sin = Math.abs(Math.sin(rotation));
+    return size.width * cos + size.height * sin;
 }
 const textDimensionsCache = {};
 function computeTextDimension(context, text, style, fontUnit = "pt") {
     const font = computeTextFont(style, fontUnit);
-    context.save();
-    context.font = font;
-    const dimensions = computeCachedTextDimension(context, text);
-    context.restore();
-    return dimensions;
-}
-function computeCachedTextDimension(context, text) {
-    const font = context.font;
+    const size = computeCachedTextDimension(context, text, font);
+    if (!style.rotation) {
+        return size;
+    }
+    const cos = Math.abs(Math.cos(style.rotation));
+    const sin = Math.abs(Math.sin(style.rotation));
+    return {
+        width: size.width * cos + size.height * sin,
+        height: size.height * cos + size.width * sin,
+    };
+}
+function computeCachedTextDimension(context, text, font) {
     if (!textDimensionsCache[font]) {
         textDimensionsCache[font] = {};
     }
     if (textDimensionsCache[font][text] === undefined) {
+        context.save();
+        context.font = font;
         const measure = context.measureText(text);
+        context.restore();
         const width = measure.width;
         const height = measure.fontBoundingBoxAscent + measure.fontBoundingBoxDescent;
         textDimensionsCache[font][text] = { width, height };
@@ -38704,7 +38998,8 @@ class HeaderSizeUIPlugin extends CoreViewPlugin {
                 }
                 break;
             case "SET_FORMATTING":
-                if (cmd.style && ("fontSize" in cmd.style || "wrapping" in cmd.style)) {
+                if (cmd.style &&
+                    ("fontSize" in cmd.style || "wrapping" in cmd.style || "rotation" in cmd.style)) {
                     for (const zone of cmd.target) {
                         // TODO FLDA use rangeSet
                         this.updateRowSizeForZoneChange(cmd.sheetId, zone);
@@ -38861,6 +39156,10 @@ function astToFormula(ast) {
                 ? `(${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)})`
@@ -40425,7 +40724,6 @@ const dateGranularities = [
 pivotRegistry.add("SPREADSHEET", {
     ui: SpreadsheetPivot,
     definition: SpreadsheetPivotRuntimeDefinition,
-    externalData: false,
     dateGranularities: [...dateGranularities],
     datetimeGranularities: [...dateGranularities, "hour_number", "minute_number", "second_number"],
     isMeasureCandidate: (field) => field.type !== "boolean",
@@ -40467,9 +40765,7 @@ class PivotUIPlugin extends CoreViewPlugin {
     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) {
@@ -40683,7 +40979,7 @@ class PivotUIPlugin extends CoreViewPlugin {
         pivot.init({ reload: true });
     }
     setupPivot(pivotId, { recreate } = { recreate: false }) {
-        const definition = this.getters.getPivotCoreDefinition(pivotId);
+        const definition = deepCopy(this.getters.getPivotCoreDefinition(pivotId));
         if (!(pivotId in this.pivots)) {
             const Pivot = withPivotPresentationLayer(pivotRegistry.get(definition.type).ui);
             this.pivots[pivotId] = new Pivot(this.custom, { definition, getters: this.getters });
@@ -43481,6 +43777,7 @@ class SheetUIPlugin extends UIPlugin {
         "getTextWidth",
         "getCellText",
         "getCellMultiLineText",
+        "getMultilineTextSize",
         "getContiguousZone",
         "computeTextYCoordinate",
     ];
@@ -43531,7 +43828,7 @@ class SheetUIPlugin extends UIPlugin {
         const content = this.getters.getEvaluatedCell(position).formattedValue;
         if (content) {
             const multiLineText = splitTextToWidth(this.ctx, content, style, undefined);
-            contentWidth += Math.max(...multiLineText.map((line) => computeTextWidth(this.ctx, line, style)));
+            contentWidth += computeMultilineTextSize(this.ctx, multiLineText, style).width;
         }
         for (const icon of this.getters.getCellIcons(position)) {
             contentWidth += icon.margin + icon.size;
@@ -43552,6 +43849,9 @@ class SheetUIPlugin extends UIPlugin {
     getTextWidth(text, style) {
         return computeTextWidth(this.ctx, text, style);
     }
+    getMultilineTextSize(text, style) {
+        return computeMultilineTextSize(this.ctx, text, style);
+    }
     getCellText(position, args) {
         const cell = this.getters.getCell(position);
         const locale = this.getters.getLocale();
@@ -43750,6 +44050,15 @@ class CarouselUIPlugin extends UIPlugin {
                     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 */;
@@ -43774,6 +44083,9 @@ class CarouselUIPlugin extends UIPlugin {
             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;
@@ -43912,6 +44224,29 @@ class CarouselUIPlugin extends UIPlugin {
         });
         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";
     }
@@ -45127,25 +45462,43 @@ class GridSelectionPlugin extends UIPlugin {
         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(this.gridSelection.anchor));
         const { col, row } = this.gridSelection.anchor.cell;
@@ -45425,7 +45778,7 @@ class GridSelectionPlugin extends UIPlugin {
     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.
@@ -46135,6 +46488,7 @@ class SheetViewPlugin extends UIPlugin {
         "getGridOffset",
         "getViewportZoomLevel",
         "getScrollBarWidth",
+        "getMaximumSheetOffset",
     ];
     viewports = {};
     /**
@@ -47240,6 +47594,9 @@ class EventStream {
     observe(owner, callbacks) {
         this.observers.set(owner, { owner, callbacks });
     }
+    unobserve(owner) {
+        this.observers.delete(owner);
+    }
     /**
      * Capture the stream for yourself
      */
@@ -47332,6 +47689,9 @@ class SelectionStreamProcessorImpl {
     observe(owner, callbacks) {
         this.stream.observe(owner, callbacks);
     }
+    unobserve(owner) {
+        this.stream.unobserve(owner);
+    }
     release(owner) {
         if (this.stream.isListening(owner)) {
             this.stream.release(owner);
@@ -47390,6 +47750,9 @@ class SelectionStreamProcessorImpl {
             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",
@@ -47410,6 +47773,22 @@ class SelectionStreamProcessorImpl {
             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
@@ -50816,5 +51195,5 @@ export { BadExpressionError, BasePlugin, CellErrorType, CircularDependencyError,
 
 
 __info__.version = "19.1.0-alpha.3";
-__info__.date = "2025-11-12T14:16:26.552Z";
-__info__.hash = "6fefc9c";
+__info__.date = "2025-12-02T05:34:07.213Z";
+__info__.hash = "04cf666";