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

package/dist/o-spreadsheet-engine.iife.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
  */
 
 (function (exports) {
@@ -637,6 +637,7 @@
       fontSize: 10,
       fillColor: "",
       textColor: "",
+      rotation: 0,
   };
   const DEFAULT_VERTICAL_ALIGN = DEFAULT_STYLE.verticalAlign;
   // Fonts
@@ -682,7 +683,7 @@
   };
   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
@@ -3108,8 +3109,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("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."),
@@ -3135,6 +3184,30 @@
       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 = {
@@ -3280,20 +3353,7 @@
       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,
   };
@@ -3552,22 +3612,7 @@
       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,
   };
@@ -3627,6 +3672,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,
@@ -3648,6 +3695,30 @@
     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 = [];
@@ -3932,7 +4003,7 @@
   }
   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 &&
@@ -4169,6 +4240,9 @@
       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 ? "%" : "");
       }
@@ -4775,7 +4849,7 @@
   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) {
@@ -6055,6 +6129,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 isSheetDependent(cmd) {
       return "sheetId" in cmd;
@@ -6085,7 +6200,6 @@
       "REDO",
       "ADD_MERGE",
       "REMOVE_MERGE",
-      "DUPLICATE_SHEET",
       "UPDATE_LOCALE",
       "ADD_PIVOT",
       "UPDATE_PIVOT",
@@ -7652,7 +7766,7 @@
                   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 }));
                       }
@@ -9547,30 +9661,6 @@
     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
    *
@@ -9599,7 +9689,9 @@
       while (!chars.isOver()) {
           let token = tokenizeNewLine(chars) ||
               tokenizeSpace(chars) ||
+              tokenizeArrayRowSeparator(chars, locale) ||
               tokenizeArgsSeparator(chars, locale) ||
+              tokenizeBraces(chars) ||
               tokenizeParenthesis(chars) ||
               tokenizeOperator(chars) ||
               tokenizeString(chars) ||
@@ -9632,6 +9724,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();
@@ -9640,6 +9743,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)) {
@@ -9860,6 +9977,9 @@
           else if (token.type === "ARG_SEPARATOR") {
               localizedFormula += toLocale.formulaArgSeparator;
           }
+          else if (token.type === "ARRAY_ROW_SEPARATOR") {
+              localizedFormula += toLocale.formulaArgSeparator === ";" ? "\\" : ";";
+          }
           else {
               localizedFormula += token.value;
           }
@@ -11023,7 +11143,6 @@
   // -----------------------------------------------------------------------------
   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.")),
@@ -13975,18 +14094,17 @@
           ["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"),
       },
   });
   ({
@@ -17224,6 +17342,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)) {
@@ -17277,6 +17397,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("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();
@@ -17367,6 +17515,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;
@@ -17384,6 +17539,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,
@@ -17542,6 +17702,23 @@
                       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();
@@ -18821,6 +18998,17 @@
           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.
@@ -25873,6 +26061,17 @@
       }
   }
 
+  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
@@ -26516,6 +26715,29 @@
           }
           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 || []) {
@@ -26772,18 +26994,22 @@
       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;
               }
           });
       }
@@ -27316,22 +27542,34 @@
       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;
@@ -29811,7 +30049,8 @@
                   }
                   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;
@@ -32144,10 +32383,17 @@
               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 });
                   }
               }
           }
@@ -33179,6 +33425,9 @@
                   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,
@@ -33218,6 +33467,13 @@
           "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":
@@ -33442,6 +33698,28 @@
       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 {
@@ -36469,48 +36747,64 @@
   }
   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 };
@@ -38707,7 +39001,8 @@
                   }
                   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);
@@ -38864,6 +39159,10 @@
                   ? `(${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)})`
@@ -40428,7 +40727,6 @@
   pivotRegistry.add("SPREADSHEET", {
       ui: SpreadsheetPivot,
       definition: SpreadsheetPivotRuntimeDefinition,
-      externalData: false,
       dateGranularities: [...dateGranularities],
       datetimeGranularities: [...dateGranularities, "hour_number", "minute_number", "second_number"],
       isMeasureCandidate: (field) => field.type !== "boolean",
@@ -40470,9 +40768,7 @@
       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) {
@@ -40686,7 +40982,7 @@
           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 });
@@ -43484,6 +43780,7 @@
           "getTextWidth",
           "getCellText",
           "getCellMultiLineText",
+          "getMultilineTextSize",
           "getContiguousZone",
           "computeTextYCoordinate",
       ];
@@ -43534,7 +43831,7 @@
           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;
@@ -43555,6 +43852,9 @@
       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();
@@ -43753,6 +44053,15 @@
                       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 */;
@@ -43777,6 +44086,9 @@
               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;
@@ -43915,6 +44227,29 @@
           });
           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";
       }
@@ -45130,25 +45465,43 @@
           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;
@@ -45428,7 +45781,7 @@
       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.
@@ -46138,6 +46491,7 @@
           "getGridOffset",
           "getViewportZoomLevel",
           "getScrollBarWidth",
+          "getMaximumSheetOffset",
       ];
       viewports = {};
       /**
@@ -47243,6 +47597,9 @@
       observe(owner, callbacks) {
           this.observers.set(owner, { owner, callbacks });
       }
+      unobserve(owner) {
+          this.observers.delete(owner);
+      }
       /**
        * Capture the stream for yourself
        */
@@ -47335,6 +47692,9 @@
       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);
@@ -47393,6 +47753,9 @@
               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",
@@ -47413,6 +47776,22 @@
               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
@@ -50927,8 +51306,8 @@
 
 
   __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";
 
 
 })(this.o_spreadsheet_engine = this.o_spreadsheet_engine || {});