@odoo/o-spreadsheet 16.5.0-alpha.11 → 16.5.0-alpha.13

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 16.5.0-alpha.11
- * @date 2023-10-19T14:26:01.790Z
- * @hash 4b42059
+ * @version 16.5.0-alpha.13
+ * @date 2023-10-25T10:04:45.428Z
+ * @hash 18a08b1
  */
 
 (function (exports, owl) {
@@ -2059,6 +2059,7 @@
       CommandResult["InvalidDataValidationCriterionValue"] = "InvalidDataValidationCriterionValue";
       CommandResult["InvalidNumberOfCriterionValues"] = "InvalidNumberOfCriterionValues";
       CommandResult["BlockingValidationRule"] = "BlockingValidationRule";
+      CommandResult["InvalidCopyPasteSelection"] = "InvalidCopyPasteSelection";
   })(exports.CommandResult || (exports.CommandResult = {}));
 
   const DEFAULT_LOCALES = [
@@ -4660,7 +4661,7 @@
           return `background-color: ${this.background}`;
       }
       get chartRuntime() {
-          const runtime = this.env.model.getters.getChartRuntime(this.props.figureId);
+          const runtime = this.env.model.getters.getChartRuntime(this.props.figure.id);
           if (!("chartJsConfig" in runtime)) {
               throw new Error("Unsupported chart runtime");
           }
@@ -4704,7 +4705,7 @@
       }
   }
   ChartJsComponent.props = {
-      figureId: String,
+      figure: Object,
   };
 
   /**
@@ -5106,6 +5107,8 @@
           ? "InvalidScorecardBaseline" /* CommandResult.InvalidScorecardBaseline */
           : "Success" /* CommandResult.Success */;
   }
+  const arrowDownPath = new window.Path2D("M8.6 4.8a.5.5 0 0 1 0 .75l-3.9 3.9a.5 .5 0 0 1 -.75 0l-3.8 -3.9a.5 .5 0 0 1 0 -.75l.4-.4a.5.5 0 0 1 .75 0l2.3 2.4v-5.7c0-.25.25-.5.5-.5h.6c.25 0 .5.25.5.5v5.8l2.3 -2.4a.5.5 0 0 1 .75 0z");
+  const arrowUpPath = new window.Path2D("M8.7 5.5a.5.5 0 0 0 0-.75l-3.8-4a.5.5 0 0 0-.75 0l-3.8 4a.5.5 0 0 0 0 .75l.4.4a.5.5 0 0 0 .75 0l2.3-2.4v5.8c0 .25.25.5.5.5h.6c.25 0 .5-.25.5-.5v-5.8l2.2 2.4a.5.5 0 0 0 .75 0z");
   let ScorecardChart$1 = class ScorecardChart extends AbstractChart {
       keyValue;
       baseline;
@@ -5226,10 +5229,24 @@
           ctx.fillStyle = structure.baseline.style.color;
           drawDecoratedText(ctx, structure.baseline.text, structure.baseline.position, structure.baseline.style.underline, structure.baseline.style.strikethrough);
       }
-      if (structure.baselineArrow) {
-          ctx.font = structure.baselineArrow.style.font;
+      if (structure.baselineArrow && structure.baselineArrow.style.size > 0) {
+          ctx.save();
           ctx.fillStyle = structure.baselineArrow.style.color;
-          ctx.fillText(structure.baselineArrow.text, structure.baselineArrow.position.x, structure.baselineArrow.position.y);
+          ctx.translate(structure.baselineArrow.position.x, structure.baselineArrow.position.y);
+          // This ratio is computed according to the original svg size and the final size we want
+          const ratio = structure.baselineArrow.style.size / 10;
+          ctx.scale(ratio, ratio);
+          switch (structure.baselineArrow.direction) {
+              case "down": {
+                  ctx.fill(arrowDownPath);
+                  break;
+              }
+              case "up": {
+                  ctx.fill(arrowUpPath);
+                  break;
+              }
+          }
+          ctx.restore();
       }
       if (structure.baselineDescr) {
           ctx.font = structure.baselineDescr.style.font;
@@ -5352,25 +5369,29 @@
                   },
               };
           }
