@odoo/o-spreadsheet 19.0.6 → 19.0.7

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 19.0.6
- * @date 2025-10-16T06:39:36.282Z
- * @hash 0d4315a
+ * @version 19.0.7
+ * @date 2025-10-23T08:19:01.764Z
+ * @hash 1c1d1ec
  */
 
 (function (exports, owl) {
@@ -1892,6 +1892,29 @@
           removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex);
       }
   }
+  function profilesContainsZone(profilesStartingPosition, profiles, zone) {
+      const leftValue = zone.left;
+      const rightValue = zone.right;
+      const topValue = zone.top;
+      const bottomValue = zone.bottom + 1;
+      const leftIndex = binaryPredecessorSearch(profilesStartingPosition, leftValue, 0);
+      const rightIndex = binaryPredecessorSearch(profilesStartingPosition, rightValue, leftIndex);
+      if (leftIndex === -1 || rightIndex === -1) {
+          return false;
+      }
+      for (let i = leftIndex; i <= rightIndex; i++) {
+          const profile = profiles.get(profilesStartingPosition[i]);
+          const topPredIndex = binaryPredecessorSearch(profile, topValue, 0, true);
+          const bottomSuccIndex = binarySuccessorSearch(profile, bottomValue, 0, true);
+          if (topPredIndex === -1 || topPredIndex % 2 !== 0) {
+              return false;
+          }
+          if (topValue < profile[topPredIndex] || bottomValue > profile[bottomSuccIndex]) {
+              return false;
+          }
+      }
+      return true;
+  }
   function findIndexAndCreateProfile(profilesStartingPosition, profiles, value, searchLeft, startIndex) {
       if (value === undefined) {
           // this is only the case when the value correspond to a bottom value that could be undefined
@@ -1976,7 +1999,18 @@
       }
       // add the top and bottom value to the profile and
       // remove all information between the top and bottom index
-      profile.splice(topPredIndex + 1, bottomSuccIndex - topPredIndex - 1, ...newPoints);
+      const toDelete = bottomSuccIndex - topPredIndex - 1;
+      const toInsert = newPoints.length;
+      const start = topPredIndex + 1;
+      // fast path and slow path
+      if (start === profile.length - 1 && toDelete === 1 && toInsert === 1) {
+          // fast path: we just need to replace the last element
+          profile[start] = newPoints[0] ?? newPoints[1];
+      }
+      else {
+          // equivalent but slower and with memory allocation
+          profile.splice(start, toDelete, ...newPoints);
+      }
   }
   function removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex) {
       const start = leftIndex - 1 === -1 ? 0 : leftIndex - 1;
@@ -2015,8 +2049,10 @@
                   left,
                   bottom,
                   right,
-                  hasHeader: (bottom === undefined && top !== 0) || (right === undefined && left !== 0),
               };
+              if ((bottom === undefined && top !== 0) || (right === undefined && left !== 0)) {
+                  profileZone.hasHeader = true;
+              }
               let findCorrespondingZone = false;
               for (let j = pendingZones.length - 1; j >= 0; j--) {
                   const pendingZone = pendingZones[j];
@@ -2501,17 +2537,6 @@
       }
       return [leftColumnZone, rightPartZone];
   }
-  function aggregatePositionsToZones(positions) {
-      const result = {};
-      for (const position of positions) {
-          result[position.sheetId] ??= [];
-          result[position.sheetId].push(positionToZone(position));
-      }
-      for (const sheetId in result) {
-          result[sheetId] = recomputeZones(result[sheetId]);
-      }
-      return result;
-  }
   /**
    * Array of all positions in the zone.
    */
@@ -6943,6 +6968,10 @@
       }
       return parts;
   }
