@odoo/o-spreadsheet 18.5.0-alpha.0 → 18.5.0-alpha.2

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 18.5.0-alpha.0
- * @date 2025-06-24T12:26:38.163Z
- * @hash ed0f325
+ * @version 18.5.0-alpha.2
+ * @date 2025-07-11T11:13:53.317Z
+ * @hash 6d42178
  */
 
 (function (exports, owl) {
@@ -853,6 +853,7 @@
   ];
   const specialWhiteSpaceRegexp = new RegExp(specialWhiteSpaceSpecialCharacters.join("|"), "g");
   const newLineRegexp = /(\r\n|\r)/g;
+  const whiteSpaceCharacters = specialWhiteSpaceSpecialCharacters.concat([" "]);
   /**
    * Replace all different newlines characters by \n
    */
@@ -1989,8 +1990,9 @@
   const DATE_JS_1900_OFFSET = INITIAL_JS_DAY.getTime() - INITIAL_1900_DAY.getTime();
   const mdyDateRegexp = /^\d{1,2}(\/|-|\s)\d{1,2}((\/|-|\s)\d{1,4})?$/;
   const ymdDateRegexp = /^\d{3,4}(\/|-|\s)\d{1,2}(\/|-|\s)\d{1,2}$/;
-  const dateSeparatorsRegex = /\/|-|\s/;
-  const dateRegexp = /^(\d{1,4})[\/-\s](\d{1,4})([\/-\s](\d{1,4}))?$/;
+  const whiteSpaceChars = whiteSpaceCharacters.join("");
+  const dateSeparatorsRegex = new RegExp(`\/|-|${whiteSpaceCharacters.join("|")}`);
+  const dateRegexp = new RegExp(`^(\\d{1,4})[\/${whiteSpaceChars}\-](\\d{1,4})([\/${whiteSpaceChars}\-](\\d{1,4}))?$`);
   const timeRegexp = /((\d+(:\d+)?(:\d+)?\s*(AM|PM))|(\d+:\d+(:\d+)?))$/;
   /** Convert a value number representing a date, or return undefined if it isn't possible */
   function valueToDateNumber(value, locale) {
@@ -6925,6 +6927,8 @@
   function splitTextToWidth(ctx, text, style, width) {
       if (!style)
           style = {};
+      if (isMarkdownLink(text))
+          text = parseMarkdownLink(text).label;
       const brokenText = [];
       // Checking if text contains NEWLINE before split makes it very slightly slower if text contains it,
       // but 5-10x faster if it doesn't
@@ -8765,6 +8769,10 @@
       if (groupValue === null || groupValue === "null") {
           return null;
       }
+      const extractedGroupValue = typeof groupValue === "object" ? groupValue.value : groupValue;
+      if (isEvaluationError(extractedGroupValue)) {
+          return extractedGroupValue;
+      }
       const groupValueString = typeof groupValue === "boolean"
           ? toString(groupValue).toLocaleLowerCase()
           : toString(groupValue);
@@ -26509,6 +26517,51 @@ stores.inject(MyMetaStore, storeInstance);
           Object.assign(animatedBox.style, style);
       },
   });
