@odoo/o-spreadsheet 19.1.0-alpha.13 → 19.1.0-alpha.14

package/dist/o-spreadsheet-engine.esm.js

@@ -3,8 +3,8 @@
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
  * @version 19.1.0-alpha.3
- * @date 2025-11-24T07:52:34.809Z
- * @hash e232982
+ * @date 2025-12-02T05:34:07.213Z
+ * @hash 04cf666
  */
 
 class FunctionCodeBuilder {
@@ -3106,8 +3106,56 @@ function isMultipleElementMatrix(arg) {
     return isMatrix(arg) && !isSingleElementMatrix(arg);
 }
 
+function stackHorizontally(ranges, options) {
+    const matrices = ranges.map(toMatrix);
+    const nbRowsArr = matrices.map((m) => m?.[0]?.length ?? 0);
+    const nbRows = Math.max(...nbRowsArr);
+    if (options?.requireSameRowCount) {
+        const firstLength = nbRowsArr[0];
+        if (nbRowsArr.some((len) => len !== firstLength)) {
+            return new EvaluationError(_t("All ranges in [[FUNCTION_NAME]] must have the same number of columns (got %s).", nbRowsArr.join(", ")));
+        }
+    }
+    const result = [];
+    for (const matrix of matrices) {
+        for (let col = 0; col < matrix.length; col++) {
+            // Fill with nulls if needed
+            const array = Array(nbRows).fill({ value: null });
+            for (let row = 0; row < matrix[col].length; row++) {
+                array[row] = matrix[col][row];
+            }
+            result.push(array);
+        }
+    }
+    return result;
+}
+function stackVertically(ranges, options) {
+    const matrices = ranges.map(toMatrix);
+    const nbColsArr = matrices.map((m) => m?.length ?? 0);
+    const nbCols = Math.max(...nbColsArr);
+    if (options?.requireSameColCount) {
+        const firstLength = nbColsArr[0];
+        if (nbColsArr.some((len) => len !== firstLength)) {
+            return new EvaluationError(_t("All ranges in [[FUNCTION_NAME]] must have the same number of columns (got %s).", nbColsArr.join(", ")));
+        }
+    }
+    const nbRows = matrices.reduce((acc, m) => acc + (m?.[0]?.length ?? 0), 0);
+    const result = generateMatrix(nbCols, nbRows, () => ({
+        value: null,
+    }));
+    let currentRow = 0;
+    for (const matrix of matrices) {
+        for (let col = 0; col < matrix.length; col++) {
+            for (let row = 0; row < matrix[col].length; row++) {
+                result[col][currentRow + row] = matrix[col][row];
+            }
+        }
+        currentRow += matrix[0]?.length ?? 0;
+    }
+    return result;
+}
 // -----------------------------------------------------------------------------
-// ARRAY_CONSTRAIN
+// ARRAY.CONSTRAIN
 // -----------------------------------------------------------------------------
 const ARRAY_CONSTRAIN = {
     description: _t("Returns a result array constrained to a specific width and height."),
@@ -3133,6 +3181,30 @@ const ARRAY_CONSTRAIN = {
     isExported: false,
 };
 // -----------------------------------------------------------------------------
+// ARRAY.LITERAL
+// -----------------------------------------------------------------------------
+const ARRAY_LITERAL = {
+    description: _t("Appends ranges vertically and in sequence to return a larger array. All ranges must have the same number of columns."),
+    args: [arg("range (any, range<any>, repeating)", _t("The range to be appended."))],
+    compute: function (...ranges) {
+        return stackVertically(ranges, { requireSameColCount: true });
+    },
+    isExported: false,
+    hidden: true,
+};
+// -----------------------------------------------------------------------------
+// ARRAY.ROW
+// -----------------------------------------------------------------------------
+const ARRAY_ROW = {
+    description: _t("Appends ranges horizontally and in sequence to return a larger array. All ranges must have the same number of rows."),
+    args: [arg("range (any, range<any>, repeating)", _t("The range to be appended."))],
+    compute: function (...ranges) {
+        return stackHorizontally(ranges, { requireSameRowCount: true });
+    },
+    isExported: false,
+    hidden: true,
+};
+// -----------------------------------------------------------------------------
 // CHOOSECOLS
 // -----------------------------------------------------------------------------
 const CHOOSECOLS = {
@@ -3278,20 +3350,7 @@ const HSTACK = {
     description: _t("Appends ranges horizontally and in sequence to return a larger array."),
     args: [arg("range (any, range<any>, repeating)", _t("The range to be appended."))],
     compute: function (...ranges) {
-        const nbRows = Math.max(...ranges.map((r) => r?.[0]?.length ?? 0));
-        const result = [];
-        for (const range of ranges) {
-            const _range = toMatrix(range);
-            for (let col = 0; col < _range.length; col++) {
-                //TODO: fill with #N/A for unavailable values instead of zeroes
-                const array = Array(nbRows).fill({ value: null });
-                for (let row = 0; row < _range[col].length; row++) {
-                    array[row] = _range[col][row];
-                }
-                result.push(array);
-            }
-        }
-        return result;
+        return stackHorizontally(ranges);
     },
     isExported: true,
 };
@@ -3550,22 +3609,7 @@ const VSTACK = {
     description: _t("Appends ranges vertically and in sequence to return a larger array."),
     args: [arg("range (any, range<any>, repeating)", _t("The range to be appended."))],
     compute: function (...ranges) {
-        const nbColumns = Math.max(...ranges.map((range) => toMatrix(range).length));
-        const nbRows = ranges.reduce((acc, range) => acc + toMatrix(range)[0].length, 0);
-        const result = Array(nbColumns)
-            .fill([])
-            .map(() => Array(nbRows).fill({ value: 0 })); // TODO fill with #N/A
-        let currentRow = 0;
-        for (const range of ranges) {
-            const _array = toMatrix(range);
-            for (let col = 0; col < _array.length; col++) {
-                for (let row = 0; row < _array[col].length; row++) {
-                    result[col][currentRow + row] = _array[col][row];
-                }
-            }
-            currentRow += _array[0].length;
-        }
-        return result;
+        return stackVertically(ranges);
     },
     isExported: true,
 };
@@ -3625,6 +3669,8 @@ const WRAPROWS = {
 var array = /*#__PURE__*/Object.freeze({
   __proto__: null,
   ARRAY_CONSTRAIN: ARRAY_CONSTRAIN,
+  ARRAY_LITERAL: ARRAY_LITERAL,
+  ARRAY_ROW: ARRAY_ROW,
   CHOOSECOLS: CHOOSECOLS,
   CHOOSEROWS: CHOOSEROWS,
   EXPAND: EXPAND,
@@ -6080,6 +6126,47 @@ function splitIfAdjacent(zone, zoneToRemove) {
             return newZones;
     }
 }
+/**
+ * Splits zone z2 by removing the overlapping zone z1 (fully inside z2).
+ * Returns the remaining parts of z2 that don't overlap with z1.
+ *
+ * Diagram:
+ * ┌──────────── z2 ─────────────┐
+ * │              1              │
+ * │--------─────────────--------│
+ * │  2    |     z1      |    3  │
+ * │--------─────────────--------│
+ * │              4              │
+ * └─────────────────────────────┘
+ *
+ * Input:
+ *   z1 = { top: 2, bottom: 3, left: 2, right: 3 }
+ *   z2 = { top: 1, bottom: 4, left: 1, right: 4 }
+ *
+ * Output:
+ * [
+ *   { top: 4, bottom: 4, left: 1, right: 4 },  // bottom
+ *   { top: 2, bottom: 3, left: 4, right: 4 },  // right
+ *   { top: 2, bottom: 3, left: 1, right: 1 },  // left
+ *   { top: 1, bottom: 1, left: 1, right: 4 }   // top
+ * ]
+ */
+function splitZone(z1, z2) {
+    const zones = [];
+    if (z1.bottom < z2.bottom) {
+        zones.push({ ...z2, top: z1.bottom + 1 });
+    }
+    if (z1.right < z2.right) {
+        zones.push({ ...z2, left: z1.right + 1, top: z1.top, bottom: z1.bottom });
+    }
+    if (z1.left > z2.left) {
+        zones.push({ ...z2, right: z1.left - 1, top: z1.top, bottom: z1.bottom });
+    }
+    if (z1.top > z2.top) {
+        zones.push({ ...z2, bottom: z1.top - 1 });
+    }
+    return zones;
+}
 
 function isSheetDependent(cmd) {
     return "sheetId" in cmd;
@@ -6110,7 +6197,6 @@ const invalidateEvaluationCommands = new Set([
     "REDO",
     "ADD_MERGE",
     "REMOVE_MERGE",
-    "DUPLICATE_SHEET",
     "UPDATE_LOCALE",
     "ADD_PIVOT",
     "UPDATE_PIVOT",
@@ -9600,7 +9686,9 @@ function tokenize(str, locale = DEFAULT_LOCALE) {
     while (!chars.isOver()) {
         let token = tokenizeNewLine(chars) ||
             tokenizeSpace(chars) ||
+            tokenizeArrayRowSeparator(chars, locale) ||
             tokenizeArgsSeparator(chars, locale) ||
+            tokenizeBraces(chars) ||
             tokenizeParenthesis(chars) ||
             tokenizeOperator(chars) ||
             tokenizeString(chars) ||
@@ -9633,6 +9721,17 @@ function tokenizeParenthesis(chars) {
     }
     return null;
 }
+const braces = {
+    "{": { type: "LEFT_BRACE", value: "{" },
+    "}": { type: "RIGHT_BRACE", value: "}" },
+};
+function tokenizeBraces(chars) {
+    if (chars.current === "{" || chars.current === "}") {
+        const value = chars.shift();
+        return braces[value];
+    }
+    return null;
+}
 function tokenizeArgsSeparator(chars, locale) {
     if (chars.current === locale.formulaArgSeparator) {
         const value = chars.shift();
@@ -9641,6 +9740,20 @@ function tokenizeArgsSeparator(chars, locale) {
     }
     return null;
 }
+function tokenizeArrayRowSeparator(chars, locale) {
+    // The array row separator is used in array literals to separate rows.
+    // It is not explicitly defined in locales, but depends on the formulaArgSeparator.
+    // Example: {1,2,3;4,5,6} — here, ';' separates rows and ',' separates columns.
+    const rowSeparator = locale.formulaArgSeparator === ";" ? "\\" : ";";
+    if (!rowSeparator) {
+        return null;
+    }
+    if (chars.current === rowSeparator) {
+        chars.shift();
+        return { type: "ARRAY_ROW_SEPARATOR", value: rowSeparator };
+    }
+    return null;
+}
 function tokenizeOperator(chars) {
     for (const op of OPERATORS) {
         if (chars.currentStartsWith(op)) {
@@ -9861,6 +9974,9 @@ function _localizeFormula(formula, fromLocale, toLocale) {
         else if (token.type === "ARG_SEPARATOR") {
             localizedFormula += toLocale.formulaArgSeparator;
         }
+        else if (token.type === "ARRAY_ROW_SEPARATOR") {
+            localizedFormula += toLocale.formulaArgSeparator === ";" ? "\\" : ";";
+        }
         else {
             localizedFormula += token.value;
         }
@@ -11024,7 +11140,6 @@ function sortMatrix(matrix, locale, ...criteria) {
 // -----------------------------------------------------------------------------
 const FILTER = {
     description: _t("Returns a filtered version of the source range, returning only rows or columns that meet the specified conditions."),
-    // TODO modify args description when vectorization on formulas is available
     args: [
         arg("range (any, range<any>)", _t("The data to be filtered.")),
         arg("condition (boolean, range<boolean>, repeating)", _t("Column or row containing true or false values corresponding to the range.")),
@@ -17224,6 +17339,8 @@ function parseOperand(tokens) {
                 tokenStartIndex: current.tokenIndex,
                 tokenEndIndex: rightParen.tokenIndex,
             };
+        case "LEFT_BRACE":
+            return parseArrayLiteral(tokens, current);
         case "OPERATOR":
             const operator = current.value;
             if (UNARY_OPERATORS_PREFIX.includes(operator)) {
@@ -17277,6 +17394,34 @@ function consumeOrThrow(tokens, type, message) {
     }
     return token;
 }
+function parseArrayLiteral(tokens, leftBrace) {
+    const rows = [];
+    let currentRow = [parseExpression(tokens)]; // there must be at least one element
+    while (tokens.current?.type !== "RIGHT_BRACE") {
+        const nextToken = tokens.shift();
+        if (!nextToken) {
+            throw new BadExpressionError(_t("Missing closing brace"));
+        }
+        else if (nextToken.type === "ARG_SEPARATOR") {
+            currentRow.push(parseExpression(tokens));
+        }
+        else if (nextToken.type === "ARRAY_ROW_SEPARATOR") {
+            rows.push(currentRow);
+            currentRow = [parseExpression(tokens)];
+        }
+        else {
+            throw new BadExpressionError(_t("Unexpected token: %s", nextToken.value));
+        }
+    }
+    const rightBrace = consumeOrThrow(tokens, "RIGHT_BRACE", _t("Missing closing brace"));
+    rows.push(currentRow);
+    return {
+        type: "ARRAY",
+        value: rows,
+        tokenStartIndex: leftBrace.tokenIndex,
+        tokenEndIndex: rightBrace.tokenIndex,
+    };
+}
 function parseExpression(tokens, parent_priority = 0) {
     if (tokens.length === 0) {
         throw new BadExpressionError();
@@ -17367,6 +17512,13 @@ function* astIterator(ast) {
                 yield* astIterator(arg);
             }
             break;
+        case "ARRAY":
+            for (const row of ast.value) {
+                for (const cell of row) {
+                    yield* astIterator(cell);
+                }
+            }
+            break;
         case "UNARY_OPERATION":
             yield* astIterator(ast.operand);
             break;
@@ -17384,6 +17536,11 @@ function mapAst(ast, fn) {
                 ...ast,
                 args: ast.args.map((child) => mapAst(child, fn)),
             };
+        case "ARRAY":
+            return {
+                ...ast,
+                value: ast.value.map((row) => row.map((cell) => mapAst(cell, fn))),
+            };
         case "UNARY_OPERATION":
             return {
                 ...ast,
@@ -17542,6 +17699,23 @@ function compileTokensOrThrow(tokens) {
                     code.append(...args);
                     const fnName = ast.value.toUpperCase();
                     return code.return(`ctx['${fnName}'](${args.map((arg) => arg.returnExpression)})`);
+                case "ARRAY": {
+                    // a literal array is compiled into function calls
+                    const arrayFunctionCall = {
+                        type: "FUNCALL",
+                        value: "ARRAY.LITERAL",
+                        args: ast.value.map((row) => ({
+                            type: "FUNCALL",
+                            value: "ARRAY.ROW",
+                            args: row,
+                            tokenStartIndex: 0,
+                            tokenEndIndex: 0,
+                        })),
+                        tokenStartIndex: 0,
+                        tokenEndIndex: 0,
+                    };
+                    return compileAST(arrayFunctionCall);
+                }
                 case "UNARY_OPERATION": {
                     const fnName = UNARY_OPERATOR_MAP[ast.value];
                     const operand = compileAST(ast.operand, false, false).assignResultToVariable();
@@ -25884,6 +26058,17 @@ class XlsxReader {
     }
 }
 
+function schemeToColorScale(scheme) {
+    const colors = COLORSCHEMES[scheme];
+    return colors === undefined
+        ? undefined
+        : {
+            minColor: colors[0],
+            midColor: colors.length === 3 ? colors[1] : undefined,
+            maxColor: colors[colors.length - 1],
+        };
+}
+
 /**
  * parses a formula (as a string) into the same formula,
  * but with the references to other cells extracted
@@ -26528,13 +26713,22 @@ migrationStepRegistry
         return data;
     },
 })
-    .add("19.2", {
+    .add("19.1.0", {
     migrate(data) {
         for (const sheet of data.sheets || []) {
             for (const figure of sheet.figures || []) {
                 if (figure.tag === "chart" && figure.data.type === "geo") {
                     if ("colorScale" in figure.data && typeof figure.data.colorScale === "string") {
-                        figure.data.colorScale = COLORSCHEMES[figure.data.colorScale];
+                        figure.data.colorScale = schemeToColorScale(figure.data.colorScale);
+                    }
+                }
+                if (figure.tag === "carousel") {
+                    for (const definition of Object.values(figure.data.chartDefinitions) || []) {
+                        if (definition.type === "geo") {
+                            if ("colorScale" in definition && typeof definition.colorScale === "string") {
+                                definition.colorScale = schemeToColorScale(definition.colorScale);
+                            }
+                        }
                     }
                 }
             }
@@ -26797,18 +26991,22 @@ function dropCommands(initialMessages, commandType) {
     return messages;
 }
 function fixChartDefinitions(data, initialMessages) {
+    /**
+     * Revisions created after version 18.5.1 contain the full chart definition in the command
+     * if the data was alreay updated to 18.5.1, then those older revision cannot (by definition) be reaplied
+     * and should not be replayed.
+     * FIXME: every command should be versionned when upgraded to allow finer tuning.
+     */
+    if (!data.version || compareVersions(String(data.version), "18.5.1") >= 0) {
+        return initialMessages;
+    }
     const messages = [];
     const map = {};
     for (const sheet of data.sheets || []) {
         sheet.figures?.forEach((figure) => {
             if (figure.tag === "chart") {
                 // chart definition
-                if (data.version && compareVersions(String(data.version), "18.5.1") <= 0) {
-                    map[figure.data.chartId] = figure.data;
-                }
-                else {
-                    map[figure.id] = figure.data;
-                }
+                map[figure.id] = figure.data;
             }
         });
     }
@@ -29848,7 +30046,8 @@ class FigurePlugin extends CorePlugin {
                 }
                 break;
             case "DUPLICATE_SHEET": {
-                for (const figureId in this.figures[cmd.sheetId]) {
+                for (const figure of this.getFigures(cmd.sheetId)) {
+                    const figureId = figure.id;
                     const fig = this.figures[cmd.sheetId]?.[figureId];
                     if (!fig) {
                         continue;
@@ -32181,10 +32380,17 @@ class PivotCorePlugin extends CorePlugin {
             if (!pivot) {
                 continue;
             }
-            for (const measure of pivot.definition.measures) {
+            const def = deepCopy(pivot.definition);
+            for (const measure of def.measures) {
                 if (measure.computedBy?.formula === formulaString) {
-                    const measureIndex = pivot.definition.measures.indexOf(measure);
-                    this.history.update("pivots", pivotId, "definition", "measures", measureIndex, "computedBy", { formula: newFormulaString, sheetId });
+                    const measureIndex = def.measures.indexOf(measure);
+                    if (measureIndex !== -1) {
+                        def.measures[measureIndex].computedBy = {
+                            formula: newFormulaString,
+                            sheetId,
+                        };
+                    }
+                    this.dispatch("UPDATE_PIVOT", { pivotId, pivot: def });
                 }
             }
         }
@@ -33216,6 +33422,9 @@ class SpreadsheetPivotCorePlugin extends CorePlugin {
                 const { sheetId, zone } = definition.dataSet;
                 const range = this.getters.getRangeFromZone(sheetId, zone);
                 const adaptedRange = adaptPivotRange(range, applyChange);
+                if (adaptedRange === range) {
+                    return;
+                }
                 const dataSet = adaptedRange && {
                     sheetId: adaptedRange.sheetId,
                     zone: adaptedRange.zone,
@@ -38947,6 +39156,10 @@ function astToFormula(ast) {
                 ? `(${astToFormula(ast.operand)})`
                 : astToFormula(ast.operand);
             return ast.value + rightOperand;
+        case "ARRAY":
+            return ("{" +
+                ast.value.map((row) => row.map((cell) => astToFormula(cell)).join(",")).join(";") +
+                "}");
         case "BIN_OPERATION":
             const leftOperation = leftOperandNeedsParenthesis(ast)
                 ? `(${astToFormula(ast.left)})`
@@ -40511,7 +40724,6 @@ const dateGranularities = [
 pivotRegistry.add("SPREADSHEET", {
     ui: SpreadsheetPivot,
     definition: SpreadsheetPivotRuntimeDefinition,
-    externalData: false,
     dateGranularities: [...dateGranularities],
     datetimeGranularities: [...dateGranularities, "hour_number", "minute_number", "second_number"],
     isMeasureCandidate: (field) => field.type !== "boolean",
@@ -40553,9 +40765,7 @@ class PivotUIPlugin extends CoreViewPlugin {
     handle(cmd) {
         if (invalidateEvaluationCommands.has(cmd.type)) {
             for (const pivotId of this.getters.getPivotIds()) {
-                if (!pivotRegistry.get(this.getters.getPivotCoreDefinition(pivotId).type).externalData) {
-                    this.setupPivot(pivotId, { recreate: true });
-                }
+                this.setupPivot(pivotId, { recreate: true });
             }
         }
         switch (cmd.type) {
@@ -40769,7 +40979,7 @@ class PivotUIPlugin extends CoreViewPlugin {
         pivot.init({ reload: true });
     }
     setupPivot(pivotId, { recreate } = { recreate: false }) {
-        const definition = this.getters.getPivotCoreDefinition(pivotId);
+        const definition = deepCopy(this.getters.getPivotCoreDefinition(pivotId));
         if (!(pivotId in this.pivots)) {
             const Pivot = withPivotPresentationLayer(pivotRegistry.get(definition.type).ui);
             this.pivots[pivotId] = new Pivot(this.custom, { definition, getters: this.getters });
@@ -43840,6 +44050,15 @@ class CarouselUIPlugin extends UIPlugin {
                     return "InvalidFigureId" /* CommandResult.InvalidFigureId */;
                 }
                 return "Success" /* CommandResult.Success */;
+            case "DUPLICATE_CAROUSEL_CHART":
+                if (!this.getters.doesCarouselExist(cmd.carouselId) ||
+                    !this.getters
+                        .getCarousel(cmd.carouselId)
+                        .items.some((item) => item.type === "chart" && item.chartId === cmd.chartId) ||
+                    this.getters.getChart(cmd.duplicatedChartId)) {
+                    return "InvalidFigureId" /* CommandResult.InvalidFigureId */;
+                }
+                return "Success" /* CommandResult.Success */;
             case "ADD_NEW_CHART_TO_CAROUSEL":
                 if (!this.getters.doesCarouselExist(cmd.figureId)) {
                     return "InvalidFigureId" /* CommandResult.InvalidFigureId */;
@@ -43864,6 +44083,9 @@ class CarouselUIPlugin extends UIPlugin {
             case "ADD_FIGURE_CHART_TO_CAROUSEL":
                 this.addFigureChartToCarousel(cmd.carouselFigureId, cmd.chartFigureId, cmd.sheetId);
                 break;
+            case "DUPLICATE_CAROUSEL_CHART":
+                this.duplicateCarouselChart(cmd);
+                break;
             case "UPDATE_CAROUSEL_ACTIVE_ITEM":
                 this.carouselStates[cmd.figureId] = this.getCarouselItemId(cmd.item);
                 break;
@@ -44002,6 +44224,29 @@ class CarouselUIPlugin extends UIPlugin {
         });
         this.dispatch("DELETE_FIGURE", { sheetId, figureId: chartFigureId });
     }
+    duplicateCarouselChart({ carouselId, chartId, sheetId, duplicatedChartId, }) {
+        const chart = this.getters.getChart(chartId);
+        if (!chart) {
+            return;
+        }
+        const carousel = this.getters.getCarousel(carouselId);
+        const duplicatedItemIndex = carousel.items.findIndex((item) => item.type === "chart" && item.chartId === chartId);
+        if (duplicatedItemIndex === -1) {
+            return;
+        }
+        this.dispatch("CREATE_CHART", {
+            chartId: duplicatedChartId,
+            figureId: carouselId,
+            sheetId,
+            definition: chart.getDefinition(),
+        });
+        const carouselItems = insertItemsAtIndex(carousel.items, [{ type: "chart", chartId: duplicatedChartId }], duplicatedItemIndex + 1);
+        this.dispatch("UPDATE_CAROUSEL", {
+            sheetId,
+            figureId: carouselId,
+            definition: { ...carousel, items: carouselItems },
+        });
+    }
     getCarouselItemId(item) {
         return item.type === "chart" ? item.chartId : "carouselDataView";
     }
@@ -45217,25 +45462,43 @@ class GridSelectionPlugin extends UIPlugin {
         return "Success" /* CommandResult.Success */;
     }
     handleEvent(event) {
-        const anchor = event.anchor;
-        let zones = [];
+        let anchor = event.anchor;
+        let zones = [...this.gridSelection.zones];
         this.isUnbounded = event.options?.unbounded || false;
         switch (event.mode) {
             case "overrideSelection":
                 zones = [anchor.zone];
                 break;
             case "updateAnchor":
-                zones = [...this.gridSelection.zones];
                 const index = zones.findIndex((z) => isEqual(z, event.previousAnchor.zone));
                 if (index >= 0) {
                     zones[index] = anchor.zone;
                 }
                 break;
             case "newAnchor":
-                zones = [...this.gridSelection.zones, anchor.zone];
+                zones.push(anchor.zone);
+                break;
+            case "commitSelection":
+                const zoneToSplit = zones.find((zone) => isZoneInside(anchor.zone, zone) && !isEqual(anchor.zone, zone));
+                const removeFullAnchor = zones.filter((zone) => isEqual(anchor.zone, zone)).length > 1;
+                if (removeFullAnchor && zones.length > 2) {
+                    zones = zones.filter((zone) => !isEqual(zone, anchor.zone));
+                }
+                else if (zoneToSplit) {
+                    const splittedZones = splitZone(anchor.zone, zoneToSplit);
+                    zones = zones
+                        .filter((z) => !isEqual(z, anchor.zone) && !isEqual(z, zoneToSplit))
+                        .concat(splittedZones);
+                }
+                zones = uniqueZones(zones);
+                const lastZone = zones[zones.length - 1];
+                anchor = {
+                    cell: { col: lastZone.left, row: lastZone.top },
+                    zone: lastZone,
+                };
                 break;
         }
-        this.setSelectionMixin(event.anchor, zones);
+        this.setSelectionMixin(anchor, zones);
         /** Any change to the selection has to be reflected in the selection processor. */
         this.selection.resetDefaultAnchor(this, deepCopy(this.gridSelection.anchor));
         const { col, row } = this.gridSelection.anchor.cell;
@@ -45515,7 +45778,7 @@ class GridSelectionPlugin extends UIPlugin {
     setSelectionMixin(anchor, zones) {
         const { anchor: clippedAnchor, zones: clippedZones } = this.clipSelection(this.getters.getActiveSheetId(), { anchor, zones });
         this.gridSelection.anchor = clippedAnchor;
-        this.gridSelection.zones = uniqueZones(clippedZones);
+        this.gridSelection.zones = clippedZones;
     }
     /**
      * Change the anchor of the selection active cell to an absolute col and row index.
@@ -47487,6 +47750,9 @@ class SelectionStreamProcessorImpl {
             bottom: Math.max(anchorRow, row),
         };
         const expandedZone = this.getters.expandZone(sheetId, zone);
+        if (isEqual(this.anchor.zone, expandedZone)) {
+            return new DispatchResult("NoChanges" /* CommandResult.NoChanges */);
+        }
         const anchor = { zone: expandedZone, cell: { col: anchorCol, row: anchorRow } };
         return this.processEvent({
             mode: "updateAnchor",
@@ -47507,6 +47773,22 @@ class SelectionStreamProcessorImpl {
             mode: "newAnchor",
         });
     }
+    /**
+     * Triggered on mouse up to finalize the selection.
+     * - If the current anchor zone already exists in the selection, it will be removed.
+     * - If the anchor zone overlaps with existing zones, it will be split into
+     *   multiple non-overlapping parts.
+     */
+    commitSelection() {
+        return this.processEvent({
+            options: {
+                scrollIntoView: false,
+                unbounded: true,
+            },
+            anchor: this.anchor,
+            mode: "commitSelection",
+        });
+    }
     /**
      * Increase or decrease the size of the current anchor zone.
      * The anchor cell remains where it is. It's the opposite side
@@ -50913,5 +51195,5 @@ export { BadExpressionError, BasePlugin, CellErrorType, CircularDependencyError,
 
 
 __info__.version = "19.1.0-alpha.3";
-__info__.date = "2025-11-24T07:52:34.809Z";
-__info__.hash = "e232982";
+__info__.date = "2025-12-02T05:34:07.213Z";
+__info__.hash = "04cf666";