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

package/dist/o-spreadsheet-engine.iife.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
  */
 
 (function (exports) {
@@ -3109,8 +3109,56 @@
       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."),
@@ -3136,6 +3184,30 @@
       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 = {
@@ -3281,20 +3353,7 @@
       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,
   };
@@ -3553,22 +3612,7 @@
       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,
   };
@@ -3628,6 +3672,8 @@
   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,
@@ -6083,6 +6129,47 @@
               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;
@@ -6113,7 +6200,6 @@
       "REDO",
       "ADD_MERGE",
       "REMOVE_MERGE",
-      "DUPLICATE_SHEET",
       "UPDATE_LOCALE",
       "ADD_PIVOT",
       "UPDATE_PIVOT",
@@ -9603,7 +9689,9 @@
       while (!chars.isOver()) {
           let token = tokenizeNewLine(chars) ||
               tokenizeSpace(chars) ||
+              tokenizeArrayRowSeparator(chars, locale) ||
               tokenizeArgsSeparator(chars, locale) ||
+              tokenizeBraces(chars) ||
               tokenizeParenthesis(chars) ||
               tokenizeOperator(chars) ||
               tokenizeString(chars) ||
@@ -9636,6 +9724,17 @@
       }
       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();
@@ -9644,6 +9743,20 @@
       }
       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)) {
@@ -9864,6 +9977,9 @@
           else if (token.type === "ARG_SEPARATOR") {
               localizedFormula += toLocale.formulaArgSeparator;
           }
+          else if (token.type === "ARRAY_ROW_SEPARATOR") {
+              localizedFormula += toLocale.formulaArgSeparator === ";" ? "\\" : ";";
+          }
           else {
               localizedFormula += token.value;
           }
@@ -11027,7 +11143,6 @@
   // -----------------------------------------------------------------------------
   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.")),
@@ -17227,6 +17342,8 @@
                   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)) {
@@ -17280,6 +17397,34 @@
       }
       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();
@@ -17370,6 +17515,13 @@
                   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;
@@ -17387,6 +17539,11 @@
                   ...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,
@@ -17545,6 +17702,23 @@
                       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();
@@ -25887,6 +26061,17 @@
       }
   }
 
+  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
@@ -26531,13 +26716,22 @@
           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);
+                              }
+                          }
                       }
                   }
               }
@@ -26800,18 +26994,22 @@
       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;
               }
           });
       }
@@ -29851,7 +30049,8 @@
                   }
                   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;
@@ -32184,10 +32383,17 @@
               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 });
                   }
               }
           }
@@ -33219,6 +33425,9 @@
                   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,
@@ -38950,6 +39159,10 @@
                   ? `(${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)})`
@@ -40514,7 +40727,6 @@
   pivotRegistry.add("SPREADSHEET", {
       ui: SpreadsheetPivot,
       definition: SpreadsheetPivotRuntimeDefinition,
-      externalData: false,
       dateGranularities: [...dateGranularities],
       datetimeGranularities: [...dateGranularities, "hour_number", "minute_number", "second_number"],
       isMeasureCandidate: (field) => field.type !== "boolean",
@@ -40556,9 +40768,7 @@
       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) {
@@ -40772,7 +40982,7 @@
           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 });
@@ -43843,6 +44053,15 @@
                       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 */;
@@ -43867,6 +44086,9 @@
               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;
@@ -44005,6 +44227,29 @@
           });
           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";
       }
@@ -45220,25 +45465,43 @@
           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;
@@ -45518,7 +45781,7 @@
       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.
@@ -47490,6 +47753,9 @@
               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",
@@ -47510,6 +47776,22 @@
               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
@@ -51024,8 +51306,8 @@
 
 
   __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";
 
 
 })(this.o_spreadsheet_engine = this.o_spreadsheet_engine || {});