+  cellAnimationRegistry.add("iconFadeIn", {
+      id: "iconFadeIn",
+      easingFn: "easeInCubic",
+      hasAnimation: (oldBox, newBox) => {
+          return Boolean((!oldBox?.icons?.left && newBox?.icons?.left) ||
+              (!oldBox?.icons?.right && newBox?.icons?.right) ||
+              (!oldBox?.icons?.center && newBox?.icons?.center));
+      },
+      updateAnimation: function (progress, animatedBox, oldBox, newBox) {
+          const iconOpacity = EASING_FN[this.easingFn](progress);
+          if (animatedBox.icons.left && newBox.icons.left && !oldBox.icons.left) {
+              animatedBox.icons.left.opacity = iconOpacity;
+          }
+          if (animatedBox.icons.right && newBox.icons.right && !oldBox.icons.right) {
+              animatedBox.icons.right.opacity = iconOpacity;
+          }
+          if (animatedBox.icons.center && newBox.icons.center && !oldBox.icons.center) {
+              animatedBox.icons.center.opacity = iconOpacity;
+          }
+      },
+  });
+  cellAnimationRegistry.add("iconFadeOut", {
+      id: "iconFadeOut",
+      easingFn: "easeOutCubic",
+      hasAnimation: (oldBox, newBox) => {
+          return Boolean((oldBox?.icons?.left && !newBox?.icons?.left) ||
+              (oldBox?.icons?.right && !newBox?.icons?.right) ||
+              (oldBox?.icons?.center && !newBox?.icons?.center));
+      },
+      updateAnimation: function (progress, animatedBox, oldBox, newBox) {
+          const iconOpacity = 1 - EASING_FN[this.easingFn](progress);
+          if (!animatedBox.icons) {
+              animatedBox.icons = {};
+          }
+          if (oldBox.icons.left && !newBox.icons.left) {
+              animatedBox.icons.left = { ...oldBox.icons.left, opacity: iconOpacity };
+          }
+          if (oldBox.icons.right && !newBox.icons.right) {
+              animatedBox.icons.right = { ...oldBox.icons.right, opacity: iconOpacity };
+          }
+          if (oldBox.icons.center && !newBox.icons.center) {
+              animatedBox.icons.center = { ...oldBox.icons.center, opacity: iconOpacity };
+          }
+      },
+  });
   cellAnimationRegistry.add("textChange", {
       id: "textChange",
       easingFn: "easeOutCubic",
@@ -26517,7 +26570,7 @@ stores.inject(MyMetaStore, storeInstance);
           const newText = newBox?.content?.textLines?.join("\n");
           // Note: here, we also animate changes to icons layout (margins/size change, or icon appearing/disappearing)
           // because a change to the icon layout will impact where the text is positioned.
-          return (Boolean(oldText && newText && oldText !== newText) || hasIconLayoutChange(newBox, oldBox));
+          return Boolean(oldText && newText && (oldText !== newText || hasIconLayoutChange(newBox, oldBox)));
       },
       updateAnimation: function (progress, animatedBox, oldBox, newBox) {
           const value = EASING_FN[this.easingFn](progress);
@@ -26532,7 +26585,7 @@ stores.inject(MyMetaStore, storeInstance);
               height: newBox.height,
               style: { ...newBox.style },
               skipCellGridLines: true,
-              content: newBox.content,
+              content: newBox.content ? { ...newBox.content } : undefined,
               clipRect: newBox.clipRect || {
                   ...newBox,
                   // large width to avoid clipping the text it it didn't have a clipRect before,
@@ -26552,7 +26605,7 @@ stores.inject(MyMetaStore, storeInstance);
               height: newBox.height,
               style: { ...oldBox.style },
               skipCellGridLines: true,
-              content: oldBox.content,
+              content: oldBox.content ? { ...oldBox.content } : undefined,
               clipRect: oldBox.clipRect || {
                   ...newBox,
                   x: Math.max(0, newBox.x - (oldBox.content?.width || 0)),
@@ -27402,7 +27455,9 @@ stores.inject(MyMetaStore, storeInstance);
   }
   function getFormulaNumberValue(sheetId, formula, getters) {
       const value = getters.evaluateFormula(sheetId, formula);
-      return isMatrix(value) ? undefined : tryToNumber(value, getters.getLocale());
+      return isMultipleElementMatrix(value)
+          ? undefined
+          : tryToNumber(toScalar(value), getters.getLocale());
   }
   function getInvalidGaugeRuntime(chart, getters) {
       return {
@@ -31027,6 +31082,9 @@ stores.inject(MyMetaStore, storeInstance);
           return undefined;
       }
       get errorOriginPositionString() {
+          if (this.env.model.getters.isDashboard()) {
+              return "";
+          }
           const evaluationError = this.evaluationError;
           const position = evaluationError?.errorOriginPosition;
           if (!position || deepEquals(position, this.props.cellPosition)) {
@@ -32664,7 +32722,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       captureSelection(zone, col, row) {
           this.model.selection.capture(this, {
-              cell: { col: col || zone.left, row: row || zone.right },
+              cell: { col: col ?? zone.left, row: row ?? zone.right },
               zone,
           }, {
               handleEvent: this.handleEvent.bind(this),
@@ -39175,40 +39233,112 @@ stores.inject(MyMetaStore, storeInstance);
    * In all the sheets, replace the table-only references in the formula cells with standard references.
    */
   function convertTableFormulaReferences(convertedSheets, xlsxSheets) {
+      let deconstructedSheets = null;
       for (const tableSheet of convertedSheets) {
           const tables = xlsxSheets.find((s) => isSheetNameEqual(s.sheetName, tableSheet.name)).tables;
+          if (!tables || tables.length === 0) {
+              continue;
+          }
+          // Only deconstruct sheets if we are sure there are tables to process
+          if (!deconstructedSheets) {
+              deconstructedSheets = deconstructSheets(convertedSheets);
+          }
           for (const table of tables) {
-              const tabRef = table.name + "[";
-              for (const sheet of convertedSheets) {
-                  for (const xc in sheet.cells) {
-                      const cell = sheet.cells[xc];
-                      let cellContent = sheet.cells[xc];
-                      if (cell && cellContent && cellContent.startsWith("=")) {
-                          let refIndex;
-                          while ((refIndex = cellContent.indexOf(tabRef)) !== -1) {
-                              let endIndex = refIndex + tabRef.length;
-                              let openBrackets = 1;
-                              while (openBrackets > 0 && endIndex < cellContent.length) {
-                                  if (cellContent[endIndex] === "[") {
-                                      openBrackets++;
-                                  }
-                                  else if (cellContent[endIndex] === "]") {
-                                      openBrackets--;
-                                  }
-                                  endIndex++;
-                              }
-                              const reference = cellContent.slice(refIndex + tabRef.length, endIndex - 1);
-                              const sheetPrefix = tableSheet.id === sheet.id ? "" : tableSheet.name + "!";
-                              const convertedRef = convertTableReference(sheetPrefix, reference, table, xc);
-                              cellContent =
-                                  cellContent.slice(0, refIndex) + convertedRef + cellContent.slice(endIndex);
+              for (const sheetId in deconstructedSheets) {
+                  const sheet = convertedSheets.find((s) => s.id === sheetId);
+                  for (const xc in deconstructedSheets[sheetId]) {
+                      const deconstructedCell = deconstructedSheets[sheetId][xc];
+                      for (let i = deconstructedCell.length - 3; i >= 0; i -= 2) {
+                          const possibleTable = deconstructedSheets[sheetId][xc][i];
+                          if (!possibleTable.endsWith(table.name)) {
+                              continue;
                           }
+                          const possibleRef = deconstructedSheets[sheetId][xc][i + 1];
+                          const sheetPrefix = tableSheet.id === sheet.id ? "" : tableSheet.name + "!";
+                          const convertedRef = convertTableReference(sheetPrefix, possibleRef, table, xc);
+                          deconstructedSheets[sheetId][xc][i + 2] =
+                              possibleTable.slice(0, possibleTable.indexOf(table.name)) +
+                                  convertedRef +
+                                  deconstructedSheets[sheetId][xc][i + 2];
+                          deconstructedSheets[sheetId][xc].splice(i, 2);
                       }
-                      sheet.cells[xc] = cellContent;
+                      // sheet.cells[xc] = cellContent;
                   }
               }
           }
       }
+      if (!deconstructedSheets) {
+          return;
+      }
+      for (const sheetId in deconstructedSheets) {
+          const sheet = convertedSheets.find((s) => s.id === sheetId);
+          for (const xc in deconstructedSheets[sheetId]) {
+              const deconstructedCell = deconstructedSheets[sheetId][xc];
+              if (deconstructedCell.length === 1) {
+                  sheet.cells[xc] = deconstructedCell[0];
+                  continue;
+              }
+              let newContent = "";
+              for (let i = 0; i < deconstructedCell.length; i += 2) {
+                  newContent += deconstructedCell[i] + "[" + deconstructedCell[i + 1] + "]";
+              }
+              newContent += deconstructedCell[deconstructedCell.length - 1];
+              sheet.cells[xc] = newContent;
+          }
+      }
+  }
+  /**
+   * Deconstruct the content of the cells in the sheets to extract possible table references.
+   * Example from "=AVERAGE(Table1[colName1])-AVERAGE(Table2[colName2])":
+   * return --> ["=AVERAGE(Table1", "colName1", ")-AVERAGE(Table2", "colName2", ")"]
+   */
+  function deconstructSheets(convertedSheets) {
+      const deconstructedSheets = {};
+      for (const sheet of convertedSheets) {
+          for (const xc in sheet.cells) {
+              const cellContent = sheet.cells[xc];
+              if (!cellContent || !cellContent.startsWith("=")) {
+                  continue;
+              }
+              const startIndex = cellContent.indexOf("[");
+              if (startIndex === -1) {
+                  continue;
+              }
+              const deconstructedCell = [];
+              let possibleTable = cellContent.slice(0, startIndex);
+              let possibleRef = "";
+              let openBrackets = 1;
+              let mainPossibleTableIndex = 0;
+              let mainOpenBracketIndex = startIndex;
+              for (let index = startIndex + 1; index < cellContent.length; index++) {
+                  if (cellContent[index] === "[") {
+                      if (openBrackets === 0) {
+                          possibleTable = cellContent.slice(mainPossibleTableIndex, index);
+                          mainOpenBracketIndex = index;
+                      }
+                      openBrackets++;
+                      continue;
+                  }
+                  if (cellContent[index] === "]") {
+                      openBrackets--;
+                      if (openBrackets === 0) {
+                          possibleRef = cellContent.slice(mainOpenBracketIndex + 1, index);
+                          deconstructedCell.push(possibleTable);
+                          deconstructedCell.push(possibleRef);
+                          mainPossibleTableIndex = index + 1;
+                      }
+                  }
+              }
+              if (deconstructedCell.length) {
+                  if (!deconstructedSheets[sheet.id]) {
+                      deconstructedSheets[sheet.id] = {};
+                  }
+                  deconstructedCell.push(cellContent.slice(mainPossibleTableIndex));
+                  deconstructedSheets[sheet.id][xc] = [...deconstructedCell];
+              }
+          }
+      }
+      return deconstructedSheets;
   }
   /**
    * Convert table-specific references in formulas into standard references. A table reference is composed of columns names,
@@ -45520,10 +45650,10 @@ stores.inject(MyMetaStore, storeInstance);
           const cellValue = isFormula(content)
               ? this.getters.evaluateFormula(this.sheetId, content)
               : parseLiteral(content, this.getters.getLocale());
-          if (isMatrix(cellValue)) {
+          if (isMultipleElementMatrix(cellValue)) {
               return true;
           }
-          const validationResult = this.getters.getValidationResultForCellValue(cellValue, cellPosition);
+          const validationResult = this.getters.getValidationResultForCellValue(toScalar(cellValue), cellPosition);
           if (!validationResult.isValid && validationResult.rule.isBlocking) {
               return false;
           }
@@ -47944,6 +48074,7 @@ stores.inject(MyMetaStore, storeInstance);
                       continue;
                   }
                   ctx.save();
+                  ctx.globalAlpha = icon.opacity ?? 1;
                   ctx.beginPath();
                   const clipRect = icon.clipRect || box;
                   ctx.rect(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
@@ -50634,10 +50765,10 @@ stores.inject(MyMetaStore, storeInstance);
               return tryToNumber(value, locale) !== undefined;
           }
           const evaluatedValue = this.env.model.getters.evaluateFormula(this.sheetId, value);
-          if (isMatrix(evaluatedValue)) {
+          if (isMultipleElementMatrix(evaluatedValue)) {
               return false;
           }
-          return tryToNumber(evaluatedValue, locale) !== undefined;
+          return tryToNumber(toScalar(evaluatedValue), locale) !== undefined;
       }
       get sheetId() {
           const chart = this.env.model.getters.getChart(this.props.figureId);
@@ -51491,12 +51622,32 @@ stores.inject(MyMetaStore, storeInstance);
       static template = "o-spreadsheet-ChartPanel";
       static components = { Section, ChartTypePicker };
       static props = { onCloseSidePanel: Function, figureId: String };
+      panelContentRef;
+      scrollPositions = {
+          configuration: 0,
+          design: 0,
+      };
       store;
       get figureId() {
           return this.props.figureId;
       }
       setup() {
           this.store = useLocalStore(MainChartPanelStore);
+          this.panelContentRef = owl.useRef("panelContent");
+          owl.useEffect(() => {
+              const el = this.panelContentRef.el;
+              const activePanel = this.store.panel;
+              if (el) {
+                  el.scrollTop = this.scrollPositions[activePanel];
+              }
+          }, () => [this.store.panel]);
+      }
+      switchPanel(panel) {
+          const el = this.panelContentRef.el;
+          if (el) {
+              this.scrollPositions[this.store.panel] = el.scrollTop;
+          }
+          this.store.activatePanel(panel);
       }
       updateChart(figureId, updateDefinition) {
           if (figureId !== this.figureId) {
@@ -52332,6 +52483,9 @@ stores.inject(MyMetaStore, storeInstance);
                       this.switchToList();
                   }
               }
+              else if (!this.editedCF) {
+                  this.switchToList();
+              }
           });
       }
       get conditionalFormats() {
@@ -55445,10 +55599,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (finalCell.value === null) {
               return { value: _t("(Undefined)") };
           }
-          return {
-              value: finalCell.value,
-              format: finalCell.format,
-          };
+          return finalCell;
       }
       getPivotCellValueAndFormat(measureId, domain) {
           const dataEntries = this.filterDataEntriesFromDomain(this.dataEntries, domain);
@@ -55686,7 +55837,6 @@ stores.inject(MyMetaStore, storeInstance);
       ui: SpreadsheetPivot,
       definition: SpreadsheetPivotRuntimeDefinition,
       externalData: false,
-      onIterationEndEvaluation: (pivot) => pivot.markAsDirtyForEvaluation(),
       dateGranularities: [...dateGranularities],
       datetimeGranularities: [...dateGranularities, "hour_number", "minute_number", "second_number"],
       isMeasureCandidate: (field) => field.type !== "boolean",
@@ -64337,7 +64487,7 @@ stores.inject(MyMetaStore, storeInstance);
   onIterationEndEvaluationRegistry.add("pivots", (getters) => {
       for (const pivotId of getters.getPivotIds()) {
           const pivot = getters.getPivot(pivotId);
-          pivotRegistry.get(pivot.type).onIterationEndEvaluation(pivot);
+          pivot.markAsDirtyForEvaluation?.();
       }
   });
 
@@ -66801,12 +66951,12 @@ stores.inject(MyMetaStore, storeInstance);
               }
               return this.getters.evaluateFormula(sheetId, value) ?? "";
           });
-          if (evaluatedCriterionValues.some(isMatrix)) {
+          if (evaluatedCriterionValues.some(isMultipleElementMatrix)) {
               return false;
           }
           const evaluatedCriterion = {
               type: rule.operator,
-              values: evaluatedCriterionValues,
+              values: evaluatedCriterionValues.map(toScalar),
           };
           return evaluator.isValueValid(cell.value ?? "", evaluatedCriterion, this.getters, sheetId);
       }
@@ -66966,10 +67116,10 @@ stores.inject(MyMetaStore, storeInstance);
           const evaluator = criterionEvaluatorRegistry.get(criterion.type);
           const offset = this.getCellOffsetInRule(cellPosition, rule);
           const evaluatedCriterionValues = this.getEvaluatedCriterionValues(sheetId, offset, criterion);
-          if (evaluatedCriterionValues.some(isMatrix)) {
+          if (evaluatedCriterionValues.some(isMultipleElementMatrix)) {
               return undefined;
           }
-          const evaluatedCriterion = { ...criterion, values: evaluatedCriterionValues };
+          const evaluatedCriterion = { ...criterion, values: evaluatedCriterionValues.map(toScalar) };
           if (evaluator.isValueValid(cellValue, evaluatedCriterion, this.getters, sheetId)) {
               return undefined;
           }
@@ -67612,13 +67762,13 @@ stores.inject(MyMetaStore, storeInstance);
               super(custom, params);
               this.getters = params.getters;
           }
-          init(params) {
+          markAsDirtyForEvaluation() {
               this.cache = {};
               this.rankAsc = {};
               this.rankDesc = {};
               this.runningTotal = {};
               this.runningTotalInPercent = {};
-              super.init(params);
+              super.markAsDirtyForEvaluation?.();
           }
           getPivotCellValueAndFormat(measureName, domain) {
               return this.getMeasureDisplayValue(measureName, domain);
@@ -67743,7 +67893,7 @@ stores.inject(MyMetaStore, storeInstance);
                       return this.getSubTreeMatchingDomain(node.children, domain, domainLevel + 1);
                   }
               }
-              return tree;
+              return [];
           }
           treeToLeafDomains(tree, parentDomain = []) {
               const domains = [];
@@ -68431,9 +68581,9 @@ stores.inject(MyMetaStore, storeInstance);
       .add("ALPHANUMERIC_INCREMENT_MODIFIER", {
       apply: (rule, data) => {
           rule.current += rule.increment;
-          const content = `${rule.prefix}${rule.current
-            .toString()
-            .padStart(rule.numberPostfixLength || 0, "0")}`;
+          let value = Math.abs(rule.current).toString();
+          value = "0".repeat(Math.max(rule.numberPostfixLength - value.length, 0)) + value;
+          const content = `${rule.prefix}${value}`;
           return {
               cellData: {
                   border: data.border,
@@ -68551,6 +68701,7 @@ stores.inject(MyMetaStore, storeInstance);
   const numberPostfixRegExp = /(\d+)$/;
   const stringPrefixRegExp = /^(.*\D+)/;
   const alphaNumericValueRegExp = /^(.*\D+)(\d+)$/;
+  const leadingZerosRegex = /^0*/;
   /**
    * Get the consecutive evaluated cells that can pass the filter function (e.g. certain type filter).
    * Return the one which contains the given cell
@@ -68682,12 +68833,18 @@ stores.inject(MyMetaStore, storeInstance);
       generateRule: (cell, cells, direction) => {
           const numberPostfix = parseInt(cell.content.match(numberPostfixRegExp)[0]);
           const prefix = cell.content.match(stringPrefixRegExp)[0];
-          const numberPostfixLength = cell.content.length - prefix.length;
           const group = getGroup(cell, cells, (evaluatedCell) => evaluatedCell.type === CellValueType.text &&
-              alphaNumericValueRegExp.test(evaluatedCell.value)) // get consecutive alphanumeric cells, no matter what the prefix is
+              alphaNumericValueRegExp.test(evaluatedCell.value))
+              // get consecutive alphanumeric cells, no matter what the prefix is
               .filter((cell) => prefix === (cell.value ?? "").toString().match(stringPrefixRegExp)[0])
-              .map((cell) => parseInt((cell.value ?? "").toString().match(numberPostfixRegExp)[0]));
-          let increment = calculateIncrementBasedOnGroup(group);
+              .map((cell) => (cell.value ?? "").toString().match(numberPostfixRegExp)[0]);
+          // find the length of number with the most leading zeros
+          const mostLeadingZeros = group.reduce((candidate, current) => {
+              const currentLength = current.match(leadingZerosRegex)[0].length;
+              return currentLength > candidate[1] ? [current, currentLength] : candidate;
+          }, [group[0], 0]);
+          const numberPostfixLength = mostLeadingZeros[1] ? mostLeadingZeros[0].length : 0;
+          let increment = calculateIncrementBasedOnGroup(group.map((x) => parseInt(x)));
           if (["up", "left"].includes(direction) && group.length === 1) {
               increment = -increment;
           }
@@ -73475,12 +73632,12 @@ stores.inject(MyMetaStore, storeInstance);
                       }
                       return this.getters.evaluateFormula(sheetId, value) ?? "";
                   });
-                  if (evaluatedCriterionValues.some(isMatrix)) {
+                  if (evaluatedCriterionValues.some(isMultipleElementMatrix)) {
                       continue;
                   }
                   const evaluatedCriterion = {
                       type: filterValue.type,
-                      values: evaluatedCriterionValues,
+                      values: evaluatedCriterionValues.map(toScalar),
                       dateValue: filterValue.dateValue,
                   };
                   for (let row = filteredZone.top; row <= filteredZone.bottom; row++) {
@@ -80982,26 +81139,28 @@ stores.inject(MyMetaStore, storeInstance);
                   bottom: Math.min(this.getters.getNumberRows(sheetId) - 1, bottom),
               };
           };
-          const { col: refCol, row: refRow } = this.getReferencePosition();
+          const { cell: refCell, zone: refZone } = this.getReferenceAnchor();
+          const { col: refCol, row: refRow } = refCell;
           // check if we can shrink selection
           let n = 0;
           while (result !== null) {
               n++;
               if (deltaCol < 0) {
                   const newRight = this.getNextAvailableCol(deltaCol, right - (n - 1), refRow);
-                  result = refCol <= right - n ? expand({ top, left, bottom, right: newRight }) : null;
+                  result = refZone.right <= right - n ? expand({ top, left, bottom, right: newRight }) : null;
               }
               if (deltaCol > 0) {
                   const newLeft = this.getNextAvailableCol(deltaCol, left + (n - 1), refRow);
-                  result = left + n <= refCol ? expand({ top, left: newLeft, bottom, right }) : null;
+                  result = left + n <= refZone.left ? expand({ top, left: newLeft, bottom, right }) : null;
               }
               if (deltaRow < 0) {
                   const newBottom = this.getNextAvailableRow(deltaRow, refCol, bottom - (n - 1));
-                  result = refRow <= bottom - n ? expand({ top, left, bottom: newBottom, right }) : null;
+                  result =
+                      refZone.bottom <= bottom - n ? expand({ top, left, bottom: newBottom, right }) : null;
               }
               if (deltaRow > 0) {
                   const newTop = this.getNextAvailableRow(deltaRow, refCol, top + (n - 1));
-                  result = top + n <= refRow ? expand({ top: newTop, left, bottom, right }) : null;
+                  result = top + n <= refZone.top ? expand({ top: newTop, left, bottom, right }) : null;
               }
               result = result ? reorderZone(result) : result;
               if (result && !isEqual(result, anchor.zone)) {
@@ -81231,18 +81390,26 @@ stores.inject(MyMetaStore, storeInstance);
        * If the anchor is hidden, browses from left to right and top to bottom to
        * find a visible cell.
        */
-      getReferencePosition() {
+      getReferenceAnchor() {
           const sheetId = this.getters.getActiveSheetId();
           const anchor = this.anchor;
           const { left, right, top, bottom } = anchor.zone;
           const { col: anchorCol, row: anchorRow } = anchor.cell;
+          const col = this.getters.isColHidden(sheetId, anchorCol)
+              ? this.getters.findVisibleHeader(sheetId, "COL", left, right) || anchorCol
+              : anchorCol;
+          const row = this.getters.isRowHidden(sheetId, anchorRow)
+              ? this.getters.findVisibleHeader(sheetId, "ROW", top, bottom) || anchorRow
+              : anchorRow;
+          const zone = this.getters.expandZone(sheetId, {
+              left: col,
+              right: col,
+              top: row,
+              bottom: row,
+          });
           return {
-              col: this.getters.isColHidden(sheetId, anchorCol)
-                  ? this.getters.findVisibleHeader(sheetId, "COL", left, right) || anchorCol
-                  : anchorCol,
-              row: this.getters.isRowHidden(sheetId, anchorRow)
-                  ? this.getters.findVisibleHeader(sheetId, "ROW", top, bottom) || anchorRow
-                  : anchorRow,
+              cell: { col, row },
+              zone,
           };
       }
       deltaToTarget(position, direction, step) {
@@ -84398,6 +84565,7 @@ stores.inject(MyMetaStore, storeInstance);
       PivotSidePanelStore,
       PivotMeasureDisplayPanelStore,
       ClientFocusStore,
+      GridRenderer,
   };
   function addFunction(functionName, functionDescription) {
       functionRegistry.add(functionName, functionDescription);
@@ -84464,9 +84632,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.5.0-alpha.0";
-  __info__.date = "2025-06-24T12:26:38.163Z";
-  __info__.hash = "ed0f325";
+  __info__.version = "18.5.0-alpha.2";
+  __info__.date = "2025-07-11T11:13:53.317Z";
+  __info__.hash = "6d42178";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);