@odoo/o-spreadsheet 18.1.0-alpha.0 → 18.1.0-alpha.2

package/dist/o-spreadsheet.iife.js

@@ -2,14 +2,120 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 18.1.0-alpha.0
- * @date 2024-09-25T13:17:49.636Z
- * @hash 288f0b7
+ * @version 18.1.0-alpha.2
+ * @date 2024-10-24T08:53:21.828Z
+ * @hash 2a01250
  */
 
 (function (exports, owl) {
   'use strict';
 
+  function createActions(menuItems) {
+      return menuItems.map(createAction).sort((a, b) => a.sequence - b.sequence);
+  }
+  let nextItemId = 1;
+  function createAction(item) {
+      const name = item.name;
+      const children = item.children;
+      const description = item.description;
+      const icon = item.icon;
+      const secondaryIcon = item.secondaryIcon;
+      const itemId = item.id || nextItemId++;
+      return {
+          id: itemId.toString(),
+          name: typeof name === "function" ? name : () => name,
+          isVisible: item.isVisible ? item.isVisible : () => true,
+          isEnabled: item.isEnabled ? item.isEnabled : () => true,
+          isActive: item.isActive,
+          execute: item.execute,
+          children: children
+              ? (env) => {
+                  return children
+                      .map((child) => (typeof child === "function" ? child(env) : child))
+                      .flat()
+                      .map(createAction);
+              }
+              : () => [],
+          isReadonlyAllowed: item.isReadonlyAllowed || false,
+          separator: item.separator || false,
+          icon: typeof icon === "function" ? icon : () => icon || "",
+          iconColor: item.iconColor,
+          secondaryIcon: typeof secondaryIcon === "function" ? secondaryIcon : () => secondaryIcon || "",
+          description: typeof description === "function" ? description : () => description || "",
+          textColor: item.textColor,
+          sequence: item.sequence || 0,
+          onStartHover: item.onStartHover,
+          onStopHover: item.onStopHover,
+      };
+  }
+
+  /**
+   * Registry
+   *
+   * The Registry class is basically just a mapping from a string key to an object.
+   * It is really not much more than an object. It is however useful for the
+   * following reasons:
+   *
+   * 1. it let us react and execute code when someone add something to the registry
+   *   (for example, the FunctionRegistry subclass this for this purpose)
+   * 2. it throws an error when the get operation fails
+   * 3. it provides a chained API to add items to the registry.
+   */
+  class Registry {
+      content = {};
+      /**
+       * Add an item to the registry
+       *
+       * Note that this also returns the registry, so another add method call can
+       * be chained
+       */
+      add(key, value) {
+          this.content[key] = value;
+          return this;
+      }
+      /**
+       * Get an item from the registry
+       */
+      get(key) {
+          /**
+           * Note: key in {} is ~12 times slower than {}[key].
+           * So, we check the absence of key only when the direct access returns
+           * a falsy value. It's done to ensure that the registry can contains falsy values
+           */
+          const content = this.content[key];
+          if (!content) {
+              if (!(key in this.content)) {
+                  throw new Error(`Cannot find ${key} in this registry!`);
+              }
+          }
+          return content;
+      }
+      /**
+       * Check if the key is already in the registry
+       */
+      contains(key) {
+          return key in this.content;
+      }
+      /**
+       * Get a list of all elements in the registry
+       */
+      getAll() {
+          return Object.values(this.content);
+      }
+      /**
+       * Get a list of all keys in the registry
+       */
+      getKeys() {
+          return Object.keys(this.content);
+      }
+      /**
+       * Remove an item from the registry
+       */
+      remove(key) {
+          delete this.content[key];
+      }
+  }
+
   const CANVAS_SHIFT = 0.5;
   // Colors
   const HIGHLIGHT_COLOR = "#37A850";
@@ -224,6 +330,7 @@
   const DEFAULT_SCORECARD_BASELINE_COLOR_UP = "#43C5B1";
   const DEFAULT_SCORECARD_BASELINE_COLOR_DOWN = "#EA6175";
   const LINE_FILL_TRANSPARENCY = 0.4;
+  const DEFAULT_WINDOW_SIZE = 2;
   // session
   const DEBOUNCE_TIME = 200;
   const MESSAGE_VERSION = 1;
@@ -269,7 +376,7 @@
       bandedRows: true,
       bandedColumns: false,
       styleId: "TableStyleMedium5",
-      automaticAutofill: true,
+      automaticAutofill: false,
   };
   const DEFAULT_CURRENCY = {
       symbol: "$",
@@ -485,7 +592,7 @@
    */
   function parseSheetUrl(sheetLink) {
       if (sheetLink.startsWith(O_SPREADSHEET_LINK_PREFIX)) {
-          return sheetLink.substr(O_SPREADSHEET_LINK_PREFIX.length);
+          return sheetLink.slice(O_SPREADSHEET_LINK_PREFIX.length);
       }
       throw new Error(`${sheetLink} is not a valid sheet link`);
   }
@@ -3050,8 +3157,7 @@
       const p2 = pMinus + pNumber + pCurrencyFormat;
       const p3 = pCurrencyFormat + pMinus + pNumber;
       const pNumberExp = "^(?:(?:" + [p1, p2, p3].join(")|(?:") + "))$";
-      const numberRegexp = new RegExp(pNumberExp, "i");
-      return numberRegexp;
+      return new RegExp(pNumberExp, "i");
   });
   /**
    * Return true if the argument is a "number string".
@@ -5725,8 +5831,7 @@
           textWidthCache[font] = {};
       }
       if (textWidthCache[font][text] === undefined) {
-          const textWidth = context.measureText(text).width;
-          textWidthCache[font][text] = textWidth;
+          textWidthCache[font][text] = context.measureText(text).width;
       }
       return textWidthCache[font][text];
   }
@@ -5969,136 +6074,22 @@
    * https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript
    * */
   class UuidGenerator {
-      isFastIdStrategy = false;
-      fastIdStart = 0;
-      setIsFastStrategy(isFast) {
-          this.isFastIdStrategy = isFast;
-      }
       uuidv4() {
-          if (this.isFastIdStrategy) {
-              this.fastIdStart++;
-              return String(this.fastIdStart);
-              //@ts-ignore
-          }
-          else if (window.crypto && window.crypto.getRandomValues) {
+          //@ts-ignore
+          if (window.crypto && window.crypto.getRandomValues) {
               //@ts-ignore
               return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c) => (c ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16));
           }
           else {
               // mainly for jest and other browsers that do not have the crypto functionality
               return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
-                  var r = (Math.random() * 16) | 0, v = c === "x" ? r : (r & 0x3) | 0x8;
+                  const r = (Math.random() * 16) | 0, v = c === "x" ? r : (r & 0x3) | 0x8;
                   return v.toString(16);
               });
           }
       }
   }
 
-  function createActions(menuItems) {
-      return menuItems.map(createAction).sort((a, b) => a.sequence - b.sequence);
-  }
-  const uuidGenerator$1 = new UuidGenerator();
-  function createAction(item) {
-      const name = item.name;
-      const children = item.children;
-      const description = item.description;
-      const icon = item.icon;
-      const secondaryIcon = item.secondaryIcon;
-      return {
-          id: item.id || uuidGenerator$1.uuidv4(),
-          name: typeof name === "function" ? name : () => name,
-          isVisible: item.isVisible ? item.isVisible : () => true,
-          isEnabled: item.isEnabled ? item.isEnabled : () => true,
-          isActive: item.isActive,
-          execute: item.execute,
-          children: children
-              ? (env) => {
-                  return children
-                      .map((child) => (typeof child === "function" ? child(env) : child))
-                      .flat()
-                      .map(createAction);
-              }
-              : () => [],
-          isReadonlyAllowed: item.isReadonlyAllowed || false,
-          separator: item.separator || false,
-          icon: typeof icon === "function" ? icon : () => icon || "",
-          iconColor: item.iconColor,
-          secondaryIcon: typeof secondaryIcon === "function" ? secondaryIcon : () => secondaryIcon || "",
-          description: typeof description === "function" ? description : () => description || "",
-          textColor: item.textColor,
-          sequence: item.sequence || 0,
-          onStartHover: item.onStartHover,
-          onStopHover: item.onStopHover,
-      };
-  }
-
-  /**
-   * Registry
-   *
-   * The Registry class is basically just a mapping from a string key to an object.
-   * It is really not much more than an object. It is however useful for the
-   * following reasons:
-   *
-   * 1. it let us react and execute code when someone add something to the registry
-   *   (for example, the FunctionRegistry subclass this for this purpose)
-   * 2. it throws an error when the get operation fails
-   * 3. it provides a chained API to add items to the registry.
-   */
-  class Registry {
-      content = {};
-      /**
-       * Add an item to the registry
-       *
-       * Note that this also returns the registry, so another add method call can
-       * be chained
-       */
-      add(key, value) {
-          this.content[key] = value;
-          return this;
-      }
-      /**
-       * Get an item from the registry
-       */
-      get(key) {
-          /**
-           * Note: key in {} is ~12 times slower than {}[key].
-           * So, we check the absence of key only when the direct access returns
-           * a falsy value. It's done to ensure that the registry can contains falsy values
-           */
-          const content = this.content[key];
-          if (!content) {
-              if (!(key in this.content)) {
-                  throw new Error(`Cannot find ${key} in this registry!`);
-              }
-          }
-          return content;
-      }
-      /**
-       * Check if the key is already in the registry
-       */
-      contains(key) {
-          return key in this.content;
-      }
-      /**
-       * Get a list of all elements in the registry
-       */
-      getAll() {
-          return Object.values(this.content);
-      }
-      /**
-       * Get a list of all keys in the registry
-       */
-      getKeys() {
-          return Object.keys(this.content);
-      }
-      /**
-       * Remove an item from the registry
-       */
-      remove(key) {
-          delete this.content[key];
-      }
-  }
-
   function getClipboardDataPositions(sheetId, zones) {
       const lefts = new Set(zones.map((z) => z.left));
       const rights = new Set(zones.map((z) => z.right));
@@ -6589,10 +6580,9 @@
           return literal;
       }
       const decimalNumberRegex = getDecimalNumberRegex(DEFAULT_LOCALE);
-      const localized = literal.replace(decimalNumberRegex, (match) => {
+      return literal.replace(decimalNumberRegex, (match) => {
           return match.replace(".", locale.decimalSeparator);
       });
-      return localized;
   }
   /**
    * Change a literal string from its canonical form (en_US locale) to the given locale. Also convert date string.
@@ -7077,6 +7067,21 @@
       });
       return newY.length === newX.length ? newY : transposeMatrix(newY);
   }
+  function getMovingAverageValues(dataset, windowSize = DEFAULT_WINDOW_SIZE) {
+      const values = [];
+      // Fill the starting values with null until we have a full window
+      for (let i = 0; i < windowSize - 1; i++) {
+          values.push(null);
+      }
+      for (let i = 0; i <= dataset.length - windowSize; i++) {
+          let sum = 0;
+          for (let j = i; j < i + windowSize; j++) {
+              sum += dataset[j];
+          }
+          values.push(sum / windowSize);
+      }
+      return values;
+  }
 
   const PREVIOUS_VALUE = "(previous)";
   const NEXT_VALUE = "(next)";
@@ -7612,8 +7617,7 @@
           return 0;
       }
       const nums = keys.map((id) => parseInt(id, 10));
-      const max = Math.max(...nums);
-      return max;
+      return Math.max(...nums);
   }
   const ALL_PERIODS = {
       year: _t("Year"),
@@ -8453,31 +8457,30 @@
               for (let col of columnsIndexes) {
                   const position = { col, row, sheetId };
                   const table = this.getters.getTable(position);
-                  if (!table || copiedTablesIds.has(table.id)) {
+                  if (!table) {
                       tableCellsInRow.push({});
                       continue;
                   }
                   const coreTable = this.getters.getCoreTable(position);
                   const tableZone = coreTable?.range.zone;
+                  let copiedTable = undefined;
                   // Copy whole table
-                  if (coreTable && tableZone && zones.some((z) => isZoneInside(tableZone, z))) {
-                      copiedTablesIds.add(coreTable.id);
-                      const values = [];
-                      for (const col of range(tableZone.left, tableZone.right + 1)) {
-                          values.push(this.getters.getFilterHiddenValues({ sheetId, col, row: tableZone.top }));
-                      }
-                      tableCellsInRow.push({
-                          table: {
-                              range: coreTable.range.rangeData,
-                              config: coreTable.config,
-                              type: coreTable.type,
-                          },
-                      });
-                  }
-                  // Copy only style of cell
-                  else if (table) {
-                      tableCellsInRow.push({ style: this.getTableStyleToCopy(position) });
+                  if (!copiedTablesIds.has(table.id) &&
+                      coreTable &&
+                      tableZone &&
+                      zones.some((z) => isZoneInside(tableZone, z))) {
+                      copiedTablesIds.add(table.id);
+                      copiedTable = {
+                          range: coreTable.range.rangeData,
+                          config: coreTable.config,
+                          type: coreTable.type,
+                      };
                   }
+                  tableCellsInRow.push({
+                      table: copiedTable,
+                      style: this.getTableStyleToCopy(position),
+                      isWholeTableCopied: copiedTablesIds.has(table.id),
+                  });
               }
           }
           return {
@@ -8558,11 +8561,14 @@
                   tableType: tableCell.table.type,
               });
           }
-          // Do not paste table style if we're inside another table
           // We cannot check for dynamic tables, because at this point the paste can have changed the evaluation, and the
           // dynamic tables are not yet computed
-          if (!this.getters.getCoreTable(position)) {
-              if (tableCell.style?.style && options?.pasteOption !== "asValue") {
+          if (this.getters.getCoreTable(position) || options?.pasteOption === "asValue") {
+              return;
+          }
+          if ((!options?.pasteOption && !tableCell.isWholeTableCopied) ||
+              options?.pasteOption === "onlyFormat") {
+              if (tableCell.style?.style) {
                   this.dispatch("UPDATE_CELL", { ...position, style: tableCell.style.style });
               }
               if (tableCell.style?.border) {
@@ -9244,11 +9250,10 @@ stores.inject(MyMetaStore, storeInstance);
       const { x, y } = getters.getMainViewportCoordinates();
       const { scrollX, scrollY } = getters.getActiveSheetScrollInfo();
       const { width, height } = getters.getVisibleRect(getters.getActiveMainViewport());
-      const position = {
+      return {
           x: x + scrollX + Math.max(0, (width - chartSize.width) / 2),
           y: y + scrollY + Math.max(0, (height - chartSize.height) / 2),
       }; // Position at the center of the scrollable viewport
-      return position;
   }
   function getChartAxisTitleRuntime(design) {
       if (design?.title?.text) {
@@ -9282,6 +9287,49 @@ stores.inject(MyMetaStore, storeInstance);
       useLeftAxis ||= !useRightAxis;
       return { useLeftAxis, useRightAxis };
   }
+  function getChartAxis(definition, position, type, options) {
+      const { useLeftAxis, useRightAxis } = getDefinedAxis(definition);
+      if ((position === "left" && !useLeftAxis) || (position === "right" && !useRightAxis)) {
+          return undefined;
+      }
+      const fontColor = chartFontColor(definition.background);
+      let design;
+      if (position === "bottom") {
+          design = definition.axesDesign?.x;
+      }
+      else if (position === "left") {
+          design = definition.axesDesign?.y;
+      }
+      else {
+          design = definition.axesDesign?.y1;
+      }
+      if (type === "values") {
+          const displayGridLines = position === "left" || (position === "right" && !useLeftAxis);
+          return {
+              position: position,
+              title: getChartAxisTitleRuntime(design),
+              grid: {
+                  display: displayGridLines,
+              },
+              beginAtZero: true,
+              stacked: options?.stacked,
+              ticks: {
+                  color: fontColor,
+                  callback: formatTickValue(options),
+              },
+          };
+      }
+      else {
+          return {
+              ticks: {
+                  padding: 5,
+                  color: fontColor,
+              },
+              stacked: options?.stacked,
+              title: getChartAxisTitleRuntime(design),
+          };
+      }
+  }
   function computeChartPadding({ displayTitle, displayLegend, }) {
       let top = 25;
       if (displayTitle) {
@@ -9322,7 +9370,7 @@ stores.inject(MyMetaStore, storeInstance);
       return {
           ...dataset,
           type: "line",
-          xAxisID: TREND_LINE_XAXIS_ID,
+          xAxisID: config.type !== "trailingMovingAverage" ? TREND_LINE_XAXIS_ID : "x",
           label: dataset.label ? _t("Trend line for %s", dataset.label) : "",
           data,
           order: -1,
@@ -9364,10 +9412,19 @@ stores.inject(MyMetaStore, storeInstance);
           case "logarithmic": {
               return predictLinearValues([values], logM([labels]), logM([newLabels]), true)[0];
           }
+          case "trailingMovingAverage": {
+              return getMovingAverageValues(values, config.window);
+          }
           default:
               return [];
       }
   }
+  function formatChartDatasetValue(axisFormats, locale) {
+      return (value, axisId) => {
+          const format = axisId ? axisFormats?.[axisId] : undefined;
+          return formatTickValue({ format, locale })(value);
+      };
+  }
   function formatTickValue(localeFormat) {
       return (value) => {
           value = Number(value);
@@ -9403,70 +9460,115 @@ stores.inject(MyMetaStore, storeInstance);
           ctx.save();
           ctx.textAlign = "center";
           ctx.textBaseline = "middle";
-          ctx.fillStyle = chartFontColor(options.background);
-          ctx.strokeStyle = chartFontColor(ctx.fillStyle);
-          chart._metasets.forEach(function (dataset) {
-              if (dataset.xAxisID === TREND_LINE_XAXIS_ID) {
-                  return; // ignore trend lines
-              }
-              switch (dataset.type) {
-                  case "doughnut":
-                  case "pie": {
-                      for (let i = 0; i < dataset._parsed.length; i++) {
-                          const bar = dataset.data[i];
-                          const { startAngle, endAngle, innerRadius, outerRadius } = bar;
-                          const midAngle = (startAngle + endAngle) / 2;
-                          const midRadius = (innerRadius + outerRadius) / 2;
-                          const x = bar.x + midRadius * Math.cos(midAngle);
-                          const y = bar.y + midRadius * Math.sin(midAngle) + 7;
-                          ctx.fillStyle = chartFontColor(bar.options.backgroundColor);
-                          ctx.strokeStyle = chartFontColor(ctx.fillStyle);
-                          const value = options.callback(dataset._parsed[i]);
-                          ctx.strokeText(value, x, y);
-                          ctx.fillText(value, x, y);
-                      }
-                      break;
-                  }
-                  case "bar":
-                  case "line": {
-                      const yOffset = dataset.type === "bar" && !options.horizontal ? 0 : 3;
-                      for (let i = 0; i < dataset._parsed.length; i++) {
-                          const point = dataset.data[i];
-                          const value = options.horizontal ? dataset._parsed[i].x : dataset._parsed[i].y;
-                          const displayedValue = options.callback(value - 0);
-                          let xPosition = 0, yPosition = 0;
-                          if (options.horizontal) {
-                              yPosition = point.y;
-                              if (value < 0) {
-                                  ctx.textAlign = "right";
-                                  xPosition = point.x - yOffset;
-                              }
-                              else {
-                                  ctx.textAlign = "left";
-                                  xPosition = point.x + yOffset;
-                              }
-                          }
-                          else {
-                              xPosition = point.x;
-                              if (value < 0) {
-                                  ctx.textBaseline = "top";
-                                  yPosition = point.y + yOffset;
-                              }
-                              else {
-                                  ctx.textBaseline = "bottom";
-                                  yPosition = point.y - yOffset;
-                              }
-                          }
-                          ctx.strokeText(displayedValue, xPosition, yPosition);
-                          ctx.fillText(displayedValue, xPosition, yPosition);
-                      }
-                      break;
-                  }
-              }
-          });
+          ctx.miterLimit = 1; // Avoid sharp artifacts on strokeText
+          switch (chart.config.type) {
+              case "pie":
+              case "doughnut":
+                  drawPieChartValues(chart, options, ctx);
+                  break;
+              case "bar":
+              case "line":
+                  options.horizontal
+                      ? drawHorizontalBarChartValues(chart, options, ctx)
+                      : drawLineOrBarChartValues(chart, options, ctx);
+                  break;
+          }
           ctx.restore();
       },
   };
+  function drawTextWithBackground(text, x, y, ctx) {
+      ctx.lineWidth = 3; // Stroke the text with a big lineWidth width to have some kind of background
+      ctx.strokeText(text, x, y);
+      ctx.lineWidth = 1;
+      ctx.fillText(text, x, y);
+  }
+  function drawLineOrBarChartValues(chart, options, ctx) {
+      const yMax = chart.chartArea.bottom;
+      const yMin = chart.chartArea.top;
+      const textsPositions = {};
+      for (const dataset of chart._metasets) {
+          if (dataset.xAxisID === TREND_LINE_XAXIS_ID) {
+              return; // ignore trend lines
+          }
+          for (let i = 0; i < dataset._parsed.length; i++) {
+              const value = dataset._parsed[i].y;
+              const displayValue = options.callback(value - 0, dataset.yAxisID);
+              const point = dataset.data[i];
+              const xPosition = point.x;
+              let yPosition = 0;
+              if (chart.config.type === "line") {
+                  yPosition = point.y - 10;
+              }
+              else {
+                  yPosition = value < 0 ? point.y - point.height / 2 : point.y + point.height / 2;
+              }
+              yPosition = Math.min(yPosition, yMax);
+              yPosition = Math.max(yPosition, yMin);
+              // Avoid overlapping texts with same X
+              if (!textsPositions[xPosition]) {
+                  textsPositions[xPosition] = [];
+              }
+              for (const otherPosition of textsPositions[xPosition] || []) {
+                  if (Math.abs(otherPosition - yPosition) < 13) {
+                      yPosition = otherPosition - 13;
+                  }
+              }
+              textsPositions[xPosition].push(yPosition);
+              ctx.fillStyle = point.options.backgroundColor;
+              ctx.strokeStyle = options.background || "#ffffff";
+              drawTextWithBackground(displayValue, xPosition, yPosition, ctx);
+          }
+      }
+  }
+  function drawHorizontalBarChartValues(chart, options, ctx) {
+      const xMax = chart.chartArea.right;
+      const xMin = chart.chartArea.left;
+      const textsPositions = {};
+      for (const dataset of chart._metasets) {
+          if (dataset.xAxisID === TREND_LINE_XAXIS_ID) {
+              return; // ignore trend lines
+          }
+          for (let i = 0; i < dataset._parsed.length; i++) {
+              const value = dataset._parsed[i].x;
+              const displayValue = options.callback(value - 0, dataset.xAxisID);
+              const point = dataset.data[i];
+              const yPosition = point.y;
+              let xPosition = value < 0 ? point.x + point.width / 2 : point.x - point.width / 2;
+              xPosition = Math.min(xPosition, xMax);
+              xPosition = Math.max(xPosition, xMin);
+              // Avoid overlapping texts with same Y
+              if (!textsPositions[yPosition]) {
+                  textsPositions[yPosition] = [];
+              }
+              const textWidth = computeTextWidth(ctx, displayValue, { fontSize: 12 }, "px");
+              for (const otherPosition of textsPositions[yPosition]) {
+                  if (Math.abs(otherPosition - xPosition) < textWidth) {
+                      xPosition = otherPosition + textWidth + 3;
+                  }
+              }
+              textsPositions[yPosition].push(xPosition);
+              ctx.fillStyle = point.options.backgroundColor;
+              ctx.strokeStyle = options.background || "#ffffff";
+              drawTextWithBackground(displayValue, xPosition, yPosition, ctx);
+          }
+      }
+  }
+  function drawPieChartValues(chart, options, ctx) {
+      for (const dataset of chart._metasets) {
+          for (let i = 0; i < dataset._parsed.length; i++) {
+              const bar = dataset.data[i];
+              const { startAngle, endAngle, innerRadius, outerRadius } = bar;
+              const midAngle = (startAngle + endAngle) / 2;
+              const midRadius = (innerRadius + outerRadius) / 2;
+              const x = bar.x + midRadius * Math.cos(midAngle);
+              const y = bar.y + midRadius * Math.sin(midAngle) + 7;
+              ctx.fillStyle = chartFontColor(options.background);
+              ctx.strokeStyle = options.background || "#ffffff";
+              const value = options.callback(dataset._parsed[i]);
+              drawTextWithBackground(value, x, y, ctx);
+          }
+      }
+  }
 
   /** This is a chartJS plugin that will draw connector lines between the bars of a Waterfall chart */
   const waterfallLinesPlugin = {
@@ -10244,8 +10346,7 @@ stores.inject(MyMetaStore, storeInstance);
           value = value.slice(index + 1);
       }
       pendingHtmlContent.push({ value });
-      const htmlContent = pendingHtmlContent.filter((content) => content.value);
-      return htmlContent;
+      return pendingHtmlContent.filter((content) => content.value);
   }
 
   //------------------------------------------------------------------------------