-          const { height: baselineArrowHeight, width: baselineArrowWidth } = this.getTextDimensions(this.baselineArrow, style.baselineArrow.font);
+          const baselineArrowSize = style.baselineArrow?.size ?? 0;
           const { height: baselineHeight, width: baselineWidth } = this.getTextDimensions(this.baseline, style.baselineValue.font);
           const { width: baselineDescrWidth } = this.getTextDimensions(this.baselineDescr, style.baselineDescr.font);
           structure.baseline = {
               text: this.baseline,
               style: style.baselineValue,
               position: {
-                  x: (this.width - baselineWidth - baselineDescrWidth + baselineArrowWidth) / 2,
-                  y: this.height - 2 * this.chartPadding,
-              },
-          };
-          structure.baselineArrow = {
-              text: this.baselineArrow,
-              style: style.baselineArrow,
-              position: {
-                  x: structure.baseline.position.x - baselineArrowWidth,
-                  y: structure.baseline.position.y - (baselineHeight - baselineArrowHeight) / 2,
+                  x: (this.width - baselineWidth - baselineDescrWidth + baselineArrowSize) / 2,
+                  y: this.keyValue
+                      ? this.height - 2 * this.chartPadding
+                      : this.height - (this.height - titleHeight - baselineHeight) / 2 - this.chartPadding,
               },
           };
+          if (style.baselineArrow) {
+              structure.baselineArrow = {
+                  direction: this.baselineArrow,
+                  style: style.baselineArrow,
+                  position: {
+                      x: structure.baseline.position.x - baselineArrowSize,
+                      y: structure.baseline.position.y - (baselineHeight + baselineArrowSize) / 2,
+                  },
+              };
+          }
           if (this.baselineDescr) {
               structure.baselineDescr = {
                   text: this.baselineDescr,
@@ -5407,13 +5428,7 @@
           return formatBaselineDescr(this.runtime.baselineDescr, this.baseline);
       }
       get baselineArrow() {
-          switch (this.runtime.baselineArrow) {
-              case "up":
-                  return "\u{1F871}";
-              case "down":
-                  return "\u{1F873}";
-          }
-          return "";
+          return this.runtime.baselineArrow;
       }
       get backgroundColor() {
           return this.runtime.background;
@@ -5465,10 +5480,12 @@
                   font: getDefaultContextFont(baselineFontSize * BASELINE_DESCR_FONT_RATIO),
                   color: this.secondaryFontColor,
               },
-              baselineArrow: {
-                  font: getDefaultContextFont(0.8 * baselineFontSize),
-                  color: this.runtime.baselineColor || this.secondaryFontColor,
-              },
+              baselineArrow: this.baselineArrow === "neutral"
+                  ? undefined
+                  : {
+                      size: this.keyValue ? 0.8 * baselineFontSize : 0,
+                      color: this.runtime.baselineColor || this.secondaryFontColor,
+                  },
           };
       }
       /** Get the height of the chart minus all the vertical paddings */
@@ -5505,7 +5522,7 @@
           }
           const baselineStr = chart.baseline;
           // Put mock text to simulate the width of the up/down arrow
-          const largeText = chart.baselineArrow !== "" ? "A " + baselineStr : baselineStr;
+          const largeText = chart.baselineArrow !== "neutral" ? "A " + baselineStr : baselineStr;
           let textWidth = this.measureTextWidth(ctx, largeText, fontSize);
           // Baseline descr font size should be smaller than baseline font size
           textWidth += this.measureTextWidth(ctx, chart.baselineDescr, fontSize * BASELINE_DESCR_FONT_RATIO);
@@ -5542,7 +5559,7 @@
       static template = "o-spreadsheet-ScorecardChart";
       canvas = owl.useRef("chartContainer");
       get runtime() {
-          return this.env.model.getters.getChartRuntime(this.props.figureId);
+          return this.env.model.getters.getChartRuntime(this.props.figure.id);
       }
       setup() {
           owl.useEffect(this.createChart.bind(this), () => {
@@ -5558,7 +5575,7 @@
       }
   }
   ScorecardChart.props = {
-      figureId: String,
+      figure: Object,
   };
 
   /**
@@ -7567,6 +7584,18 @@
       }
       return result;
   }
+  /**
+   * Return the input if it's a scalar or the first element of the input if it's a matrix.
+   */
+  function toScalar(matrix) {
+      if (!isMatrix(matrix)) {
+          return matrix;
+      }
+      if (matrix.length !== 1 || matrix[0].length !== 1) {
+          throw new Error("toScalar: matrix should be a scalar or a 1x1 matrix");
+      }
+      return matrix[0][0];
+  }
 
   // -----------------------------------------------------------------------------
   // ARRAY_CONSTRAIN
@@ -10280,6 +10309,42 @@
       },
       isExported: true,
   };