+  function positionToBoundedRange(position) {
+      const zone = { left: position.col, top: position.row, right: position.col, bottom: position.row };
+      return { sheetId: position.sheetId, zone };
+  }
   /**
    * Check that a zone is valid regarding the order of top-bottom and left-right.
    * Left should be smaller than right, top should be smaller than bottom.
@@ -38696,12 +38725,23 @@ stores.inject(MyMetaStore, storeInstance);
       .add("LinkEditor", LinkEditorPopoverBuilder)
       .add("FilterMenu", FilterMenuPopoverBuilder);
 
-  const CHART_LIMITS = {
-      MAX_PIE_CATEGORIES: 7,
-      MAX_PIE_CATEGORIES_NO_TITLE: 6,
-      MIN_RADAR_CATEGORIES: 3,
-      MAX_RADAR_CATEGORIES: 12,
-      PERCENTAGE_THRESHOLD: 100,
+  const DEFAULT_BAR_CHART_CONFIG = {
+      type: "bar",
+      title: {},
+      dataSets: [],
+      legendPosition: "none",
+      dataSetsHaveTitle: false,
+      stacked: false,
+  };
+  const DEFAULT_LINE_CHART_CONFIG = {
+      type: "line",
+      title: {},
+      dataSets: [],
+      legendPosition: "none",
+      dataSetsHaveTitle: false,
+      stacked: false,
+      cumulative: false,
+      labelsAsText: false,
   };
   function getUnboundRange(getters, zone) {
       return zoneToXc(getters.getUnboundedZone(getters.getActiveSheetId(), zone));
@@ -38740,43 +38780,19 @@ stores.inject(MyMetaStore, storeInstance);
       return detectedType;
   }
   function categorizeColumns(zones, getters) {
-      const columns = {
-          number: [],
-          text: [],
-          date: [],
-      };
+      const columns = [];
       for (const zone of getZonesByColumns(zones)) {
           const cells = getters.getEvaluatedCellsInZone(getters.getActiveSheetId(), zone);
-          const type = detectColumnType(cells);
-          if (type !== "empty") {
-              const targetType = type === "percentage" ? "number" : type;
-              columns[targetType].push({ zone, type });
-          }
+          columns.push({ zone, type: detectColumnType(cells) });
       }
       return columns;
   }
   function getCellStats(getters, zone) {
       const cells = getters.getEvaluatedCellsInZone(getters.getActiveSheetId(), zone);
-      const uniqueValues = new Set();
-      let totalCount = 0;
-      let percentageSum = 0;
-      for (let i = 0; i < cells.length; i++) {
-          const { value } = cells[i];
-          const str = value?.toString().trim();
-          if (!str) {
-              continue;
-          }
-          uniqueValues.add(str);
-          totalCount++;
-          const num = Number(value);
-          if (!isNaN(num)) {
-              percentageSum += Math.abs(num) * 100;
-          }
-      }
+      const values = cells.map((c) => c.value?.toString().trim() || "").filter((s) => s);
       return {
-          uniqueCount: uniqueValues.size,
-          totalCount,
-          percentageSum,
+          uniqueCount: new Set(values).size,
+          totalCount: values.length,
       };
   }
   function isDatasetTitled(getters, column) {
@@ -38787,167 +38803,191 @@ stores.inject(MyMetaStore, storeInstance);
       });
       return ![CellValueType.number, CellValueType.empty].includes(titleCell.type);
   }
-  function createBaseChart(type, dataSets, options = {}) {
-      return {
-          type,
-          title: {},
-          dataSets,
-          legendPosition: "none",
-          ...options,
-      };
-  }
+  /**
+   * Builds a chart definition for a single column selection. The logic to detect the chart type is as follows:
+   * - If the column contains a single cell, create a scorecard.
+   * - If the column type is "percentage", create a pie chart.
+   * - If the column type is "text", create a pie chart
+   * - If the column type is "date", create a line chart.
+   * - Otherwise, create a bar chart.
+   */
   function buildSingleColumnChart(column, getters) {
       const { type, zone } = column;
       const sheetId = getters.getActiveSheetId();
       const dataSetsHaveTitle = isDatasetTitled(getters, column);
       const dataRange = getUnboundRange(getters, zone);
       const titleCell = getters.getEvaluatedCell({ sheetId, col: zone.left, row: zone.top });
+      if (getZoneArea(zone) === 1) {
+          return buildScorecard(zone, getters);
+      }
       switch (type) {
           case "percentage":
-              const { percentageSum } = getCellStats(getters, zone);
-              return createBaseChart("pie", [{ dataRange }], {
+              return {
+                  type: "pie",
                   title: dataSetsHaveTitle ? { text: String(titleCell.value) } : {},
+                  dataSets: [{ dataRange }],
+                  legendPosition: "none",
                   dataSetsHaveTitle,
-                  isDoughnut: percentageSum < CHART_LIMITS.PERCENTAGE_THRESHOLD,
-              });
+              };
           case "text":
               const cells = getters.getEvaluatedCellsInZone(sheetId, zone);
               const titleCount = cells.reduce((count, cell) => (cell.value === titleCell.value ? count + 1 : count), 0);
               const hasUniqueTitle = titleCell.value !== null && titleCount === 1;
-              return createBaseChart("pie", [{ dataRange }], {
+              return {
+                  type: "pie",
                   title: hasUniqueTitle ? { text: String(titleCell.value) } : {},
+                  dataSets: [{ dataRange }],
                   labelRange: dataRange,
                   dataSetsHaveTitle: hasUniqueTitle,
-                  isDoughnut: false,
                   aggregated: true,
                   legendPosition: "top",
-              });
-          // TODO: Handle date column with matrix chart when matrix chart is supported
+              };
           case "date":
-              return createBaseChart("line", [{ dataRange }], {
-                  labelRange: dataRange,
+              return {
+                  ...DEFAULT_LINE_CHART_CONFIG,
+                  type: "line",
+                  title: dataSetsHaveTitle ? { text: String(titleCell.value) } : {},
+                  dataSets: [{ dataRange }],
                   dataSetsHaveTitle,
-                  cumulative: false,
-                  labelsAsText: false,
-              });
+              };
       }
-      return createBaseChart("bar", [{ dataRange }], { dataSetsHaveTitle });
+      return {
+          ...DEFAULT_BAR_CHART_CONFIG,
+          title: dataSetsHaveTitle ? { text: String(titleCell.value) } : {},
+          dataSets: [{ dataRange }],
+          dataSetsHaveTitle,
+      };
   }