@@ -10649,7 +10750,7 @@ stores.inject(MyMetaStore, storeInstance);
           assertSquareMatrix(_t("The argument square_matrix must have the same number of columns and rows."), _matrix);
           const { inverted } = invertMatrix(_matrix);
           if (!inverted) {
-              throw new EvaluationError(_t("The matrix is not invertible."));
+              return new EvaluationError(_t("The matrix is not invertible."));
           }
           return inverted;
       },
@@ -10728,7 +10829,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
       }
       if (!validPairFound) {
-          throw new EvaluationError(_t("The arguments array_x and array_y must contain at least one pair of numbers."));
+          return new EvaluationError(_t("The arguments array_x and array_y must contain at least one pair of numbers."));
       }
       return result;
   }
@@ -10809,7 +10910,7 @@ stores.inject(MyMetaStore, storeInstance);
               .flat()
               .filter(shouldKeepValue(_ignore));
           if (result.length === 0) {
-              throw new NotAvailableError(_t("No results for the given arguments of TOCOL."));
+              return new NotAvailableError(_t("No results for the given arguments of TOCOL."));
           }
           return [result];
       },
@@ -10830,7 +10931,7 @@ stores.inject(MyMetaStore, storeInstance);
               .filter(shouldKeepValue(_ignore))
               .map((item) => [item]);
           if (result.length === 0 || result[0].length === 0) {
-              throw new NotAvailableError(_t("No results for the given arguments of TOROW."));
+              return new NotAvailableError(_t("No results for the given arguments of TOROW."));
           }
           return result;
       },
@@ -11390,7 +11491,7 @@ stores.inject(MyMetaStore, storeInstance);
            * Return error if 'value' is positive.
            * Remove '-?' in the next regex to catch this error.
            */
-          assert(() => !!DECIMAL_REPRESENTATION.test(_value), _t("The value (%s) must be a valid base %s representation.", _value, _base.toString()));
+          assert(() => DECIMAL_REPRESENTATION.test(_value), _t("The value (%s) must be a valid base %s representation.", _value, _base.toString()));
           const deci = parseInt(_value, _base);
           assert(() => !isNaN(deci), _t("The value (%s) must be a valid base %s representation.", _value, _base.toString()));
           return deci;
@@ -11658,7 +11759,7 @@ stores.inject(MyMetaStore, storeInstance);
                               count += 1;
                           }
                           if (isEvaluationError(f)) {
-                              throw j;
+                              return j;
                           }
                       }
                   }
@@ -12161,9 +12262,8 @@ stores.inject(MyMetaStore, storeInstance);
   }
   function variance(args, isSample, textAs0, locale) {
       let count = 0;
-      let sum = 0;
       const reduceFunction = textAs0 ? reduceNumbersTextAs0 : reduceNumbers;
-      sum = reduceFunction(args, (acc, a) => {
+      const sum = reduceFunction(args, (acc, a) => {
           count += 1;
           return acc + a;
       }, 0, locale);
@@ -12560,7 +12660,7 @@ stores.inject(MyMetaStore, storeInstance);
           const flatY = dataY.flat();
           assertSameNumberOfElements(flatX, flatY);
           if (flatX.length === 0) {
-              throw new EvaluationError(_t("[[FUNCTION_NAME]] expects non-empty ranges for both parameters."));
+              return new EvaluationError(_t("[[FUNCTION_NAME]] expects non-empty ranges for both parameters."));
           }
           const n = flatX.length;
           let trueN = 0, trueP = 0, falseP = 0, falseN = 0;
@@ -13360,9 +13460,8 @@ stores.inject(MyMetaStore, storeInstance);
       // 4 - return for each database row corresponding, the cells corresponding to the field parameter
       const fieldCol = database[index];
       // Example continuation:: fieldCol = ["C", "j", "k", 7]
-      const matchingCells = [...matchingRows].map((x) => fieldCol[x + 1]);
       // Example continuation:: matchingCells = ["j", 7]
-      return matchingCells;
+      return [...matchingRows].map((x) => fieldCol[x + 1]);
   }
   const databaseArgs = [
       arg("database (range)", _t("The array or range containing the data to consider, structured in such a way that the first row contains the labels for each column's values.")),
@@ -14547,7 +14646,7 @@ stores.inject(MyMetaStore, storeInstance);
               }
           }
           if (!result.length) {
-              throw new NotAvailableError(_t("No match found in FILTER evaluation"));
+              return new NotAvailableError(_t("No match found in FILTER evaluation"));
           }
           return mode === "row" ? transposeMatrix(result) : result;
       },
@@ -17245,7 +17344,7 @@ stores.inject(MyMetaStore, storeInstance);
               argsTokens[argPosition].push({ value: token.value, type: token.type });
           }
       }
