@odoo/o-spreadsheet 16.5.0-alpha.12 → 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.12
- * @date 2023-10-20T15:12:28.296Z
- * @hash 430f090
+ * @version 16.5.0-alpha.13
+ * @date 2023-10-25T10:04:45.428Z
+ * @hash 18a08b1
  */
 
 (function (exports, owl) {
@@ -7584,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
@@ -10297,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
   // -----------------------------------------------------------------------------
@@ -10641,6 +10689,7 @@
     QUARTILE: QUARTILE,
     QUARTILE_EXC: QUARTILE_EXC,
     QUARTILE_INC: QUARTILE_INC,
+    RANK: RANK,
     RSQ: RSQ,
     SLOPE: SLOPE,
     SMALL: SMALL,
@@ -11787,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
   // -----------------------------------------------------------------------------
@@ -11823,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 = {
@@ -11870,6 +12172,8 @@
   var filter = /*#__PURE__*/Object.freeze({
     __proto__: null,
     FILTER: FILTER,
+    SORT: SORT,
+    SORTN: SORTN,
     UNIQUE: UNIQUE
   });
 
@@ -20284,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."),
@@ -26565,7 +26770,6 @@
     border-top-right-radius: 4px;
     font-size: ${DEFAULT_FONT_SIZE};
     color: white;
-    opacity: 0;
     pointer-events: none;
   }
 `;
@@ -26585,7 +26789,6 @@
               left: `${x - 1}px`,
               border: `1px solid ${color}`,
               "background-color": color,
-              opacity: this.props.active ? "opacity:1 !important" : undefined,
           });
       }
   }
@@ -40762,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;
           }
@@ -40888,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() === "";
@@ -41080,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;
@@ -47575,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 */;
@@ -50814,6 +51023,7 @@
   css /* scss */ `
   .o-border-selector {
     padding: 4px;
+    background-color: white;
   }
   .o-divider {
     border-right: 1px solid #e0e2e4;
@@ -55529,9 +55739,9 @@
   exports.tokenize = tokenize;
 
 
-  __info__.version = "16.5.0-alpha.12";
-  __info__.date = "2023-10-20T15:12:28.296Z";
-  __info__.hash = "430f090";
+  __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);