+  /**
+   * Builds a chart definition for a selection of two columns. The logic to detect the chart type always consider the
+   * columns left to right, and is as follows:
+   * - any type + percentage columns: pie chart
+   * - number + number columns: scatter chart
+   * - date + number columns: line chart
+   * - text + number columns: treemap if repetition in labels
+   * - any other combination: bar chart
+   */
   function buildTwoColumnChart(columns, getters) {
-      const { number: numberColumns, text: textColumns, date: dateColumns } = columns;
-      if (numberColumns.length === 2) {
-          return createBaseChart("scatter", [{ dataRange: getUnboundRange(getters, numberColumns[1].zone) }], {
-              labelRange: getUnboundRange(getters, numberColumns[0].zone),
-              dataSetsHaveTitle: isDatasetTitled(getters, numberColumns[1]),
-              labelsAsText: false,
-          });
+      if (columns.length !== 2) {
+          throw new Error("buildTwoColumnChart expects exactly two columns");
       }
-      // TODO: Handle date + number with matrix chart when matrix chart is supported
-      if (dateColumns.length === 1 && numberColumns.length === 1) {
-          return createBaseChart("line", [{ dataRange: getUnboundRange(getters, numberColumns[0].zone) }], {
-              labelRange: getUnboundRange(getters, dateColumns[0].zone),
-              dataSetsHaveTitle: isDatasetTitled(getters, numberColumns[0]),
-              aggregated: false,
-              cumulative: false,
+      if (columns[1].type === "percentage") {
+          return {
+              type: "pie",
+              title: {},
+              dataSets: [{ dataRange: getUnboundRange(getters, columns[1].zone) }],
+              labelRange: getUnboundRange(getters, columns[0].zone),
+              dataSetsHaveTitle: isDatasetTitled(getters, columns[1]),
+              aggregated: true,
+              legendPosition: "none",
+          };
+      }
+      if (columns[0].type === "number" && columns[1].type === "number") {
+          return {
+              type: "scatter",
+              title: {},
+              dataSets: [{ dataRange: getUnboundRange(getters, columns[1].zone) }],
+              labelRange: getUnboundRange(getters, columns[0].zone),
+              dataSetsHaveTitle: isDatasetTitled(getters, columns[1]),
               labelsAsText: false,
-          });
+              legendPosition: "none",
+          };
       }
-      if (textColumns.length === 1 && numberColumns.length === 1) {
-          const [textColumn] = textColumns;
-          const [numberColumn] = numberColumns;
+      // TODO: Handle date + number with calendar chart when implemented (and change the docstring)
+      if (columns[0].type === "date" && columns[1].type === "number") {
+          return {
+              ...DEFAULT_LINE_CHART_CONFIG,
+              type: "line",
+              dataSets: [{ dataRange: getUnboundRange(getters, columns[1].zone) }],
+              labelRange: getUnboundRange(getters, columns[0].zone),
+              dataSetsHaveTitle: isDatasetTitled(getters, columns[0]),
+          };
+      }
+      if (columns[0].type === "text" && columns[1].type === "number") {
+          const textColumn = columns[0];
+          const numberColumn = columns[1];
           const { uniqueCount, totalCount } = getCellStats(getters, textColumn.zone);
           const dataSetsHaveTitle = isDatasetTitled(getters, numberColumn);
-          const maxCategories = dataSetsHaveTitle
-              ? CHART_LIMITS.MAX_PIE_CATEGORIES
-              : CHART_LIMITS.MAX_PIE_CATEGORIES_NO_TITLE;
-          const labelRange = getUnboundRange(getters, textColumn.zone);
-          const dataRange = getUnboundRange(getters, numberColumn.zone);
-          if (uniqueCount <= maxCategories) {
-              const { percentageSum } = getCellStats(getters, numberColumn.zone);
-              return createBaseChart("pie", [{ dataRange }], {
-                  labelRange,
-                  dataSetsHaveTitle,
-                  isDoughnut: numberColumn.type === "percentage" && percentageSum < CHART_LIMITS.PERCENTAGE_THRESHOLD,
-                  aggregated: true,
-                  legendPosition: "top",
-              });
-          }
-          // Use treemap when categories repeat, as pie chart would be cluttered
           if (uniqueCount !== totalCount) {
-              return createBaseChart("treemap", [{ dataRange: labelRange }], {
-                  labelRange: dataRange,
+              return {
+                  type: "treemap",
+                  title: {},
+                  dataSets: [{ dataRange: getUnboundRange(getters, textColumn.zone) }],
+                  labelRange: getUnboundRange(getters, numberColumn.zone),
                   dataSetsHaveTitle,
-              });
+                  legendPosition: "none",
+              };
           }
-          return createBaseChart("bar", [{ dataRange }], {
-              labelRange,
-              dataSetsHaveTitle,
-          });
       }
-      const labelColumn = textColumns[0] || dateColumns[0] || numberColumns[0];
-      const dataColumn = numberColumns[0] || textColumns[0] || dateColumns[0];
-      return createBaseChart("line", [{ dataRange: getUnboundRange(getters, dataColumn.zone) }], {
-          labelRange: getUnboundRange(getters, labelColumn.zone),
-          dataSetsHaveTitle: isDatasetTitled(getters, dataColumn),
-          cumulative: false,
-          labelsAsText: true,
-      });
+      return {
+          ...DEFAULT_BAR_CHART_CONFIG,
+          dataSets: [{ dataRange: getUnboundRange(getters, columns[1].zone) }],
+          labelRange: getUnboundRange(getters, columns[0].zone),
+          dataSetsHaveTitle: isDatasetTitled(getters, columns[1]),
+      };
   }
+  /**
+   * Builds a chart definition for a selection more than two columns. The logic to detect the chart type always consider
+   * the columns left to right, and is as follows:
+   * - multiple text + single number/percentage columns: sunburst if 3+ text columns, treemap otherwise
+   * - any type + multiple percentage columns: pie chart
+   * - date + multiple number columns: line chart
+   * - any other combination: bar chart
+   */
   function buildMultiColumnChart(columns, getters) {
-      const { number: numberColumns, text: textColumns, date: dateColumns } = columns;
-      const dataSetsHaveTitle = numberColumns.some((col) => isDatasetTitled(getters, col));
-      if (textColumns.length >= 2 && numberColumns.length === 1) {
-          const sortedTextColumns = textColumns.sort((colA, colB) => getCellStats(getters, colA.zone).uniqueCount - getCellStats(getters, colB.zone).uniqueCount);
-          const dataSets = sortedTextColumns.map(({ zone }) => ({
+      if (columns.length < 3) {
+          throw new Error("buildMultiColumnChart expects at least three columns");
+      }
+      const dataSetsHaveTitle = columns.some((col) => col.type !== "text" && isDatasetTitled(getters, col));
+      const lastColumn = columns[columns.length - 1];
+      const columnsExceptLast = columns.slice(0, columns.length - 1);
+      if ((lastColumn.type === "percentage" || lastColumn.type === "number") &&
+          columnsExceptLast.every((col) => col.type === "text")) {
+          const dataSets = columnsExceptLast.map(({ zone }) => ({
               dataRange: getUnboundRange(getters, zone),
           }));
-          return createBaseChart(textColumns.length >= 3 ? "sunburst" : "treemap", dataSets, {
-              labelRange: getUnboundRange(getters, numberColumns[0].zone),
+          return {
+              type: columnsExceptLast.length >= 3 ? "sunburst" : "treemap",
+              title: {},
+              dataSets,
+              labelRange: getUnboundRange(getters, lastColumn.zone),
               dataSetsHaveTitle,
-          });
+              legendPosition: "none",
+          };
       }
-      const dataSets = recomputeZones(numberColumns.map((col) => col.zone)).map((zone) => ({
+      const firstColumn = columns[0];
+      const columnsExceptFirst = columns.slice(1);
+      const rangesOfColumnsExceptFirst = columnsExceptFirst.map(({ zone }) => ({
           dataRange: getUnboundRange(getters, zone),
       }));
-      if (dateColumns.length === 1 && numberColumns.length > 1) {
-          return createBaseChart("line", dataSets, {
-              labelRange: getUnboundRange(getters, dateColumns[0].zone),
+      if (columnsExceptFirst.every((col) => col.type === "percentage")) {
+          return {
+              type: "pie",
+              title: {},
+              dataSets: rangesOfColumnsExceptFirst,
+              labelRange: getUnboundRange(getters, firstColumn.zone),
               dataSetsHaveTitle,
-              cumulative: false,
-              labelsAsText: false,
+              aggregated: false,
               legendPosition: "top",
-          });
+          };
       }
-      if (textColumns.length === 1 && numberColumns.length >= 2) {
-          const [textColumn] = textColumns;
-          const firstCell = getters.getEvaluatedCell({
-              sheetId: getters.getActiveSheetId(),
-              row: textColumn.zone.top,
-              col: textColumn.zone.left,
-          });
-          const { uniqueCount, totalCount } = getCellStats(getters, textColumn.zone);
-          const categoryCount = dataSetsHaveTitle && firstCell.value ? uniqueCount - 1 : uniqueCount;
-          const expectedDataCount = categoryCount * numberColumns.length + (dataSetsHaveTitle ? numberColumns.length : 0);
-          const actualDataCount = numberColumns.reduce((sum, dataCol) => sum + getCellStats(getters, dataCol.zone).totalCount, 0);
-          if (uniqueCount === totalCount &&
-              uniqueCount >= CHART_LIMITS.MIN_RADAR_CATEGORIES &&
-              uniqueCount <= CHART_LIMITS.MAX_RADAR_CATEGORIES &&
-              expectedDataCount === actualDataCount) {
-              return createBaseChart("radar", dataSets, {
-                  title: dataSetsHaveTitle && firstCell.value ? { text: String(firstCell.value) } : {},
-                  labelRange: getUnboundRange(getters, textColumn.zone),
-                  dataSetsHaveTitle,
-                  legendPosition: "top",
-              });
-          }
+      if (firstColumn.type === "date" && columnsExceptFirst.every((col) => col.type === "number")) {
+          return {
+              ...DEFAULT_LINE_CHART_CONFIG,
+              type: "line",
+              dataSets: rangesOfColumnsExceptFirst,
+              labelRange: getUnboundRange(getters, firstColumn.zone),
+              dataSetsHaveTitle,
+              legendPosition: "top",
+          };
       }
-      const labelColumn = textColumns[0] || dateColumns[0] || numberColumns[0];
-      return createBaseChart("bar", dataSets, {
-          labelRange: dataSets.length ? getUnboundRange(getters, labelColumn.zone) : "",
+      return {
+          ...DEFAULT_BAR_CHART_CONFIG,
+          dataSets: rangesOfColumnsExceptFirst,
+          labelRange: getUnboundRange(getters, firstColumn.zone),
           dataSetsHaveTitle,
-          aggregated: true,
           legendPosition: "top",
-      });
+      };
   }
   function buildScorecard(zone, getters) {
       const cell = getters.getCell({
@@ -38970,22 +39010,18 @@ stores.inject(MyMetaStore, storeInstance);
    */
   function getSmartChartDefinition(zones, getters) {
       const columns = categorizeColumns(zones, getters);
-      const { number: numberColumns, text: textColumns, date: dateColumns } = columns;
-      const columnCount = numberColumns.length + textColumns.length + dateColumns.length;
-      switch (columnCount) {
-          case 0:
-              return createBaseChart("bar", [{ dataRange: getUnboundRange(getters, zones[0]) }], {
-                  dataSetsHaveTitle: false,
-              });
+      if (columns.length === 0 || columns.every((col) => col.type === "empty")) {
+          const dataSets = columns.map(({ zone }) => ({ dataRange: getUnboundRange(getters, zone) }));
+          return { ...DEFAULT_BAR_CHART_CONFIG, dataSets };
+      }
+      const nonEmptyColumns = columns.filter((col) => col.type !== "empty");
+      switch (nonEmptyColumns.length) {
           case 1:
-              const singleColumn = numberColumns[0] || textColumns[0] || dateColumns[0];
-              return getZoneArea(singleColumn.zone) === 1
-                  ? buildScorecard(singleColumn.zone, getters)
-                  : buildSingleColumnChart(singleColumn, getters);
+              return buildSingleColumnChart(nonEmptyColumns[0], getters);
           case 2:
-              return buildTwoColumnChart(columns, getters);
+              return buildTwoColumnChart(nonEmptyColumns, getters);
           default:
-              return buildMultiColumnChart(columns, getters);
+              return buildMultiColumnChart(nonEmptyColumns, getters);
       }
   }
 
@@ -44026,6 +44062,7 @@ stores.inject(MyMetaStore, storeInstance);
           return data;
       }
       const figureIds = new Set();
+      const chartIds = new Set();
       const uuidGenerator = new UuidGenerator();
       for (const sheet of data.sheets || []) {
           for (const figure of sheet.figures || []) {
@@ -44033,6 +44070,12 @@ stores.inject(MyMetaStore, storeInstance);
                   figure.id += uuidGenerator.smallUuid();
               }
               figureIds.add(figure.id);
+              if (figure.tag === "chart") {
+                  if (chartIds.has(figure.data?.chartId)) {
+                      figure.data.chartId += uuidGenerator.smallUuid();
+                  }
+                  chartIds.add(figure.data?.chartId);
+              }
           }
       }
       data.uniqueFigureIds = true;
@@ -68768,6 +68811,281 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class ZoneSet {
+      profilesStartingPosition = [0];
+      profiles = new Map([[0, []]]);
+      constructor(zones = []) {
+          for (const zone of zones) {
+              this.add(zone);
+          }
+      }
+      isEmpty() {
+          return this.profiles.size === 1 && this.profiles.get(0)?.length === 0;
+      }
+      add(zone) {
+          modifyProfiles(this.profilesStartingPosition, this.profiles, [zone]);
+      }
+      delete(zone) {
+          modifyProfiles(this.profilesStartingPosition, this.profiles, [zone], true);
+      }
+      has(zone) {
+          return profilesContainsZone(this.profilesStartingPosition, this.profiles, zone);
+      }
+      difference(other) {
+          const result = this.copy();
+          for (const zone of other) {
+              result.delete(zone);
+          }
+          return result;
+      }
+      copy() {
+          const result = new ZoneSet();
+          result.profilesStartingPosition = [...this.profilesStartingPosition];
+          result.profiles = new Map();
+          for (const [key, value] of this.profiles) {
+              result.profiles.set(key, [...value]);
+          }
+          return result;
+      }
+      size() {
+          let size = 0;
+          for (const profile of this.profiles.values()) {
+              size += profile.length;
+          }
+          return size / 2;
+      }
+      /**
+       * iterator of all the zones in the ZoneSet
+       */
+      [Symbol.iterator]() {
+          return constructZonesFromProfiles(this.profilesStartingPosition, this.profiles)[Symbol.iterator]();
+      }
+  }
+
+  class RangeSet {
+      setsBySheetId = {};
+      constructor(ranges = []) {
+          for (const range of ranges) {
+              this.add(range);
+          }
+      }
+      add(range) {
+          if (!this.setsBySheetId[range.sheetId]) {
+              this.setsBySheetId[range.sheetId] = new ZoneSet();
+          }
+          this.setsBySheetId[range.sheetId].add(range.zone);
+      }
+      addMany(ranges) {
+          for (const range of ranges) {
+              this.add(range);
+          }
+      }
+      addPosition(position) {
+          this.add(positionToBoundedRange(position));
+      }
+      addManyPositions(positions) {
+          for (const position of positions) {
+              this.addPosition(position);
+          }
+      }
+      has(range) {
+          if (!this.setsBySheetId[range.sheetId]) {
+              return false;
+          }
+          return this.setsBySheetId[range.sheetId].has(range.zone);
+      }
+      hasPosition(position) {
+          return this.has(positionToBoundedRange(position));
+      }
+      delete(range) {
+          if (!this.setsBySheetId[range.sheetId]) {
+              return;
+          }
+          this.setsBySheetId[range.sheetId].delete(range.zone);
+      }
+      deleteMany(ranges) {
+          for (const range of ranges) {
+              this.delete(range);
+          }
+      }
+      deleteManyPositions(positions) {
+          for (const position of positions) {
+              this.delete(positionToBoundedRange(position));
+          }
+      }
+      difference(other) {
+          const result = new RangeSet();
+          for (const sheetId in this.setsBySheetId) {
+              result.setsBySheetId[sheetId] = this.setsBySheetId[sheetId];
+          }
+          for (const sheetId in other.setsBySheetId) {
+              if (result.setsBySheetId[sheetId]) {
+                  result.setsBySheetId[sheetId] = result.setsBySheetId[sheetId].difference(other.setsBySheetId[sheetId]);
+              }
+          }
+          return result;
+      }
+      copy() {
+          const result = new RangeSet();
+          for (const sheetId in this.setsBySheetId) {
+              result.setsBySheetId[sheetId] = this.setsBySheetId[sheetId].copy();
+          }
+          return result;
+      }
+      clear() {
+          this.setsBySheetId = {};
+      }
+      size() {
+          let size = 0;
+          for (const sheetId in this.setsBySheetId) {
+              size += this.setsBySheetId[sheetId].size();
+          }
+          return size;
+      }
+      isEmpty() {
+          for (const sheetId in this.setsBySheetId) {
+              if (!this.setsBySheetId[sheetId].isEmpty()) {
+                  return false;
+              }
+          }
+          return true;
+      }
+      /**
+       * iterator of all the ranges in the RangeSet
+       */
+      [Symbol.iterator]() {
+          const result = [];
+          for (const sheetId in this.setsBySheetId) {
+              for (const zone of this.setsBySheetId[sheetId]) {
+                  result.push({ sheetId: sheetId, zone });
+              }
+          }
+          return result[Symbol.iterator]();
+      }
+  }
+
+  /**
+   * R-Tree of ranges, mapping zones (r-tree bounding boxes) to ranges (data of the r-tree item).
+   * Ranges associated to the exact same bounding box are grouped together
+   * to reduce the number of nodes in the R-tree.
+   */
+  class DependenciesRTree {
+      rTree;
+      constructor(items = []) {
+          const compactedBoxes = groupSameBoundingBoxes(items);
+          this.rTree = new SpreadsheetRTree(compactedBoxes);
+      }
+      insert(item) {
+          const data = this.rTree.search(item.boundingBox);
+          const itemBoundingBox = item.boundingBox;
+          const exactBoundingBox = data.find(({ boundingBox }) => boundingBox.sheetId === itemBoundingBox.sheetId &&
+              boundingBox.zone.left === itemBoundingBox.zone.left &&
+              boundingBox.zone.top === itemBoundingBox.zone.top &&
+              boundingBox.zone.right === itemBoundingBox.zone.right &&
+              boundingBox.zone.bottom === itemBoundingBox.zone.bottom);
+          if (exactBoundingBox) {
+              exactBoundingBox.data.add(item.data);
+          }
+          else {
+              this.rTree.insert({ ...item, data: new RangeSet([item.data]) });
+          }
+      }
+      search({ zone, sheetId }) {
+          const results = new RangeSet();
+          for (const { data } of this.rTree.search({ zone, sheetId })) {
+              results.addMany(data);
+          }
+          return results;
+      }
+      remove(item) {
+          const data = this.rTree.search(item.boundingBox);
+          const itemBoundingBox = item.boundingBox;
+          const exactBoundingBox = data.find(({ boundingBox }) => boundingBox.sheetId === itemBoundingBox.sheetId &&
+              boundingBox.zone.left === itemBoundingBox.zone.left &&
+              boundingBox.zone.top === itemBoundingBox.zone.top &&
+              boundingBox.zone.right === itemBoundingBox.zone.right &&
+              boundingBox.zone.bottom === itemBoundingBox.zone.bottom);
+          if (exactBoundingBox) {
+              exactBoundingBox.data.delete(item.data);
+          }
+          else {
+              this.rTree.remove({ ...item, data: new RangeSet([item.data]) });
+          }
+      }
+  }
+  /**
+   * Group together all formulas pointing to the exact same dependency (bounding box).
+   * The goal is to optimize the following case:
+   * - if any cell in B1:B1000 changes, C1 must be recomputed
+   * - if any cell in B1:B1000 changes, C2 must be recomputed
+   * - if any cell in B1:B1000 changes, C3 must be recomputed
+   * ...
+   * - if any cell in B1:B1000 changes, C1000 must be recomputed
+   *
+   * Instead of having 1000 entries in the R-tree, we want to have a single entry
+   * with B1:B1000 (bounding box) pointing to C1:C1000 (formulas).
+   */
+  function groupSameBoundingBoxes(items) {
+      // Important: this function must be as fast as possible. It is on the evaluation hot path.
+      let maxCol = 0;
+      let maxRow = 0;
+      for (let i = 0; i < items.length; i++) {
+          const zone = items[i].boundingBox.zone;
+          if (zone.right > maxCol) {
+              maxCol = zone.right;
+          }
+          if (zone.bottom > maxRow) {
+              maxRow = zone.bottom;
+          }
+      }
+      maxCol += 1;
+      maxRow += 1;
+      // in most real-world cases, we can use a fast numeric key
+      // but if the zones are too far right or bottom, we fallback to a slower string key
+      const maxPossibleKey = (((maxRow + 1) * maxCol + 1) * maxRow + 1) * maxCol;
+      const useFastKey = maxPossibleKey <= Number.MAX_SAFE_INTEGER;
+      if (!useFastKey) {
+          console.warn("Max col/row size exceeded, using slow zone key");
+      }
+      const groupedByBBox = {};
+      for (const item of items) {
+          const sheetId = item.boundingBox.sheetId;
+          if (!groupedByBBox[sheetId]) {
+              groupedByBBox[sheetId] = {};
+          }
+          const bBox = item.boundingBox.zone;
+          let bBoxKey = 0;
+          if (useFastKey) {
+              bBoxKey =
+                  bBox.left +
+                      bBox.top * maxCol +
+                      bBox.right * maxCol * maxRow +
+                      bBox.bottom * maxCol * maxRow * maxCol;
+          }
+          else {
+              bBoxKey = `${bBox.left},${bBox.top},${bBox.right},${bBox.bottom}`;
+          }
+          if (groupedByBBox[sheetId][bBoxKey]) {
+              const ranges = groupedByBBox[sheetId][bBoxKey].data;
+              ranges.add(item.data);
+          }
+          else {
+              groupedByBBox[sheetId][bBoxKey] = {
+                  boundingBox: item.boundingBox,
+                  data: new RangeSet([item.data]),
+              };
+          }
+      }
+      const result = [];
+      for (const sheetId in groupedByBBox) {
+          const map = groupedByBBox[sheetId];
+          for (const key in map) {
+              result.push(map[key]);
+          }
+      }
+      return result;
+  }
+
   /**
    * Implementation of a dependency Graph.
    * The graph is used to evaluate the cells in the correct
@@ -68776,12 +69094,10 @@ stores.inject(MyMetaStore, storeInstance);
    * It uses an R-Tree data structure to efficiently find dependent cells.
    */
   class FormulaDependencyGraph {
-      createEmptyPositionSet;
       dependencies = new PositionMap();
       rTree;
-      constructor(createEmptyPositionSet, data = []) {
-          this.createEmptyPositionSet = createEmptyPositionSet;
-          this.rTree = new SpreadsheetRTree(data);
+      constructor(data = []) {
+          this.rTree = new DependenciesRTree(data);
       }
       removeAllDependencies(formulaPosition) {
           const ranges = this.dependencies.get(formulaPosition);
@@ -68795,7 +69111,10 @@ stores.inject(MyMetaStore, storeInstance);
       }
       addDependencies(formulaPosition, dependencies) {
           const rTreeItems = dependencies.map(({ sheetId, zone }) => ({
-              data: formulaPosition,
+              data: {
+                  sheetId: formulaPosition.sheetId,
+                  zone: positionToZone(formulaPosition),
+              },
               boundingBox: {
                   zone,
                   sheetId,
@@ -68813,46 +69132,20 @@ stores.inject(MyMetaStore, storeInstance);
           }
       }
       /**
-       * Return all the cells that depend on the provided ranges,
-       * in the correct order they should be evaluated.
-       * This is called a topological ordering (excluding cycles)
+       * Return all the cells that depend on the provided ranges.
        */
-      getCellsDependingOn(ranges, ignore) {
-          const visited = this.createEmptyPositionSet();
+      getCellsDependingOn(ranges, visited = new RangeSet()) {
+          visited = visited.copy();
           const queue = Array.from(ranges).reverse();
           while (queue.length > 0) {
               const range = queue.pop();
-              const zone = range.zone;
-              const sheetId = range.sheetId;
-              for (let col = zone.left; col <= zone.right; col++) {
-                  for (let row = zone.top; row <= zone.bottom; row++) {
-                      visited.add({ sheetId, col, row });
-                  }
-              }
-              const impactedPositions = this.rTree.search(range).map((dep) => dep.data);
-              const nextInQueue = {};
-              for (const position of impactedPositions) {
-                  if (!visited.has(position) && !ignore.has(position)) {
-                      if (!nextInQueue[position.sheetId]) {
-                          nextInQueue[position.sheetId] = [];
-                      }
-                      nextInQueue[position.sheetId].push(positionToZone(position));
-                  }
-              }
-              for (const sheetId in nextInQueue) {
-                  const zones = recomputeZones(nextInQueue[sheetId], []);
-                  queue.push(...zones.map((zone) => ({ sheetId, zone })));
-              }
+              visited.add(range);
+              const impactedRanges = this.rTree.search(range);
+              queue.push(...impactedRanges.difference(visited));
           }
           // remove initial ranges
           for (const range of ranges) {
-              const zone = range.zone;
-              const sheetId = range.sheetId;
-              for (let col = zone.left; col <= zone.right; col++) {
-                  for (let row = zone.top; row <= zone.bottom; row++) {
-                      visited.delete({ sheetId, col, row });
-                  }
-              }
+              visited.delete(range);
           }
           return visited;
       }
@@ -69115,7 +69408,7 @@ stores.inject(MyMetaStore, storeInstance);
       getters;
       compilationParams;
       evaluatedCells = new PositionMap();
-      formulaDependencies = lazy(new FormulaDependencyGraph(this.createEmptyPositionSet.bind(this)));
+      formulaDependencies = lazy(new FormulaDependencyGraph());
       blockedArrayFormulas = new PositionSet({});
       spreadingRelations = new SpreadingRelation();
       constructor(context, getters) {
@@ -69150,7 +69443,7 @@ stores.inject(MyMetaStore, storeInstance);
               return undefined;
           }
           const arrayFormulas = this.spreadingRelations.searchFormulaPositionsSpreadingOn(position.sheetId, positionToZone(position));
-          return Array.from(arrayFormulas).find((position) => !this.blockedArrayFormulas.has(position));
+          return arrayFormulas.find((position) => !this.blockedArrayFormulas.has(position));
       }
       updateDependencies(position) {
           // removing dependencies is slow because it requires
@@ -69194,57 +69487,72 @@ stores.inject(MyMetaStore, storeInstance);
       }
       evaluateCells(positions) {
           const start = performance.now();
-          const cellsToCompute = this.createEmptyPositionSet();
-          cellsToCompute.addMany(positions);
+          const rangesToCompute = new RangeSet();
+          rangesToCompute.addManyPositions(positions);
           const arrayFormulasPositions = this.getArrayFormulasImpactedByChangesOf(positions);
-          cellsToCompute.addMany(this.getCellsDependingOn(positions));
-          cellsToCompute.addMany(arrayFormulasPositions);
-          cellsToCompute.addMany(this.getCellsDependingOn(arrayFormulasPositions));
-          this.evaluate(cellsToCompute);
+          rangesToCompute.addMany(this.getCellsDependingOn(rangesToCompute));
+          rangesToCompute.addMany(arrayFormulasPositions);
+          rangesToCompute.addMany(this.getCellsDependingOn(arrayFormulasPositions));
+          this.evaluate(rangesToCompute);
           console.debug("evaluate Cells", performance.now() - start, "ms");
       }
       getArrayFormulasImpactedByChangesOf(positions) {
-          const impactedPositions = this.createEmptyPositionSet();
+          const impactedRanges = new RangeSet();
           for (const position of positions) {
               const content = this.getters.getCell(position)?.content;
               const arrayFormulaPosition = this.getArrayFormulaSpreadingOn(position);
               if (arrayFormulaPosition !== undefined) {
                   // take into account new collisions.
-                  impactedPositions.add(arrayFormulaPosition);
+                  impactedRanges.addPosition(arrayFormulaPosition);
               }
               if (!content) {
                   // The previous content could have blocked some array formulas
-                  impactedPositions.add(position);
+                  impactedRanges.addPosition(position);
               }
           }
-          const zonesBySheetIds = aggregatePositionsToZones(impactedPositions);
-          for (const sheetId in zonesBySheetIds) {
-              for (const zone of zonesBySheetIds[sheetId]) {
-                  impactedPositions.addMany(this.getArrayFormulasBlockedBy(sheetId, zone));
-              }
+          for (const range of [...impactedRanges]) {
+              impactedRanges.addMany(this.getArrayFormulasBlockedBy(range.sheetId, range.zone));
           }
-          return impactedPositions;
+          return impactedRanges;
       }
       buildDependencyGraph() {
           this.blockedArrayFormulas = this.createEmptyPositionSet();
           this.spreadingRelations = new SpreadingRelation();
           this.formulaDependencies = lazy(() => {
-              const dependencies = [...this.getAllCells()].flatMap((position) => this.getDirectDependencies(position)
-                  .filter((range) => !range.invalidSheetName && !range.invalidXc)
-                  .map((range) => ({
-                  data: position,
-                  boundingBox: {
-                      zone: range.zone,
-                      sheetId: range.sheetId,
-                  },
-              })));
-              return new FormulaDependencyGraph(this.createEmptyPositionSet.bind(this), dependencies);
+              const rTreeItems = [];
+              for (const sheetId of this.getters.getSheetIds()) {
+                  const cells = this.getters.getCells(sheetId);
+                  for (const cellId in cells) {
+                      const cell = cells[cellId];
+                      if (cell.isFormula) {
+                          const directDependencies = cell.compiledFormula.dependencies;
+                          for (const range of directDependencies) {
+                              if (range.invalidSheetName || range.invalidXc) {
+                                  continue;
+                              }
+                              rTreeItems.push({
+                                  data: {
+                                      sheetId,
+                                      zone: positionToZone(this.getters.getCellPosition(cellId)),
+                                  },
+                                  boundingBox: { sheetId: range.sheetId, zone: range.zone },
+                              });
+                          }
+                      }
+                  }
+              }
+              return new FormulaDependencyGraph(rTreeItems);
           });
       }
       evaluateAllCells() {
           const start = performance.now();
           this.evaluatedCells = new PositionMap();
-          this.evaluate(this.getAllCells());
+          const ranges = [];
+          for (const sheetId of this.getters.getSheetIds()) {
+              const zone = this.getters.getSheetZone(sheetId);
+              ranges.push({ sheetId, zone });
+          }
+          this.evaluate(ranges);
           console.debug("evaluate all cells", performance.now() - start, "ms");
       }
       evaluateFormulaResult(sheetId, formulaString) {
@@ -69268,48 +69576,47 @@ stores.inject(MyMetaStore, storeInstance);
               return handleError(error, "");
           }
       }
-      getAllCells() {
-          const positions = this.createEmptyPositionSet();
-          positions.fillAllPositions();
-          return positions;
-      }
       /**
        * Return the position of formulas blocked by the given positions
        * as well as all their dependencies.
        */
       getArrayFormulasBlockedBy(sheetId, zone) {
-          const arrayFormulaPositions = this.createEmptyPositionSet();
+          const arrayFormulaPositions = new RangeSet();
           const arrayFormulas = this.spreadingRelations.searchFormulaPositionsSpreadingOn(sheetId, zone);
-          arrayFormulaPositions.addMany(arrayFormulas);
+          arrayFormulaPositions.addManyPositions(arrayFormulas);
           const spilledPositions = [...arrayFormulas].filter((position) => !this.blockedArrayFormulas.has(position));
           if (spilledPositions.length) {
               // ignore the formula spreading on the position. Keep only the blocked ones
-              arrayFormulaPositions.deleteMany(spilledPositions);
+              arrayFormulaPositions.deleteManyPositions(spilledPositions);
           }
           arrayFormulaPositions.addMany(this.getCellsDependingOn(arrayFormulaPositions));
           return arrayFormulaPositions;
       }
-      nextPositionsToUpdate = new PositionSet({});
+      nextRangesToUpdate = new RangeSet();
       cellsBeingComputed = new Set();
       symbolsBeingComputed = new Set();
-      evaluate(positions) {
+      evaluate(ranges) {
           this.cellsBeingComputed = new Set();
-          this.nextPositionsToUpdate = positions;
+          this.nextRangesToUpdate = new RangeSet(ranges);
           let currentIteration = 0;
-          while (!this.nextPositionsToUpdate.isEmpty() && currentIteration++ < MAX_ITERATION) {
+          while (!this.nextRangesToUpdate.isEmpty() && currentIteration++ < MAX_ITERATION) {
               this.updateCompilationParameters();
-              const positions = this.nextPositionsToUpdate.clear();
-              for (let i = 0; i < positions.length; ++i) {
-                  this.evaluatedCells.delete(positions[i]);
-              }
-              for (let i = 0; i < positions.length; ++i) {
-                  const position = positions[i];
-                  if (this.nextPositionsToUpdate.has(position)) {
-                      continue;
-                  }
-                  const evaluatedCell = this.computeCell(position);
-                  if (evaluatedCell !== EMPTY_CELL) {
-                      this.evaluatedCells.set(position, evaluatedCell);
+              const ranges = [...this.nextRangesToUpdate];
+              this.nextRangesToUpdate.clear();
+              this.clearEvaluatedRanges(ranges);
+              for (const range of ranges) {
+                  const { left, bottom, right, top } = range.zone;
+                  for (let col = left; col <= right; col++) {
+                      for (let row = top; row <= bottom; row++) {
+                          const position = { sheetId: range.sheetId, col, row };
+                          if (this.nextRangesToUpdate.hasPosition(position)) {
+                              continue;
+                          }
+                          const evaluatedCell = this.computeCell(position);
+                          if (evaluatedCell !== EMPTY_CELL) {
+                              this.evaluatedCells.set(position, evaluatedCell);
+                          }
+                      }
                   }
               }
               onIterationEndEvaluationRegistry.getAll().forEach((callback) => callback(this.getters));
@@ -69318,6 +69625,16 @@ stores.inject(MyMetaStore, storeInstance);
               console.warn("Maximum iteration reached while evaluating cells");
           }
       }
+      clearEvaluatedRanges(ranges) {
+          for (const range of ranges) {
+              const { left, bottom, right, top } = range.zone;
+              for (let col = left; col <= right; col++) {
+                  for (let row = top; row <= bottom; row++) {
+                      this.evaluatedCells.delete({ sheetId: range.sheetId, col, row });
+                  }
+              }
+          }
+      }
       computeCell(position) {
           const evaluation = this.evaluatedCells.get(position);
           if (evaluation) {
@@ -69390,9 +69707,9 @@ stores.inject(MyMetaStore, storeInstance);
       }
       invalidatePositionsDependingOnSpread(sheetId, resultZone) {
           // the result matrix is split in 2 zones to exclude the array formula position
-          const invalidatedPositions = this.formulaDependencies().getCellsDependingOn(excludeTopLeft(resultZone).map((zone) => ({ sheetId, zone })), this.nextPositionsToUpdate);
-          invalidatedPositions.delete({ sheetId, col: resultZone.left, row: resultZone.top });
-          this.nextPositionsToUpdate.addMany(invalidatedPositions);
+          const invalidatedPositions = this.getCellsDependingOn(excludeTopLeft(resultZone).map((zone) => ({ sheetId, zone })));
+          invalidatedPositions.delete({ sheetId, zone: resultZone });
+          this.nextRangesToUpdate.addMany(invalidatedPositions);
       }
       assertSheetHasEnoughSpaceToSpreadFormulaResult({ sheetId, col, row }, matrixResult) {
           const numberOfCols = this.getters.getNumberCols(sheetId);
@@ -69467,7 +69784,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const sheetId = position.sheetId;
           this.invalidatePositionsDependingOnSpread(sheetId, zone);
-          this.nextPositionsToUpdate.addMany(this.getArrayFormulasBlockedBy(sheetId, zone));
+          this.nextRangesToUpdate.addMany(this.getArrayFormulasBlockedBy(sheetId, zone));
       }
       /**
        * Wraps a GetSymbolValue function to add cycle detection
@@ -69502,13 +69819,8 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return cell.compiledFormula.dependencies;
       }
-      getCellsDependingOn(positions) {
-          const ranges = [];
-          const zonesBySheetIds = aggregatePositionsToZones(positions);
-          for (const sheetId in zonesBySheetIds) {
-              ranges.push(...zonesBySheetIds[sheetId].map((zone) => ({ sheetId, zone })));
-          }
-          return this.formulaDependencies().getCellsDependingOn(ranges, this.nextPositionsToUpdate);
+      getCellsDependingOn(ranges) {
+          return this.formulaDependencies().getCellsDependingOn(ranges, this.nextRangesToUpdate);
       }
   }
   function forEachSpreadPositionInMatrix(nbColumns, nbRows, callback) {
@@ -88623,9 +88935,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "19.0.6";
-  __info__.date = "2025-10-16T06:39:36.282Z";
-  __info__.hash = "0d4315a";
+  __info__.version = "19.0.7";
+  __info__.date = "2025-10-23T08:19:01.764Z";
+  __info__.hash = "1c1d1ec";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);