@odoo/o-spreadsheet 17.2.0-alpha.8 → 17.3.0-alpha.0

package/dist/o-spreadsheet.iife.js

@@ -3,9 +3,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.2.0-alpha.8
- * @date 2024-03-15T11:01:01.388Z
- * @hash 11cf381
+ * @version 17.3.0-alpha.0
+ * @date 2024-03-20T13:42:32.042Z
+ * @hash 073e154
  */
 
 (function (exports, owl) {
@@ -641,21 +641,6 @@
       }
       return true;
   }
-  class JetSet extends Set {
-      addMany(iterable) {
-          for (const element of iterable) {
-              super.add(element);
-          }
-          return this;
-      }
-      deleteMany(iterable) {
-          let wasDeleted = false;
-          for (const element of iterable) {
-              wasDeleted ||= super.delete(element);
-          }
-          return wasDeleted;
-      }
-  }
   /**
    * Creates a version of the function that's memoized on the value of its first
    * argument, if any.
@@ -4101,14 +4086,6 @@
       }
       return positions;
   }
-  function forEachPositionsInZone(zone, callback) {
-      const { left, right, top, bottom } = zone;
-      for (let col = left; col <= right; col++) {
-          for (let row = top; row <= bottom; row++) {
-              callback(col, row);
-          }
-      }
-  }
   /**
    * This function returns a zone with coordinates modified according to the change
    * applied to the zone. It may be possible to change the zone by resizing or moving
@@ -10054,6 +10031,9 @@ stores.inject(MyMetaStore, storeInstance);
           result.default = true;
           result.defaultValue = defaultValue;
       }
+      if (types.some((t) => t.startsWith("RANGE"))) {
+          result.acceptMatrix = true;
+      }
       return result;
   }
   /**
@@ -18624,11 +18604,27 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const descr = addMetaInfoFromArg(addDescr);
           validateArguments(descr.args);
-          this.mapping[name] = addErrorHandling(addResultHandling(descr.compute), name);
+          this.mapping[name] = addErrorHandling(addResultHandling(addInputHandling(descr)), name);
           super.add(name, descr);
           return this;
       }
   }
+  function addInputHandling(descr) {
+      function computeWithInputHandling(...args) {
+          for (let i = 0; i < args.length; i++) {
+              const argDefinition = descr.args[descr.getArgToFocus(i + 1) - 1];
+              const arg = args[i];
+              if (isMatrix(arg) && !argDefinition.acceptMatrix) {
+                  if (arg.length !== 1 || arg[0].length !== 1) {
+                      throw new EvaluationError(_t("Function [[FUNCTION_NAME]] expects the parameter '%s' to be a single value or a single cell reference, not a range.", argDefinition.name));
+                  }
+                  args[i] = arg[0][0];
+              }
+          }
+          return descr.compute.apply(this, args);
+      }
+      return computeWithInputHandling;
+  }
   function addErrorHandling(compute, functionName) {
       return function (...args) {
           try {
@@ -45850,6 +45846,41 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class PositionMap {
+      map = {};
+      set({ sheetId, col, row }, value) {
+          const map = this.map;
+          if (!map[sheetId]) {
+              map[sheetId] = {};
+          }
+          if (!map[sheetId][col]) {
+              map[sheetId][col] = {};
+          }
+          map[sheetId][col][row] = value;
+      }
+      get({ sheetId, col, row }) {
+          return this.map[sheetId]?.[col]?.[row];
+      }
+      has({ sheetId, col, row }) {
+          return this.map[sheetId]?.[col]?.[row] !== undefined;
+      }
+      delete({ sheetId, col, row }) {
+          delete this.map[sheetId]?.[col]?.[row];
+      }
+      keys() {
+          const map = this.map;
+          const keys = [];
+          for (const sheetId in map) {
+              for (const col in map[sheetId]) {
+                  for (const row in map[sheetId][col]) {
+                      keys.push({ sheetId, col: parseInt(col), row: parseInt(row) });
+                  }
+              }
+          }
+          return keys;
+      }
+  }
+
   function quickselect(arr, k, left, right, compare) {
       quickselectStep(arr, k, left || 0, right || (arr.length - 1), compare || defaultCompare);
   }
@@ -46576,26 +46607,26 @@ stores.inject(MyMetaStore, storeInstance);
    * It uses an R-Tree data structure to efficiently find dependent cells.
    */
   class FormulaDependencyGraph {
-      encoder;
-      dependencies = new Map();
+      createEmptyPositionSet;
+      dependencies = new PositionMap();
       rTree;
-      constructor(encoder, data = []) {
-          this.encoder = encoder;
+      constructor(createEmptyPositionSet, data = []) {
+          this.createEmptyPositionSet = createEmptyPositionSet;
           this.rTree = new SpreadsheetRTree(data);
       }
-      removeAllDependencies(formulaPositionId) {
-          const ranges = this.dependencies.get(formulaPositionId);
+      removeAllDependencies(formulaPosition) {
+          const ranges = this.dependencies.get(formulaPosition);
           if (!ranges) {
               return;
           }
           for (const range of ranges) {
               this.rTree.remove(range);
           }
-          this.dependencies.delete(formulaPositionId);
+          this.dependencies.delete(formulaPosition);
       }
-      addDependencies(formulaPositionId, dependencies) {
+      addDependencies(formulaPosition, dependencies) {
           const rTreeItems = dependencies.map(({ sheetId, zone }) => ({
-              data: formulaPositionId,
+              data: formulaPosition,
               boundingBox: {
                   zone,
                   sheetId,
@@ -46604,12 +46635,12 @@ stores.inject(MyMetaStore, storeInstance);
           for (const item of rTreeItems) {
               this.rTree.insert(item);
           }
-          const existingDependencies = this.dependencies.get(formulaPositionId);
+          const existingDependencies = this.dependencies.get(formulaPosition);
           if (existingDependencies) {
               existingDependencies.push(...rTreeItems);
           }
           else {
-              this.dependencies.set(formulaPositionId, rTreeItems);
+              this.dependencies.set(formulaPosition, rTreeItems);
           }
       }
       /**
@@ -46618,23 +46649,194 @@ stores.inject(MyMetaStore, storeInstance);
        * This is called a topological ordering (excluding cycles)
        */
       getCellsDependingOn(ranges) {
-          const visited = new JetSet();
+          const visited = this.createEmptyPositionSet();
           const queue = Array.from(ranges).reverse();
           while (queue.length > 0) {
               const range = queue.pop();
-              visited.addMany(this.encoder.encodeBoundingBox(range));
-              const impactedPositionIds = this.rTree.search(range).map((dep) => dep.data);
-              for (const positionId of impactedPositionIds) {
-                  if (!visited.has(positionId)) {
-                      queue.push(this.encoder.decodeToBoundingBox(positionId));
+              visited.addMany(positions(range.zone).map((position) => ({ sheetId: range.sheetId, ...position })));
+              const impactedPositions = this.rTree.search(range).map((dep) => dep.data);
+              for (const position of impactedPositions) {
+                  if (!visited.has(position)) {
+                      queue.push({ sheetId: position.sheetId, zone: positionToZone(position) });
                   }
               }
           }
-          visited.deleteMany(ranges.flatMap((r) => this.encoder.encodeBoundingBox(r)));
+          visited.deleteMany(ranges.flatMap((r) => positions(r.zone).map((position) => ({ sheetId: r.sheetId, ...position }))));
           return visited;
       }
   }
 
+  /**
+   * Implements a fixed-sized grid or 2D matrix of bits.
+   * based on https://github.com/zandaqo/structurae
+   *
+   * The grid is implemented as a 1D array of 32-bit integers, where each bit represents a cell in the grid.
+   * It follows row-major order, with each row stored consecutively in 32-bit blocks.
+   * Pads the number of columns to the next power of 2 to allow quick lookups with bitwise operations.
+   *
+   * Key terminology:
+   * - bucket: Index of an item in the Uint32Array, a 32-bit integer.
+   * - bitPosition: The position of a bit within the bucket 32-bit integer.
+   */
+  class BinaryGrid extends Uint32Array {
+      columnOffset = 0;
+      cols = 0;
+      rows = 0;
+      /**
+       * Creates a binary grid of specified dimensions.
+       */
+      static create(rows, columns) {
+          const columnOffset = log2Ceil(columns);
+          const length = (rows << columnOffset) >> 5;
+          const grid = new this(length + 1);
+          grid.columnOffset = columnOffset;
+          grid.cols = columns;
+          grid.rows = rows;
+          return grid;
+      }
+      /**
+       * Returns the bit at given coordinates.
+       */
+      getValue(position) {
+          const [bucket, bitPosition] = this.getCoordinates(position);
+          return ((this[bucket] >> bitPosition) & 1);
+      }
+      /**
+       * Sets the bit at given coordinates.
+       */
+      setValue(position, value) {
+          const [bucket, bitPosition] = this.getCoordinates(position);
+          const currentValue = (this[bucket] >> bitPosition) & 1;
+          const hasBeenInserted = currentValue === 0 && value === 1;
+          this[bucket] = (this[bucket] & ~(1 << bitPosition)) | (value << bitPosition);
+          return hasBeenInserted;
+          // Let's breakdown of the above line:
+          // with an example with a 4-bit integer (instead of 32-bit).
+          //
+          // Let's say we want to set the bit at position 2 to 1 and the existing
+          // bit sequence this[bucket] is 1001. The final bit sequence should be 1101.
+          //
+          // First, we clear the bit at position 2 by AND-ing this[bucket] with a
+          // mask having all 1s except a 0 at the bit position (~ (1 << bitPosition)).
+          // 1 << bitPosition is 0100 (shifting 0001 to the left by 2)
+          // Inverting the bits with ~ gives the final mask ~(1 << bitPosition): 1011
+          //
+          // Then, we shift the value by the bit position (value << bitPosition: 0100)
+          // and OR the result with the previous step's result:
+          // (1001 & 1011) | 0100 = 1101
+      }
+      isEmpty() {
+          return !this.some((bucket) => bucket !== 0);
+      }
+      fillAllPositions() {
+          const thirtyTwoOnes = -1 >>> 0; // same as 2 ** 32 - 1, a 32-bit number with all bits set to 1
+          this.fill(thirtyTwoOnes);
+      }
+      clear() {
+          this.fill(0);
+      }
+      getCoordinates(position) {
+          const { row, col } = position;
+          const index = (row << this.columnOffset) + col;
+          const bucket = index >> 5;
+          return [bucket, index - (bucket << 5)];
+      }
+  }
+  function log2Ceil(value) {
+      // A faster version of Math.ceil(Math.log2(value)).
+      if (value === 0) {
+          return -Infinity;
+      }
+      else if (value < 0) {
+          return NaN;
+      }
+      // --value handles the case where value is a power of 2
+      return 32 - Math.clz32(--value);
+  }
+
+  class PositionSet {
+      sheets = {};
+      /**
+       * List of positions in the order they were inserted.
+       */
+      insertions = [];
+      maxSize = 0;
+      constructor(sheetSizes) {
+          for (const sheetId in sheetSizes) {
+              const cols = sheetSizes[sheetId].cols;
+              const rows = sheetSizes[sheetId].rows;
+              this.maxSize += cols * rows;
+              this.sheets[sheetId] = BinaryGrid.create(rows, cols);
+          }
+      }
+      add(position) {
+          const hasBeenInserted = this.sheets[position.sheetId].setValue(position, 1);
+          if (hasBeenInserted) {
+              this.insertions.push(position);
+          }
+      }
+      addMany(positions) {
+          for (const position of positions) {
+              this.add(position);
+          }
+      }
+      delete(position) {
+          this.sheets[position.sheetId].setValue(position, 0);
+      }
+      deleteMany(positions) {
+          for (const position of positions) {
+              this.delete(position);
+          }
+      }
+      has(position) {
+          return this.sheets[position.sheetId].getValue(position) === 1;
+      }
+      clear() {
+          const insertions = this.insertions;
+          this.insertions = [];
+          for (const sheetId in this.sheets) {
+              this.sheets[sheetId].clear();
+          }
+          return insertions;
+      }
+      isEmpty() {
+          if (this.insertions.length === 0) {
+              return true;
+          }
+          for (const sheetId in this.sheets) {
+              if (!this.sheets[sheetId].isEmpty()) {
+                  return false;
+              }
+          }
+          return true;
+      }
+      fillAllPositions() {
+          this.insertions = new Array(this.maxSize);
+          let index = 0;
+          for (const sheetId in this.sheets) {
+              const grid = this.sheets[sheetId];
+              grid.fillAllPositions();
+              for (let i = 0; i < grid.rows; i++) {
+                  for (let j = 0; j < grid.cols; j++) {
+                      this.insertions[index++] = { sheetId, row: i, col: j };
+                  }
+              }
+          }
+      }
+      /**
+       * Iterate over the positions in the order of insertion.
+       * Note that the same position may be yielded multiple times if the value was added
+       * to the set then removed and then added again.
+       */
+      *[Symbol.iterator]() {
+          for (const position of this.insertions) {
+              if (this.sheets[position.sheetId].getValue(position) === 1) {
+                  yield position;
+              }
+          }
+      }
+  }
+
   /**
    * Contains, for each cell, the array
    * formulas that could potentially spread on it
@@ -46648,6 +46850,7 @@ stores.inject(MyMetaStore, storeInstance);
    *
    */
   class SpreadingRelation {
+      createEmptyPositionSet;
       /**
        * Internal structure:
        * For something like
@@ -46676,39 +46879,42 @@ stores.inject(MyMetaStore, storeInstance);
        * - (B1) --> (B2, B3, B4)  meaning B1 spreads on B2, B3 and B4
        *
        */
-      resultsToArrayFormulas = new Map();
-      arrayFormulasToResults = new Map();
-      getFormulaPositionsSpreadingOn(resultPositionId) {
-          return this.resultsToArrayFormulas.get(resultPositionId) || EMPTY_ARRAY;
+      resultsToArrayFormulas = new PositionMap();
+      arrayFormulasToResults = new PositionMap();
+      constructor(createEmptyPositionSet) {
+          this.createEmptyPositionSet = createEmptyPositionSet;
+      }
+      getFormulaPositionsSpreadingOn(resultPosition) {
+          return this.resultsToArrayFormulas.get(resultPosition) || EMPTY_ARRAY;
       }
-      getArrayResultPositionIds(formulasPositionId) {
-          return this.arrayFormulasToResults.get(formulasPositionId) || EMPTY_ARRAY;
+      getArrayResultPositions(formulasPosition) {
+          return this.arrayFormulasToResults.get(formulasPosition) || EMPTY_ARRAY;
       }
       /**
        * Remove a node, also remove it from other nodes adjacency list
        */
-      removeNode(positionId) {
-          this.resultsToArrayFormulas.delete(positionId);
-          this.arrayFormulasToResults.delete(positionId);
+      removeNode(position) {
+          this.resultsToArrayFormulas.delete(position);
+          this.arrayFormulasToResults.delete(position);
       }
       /**
        * Create a spreading relation between two cells
        */
-      addRelation({ arrayFormulaPositionId, resultPositionId, }) {
-          if (!this.resultsToArrayFormulas.has(resultPositionId)) {
-              this.resultsToArrayFormulas.set(resultPositionId, new Set());
+      addRelation({ arrayFormulaPosition, resultPosition, }) {
+          if (!this.resultsToArrayFormulas.has(resultPosition)) {
+              this.resultsToArrayFormulas.set(resultPosition, this.createEmptyPositionSet());
           }
-          this.resultsToArrayFormulas.get(resultPositionId)?.add(arrayFormulaPositionId);
-          if (!this.arrayFormulasToResults.has(arrayFormulaPositionId)) {
-              this.arrayFormulasToResults.set(arrayFormulaPositionId, new Set());
+          this.resultsToArrayFormulas.get(resultPosition)?.add(arrayFormulaPosition);
+          if (!this.arrayFormulasToResults.has(arrayFormulaPosition)) {
+              this.arrayFormulasToResults.set(arrayFormulaPosition, this.createEmptyPositionSet());
           }
-          this.arrayFormulasToResults.get(arrayFormulaPositionId)?.add(resultPositionId);
+          this.arrayFormulasToResults.get(arrayFormulaPosition)?.add(resultPosition);
       }
-      hasArrayFormulaResult(positionId) {
-          return this.resultsToArrayFormulas.has(positionId);
+      hasArrayFormulaResult(position) {
+          return this.resultsToArrayFormulas.has(position);
       }
-      isArrayFormula(positionId) {
-          return this.arrayFormulasToResults.has(positionId);
+      isArrayFormula(position) {
+          return this.arrayFormulasToResults.has(position);
       }
   }
   const EMPTY_ARRAY = [];
@@ -46720,50 +46926,41 @@ stores.inject(MyMetaStore, storeInstance);
       context;
       getters;
       compilationParams;
-      encoder = new PositionBitsEncoder();
-      evaluatedCells = new Map();
-      formulaDependencies = lazy(new FormulaDependencyGraph(this.encoder));
-      blockedArrayFormulas = new Set();
-      spreadingRelations = new SpreadingRelation();
+      evaluatedCells = new PositionMap();
+      formulaDependencies = lazy(new FormulaDependencyGraph(this.createEmptyPositionSet.bind(this)));
+      blockedArrayFormulas = new PositionSet({});
+      spreadingRelations = new SpreadingRelation(this.createEmptyPositionSet.bind(this));
       constructor(context, getters) {
           this.context = context;
           this.getters = getters;
           this.compilationParams = buildCompilationParameters(this.context, this.getters, this.computeAndSave.bind(this));
       }
       getEvaluatedCell(position) {
-          return this.evaluatedCells.get(this.encoder.encode(position)) || EMPTY_CELL;
+          return this.evaluatedCells.get(position) || EMPTY_CELL;
       }
       getSpreadPositionsOf(position) {
-          const positionId = this.encoder.encode(position);
-          if (!this.spreadingRelations.isArrayFormula(positionId)) {
+          if (!this.spreadingRelations.isArrayFormula(position)) {
               return [];
           }
-          return Array.from(this.spreadingRelations.getArrayResultPositionIds(positionId)).map((positionId) => this.encoder.decode(positionId));
-      }
-      getArrayFormulaSpreadingOn(position) {
-          const positionId = this.encoder.encode(position);
-          const formulaPosition = this.getArrayFormulaSpreadingOnId(positionId);
-          return formulaPosition !== undefined ? this.encoder.decode(formulaPosition) : undefined;
+          return Array.from(this.spreadingRelations.getArrayResultPositions(position));
       }
       getEvaluatedPositions() {
-          return [...this.evaluatedCells.keys()].map((p) => this.encoder.decode(p));
+          return this.evaluatedCells.keys();
       }
-      getArrayFormulaSpreadingOnId(positionId) {
-          if (!this.spreadingRelations.hasArrayFormulaResult(positionId)) {
+      getArrayFormulaSpreadingOn(position) {
+          if (!this.spreadingRelations.hasArrayFormulaResult(position)) {
               return undefined;
           }
-          const arrayFormulas = this.spreadingRelations.getFormulaPositionsSpreadingOn(positionId);
-          return Array.from(arrayFormulas).find((positionId) => !this.blockedArrayFormulas.has(positionId));
+          const arrayFormulas = this.spreadingRelations.getFormulaPositionsSpreadingOn(position);
+          return Array.from(arrayFormulas).find((position) => !this.blockedArrayFormulas.has(position));
       }
       updateDependencies(position) {
-          const positionId = this.encoder.encode(position);
-          this.formulaDependencies().removeAllDependencies(positionId);
-          const dependencies = this.getDirectDependencies(positionId);
-          this.formulaDependencies().addDependencies(positionId, dependencies);
+          this.formulaDependencies().removeAllDependencies(position);
+          const dependencies = this.getDirectDependencies(position);
+          this.formulaDependencies().addDependencies(position, dependencies);
       }
       addDependencies(position, dependencies) {
-          const positionId = this.encoder.encode(position);
-          this.formulaDependencies().addDependencies(positionId, dependencies);
+          this.formulaDependencies().addDependencies(position, dependencies);
       }
       updateCompilationParameters() {
           // rebuild the compilation parameters (with a clean cache)
@@ -46771,47 +46968,57 @@ stores.inject(MyMetaStore, storeInstance);
           this.compilationParams.evalContext.updateDependencies = this.updateDependencies.bind(this);
           this.compilationParams.evalContext.addDependencies = this.addDependencies.bind(this);
       }
+      createEmptyPositionSet() {
+          const sheetSizes = {};
+          for (const sheetId of this.getters.getSheetIds()) {
+              sheetSizes[sheetId] = {
+                  rows: this.getters.getNumberRows(sheetId),
+                  cols: this.getters.getNumberCols(sheetId),
+              };
+          }
+          return new PositionSet(sheetSizes);
+      }
       evaluateCells(positions) {
-          const cells = positions.map((p) => this.encoder.encode(p));
-          const cellsToCompute = new JetSet(cells);
-          const arrayFormulasPositionIds = this.getArrayFormulasImpactedByChangesOf(cells);
-          cellsToCompute.addMany(this.getCellsDependingOn(cells));
-          cellsToCompute.addMany(arrayFormulasPositionIds);
-          cellsToCompute.addMany(this.getCellsDependingOn(arrayFormulasPositionIds));
+          const cellsToCompute = this.createEmptyPositionSet();
+          cellsToCompute.addMany(positions);
+          const arrayFormulasPositions = this.getArrayFormulasImpactedByChangesOf(positions);
+          cellsToCompute.addMany(this.getCellsDependingOn(positions));
+          cellsToCompute.addMany(arrayFormulasPositions);
+          cellsToCompute.addMany(this.getCellsDependingOn(arrayFormulasPositions));
           this.evaluate(cellsToCompute);
       }
-      getArrayFormulasImpactedByChangesOf(positionIds) {
-          const impactedPositionIds = new JetSet();
-          for (const positionId of positionIds) {
-              const content = this.getCell(positionId)?.content;
-              const arrayFormulaPositionId = this.getArrayFormulaSpreadingOnId(positionId);
-              if (arrayFormulaPositionId !== undefined) {
+      getArrayFormulasImpactedByChangesOf(positions) {
+          const impactedPositions = this.createEmptyPositionSet();
+          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.
-                  impactedPositionIds.add(arrayFormulaPositionId);
+                  impactedPositions.add(arrayFormulaPosition);
               }
               if (!content) {
                   // The previous content could have blocked some array formulas
-                  impactedPositionIds.addMany(this.getArrayFormulasBlockedByOrSpreadingOn(positionId));
+                  impactedPositions.addMany(this.getArrayFormulasBlockedByOrSpreadingOn(position));
               }
           }
-          return impactedPositionIds;
+          return impactedPositions;
       }
       buildDependencyGraph() {
-          this.blockedArrayFormulas = new Set();
-          this.spreadingRelations = new SpreadingRelation();
+          this.blockedArrayFormulas = this.createEmptyPositionSet();
+          this.spreadingRelations = new SpreadingRelation(this.createEmptyPositionSet.bind(this));
           this.formulaDependencies = lazy(() => {
-              const dependencies = [...this.getAllCells()].flatMap((positionId) => this.getDirectDependencies(positionId).map((range) => ({
-                  data: positionId,
+              const dependencies = [...this.getAllCells()].flatMap((position) => this.getDirectDependencies(position).map((range) => ({
+                  data: position,
                   boundingBox: {
                       zone: range.zone,
                       sheetId: range.sheetId,
                   },
               })));
-              return new FormulaDependencyGraph(this.encoder, dependencies);
+              return new FormulaDependencyGraph(this.createEmptyPositionSet.bind(this), dependencies);
           });
       }
       evaluateAllCells() {
-          this.evaluatedCells = new Map();
+          this.evaluatedCells = new PositionMap();
           this.evaluate(this.getAllCells());
       }
       evaluateFormula(sheetId, formulaString) {
@@ -46828,57 +47035,50 @@ stores.inject(MyMetaStore, storeInstance);
           return result.value;
       }
       getAllCells() {
-          const positionIds = new JetSet();
-          for (const sheetId of this.getters.getSheetIds()) {
-              const cellIds = this.getters.getCells(sheetId);
-              for (const cellId in cellIds) {
-                  positionIds.add(this.encoder.encode(this.getters.getCellPosition(cellId)));
-              }
-          }
-          return positionIds;
+          const positions = this.createEmptyPositionSet();
+          positions.fillAllPositions();
+          return positions;
       }
-      getArrayFormulasBlockedByOrSpreadingOn(positionId) {
-          if (!this.spreadingRelations.hasArrayFormulaResult(positionId)) {
+      getArrayFormulasBlockedByOrSpreadingOn(position) {
+          if (!this.spreadingRelations.hasArrayFormulaResult(position)) {
               return [];
           }
-          const arrayFormulas = this.spreadingRelations.getFormulaPositionsSpreadingOn(positionId);
-          const cells = new JetSet(arrayFormulas);
-          cells.addMany(this.getCellsDependingOn(arrayFormulas));
-          return cells;
+          const arrayFormulas = this.spreadingRelations.getFormulaPositionsSpreadingOn(position);
+          const positions = this.createEmptyPositionSet();
+          positions.addMany(arrayFormulas);
+          positions.addMany(this.getCellsDependingOn(arrayFormulas));
+          return positions;
       }
-      nextPositionsToUpdate = new JetSet();
+      nextPositionsToUpdate = new PositionSet({});
       cellsBeingComputed = new Set();
-      evaluate(cells) {
+      evaluate(positions) {
           this.cellsBeingComputed = new Set();
-          this.nextPositionsToUpdate = cells;
+          this.nextPositionsToUpdate = positions;
           let currentIteration = 0;
-          while (this.nextPositionsToUpdate.size && currentIteration++ < MAX_ITERATION) {
+          while (!this.nextPositionsToUpdate.isEmpty() && currentIteration++ < MAX_ITERATION) {
               this.updateCompilationParameters();
-              const positionIds = Array.from(this.nextPositionsToUpdate);
-              this.nextPositionsToUpdate.clear();
-              for (let i = 0; i < positionIds.length; ++i) {
-                  const cell = positionIds[i];
-                  this.evaluatedCells.delete(cell);
+              const positions = this.nextPositionsToUpdate.clear();
+              for (let i = 0; i < positions.length; ++i) {
+                  this.evaluatedCells.delete(positions[i]);
               }
-              for (let i = 0; i < positionIds.length; ++i) {
-                  const cell = positionIds[i];
-                  this.setEvaluatedCell(cell, this.computeCell(cell));
+              for (let i = 0; i < positions.length; ++i) {
+                  const position = positions[i];
+                  const evaluatedCell = this.computeCell(position);
+                  if (evaluatedCell !== EMPTY_CELL) {
+                      this.evaluatedCells.set(position, evaluatedCell);
+                  }
               }
           }
       }
-      setEvaluatedCell(positionId, evaluatedCell) {
-          this.evaluatedCells.set(positionId, evaluatedCell);
-      }
-      computeCell(positionId) {
-          const evaluation = this.evaluatedCells.get(positionId);
+      computeCell(position) {
+          const evaluation = this.evaluatedCells.get(position);
           if (evaluation) {
               return evaluation; // already computed
           }
-          if (!this.blockedArrayFormulas.has(positionId)) {
-              this.invalidateSpreading(positionId);
+          if (!this.blockedArrayFormulas.has(position)) {
+              this.invalidateSpreading(position);
           }
-          const cellPosition = this.encoder.decode(positionId);
-          const cell = this.getters.getCell(cellPosition);
+          const cell = this.getters.getCell(position);
           if (cell === undefined) {
               return EMPTY_CELL;
           }
@@ -46890,7 +47090,7 @@ stores.inject(MyMetaStore, storeInstance);
               }
               this.cellsBeingComputed.add(cellId);
               return cell.isFormula
-                  ? this.computeFormulaCell(cellPosition.sheetId, cell)
+                  ? this.computeFormulaCell(position.sheetId, cell)
                   : evaluateLiteral(cell.content, localeFormat);
           }
           catch (e) {
@@ -46903,10 +47103,9 @@ stores.inject(MyMetaStore, storeInstance);
           }
       }
       computeAndSave(position) {
-          const positionId = this.encoder.encode(position);
-          const evaluatedCell = this.computeCell(positionId);
-          if (!this.evaluatedCells.has(positionId)) {
-              this.setEvaluatedCell(positionId, evaluatedCell);
+          const evaluatedCell = this.computeCell(position);
+          if (!this.evaluatedCells.has(position)) {
+              this.evaluatedCells.set(position, evaluatedCell);
           }
           return evaluatedCell;
       }
@@ -46944,24 +47143,23 @@ stores.inject(MyMetaStore, storeInstance);
           throw new EvaluationError(_t("Result couldn't be automatically expanded. Please insert more columns and rows."));
       }
       updateSpreadRelation({ sheetId, col, row, }) {
-          const arrayFormulaPositionId = this.encoder.encode({ sheetId, col, row });
+          const arrayFormulaPosition = { sheetId, col, row };
           return (i, j) => {
               const position = { sheetId, col: i + col, row: j + row };
-              const resultPositionId = this.encoder.encode(position);
-              this.spreadingRelations.addRelation({ resultPositionId, arrayFormulaPositionId });
+              this.spreadingRelations.addRelation({ resultPosition: position, arrayFormulaPosition });
           };
       }
-      checkCollision({ sheetId, col, row }) {
-          const formulaPositionId = this.encoder.encode({ sheetId, col, row });
+      checkCollision(formulaPosition) {
+          const { sheetId, col, row } = formulaPosition;
           return (i, j) => {
               const position = { sheetId: sheetId, col: i + col, row: j + row };
               const rawCell = this.getters.getCell(position);
               if (rawCell?.content ||
                   this.getters.getEvaluatedCell(position).type !== CellValueType.empty) {
-                  this.blockedArrayFormulas.add(formulaPositionId);
+                  this.blockedArrayFormulas.add(formulaPosition);
                   throw new EvaluationError(_t("Array result was not expanded because it would overwrite data in %s.", toXC(position.col, position.row)));
               }
-              this.blockedArrayFormulas.delete(formulaPositionId);
+              this.blockedArrayFormulas.delete(formulaPosition);
           };
       }
       spreadValues({ sheetId, col, row }, matrixResult) {
@@ -46969,19 +47167,18 @@ stores.inject(MyMetaStore, storeInstance);
               const position = { sheetId, col: i + col, row: j + row };
               const cell = this.getters.getCell(position);
               const evaluatedCell = createEvaluatedCell(nullValueToZeroValue(matrixResult[i][j]), this.getters.getLocale(), cell);
-              const positionId = this.encoder.encode(position);
-              this.setEvaluatedCell(positionId, evaluatedCell);
+              this.evaluatedCells.set(position, evaluatedCell);
               // check if formula dependencies present in the spread zone
               // if so, they need to be recomputed
-              this.nextPositionsToUpdate.addMany(this.getCellsDependingOn([positionId]));
+              this.nextPositionsToUpdate.addMany(this.getCellsDependingOn([position]));
           };
       }
-      invalidateSpreading(positionId) {
-          if (!this.spreadingRelations.isArrayFormula(positionId)) {
+      invalidateSpreading(position) {
+          if (!this.spreadingRelations.isArrayFormula(position)) {
               return;
           }
-          for (const child of this.spreadingRelations.getArrayResultPositionIds(positionId)) {
-              const content = this.getCell(child)?.content;
+          for (const child of this.spreadingRelations.getArrayResultPositions(position)) {
+              const content = this.getters.getCell(child)?.content;
               if (content) {
                   // there's no point at re-evaluating overlapping array formulas,
                   // there's still a collision
@@ -46991,28 +47188,25 @@ stores.inject(MyMetaStore, storeInstance);
               this.nextPositionsToUpdate.addMany(this.getCellsDependingOn([child]));
               this.nextPositionsToUpdate.addMany(this.getArrayFormulasBlockedByOrSpreadingOn(child));
           }
-          this.spreadingRelations.removeNode(positionId);
+          this.spreadingRelations.removeNode(position);
       }
       // ----------------------------------------------------------
       //                 COMMON FUNCTIONALITY
       // ----------------------------------------------------------
-      getDirectDependencies(positionId) {
-          const cell = this.getCell(positionId);
+      getDirectDependencies(position) {
+          const cell = this.getters.getCell(position);
           if (!cell?.isFormula) {
               return [];
           }
           return cell.compiledFormula.dependencies;
       }
-      getCellsDependingOn(positionIds) {
+      getCellsDependingOn(positions) {
           const ranges = [];
-          for (const positionId of positionIds) {
-              ranges.push(this.encoder.decodeToBoundingBox(positionId));
+          for (const position of positions) {
+              ranges.push({ sheetId: position.sheetId, zone: positionToZone(position) });
           }
           return this.formulaDependencies().getCellsDependingOn(ranges);
       }
-      getCell(positionId) {
-          return this.getters.getCell(this.encoder.decode(positionId));
-      }
   }
   function forEachSpreadPositionInMatrix(nbColumns, nbRows, callback) {
       for (let i = 0; i < nbColumns; ++i) {
@@ -47038,85 +47232,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
       return fPayload;
   }
-  /**
-   * Encode (and decode) cell positions { sheetId, col, row }
-   * to a single integer.
-   *
-   * `col` and `row` values are encoded on 21 bits each (max 2^21 = 2_097_152),
-   * An incremental integer id is assigned to each different sheet id, starting at 0.
-   *
-   * e.g.
-   * Given { col: 10, row: 4, sheetId: "abcde" }
-   * we have:
-   *  - row "4" encoded on 21 bits:  000000000000000000100
-   *  - col "10" encoded on 21 bits: 000000000000000001010
-   *  - sheetId: let's say it's the 4th sheetId met, encoded to: 11
-   *
-   * The final encoded value is found by concatenating the 3 bit sequences:
-   *
-   * sheetId: 11
-   * col:       000000000000000001010
-   * row:                            000000000000000000100
-   * =>       11000000000000000001010000000000000000000100
-   *
-   * this binary sequence is the integer 13194160504836
-   */
-  class PositionBitsEncoder {
-      sheetMapping = {};
-      inverseSheetMapping = new Map();
-      constructor() {
-          try {
-              // @ts-ignore
-              o_spreadsheet.__DEBUG__ = o_spreadsheet.__DEBUG__ || {};
-              // @ts-ignore
-              o_spreadsheet.__DEBUG__.decodePosition = this.decode.bind(this);
-              // @ts-ignore
-              o_spreadsheet.__DEBUG__.encodePosition = this.encode.bind(this);
-          }
-          catch (error) { }
-      }
-      /**
-       * Encode a cell position to a single integer.
-       */
-      encode({ sheetId, col, row }) {
-          return (this.encodeSheet(sheetId) << 42n) | (BigInt(col) << 21n) | BigInt(row);
-      }
-      encodeBoundingBox({ sheetId, zone }) {
-          const positions = [];
-          forEachPositionsInZone(zone, (col, row) => {
-              positions.push(this.encode({ sheetId, col, row }));
-          });
-          return positions;
-      }
-      decode(id) {
-          // keep only the last 21 bits by AND-ing the bit sequence with 21 ones
-          const row = Number(id & 2097151n);
-          const col = Number((id >> 21n) & 2097151n);
-          const sheetId = this.decodeSheet(id >> 42n);
-          return { sheetId, col, row };
-      }
-      decodeToBoundingBox(id) {
-          const { sheetId, col, row } = this.decode(id);
-          return { sheetId, zone: { left: col, top: row, right: col, bottom: row } };
-      }
-      encodeSheet(sheetId) {
-          const sheetKey = this.sheetMapping[sheetId];
-          if (sheetKey === undefined) {
-              const newSheetKey = BigInt(Object.keys(this.sheetMapping).length);
-              this.sheetMapping[sheetId] = newSheetKey;
-              this.inverseSheetMapping.set(newSheetKey, sheetId);
-              return newSheetKey;
-          }
-          return sheetKey;
-      }
-      decodeSheet(sheetKey) {
-          const sheetId = this.inverseSheetMapping.get(sheetKey);
-          if (sheetId === undefined) {
-              throw new Error("Sheet id not found");
-          }
-          return sheetId;
-      }
-  }
   function updateEvalContextAndExecute(compiledFormula, compilationParams, sheetId, cellId) {
       compilationParams.evalContext.__originCellXC = lazy(() => {
           if (!cellId) {
@@ -47263,6 +47378,10 @@ stores.inject(MyMetaStore, storeInstance);
                       this.evaluator.updateDependencies(cmd);
                   }
                   break;
+              case "DUPLICATE_SHEET":
+              case "CREATE_SHEET":
+                  this.shouldRebuildDependenciesGraph = true;
+                  break;
               case "EVALUATE_CELLS":
                   this.evaluator.evaluateAllCells();
                   break;
@@ -60047,9 +60166,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "17.2.0-alpha.8";
-  __info__.date = "2024-03-15T11:01:01.388Z";
-  __info__.hash = "11cf381";
+  __info__.version = "17.3.0-alpha.0";
+  __info__.date = "2024-03-20T13:42:32.042Z";
+  __info__.hash = "073e154";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);