+  // RANK
+  // -----------------------------------------------------------------------------
+  const RANK = {
+      description: _t("Returns the rank of a specified value in a dataset."),
+      args: [
+          arg("value (number)", _t("The value whose rank will be determined.")),
+          arg("data (range)", _t("The range containing the dataset to consider.")),
+          arg("is_ascending (boolean, default=FALSE)", _t("Whether to consider the values in data in descending or ascending order.")),
+      ],
+      returns: ["ANY"],
+      compute: function (value, data, isAscending = false) {
+          const _isAscending = toBoolean(isAscending);
+          const _value = toNumber(value, this.locale);
+          let rank = 1;
+          let found = false;
+          for (const row of data) {
+              for (const cell of row) {
+                  if (typeof cell !== "number") {
+                      continue;
+                  }
+                  const _cell = toNumber(cell, this.locale);
+                  if (_cell === _value) {
+                      found = true;
+                  }
+                  else if (_cell > _value !== _isAscending) {
+                      rank++;
+                  }
+              }
+          }
+          if (!found) {
+              throw new NotAvailableError(_t("Value not found in the given data."));
+          }
+          return rank;
+      },
+      isExported: true,
+  };
   // -----------------------------------------------------------------------------
   // RSQ
   // -----------------------------------------------------------------------------
@@ -10624,6 +10689,7 @@
     QUARTILE: QUARTILE,
     QUARTILE_EXC: QUARTILE_EXC,
     QUARTILE_INC: QUARTILE_INC,
+    RANK: RANK,
     RSQ: RSQ,
     SLOPE: SLOPE,
     SMALL: SMALL,
@@ -11770,6 +11836,172 @@
     DELTA: DELTA
   });
 