-      const res = tokens.map((token, i) => {
+      return tokens.map((token, i) => {
           if (!["SPACE", "LEFT_PAREN"].includes(token.type)) {
               functionStarted = "";
           }
@@ -17283,7 +17382,6 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return token;
       });
-      return res;
   }
   /**
    * Parse the list of tokens that compose the arguments of a function to
@@ -17739,7 +17837,7 @@ stores.inject(MyMetaStore, storeInstance);
                   return result;
               }
           }
-          throw new EvaluationError(_t("No match."));
+          return new EvaluationError(_t("No match."));
       },
       isExported: true,
   };
@@ -17842,7 +17940,7 @@ stores.inject(MyMetaStore, storeInstance);
           throw new EvaluationError(_t("Function PIVOT takes an even number of arguments."));
       }
   }
-  function addPivotDependencies(evalContext, coreDefinition) {
+  function addPivotDependencies(evalContext, coreDefinition, forMeasures) {
       //TODO This function can be very costly when used with PIVOT.VALUE and PIVOT.HEADER
       const dependencies = [];
       if (coreDefinition.type === "SPREADSHEET" && coreDefinition.dataSet) {
@@ -17854,7 +17952,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           dependencies.push(range);
       }
-      for (const measure of coreDefinition.measures) {
+      for (const measure of forMeasures) {
           if (measure.computedBy) {
               const formula = evalContext.getters.getMeasureCompiledFormula(measure);
               dependencies.push(...formula.dependencies.filter((range) => !range.invalidXc));
@@ -17903,8 +18001,8 @@ stores.inject(MyMetaStore, storeInstance);
           let cellReference;
           if (_useA1Notation) {
               const rangePart = {
-                  rowFixed: [1, 2].includes(_absoluteRelativeMode) ? true : false,
-                  colFixed: [1, 3].includes(_absoluteRelativeMode) ? true : false,
+                  rowFixed: [1, 2].includes(_absoluteRelativeMode),
+                  colFixed: [1, 3].includes(_absoluteRelativeMode),
               };
               cellReference = toXC(colNumber - 1, rowNumber - 1, rangePart);
           }
@@ -17930,7 +18028,7 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (cellReference) {
           if (isEvaluationError(cellReference?.value)) {
-              throw cellReference;
+              return cellReference;
           }
           const column = cellReference === undefined
               ? this.__originCellPosition?.col
@@ -17948,7 +18046,7 @@ stores.inject(MyMetaStore, storeInstance);
       args: [arg("range (meta)", _t("The range whose column count will be returned."))],
       compute: function (range) {
           if (isEvaluationError(range?.value)) {
-              throw range;
+              return range;
           }
           const zone = toZone(range.value);
           return zone.right - zone.left + 1;
@@ -18028,11 +18126,11 @@ stores.inject(MyMetaStore, storeInstance);
       compute: function (reference, useA1Notation = { value: true }) {
           let _reference = reference?.value?.toString();
           if (!_reference) {
-              throw new InvalidReferenceError(_t("Reference should be defined."));
+              return new InvalidReferenceError(_t("Reference should be defined."));
           }
           const _useA1Notation = toBoolean(useA1Notation);
           if (!_useA1Notation) {
-              throw new EvaluationError(_t("R1C1 notation is not supported."));
+              return new EvaluationError(_t("R1C1 notation is not supported."));
           }
           const sheetId = this.__originSheetId;
           const originPosition = this.__originCellPosition;
@@ -18044,7 +18142,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const range = this.getters.getRangeFromSheetXC(sheetId, _reference);
           if (range === undefined || range.invalidXc || range.invalidSheetName) {
-              throw new InvalidReferenceError();
+              return new InvalidReferenceError();
           }
           if (originPosition) {
               this.addDependencies?.(originPosition, [range]);
@@ -18152,7 +18250,7 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (cellReference) {
           if (isEvaluationError(cellReference?.value)) {
-              throw cellReference;
+              return cellReference;
           }
           const row = cellReference === undefined
               ? this.__originCellPosition?.row
@@ -18170,7 +18268,7 @@ stores.inject(MyMetaStore, storeInstance);
       args: [arg("range (meta)", _t("The range whose row count will be returned."))],
       compute: function (range) {
           if (isEvaluationError(range?.value)) {
-              throw range;
+              return range;
           }
           const zone = toZone(range.value);
           return zone.bottom - zone.top + 1;
@@ -18287,7 +18385,7 @@ stores.inject(MyMetaStore, storeInstance);
           assertDomainLength(domainArgs);
           const pivot = this.getters.getPivot(pivotId);
           const coreDefinition = this.getters.getPivotCoreDefinition(pivotId);
-          addPivotDependencies(this, coreDefinition);
+          addPivotDependencies(this, coreDefinition, coreDefinition.measures.filter((m) => m.id === _measure));
           pivot.init({ reload: pivot.needsReevaluation });
           const error = pivot.assertIsValid({ throwOnError: false });
           if (error) {
@@ -18317,7 +18415,7 @@ stores.inject(MyMetaStore, storeInstance);
           assertDomainLength(domainArgs);
           const pivot = this.getters.getPivot(_pivotId);
           const coreDefinition = this.getters.getPivotCoreDefinition(_pivotId);
-          addPivotDependencies(this, coreDefinition);
+          addPivotDependencies(this, coreDefinition, []);
           pivot.init({ reload: pivot.needsReevaluation });
           const error = pivot.assertIsValid({ throwOnError: false });
           if (error) {
@@ -18357,18 +18455,18 @@ stores.inject(MyMetaStore, storeInstance);
           const _pivotFormulaId = toString(pivotFormulaId);
           const _rowCount = toNumber(rowCount, this.locale);
           if (_rowCount < 0) {
-              throw new EvaluationError(_t("The number of rows must be positive."));
+              return new EvaluationError(_t("The number of rows must be positive."));
           }
           const _columnCount = toNumber(columnCount, this.locale);
           if (_columnCount < 0) {
-              throw new EvaluationError(_t("The number of columns must be positive."));
+              return new EvaluationError(_t("The number of columns must be positive."));
           }
           const _includeColumnHeaders = toBoolean(includeColumnHeaders);
           const _includedTotal = toBoolean(includeTotal);
           const pivotId = getPivotId(_pivotFormulaId, this.getters);
           const pivot = this.getters.getPivot(pivotId);
           const coreDefinition = this.getters.getPivotCoreDefinition(pivotId);
-          addPivotDependencies(this, coreDefinition);
+          addPivotDependencies(this, coreDefinition, coreDefinition.measures);
           pivot.init({ reload: pivot.needsReevaluation });
           const error = pivot.assertIsValid({ throwOnError: false });
           if (error) {
@@ -18560,6 +18658,12 @@ stores.inject(MyMetaStore, storeInstance);
           arg("value2 (any)", _t("The value to test against value1 for equality.")),
       ],
       compute: function (value1, value2) {
+          if (isEvaluationError(value1?.value)) {
+              return value1;
+          }
+          if (isEvaluationError(value2?.value)) {
+              return value2;
+          }
           let _value1 = isEmpty(value1) ? getNeutral[typeof value2?.value] : value1?.value;
           let _value2 = isEmpty(value2) ? getNeutral[typeof value1?.value] : value2?.value;
           if (typeof _value1 === "string") {
@@ -18568,27 +18672,21 @@ stores.inject(MyMetaStore, storeInstance);
           if (typeof _value2 === "string") {
               _value2 = _value2.toUpperCase();
           }
-          if (isEvaluationError(_value1)) {
-              throw value1;
-          }
-          if (isEvaluationError(_value2)) {
-              throw value2;
-          }
-          return _value1 === _value2;
+          return { value: _value1 === _value2 };
       },
   };
   // -----------------------------------------------------------------------------
   // GT
   // -----------------------------------------------------------------------------
   function applyRelationalOperator(value1, value2, cb) {
-      let _value1 = isEmpty(value1) ? getNeutral[typeof value2?.value] : value1?.value;
-      let _value2 = isEmpty(value2) ? getNeutral[typeof value1?.value] : value2?.value;
-      if (isEvaluationError(_value1)) {
-          throw value1;
+      if (isEvaluationError(value1?.value)) {
+          return value1;
       }
-      if (isEvaluationError(_value2)) {
-          throw value2;
+      if (isEvaluationError(value2?.value)) {
+          return value2;
       }
+      let _value1 = isEmpty(value1) ? getNeutral[typeof value2?.value] : value1?.value;
+      let _value2 = isEmpty(value2) ? getNeutral[typeof value1?.value] : value2?.value;
       if (typeof _value1 !== "number") {
           _value1 = toString(_value1).toUpperCase();
       }
@@ -18598,12 +18696,12 @@ stores.inject(MyMetaStore, storeInstance);
       const tV1 = typeof _value1;
       const tV2 = typeof _value2;
       if (tV1 === "string" && tV2 === "number") {
-          return true;
+          return { value: true };
       }
       if (tV2 === "string" && tV1 === "number") {
-          return false;
+          return { value: false };
       }
-      return cb(_value1, _value2);
+      return { value: cb(_value1, _value2) };
   }
   const GT = {
       description: _t("Strictly greater than."),
@@ -18642,7 +18740,11 @@ stores.inject(MyMetaStore, storeInstance);
           arg("value2 (any)", _t("The second value.")),
       ],
       compute: function (value1, value2) {
-          return !GTE.compute.bind(this)(value1, value2);
+          const result = GTE.compute.bind(this)(value1, value2);
+          if (isEvaluationError(result.value)) {
+              return result;
+          }
+          return { value: !result.value };
       },
   };
   // -----------------------------------------------------------------------------
@@ -18655,7 +18757,11 @@ stores.inject(MyMetaStore, storeInstance);
           arg("value2 (any)", _t("The second value.")),
       ],
       compute: function (value1, value2) {
-          return !GT.compute.bind(this)(value1, value2);
+          const result = GT.compute.bind(this)(value1, value2);
+          if (isEvaluationError(result.value)) {
+              return result;
+          }
+          return { value: !result.value };
       },
   };
   // -----------------------------------------------------------------------------
@@ -18700,7 +18806,11 @@ stores.inject(MyMetaStore, storeInstance);
           arg("value2 (any)", _t("The value to test against value1 for inequality.")),
       ],
       compute: function (value1, value2) {
-          return !EQ.compute.bind(this)(value1, value2);
+          const result = EQ.compute.bind(this)(value1, value2);
+          if (isEvaluationError(result.value)) {
+              return result;
+          }
+          return { value: !result.value };
       },
   };
   // -----------------------------------------------------------------------------
@@ -19859,13 +19969,12 @@ stores.inject(MyMetaStore, storeInstance);
   }
   function getElementMargins(el) {
       const style = window.getComputedStyle(el);
-      const margins = {
+      return {
           top: parseInt(style.marginTop, 10) || 0,
           bottom: parseInt(style.marginBottom, 10) || 0,
           left: parseInt(style.marginLeft, 10) || 0,
           right: parseInt(style.marginRight, 10) || 0,
       };
-      return margins;
   }
 
   const macRegex = /Mac/i;
@@ -20164,7 +20273,7 @@ stores.inject(MyMetaStore, storeInstance);
               let startNode = this.findChildAtCharacterIndex(start);
               let endNode = this.findChildAtCharacterIndex(end);
               range.setStart(startNode.node, startNode.offset);
-              selection.extend(endNode.node, endNode.offset);
+              range.setEnd(endNode.node, endNode.offset);
           }
       }
       /**
@@ -20662,7 +20771,7 @@ stores.inject(MyMetaStore, storeInstance);
           "Alt+Enter": this.processNewLineEvent,
           "Ctrl+Enter": this.processNewLineEvent,
           Escape: this.processEscapeKey,
-          F2: () => console.warn("Not implemented"),
+          F2: (ev) => this.toggleEditionMode(ev),
           F4: (ev) => this.processF4Key(ev),
           Tab: (ev) => this.processTabKey(ev, "right"),
           "Shift+Tab": (ev) => this.processTabKey(ev, "left"),
@@ -20781,6 +20890,11 @@ stores.inject(MyMetaStore, storeInstance);
           this.props.composerStore.cycleReferences();
           this.processContent();
       }
+      toggleEditionMode(ev) {
+          ev.stopPropagation();
+          this.props.composerStore.toggleEditionMode();
+          this.processContent();
+      }
       processNumpadDecimal(ev) {
           ev.stopPropagation();
           ev.preventDefault();
@@ -21006,7 +21120,13 @@ stores.inject(MyMetaStore, storeInstance);
                       break;
                   case "REFERENCE":
                       const { xc, sheetName } = splitReference(token.value);
-                      result.push({ value: token.value, color: this.rangeColor(xc, sheetName) || "#000" });
+                      result.push({
+                          value: token.value,
+                          color: this.rangeColor(xc, sheetName) || "#000",
+                          class: tokenAtCursor === token && this.props.composerStore.editionMode === "selecting"
+                              ? "text-decoration-underline"
+                              : undefined,
+                      });
                       break;
                   case "SYMBOL":
                       const value = token.value;
@@ -21577,6 +21697,7 @@ stores.inject(MyMetaStore, storeInstance);
           // replace the whole token
           start = tokenAtCursor.start;
       }
+      this.composer.stopComposerRangeSelection();
       this.composer.changeComposerCursorSelection(start, end);
       this.composer.replaceComposerCursorSelection(value);
   }
@@ -21594,6 +21715,7 @@ stores.inject(MyMetaStore, storeInstance);
           // replace the whole token
           start = tokenAtCursor.start;
       }
+      this.composer.stopComposerRangeSelection();
       this.composer.changeComposerCursorSelection(start, end);
       this.composer.replaceComposerCursorSelection(value);
   }
@@ -21727,9 +21849,13 @@ stores.inject(MyMetaStore, storeInstance);
           const colFields = columns.map((groupBy) => groupBy.nameWithGranularity);
           const rowFields = rows.map((groupBy) => groupBy.nameWithGranularity);
           const proposals = [];
-          const previousGroupBy = ["ARG_SEPARATOR", "SPACE"].includes(tokenAtCursor.type)
+          let previousGroupBy = ["ARG_SEPARATOR", "SPACE"].includes(tokenAtCursor.type)
               ? argGroupBys.at(-1)
               : argGroupBys.at(-2);
+          const isPositionalSupported = supportedPivotPositionalFormulaRegistry.get(pivot.type);
+          if (isPositionalSupported && previousGroupBy?.startsWith("#")) {
+              previousGroupBy = previousGroupBy.slice(1);
+          }
           if (previousGroupBy === undefined) {
               proposals.push(colFields[0]);
               proposals.push(rowFields[0]);
@@ -21751,7 +21877,7 @@ stores.inject(MyMetaStore, storeInstance);
               return field ? makeFieldProposal(field, granularity) : undefined;
           })
               .concat(groupBys.map((groupBy) => {
-              if (!supportedPivotPositionalFormulaRegistry.get(pivot.type)) {
+              if (!isPositionalSupported) {
                   return undefined;
               }
               const fieldName = groupBy.split(":")[0];
@@ -21760,13 +21886,12 @@ stores.inject(MyMetaStore, storeInstance);
                   return undefined;
               }
               const positionalFieldArg = `"#${groupBy}"`;
-              const positionalProposal = {
+              return {
                   text: positionalFieldArg,
                   description: _t("%s (positional)", field.string) + (field.help ? ` (${field.help})` : ""),
                   htmlContent: [{ value: positionalFieldArg, color: tokenColors.STRING }],
                   fuzzySearchKey: field.string + positionalFieldArg, // search on translated name and on technical name
               };
-              return positionalProposal;
           }))
               .filter(isDefined);
       },
@@ -22035,7 +22160,7 @@ stores.inject(MyMetaStore, storeInstance);
           return internalDate.value;
       }
       if (isBoolean(content)) {
-          return content.toUpperCase() === "TRUE" ? true : false;
+          return content.toUpperCase() === "TRUE";
       }
       return content;
   }
@@ -22186,6 +22311,27 @@ stores.inject(MyMetaStore, storeInstance);
               tooltip: content ? { props: { content: tooltipValue } } : undefined,
           };
       },
+  })
+      .add("DATE_INCREMENT_MODIFIER", {
+      apply: (rule, data, getters) => {
+          const date = toJsDate(rule.current, getters.getLocale());
+          date.setFullYear(date.getFullYear() + rule.increment.years || 0);
+          date.setMonth(date.getMonth() + rule.increment.months || 0);
+          date.setDate(date.getDate() + rule.increment.days || 0);
+          const value = jsDateToNumber(date);
+          rule.current = value;
+          const locale = getters.getLocale();
+          const tooltipValue = formatValue(value, { format: data.cell?.format, locale });
+          return {
+              cellData: {
+                  border: data.border,
+                  style: data.cell && data.cell.style,
+                  format: data.cell && data.cell.format,
+                  content: value.toString(),
+              },
+              tooltip: value ? { props: { content: tooltipValue } } : undefined,
+          };
+      },
   })
       .add("COPY_MODIFIER", {
       apply: (rule, data, getters) => {
@@ -22266,7 +22412,9 @@ stores.inject(MyMetaStore, storeInstance);
           if (x === cell) {
               found = true;
           }
-          const cellValue = x === undefined || x.isFormula ? undefined : evaluateLiteral(x, { locale: DEFAULT_LOCALE });
+          const cellValue = x === undefined || x.isFormula
+              ? undefined
+              : evaluateLiteral(x, { locale: DEFAULT_LOCALE, format: x.format });
           if (cellValue && filter(cellValue)) {
               group.push(cellValue);
           }
@@ -22302,6 +22450,71 @@ stores.inject(MyMetaStore, storeInstance);
       }
       return increment;
   }
+  /**
+   * Iterates on a list of date intervals.
+   * if every interval is the same, return the interval
+   * Otherwise return undefined
+   *
+   */
+  function getEqualInterval(intervals) {
+      if (intervals.length < 2) {
+          return intervals[0] || { years: 0, months: 0, days: 0 };
+      }
+      const equal = intervals.every((interval) => interval.years === intervals[0].years &&
+          interval.months === intervals[0].months &&
+          interval.days === intervals[0].days);
+      return equal ? intervals[0] : undefined;
+  }
+  /**
+   * Based on a group of dates, calculate the increment that should be applied
+   * to the next date.
+   *
+   * This will compute the date difference in calendar terms (years, months, days)
+   * In order to make abstraction of leap years and months with different number of days.
+   *
+   * In case the dates are not equidistant in calendar terms, no rule can be extrapolated
+   * In case of equidistant dates, we either have in that order:
+   *  - exact date interval (e.g. +n year OR +n month OR +n day) in which case we increment by the same interval
+   *  - exact day interval (e.g. +n days) in which case we increment by the same day interval
+   *  - equidistant dates but not the same interval, in which case we return increment of the same interval
+   *
+   * */
+  function calculateDateIncrementBasedOnGroup(group) {
+      if (group.length < 2) {
+          return 1;
+      }
+      const jsDates = group.map((date) => toJsDate(date, DEFAULT_LOCALE));
+      const datesIntervals = getDateIntervals(jsDates);
+      const datesEquidistantInterval = getEqualInterval(datesIntervals);
+      if (datesEquidistantInterval === undefined) {
+          // dates are not equidistant in terms of years, months or days, thus no rule can be extrapolated
+          return undefined;
+      }
+      // The dates are apart by an exact interval of years, months or days
+      // but not a combination of them
+      const exactDateInterval = Object.values(datesEquidistantInterval).filter((value) => value !== 0).length === 1;
+      const isSameDay = Object.values(datesEquidistantInterval).every((el) => el === 0); // handles time values (strict decimals)
+      if (!exactDateInterval || isSameDay) {
+          const timeIntervals = jsDates
+              .map((date, index) => {
+              if (index === 0) {
+                  return 0;
+              }
+              const previous = jsDates[index - 1];
+              return Math.floor(date.getTime()) - Math.floor(previous.getTime());
+          })
+              .slice(1);
+          const equidistantDates = timeIntervals.every((interval) => interval === timeIntervals[0]);
+          if (equidistantDates) {
+              return group.length * (group[1] - group[0]);
+          }
+      }
+      return {
+          years: datesEquidistantInterval.years * group.length,
+          months: datesEquidistantInterval.months * group.length,
+          days: datesEquidistantInterval.days * group.length,
+      };
+  }
   autofillRulesRegistry
       .add("simple_value_copy", {
       condition: (cell, cells) => {
@@ -22349,12 +22562,47 @@ stores.inject(MyMetaStore, storeInstance);
           return { type: "FORMULA_MODIFIER", increment: cells.length, current: 0 };
       },
       sequence: 30,
+  })
+      .add("increment_dates", {
+      condition: (cell, cells) => {
+          return (!cell.isFormula &&
+              evaluateLiteral(cell, { locale: DEFAULT_LOCALE }).type === CellValueType.number &&
+              !!cell.format &&
+              isDateTimeFormat(cell.format));
+      },
+      generateRule: (cell, cells) => {
+          const group = getGroup(cell, cells, (evaluatedCell) => evaluatedCell.type === CellValueType.number &&
+              !!evaluatedCell.format &&
+              isDateTimeFormat(evaluatedCell.format)).map((cell) => Number(cell.value));
+          const increment = calculateDateIncrementBasedOnGroup(group);
+          if (increment === undefined) {
+              return { type: "COPY_MODIFIER" };
+          }
+          /**  requires to detect the current date (requires to be an integer value  with the right format)
+           * detect  if year  or if month or if day then extrapolate increment required (+1 month, +1 year + 1 day)
+           */
+          const evaluation = evaluateLiteral(cell, { locale: DEFAULT_LOCALE });
+          if (typeof increment === "object") {
+              return {
+                  type: "DATE_INCREMENT_MODIFIER",
+                  increment,
+                  current: evaluation.type === CellValueType.number ? evaluation.value : 0,
+              };
+          }
+          return {
+              type: "INCREMENT_MODIFIER",
+              increment,
+              current: evaluation.type === CellValueType.number ? evaluation.value : 0,
+          };
+      },
+      sequence: 25,
   })
       .add("increment_number", {
       condition: (cell) => !cell.isFormula &&
           evaluateLiteral(cell, { locale: DEFAULT_LOCALE }).type === CellValueType.number,
       generateRule: (cell, cells) => {
-          const group = getGroup(cell, cells, (evaluatedCell) => evaluatedCell.type === CellValueType.number).map((cell) => Number(cell.value));
+          const group = getGroup(cell, cells, (evaluatedCell) => evaluatedCell.type === CellValueType.number &&
+              !isDateTimeFormat(evaluatedCell.format || "")).map((cell) => Number(cell.value));
           const increment = calculateIncrementBasedOnGroup(group);
           const evaluation = evaluateLiteral(cell, { locale: DEFAULT_LOCALE });
           return {
@@ -22365,6 +22613,37 @@ stores.inject(MyMetaStore, storeInstance);
       },
       sequence: 40,
   });
+  /**
+   * Returns the date intervals between consecutive dates of an array
+   * in the format of { years: number, months: number, days: number }
+   *
+   * The split is necessary to make abstraction of leap years and
+   * months with different number of days.
+   *
+   * @param dates
+   */
+  function getDateIntervals(dates) {
+      if (dates.length < 2) {
+          return [{ years: 0, months: 0, days: 0 }];
+      }
+      const res = dates.map((date, index) => {
+          if (index === 0) {
+              return { years: 0, months: 0, days: 0 };
+          }
+          const previous = DateTime.fromTimestamp(dates[index - 1].getTime());
+          const years = getTimeDifferenceInWholeYears(previous, date);
+          const months = getTimeDifferenceInWholeMonths(previous, date) % 12;
+          previous.setFullYear(previous.getFullYear() + years);
+          previous.setMonth(previous.getMonth() + months);
+          const days = getTimeDifferenceInWholeDays(previous, date);
+          return {
+              years,
+              months,
+              days,
+          };
+      });
+      return res.slice(1);
+  }
 
   const cellPopoverRegistry = new Registry();
 
@@ -22781,6 +23060,7 @@ stores.inject(MyMetaStore, storeInstance);
       "surface3DChart",
       "bubbleChart",
       "comboChart",
+      "radarChart",
   ];
 
   /** In XLSX color format (no #)  */
@@ -23321,7 +23601,7 @@ stores.inject(MyMetaStore, storeInstance);
       lineChart: "line",
       line3DChart: undefined,
       stockChart: undefined,
-      radarChart: undefined,
+      radarChart: "radar",
       scatterChart: "scatter",
       pieChart: "pie",
       pie3DChart: undefined,
@@ -24734,7 +25014,7 @@ stores.inject(MyMetaStore, storeInstance);
       custom: _t("Custom"),
   };
   const DEFAULT_TABLE_CONFIG = {
-      hasFilters: true,
+      hasFilters: false,
       totalRow: false,
       firstColumn: false,
       lastColumn: false,
@@ -25403,12 +25683,11 @@ stores.inject(MyMetaStore, storeInstance);
        * Get the list of all the XLSX files in the XLSX file structure
        */
       getListOfXMLFiles() {
-          const XMLFiles = Object.entries(this.xlsxFileStructure)
+          return Object.entries(this.xlsxFileStructure)
               .filter(([key]) => key !== "images")
               .map(([_, value]) => value)
               .flat()
               .filter(isDefined);
-          return XMLFiles;
       }
       /**
        * Return an array containing the return value of the given function applied to all the XML elements
@@ -25572,13 +25851,12 @@ stores.inject(MyMetaStore, storeInstance);
               rgb = this.extractAttr(colorElement, "rgb")?.asString();
               rgb = rgb === DEFAULT_SYSTEM_COLOR ? undefined : rgb;
           }
-          const color = {
+          return {
               rgb: rgb || defaultColor,
               auto: this.extractAttr(colorElement, "auto")?.asBool(),
               indexed: this.extractAttr(colorElement, "indexed")?.asNum(),
               tint: this.extractAttr(colorElement, "tint")?.asNum(),
           };
-          return color;
       }
       /**
        * Returns the xml file targeted by a relationship.
@@ -26170,7 +26448,7 @@ stores.inject(MyMetaStore, storeInstance);
                   hyperlinks: this.extractHyperLinks(sheetElement),
                   tables: this.extractTables(sheetElement),
                   pivotTables: this.extractPivotTables(),
-                  isVisible: sheetWorkbookInfo.state === "visible" ? true : false,
+                  isVisible: sheetWorkbookInfo.state === "visible",
               };
           })[0];
       }
@@ -26241,8 +26519,7 @@ stores.inject(MyMetaStore, storeInstance);
           const figures = this.mapOnElements({ parent: worksheet, query: "drawing" }, (drawingElement) => {
               const drawingId = this.extractAttr(drawingElement, "r:id", { required: true })?.asString();
               const drawingFile = this.getTargetXmlFile(this.relationships[drawingId]);
-              const figures = new XlsxFigureExtractor(drawingFile, this.xlsxFileStructure, this.warningManager).extractFigures();
-              return figures;
+              return new XlsxFigureExtractor(drawingFile, this.xlsxFileStructure, this.warningManager).extractFigures();
           })[0];
           return figures || [];
       }
@@ -26260,8 +26537,7 @@ stores.inject(MyMetaStore, storeInstance);
                   .filter((relationship) => relationship.type.endsWith("pivotTable"))
                   .map((pivotRelationship) => {
                   const pivotFile = this.getTargetXmlFile(pivotRelationship);
-                  const pivot = new XlsxPivotExtractor(pivotFile, this.xlsxFileStructure, this.warningManager).getPivotTable();
-                  return pivot;
+                  return new XlsxPivotExtractor(pivotFile, this.xlsxFileStructure, this.warningManager).getPivotTable();
               });
           }
           catch (e) {
@@ -26660,8 +26936,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       convertXlsx() {
           const xlsxData = this.getXlsxData();
-          const convertedData = this.convertImportedData(xlsxData);
-          return convertedData;
+          return this.convertImportedData(xlsxData);
       }
       // ---------------------------------------------------------------------------
       // Parsing XMLs
@@ -27252,6 +27527,20 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return data;
       },
+  })
+      .add("migration_22", {
+      // "tables are no longer inserted with filters by default",
+      versionFrom: "22",
+      migrate(data) {
+          for (const sheet of data.sheets || []) {
+              for (const table of sheet.tables || []) {
+                  if (!table.config) {
+                      table.config = { ...DEFAULT_TABLE_CONFIG, hasFilters: true };
+                  }
+              }
+          }
+          return data;
+      },
   });
   function fixOverlappingFilters(data) {
       for (let sheet of data.sheets || []) {
@@ -27279,7 +27568,7 @@ stores.inject(MyMetaStore, storeInstance);
    * a breaking change is made in the way the state is handled, and an upgrade
    * function should be defined
    */
-  const CURRENT_VERSION = 22;
+  const CURRENT_VERSION = 23;
   const INITIAL_SHEET_ID = "Sheet1";
   /**
    * This function tries to load anything that could look like a valid
@@ -27292,7 +27581,7 @@ stores.inject(MyMetaStore, storeInstance);
       if (!data) {
           return createEmptyWorkbookData();
       }
-      console.group("Loading data");
+      console.debug("### Loading data ###");
       const start = performance.now();
       if (data["[Content_Types].xml"]) {
           const reader = new XlsxReader(data);
@@ -27306,13 +27595,13 @@ stores.inject(MyMetaStore, storeInstance);
       // apply migrations, if needed
       if ("version" in data) {
           if (data.version < CURRENT_VERSION) {
-              console.info("Migrating data from version", data.version);
+              console.debug("Migrating data from version", data.version);
               data = migrate(data);
           }
       }
       data = repairData(data);
-      console.info("Data loaded in", performance.now() - start, "ms");
-      console.groupEnd();
+      console.debug("Data loaded in", performance.now() - start, "ms");
+      console.debug("###");
       return data;
   }
   // -----------------------------------------------------------------------------
@@ -27342,7 +27631,7 @@ stores.inject(MyMetaStore, storeInstance);
       for (let i = index; i < steps.length; i++) {
           data = steps[i].migrate(data);
       }
-      console.info("Data migrated in", performance.now() - start, "ms");
+      console.debug("Data migrated in", performance.now() - start, "ms");
       return data;
   }
   /**
@@ -27524,7 +27813,7 @@ stores.inject(MyMetaStore, storeInstance);
       };
   }
   function createEmptyWorkbookData(sheetName = "Sheet1") {
-      const data = {
+      return {
           version: CURRENT_VERSION,
           sheets: [createEmptySheet(INITIAL_SHEET_ID, sheetName)],
           styles: {},
@@ -27537,7 +27826,6 @@ stores.inject(MyMetaStore, storeInstance);
           pivotNextId: 1,
           customTableStyles: {},
       };
-      return data;
   }
   function createEmptyExcelSheet(sheetId, name) {
       return {
@@ -27875,9 +28163,9 @@ stores.inject(MyMetaStore, storeInstance);
   /**
    * Get a default chart js configuration
    */
-  function getDefaultChartJsRuntime(chart, labels, fontColor, { format, locale, truncateLabels = true, horizontalChart, }) {
+  function getDefaultChartJsRuntime(chart, labels, fontColor, { axisFormats, locale, truncateLabels = true, horizontalChart }) {
       const chartTitle = chart.title.text ? chart.title : { ...chart.title, content: "" };
-      const options = {
+      const chartOptions = {
           // https://www.chartjs.org/docs/latest/general/responsive.html
           responsive: true, // will resize when its container is resized
           maintainAspectRatio: false, // doesn't maintain the aspect ration (width/height =2 by default) so the user has the choice of the exact layout
@@ -27921,11 +28209,13 @@ stores.inject(MyMetaStore, storeInstance);
                           const xLabel = tooltipItem.dataset?.label || tooltipItem.label;
                           // tooltipItem.parsed can be an object or a number for pie charts
                           let yLabel = horizontalChart ? tooltipItem.parsed.x : tooltipItem.parsed.y;
-                          if (!yLabel) {
+                          if (yLabel === undefined || yLabel === null) {
                               yLabel = tooltipItem.parsed;
                           }
-                          const toolTipFormat = !format && Math.abs(yLabel) >= 1000 ? "#,##" : format;
-                          const yLabelStr = formatValue(yLabel, { format: toolTipFormat, locale });
+                          const axisId = horizontalChart
+                              ? tooltipItem.dataset.xAxisID
+                              : tooltipItem.dataset.yAxisID;
+                          const yLabelStr = formatChartDatasetValue(axisFormats, locale)(yLabel, axisId);
                           return xLabel ? `${xLabel}: ${yLabelStr}` : yLabelStr;
                       },
                   },
@@ -27934,7 +28224,7 @@ stores.inject(MyMetaStore, storeInstance);
       };
       return {
           type: chart.type,
-          options,
+          options: chartOptions,
           data: {
               labels: truncateLabels ? labels.map(truncateLabel) : labels,
               datasets: [],
@@ -27993,7 +28283,8 @@ stores.inject(MyMetaStore, storeInstance);
    * Get the format to apply to the the dataset values. This format is defined as the first format
    * found in the dataset ranges that isn't a date format.
    */
-  function getChartDatasetFormat(getters, dataSets) {
+  function getChartDatasetFormat(getters, allDataSets, axis) {
+      const dataSets = allDataSets.filter((ds) => (axis === "right") === !!ds.rightYAxis);
       for (const ds of dataSets) {
           const formatsInDataset = getters.getRangeFormats(ds.dataRange);
           const format = formatsInDataset.find((f) => f !== undefined && !isDateTimeFormat(f));
@@ -28247,12 +28538,16 @@ stores.inject(MyMetaStore, storeInstance);
       if (chart.aggregated) {
           ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
       }
-      const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets);
+      const leftAxisFormat = getChartDatasetFormat(getters, chart.dataSets, "left");
+      const rightAxisFormat = getChartDatasetFormat(getters, chart.dataSets, "right");
       const locale = getters.getLocale();
-      const localeFormat = { format: dataSetFormat, locale };
       const fontColor = chartFontColor(chart.background);
+      const axisFormats = chart.horizontal
+          ? { x: leftAxisFormat || rightAxisFormat }
+          : { y: leftAxisFormat, y1: rightAxisFormat };
       const config = getDefaultChartJsRuntime(chart, labels, fontColor, {
-          ...localeFormat,
+          locale,
+          axisFormats,
           horizontalChart: chart.horizontal,
       });
       const legend = {
@@ -28273,51 +28568,27 @@ stores.inject(MyMetaStore, storeInstance);
       };
       config.options.indexAxis = chart.horizontal ? "y" : "x";
       config.options.scales = {};
-      const labelsAxis = { ticks: { padding: 5, color: fontColor } };
-      const valuesAxis = {
-          beginAtZero: true, // the origin of the y axis is always zero
-          ticks: {
-              color: fontColor,
-              callback: formatTickValue(localeFormat),
-          },
-      };
-      const xAxis = chart.horizontal ? valuesAxis : labelsAxis;
-      const yAxis = chart.horizontal ? labelsAxis : valuesAxis;
-      const { useLeftAxis, useRightAxis } = getDefinedAxis(chart.getDefinition());
-      config.options.scales.x = { ...xAxis, title: getChartAxisTitleRuntime(chart.axesDesign?.x) };
-      if (useLeftAxis) {
-          config.options.scales.y = {
-              ...yAxis,
-              position: "left",
-              title: getChartAxisTitleRuntime(chart.axesDesign?.y),
-          };
-      }
-      if (useRightAxis) {
-          config.options.scales.y1 = {
-              ...yAxis,
-              position: "right",
-              title: getChartAxisTitleRuntime(chart.axesDesign?.y1),
-          };
+      const definition = chart.getDefinition();
+      const options = { stacked: chart.stacked, locale };
+      if (chart.horizontal) {
+          const format = leftAxisFormat || rightAxisFormat;
+          config.options.scales.x = getChartAxis(definition, "bottom", "values", { ...options, format });
+          config.options.scales.y = getChartAxis(definition, "left", "labels", options);
       }
-      if (chart.stacked) {
-          // @ts-ignore chart.js type is broken
-          config.options.scales.x.stacked = true;
-          if (useLeftAxis) {
-              // @ts-ignore chart.js type is broken
-              config.options.scales.y.stacked = true;
-          }
-          if (useRightAxis) {
-              // @ts-ignore chart.js type is broken
-              config.options.scales.y1.stacked = true;
-          }
+      else {
+          config.options.scales.x = getChartAxis(definition, "bottom", "labels", options);
+          const leftAxisOptions = { ...options, format: leftAxisFormat };
+          config.options.scales.y = getChartAxis(definition, "left", "values", leftAxisOptions);
+          const rightAxisOptions = { ...options, format: rightAxisFormat };
+          config.options.scales.y1 = getChartAxis(definition, "right", "values", rightAxisOptions);
       }
+      config.options.scales = removeFalsyAttributes(config.options.scales);
       config.options.plugins.chartShowValuesPlugin = {
           showValues: chart.showValues,
           background: chart.background,
           horizontal: chart.horizontal,
-          callback: formatTickValue(localeFormat),
+          callback: formatChartDatasetValue(axisFormats, locale),
       };
-      const definition = chart.getDefinition();
       const colors = getChartColorsGenerator(definition, dataSetsValues.length);
       const trendDatasets = [];
       for (const index in dataSetsValues) {
@@ -28332,12 +28603,10 @@ stores.inject(MyMetaStore, storeInstance);
           };
           config.data.datasets.push(dataset);
           if (definition.dataSets?.[index]?.label) {
-              const label = definition.dataSets[index].label;
-              dataset.label = label;
-          }
-          if (definition.dataSets?.[index]?.yAxisId && !chart.horizontal) {
-              dataset["yAxisID"] = definition.dataSets[index].yAxisId;
+              dataset.label = definition.dataSets[index].label;
           }
+          dataset.yAxisID = chart.horizontal ? "y" : definition.dataSets[index].yAxisId || "y";
+          dataset.xAxisID = "x";
           const trend = definition.dataSets?.[index].trend;
           if (!trend?.display || chart.horizontal) {
               continue;
@@ -28353,7 +28622,7 @@ stores.inject(MyMetaStore, storeInstance);
            */
           const maxLength = Math.max(...trendDatasets.map((trendDataset) => trendDataset.data.length));
           config.options.scales[TREND_LINE_XAXIS_ID] = {
-              ...xAxis,
+              ...config.options.scales.x,
               labels: Array(maxLength).fill(""),
               offset: false,
               display: false,
@@ -28362,13 +28631,10 @@ stores.inject(MyMetaStore, storeInstance);
            * datasets to ensure the way we distinguish the originals and trendLine datasets after
            */
           trendDatasets.forEach((x) => config.data.datasets.push(x));
-          const originalTooltipTitle = config.options.plugins.tooltip.callbacks.title;
           config.options.plugins.tooltip.callbacks.title = function (tooltipItems) {
-              if (tooltipItems.some((item) => item.dataset.xAxisID !== TREND_LINE_XAXIS_ID)) {
-                  // @ts-expect-error
-                  return originalTooltipTitle?.(tooltipItems);
-              }
-              return "";
+              return tooltipItems.some((item) => item.dataset.xAxisID !== TREND_LINE_XAXIS_ID)
+                  ? undefined
+                  : "";
           };
       }
       return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
@@ -28643,8 +28909,10 @@ stores.inject(MyMetaStore, storeInstance);
       }
       const locale = getters.getLocale();
       const truncateLabels = axisType === "category";
-      const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets);
-      const options = { format: dataSetFormat, locale, truncateLabels };
+      const leftAxisFormat = getChartDatasetFormat(getters, chart.dataSets, "left");
+      const rightAxisFormat = getChartDatasetFormat(getters, chart.dataSets, "right");
+      const axisFormats = { y: leftAxisFormat, y1: rightAxisFormat };
+      const options = { locale, truncateLabels, axisFormats };
       const fontColor = chartFontColor(chart.background);
       const config = getDefaultChartJsRuntime(chart, labels, fontColor, options);
       const legend = {
@@ -28674,52 +28942,18 @@ stores.inject(MyMetaStore, storeInstance);
               displayLegend: chart.legendPosition === "top",
           }),
       };
-      const xAxis = {
-          ticks: {
-              padding: 5,
-              color: fontColor,
-          },
-          title: getChartAxisTitleRuntime(chart.axesDesign?.x),
-      };
+      const definition = chart.getDefinition();
+      const stacked = "stacked" in chart && chart.stacked;
       config.options.scales = {
-          x: xAxis,
-      };
-      const yAxis = {
-          beginAtZero: true, // the origin of the y axis is always zero
-          ticks: {
-              color: fontColor,
-              callback: formatTickValue(options),
-          },
+          x: getChartAxis(definition, "bottom", "labels", { locale }),
+          y: getChartAxis(definition, "left", "values", { locale, stacked, format: leftAxisFormat }),
+          y1: getChartAxis(definition, "right", "values", { locale, stacked, format: rightAxisFormat }),
       };
-      const { useLeftAxis, useRightAxis } = getDefinedAxis(chart.getDefinition());
-      if (useLeftAxis) {
-          config.options.scales.y = {
-              ...yAxis,
-              position: "left",
-              title: getChartAxisTitleRuntime(chart.axesDesign?.y),
-          };
-      }
-      if (useRightAxis) {
-          config.options.scales.y1 = {
-              ...yAxis,
-              position: "right",
-              title: getChartAxisTitleRuntime(chart.axesDesign?.y1),
-          };
-      }
-      if ("stacked" in chart && chart.stacked) {
-          if (useLeftAxis) {
-              // @ts-ignore chart.js type is broken
-              config.options.scales.y.stacked = true;
-          }
-          if (useRightAxis) {
-              // @ts-ignore chart.js type is broken
-              config.options.scales.y1.stacked = true;
-          }
-      }
+      config.options.scales = removeFalsyAttributes(config.options.scales);
       config.options.plugins.chartShowValuesPlugin = {
           showValues: chart.showValues,
           background: chart.background,
-          callback: formatTickValue(options),
+          callback: formatChartDatasetValue(axisFormats, locale),
       };
       if (chart.dataSetsHaveTitle &&
           dataSetsValues[0] &&
@@ -28738,7 +28972,6 @@ stores.inject(MyMetaStore, storeInstance);
       else if (axisType === "linear") {
           config.options.scales.x.type = "linear";
           config.options.scales.x.ticks.callback = (value) => formatValue(value, { format: labelFormat, locale });
-          config.options.plugins.tooltip.callbacks.title = () => "";
           config.options.plugins.tooltip.callbacks.label = (tooltipItem) => {
               const dataSetPoint = dataSetsValues[tooltipItem.datasetIndex].data[tooltipItem.dataIndex];
               let label = tooltipItem.label || labelValues.values[tooltipItem.dataIndex];
@@ -28746,7 +28979,7 @@ stores.inject(MyMetaStore, storeInstance);
                   label = toNumber(label, locale);
               }
               const formattedX = formatValue(label, { locale, format: labelFormat });
-              const formattedY = formatValue(dataSetPoint, { locale, format: dataSetFormat });
+              const formattedY = formatValue(dataSetPoint, { locale, format: leftAxisFormat });
               const dataSetTitle = tooltipItem.dataset.label;
               return formattedX
                   ? `${dataSetTitle}: (${formattedX}, ${formattedY})`
@@ -28756,7 +28989,6 @@ stores.inject(MyMetaStore, storeInstance);
       const areaChart = "fillArea" in chart ? chart.fillArea : false;
       const stackedChart = "stacked" in chart ? chart.stacked : false;
       const cumulative = "cumulative" in chart ? chart.cumulative : false;
-      const definition = chart.getDefinition();
       const colors = getChartColorsGenerator(definition, dataSetsValues.length);
       for (let [index, { label, data }] of dataSetsValues.entries()) {
           const color = colors.next();
@@ -28794,12 +29026,9 @@ stores.inject(MyMetaStore, storeInstance);
       const trendDatasets = [];
       for (const [index, dataset] of config.data.datasets.entries()) {
           if (definition.dataSets?.[index]?.label) {
-              const label = definition.dataSets[index].label;
-              dataset.label = label;
-          }
-          if (definition.dataSets?.[index]?.yAxisId) {
-              dataset["yAxisID"] = definition.dataSets[index].yAxisId;
+              dataset.label = definition.dataSets[index].label;
           }
+          dataset["yAxisID"] = definition.dataSets[index].yAxisId || "y";
           const trend = definition.dataSets?.[index].trend;
           if (!trend?.display) {
               continue;
@@ -28816,7 +29045,7 @@ stores.inject(MyMetaStore, storeInstance);
            * set so that the second axis points match the classical x axis
            */
           config.options.scales[TREND_LINE_XAXIS_ID] = {
-              ...xAxis,
+              ...config.options.scales.x,
               type: "category",
               labels: range(0, maxLength).map((x) => x.toString()),
               offset: false,
@@ -28826,22 +29055,15 @@ stores.inject(MyMetaStore, storeInstance);
            * distinguish the originals and trendLine datasets after
            */
           trendDatasets.forEach((x) => config.data.datasets.push(x));
-          const originalTooltipTitle = config.options.plugins.tooltip.callbacks.title;
-          config.options.plugins.tooltip.callbacks.title = function (tooltipItems) {
-              if (tooltipItems.some((item) => item.dataset.xAxisID !== TREND_LINE_XAXIS_ID)) {
-                  // @ts-expect-error
-                  return originalTooltipTitle?.(tooltipItems);
-              }
-              return "";
-          };
       }
+      config.options.plugins.tooltip.callbacks.title = function (tooltipItems) {
+          const displayTooltipTitle = axisType !== "linear" &&
+              tooltipItems.some((item) => item.dataset.xAxisID !== TREND_LINE_XAXIS_ID);
+          return displayTooltipTitle ? undefined : "";
+      };
       return {
           chartJsConfig: config,
           background: chart.background || BACKGROUND_CHART_COLOR,
-          dataSetsValues,
-          labelValues,
-          dataSetFormat,
-          labelFormat,
       };
   }
 
@@ -28899,6 +29121,7 @@ stores.inject(MyMetaStore, storeInstance);
               ranges.push({
                   ...this.dataSetDesign?.[i],
                   dataRange: this.getters.getRangeString(dataSet.dataRange, targetSheetId || this.sheetId),
+                  type: this.dataSetDesign?.[i]?.type ?? (i ? "line" : "bar"),
               });
           }
           return {
@@ -28944,9 +29167,13 @@ stores.inject(MyMetaStore, storeInstance);
           return new ComboChart(definition, this.sheetId, this.getters);
       }
       static getDefinitionFromContextCreation(context) {
+          const dataSets = (context.range ?? []).map((ds, index) => ({
+              ...ds,
+              type: index ? "line" : "bar",
+          }));
           return {
               background: context.background,
-              dataSets: context.range ?? [],
+              dataSets,
               dataSetsHaveTitle: context.dataSetsHaveTitle ?? false,
               aggregated: context.aggregated,
               legendPosition: context.legendPosition ?? "top",
@@ -28969,10 +29196,8 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
   function createComboChartRuntime(chart, getters) {
-      const mainDataSetFormat = chart.dataSets.length
-          ? getChartDatasetFormat(getters, [chart.dataSets[0]])
-          : undefined;
-      const lineDataSetsFormat = getChartDatasetFormat(getters, chart.dataSets.slice(1));
+      const mainDataSetFormat = getChartDatasetFormat(getters, chart.dataSets, "left");
+      const lineDataSetsFormat = getChartDatasetFormat(getters, chart.dataSets, "right");
       const locale = getters.getLocale();
       const labelValues = getChartLabelValues(getters, chart.dataSets, chart.labelRange);
       let labels = labelValues.formattedValues;
@@ -28986,12 +29211,11 @@ stores.inject(MyMetaStore, storeInstance);
       if (chart.aggregated) {
           ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
       }
-      const localeFormat = { format: mainDataSetFormat, locale };
       const fontColor = chartFontColor(chart.background);
-      const config = getDefaultChartJsRuntime(chart, labels, fontColor, localeFormat);
+      const axisFormats = { y: mainDataSetFormat, y1: lineDataSetsFormat };
+      const config = getDefaultChartJsRuntime(chart, labels, fontColor, { locale, axisFormats });
       const legend = {
           labels: { color: fontColor },
-          reverse: true,
       };
       if (chart.legendPosition === "none") {
           legend.display = false;
@@ -29006,52 +29230,17 @@ stores.inject(MyMetaStore, storeInstance);
               displayLegend: chart.legendPosition === "top",
           }),
       };
+      const definition = chart.getDefinition();
       config.options.scales = {
-          x: {
-              ticks: {
-                  padding: 5,
-                  color: fontColor,
-              },
-              title: getChartAxisTitleRuntime(chart.axesDesign?.x),
-          },
+          x: getChartAxis(definition, "bottom", "labels", { locale }),
+          y: getChartAxis(definition, "left", "values", { locale, format: mainDataSetFormat }),
+          y1: getChartAxis(definition, "right", "values", { locale, format: lineDataSetsFormat }),
       };
-      const leftVerticalAxis = {
-          beginAtZero: true, // the origin of the y axis is always zero
-          ticks: {
-              color: fontColor,
-              callback: formatTickValue({ format: mainDataSetFormat, locale }),
-          },
-      };
-      const rightVerticalAxis = {
-          beginAtZero: true, // the origin of the y axis is always zero
-          ticks: {
-              color: fontColor,
-              callback: formatTickValue({ format: lineDataSetsFormat, locale }),
-          },
-      };
-      const definition = chart.getDefinition();
-      const { useLeftAxis, useRightAxis } = getDefinedAxis(definition);
-      if (useLeftAxis) {
-          config.options.scales.y = {
-              ...leftVerticalAxis,
-              position: "left",
-              title: getChartAxisTitleRuntime(chart.axesDesign?.y),
-          };
-      }
-      if (useRightAxis) {
-          config.options.scales.y1 = {
-              ...rightVerticalAxis,
-              position: "right",
-              grid: {
-                  display: false,
-              },
-              title: getChartAxisTitleRuntime(chart.axesDesign?.y1),
-          };
-      }
+      config.options.scales = removeFalsyAttributes(config.options.scales);
       config.options.plugins.chartShowValuesPlugin = {
           showValues: chart.showValues,
           background: chart.background,
-          callback: formatTickValue({ format: mainDataSetFormat, locale }),
+          callback: formatChartDatasetValue(axisFormats, locale),
       };
       const colors = getChartColorsGenerator(definition, dataSetsValues.length);
       let maxLength = 0;
@@ -29059,14 +29248,15 @@ stores.inject(MyMetaStore, storeInstance);
       for (let [index, { label, data }] of dataSetsValues.entries()) {
           const design = definition.dataSets[index];
           const color = colors.next();
+          const type = design?.type ?? "line";
           const dataset = {
               label: design?.label ?? label,
               data,
               borderColor: color,
               backgroundColor: color,
               yAxisID: design?.yAxisId ?? "y",
-              type: index === 0 ? "bar" : "line",
-              order: -index,
+              type,
+              order: type === "bar" ? dataSetsValues.length + index : index,
           };
           config.data.datasets.push(dataset);
           const trend = definition.dataSets?.[index].trend;
@@ -29093,13 +29283,10 @@ stores.inject(MyMetaStore, storeInstance);
            * distinguish the originals and trendLine datasets after
            */
           trendDatasets.forEach((x) => config.data.datasets.push(x));
-          const originalTooltipTitle = config.options.plugins.tooltip.callbacks.title;
           config.options.plugins.tooltip.callbacks.title = function (tooltipItems) {
-              if (tooltipItems.some((item) => item.dataset.xAxisID !== TREND_LINE_XAXIS_ID)) {
-                  // @ts-expect-error
-                  return originalTooltipTitle?.(tooltipItems);
-              }
-              return "";
+              return tooltipItems.some((item) => item.dataset.xAxisID !== TREND_LINE_XAXIS_ID)
+                  ? undefined
+                  : "";
           };
       }
       return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
@@ -29679,7 +29866,7 @@ stores.inject(MyMetaStore, storeInstance);
           ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
       }
       ({ dataSetsValues, labels } = filterNegativeValues(labels, dataSetsValues));
-      const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets);
+      const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets, "left");
       const locale = getters.getLocale();
       const config = getPieConfiguration(chart, labels, { format: dataSetFormat, locale });
       const dataSetsLength = Math.max(0, ...dataSetsValues.map((ds) => ds?.data?.length ?? 0));
@@ -29834,7 +30021,199 @@ stores.inject(MyMetaStore, storeInstance);
           return tooltipLabelCallback(tooltipItem);
       };
       const callback = config.options.plugins.chartShowValuesPlugin.callback;
-      config.options.plugins.chartShowValuesPlugin.callback = (x) => callback(Math.abs(x));
+      config.options.plugins.chartShowValuesPlugin.callback = (x, axisId) => callback(Math.abs(x), axisId);
+      return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
+  }
+
+  class RadarChart extends AbstractChart {
+      dataSets;
+      labelRange;
+      background;
+      legendPosition;
+      stacked;
+      aggregated;
+      type = "radar";
+      dataSetsHaveTitle;
+      dataSetDesign;
+      fillArea;
+      constructor(definition, sheetId, getters) {
+          super(definition, sheetId, getters);
+          this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
+          this.labelRange = createValidRange(getters, sheetId, definition.labelRange);
+          this.background = definition.background;
+          this.legendPosition = definition.legendPosition;
+          this.stacked = definition.stacked;
+          this.aggregated = definition.aggregated;
+          this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
+          this.dataSetDesign = definition.dataSets;
+          this.fillArea = definition.fillArea;
+      }
+      static transformDefinition(definition, executed) {
+          return transformChartDefinitionWithDataSetsWithZone(definition, executed);
+      }
+      static validateChartDefinition(validator, definition) {
+          return validator.checkValidations(definition, checkDataset, checkLabelRange);
+      }
+      static getDefinitionFromContextCreation(context) {
+          return {
+              background: context.background,
+              dataSets: context.range ?? [],
+              dataSetsHaveTitle: context.dataSetsHaveTitle ?? false,
+              stacked: context.stacked ?? false,
+              aggregated: context.aggregated ?? false,
+              legendPosition: context.legendPosition ?? "top",
+              title: context.title || { text: "" },
+              type: "radar",
+              labelRange: context.auxiliaryRange || undefined,
+              fillArea: context.fillArea ?? false,
+          };
+      }
+      getContextCreation() {
+          const range = [];
+          for (const [i, dataSet] of this.dataSets.entries()) {
+              range.push({
+                  ...this.dataSetDesign?.[i],
+                  dataRange: this.getters.getRangeString(dataSet.dataRange, this.sheetId),
+              });
+          }
+          return {
+              ...this,
+              range,
+              auxiliaryRange: this.labelRange
+                  ? this.getters.getRangeString(this.labelRange, this.sheetId)
+                  : undefined,
+          };
+      }
+      copyForSheetId(sheetId) {
+          const dataSets = copyDataSetsWithNewSheetId(this.sheetId, sheetId, this.dataSets);
+          const labelRange = copyLabelRangeWithNewSheetId(this.sheetId, sheetId, this.labelRange);
+          const definition = this.getDefinitionWithSpecificDataSets(dataSets, labelRange, sheetId);
+          return new RadarChart(definition, sheetId, this.getters);
+      }
+      copyInSheetId(sheetId) {
+          const definition = this.getDefinitionWithSpecificDataSets(this.dataSets, this.labelRange, sheetId);
+          return new RadarChart(definition, sheetId, this.getters);
+      }
+      getDefinition() {
+          return this.getDefinitionWithSpecificDataSets(this.dataSets, this.labelRange);
+      }
+      getDefinitionWithSpecificDataSets(dataSets, labelRange, targetSheetId) {
+          const ranges = [];
+          for (const [i, dataSet] of dataSets.entries()) {
+              ranges.push({
+                  ...this.dataSetDesign?.[i],
+                  dataRange: this.getters.getRangeString(dataSet.dataRange, targetSheetId || this.sheetId),
+              });
+          }
+          return {
+              type: "radar",
+              dataSetsHaveTitle: dataSets.length ? Boolean(dataSets[0].labelCell) : false,
+              background: this.background,
+              dataSets: ranges,
+              legendPosition: this.legendPosition,
+              labelRange: labelRange
+                  ? this.getters.getRangeString(labelRange, targetSheetId || this.sheetId)
+                  : undefined,
+              title: this.title,
+              stacked: this.stacked,
+              aggregated: this.aggregated,
+              fillArea: this.fillArea,
+          };
+      }
+      getDefinitionForExcel() {
+          if (this.aggregated) {
+              return undefined;
+          }
+          const dataSets = this.dataSets
+              .map((ds) => toExcelDataset(this.getters, ds))
+              .filter((ds) => ds.range !== "" && ds.range !== CellErrorType.InvalidReference);
+          const labelRange = toExcelLabelRange(this.getters, this.labelRange, shouldRemoveFirstLabel(this.labelRange, this.dataSets[0], this.dataSetsHaveTitle));
+          const definition = this.getDefinition();
+          return {
+              ...definition,
+              backgroundColor: toXlsxHexColor(this.background || BACKGROUND_CHART_COLOR),
+              fontColor: toXlsxHexColor(chartFontColor(this.background)),
+              dataSets,
+              labelRange,
+          };
+      }
+      updateRanges(applyChange) {
+          const { dataSets, labelRange, isStale } = updateChartRangesWithDataSets(this.getters, applyChange, this.dataSets, this.labelRange);
+          if (!isStale) {
+              return this;
+          }
+          const definition = this.getDefinitionWithSpecificDataSets(dataSets, labelRange);
+          return new RadarChart(definition, this.sheetId, this.getters);
+      }
+  }
+  function createRadarChartRuntime(chart, getters) {
+      const definition = chart.getDefinition();
+      const labelValues = getChartLabelValues(getters, chart.dataSets, chart.labelRange);
+      let labels = labelValues.formattedValues;
+      let dataSetsValues = getChartDatasetValues(getters, chart.dataSets);
+      if (chart.dataSetsHaveTitle &&
+          dataSetsValues[0] &&
+          labels.length > dataSetsValues[0].data.length) {
+          labels.shift();
+      }
+      ({ labels, dataSetsValues } = filterEmptyDataPoints(labels, dataSetsValues));
+      if (chart.aggregated) {
+          ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
+      }
+      const leftAxisFormat = getChartDatasetFormat(getters, chart.dataSets, "left");
+      const rightAxisFormat = getChartDatasetFormat(getters, chart.dataSets, "right");
+      const axisFormats = { y: leftAxisFormat, y1: rightAxisFormat };
+      const locale = getters.getLocale();
+      const fontColor = chartFontColor(chart.background);
+      const config = getDefaultChartJsRuntime(chart, labels, fontColor, {
+          axisFormats,
+          locale,
+      });
+      const legend = {
+          labels: { color: fontColor },
+      };
+      if ((!chart.labelRange && chart.dataSets.length === 1) || chart.legendPosition === "none") {
+          legend.display = false;
+      }
+      else {
+          legend.position = chart.legendPosition;
+      }
+      const fill = definition.fillArea ?? false;
+      if (!fill) {
+          legend.labels["boxHeight"] = 0;
+      }
+      config.options.plugins.legend = { ...config.options.plugins?.legend, ...legend };
+      config.options.plugins.tooltip = {
+          ...config.options.plugins?.tooltip,
+          callbacks: {
+              label: function (tooltipItem) {
+                  const xLabel = tooltipItem.dataset?.label || tooltipItem.label;
+                  const yLabel = tooltipItem.parsed.r;
+                  return xLabel ? `${xLabel}: ${yLabel}` : yLabel.toString();
+              },
+          },
+      };
+      config.options.layout = {
+          padding: { left: 20, right: 20, top: chart.title ? 10 : 25, bottom: 10 },
+      };
+      const colorGenerator = getChartColorsGenerator(definition, dataSetsValues.length);
+      for (let i = 0; i < dataSetsValues.length; i++) {
+          let { label, data } = dataSetsValues[i];
+          if (definition.dataSets?.[i]?.label) {
+              label = definition.dataSets[i].label;
+          }
+          const borderColor = colorGenerator.next();
+          const dataset = {
+              label,
+              data,
+              borderColor,
+          };
+          if (fill) {
+              dataset.backgroundColor = setColorAlpha(borderColor, 0.3);
+              dataset["fill"] = true;
+          }
+          config.data.datasets.push(dataset);
+      }
       return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
   }
 
@@ -30225,7 +30604,8 @@ stores.inject(MyMetaStore, storeInstance);
       if (chart.showSubTotals) {
           labels.push(_t("Subtotal"));
       }
-      const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets);
+      const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets, "left") ||
+          getChartDatasetFormat(getters, chart.dataSets, "right");
       const locale = getters.getLocale();
       const dataSeriesLabels = dataSetsValues.map((dataSet) => dataSet.label);
       const config = getWaterfallConfiguration(chart, labels, dataSeriesLabels, {
@@ -30359,6 +30739,15 @@ stores.inject(MyMetaStore, storeInstance);
       getChartDefinitionFromContextCreation: PyramidChart.getDefinitionFromContextCreation,
       sequence: 80,
   });
+  chartRegistry.add("radar", {
+      match: (type) => type === "radar",
+      createChart: (definition, sheetId, getters) => new RadarChart(definition, sheetId, getters),
+      getChartRuntime: createRadarChartRuntime,
+      validateChartDefinition: RadarChart.validateChartDefinition,
+      transformDefinition: RadarChart.transformDefinition,
+      getChartDefinitionFromContextCreation: RadarChart.getDefinitionFromContextCreation,
+      sequence: 80,
+  });
   const chartComponentRegistry = new Registry();
   chartComponentRegistry.add("line", ChartJsComponent);
   chartComponentRegistry.add("bar", ChartJsComponent);
@@ -30369,6 +30758,7 @@ stores.inject(MyMetaStore, storeInstance);
   chartComponentRegistry.add("scorecard", ScorecardChart);
   chartComponentRegistry.add("waterfall", ChartJsComponent);
   chartComponentRegistry.add("pyramid", ChartJsComponent);
+  chartComponentRegistry.add("radar", ChartJsComponent);
   const chartCategories = {
       line: _t("Line"),
       column: _t("Column"),
@@ -30510,6 +30900,24 @@ stores.inject(MyMetaStore, storeInstance);
       chartType: "pyramid",
       category: "misc",
       preview: "o-spreadsheet-ChartPreview.POPULATION_PYRAMID_CHART",
+  })
+      .add("radar", {
+      matcher: (definition) => definition.type === "radar" && !definition.fillArea,
+      displayName: _t("Radar"),
+      chartSubtype: "radar",
+      chartType: "radar",
+      subtypeDefinition: { fillArea: false },
+      category: "misc",
+      preview: "o-spreadsheet-ChartPreview.RADAR_CHART",
+  })
+      .add("filled_radar", {
+      matcher: (definition) => definition.type === "radar" && !!definition.fillArea,
+      displayName: _t("Filled Radar"),
+      chartType: "radar",
+      chartSubtype: "filled_radar",
+      subtypeDefinition: { fillArea: true },
+      category: "misc",
+      preview: "o-spreadsheet-ChartPreview.FILLED_RADAR_CHART",
   });
 
   /**
@@ -30577,11 +30985,10 @@ stores.inject(MyMetaStore, storeInstance);
       const rect = getters.getVisibleRect(getters.getActiveMainViewport());
       const scrollableViewportWidth = Math.min(rect.width, dim.width - offsetCorrectionX);
       const scrollableViewportHeight = Math.min(rect.height, dim.height - offsetCorrectionY);
-      const position = {
+      return {
           x: offsetCorrectionX + scrollX + Math.max(0, (scrollableViewportWidth - size.width) / 2),
           y: offsetCorrectionY + scrollY + Math.max(0, (scrollableViewportHeight - size.height) / 2),
       }; // Position at the center of the scrollable viewport
-      return position;
   }
   function getMaxFigureSize(getters, figureSize) {
       const size = deepCopy(figureSize);
@@ -31154,14 +31561,13 @@ stores.inject(MyMetaStore, storeInstance);
           const shouldRenderAtBottom = this.shouldRenderAtBottom(elDims.height);
           const shouldRenderAtRight = this.shouldRenderAtRight(elDims.width);
           verticalOffset = shouldRenderAtBottom ? verticalOffset : -verticalOffset;
-          const cssProperties = {
+          return {
               top: this.getTopCoordinate(actualHeight, shouldRenderAtBottom) -
                   this.spreadsheetOffset.y -
                   verticalOffset +
                   "px",
               left: this.getLeftCoordinate(actualWidth, shouldRenderAtRight) - this.spreadsheetOffset.x + "px",
           };
-          return cssProperties;
       }
       getCurrentPosition(elDims) {
           const shouldRenderAtBottom = this.shouldRenderAtBottom(elDims.height);
@@ -32389,7 +32795,7 @@ stores.inject(MyMetaStore, storeInstance);
    * Create a table on the selected zone, with UI warnings to the user if the creation fails.
    * If a single cell is selected, expand the selection to non-empty adjacent cells to create a table.
    */
-  function interactiveCreateTable(env, sheetId, tableConfig) {
+  function interactiveCreateTable(env, sheetId, tableConfig = DEFAULT_TABLE_CONFIG) {
       let target = env.model.getters.getSelectedZones();
       let isDynamic = env.model.getters.canCreateDynamicTableOnZones(sheetId, target);
       if (target.length === 1 && !isDynamic && getZoneArea(target[0]) === 1) {
@@ -33448,7 +33854,7 @@ stores.inject(MyMetaStore, storeInstance);
   }
 
   const pivotProperties = {
-      name: _t("Edit Pivot"),
+      name: _t("See pivot properties"),
       execute(env) {
           const position = env.model.getters.getActivePosition();
           const pivotId = env.model.getters.getPivotIdFromPosition(position);
@@ -33602,8 +34008,7 @@ stores.inject(MyMetaStore, storeInstance);
   })
       .add("pivot_properties", {
       ...pivotProperties,
-      sequence: 160,
-      separator: true,
+      sequence: 170,
   });
 
   const sortRange = {
@@ -35295,6 +35700,7 @@ stores.inject(MyMetaStore, storeInstance);
   <path fill='none' stroke='#FFF' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='m6 10 3 3 6-6'/>
 </svg>
 `;
+  const CHECKBOX_WIDTH = 14;
   css /* scss */ `
   label.o-checkbox {
     input {
@@ -35302,8 +35708,8 @@ stores.inject(MyMetaStore, storeInstance);
       -webkit-appearance: none;
       -moz-appearance: none;
       border-radius: 0;
-      width: 14px;
-      height: 14px;
+      width: ${CHECKBOX_WIDTH}px;
+      height: ${CHECKBOX_WIDTH}px;
       vertical-align: top;
       box-sizing: border-box;
       outline: none;
@@ -35349,6 +35755,7 @@ stores.inject(MyMetaStore, storeInstance);
       static template = "o_spreadsheet.Section";
       static props = {
           class: { type: String, optional: true },
+          title: { type: String, optional: true },
           slots: Object,
       };
   }
@@ -36078,17 +36485,11 @@ stores.inject(MyMetaStore, storeInstance);
               stacked,
           });
       }
-      onUpdateAggregated(aggregated) {
-          this.props.updateChart(this.props.figureId, {
-              aggregated,
-          });
-      }
   }
 
   css /* scss */ `
   .o_side_panel_collapsible_title {
     font-size: 16px;
-    font-weight: bold;
     cursor: pointer;
     padding: 6px 0px 6px 6px !important;
 
@@ -36125,49 +36526,40 @@ stores.inject(MyMetaStore, storeInstance);
       static template = "o-spreadsheet-SidePanelCollapsible";
       static props = {
           slots: Object,
+          title: { type: String, optional: true },
           collapsedAtInit: { type: Boolean, optional: true },
           class: { type: String, optional: true },
       };
       currentId = (CURRENT_COLLAPSIBLE_ID++).toString();
   }
 
-  const CIRCLE_SVG = /*xml*/ `
-<svg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'>
-  <circle r="2" fill="#FFF"/>
-</svg>
-`;
   css /* scss */ `
-  .o-radio {
-    input {
-      appearance: none;
-      -webkit-appearance: none;
-      -moz-appearance: none;
-      width: 14px;
-      height: 14px;
-      border: 1px solid ${GRAY_300};
-      box-sizing: border-box;
-      outline: none;
-      border-radius: 8px;
-
-      &:checked {
-        background: url("data:image/svg+xml,${encodeURIComponent(CIRCLE_SVG)}");
-        background-color: ${ACTION_COLOR};
+  .o-badge-selection {
+    gap: 1px;
+    button.o-button {
+      border-radius: 0;
+      &.selected {
+        color: ${GRAY_900};
         border-color: ${ACTION_COLOR};
+        background: ${BADGE_SELECTED_COLOR};
+        font-weight: 600;
+      }
+
+      &:first-child {
+        border-radius: 4px 0 0 4px;
+      }
+      &:last-child {
+        border-radius: 0 4px 4px 0;
       }
     }
   }
 `;
-  class RadioSelection extends owl.Component {
-      static template = "o-spreadsheet.RadioSelection";
+  class BadgeSelection extends owl.Component {
+      static template = "o-spreadsheet.BadgeSelection";
       static props = {
           choices: Array,
           onChange: Function,
-          selectedValue: { optional: false },
-          name: String,
-          direction: { type: String, optional: true },
-      };
-      static defaultProps = {
-          direction: "horizontal",
+          selectedValue: String,
       };
   }
 
@@ -36712,86 +37104,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  const TRANSPARENT_BACKGROUND_SVG = /*xml*/ `
-<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10">
-  <path fill="#d9d9d9" d="M5 5h5v5H5zH0V0h5"/>
-</svg>
-`;
-  css /* scss */ `
-  .o-round-color-picker-button {
-    width: 18px;
-    height: 18px;
-    cursor: pointer;
-    border: 1px solid ${GRAY_300};
-    background-position: 1px 1px;
-    background-image: url("data:image/svg+xml,${encodeURIComponent(TRANSPARENT_BACKGROUND_SVG)}");
-  }
-`;
-  class RoundColorPicker extends owl.Component {
-      static template = "o-spreadsheet.RoundColorPicker";
-      static components = { ColorPickerWidget, Section, ColorPicker };
-      static props = {
-          currentColor: { type: String, optional: true },
-          title: { type: String, optional: true },
-          onColorPicked: Function,
-      };
-      colorPickerButtonRef = owl.useRef("colorPickerButton");
-      state;
-      setup() {
-          this.state = owl.useState({ pickerOpened: false });
-          owl.useExternalListener(window, "click", this.closePicker);
-      }
-      closePicker() {
-          this.state.pickerOpened = false;
-      }
-      togglePicker() {
-          this.state.pickerOpened = !this.state.pickerOpened;
-      }
-      onColorPicked(color) {
-          this.props.onColorPicked(color);
-          this.state.pickerOpened = false;
-      }
-      get colorPickerAnchorRect() {
-          const button = this.colorPickerButtonRef.el;
-          return getBoundingRectAsPOJO(button);
-      }
-      get buttonStyle() {
-          return cssPropertiesToCss({
-              background: this.props.currentColor,
-          });
-      }
-  }
-
-  css /* scss */ `
-  .o-badge-selection {
-    gap: 1px;
-    button.o-button {
-      border-radius: 0;
-      &.selected {
-        color: ${GRAY_900};
-        border-color: ${ACTION_COLOR};
-        background: ${BADGE_SELECTED_COLOR};
-        font-weight: 600;
-      }
-
-      &:first-child {
-        border-radius: 4px 0 0 4px;
-      }
-      &:last-child {
-        border-radius: 0 4px 4px 0;
-      }
-    }
-  }
-`;
-  class BadgeSelection extends owl.Component {
-      static template = "o-spreadsheet.BadgeSelection";
-      static props = {
-          choices: Array,
-          onChange: Function,
-          selectedValue: String,
-      };
-  }
-
   css /* scss */ `
   .o-chart-title-designer {
     > span {
@@ -36946,8 +37258,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.props.updateChart(this.props.figureId, { axesDesign });
       }
       updateAxisEditor(ev) {
-          const axis = ev.target.value;
-          this.state.currentAxis = axis;
+          this.state.currentAxis = ev.target.value;
       }
       getAxisTitle() {
           const axesDesign = this.props.definition.axesDesign ?? {};
@@ -36966,6 +37277,56 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  const TRANSPARENT_BACKGROUND_SVG = /*xml*/ `
+<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10">
+  <path fill="#d9d9d9" d="M5 5h5v5H5zH0V0h5"/>
+</svg>
+`;
+  css /* scss */ `
+  .o-round-color-picker-button {
+    width: 18px;
+    height: 18px;
+    cursor: pointer;
+    border: 1px solid ${GRAY_300};
+    background-position: 1px 1px;
+    background-image: url("data:image/svg+xml,${encodeURIComponent(TRANSPARENT_BACKGROUND_SVG)}");
+  }
+`;
+  class RoundColorPicker extends owl.Component {
+      static template = "o-spreadsheet.RoundColorPicker";
+      static components = { Section, ColorPicker };
+      static props = {
+          currentColor: { type: String, optional: true },
+          title: { type: String, optional: true },
+          onColorPicked: Function,
+      };
+      colorPickerButtonRef = owl.useRef("colorPickerButton");
+      state;
+      setup() {
+          this.state = owl.useState({ pickerOpened: false });
+          owl.useExternalListener(window, "click", this.closePicker);
+      }
+      closePicker() {
+          this.state.pickerOpened = false;
+      }
+      togglePicker() {
+          this.state.pickerOpened = !this.state.pickerOpened;
+      }
+      onColorPicked(color) {
+          this.props.onColorPicked(color);
+          this.state.pickerOpened = false;
+      }
+      get colorPickerAnchorRect() {
+          const button = this.colorPickerButtonRef.el;
+          return getBoundingRectAsPOJO(button);
+      }
+      get buttonStyle() {
+          return cssPropertiesToCss({
+              background: this.props.currentColor,
+          });
+      }
+  }
+
   class GeneralDesignEditor extends owl.Component {
       static template = "o-spreadsheet-GeneralDesignEditor";
       static components = {
@@ -37030,58 +37391,75 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  class ChartWithAxisDesignPanel extends owl.Component {
-      static template = "o-spreadsheet-ChartWithAxisDesignPanel";
+  const CIRCLE_SVG = /*xml*/ `
+<svg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'>
+  <circle r="2" fill="#FFF"/>
+</svg>
+`;
+  css /* scss */ `
+  .o-radio {
+    input {
+      appearance: none;
+      -webkit-appearance: none;
+      -moz-appearance: none;
+      width: 14px;
+      height: 14px;
+      border: 1px solid ${GRAY_300};
+      box-sizing: border-box;
+      outline: none;
+      border-radius: 8px;
+
+      &:checked {
+        background: url("data:image/svg+xml,${encodeURIComponent(CIRCLE_SVG)}");
+        background-color: ${ACTION_COLOR};
+        border-color: ${ACTION_COLOR};
+      }
+    }
+  }
+`;
+  class RadioSelection extends owl.Component {
+      static template = "o-spreadsheet.RadioSelection";
+      static props = {
+          choices: Array,
+          onChange: Function,
+          selectedValue: { optional: false },
+          name: String,
+          direction: { type: String, optional: true },
+      };
+      static defaultProps = {
+          direction: "horizontal",
+      };
+  }
+
+  class SeriesDesignEditor extends owl.Component {
+      static template = "o-spreadsheet-SeriesDesignEditor";
       static components = {
-          GeneralDesignEditor,
           SidePanelCollapsible,
           Section,
-          AxisDesignEditor,
           RoundColorPicker,
-          Checkbox,
-          RadioSelection,
       };
       static props = {
           figureId: String,
           definition: Object,
-          canUpdateChart: Function,
           updateChart: Function,
+          canUpdateChart: Function,
+          slots: { type: Object, optional: true },
       };
-      axisChoices = CHART_AXIS_CHOICES;
       state = owl.useState({ index: 0 });
-      get axesList() {
-          const { useLeftAxis, useRightAxis } = getDefinedAxis(this.props.definition);
-          let axes = [{ id: "x", name: _t("Horizontal axis") }];
-          if (useLeftAxis) {
-              axes.push({ id: "y", name: useRightAxis ? _t("Left axis") : _t("Vertical axis") });
-          }
-          if (useRightAxis) {
-              axes.push({ id: "y1", name: useLeftAxis ? _t("Right axis") : _t("Vertical axis") });
-          }
-          return axes;
-      }
-      updateLegendPosition(ev) {
-          this.props.updateChart(this.props.figureId, {
-              legendPosition: ev.target.value,
-          });
-      }
       getDataSeries() {
-          return this.props.definition.dataSets.map((d, i) => d.label ?? `${ChartTerms.Series} ${i + 1}`);
+          const runtime = this.env.model.getters.getChartRuntime(this.props.figureId);
+          if (!runtime || !("chartJsConfig" in runtime)) {
+              return [];
+          }
+          return runtime.chartJsConfig.data.datasets.map((d) => d.label);
       }
       updateSerieEditor(ev) {
-          const chartId = this.props.figureId;
-          const selectedIndex = ev.target.selectedIndex;
-          const runtime = this.env.model.getters.getChartRuntime(chartId);
-          if (!runtime) {
-              return;
-          }
-          this.state.index = selectedIndex;
+          this.state.index = ev.target.selectedIndex;
       }
       updateDataSeriesColor(color) {
-          const dataSets = [...this.props.definition.dataSets];
-          if (!dataSets?.[this.state.index]) {
+          const dataSets = this.props.definition.dataSets;
+          if (!dataSets?.[this.state.index])
               return;
-          }
           dataSets[this.state.index] = {
               ...dataSets[this.state.index],
               backgroundColor: color,
@@ -37090,71 +37468,87 @@ stores.inject(MyMetaStore, storeInstance);
       }
       getDataSerieColor() {
           const dataSets = this.props.definition.dataSets;
-          if (!dataSets?.[this.state.index]) {
+          if (!dataSets?.[this.state.index])
               return "";
-          }
           const color = dataSets[this.state.index].backgroundColor;
-          return color ? toHex(color) : getNthColor(this.state.index, getColorsPalette(dataSets.length));
+          return color
+              ? toHex(color)
+              : getNthColor(this.state.index, getColorsPalette(this.props.definition.dataSets.length));
       }
-      updateDataSeriesAxis(axis) {
-          const dataSets = [...this.props.definition.dataSets];
-          if (!dataSets?.[this.state.index]) {
+      updateDataSeriesLabel(ev) {
+          const label = ev.target.value;
+          const dataSets = this.props.definition.dataSets;
+          if (!dataSets?.[this.state.index])
               return;
-          }
           dataSets[this.state.index] = {
               ...dataSets[this.state.index],
-              yAxisId: axis === "left" ? "y" : "y1",
+              label,
           };
           this.props.updateChart(this.props.figureId, { dataSets });
       }
-      getDataSerieAxis() {
+      getDataSerieLabel() {
           const dataSets = this.props.definition.dataSets;
-          if (!dataSets?.[this.state.index]) {
-              return "left";
-          }
-          return dataSets[this.state.index].yAxisId === "y1" ? "right" : "left";
-      }
-      get canHaveTwoVerticalAxis() {
-          return "horizontal" in this.props.definition ? !this.props.definition.horizontal : true;
+          return dataSets[this.state.index]?.label || this.getDataSeries()[this.state.index];
       }
-      updateDataSeriesLabel(ev) {
-          const label = ev.target.value;
+  }
+
+  class SeriesWithAxisDesignEditor extends owl.Component {
+      static template = "o-spreadsheet-SeriesWithAxisDesignEditor";
+      static components = {
+          SeriesDesignEditor,
+          Checkbox,
+          RadioSelection,
+          Section,
+          RoundColorPicker,
+      };
+      static props = {
+          figureId: String,
+          definition: Object,
+          canUpdateChart: Function,
+          updateChart: Function,
+          slots: { type: Object, optional: true },
+      };
+      axisChoices = CHART_AXIS_CHOICES;
+      updateDataSeriesAxis(index, axis) {
           const dataSets = [...this.props.definition.dataSets];
-          if (!dataSets?.[this.state.index]) {
+          if (!dataSets?.[index]) {
               return;
           }
-          dataSets[this.state.index] = {
-              ...dataSets[this.state.index],
-              label,
+          dataSets[index] = {
+              ...dataSets[index],
+              yAxisId: axis === "left" ? "y" : "y1",
           };
           this.props.updateChart(this.props.figureId, { dataSets });
       }
-      getDataSerieLabel() {
+      getDataSerieAxis(index) {
           const dataSets = this.props.definition.dataSets;
-          return dataSets[this.state.index]?.label || this.getDataSeries()[this.state.index];
+          if (!dataSets?.[index]) {
+              return "left";
+          }
+          return dataSets[index].yAxisId === "y1" ? "right" : "left";
       }
-      updateShowValues(showValues) {
-          this.props.updateChart(this.props.figureId, { showValues });
+      get canHaveTwoVerticalAxis() {
+          return !("horizontal" in this.props.definition && this.props.definition.horizontal);
       }
-      toggleDataTrend(display) {
+      toggleDataTrend(index, display) {
           const dataSets = [...this.props.definition.dataSets];
-          if (!dataSets?.[this.state.index]) {
+          if (!dataSets?.[index]) {
               return;
           }
-          dataSets[this.state.index] = {
-              ...dataSets[this.state.index],
+          dataSets[index] = {
+              ...dataSets[index],
               trend: {
                   type: "polynomial",
                   order: 1,
-                  ...dataSets[this.state.index].trend,
+                  ...dataSets[index].trend,
                   display,
               },
           };
           this.props.updateChart(this.props.figureId, { dataSets });
       }
-      getTrendLineConfiguration() {
+      getTrendLineConfiguration(index) {
           const dataSets = this.props.definition.dataSets;
-          return dataSets?.[this.state.index]?.trend;
+          return dataSets?.[index]?.trend;
       }
       getTrendType(config) {
           if (!config) {
@@ -37162,7 +37556,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return config.type === "polynomial" && config.order === 1 ? "linear" : config.type;
       }
-      onChangeTrendType(ev) {
+      onChangeTrendType(index, ev) {
           const type = ev.target.value;
           let config;
           switch (type) {
@@ -37175,37 +37569,59 @@ stores.inject(MyMetaStore, storeInstance);
                   break;
               case "exponential":
               case "logarithmic":
+              case "trailingMovingAverage":
                   config = { type };
                   break;
               default:
                   return;
           }
-          this.updateTrendLineValue(config);
+          this.updateTrendLineValue(index, config);
       }
-      onChangePolynomialDegree(ev) {
+      onChangePolynomialDegree(index, ev) {
           const element = ev.target;
           const order = parseInt(element.value || "1");
           if (order < 2) {
-              element.value = `${this.getTrendLineConfiguration()?.order ?? 2}`;
+              element.value = `${this.getTrendLineConfiguration(index)?.order ?? 2}`;
               return;
           }
-          this.updateTrendLineValue({ order });
+          this.updateTrendLineValue(index, { order });
+      }
+      get defaultWindowSize() {
+          return DEFAULT_WINDOW_SIZE;
+      }
+      onChangeMovingAverageWindow(index, ev) {
+          const element = ev.target;
+          let window = parseInt(element.value) || DEFAULT_WINDOW_SIZE;
+          if (window <= 1) {
+              window = DEFAULT_WINDOW_SIZE;
+          }
+          this.updateTrendLineValue(index, { window });
       }
-      getTrendLineColor() {
-          return this.getTrendLineConfiguration()?.color ?? setColorAlpha(this.getDataSerieColor(), 0.5);
+      getDataSerieColor(index) {
+          const dataSets = this.props.definition.dataSets;
+          if (!dataSets?.[index])
+              return "";
+          const color = dataSets[index].backgroundColor;
+          return color
+              ? toHex(color)
+              : getNthColor(index, getColorsPalette(this.props.definition.dataSets.length));
+      }
+      getTrendLineColor(index) {
+          return (this.getTrendLineConfiguration(index)?.color ??
+              setColorAlpha(this.getDataSerieColor(index), 0.5));
       }
-      updateTrendLineColor(color) {
-          this.updateTrendLineValue({ color });
+      updateTrendLineColor(index, color) {
+          this.updateTrendLineValue(index, { color });
       }
-      updateTrendLineValue(config) {
+      updateTrendLineValue(index, config) {
           const dataSets = [...this.props.definition.dataSets];
-          if (!dataSets?.[this.state.index]) {
+          if (!dataSets?.[index]) {
               return;
           }
-          dataSets[this.state.index] = {
-              ...dataSets[this.state.index],
+          dataSets[index] = {
+              ...dataSets[index],
               trend: {
-                  ...dataSets[this.state.index].trend,
+                  ...dataSets[index].trend,
                   ...config,
               },
           };
@@ -37213,6 +37629,70 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class ChartWithAxisDesignPanel extends owl.Component {
+      static template = "o-spreadsheet-ChartWithAxisDesignPanel";
+      static components = {
+          GeneralDesignEditor,
+          SidePanelCollapsible,
+          Section,
+          AxisDesignEditor,
+          Checkbox,
+          SeriesWithAxisDesignEditor,
+      };
+      static props = {
+          figureId: String,
+          definition: Object,
+          canUpdateChart: Function,
+          updateChart: Function,
+      };
+      get axesList() {
+          const { useLeftAxis, useRightAxis } = getDefinedAxis(this.props.definition);
+          let axes = [{ id: "x", name: _t("Horizontal axis") }];
+          if (useLeftAxis) {
+              axes.push({ id: "y", name: useRightAxis ? _t("Left axis") : _t("Vertical axis") });
+          }
+          if (useRightAxis) {
+              axes.push({ id: "y1", name: useLeftAxis ? _t("Right axis") : _t("Vertical axis") });
+          }
+          return axes;
+      }
+      updateLegendPosition(ev) {
+          this.props.updateChart(this.props.figureId, {
+              legendPosition: ev.target.value,
+          });
+      }
+  }
+
+  class ComboChartDesignPanel extends ChartWithAxisDesignPanel {
+      static template = "o-spreadsheet-ComboChartDesignPanel";
+      static components = {
+          ...ChartWithAxisDesignPanel.components,
+          RadioSelection,
+      };
+      seriesTypeChoices = [
+          { value: "bar", label: _t("Bar") },
+          { value: "line", label: _t("Line") },
+      ];
+      updateDataSeriesType(index, type) {
+          const dataSets = [...this.props.definition.dataSets];
+          if (!dataSets?.[index]) {
+              return;
+          }
+          dataSets[index] = {
+              ...dataSets[index],
+              type,
+          };
+          this.props.updateChart(this.props.figureId, { dataSets });
+      }
+      getDataSeriesType(index) {
+          const dataSets = this.props.definition.dataSets;
+          if (!dataSets?.[index]) {
+              return "bar";
+          }
+          return dataSets[index].type ?? "line";
+      }
+  }
+
   class GaugeChartConfigPanel extends owl.Component {
       static template = "o-spreadsheet-GaugeChartConfigPanel";
       static components = { ChartErrorSection, ChartDataSeries };
@@ -37392,11 +37872,6 @@ stores.inject(MyMetaStore, storeInstance);
               stacked,
           });
       }
-      onUpdateAggregated(aggregated) {
-          this.props.updateChart(this.props.figureId, {
-              aggregated,
-          });
-      }
       onUpdateCumulative(cumulative) {
           this.props.updateChart(this.props.figureId, {
               cumulative,
@@ -37424,6 +37899,27 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class RadarChartDesignPanel extends owl.Component {
+      static template = "o-spreadsheet-RadarChartDesignPanel";
+      static components = {
+          GeneralDesignEditor,
+          SeriesDesignEditor,
+          Section,
+          Checkbox,
+      };
+      static props = {
+          figureId: String,
+          definition: Object,
+          canUpdateChart: Function,
+          updateChart: Function,
+      };
+      updateLegendPosition(ev) {
+          this.props.updateChart(this.props.figureId, {
+              legendPosition: ev.target.value,
+          });
+      }
+  }
+
   class ScatterConfigPanel extends GenericChartConfigPanel {
       static template = "o-spreadsheet-ScatterConfigPanel";
       get canTreatLabelsAsText() {
@@ -37618,9 +38114,6 @@ stores.inject(MyMetaStore, storeInstance);
               verticalAxisPosition: value,
           });
       }
-      updateShowValues(showValues) {
-          this.props.updateChart(this.props.figureId, { showValues });
-      }
   }
 
   const chartSidePanelComponentRegistry = new Registry();
@@ -37639,7 +38132,7 @@ stores.inject(MyMetaStore, storeInstance);
   })
       .add("combo", {
       configuration: GenericChartConfigPanel,
-      design: ChartWithAxisDesignPanel,
+      design: ComboChartDesignPanel,
   })
       .add("pie", {
       configuration: GenericChartConfigPanel,
@@ -37660,6 +38153,10 @@ stores.inject(MyMetaStore, storeInstance);
       .add("pyramid", {
       configuration: GenericChartConfigPanel,
       design: ChartWithAxisDesignPanel,
+  })
+      .add("radar", {
+      configuration: GenericChartConfigPanel,
+      design: RadarChartDesignPanel,
   });
 
   css /* scss */ `
@@ -37925,6 +38422,7 @@ stores.inject(MyMetaStore, storeInstance);
           "stopComposerRangeSelection",
           "cancelEdition",
           "cycleReferences",
+          "toggleEditionMode",
           "changeComposerCursorSelection",
           "replaceComposerCursorSelection",
       ];
@@ -38080,6 +38578,42 @@ stores.inject(MyMetaStore, storeInstance);
           }
           this.setCurrentContent(updated.content, updated.selection);
       }
+      toggleEditionMode() {
+          if (this.editionMode === "inactive")
+              return;
+          const start = Math.min(this.selectionStart, this.selectionEnd);
+          const end = Math.max(this.selectionStart, this.selectionEnd);
+          const refToken = [...this.currentTokens]
+              .reverse()
+              .find((tk) => tk.end >= start && end >= tk.start && tk.type === "REFERENCE");
+          if (this.editionMode === "editing" && refToken) {
+              const currentSheetId = this.getters.getActiveSheetId();
+              const { sheetName, xc } = splitReference(refToken.value);
+              const sheetId = this.getters.getSheetIdByName(sheetName);
+              if (sheetId && sheetId !== currentSheetId) {
+                  this.model.dispatch("ACTIVATE_SHEET", { sheetIdFrom: currentSheetId, sheetIdTo: sheetId });
+              }
+              // move cursor to the right part of the token
+              this.selectionStart = this.selectionEnd = refToken.end;
+              const zone = this.getters.getRangeFromSheetXC(this.sheetId, xc).zone;
+              this.captureSelection(zone);
+              this.editionMode = "selecting";
+          }
+          else {
+              this.editionMode = "editing";
+          }
+      }
+      captureSelection(zone, col, row) {
+          this.model.selection.capture(this, {
+              cell: { col: col || zone.left, row: row || zone.right },
+              zone,
+          }, {
+              handleEvent: this.handleEvent.bind(this),
+              release: () => {
+                  this._stopEdition();
+              },
+          });
+      }
       isSelectionValid(length, start, end) {
           return start >= 0 && start <= length && end >= 0 && end <= length;
       }
@@ -38118,12 +38652,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.setContent(str || this.initialContent, selection);
           this.colorIndexByRange = {};
           const zone = positionToZone({ col: this.col, row: this.row });
-          this.model.selection.capture(this, { cell: { col: this.col, row: this.row }, zone }, {
-              handleEvent: this.handleEvent.bind(this),
-              release: () => {
-                  this._stopEdition();
-              },
-          });
+          this.captureSelection(zone, col, row);
       }
       _stopEdition() {
           if (this.editionMode !== "inactive") {
@@ -38830,13 +39359,6 @@ stores.inject(MyMetaStore, storeInstance);
               return;
           this.edgeScrollIntervalId = window.setInterval(() => {
               const offset = direction * 3;
-              let newPosition = this.currentMousePosition + offset;
-              if (newPosition < Math.min(this.container.start, this.minPosition)) {
-                  newPosition = Math.min(this.container.start, this.minPosition);
-              }
-              else if (newPosition > Math.max(this.container.end, this.maxPosition)) {
-                  newPosition = Math.max(this.container.end, this.maxPosition);
-              }
               this.container.scroll += offset;
           }, 5);
       }
@@ -39013,7 +39535,6 @@ stores.inject(MyMetaStore, storeInstance);
       width: 142px;
       .o-cf-preview-description-rule {
         margin-bottom: 4px;
-        font-weight: 600;
         max-height: 2.8em;
         line-height: 1.4em;
       }
@@ -39485,7 +40006,7 @@ stores.inject(MyMetaStore, storeInstance);
       setColorScaleColor(target, color) {
           const point = this.state.rules.colorScale[target];
           if (point) {
-              point.color = Number.parseInt(color.substr(1), 16);
+              point.color = Number.parseInt(color.slice(1), 16);
           }
           this.closeMenus();
       }
@@ -39596,7 +40117,7 @@ stores.inject(MyMetaStore, storeInstance);
           return [this.state.rules.dataBar.rangeValues || ""];
       }
       updateDataBarColor(color) {
-          this.state.rules.dataBar.color = Number.parseInt(color.substr(1), 16);
+          this.state.rules.dataBar.color = Number.parseInt(color.slice(1), 16);
       }
       onDataBarRangeUpdate(ranges) {
           this.state.rules.dataBar.rangeValues = ranges[0];
@@ -41009,10 +41530,11 @@ stores.inject(MyMetaStore, storeInstance);
       activeSheetMatches = [];
       specificRangeMatches = [];
       currentSearchRegex = null;
-      isSearchDirty = false;
       initialShowFormulaState;
       preserveSelectedMatchIndex = false;
       irreplaceableMatchCount = 0;
+      isSearchDirty = false;
+      shouldFinalizeUpdateSelection = false;
       notificationStore = this.get(NotificationStore);
       // fixme: why do we make selectedMatchIndex on top of a selected
       // property in the matches?
@@ -41058,10 +41580,13 @@ stores.inject(MyMetaStore, storeInstance);
           this.updateSearchOptions({ searchFormulas: showFormula });
       }
       selectPreviousMatch() {
-          this.selectNextCell(Direction.previous);
+          this.selectNextCell(Direction.previous, {
+              jumpToMatchSheet: true,
+              updateSelection: true,
+          });
       }
       selectNextMatch() {
-          this.selectNextCell(Direction.next);
+          this.selectNextCell(Direction.next, { jumpToMatchSheet: true, updateSelection: true });
       }
       handle(cmd) {
           switch (cmd.type) {
@@ -41078,8 +41603,11 @@ stores.inject(MyMetaStore, storeInstance);
               case "ADD_COLUMNS_ROWS":
               case "EVALUATE_CELLS":
               case "UPDATE_CELL":
+                  this.isSearchDirty = true;
+                  break;
               case "ACTIVATE_SHEET":
                   this.isSearchDirty = true;
+                  this.shouldFinalizeUpdateSelection = true;
                   break;
               case "REPLACE_SEARCH":
                   for (const match of cmd.matches) {
@@ -41094,7 +41622,11 @@ stores.inject(MyMetaStore, storeInstance);
       }
       finalize() {
           if (this.isSearchDirty) {
-              this.refreshSearch(false);
+              this.refreshSearch({
+                  jumpToMatchSheet: false,
+                  updateSelection: this.shouldFinalizeUpdateSelection,
+              });
+              this.shouldFinalizeUpdateSelection = false;
               this.isSearchDirty = false;
           }
       }
@@ -41121,17 +41653,17 @@ stores.inject(MyMetaStore, storeInstance);
           }
           this.toSearch = toSearch;
           this.currentSearchRegex = getSearchRegex(this.toSearch, this.searchOptions);
-          this.refreshSearch();
+          this.refreshSearch({ jumpToMatchSheet: true, updateSelection: true });
       }
       /**
        * refresh the matches according to the current search options
        */
-      refreshSearch(jumpToMatchSheet = true) {
+      refreshSearch(options) {
           if (!this.preserveSelectedMatchIndex) {
               this.selectedMatchIndex = null;
           }
           this.findMatches();
-          this.selectNextCell(Direction.current, jumpToMatchSheet);
+          this.selectNextCell(Direction.current, options);
       }
       getSheetsInSearchOrder() {
           switch (this.searchOptions.searchScope) {
@@ -41201,7 +41733,7 @@ stores.inject(MyMetaStore, storeInstance);
        * It is also used to keep coherence between the selected searchMatch
        * and selectedMatchIndex.
        */
-      selectNextCell(indexChange, jumpToMatchSheet = true) {
+      selectNextCell(indexChange, options) {
           const matches = this.searchMatches;
           if (!matches.length) {
               this.selectedMatchIndex = null;
@@ -41227,7 +41759,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.selectedMatchIndex = nextIndex;
           const selectedMatch = matches[nextIndex];
           // Switch to the sheet where the match is located
-          if (jumpToMatchSheet && this.getters.getActiveSheetId() !== selectedMatch.sheetId) {
+          if (options.jumpToMatchSheet && this.getters.getActiveSheetId() !== selectedMatch.sheetId) {
               // We set `preserveSelectedMatchIndex` to true to avoid resetting the selected search
               // index in the `refreshSearch` function when a new sheet is activated. The reason being
               // that, when we automatically go back to previous sheet while performing a search, the
@@ -41243,7 +41775,9 @@ stores.inject(MyMetaStore, storeInstance);
           }
           // we want grid selection to capture the selection stream
           this.model.selection.getBackToDefault();
-          this.model.selection.selectCell(selectedMatch.col, selectedMatch.row);
+          if (options.updateSelection) {
+              this.model.selection.selectCell(selectedMatch.col, selectedMatch.row);
+          }
       }
       /**
        * Replace the value of the currently selected match
@@ -41258,7 +41792,7 @@ stores.inject(MyMetaStore, storeInstance);
               matches: [this.searchMatches[this.selectedMatchIndex]],
               searchOptions: this.searchOptions,
           });
-          this.selectNextCell(Direction.next);
+          this.selectNextCell(Direction.next, { jumpToMatchSheet: true, updateSelection: true });
       }
       /**
        * Apply the replace function to all the matches one time.
@@ -41440,6 +41974,14 @@ stores.inject(MyMetaStore, storeInstance);
           owl.onMounted(() => this.searchInput.el?.focus());
           owl.onWillUnmount(() => this.updateSearchContent.stopDebounce());
           this.updateSearchContent = debounce(this.store.updateSearchContent, 200);
+          owl.useExternalListener(window, "keydown", (ev) => {
+              const code = keyboardEventToShortcutString(ev);
+              if (code === "Ctrl+F" || code === "Ctrl+H") {
+                  this.searchInput.el?.focus();
+                  ev.preventDefault();
+                  ev.stopPropagation();
+              }
+          }, { capture: true });
       }
       onFocusSearch() {
           this.updateDataRange();
@@ -42015,7 +42557,6 @@ stores.inject(MyMetaStore, storeInstance);
           sequence: 0,
           autoSelectFirstProposal: true,
           getProposals(tokenAtCursor) {
-              // return []
               const measureProposals = pivot.measures
                   .filter((m) => m !== forComputedMeasure)
                   .map((measure) => {
@@ -42818,8 +43359,9 @@ stores.inject(MyMetaStore, storeInstance);
    * This function converts a list of data entry into a spreadsheet pivot table.
    */
   function dataEntriesToSpreadsheetPivotTable(dataEntries, definition) {
+      const measureIds = definition.measures.filter((measure) => !measure.isHidden).map((m) => m.id);
       const columnsTree = dataEntriesToColumnsTree(dataEntries, definition.columns, 0);
-      computeWidthOfColumnsNodes(columnsTree, definition.measures.length);
+      computeWidthOfColumnsNodes(columnsTree, measureIds.length);
       const cols = columnsTreeToColumns(columnsTree, definition);
       const rows = dataEntriesToRows(dataEntries, 0, definition.rows, [], []);
       // Add the total row
@@ -42828,7 +43370,6 @@ stores.inject(MyMetaStore, storeInstance);
           values: [],
           indent: 0,
       });
-      const measureIds = definition.measures.filter((measure) => !measure.isHidden).map((m) => m.id);
       const fieldsType = {};
       for (const columns of definition.columns) {
           fieldsType[columns.fieldName] = columns.type;
@@ -43589,20 +44130,22 @@ stores.inject(MyMetaStore, storeInstance);
       onIterationEndEvaluation: (pivot) => pivot.markAsDirtyForEvaluation(),
       dateGranularities: [...dateGranularities],
       datetimeGranularities: [...dateGranularities, "hour_number", "minute_number", "second_number"],
-      isMeasureCandidate: (field) => !["date", "boolean"].includes(field.type),
+      isMeasureCandidate: (field) => !["datetime", "boolean"].includes(field.type),
       isGroupable: () => true,
   });
 
   class PivotSidePanelStore extends SpreadsheetStore {
       pivotId;
       mutators = ["reset", "deferUpdates", "applyUpdate", "discardPendingUpdate", "update"];
-      updatesAreDeferred = false;
+      updatesAreDeferred;
       draft = null;
       notification = this.get(NotificationStore);
       alreadyNotified = false;
       constructor(get, pivotId) {
           super(get);
           this.pivotId = pivotId;
+          this.updatesAreDeferred =
+              this.getters.getPivotCoreDefinition(this.pivotId).deferUpdates ?? false;
       }
       handle(cmd) {
           switch (cmd.type) {
@@ -43690,10 +44233,14 @@ stores.inject(MyMetaStore, storeInstance);
           this.draft = null;
       }
       deferUpdates(shouldDefer) {
-          this.updatesAreDeferred = shouldDefer;
           if (shouldDefer === false && this.draft) {
+              this.draft.deferUpdates = false;
               this.applyUpdate();
           }
+          else {
+              this.update({ deferUpdates: shouldDefer });
+          }
+          this.updatesAreDeferred = shouldDefer;
       }
       applyUpdate() {
           if (this.draft) {
@@ -43951,7 +44498,7 @@ stores.inject(MyMetaStore, storeInstance);
           return colLabel;
       }
       get isEveryColumnSelected() {
-          return Object.values(this.state.columns).every((value) => value === true);
+          return Object.values(this.state.columns).every((value) => value);
       }
       get errorMessages() {
           const cancelledReasons = this.env.model.canDispatch("REMOVE_DUPLICATES", {
@@ -44051,8 +44598,7 @@ stores.inject(MyMetaStore, storeInstance);
           const currentLocale = this.currentLocale;
           const localeInLoadedLocales = this.loadedLocales.find((l) => l.code === currentLocale.code);
           if (!localeInLoadedLocales) {
-              const locales = [...this.loadedLocales, currentLocale].sort((a, b) => a.name.localeCompare(b.name));
-              return locales;
+              return [...this.loadedLocales, currentLocale].sort((a, b) => a.name.localeCompare(b.name));
           }
           else if (!deepEquals(currentLocale, localeInLoadedLocales)) {
               const index = this.loadedLocales.indexOf(localeInLoadedLocales);
@@ -45946,10 +46492,9 @@ stores.inject(MyMetaStore, storeInstance);
           });
       }
       get focus() {
-          const focus = this.composerFocusStore.activeComposer === this.composerInterface
+          return this.composerFocusStore.activeComposer === this.composerInterface
               ? this.composerFocusStore.focusMode
               : "inactive";
-          return focus;
       }
       get composerProps() {
           const { width, height } = this.env.model.getters.getSheetViewDimensionWithHeaders();
@@ -46118,13 +46663,10 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  const CHECKBOX_WIDTH = 15;
   const MARGIN = (GRID_ICON_EDGE_LENGTH - CHECKBOX_WIDTH) / 2;
   css /* scss */ `
   .o-dv-checkbox {
     box-sizing: border-box !important;
-    width: ${CHECKBOX_WIDTH}px;
-    height: ${CHECKBOX_WIDTH}px;
     accent-color: #808080;
     margin: ${MARGIN}px;
     /** required to prevent the checkbox position to be sensible to the font-size (affects Firefox) */
@@ -46133,13 +46675,15 @@ stores.inject(MyMetaStore, storeInstance);
 `;
   class DataValidationCheckbox extends owl.Component {
       static template = "o-spreadsheet-DataValidationCheckbox";
+      static components = {
+          Checkbox,
+      };
       static props = {
           cellPosition: Object,
       };
-      onCheckboxChange(ev) {
-          const newValue = ev.target.checked;
+      onCheckboxChange(value) {
           const { sheetId, col, row } = this.props.cellPosition;
-          const cellContent = newValue ? "TRUE" : "FALSE";
+          const cellContent = value ? "TRUE" : "FALSE";
           this.env.model.dispatch("UPDATE_CELL", { sheetId, col, row, content: cellContent });
       }
       get checkBoxValue() {
@@ -46953,7 +47497,12 @@ stores.inject(MyMetaStore, storeInstance);
   class PaintFormatStore extends SpreadsheetStore {
       mutators = ["activate", "cancel", "pasteFormat"];
       highlightStore = this.get(HighlightStore);
-      cellClipboardHandler = new CellClipboardHandler(this.getters, this.model.dispatch);
+      clipboardHandlers = [
+          new CellClipboardHandler(this.getters, this.model.dispatch),
+          new BorderClipboardHandler(this.getters, this.model.dispatch),
+          new TableClipboardHandler(this.getters, this.model.dispatch),
+          new ConditionalFormatClipboardHandler(this.getters, this.model.dispatch),
+      ];
       status = "inactive";
       copiedData;
       constructor(get) {
@@ -46963,6 +47512,13 @@ stores.inject(MyMetaStore, storeInstance);
               this.highlightStore.unRegister(this);
           });
       }
+      handle(cmd) {
+          switch (cmd.type) {
+              case "PAINT_FORMAT":
+                  this.paintFormat(cmd.sheetId, cmd.target);
+                  break;
+          }
+      }
       activate(args) {
           this.copiedData = this.copyFormats();
           this.status = args.persistent ? "persistent" : "oneOff";
@@ -46972,16 +47528,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.copiedData = undefined;
       }
       pasteFormat(target) {
-          if (this.copiedData) {
-              const sheetId = this.getters.getActiveSheetId();
-              this.cellClipboardHandler.paste({ zones: target, sheetId }, this.copiedData, {
-                  isCutOperation: false,
-                  pasteOption: "onlyFormat",
-              });
-          }
-          if (this.status === "oneOff") {
-              this.cancel();
-          }
+          this.model.dispatch("PAINT_FORMAT", { target, sheetId: this.getters.getActiveSheetId() });
       }
       get isActive() {
           return this.status !== "inactive";
@@ -46989,7 +47536,24 @@ stores.inject(MyMetaStore, storeInstance);
       copyFormats() {
           const sheetId = this.getters.getActiveSheetId();
           const zones = this.getters.getSelectedZones();
-          return this.cellClipboardHandler.copy(getClipboardDataPositions(sheetId, zones));
+          const copiedData = {};
+          for (const handler of this.clipboardHandlers) {
+              Object.assign(copiedData, handler.copy(getClipboardDataPositions(sheetId, zones)));
+          }
+          return copiedData;
+      }
+      paintFormat(sheetId, target) {
+          if (this.copiedData) {
+              for (const handler of this.clipboardHandlers) {
+                  handler.paste({ zones: target, sheetId }, this.copiedData, {
+                      isCutOperation: false,
+                      pasteOption: "onlyFormat",
+                  });
+              }
+          }
+          if (this.status === "oneOff") {
+              this.cancel();
+          }
       }
       get highlights() {
           const data = this.copiedData;
@@ -47367,7 +47931,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (index < 0) {
               return;
           }
-          if (this.state.waitingForMove === true) {
+          if (this.state.waitingForMove) {
               if (!this.env.model.getters.isGridSelectionActive()) {
                   this._selectElement(index, false);
               }
@@ -48926,7 +49490,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       open(componentTag, panelProps = {}) {
           const state = this.computeState(componentTag, panelProps);
-          if (state.isOpen === false) {
+          if (!state.isOpen) {
               return;
           }
           if (this.isOpen && componentTag !== this.componentTag) {
@@ -49265,6 +49829,8 @@ stores.inject(MyMetaStore, storeInstance);
           },
           "Ctrl+D": async () => this.env.model.dispatch("COPY_PASTE_CELLS_ABOVE"),
           "Ctrl+R": async () => this.env.model.dispatch("COPY_PASTE_CELLS_ON_LEFT"),
+          "Ctrl+H": () => this.sidePanel.open("FindAndReplace", {}),
+          "Ctrl+F": () => this.sidePanel.open("FindAndReplace", {}),
           "Ctrl+Shift+E": () => this.setHorizontalAlign("center"),
           "Ctrl+Shift+L": () => this.setHorizontalAlign("left"),
           "Ctrl+Shift+R": () => this.setHorizontalAlign("right"),
@@ -49672,31 +50238,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  /** @odoo-module */
-  class EditableName extends owl.Component {
-      static template = "o-spreadsheet-EditableName";
-      static props = {
-          name: String,
-          displayName: String,
-          onChanged: Function,
-      };
-      state;
-      setup() {
-          this.state = owl.useState({
-              isEditing: false,
-              name: "",
-          });
-      }
-      rename() {
-          this.state.isEditing = true;
-          this.state.name = this.props.name;
-      }
-      save() {
-          this.props.onChanged(this.state.name.trim());
-          this.state.isEditing = false;
-      }
-  }
-
   /**
    * BasePlugin
    *
@@ -49797,12 +50338,10 @@ stores.inject(MyMetaStore, storeInstance);
    */
   class CorePlugin extends BasePlugin {
       getters;
-      uuidGenerator;
-      constructor({ getters, stateObserver, range, dispatch, canDispatch, uuidGenerator, }) {
+      constructor({ getters, stateObserver, range, dispatch, canDispatch }) {
           super(stateObserver, dispatch, canDispatch);
           range.addRangeProvider(this.adaptRanges.bind(this));
           this.getters = getters;
-          this.uuidGenerator = uuidGenerator;
       }
       // ---------------------------------------------------------------------------
       // Import/Export
@@ -53616,7 +54155,7 @@ stores.inject(MyMetaStore, storeInstance);
               this.sheetIdsMapName[sheet.name] = sheet.id;
           }
           for (let sheetData of data.sheets) {
-              const name = sheetData.name || _t("Sheet") + (Object.keys(this.sheets).length + 1);
+              const name = sheetData.name || "Sheet" + (Object.keys(this.sheets).length + 1);
               const { colNumber, rowNumber } = this.getImportedSheetSize(sheetData);
               const sheet = {
                   id: sheetData.id,
@@ -54300,6 +54839,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  let nextTableId = 1;
   class TablePlugin extends CorePlugin {
       static getters = ["getCoreTable", "getCoreTables", "getCoreTableMatchingTopLeft"];
       tables = {};
@@ -54367,7 +54907,7 @@ stores.inject(MyMetaStore, storeInstance);
                   const union = this.getters.getRangesUnion(ranges);
                   const mergesInTarget = this.getters.getMergesInZone(cmd.sheetId, union.zone);
                   this.dispatch("REMOVE_MERGE", { sheetId: cmd.sheetId, target: mergesInTarget });
-                  const id = this.uuidGenerator.uuidv4();
+                  const id = `${nextTableId++}`;
                   const config = cmd.config || DEFAULT_TABLE_CONFIG;
                   const newTable = cmd.tableType === "dynamic"
                       ? this.createDynamicTable(id, union, config)
@@ -54520,7 +55060,7 @@ stores.inject(MyMetaStore, storeInstance);
               filters = [];
               for (const i of range(zone.left, zone.right + 1)) {
                   const filterZone = { ...zone, left: i, right: i };
-                  const uid = this.uuidGenerator.uuidv4();
+                  const uid = `${nextTableId++}`;
                   filters.push(this.createFilterFromZone(uid, tableRange.sheetId, filterZone, config));
               }
           }
@@ -54585,7 +55125,7 @@ stores.inject(MyMetaStore, storeInstance);
                       ? table.filters.find((f) => f.col === i)
                       : undefined;
                   const filterZone = { ...tableZone, left: i, right: i };
-                  const filterId = oldFilter?.id || this.uuidGenerator.uuidv4();
+                  const filterId = oldFilter?.id || `${nextTableId++}`;
                   filters.push(this.createFilterFromZone(filterId, tableRange.sheetId, filterZone, config));
               }
           }
@@ -54686,7 +55226,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (filters.length < zoneToDimension(tableZone).numberOfCols) {
               for (let col = tableZone.left; col <= tableZone.right; col++) {
                   if (!filters.find((filter) => filter.col === col)) {
-                      const uid = this.uuidGenerator.uuidv4();
+                      const uid = `${nextTableId++}`;
                       const filterZone = { ...tableZone, left: col, right: col };
                       filters.push(this.createFilterFromZone(uid, sheetId, filterZone, table.config));
                   }
@@ -54702,7 +55242,7 @@ stores.inject(MyMetaStore, storeInstance);
       import(data) {
           for (const sheet of data.sheets) {
               for (const tableData of sheet.tables || []) {
-                  const uuid = this.uuidGenerator.uuidv4();
+                  const uuid = `${nextTableId++}`;
                   const tableConfig = tableData.config || DEFAULT_TABLE_CONFIG;
                   const range = this.getters.getRangeFromSheetXC(sheet.id, tableData.range);
                   const tableType = tableData.type || "static";
@@ -55234,7 +55774,7 @@ stores.inject(MyMetaStore, storeInstance);
               case "DUPLICATE_PIVOT": {
                   const { pivotId, newPivotId } = cmd;
                   const pivot = deepCopy(this.getPivotCore(pivotId).definition);
-                  pivot.name = _t("%s (copy)", pivot.name);
+                  pivot.name = cmd.duplicatedPivotName ?? pivot.name + " (copy)";
                   this.addPivot(newPivotId, pivot);
                   break;
               }
@@ -55274,7 +55814,7 @@ stores.inject(MyMetaStore, storeInstance);
           return `(#${formulaId}) ${this.getPivotName(pivotId)}`;
       }
       getPivotName(pivotId) {
-          return _t(this.getPivotCore(pivotId).definition.name);
+          return this.getPivotCore(pivotId).definition.name;
       }
       /**
        * Returns the pivot core definition of the pivot with the given id.
@@ -56916,7 +57456,7 @@ stores.inject(MyMetaStore, storeInstance);
           cellsToCompute.addMany(arrayFormulasPositions);
           cellsToCompute.addMany(this.getCellsDependingOn(arrayFormulasPositions));
           this.evaluate(cellsToCompute);
-          console.info("evaluate Cells", performance.now() - start, "ms");
+          console.debug("evaluate Cells", performance.now() - start, "ms");
       }
       getArrayFormulasImpactedByChangesOf(positions) {
           const impactedPositions = this.createEmptyPositionSet();
@@ -56960,7 +57500,7 @@ stores.inject(MyMetaStore, storeInstance);
           const start = performance.now();
           this.evaluatedCells = new PositionMap();
           this.evaluate(this.getAllCells());
-          console.info("evaluate all cells", performance.now() - start, "ms");
+          console.debug("evaluate all cells", performance.now() - start, "ms");
       }
       evaluateFormulaResult(sheetId, formulaString) {
           const compiledFormula = compile(formulaString);
@@ -57966,8 +58506,7 @@ stores.inject(MyMetaStore, storeInstance);
               .map((cell) => cell.value);
           switch (threshold.type) {
               case "value":
-                  const result = functionName === "max" ? largeMax(rangeValues) : largeMin(rangeValues);
-                  return result;
+                  return functionName === "max" ? largeMax(rangeValues) : largeMin(rangeValues);
               case "number":
                   return Number(threshold.value);
               case "percentage":
@@ -59051,7 +59590,7 @@ stores.inject(MyMetaStore, storeInstance);
               const ranking = {};
               const mainDimension = getFieldDimensionType(this, fieldNameWithGranularity);
               const secondaryDimension = mainDimension === "row" ? "column" : "row";
-              let pivotCells = this.getPivotValueCells();
+              let pivotCells = this.getPivotValueCells(measure.id);
               if (mainDimension === "column") {
                   // Transpose the pivot cells so we can do the same operations on the columns as on the rows
                   // This means that we need to transpose back the ranking at the end
@@ -59095,7 +59634,7 @@ stores.inject(MyMetaStore, storeInstance);
               const cellsRunningTotals = {};
               const mainDimension = getFieldDimensionType(this, fieldNameWithGranularity);
               const secondaryDimension = mainDimension === "row" ? "column" : "row";
-              let pivotCells = this.getPivotValueCells();
+              let pivotCells = this.getPivotValueCells(measure.id);
               if (mainDimension === "column") {
                   // Transpose the pivot cells so we can do the same operations on the columns as on the rows
                   // This means that we need to transpose back the totals at the end
@@ -59171,13 +59710,12 @@ stores.inject(MyMetaStore, storeInstance);
                   throw new NotAvailableError();
               }
               const comparedValue = this._getPivotCellValueAndFormat(measure.id, comparedDomain);
-              const comparedValueNumber = this.strictMeasureValueToNumber(comparedValue);
-              return comparedValueNumber;
+              return this.strictMeasureValueToNumber(comparedValue);
           }
-          getPivotValueCells() {
+          getPivotValueCells(measureId) {
               return this.getTableStructure()
                   .getPivotCells()
-                  .map((col) => col.filter((cell) => cell.type === "VALUE"))
+                  .map((col) => col.filter((cell) => cell.type === "VALUE" && cell.measure === measureId))
                   .filter((col) => col.length > 0);
           }
           measureValueToNumber(result) {
@@ -60706,7 +61244,7 @@ stores.inject(MyMetaStore, storeInstance);
               this.onMessageReceived(message);
           }
           this.isReplayingInitialRevisions = false;
-          console.info("Replayed", numberOfCommands, "commands in", performance.now() - start, "ms");
+          console.debug("Replayed", numberOfCommands, "commands in", performance.now() - start, "ms");
       }
       /**
        * Notify the server that the user client left the collaborative session
@@ -60878,7 +61416,6 @@ stores.inject(MyMetaStore, storeInstance);
           if (this.waitingAck) {
               return;
           }
-          this.waitingAck = true;
           this.sendPendingMessage();
       }
       /**
@@ -60915,6 +61452,7 @@ stores.inject(MyMetaStore, storeInstance);
               throw new Error(`Trying to send a new revision while replaying initial revision. This can lead to endless dispatches every time the spreadsheet is open.
       ${JSON.stringify(message)}`);
           }
+          this.waitingAck = true;
           this.transportService.sendMessage({
               ...message,
               serverRevisionId: this.serverRevisionId,
@@ -60945,6 +61483,7 @@ stores.inject(MyMetaStore, storeInstance);
               case "REMOTE_REVISION":
               case "REVISION_REDONE":
               case "REVISION_UNDONE":
+              case "SNAPSHOT_CREATED":
                   return this.processedRevisions.has(message.nextRevisionId);
               default:
                   return false;
@@ -61073,8 +61612,7 @@ stores.inject(MyMetaStore, storeInstance);
               }
               const color = client.color;
               /* Cell background */
-              const cellBackgroundColor = `${color}10`;
-              ctx.fillStyle = cellBackgroundColor;
+              ctx.fillStyle = `${color}10`;
               ctx.lineWidth = 4 * thinLineWidth;
               ctx.strokeStyle = color;
               ctx.globalCompositeOperation = "multiply";
@@ -61441,8 +61979,7 @@ stores.inject(MyMetaStore, storeInstance);
       exportForExcel(data) {
           for (const sheetData of data.sheets) {
               for (const [row, rowData] of Object.entries(sheetData.rows)) {
-                  const isHidden = this.isRowHidden(sheetData.id, Number(row));
-                  rowData.isHidden = isHidden;
+                  rowData.isHidden = this.isRowHidden(sheetData.id, Number(row));
               }
           }
       }
@@ -61502,12 +62039,13 @@ stores.inject(MyMetaStore, storeInstance);
           this.dispatch("DUPLICATE_PIVOT", {
               pivotId,
               newPivotId,
+              duplicatedPivotName: _t("%s (copy)", this.getters.getPivotCoreDefinition(pivotId).name),
           });
           const activeSheetId = this.getters.getActiveSheetId();
           const position = this.getters.getSheetIds().indexOf(activeSheetId) + 1;
           const formulaId = this.getters.getPivotFormulaId(newPivotId);
           const newPivotName = this.getters.getPivotName(newPivotId);
-          this.dispatch("CREATE_SHEET", {
+          const result = this.dispatch("CREATE_SHEET", {
               sheetId: newSheetId,
               name: this.getPivotDuplicateSheetName(_t("%(newPivotName)s (Pivot #%(formulaId)s)", {
                   newPivotName,
@@ -61515,20 +62053,19 @@ stores.inject(MyMetaStore, storeInstance);
               })),
               position,
           });
-          this.dispatch("ACTIVATE_SHEET", { sheetIdFrom: activeSheetId, sheetIdTo: newSheetId });
-          this.dispatch("UPDATE_CELL", {
-              sheetId: newSheetId,
-              col: 0,
-              row: 0,
-              content: `=PIVOT(${formulaId})`,
-          });
+          if (result.isSuccessful) {
+              this.dispatch("ACTIVATE_SHEET", { sheetIdFrom: activeSheetId, sheetIdTo: newSheetId });
+              const pivot = this.getters.getPivot(pivotId);
+              this.insertPivotWithTable(newSheetId, 0, 0, newPivotId, pivot.getTableStructure().export(), "dynamic");
+          }
       }
       getPivotDuplicateSheetName(pivotName) {
           let i = 1;
           const names = this.getters.getSheetIds().map((id) => this.getters.getSheetName(id));
-          let name = pivotName;
+          const sanitizedName = pivotName.replace(new RegExp(FORBIDDEN_IN_EXCEL_REGEX, "g"), " ");
+          let name = sanitizedName;
           while (names.includes(name)) {
-              name = `${pivotName} (${i})`;
+              name = `${sanitizedName} (${i})`;
               i++;
           }
           return name;
@@ -61967,7 +62504,6 @@ stores.inject(MyMetaStore, storeInstance);
               if (!isEqual(zone, newZone)) {
                   hasExpanded = true;
                   zone = newZone;
-                  continue;
               }
           } while (hasExpanded);
           return zone;
@@ -63060,7 +63596,7 @@ stores.inject(MyMetaStore, storeInstance);
               case "ADD_COLUMNS_ROWS": {
                   this.status = "invisible";
                   // If we add a col/row inside or before the cut area, we invalidate the clipboard
-                  if (this._isCutOperation !== true || cmd.sheetId !== this.copiedData?.sheetId) {
+                  if (!this._isCutOperation || cmd.sheetId !== this.copiedData?.sheetId) {
                       return;
                   }
                   const isClipboardDirty = this.isColRowDirtyingClipboard(cmd.position === "before" ? cmd.base : cmd.base + 1, cmd.dimension);
@@ -63072,7 +63608,7 @@ stores.inject(MyMetaStore, storeInstance);
               case "REMOVE_COLUMNS_ROWS": {
                   this.status = "invisible";
                   // If we remove a col/row inside or before the cut area, we invalidate the clipboard
-                  if (this._isCutOperation !== true || cmd.sheetId !== this.copiedData?.sheetId) {
+                  if (!this._isCutOperation || cmd.sheetId !== this.copiedData?.sheetId) {
                       return;
                   }
                   for (let el of cmd.elements) {
@@ -63094,7 +63630,7 @@ stores.inject(MyMetaStore, storeInstance);
                   break;
               }
               case "DELETE_SHEET":
-                  if (this._isCutOperation !== true) {
+                  if (!this._isCutOperation) {
                       return;
                   }
                   if (this.originSheetId === cmd.sheetId) {
@@ -63987,8 +64523,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.setSelectionMixin({ zone, cell: { col, row } }, [zone]);
       }
       setActiveSheet(id) {
-          const sheet = this.getters.getSheet(id);
-          this.activeSheet = sheet;
+          this.activeSheet = this.getters.getSheet(id);
       }
       activateNextSheet(direction) {
           const sheetIds = this.getters.getSheetIds();
@@ -64682,9 +65217,6 @@ stores.inject(MyMetaStore, storeInstance);
               case "UNFREEZE_COLUMNS_ROWS":
                   this.resetViewports(this.getters.getActiveSheetId());
                   break;
-              case "DELETE_SHEET":
-                  this.sheetsWithDirtyViewports.delete(cmd.sheetId);
-                  break;
               case "SCROLL_TO_CELL":
                   this.refreshViewport(this.getters.getActiveSheetId(), { col: cmd.col, row: cmd.row });
                   break;
@@ -66636,10 +67168,9 @@ stores.inject(MyMetaStore, storeInstance);
     user-select: none;
     color: ${TEXT_BODY};
 
-    .o-heading-3 {
+    .o-sidePanelTitle {
       line-height: 20px;
       font-size: 16px;
-      font-weight: 600;
     }
 
     .o-sidePanelHeader {
@@ -66724,6 +67255,10 @@ stores.inject(MyMetaStore, storeInstance);
       }
     }
   }
+
+  .o-fw-bold {
+    font-weight: 500;
+  }
 `;
   class SidePanel extends owl.Component {
       static template = "o-spreadsheet-SidePanel";
@@ -67555,8 +68090,7 @@ stores.inject(MyMetaStore, storeInstance);
                   for (const item of clipboardItems) {
                       for (const type of item.types) {
                           const blob = await item.getType(type);
-                          const text = await blob.text();
-                          clipboardContent[type] = text;
+                          clipboardContent[type] = await blob.text();
                       }
                   }
                   return { status: "ok", content: clipboardContent };
@@ -67868,7 +68402,6 @@ stores.inject(MyMetaStore, storeInstance);
       spreadsheetRef = owl.useRef("spreadsheet");
       spreadsheetRect = useSpreadsheetRect();
       _focusGrid;
-      keyDownMapping;
       isViewportTooSmall = false;
       notificationStore;
       composerFocusStore;
@@ -67892,10 +68425,6 @@ stores.inject(MyMetaStore, storeInstance);
           this.notificationStore = useStore(NotificationStore);
           this.composerFocusStore = useStore(ComposerFocusStore);
           this.sidePanel = useStore(SidePanelStore);
-          this.keyDownMapping = {
-              "CTRL+H": () => this.sidePanel.toggle("FindAndReplace", {}),
-              "CTRL+F": () => this.sidePanel.toggle("FindAndReplace", {}),
-          };
           const fileStore = this.model.config.external.fileStore;
           owl.useSubEnv({
               model: this.model,
@@ -67995,20 +68524,6 @@ stores.inject(MyMetaStore, storeInstance);
           }
           this._focusGrid();
       }
-      onKeydown(ev) {
-          let keyDownString = "";
-          if (isCtrlKey(ev)) {
-              keyDownString += "CTRL+";
-          }
-          keyDownString += ev.key.toUpperCase();
-          let handler = this.keyDownMapping[keyDownString];
-          if (handler) {
-              ev.preventDefault();
-              ev.stopPropagation();
-              handler();
-              return;
-          }
-      }
       get gridHeight() {
           const { height } = this.env.model.getters.getSheetViewDimension();
           return height;
@@ -69423,10 +69938,10 @@ stores.inject(MyMetaStore, storeInstance);
       getNextCellPosition(currentPosition, dimension, direction) {
           const dimOfInterest = dimension === "cols" ? "col" : "row";
           const startingPosition = { ...currentPosition };
-          const nextCoord = dimension === "cols"
-              ? this.getNextAvailableCol(direction, startingPosition.col, startingPosition.row)
-              : this.getNextAvailableRow(direction, startingPosition.col, startingPosition.row);
-          startingPosition[dimOfInterest] = nextCoord;
+          startingPosition[dimOfInterest] =
+              dimension === "cols"
+                  ? this.getNextAvailableCol(direction, startingPosition.col, startingPosition.row)
+                  : this.getNextAvailableRow(direction, startingPosition.col, startingPosition.row);
           return { col: startingPosition.col, row: startingPosition.row };
       }
       getPosition() {
@@ -69550,6 +70065,8 @@ stores.inject(MyMetaStore, storeInstance);
           case "pie":
               plot = addDoughnutChart(chart.data, chartSheetIndex, data, { holeSize: 0 });
               break;
+          case "radar":
+              plot = addRadarChart(chart.data);
       }
       let position = "t";
       switch (chart.data.legendPosition) {
@@ -70008,6 +70525,53 @@ stores.inject(MyMetaStore, storeInstance);
     `
         : ""}`;
   }
+  function addRadarChart(chart) {
+      const dataSetsColors = chart.dataSets.map((ds) => ds.backgroundColor ?? "");
+      const colors = new ColorGenerator(chart.dataSets.length, dataSetsColors);
+      const dataSetsNodes = [];
+      for (const [dsIndex, dataset] of Object.entries(chart.dataSets)) {
+          const color = toXlsxHexColor(colors.next());
+          const dataShapeProperty = shapeProperty({
+              line: {
+                  width: 2.5,
+                  style: "solid",
+                  color,
+              },
+          });
+          const dataSetNode = escapeXml /*xml*/ `
+      <c:ser>
+        <c:idx val="${dsIndex}"/>
+        <c:order val="${dsIndex}"/>
+        <c:smooth val="0"/>
+        <c:marker>
+          <c:symbol val="circle" />
+          <c:size val="5"/>
+          ${shapeProperty({ backgroundColor: color, line: { color } })}
+        </c:marker>
+        ${extractDataSetLabel(dataset.label)}
+        ${dataShapeProperty}
+        ${chart.labelRange ? escapeXml `<c:cat>${stringRef(chart.labelRange)}</c:cat>` : ""} <!-- x-coordinate values -->
+        <c:val> <!-- x-coordinate values -->
+          ${numberRef(dataset.range)}
+        </c:val>
+      </c:ser>
+    `;
+          dataSetsNodes.push(dataSetNode);
+      }
+      return escapeXml /*xml*/ `
+    ${escapeXml /*xml*/ `
+        <c:radarChart>
+        <c:radarStyle val="marker"/>
+          <c:varyColors val="0"/>
+          ${joinXmlNodes(dataSetsNodes)}
+          <c:axId val="${catAxId}" />
+          <c:axId val="${valAxId}" />
+        </c:radarChart>
+        ${addAx("b", "c:catAx", catAxId, valAxId, chart.axesDesign?.x?.title, chart.fontColor)}
+        ${addAx("l", "c:valAx", valAxId, catAxId, chart.axesDesign?.y?.title, chart.fontColor)}
+      `}
+  `;
+  }
   function addDoughnutChart(chart, chartSheetIndex, data, { holeSize } = { holeSize: 50 }) {
       const maxLength = largeMax(chart.dataSets.map((ds) => getRangeSize(ds.range, chartSheetIndex, data)));
       const colors = new ColorGenerator(maxLength);
@@ -70881,6 +71445,15 @@ stores.inject(MyMetaStore, storeInstance);
               ["id", i + 1], // id cannot be 0
               ["name", colName],
           ];
+          if (table.config.totalRow) {
+              // Note: To be 100% complete, we could also add a `totalsRowLabel` attribute for total strings, and a tag
+              // `<totalsRowFormula>` for the formula of the total. But those doesn't seem to be mandatory for Excel.
+              const colTotalXc = toXC(tableZone.left + i, tableZone.bottom);
+              const colTotalContent = sheetData.cells[colTotalXc]?.content;
+              if (colTotalContent?.startsWith("=")) {
+                  colAttributes.push(["totalsRowFunction", "custom"]);
+              }
+          }
           columns.push(escapeXml /*xml*/ `<tableColumn ${formatAttributes(colAttributes)}/>`);
       }
       return escapeXml /*xml*/ `
@@ -70975,8 +71548,9 @@ stores.inject(MyMetaStore, storeInstance);
                   }
                   else if (cell.content && cell.content !== "") {
                       const isTableHeader = isCellTableHeader(c, r, sheet);
+                      const isTableTotal = isCellTableTotal(c, r, sheet);
                       const isPlainText = !!(cell.format && isTextFormat(data.formats[cell.format]));
-                      ({ attrs: additionalAttrs, node: cellNode } = addContent(cell.content, construct.sharedStrings, isTableHeader || isPlainText));
+                      ({ attrs: additionalAttrs, node: cellNode } = addContent(cell.content, construct.sharedStrings, isTableHeader || isTableTotal || isPlainText));
                   }
                   attributes.push(...additionalAttrs);
                   // prettier-ignore
@@ -71010,6 +71584,16 @@ stores.inject(MyMetaStore, storeInstance);
           return isInside(col, row, headerZone);
       });
   }
+  function isCellTableTotal(col, row, sheet) {
+      return sheet.tables.some((table) => {
+          if (!table.config.totalRow) {
+              return false;
+          }
+          const zone = toZone(table.range);
+          const totalZone = { ...zone, top: zone.bottom };
+          return isInside(col, row, totalZone);
+      });
+  }
   function addHyperlinks(construct, data, sheetIndex) {
       const sheet = data.sheets[sheetIndex];
       const cells = sheet.cells;
@@ -71095,25 +71679,23 @@ stores.inject(MyMetaStore, storeInstance);
           ["showGridLines", sheet.areGridLinesVisible ? 1 : 0],
           ["workbookViewId", 0],
       ];
-      let sheetView = escapeXml /*xml*/ `
+      return escapeXml /*xml*/ `
       <sheetViews>
         <sheetView ${formatAttributes(sheetViewAttrs)}>
           ${splitPanes}
         </sheetView>
       </sheetViews>
     `;
-      return sheetView;
   }
   function addSheetProperties(sheet) {
       if (!sheet.color) {
           return "";
       }
-      let sheetView = escapeXml /*xml*/ `
+      return escapeXml /*xml*/ `
       <sheetPr>
         <tabColor ${formatAttributes([["rgb", toXlsxHexColor(sheet.color)]])} />
       </sheetPr>
     `;
-      return sheetView;
   }
 
   /**
@@ -71426,9 +72008,7 @@ stores.inject(MyMetaStore, storeInstance);
   })(Status || (Status = {}));
   class Model extends EventBus {
       corePlugins = [];
-      featurePlugins = [];
       statefulUIPlugins = [];
-      coreViewsPlugins = [];
       range;
       session;
       /**
@@ -71473,7 +72053,7 @@ stores.inject(MyMetaStore, storeInstance);
       coreHandlers = [];
       constructor(data = {}, config = {}, stateUpdateMessages = [], uuidGenerator = new UuidGenerator(), verboseImport = false) {
           const start = performance.now();
-          console.group("Model creation");
+          console.debug("##### Model creation #####");
           super();
           setDefaultTranslationMethod();
           stateUpdateMessages = repairInitialMessages(data, stateUpdateMessages);
@@ -71500,7 +72080,6 @@ stores.inject(MyMetaStore, storeInstance);
               isReadonly: () => this.config.mode === "readonly" || this.config.mode === "dashboard",
               isDashboard: () => this.config.mode === "dashboard",
           };
-          this.uuidGenerator.setIsFastStrategy(true);
           // Initiate stream processor
           this.selection = new SelectionStreamProcessorImpl(this.getters);
           this.coreHandlers.push(this.range);
@@ -71515,7 +72094,6 @@ stores.inject(MyMetaStore, storeInstance);
           this.session.loadInitialMessages(stateUpdateMessages);
           for (let Plugin of coreViewsPluginRegistry.getAll()) {
               const plugin = this.setupUiPlugin(Plugin);
-              this.coreViewsPlugins.push(plugin);
               this.handlers.push(plugin);
               this.uiHandlers.push(plugin);
               this.coreHandlers.push(plugin);
@@ -71528,11 +72106,9 @@ stores.inject(MyMetaStore, storeInstance);
           }
           for (let Plugin of featurePluginRegistry.getAll()) {
               const plugin = this.setupUiPlugin(Plugin);
-              this.featurePlugins.push(plugin);
               this.handlers.push(plugin);
               this.uiHandlers.push(plugin);
           }
-          this.uuidGenerator.setIsFastStrategy(false);
           // starting plugins
           this.dispatch("START");
           // Model should be the last permanent subscriber in the list since he should render
@@ -71546,16 +72122,16 @@ stores.inject(MyMetaStore, storeInstance);
           this.joinSession();
           if (config.snapshotRequested) {
               const startSnapshot = performance.now();
-              console.info("Snapshot requested");
+              console.debug("Snapshot requested");
               this.session.snapshot(this.exportData());
               this.garbageCollectExternalResources();
-              console.info("Snapshot taken in", performance.now() - startSnapshot, "ms");
+              console.debug("Snapshot taken in", performance.now() - startSnapshot, "ms");
           }
           // mark all models as "raw", so they will not be turned into reactive objects
           // by owl, since we do not rely on reactivity
           owl.markRaw(this);
-          console.info("Model created in", performance.now() - start, "ms");
-          console.groupEnd();
+          console.debug("Model created in", performance.now() - start, "ms");
+          console.debug("######");
       }
       joinSession() {
           this.session.join(this.config.client);
@@ -71614,7 +72190,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.finalize();
       }
       setupSession(revisionId) {
-          const session = new Session(buildRevisionLog({
+          return new Session(buildRevisionLog({
               initialRevisionId: revisionId,
               recordChanges: this.state.recordChanges.bind(this.state),
               dispatch: (command) => {
@@ -71627,7 +72203,6 @@ stores.inject(MyMetaStore, storeInstance);
                   this.isReplayingCommand = false;
               },
           }), this.config.transportService, revisionId);
-          return session;
       }
       setupSessionEvents() {
           this.session.on("remote-revision-received", this, this.onRemoteRevisionReceived);
@@ -71680,7 +72255,6 @@ stores.inject(MyMetaStore, storeInstance);
               range: this.range,
               dispatch: this.dispatchFromCorePlugin,
               canDispatch: this.canDispatch,
-              uuidGenerator: this.uuidGenerator,
               custom: this.config.custom,
               external: this.config.external,
           };
@@ -71721,8 +72295,7 @@ stores.inject(MyMetaStore, storeInstance);
           return results;
       }
       checkDispatchAllowedLocalCommand(command) {
-          const results = this.uiHandlers.map((handler) => handler.allowDispatch(command));
-          return results;
+          return this.uiHandlers.map((handler) => handler.allowDispatch(command));
       }
       finalize() {
           this.status = 3 /* Status.Finalizing */;
@@ -71779,7 +72352,7 @@ stores.inject(MyMetaStore, storeInstance);
                       this.finalize();
                       const time = performance.now() - start;
                       if (time > 5) {
-                          console.info(type, time, "ms");
+                          console.debug(type, time, "ms");
                       }
                   });
                   this.session.save(command, commands, changes);
@@ -72082,7 +72655,6 @@ stores.inject(MyMetaStore, storeInstance);
       PivotDimensionOrder,
       PivotDimension,
       PivotLayoutConfigurator,
-      EditableName,
       PivotDeferUpdate,
       PivotTitleSection,
       CogWheelMenu,
@@ -72174,9 +72746,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.1.0-alpha.0";
-  __info__.date = "2024-09-25T13:17:49.636Z";
-  __info__.hash = "288f0b7";
+  __info__.version = "18.1.0-alpha.2";
+  __info__.date = "2024-10-24T08:53:21.828Z";
+  __info__.hash = "2a01250";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);