@odoo/o-spreadsheet 18.5.0-alpha.10 → 18.5.0-alpha.12

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 18.5.0-alpha.10
- * @date 2025-08-21T06:42:10.830Z
- * @hash 5800d1b
+ * @version 18.5.0-alpha.12
+ * @date 2025-08-29T08:05:09.767Z
+ * @hash 8ee7677
  */
 
 (function (exports, owl) {
@@ -724,7 +724,7 @@
   /*
    * Concatenate an array of strings.
    */
-  function concat(chars) {
+  function concat$1(chars) {
       // ~40% faster than chars.join("")
       let output = "";
       for (let i = 0, len = chars.length; i < len; i++) {
@@ -1196,7 +1196,7 @@
       if (alphaHex !== 255) {
           vals.push(alphaHex);
       }
-      return "#" + concat(vals.map((value) => value.toString(16).padStart(2, "0"))).toUpperCase();
+      return "#" + concat$1(vals.map((value) => value.toString(16).padStart(2, "0"))).toUpperCase();
   }
   /**
    * RGBA to HEX representation (#RRGGBBAA).
@@ -1346,6 +1346,18 @@
   function hexToHSLA(hex) {
       return rgbaToHSLA(colorToRGBA(hex));
   }
+  /**
+   * Blend color2 on top of color1, with alpha blending.
+   */
+  function blendColors(color1, color2) {
+      const rgba2 = colorToRGBA(color2);
+      const rgba1 = colorToRGBA(color1);
+      const a = rgba2.a + rgba1.a * (1 - rgba2.a);
+      const r = Math.round((rgba2.r * rgba2.a + rgba1.r * rgba1.a * (1 - rgba2.a)) / a);
+      const g = Math.round((rgba2.g * rgba2.a + rgba1.g * rgba1.a * (1 - rgba2.a)) / a);
+      const b = Math.round((rgba2.b * rgba2.a + rgba1.b * rgba1.a * (1 - rgba2.a)) / a);
+      return rgbaToHex({ r, g, b, a });
+  }
   function colorOrNumberToRGBA(color) {
       if (typeof color === "number") {
           return colorToRGBA(colorNumberToHex(color));
@@ -2660,6 +2672,7 @@
       "AUTOFILL_CELL",
       "SET_BORDER",
       "SET_ZONE_BORDERS",
+      "SET_BORDERS_ON_TARGET",
   ]);
   const invalidSubtotalFormulasCommands = new Set([
       "UNHIDE_COLUMNS_ROWS",
@@ -2687,6 +2700,7 @@
       "UPDATE_FILTER",
       "UPDATE_CHART",
       "UPDATE_CAROUSEL_ACTIVE_ITEM",
+      "UPDATE_PIVOT",
   ]);
   const coreTypes = new Set([
       /** CELLS */
@@ -5110,6 +5124,9 @@
       if (content === "") {
           return null;
       }
+      if (content.includes("\n")) {
+          return content;
+      }
       if (isNumber(content, DEFAULT_LOCALE)) {
           return parseNumber(content, DEFAULT_LOCALE);
       }
@@ -7318,14 +7335,11 @@
       const width = content[0].length, height = content.length;
       return target.map((t) => splitZoneForPaste(t, width, height)).flat();
   }
-  function parseOSClipboardContent(content, clipboardId) {
+  function parseOSClipboardContent(content) {
       let spreadsheetContent = undefined;
       if (content[ClipboardMIMEType.Html]) {
           const htmlDocument = new DOMParser().parseFromString(content[ClipboardMIMEType.Html], "text/html");
-          const oSheetClipboardData = htmlDocument
-              .querySelector("div")
-              ?.getAttribute("data-osheet-clipboard");
-          spreadsheetContent = oSheetClipboardData && JSON.parse(oSheetClipboardData);
+          spreadsheetContent = getOSheetDataFromHTML(htmlDocument);
       }
       const textContent = content[ClipboardMIMEType.PlainText] || "";
       let imageBlob = undefined;
@@ -7344,6 +7358,17 @@
       };
       return osClipboardContent;
   }
+  function getOSheetDataFromHTML(htmlDocument) {
+      const attributes = [...htmlDocument.documentElement.attributes];
+      // Check if it's a Microsoft Office clipboard data (it will have some namespaces defined in the root element)
+      if (attributes.some((attr) => attr.value.includes("microsoft"))) {
+          return undefined;
+      }
+      const oSheetClipboardData = htmlDocument
+          .querySelector("div")
+          ?.getAttribute("data-osheet-clipboard");
+      return oSheetClipboardData && JSON.parse(oSheetClipboardData);
+  }
   /**
    * Applies each clipboard handler to paste its corresponding data into the target.
    */
@@ -18337,7 +18362,6 @@ stores.inject(MyMetaStore, storeInstance);
   const functionRegex = /[a-zA-Z0-9\_]+(\.[a-zA-Z0-9\_]+)*/;
   const UNARY_OPERATORS_PREFIX = ["-", "+"];
   const UNARY_OPERATORS_POSTFIX = ["%"];
-  const ASSOCIATIVE_OPERATORS = ["*", "+", "&"];
   class TokenList {
       tokens;
       currentIndex = 0;
@@ -18358,8 +18382,8 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
   const OP_PRIORITY = {
+      "%": 40,
       "^": 30,
-      "%": 30,
       "*": 20,
       "/": 20,
       "+": 15,
@@ -18640,64 +18664,6 @@ stores.inject(MyMetaStore, storeInstance);
               return ast;
       }
   }
-  /**
-   * Converts an ast formula to the corresponding string
-   */
-  function astToFormula(ast) {
-      switch (ast.type) {
-          case "FUNCALL":
-              const args = ast.args.map((arg) => astToFormula(arg));
-              return `${ast.value}(${args.join(",")})`;
-          case "NUMBER":
-              return ast.value.toString();
-          case "REFERENCE":
-              return ast.value;
-          case "STRING":
-              return `"${ast.value}"`;
-          case "BOOLEAN":
-              return ast.value ? "TRUE" : "FALSE";
-          case "UNARY_OPERATION":
-              return ast.postfix
-                  ? leftOperandToFormula(ast) + ast.value
-                  : ast.value + rightOperandToFormula(ast);
-          case "BIN_OPERATION":
-              return leftOperandToFormula(ast) + ast.value + rightOperandToFormula(ast);
-          default:
-              return ast.value;
-      }
-  }
-  /**
-   * Convert the left operand of a binary operation to the corresponding string
-   * and enclose the result inside parenthesis if necessary.
-   */
-  function leftOperandToFormula(operationAST) {
-      const mainOperator = operationAST.value;
-      const leftOperation = "left" in operationAST ? operationAST.left : operationAST.operand;
-      const leftOperator = leftOperation.value;
-      const needParenthesis = leftOperation.type === "BIN_OPERATION" && OP_PRIORITY[leftOperator] < OP_PRIORITY[mainOperator];
-      return needParenthesis ? `(${astToFormula(leftOperation)})` : astToFormula(leftOperation);
-  }
-  /**
-   * Convert the right operand of a binary or unary operation to the corresponding string
-   * and enclose the result inside parenthesis if necessary.
-   */
-  function rightOperandToFormula(operationAST) {
-      const mainOperator = operationAST.value;
-      const rightOperation = "right" in operationAST ? operationAST.right : operationAST.operand;
-      const rightPriority = OP_PRIORITY[rightOperation.value];
-      const mainPriority = OP_PRIORITY[mainOperator];
-      let needParenthesis = false;
-      if (rightOperation.type !== "BIN_OPERATION") {
-          needParenthesis = false;
-      }
-      else if (rightPriority < mainPriority) {
-          needParenthesis = true;
-      }
-      else if (rightPriority === mainPriority && !ASSOCIATIVE_OPERATORS.includes(mainOperator)) {
-          needParenthesis = true;
-      }
-      return needParenthesis ? `(${astToFormula(rightOperation)})` : astToFormula(rightOperation);
-  }
 
   /**
    * Add the following information on tokens:
@@ -22196,7 +22162,7 @@ stores.inject(MyMetaStore, storeInstance);
               };
           }
       }
-      return concat(tokens.map((token) => token.value));
+      return concat$1(tokens.map((token) => token.value));
   }
   function adaptStringRange(defaultSheetId, sheetXC, applyChange) {
       const sheetName = splitReference(sheetXC).sheetName;
@@ -28281,10 +28247,6 @@ stores.inject(MyMetaStore, storeInstance);
           };
       }
       getDefinitionForExcel() {
-          // Excel does not support aggregating labels
-          if (this.aggregated) {
-              return undefined;
-          }
           const { dataSets, labelRange } = this.getCommonDataSetAttributesForExcel(this.labelRange, this.dataSets, shouldRemoveFirstLabel(this.labelRange, this.dataSets[0], this.dataSetsHaveTitle));
           const definition = this.getDefinition();
           return {
@@ -29486,9 +29448,6 @@ stores.inject(MyMetaStore, storeInstance);
           };
       }
       getDefinitionForExcel() {
-          if (this.aggregated) {
-              return undefined;
-          }
           const { dataSets, labelRange } = this.getCommonDataSetAttributesForExcel(this.labelRange, this.dataSets, shouldRemoveFirstLabel(this.labelRange, this.dataSets[0], this.dataSetsHaveTitle));
           const definition = this.getDefinition();
           return {
@@ -29636,10 +29595,6 @@ stores.inject(MyMetaStore, storeInstance);
           return new ScatterChart(definition, this.sheetId, this.getters);
       }
       getDefinitionForExcel() {
-          // Excel does not support aggregating labels
-          if (this.aggregated) {
-              return undefined;
-          }
           const dataSets = this.dataSets
               .map((ds) => toExcelDataset(this.getters, ds))
               .filter((ds) => ds.range !== "");
@@ -30958,7 +30913,7 @@ stores.inject(MyMetaStore, storeInstance);
           const value = expressions[i] instanceof XMLString ? expressions[i] : xmlEscape(expressions[i]);
           str.push(value + strings[i + 1]);
       }
-      return new XMLString(concat(str));
+      return new XMLString(concat$1(str));
   }
   /**
    * Removes the escaped namespace of all the xml tags in the string.
@@ -32044,10 +31999,10 @@ stores.inject(MyMetaStore, storeInstance);
               const item = chartSubtypeRegistry.get(type);
               return {
                   id: item.chartType,
-                  label: item.displayName,
+                  label: _t("Show as %(chart_type)s chart", { chart_type: item.displayName.toLowerCase() }),
                   onClick: () => this.updateType(item.chartType),
-                  isSelected: item.chartType === this.getters.getChartDefinition(this.chartId).type,
-                  iconClass: this.getIconClasses(item.chartType),
+                  class: item.chartType === definition.type ? "active" : "",
+                  preview: item.preview,
               };
           });
       }
@@ -32083,18 +32038,6 @@ stores.inject(MyMetaStore, storeInstance);
               sheetId: this.getters.getActiveSheetId(),
           });
       }
-      getIconClasses(type) {
-          if (type.includes("bar")) {
-              return "fa fa-bar-chart";
-          }
-          if (type.includes("line")) {
-              return "fa fa-line-chart";
-          }
-          if (type.includes("pie")) {
-              return "fa fa-pie-chart";
-          }
-          return "";
-      }
   }
 
   class ChartDashboardMenu extends owl.Component {
@@ -32133,20 +32076,11 @@ stores.inject(MyMetaStore, storeInstance);
           if (definition.type === "scorecard") {
               return undefined;
           }
-          if (this.props.chartId === this.fullScreenFigureStore.fullScreenFigure?.id) {
-              return {
-                  id: "fullScreenChart",
-                  label: _t("Exit Full Screen"),
-                  iconClass: "fa fa-compress",
-                  onClick: () => {
-                      this.fullScreenFigureStore.toggleFullScreenChart(figureId);
-                  },
-              };
-          }
+          const isFullScreen = this.props.chartId === this.fullScreenFigureStore.fullScreenFigure?.id;
           return {
               id: "fullScreenChart",
-              label: _t("Full Screen"),
-              iconClass: "fa fa-expand",
+              label: isFullScreen ? _t("Exit Full Screen") : _t("Full Screen"),
+              class: `text-muted fa ${isFullScreen ? "fa-compress" : "fa-expand"}`,
               onClick: () => {
                   this.fullScreenFigureStore.toggleFullScreenChart(figureId);
               },
@@ -34328,7 +34262,7 @@ stores.inject(MyMetaStore, storeInstance);
                   if (isFormula(content)) {
                       const missing = this.getNumberOfMissingParenthesis(this.currentTokens);
                       if (missing > 0) {
-                          content += concat(new Array(missing).fill(")"));
+                          content += concat$1(new Array(missing).fill(")"));
                       }
                   }
               }
@@ -34380,9 +34314,10 @@ stores.inject(MyMetaStore, storeInstance);
           if (isNewCurrentContent || this.editionMode !== "inactive") {
               const locale = this.getters.getLocale();
               this.currentTokens = isFormula(text) ? composerTokenize(text, locale) : [];
-              if (this.currentTokens.length > 100) {
+              const nonSpaceTokensCount = this.currentTokens.filter((token) => token.type !== "SPACE").length;
+              if (nonSpaceTokensCount > 1000) {
                   if (raise) {
-                      this.notificationStore.raiseError(_t("This formula has over 100 parts. It can't be processed properly, consider splitting it into multiple cells"));
+                      this.notificationStore.raiseError(_t("This formula has over 1000 parts. It can't be processed properly, consider splitting it into multiple cells"));
                   }
               }
           }
@@ -34803,6 +34738,8 @@ stores.inject(MyMetaStore, storeInstance);
       padding-right: 3px;
       outline: none;
 
+      tab-size: 4;
+
       p {
         margin-bottom: 0px;
 
@@ -47002,18 +46939,18 @@ stores.inject(MyMetaStore, storeInstance);
   };
   const pivotSortingAsc = {
       name: _t("Ascending"),
-      execute: (env) => sortPivot(env, "asc"),
-      isActive: (env) => isPivotSortMenuItemActive(env, "asc"),
+      execute: (env) => sortPivot(env, env.model.getters.getActivePosition(), "asc"),
+      isActive: (env) => env.model.getters.getPivotCellSortDirection(env.model.getters.getActivePosition()) === "asc",
   };
   const pivotSortingDesc = {
       name: _t("Descending"),
-      execute: (env) => sortPivot(env, "desc"),
-      isActive: (env) => isPivotSortMenuItemActive(env, "desc"),
+      execute: (env) => sortPivot(env, env.model.getters.getActivePosition(), "desc"),
+      isActive: (env) => env.model.getters.getPivotCellSortDirection(env.model.getters.getActivePosition()) === "desc",
   };
   const noPivotSorting = {
       name: _t("No sorting"),
-      execute: (env) => sortPivot(env, "none"),
-      isActive: (env) => isPivotSortMenuItemActive(env, "none"),
+      execute: (env) => sortPivot(env, env.model.getters.getActivePosition(), "none"),
+      isActive: (env) => env.model.getters.getPivotCellSortDirection(env.model.getters.getActivePosition()) === "none",
   };
   const FIX_FORMULAS = {
       name: _t("Convert to individual formulas"),
@@ -47149,23 +47086,19 @@ stores.inject(MyMetaStore, storeInstance);
           return areFieldValuesInGroups(definition, values, field, pivot.getFields());
       },
   };
-  function canSortPivot(env) {
-      const position = env.model.getters.getActivePosition();
-      const pivotId = env.model.getters.getPivotIdFromPosition(position);
-      if (!pivotId ||
-          !env.model.getters.isExistingPivot(pivotId) ||
-          !env.model.getters.isSpillPivotFormula(position)) {
+  function canSortPivot(getters, position) {
+      const pivotId = getters.getPivotIdFromPosition(position);
+      if (!pivotId || !getters.isExistingPivot(pivotId) || !getters.isSpillPivotFormula(position)) {
           return false;
       }
-      const pivot = env.model.getters.getPivot(pivotId);
+      const pivot = getters.getPivot(pivotId);
       if (!pivot.isValid()) {
           return false;
       }
-      const pivotCell = env.model.getters.getPivotCellFromPosition(position);
+      const pivotCell = getters.getPivotCellFromPosition(position);
       return pivotCell.type === "VALUE" || pivotCell.type === "MEASURE_HEADER";
   }
-  function sortPivot(env, order) {
-      const position = env.model.getters.getActivePosition();
+  function sortPivot(env, position, order) {
       const pivotId = env.model.getters.getPivotIdFromPosition(position);
       const pivotCell = env.model.getters.getPivotCellFromPosition(position);
       if (pivotCell.type === "EMPTY" || pivotCell.type === "HEADER" || !pivotId) {
@@ -47191,24 +47124,6 @@ stores.inject(MyMetaStore, storeInstance);
           },
       });
   }
-  function isPivotSortMenuItemActive(env, order) {
-      const position = env.model.getters.getActivePosition();
-      const pivotId = env.model.getters.getPivotIdFromPosition(position);
-      const pivotCell = env.model.getters.getPivotCellFromPosition(position);
-      if (pivotCell.type === "EMPTY" || pivotCell.type === "HEADER" || !pivotId) {
-          return false;
-      }
-      const pivot = env.model.getters.getPivot(pivotId);
-      const colDomain = domainToColRowDomain(pivot, pivotCell.domain).colDomain;
-      const sortedColumn = pivot.definition.sortedColumn;
-      if (order === "none") {
-          return !sortedColumn;
-      }
-      if (!sortedColumn || sortedColumn.order !== order) {
-          return false;
-      }
-      return sortedColumn.measure === pivotCell.measure && deepEquals(sortedColumn.domain, colDomain);
-  }
   /*
    * Get the values of the pivot headers in the current selection, if all the pivot headers on the selection belong
    * to the same pivot, the same field and that the pivot formula is a dynamic pivot. Otherwise return undefined.
@@ -47511,7 +47426,10 @@ stores.inject(MyMetaStore, storeInstance);
       name: _t("Sort pivot"),
       sequence: 155,
       icon: "o-spreadsheet-Icon.SORT_RANGE",
-      isVisible: canSortPivot,
+      isVisible: (env) => {
+          const position = env.model.getters.getActivePosition();
+          return canSortPivot(env.model.getters, position);
+      },
   })
       .add("pivot_fix_formulas", {
       ...FIX_FORMULAS,
@@ -48653,6 +48571,280 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  const ASSOCIATIVE_OPERATORS = ["*", "+", "&"];
+  /**
+   * Pretty-prints formula ASTs into readable formulas.
+   *
+   * Implements a Wadler-inspired pretty printer:
+   * it converts an AST into a `Doc` structure,
+   * and then chooses between compact (flat) or expanded (with
+   * line breaks and indentation) layouts depending on space.
+   *
+   * References:
+   * - https://lik.ai/blog/how-a-pretty-printer-works/
+   * - Wadler, "A prettier printer": https://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf
+   */
+  function prettify(ast, width = 60) {
+      return "=" + print(astToDoc(ast), width - 1); // width-1 because of the leading '='
+  }
+  /**
+   * A possible line break.
+   * Printed as either space or newline.
+   */
+  function line() {
+      return { type: "insertLine" };
+  }
+  /**
+   * Increase indentation for a nested block.
+   */
+  function nest(indentLevel, doc) {
+      return { type: "nest", indentLevel, doc };
+  }
+  /**
+   * Combines multiple docs into a single doc, concatenating them side by side
+   * without any line breaks or indentation.
+   */
+  function concat(docs) {
+      return { type: "concat", docs };
+  }
+  /**
+   * Marks a document as a unit to be printed "flat" (all on one line)
+   * if it fits within the width, otherwise with line breaks.
+   */
+  function group(doc) {
+      return chooseBetween(flatten(doc), doc);
+  }
+  /**
+   * Creates a choice between two alternative layouts.
+   * The formatter tries `doc1`; if it does not fit within
+   * the line width, it falls back to `doc2`.
+   */
+  function chooseBetween(doc1, doc2) {
+      return { type: "chooseBetween", doc1, doc2 };
+  }
+  /**
+   * Flattens a doc into its single-line form.
+   */
+  function flatten(doc) {
+      if (typeof doc === "string") {
+          return doc;
+      }
+      if (doc.type === "chooseBetween") {
+          // Normally should be "chooseBetween(flatten(doc.doc1), flatten(doc.doc2))",
+          // but this is simplified for performance reasons.
+          return flatten(doc.doc1);
+      }
+      if (doc.type === "concat") {
+          return concat(doc.docs.map(flatten));
+      }
+      if (doc.type === "nest") {
+          return {
+              type: "nest",
+              indentLevel: doc.indentLevel,
+              doc: flatten(doc.doc),
+          };
+      }
+      if (doc.type === "insertLine") {
+          return "";
+      }
+      return doc;
+  }
+  const getIndentationString = memoize(function getIndentationString(indentLevel) {
+      return "\n" + "\t".repeat(indentLevel);
+  });
+  /**
+   * Converts a `Doc` into a string representation that fits within
+   * the specified width.
+   */
+  function print(doc, width) {
+      return stringify(selectBestLayout(width, doc));
+  }
+  /**
+   * Join all segments of a LinkedString into the final string.
+   */
+  function stringify(linkedString) {
+      let result = "";
+      while (linkedString) {
+          result += linkedString.subString;
+          linkedString = linkedString.next;
+      }
+      return result;
+  }
+  /**
+   * Layout selection for a `Doc` that fits within the given width.
+   */
+  function selectBestLayout(width, doc) {
+      const head = {
+          indentLevel: 0,
+          doc,
+          next: null,
+      };
+      return _selectBestLayout(width, 0, head);
+  }
+  function _selectBestLayout(width, currentIndentLevel, head) {
+      if (head === null) {
+          return null;
+      }
+      const { indentLevel, doc, next } = head;
+      if (typeof doc === "string") {
+          return {
+              subString: doc,
+              next: _selectBestLayout(width, currentIndentLevel + doc.length, next),
+          };
+      }
+      if (doc.type === "concat") {
+          let newHead = next;
+          for (let i = doc.docs.length - 1; i >= 0; i--) {
+              newHead = { indentLevel, doc: doc.docs[i], next: newHead };
+          }
+          return _selectBestLayout(width, currentIndentLevel, newHead);
+      }
+      if (doc.type === "nest") {
+          return _selectBestLayout(width, currentIndentLevel, {
+              indentLevel: indentLevel + doc.indentLevel,
+              doc: doc.doc,
+              next,
+          });
+      }
+      if (doc.type === "insertLine") {
+          return {
+              subString: getIndentationString(indentLevel),
+              next: _selectBestLayout(width, indentLevel, next),
+          };
+      }
+      if (doc.type === "chooseBetween") {
+          const head1 = { indentLevel, doc: doc.doc1, next };
+          const possibleLinkedString = _selectBestLayout(width, currentIndentLevel, head1);
+          if (fits(width - currentIndentLevel, possibleLinkedString)) {
+              return possibleLinkedString;
+          }
+          const head2 = { indentLevel, doc: doc.doc2, next };
+          return _selectBestLayout(width, currentIndentLevel, head2);
+      }
+      return null;
+  }
+  /**
+   * Check if a layout fits on a single line within width.
+   */
+  function fits(width, linkedString) {
+      while (linkedString) {
+          if (linkedString.subString[0] === "\n") {
+              return true;
+          }
+          width -= linkedString.subString.length;
+          if (width < 0)
+              return false;
+          linkedString = linkedString.next;
+      }
+      return true;
+  }
+  function astToDoc(ast) {
+      switch (ast.type) {
+          case "NUMBER":
+              return String(ast.value);
+          case "STRING":
+              return `"${ast.value}"`;
+          case "BOOLEAN":
+              return ast.value ? "TRUE" : "FALSE";
+          case "REFERENCE":
+              return ast.value;
+          case "FUNCALL":
+              const docs = ast.args.map(astToDoc);
+              return wrapInParentheses(concat(docs.map((doc, i) => (i < 1 ? doc : concat([", ", line(), doc])))), ast.value);
+          case "UNARY_OPERATION":
+              const operandDoc = astToDoc(ast.operand);
+              const needParenthesis = ast.postfix
+                  ? leftOperandNeedsParenthesis(ast)
+                  : rightOperandNeedsParenthesis(ast);
+              const finalOperandDoc = needParenthesis ? wrapInParentheses(operandDoc) : operandDoc;
+              return ast.postfix
+                  ? concat([finalOperandDoc, ast.value])
+                  : concat([ast.value, finalOperandDoc]);
+          case "BIN_OPERATION": {
+              const leftDoc = astToDoc(ast.left);
+              const needParenthesisLeftDoc = leftOperandNeedsParenthesis(ast);
+              const finalLeftDoc = needParenthesisLeftDoc ? wrapInParentheses(leftDoc) : leftDoc;
+              const rightDoc = astToDoc(ast.right);
+              const needParenthesisRightDoc = rightOperandNeedsParenthesis(ast);
+              const finalRightDoc = needParenthesisRightDoc ? wrapInParentheses(rightDoc) : rightDoc;
+              const operator = `${ast.value}`;
+              return group(concat([finalLeftDoc, operator, nest(1, concat([line(), finalRightDoc]))]));
+          }
+          case "SYMBOL":
+              return ast.value;
+          case "EMPTY":
+              return "";
+      }
+  }
+  /**
+   * Wraps a `Doc` in parentheses (with optional function name).
+   */
+  function wrapInParentheses(doc, functionName = undefined) {
+      const docToConcat = ["(", nest(1, concat([line(), doc])), line(), ")"];
+      if (functionName) {
+          docToConcat.unshift(functionName);
+      }
+      return group(concat(docToConcat));
+  }
+  /**
+   * Converts an ast formula to the corresponding string
+   */
+  function astToFormula(ast) {
+      switch (ast.type) {
+          case "FUNCALL":
+              const args = ast.args.map((arg) => astToFormula(arg));
+              return `${ast.value}(${args.join(",")})`;
+          case "NUMBER":
+              return ast.value.toString();
+          case "REFERENCE":
+              return ast.value;
+          case "STRING":
+              return `"${ast.value}"`;
+          case "BOOLEAN":
+              return ast.value ? "TRUE" : "FALSE";
+          case "UNARY_OPERATION":
+              if (ast.postfix) {
+                  const leftOperand = leftOperandNeedsParenthesis(ast)
+                      ? `(${astToFormula(ast.operand)})`
+                      : astToFormula(ast.operand);
+                  return leftOperand + ast.value;
+              }
+              const rightOperand = rightOperandNeedsParenthesis(ast)
+                  ? `(${astToFormula(ast.operand)})`
+                  : astToFormula(ast.operand);
+              return ast.value + rightOperand;
+          case "BIN_OPERATION":
+              const leftOperation = leftOperandNeedsParenthesis(ast)
+                  ? `(${astToFormula(ast.left)})`
+                  : astToFormula(ast.left);
+              const rightOperation = rightOperandNeedsParenthesis(ast)
+                  ? `(${astToFormula(ast.right)})`
+                  : astToFormula(ast.right);
+              return leftOperation + ast.value + rightOperation;
+          default:
+              return ast.value;
+      }
+  }
+  function leftOperandNeedsParenthesis(operationAST) {
+      const mainOperator = operationAST.value;
+      const leftOperation = "left" in operationAST ? operationAST.left : operationAST.operand;
+      const leftOperator = leftOperation.value;
+      return (leftOperation.type === "BIN_OPERATION" && OP_PRIORITY[leftOperator] < OP_PRIORITY[mainOperator]);
+  }
+  function rightOperandNeedsParenthesis(operationAST) {
+      const mainOperator = operationAST.value;
+      const rightOperation = "right" in operationAST ? operationAST.right : operationAST.operand;
+      const rightPriority = OP_PRIORITY[rightOperation.value];
+      const mainPriority = OP_PRIORITY[mainOperator];
+      if (rightOperation.type !== "BIN_OPERATION") {
+          return false;
+      }
+      if (rightPriority < mainPriority) {
+          return true;
+      }
+      return rightPriority === mainPriority && !ASSOCIATIVE_OPERATORS.includes(mainOperator);
+  }
+
   const CELL_DELETED_MESSAGE = _t("The cell you are trying to edit has been deleted.");
   class CellComposerStore extends AbstractComposerStore {
       canStopEdition() {
@@ -48796,7 +48988,10 @@ stores.inject(MyMetaStore, storeInstance);
           const locale = this.getters.getLocale();
           const cell = this.getters.getCell(position);
           if (cell?.isFormula) {
-              return localizeFormula(cell.content, locale);
+              const prettifiedContent = cell.compiledFormula.isBadExpression
+                  ? cell.content
+                  : prettify(parseTokens(cell.compiledFormula.tokens), 80);
+              return localizeFormula(prettifiedContent, locale);
           }
           const spreader = this.model.getters.getArrayFormulaSpreadingOn(position);
           if (spreader) {
@@ -60500,6 +60695,42 @@ stores.inject(MyMetaStore, storeInstance);
   const supportedPivotPositionalFormulaRegistry = new Registry();
   supportedPivotPositionalFormulaRegistry.add("SPREADSHEET", false);
 
+  class ClickableCellSortIcon extends owl.Component {
+      static template = "o-spreadsheet-ClickableCellSortIcon";
+      static props = {
+          position: Object,
+          sortDirection: String,
+      };
+      hoveredTableStore;
+      setup() {
+          this.hoveredTableStore = useStore(HoveredTableStore);
+      }
+      get style() {
+          const cellStyle = this.env.model.getters.getCellComputedStyle(this.props.position);
+          return cssPropertiesToCss({
+              color: cellStyle.textColor || TEXT_BODY_MUTED,
+              "background-color": this.getBackgroundColor(cellStyle),
+          });
+      }
+      get icon() {
+          switch (this.props.sortDirection) {
+              case "asc":
+                  return "fa-sort-asc";
+              case "desc":
+                  return "fa-sort-desc";
+              default:
+                  return "fa-sort";
+          }
+      }
+      getBackgroundColor(cellStyle) {
+          const overlayColor = this.hoveredTableStore.overlayColors.get(this.props.position);
+          if (overlayColor) {
+              return blendColors(cellStyle.fillColor || "#FFFFFF", overlayColor);
+          }
+          return cellStyle.fillColor || "#FFFFFF";
+      }
+  }
+
   class FullScreenChart extends owl.Component {
       static template = "o-spreadsheet-FullScreenChart";
       static props = {};
@@ -61794,10 +62025,10 @@ stores.inject(MyMetaStore, storeInstance);
        */
       getFormulaString(sheetId, tokens, dependencies, useBoundedReference = false) {
           if (!dependencies.length) {
-              return concat(tokens.map((token) => token.value));
+              return concat$1(tokens.map((token) => token.value));
           }
           let rangeIndex = 0;
-          return concat(tokens.map((token) => {
+          return concat$1(tokens.map((token) => {
               if (token.type === "REFERENCE") {
                   const range = dependencies[rangeIndex++];
                   return this.getters.getRangeString(range, sheetId, { useBoundedReference });
@@ -62072,11 +62303,11 @@ stores.inject(MyMetaStore, storeInstance);
           };
       }
       get content() {
-          return concat(this.compiledFormula.tokens.map((token) => token.value));
+          return concat$1(this.compiledFormula.tokens.map((token) => token.value));
       }
       get contentWithFixedReferences() {
           let rangeIndex = 0;
-          return concat(this.compiledFormula.tokens.map((token) => {
+          return concat$1(this.compiledFormula.tokens.map((token) => {
               if (token.type === "REFERENCE") {
                   const index = rangeIndex++;
                   return this.getRangeString(this.compiledFormula.dependencies[index], this.sheetId, {
@@ -70856,6 +71087,7 @@ stores.inject(MyMetaStore, storeInstance);
       static getters = [
           "getPivot",
           "getFirstPivotFunction",
+          "getPivotCellSortDirection",
           "getPivotIdFromPosition",
           "getPivotCellFromPosition",
           "generateNewCalculatedMeasureName",
@@ -71076,6 +71308,20 @@ stores.inject(MyMetaStore, storeInstance);
       isPivotUnused(pivotId) {
           return this._getUnusedPivots().includes(pivotId);
       }
+      getPivotCellSortDirection(position) {
+          const pivotId = this.getters.getPivotIdFromPosition(position);
+          const pivotCell = this.getters.getPivotCellFromPosition(position);
+          if (pivotCell.type === "EMPTY" || pivotCell.type === "HEADER" || !pivotId) {
+              return undefined;
+          }
+          const pivot = this.getters.getPivot(pivotId);
+          const colDomain = domainToColRowDomain(pivot, pivotCell.domain).colDomain;
+          const sortedColumn = pivot.definition.sortedColumn;
+          if (sortedColumn?.measure === pivotCell.measure && deepEquals(sortedColumn.domain, colDomain)) {
+              return sortedColumn.order;
+          }
+          return "none";
+      }
       // ---------------------------------------------------------------------
       // Private
       // ---------------------------------------------------------------------
@@ -78768,6 +79014,34 @@ stores.inject(MyMetaStore, storeInstance);
       },
       sequence: 5,
   });
+  clickableCellRegistry.add("dashboard_pivot_sorting", {
+      condition: (position, getters) => {
+          if (!getters.isDashboard()) {
+              return false;
+          }
+          const pivotCell = getters.getPivotCellFromPosition(position);
+          return canSortPivot(getters, position) && pivotCell.type === "MEASURE_HEADER";
+      },
+      execute: (position, env) => {
+          sortPivot(env, position, getNextSortDirection(env.model.getters, position));
+      },
+      component: ClickableCellSortIcon,
+      componentProps: (position, getters) => {
+          return {
+              position,
+              sortDirection: getters.getPivotCellSortDirection(position),
+          };
+      },
+      sequence: 2,
+  });
+  const NEXT_SORT_DIRECTION = {
+      none: "asc",
+      asc: "desc",
+      desc: "none",
+  };
+  function getNextSortDirection(getters, position) {
+      return NEXT_SORT_DIRECTION[getters.getPivotCellSortDirection(position) ?? "none"];
+  }
 
   const inverseCommandRegistry = new Registry()
       .add("ADD_COLUMNS_ROWS", inverseAddColumnsRows)
@@ -80484,6 +80758,8 @@ stores.inject(MyMetaStore, storeInstance);
                   position,
                   action: item.execute,
                   title: title || "",
+                  component: item.component,
+                  componentProps: item.componentProps?.(position, getters) ?? {},
               });
           }
           return cells;
@@ -81236,7 +81512,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  const COMPOSER_MAX_HEIGHT = 100;
+  const COMPOSER_MAX_HEIGHT = 300;
   /* svg free of use from https://uxwing.com/formula-fx-icon/ */
   const FX_SVG = /*xml*/ `
 <svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 121.8 122.9' width='16' height='16' focusable='false'>
@@ -82830,6 +83106,27 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class ReadonlyTransportFilter {
+      transportService;
+      constructor(transportService) {
+          this.transportService = transportService;
+      }
+      async sendMessage(message) {
+          if (message.type === "CLIENT_JOINED" ||
+              message.type === "CLIENT_LEFT" ||
+              message.type === "CLIENT_MOVED") {
+              this.transportService.sendMessage(message);
+          }
+          // ignore all other messages
+      }
+      onNewMessage(id, callback) {
+          this.transportService.onNewMessage(id, callback);
+      }
+      leave(id) {
+          this.transportService.leave(id);
+      }
+  }
+
   function inverseCommand(cmd) {
       return inverseCommandRegistry.get(cmd.type)(cmd);
   }
@@ -86922,12 +87219,15 @@ stores.inject(MyMetaStore, storeInstance);
               name: _t("Anonymous").toString(),
           };
           const transportService = config.transportService || new LocalTransportService();
+          const isReadonly = config.mode === "readonly" || config.mode === "dashboard";
           return {
               ...config,
               mode: config.mode || "normal",
               custom: config.custom || {},
               external: this.setupExternalConfig(config.external || {}),
-              transportService,
+              transportService: isReadonly
+                  ? new ReadonlyTransportFilter(transportService)
+                  : transportService,
               client,
               moveClient: () => { },
               snapshotRequested: false,
@@ -87340,6 +87640,7 @@ stores.inject(MyMetaStore, storeInstance);
       ChartPanel,
       ChartFigure,
       ChartJsComponent,
+      ClickableCellSortIcon,
       ZoomableChartJsComponent,
       Grid,
       GridOverlay,
@@ -87425,6 +87726,8 @@ stores.inject(MyMetaStore, storeInstance);
       PIVOT_TABLE_CONFIG,
       ChartTerms,
       FIGURE_ID_SPLITTER,
+      GRID_ICON_EDGE_LENGTH,
+      GRID_ICON_MARGIN,
   };
   const chartHelpers = { ...CHART_HELPERS, ...CHART_RUNTIME_HELPERS };
 
@@ -87479,9 +87782,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.5.0-alpha.10";
-  __info__.date = "2025-08-21T06:42:10.830Z";
-  __info__.hash = "5800d1b";
+  __info__.version = "18.5.0-alpha.12";
+  __info__.date = "2025-08-29T08:05:09.767Z";
+  __info__.hash = "8ee7677";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);