+  const SORT_TYPES = [
+      CellValueType.number,
+      CellValueType.error,
+      CellValueType.text,
+      CellValueType.boolean,
+  ];
+  function cellsSortingCriterion(sortingOrder) {
+      const inverse = sortingOrder === "ascending" ? 1 : -1;
+      return (left, right) => {
+          if (left.type === CellValueType.empty) {
+              return right.type === CellValueType.empty ? 0 : 1;
+          }
+          else if (right.type === CellValueType.empty) {
+              return -1;
+          }
+          let typeOrder = SORT_TYPES.indexOf(left.type) - SORT_TYPES.indexOf(right.type);
+          if (typeOrder === 0) {
+              if (left.type === CellValueType.text || left.type === CellValueType.error) {
+                  typeOrder = left.value.localeCompare(right.value);
+              }
+              else {
+                  typeOrder = left.value - right.value;
+              }
+          }
+          return inverse * typeOrder;
+      };
+  }
+  function sortCells(cells, sortDirection, emptyCellAsZero) {
+      const cellsWithIndex = cells.map((cell, index) => ({
+          index,
+          type: cell.type,
+          value: cell.value,
+      }));
+      const cellsToSort = emptyCellAsZero
+          ? cellsWithIndex.map((cell) => cell.type === CellValueType.empty ? { ...cell, type: CellValueType.number, value: 0 } : cell)
+          : cellsWithIndex;
+      return cellsToSort.sort(cellsSortingCriterion(sortDirection));
+  }
+  function interactiveSortSelection(env, sheetId, anchor, zone, sortDirection) {
+      let result = DispatchResult.Success;
+      //several columns => bypass the contiguity check
+      let multiColumns = zone.right > zone.left;
+      if (env.model.getters.doesIntersectMerge(sheetId, zone)) {
+          multiColumns = false;
+          let table;
+          for (let row = zone.top; row <= zone.bottom; row++) {
+              table = [];
+              for (let col = zone.left; col <= zone.right; col++) {
+                  let merge = env.model.getters.getMerge({ sheetId, col, row });
+                  if (merge && !table.includes(merge.id.toString())) {
+                      table.push(merge.id.toString());
+                  }
+              }
+              if (table.length >= 2) {
+                  multiColumns = true;
+                  break;
+              }
+          }
+      }
+      const { col, row } = anchor;
+      if (multiColumns) {
+          result = env.model.dispatch("SORT_CELLS", { sheetId, col, row, zone, sortDirection });
+      }
+      else {
+          // check contiguity
+          const contiguousZone = env.model.getters.getContiguousZone(sheetId, zone);
+          if (isEqual(contiguousZone, zone)) {
+              // merge as it is
+              result = env.model.dispatch("SORT_CELLS", {
+                  sheetId,
+                  col,
+                  row,
+                  zone,
+                  sortDirection,
+              });
+          }
+          else {
+              env.askConfirmation(_t("We found data next to your selection. Since this data was not selected, it will not be sorted. Do you want to extend your selection?"), () => {
+                  zone = contiguousZone;
+                  result = env.model.dispatch("SORT_CELLS", {
+                      sheetId,
+                      col,
+                      row,
+                      zone,
+                      sortDirection,
+                  });
+              }, () => {
+                  result = env.model.dispatch("SORT_CELLS", {
+                      sheetId,
+                      col,
+                      row,
+                      zone,
+                      sortDirection,
+                  });
+              });
+          }
+      }
+      if (result.isCancelledBecause("InvalidSortZone" /* CommandResult.InvalidSortZone */)) {
+          const { col, row } = anchor;
+          env.model.selection.selectZone({ cell: { col, row }, zone });
+          env.raiseError(_t("Cannot sort. To sort, select only cells or only merges that have the same size."));
+      }
+  }
+
+  function sortMatrix(matrix, locale, ...criteria) {
+      for (const [i, value] of criteria.entries()) {
+          assert(() => value !== undefined, _t(`Value for parameter %d is missing, while the function [[FUNCTION_NAME]] expect a number or a range.`, i + 1));
+      }
+      const sortingOrders = [];
+      const sortColumns = [];
+      const nRows = matrix.length;
+      for (let i = 0; i < criteria.length; i += 2) {
+          sortingOrders.push(toBoolean(toScalar(criteria[i + 1])?.value) ? "ascending" : "descending");
+          const sortColumn = criteria[i];
+          if (isMatrix(sortColumn) && (sortColumn.length > 1 || sortColumn[0].length > 1)) {
+              assert(() => sortColumn.length === 1 && sortColumn[0].length === nRows, _t(`Wrong size for %s. Expected a range of size 1x%s. Got %sx%s.`, `sort_column{i + 1}`, nRows, sortColumn.length, sortColumn[0].length));
+              sortColumns.push(sortColumn.flat().map((c) => c.value));
+          }
+          else {
+              const colIndex = toNumber(toScalar(sortColumn)?.value, locale);
+              if (colIndex < 1 || colIndex > matrix[0].length) {
+                  return matrix;
+              }
+              sortColumns.push(matrix.map((row) => row[colIndex - 1].value));
+          }
+      }
+      if (sortColumns.length === 0) {
+          for (let i = 0; i < matrix[0].length; i++) {
+              sortColumns.push(matrix.map((row) => row[i].value));
+              sortingOrders.push("ascending");
+          }
+      }
+      const sortingCriteria = {
+          descending: cellsSortingCriterion("descending"),
+          ascending: cellsSortingCriterion("ascending"),
+      };
+      const indexes = range(0, matrix.length);
+      indexes.sort((a, b) => {
+          for (const [i, sortColumn] of sortColumns.entries()) {
+              const left = sortColumn[a];
+              const right = sortColumn[b];
+              const leftCell = {
+                  value: left,
+                  type: left === null
+                      ? CellValueType.empty
+                      : typeof left === "string"
+                          ? CellValueType.text
+                          : typeof left,
+              };
+              const rightCell = {
+                  value: right,
+                  type: right === null
+                      ? CellValueType.empty
+                      : typeof right === "string"
+                          ? CellValueType.text
+                          : typeof right,
+              };
+              const result = sortingCriteria[sortingOrders[i]](leftCell, rightCell);
+              if (result !== 0) {
+                  return result;
+              }
+          }
+          return 0;
+      });
+      return indexes.map((i) => matrix[i]);
+  }
   // -----------------------------------------------------------------------------
   // FILTER
   // -----------------------------------------------------------------------------
@@ -11806,6 +12038,93 @@
       isExported: true,
   };
   // -----------------------------------------------------------------------------
