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

package/dist/o-spreadsheet.cjs.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
  */
 
 'use strict';
@@ -2060,6 +2060,7 @@ exports.CommandResult = void 0;
     CommandResult["InvalidDataValidationCriterionValue"] = "InvalidDataValidationCriterionValue";
     CommandResult["InvalidNumberOfCriterionValues"] = "InvalidNumberOfCriterionValues";
     CommandResult["BlockingValidationRule"] = "BlockingValidationRule";
+    CommandResult["InvalidCopyPasteSelection"] = "InvalidCopyPasteSelection";
 })(exports.CommandResult || (exports.CommandResult = {}));
 
 const DEFAULT_LOCALES = [
@@ -4661,7 +4662,7 @@ class ChartJsComponent extends owl.Component {
         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");
         }
@@ -4705,7 +4706,7 @@ class ChartJsComponent extends owl.Component {
     }
 }
 ChartJsComponent.props = {
-    figureId: String,
+    figure: Object,
 };
 
 /**
@@ -5107,6 +5108,8 @@ function checkBaseline(definition) {
         ? "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;
@@ -5227,10 +5230,24 @@ function drawScoreChart(structure, canvas) {
         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;
@@ -5353,25 +5370,29 @@ class ScorecardChartConfigBuilder {
                 },
             };
         }
-        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,
@@ -5408,13 +5429,7 @@ class ScorecardChartConfigBuilder {
         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;
@@ -5466,10 +5481,12 @@ class ScorecardChartConfigBuilder {
                 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 */
@@ -5506,7 +5523,7 @@ class BaselineElement extends ScorecardScalableElement {
         }
         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);
@@ -5543,7 +5560,7 @@ class ScorecardChart extends owl.Component {
     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), () => {
@@ -5559,7 +5576,7 @@ class ScorecardChart extends owl.Component {
     }
 }
 ScorecardChart.props = {
-    figureId: String,
+    figure: Object,
 };
 
 /**
@@ -7568,6 +7585,18 @@ function multiplyMatrices(matrix1, matrix2) {
     }
     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
@@ -10281,6 +10310,42 @@ const QUARTILE_INC = {
     },
     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
 // -----------------------------------------------------------------------------
@@ -10625,6 +10690,7 @@ var statistical = /*#__PURE__*/Object.freeze({
   QUARTILE: QUARTILE,
   QUARTILE_EXC: QUARTILE_EXC,
   QUARTILE_INC: QUARTILE_INC,
+  RANK: RANK,
   RSQ: RSQ,
   SLOPE: SLOPE,
   SMALL: SMALL,
@@ -11771,6 +11837,172 @@ var engineering = /*#__PURE__*/Object.freeze({
   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
 // -----------------------------------------------------------------------------
@@ -11807,6 +12039,93 @@ const FILTER = {
     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 = {
@@ -11854,6 +12173,8 @@ const UNIQUE = {
 var filter = /*#__PURE__*/Object.freeze({
   __proto__: null,
   FILTER: FILTER,
+  SORT: SORT,
+  SORTN: SORTN,
   UNIQUE: UNIQUE
 });
 
@@ -17089,7 +17410,7 @@ const PasteInteractiveContent = {
     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) {
@@ -18629,11 +18950,11 @@ class ChartFigure extends owl.Component {
     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;
@@ -18645,7 +18966,7 @@ class ChartFigure extends owl.Component {
     }
 }
 ChartFigure.props = {
-    figureId: String,
+    figure: Object,
     onFigureDeleted: Function,
 };
 
@@ -18656,14 +18977,14 @@ class ImageFigure extends owl.Component {
     // 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,
 };
 
@@ -20268,105 +20589,6 @@ cellMenuRegistry
     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."),
@@ -26549,7 +26771,6 @@ css /* scss */ `
     border-top-right-radius: 4px;
     font-size: ${DEFAULT_FONT_SIZE};
     color: white;
-    opacity: 0;
     pointer-events: none;
   }
 `;
@@ -26569,7 +26790,6 @@ class ClientTag extends owl.Component {
             left: `${x - 1}px`,
             border: `1px solid ${color}`,
             "background-color": color,
-            opacity: this.props.active ? "opacity:1 !important" : undefined,
         });
     }
 }
@@ -30115,6 +30335,8 @@ class Grid extends owl.Component {
             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"),
@@ -40744,7 +40966,7 @@ class EvaluationConditionalFormatPlugin extends UIPlugin {
                 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;
         }
@@ -40870,10 +41092,13 @@ class EvaluationConditionalFormatPlugin extends UIPlugin {
             }
             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() === "";
@@ -41062,7 +41287,7 @@ class EvaluationDataValidationPlugin extends UIPlugin {
                 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;
@@ -46517,6 +46742,20 @@ class ClipboardPlugin extends UIPlugin {
                 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");
@@ -46556,6 +46795,40 @@ class ClipboardPlugin extends UIPlugin {
                     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;
@@ -47509,6 +47782,9 @@ class EditionPlugin extends UIPlugin {
             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 */;
@@ -48095,11 +48371,19 @@ class GridSelectionPlugin extends UIPlugin {
         }
     }
     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) {
@@ -50740,6 +51024,7 @@ const BORDER_POSITIONS = [
 css /* scss */ `
   .o-border-selector {
     padding: 4px;
+    background-color: white;
   }
   .o-divider {
     border-right: 1px solid #e0e2e4;
@@ -55455,6 +55740,6 @@ exports.setTranslationMethod = setTranslationMethod;
 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";