+  // SORT
+  // -----------------------------------------------------------------------------
+  const SORT = {
+      description: _t("Sorts the rows of a given array or range by the values in one or more columns."),
+      args: [
+          arg("range (range)", _t("The data to be sorted.")),
+          arg("sort_column (any, range<number>, repeating)", _t("The index of the column in range or a range outside of range containing the values by which to sort.")),
+          arg("is_ascending (boolean, repeating)", _t("TRUE or FALSE indicating whether to sort sort_column in ascending order. FALSE sorts in descending order.")),
+      ],
+      returns: ["RANGE"],
+      computeValueAndFormat: function (range, ...sortingCriteria) {
+          const _range = transposeMatrix(range);
+          return transposeMatrix(sortMatrix(_range, this.locale, ...sortingCriteria));
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
+  // SORTN
+  // -----------------------------------------------------------------------------
+  const SORTN = {
+      description: _t("Returns the first n items in a data set after performing a sort."),
+      args: [
+          arg("range (range)", _t("The data to be sorted.")),
+          arg("n (number, default=1)", _t("The number of items to return.")),
+          arg("display_ties_mode (number, default=0)", _t("A number representing the way to display ties.")),
+          arg("sort_column (number, range<number>, repeating)", _t("The index of the column in range or a range outside of range containing the values by which to sort.")),
+          arg("is_ascending (boolean, repeating)", _t("TRUE or FALSE indicating whether to sort sort_column in ascending order. FALSE sorts in descending order.")),
+      ],
+      returns: ["RANGE"],
+      computeValueAndFormat: function (range, n, displayTiesMode, ...sortingCriteria) {
+          const _n = toNumber(n?.value ?? 1, this.locale);
+          assert(() => _n >= 0, _t(`Wrong value of 'n'. Expected a positive number. Got %s.`, _n));
+          const _displayTiesMode = toNumber(displayTiesMode?.value ?? 0, this.locale);
+          assert(() => _displayTiesMode >= 0 && _displayTiesMode <= 3, _t(`Wrong value of 'display_ties_mode'. Expected a positive number between 0 and 3. Got %s.`, _displayTiesMode));
+          const sortedData = sortMatrix(transposeMatrix(range), this.locale, ...sortingCriteria);
+          const sameRows = (i, j) => JSON.stringify(sortedData[i].map((c) => c.value)) ===
+              JSON.stringify(sortedData[j].map((c) => c.value));
+          /*
+           * displayTiesMode determine how ties (equal values) are dealt with:
+           * 0 - ignore ties and show first n rows only
+           * 1 - show first n rows plus any additional ties with nth row
+           * 2 - show n rows but remove duplicates
+           * 3 - show first n unique rows and all duplicates of these rows
+           */
+          switch (_displayTiesMode) {
+              case 0:
+                  return transposeMatrix(sortedData.slice(0, _n));
+              case 1:
+                  for (let i = _n; i < sortedData.length; i++) {
+                      if (!sameRows(i, _n - 1)) {
+                          return transposeMatrix(sortedData.slice(0, i));
+                      }
+                  }
+                  return transposeMatrix(sortedData);
+              case 2: {
+                  const uniques = [sortedData[0]];
+                  for (let i = 1; i < sortedData.length; i++) {
+                      for (let j = 0; j < i; j++) {
+                          if (sameRows(i, j)) {
+                              break;
+                          }
+                          if (j === i - 1) {
+                              uniques.push(sortedData[i]);
+                          }
+                      }
+                  }
+                  return transposeMatrix(uniques.slice(0, _n));
+              }
+              case 3: {
+                  const uniques = [sortedData[0]];
+                  let counter = 1;
+                  for (let i = 1; i < sortedData.length; i++) {
+                      if (!sameRows(i, i - 1)) {
+                          counter++;
+                      }
+                      if (counter > _n) {
+                          break;
+                      }
+                      uniques.push(sortedData[i]);
+                  }
+                  return transposeMatrix(uniques);
+              }
+          }
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
   // UNIQUE
   // -----------------------------------------------------------------------------
   const UNIQUE = {
@@ -11853,6 +12172,8 @@
   var filter = /*#__PURE__*/Object.freeze({
     __proto__: null,
     FILTER: FILTER,
+    SORT: SORT,
+    SORTN: SORTN,
     UNIQUE: UNIQUE
   });
 
@@ -17088,7 +17409,7 @@
       wrongPasteSelection: _t("This operation is not allowed with multiple selections."),
       willRemoveExistingMerge: _t("This operation is not possible due to a merge. Please remove the merges first than try again."),
       wrongFigurePasteOption: _t("Cannot do a special paste of a figure."),
-      frozenPaneOverlap: _t("Cannot paste merged cells over a frozen pane."),
+      frozenPaneOverlap: _t("This operation is not allowed due to an overlapping frozen pane."),
   };
   function handlePasteResult(env, result) {
       if (!result.isSuccessful) {
@@ -18628,11 +18949,11 @@
       static template = "o-spreadsheet-ChartFigure";
       static components = {};
       onDoubleClick() {
-          this.env.model.dispatch("SELECT_FIGURE", { id: this.props.figureId });
+          this.env.model.dispatch("SELECT_FIGURE", { id: this.props.figure.id });
           this.env.openSidePanel("ChartPanel");
       }
       get chartType() {
-          return this.env.model.getters.getChartType(this.props.figureId);
+          return this.env.model.getters.getChartType(this.props.figure.id);
       }
       get chartComponent() {
           const type = this.chartType;
@@ -18644,7 +18965,7 @@
       }
   }
   ChartFigure.props = {
-      figureId: String,
+      figure: Object,
       onFigureDeleted: Function,
   };
 
@@ -18655,14 +18976,14 @@
       // Getters
       // ---------------------------------------------------------------------------
       get figureId() {
-          return this.props.figureId;
+          return this.props.figure.id;
       }
       get getImagePath() {
           return this.env.model.getters.getImagePath(this.figureId);
       }
   }
   ImageFigure.props = {
-      figureId: String,
+      figure: Object,
       onFigureDeleted: Function,
   };
 
@@ -20267,105 +20588,6 @@
       separator: true,
   });
 
-  const SORT_TYPES = [
-      CellValueType.number,
-      CellValueType.error,
-      CellValueType.text,
-      CellValueType.boolean,
-  ];
-  function sortCells(cells, sortDirection, emptyCellAsZero) {
-      const cellsWithIndex = cells.map((cell, index) => ({
-          index,
-          type: cell.type,
-          value: cell.value,
-      }));
-      let emptyCells = cellsWithIndex.filter((x) => x.type === CellValueType.empty);
-      let nonEmptyCells = cellsWithIndex.filter((x) => x.type !== CellValueType.empty);
-      if (emptyCellAsZero) {
-          nonEmptyCells.push(...emptyCells.map((emptyCell) => ({ ...emptyCell, type: CellValueType.number, value: 0 })));
-          emptyCells = [];
-      }
-      const inverse = sortDirection === "descending" ? -1 : 1;
-      return nonEmptyCells
-          .sort((left, right) => {
-          let typeOrder = SORT_TYPES.indexOf(left.type) - SORT_TYPES.indexOf(right.type);
-          if (typeOrder === 0) {
-              if (left.type === CellValueType.text || left.type === CellValueType.error) {
-                  typeOrder = left.value.localeCompare(right.value);
-              }
-              else
-                  typeOrder = left.value - right.value;
-          }
-          return inverse * typeOrder;
-      })
-          .concat(emptyCells);
-  }
-  function interactiveSortSelection(env, sheetId, anchor, zone, sortDirection) {
-      let result = DispatchResult.Success;
-      //several columns => bypass the contiguity check
-      let multiColumns = zone.right > zone.left;
-      if (env.model.getters.doesIntersectMerge(sheetId, zone)) {
-          multiColumns = false;
-          let table;
-          for (let row = zone.top; row <= zone.bottom; row++) {
-              table = [];
-              for (let col = zone.left; col <= zone.right; col++) {
-                  let merge = env.model.getters.getMerge({ sheetId, col, row });
-                  if (merge && !table.includes(merge.id.toString())) {
-                      table.push(merge.id.toString());
-                  }
-              }
-              if (table.length >= 2) {
-                  multiColumns = true;
-                  break;
-              }
-          }
-      }
-      const { col, row } = anchor;
-      if (multiColumns) {
-          result = env.model.dispatch("SORT_CELLS", { sheetId, col, row, zone, sortDirection });
-      }
-      else {
-          // check contiguity
-          const contiguousZone = env.model.getters.getContiguousZone(sheetId, zone);
-          if (isEqual(contiguousZone, zone)) {
-              // merge as it is
-              result = env.model.dispatch("SORT_CELLS", {
-                  sheetId,
-                  col,
-                  row,
-                  zone,
-                  sortDirection,
-              });
-          }
-          else {
-              env.askConfirmation(_t("We found data next to your selection. Since this data was not selected, it will not be sorted. Do you want to extend your selection?"), () => {
-                  zone = contiguousZone;
-                  result = env.model.dispatch("SORT_CELLS", {
-                      sheetId,
-                      col,
-                      row,
-                      zone,
-                      sortDirection,
-                  });
-              }, () => {
-                  result = env.model.dispatch("SORT_CELLS", {
-                      sheetId,
-                      col,
-                      row,
-                      zone,
-                      sortDirection,
-                  });
-              });
-          }
-      }
-      if (result.isCancelledBecause("InvalidSortZone" /* CommandResult.InvalidSortZone */)) {
-          const { col, row } = anchor;
-          env.model.selection.selectZone({ cell: { col, row }, zone });
-          env.raiseError(_t("Cannot sort. To sort, select only cells or only merges that have the same size."));
-      }
-  }
-
   const AddFilterInteractiveContent = {
       filterOverlap: _t("You cannot create overlapping filters."),
       nonContinuousTargets: _t("A filter can only be created on a continuous selection."),
@@ -26548,7 +26770,6 @@
     border-top-right-radius: 4px;
     font-size: ${DEFAULT_FONT_SIZE};
     color: white;
-    opacity: 0;
     pointer-events: none;
   }
 `;
@@ -26568,7 +26789,6 @@
               left: `${x - 1}px`,
               border: `1px solid ${color}`,
               "background-color": color,
-              opacity: this.props.active ? "opacity:1 !important" : undefined,
           });
       }
   }
@@ -30114,6 +30334,8 @@
               const position = this.env.model.getters.getActivePosition();
               this.env.model.selection.selectZone({ cell: position, zone: newZone });
           },
+          "CTRL+D": async () => this.env.model.dispatch("COPY_PASTE_CELLS_ABOVE"),
+          "CTRL+R": async () => this.env.model.dispatch("COPY_PASTE_CELLS_ON_LEFT"),
           "CTRL+SHIFT+E": () => this.setHorizontalAlign("center"),
           "CTRL+SHIFT+L": () => this.setHorizontalAlign("left"),
           "CTRL+SHIFT+R": () => this.setHorizontalAlign("right"),
@@ -40743,7 +40965,7 @@
                   return percentile(rangeValues, Number(threshold.value) / 100, true);
               case "formula":
                   const value = threshold.value && this.getters.evaluateFormula(sheetId, threshold.value);
-                  return !(value instanceof Promise) ? value : null;
+                  return typeof value === "number" ? value : null;
               default:
                   return null;
           }
@@ -40869,10 +41091,13 @@
               }
               const [value0, value1] = rule.values.map((val) => {
                   if (val.startsWith("=")) {
-                      return this.getters.evaluateFormula(target.sheetId, val);
+                      return this.getters.evaluateFormula(target.sheetId, val) ?? "";
                   }
                   return parseLiteral(val, DEFAULT_LOCALE);
               });
+              if (isMatrix(value0) || isMatrix(value1)) {
+                  return false;
+              }
               switch (rule.operator) {
                   case "IsEmpty":
                       return cell.value.toString().trim() === "";
@@ -41061,7 +41286,7 @@
                   const formula = compile(value);
                   const translatedFormula = this.getters.getTranslatedCellFormula(sheetId, offset.col, offset.row, formula, formula.dependencies.map((d) => this.getters.getRangeFromSheetXC(sheetId, d)));
                   const evaluated = this.getters.evaluateFormula(sheetId, translatedFormula);
-                  return evaluated ? evaluated.toString() : "";
+                  return evaluated && !isMatrix(evaluated) ? evaluated.toString() : "";
               }
               catch (e) {
                   return e instanceof EvaluationError ? e.errorType : CellErrorType.GenericError;
@@ -46516,6 +46741,20 @@
                   const state = new ClipboardOsState(cmd.text, this.getters, this.dispatch, this.selection);
                   return state.isPasteAllowed(cmd.target, { pasteOption: cmd.pasteOption });
               }
+              case "COPY_PASTE_CELLS_ABOVE": {
+                  const zones = this.getters.getSelectedZones();
+                  if (zones.length > 1 || (zones[0].top === 0 && zones[0].bottom === 0)) {
+                      return "InvalidCopyPasteSelection" /* CommandResult.InvalidCopyPasteSelection */;
+                  }
+                  break;
+              }
+              case "COPY_PASTE_CELLS_ON_LEFT": {
+                  const zones = this.getters.getSelectedZones();
+                  if (zones.length > 1 || (zones[0].left === 0 && zones[0].right === 0)) {
+                      return "InvalidCopyPasteSelection" /* CommandResult.InvalidCopyPasteSelection */;
+                  }
+                  break;
+              }
               case "INSERT_CELL": {
                   const { cut, paste } = this.getInsertCellsTargets(cmd.zone, cmd.shiftDimension);
                   const state = this.getClipboardStateForCopyCells(cut, "CUT");
@@ -46555,6 +46794,40 @@
                       this.status = "invisible";
                   }
                   break;
+              case "COPY_PASTE_CELLS_ABOVE":
+                  {
+                      const zone = this.getters.getSelectedZone();
+                      const multipleRowsInSelection = zone.top !== zone.bottom;
+                      const copyTarget = {
+                          ...zone,
+                          bottom: multipleRowsInSelection ? zone.top : zone.top - 1,
+                          top: multipleRowsInSelection ? zone.top : zone.top - 1,
+                      };
+                      const state = this.getClipboardStateForCopyCells([copyTarget], "COPY");
+                      state.paste([zone], {
+                          pasteOption: undefined,
+                          shouldPasteCF: true,
+                          selectTarget: true,
+                      });
+                  }
+                  break;
+              case "COPY_PASTE_CELLS_ON_LEFT":
+                  {
+                      const zone = this.getters.getSelectedZone();
+                      const multipleColsInSelection = zone.left !== zone.right;
+                      const copyTarget = {
+                          ...zone,
+                          right: multipleColsInSelection ? zone.left : zone.left - 1,
+                          left: multipleColsInSelection ? zone.left : zone.left - 1,
+                      };
+                      const state = this.getClipboardStateForCopyCells([copyTarget], "COPY");
+                      state.paste([zone], {
+                          pasteOption: undefined,
+                          shouldPasteCF: true,
+                          selectTarget: true,
+                      });
+                  }
+                  break;
               case "CLEAN_CLIPBOARD_HIGHLIGHT":
                   this.status = "invisible";
                   break;
@@ -47508,6 +47781,9 @@
               const cellValue = content.startsWith("=")
                   ? this.getters.evaluateFormula(this.sheetId, content)
                   : parseLiteral(content, this.getters.getLocale());
+              if (isMatrix(cellValue)) {
+                  return "Success" /* CommandResult.Success */;
+              }
               const validationResult = this.getters.getValidationResultForCellValue(cellValue, cellPosition);
               if (!validationResult.isValid && validationResult.rule.isBlocking) {
                   return "BlockingValidationRule" /* CommandResult.BlockingValidationRule */;
@@ -48094,11 +48370,19 @@
           }
       }
       getStatisticFnResults() {
-          // get deduplicated cells in zones
-          const cells = new Set(this.gridSelection.zones
-              .map((zone) => this.getters.getEvaluatedCellsInZone(this.getters.getActiveSheetId(), zone))
-              .flat()
-              .filter((cell) => cell.type !== CellValueType.empty));
+          const sheetId = this.getters.getActiveSheetId();
+          const cells = new Set();
+          for (const zone of this.gridSelection.zones) {
+              for (const { col, row } of positions(zone)) {
+                  if (this.getters.isRowHidden(sheetId, row) || this.getters.isColHidden(sheetId, col)) {
+                      continue; // Skip hidden cells
+                  }
+                  const evaluatedCell = this.getters.getEvaluatedCell({ sheetId, col, row });
+                  if (evaluatedCell.type !== CellValueType.empty) {
+                      cells.add(evaluatedCell);
+                  }
+              }
+          }
           let cellsTypes = new Set();
           let cellsValues = [];
           for (let cell of cells) {
@@ -50739,6 +51023,7 @@
   css /* scss */ `
   .o-border-selector {
     padding: 4px;
+    background-color: white;
   }
   .o-divider {
     border-right: 1px solid #e0e2e4;
@@ -55454,9 +55739,9 @@
   exports.tokenize = tokenize;
 
 
-  __info__.version = "16.5.0-alpha.11";
-  __info__.date = "2023-10-19T14:26:01.790Z";
-  __info__.hash = "4b42059";
+  __info__.version = "16.5.0-alpha.13";
+  __info__.date = "2023-10-25T10:04:45.428Z";
+  __info__.hash = "18a08b1";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);