@odoo/o-spreadsheet 16.4.8 → 16.4.10

package/dist/o-spreadsheet.iife.js

@@ -1194,7 +1194,17 @@
   function isDateTime(str, locale) {
       return parseDateTime(str, locale) !== null;
   }
+  const CACHE = new Map();
   function parseDateTime(str, locale) {
+      if (!CACHE.has(locale)) {
+          CACHE.set(locale, new Map());
+      }
+      if (!CACHE.get(locale).has(str)) {
+          CACHE.get(locale).set(str, _parseDateTime(str, locale));
+      }
+      return CACHE.get(locale).get(str);
+  }
+  function _parseDateTime(str, locale) {
       str = str.trim();
       let time = null;
       const timeMatch = str.match(timeRegexp);
@@ -3013,8 +3023,9 @@
       }
       get zone() {
           const { left, top, bottom, right } = this._zone;
-          if (right !== undefined && bottom !== undefined)
-              return { left, top, right, bottom };
+          if (right !== undefined && bottom !== undefined) {
+              return this._zone;
+          }
           else if (bottom === undefined && right !== undefined) {
               return { right, top, left, bottom: this.getSheetSize(this.sheetId).numberOfRows - 1 };
           }
@@ -4284,7 +4295,7 @@
   const SORT_TYPES_ORDER = ["number", "string", "boolean", "undefined"];
   function assert(condition, message) {
       if (!condition()) {
-          throw new Error(message);
+          throw new EvaluationError(CellErrorType.GenericError, message);
       }
   }
   // -----------------------------------------------------------------------------
@@ -4929,7 +4940,7 @@
           return textCell((value || "").toString(), localeFormat);
       }
       catch (error) {
-          return errorCell((value || "").toString(), new EvaluationError(CellErrorType.GenericError, error.message || DEFAULT_ERROR_MESSAGE));
+          return errorCell(new EvaluationError(CellErrorType.GenericError, error.message || DEFAULT_ERROR_MESSAGE));
       }
   }
   function textCell(value, localeFormat) {
@@ -4996,7 +5007,7 @@
           formattedValue,
       };
   }
-  function errorCell(content, error) {
+  function errorCell(error) {
       return {
           type: CellValueType.error,
           value: error.errorType,
@@ -13033,6 +13044,35 @@
       isExported: true,
   };
   // -----------------------------------------------------------------------------
+  // INDEX
+  // -----------------------------------------------------------------------------
+  const INDEX = {
+      description: _lt(`Returns the content of a cell, specified by row and column offset.`),
+      args: [
+          arg("reference (any, range)", _lt("The range of cells from which the values are returned.")),
+          arg("row (number)", _lt("The index of the row to be returned from within the reference range of cells.")),
+          arg("column (number)", _lt("The index of the column to be returned from within the reference range of cells.")),
+      ],
+      returns: ["ANY"],
+      computeFormat: function (reference, row, column) {
+          const _row = toNumber(row.value, this.locale);
+          const _column = toNumber(column.value, this.locale);
+          return reference.format[_column - 1][_row - 1];
+      },
+      compute: function (reference, row, column) {
+          const _reference = isMatrix(reference) ? reference : [[reference]];
+          const _row = toNumber(row, this.locale);
+          const _column = toNumber(column, this.locale);
+          assert(() => _column >= 0 &&
+              _column - 1 < _reference.length &&
+              _row >= 0 &&
+              _row - 1 < _reference[0].length, _lt("Index out of range."));
+          assert(() => row !== 0 && column !== 0, _lt("This function can only return a single cell value, not an array. Provide valid row and column indices."));
+          return _reference[_column - 1][_row - 1];
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
   // LOOKUP
   // -----------------------------------------------------------------------------
   const LOOKUP = {
@@ -13230,6 +13270,7 @@
     COLUMN: COLUMN,
     COLUMNS: COLUMNS,
     HLOOKUP: HLOOKUP,
+    INDEX: INDEX,
     LOOKUP: LOOKUP,
     MATCH: MATCH,
     ROW: ROW,
@@ -21801,7 +21842,7 @@
           });
       }
       canUpdateChart(figureId, updateDefinition) {
-          if (figureId !== this.figureId) {
+          if (figureId !== this.figureId || !this.env.model.getters.isChartDefined(figureId)) {
               return;
           }
           const definition = {
@@ -25669,7 +25710,14 @@
               return;
           }
           if (this.state.waitingForMove === true) {
-              this.startMovement(ev);
+              if (!this.env.model.getters.isGridSelectionActive()) {
+                  this._selectElement(index, false);
+              }
+              else {
+                  // FIXME: Consider reintroducing this feature for all type of selection if we find
+                  // a way to have the grid selection follow the other selections evolution
+                  this.startMovement(ev);
+              }
               return;
           }
           if (this.env.model.getters.getEditionMode() === "editing") {
@@ -29095,12 +29143,15 @@
       };
   }
   function xmlEscape(str) {
-      return String(str)
+      return (String(str)
           .replace(/\&/g, "&amp;")
           .replace(/\</g, "&lt;")
           .replace(/\>/g, "&gt;")
           .replace(/\"/g, "&quot;")
-          .replace(/\'/g, "&apos;");
+          .replace(/\'/g, "&apos;")
+          // Delete all ASCII control characters except for TAB (\x09), LF (\x0A) and CR (\x0D)
+          // They are not valid at all in XML 1.0 (even escaped)
+          .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, ""));
   }
   function formatAttributes(attrs) {
       return new XMLString(attrs.map(([key, val]) => `${key}="${xmlEscape(val)}"`).join(" "));
@@ -31818,10 +31869,11 @@
        * Reconstructs the original formula string based on a normalized form and its dependencies
        */
       buildFormulaContent(sheetId, cell, dependencies) {
-          const ranges = dependencies || [...cell.dependencies];
+          const ranges = dependencies || cell.dependencies;
+          let rangeIndex = 0;
           return concat(cell.compiledFormula.tokens.map((token) => {
               if (token.type === "REFERENCE") {
-                  const range = ranges.shift();
+                  const range = ranges[rangeIndex++];
                   return this.getters.getRangeString(range, sheetId);
               }
               return token.value;
@@ -35429,7 +35481,7 @@
           const evaluatedCell = this.getEvaluatedCell(position);
           if (evaluatedCell.type === CellValueType.empty) {
               const cell = this.getters.getCell(position);
-              if (!cell || cell.content === "") {
+              if (!cell || (!cell.isFormula && cell.content === "")) {
                   return undefined;
               }
           }
@@ -35649,7 +35701,7 @@
       constructor(context, getters) {
           this.context = context;
           this.getters = getters;
-          this.compilationParams = buildCompilationParameters(context, getters, (position) => this.computeCell(this.encodePosition(position)));
+          this.compilationParams = buildCompilationParameters(this.context, this.getters, this.computeAndSave.bind(this));
       }
       getEvaluatedCell(position) {
           return (this.evaluatedCells.get(this.encodePosition(position)) ||
@@ -35677,7 +35729,7 @@
           this.formulaDependencies().addDependencies(positionId, dependencies);
       }
       updateCompilationParameters() {
-          this.compilationParams = buildCompilationParameters(this.context, this.getters, (position) => this.computeCell(this.encodePosition(position)));
+          this.compilationParams = buildCompilationParameters(this.context, this.getters, this.computeAndSave.bind(this));
       }
       evaluateCells(positions) {
           const cells = positions.map(this.encodePosition.bind(this));
@@ -35793,15 +35845,21 @@
               this.cellsBeingComputed.delete(cellId);
           }
       }
+      computeAndSave(position) {
+          const positionId = this.encodePosition(position);
+          const evaluatedCell = this.computeCell(positionId);
+          if (!this.evaluatedCells.has(positionId)) {
+              this.setEvaluatedCell(positionId, evaluatedCell);
+          }
+          return evaluatedCell;
+      }
       handleError(e, cell) {
-          if (!(e instanceof Error)) {
-              e = new Error(e);
+          if (!(e instanceof EvaluationError)) {
+              e = new EvaluationError(CellErrorType.GenericError, e.message);
           }
-          const msg = e?.errorType || CellErrorType.GenericError;
-          // apply function name
           const __lastFnCalled = this.compilationParams[2].__lastFnCalled || "";
-          const error = new EvaluationError(msg, e.message.replace("[[FUNCTION_NAME]]", __lastFnCalled), e.logLevel !== undefined ? e.logLevel : CellErrorLevel.error);
-          return errorCell(cell.content, error);
+          e.message = e.message.replace("[[FUNCTION_NAME]]", __lastFnCalled);
+          return errorCell(e);
       }
       computeFormulaCell(cellData) {
           const cellId = cellData.id;
@@ -41693,6 +41751,10 @@
           if (!newRangesXC) {
               return;
           }
+          if (newRangesXC.length === 0) {
+              this.dispatch("REMOVE_CONDITIONAL_FORMAT", { id: cf.id, sheetId });
+              return;
+          }
           this.dispatch("ADD_CONDITIONAL_FORMAT", {
               cf: {
                   id: cf.id,
@@ -43198,6 +43260,7 @@
           "isSingleColSelected",
           "getElementsFromSelection",
           "tryGetActiveSheetId",
+          "isGridSelectionActive",
       ];
       gridSelection = {
           anchor: {
@@ -43407,6 +43470,9 @@
       // ---------------------------------------------------------------------------
       // Getters
       // ---------------------------------------------------------------------------
+      isGridSelectionActive() {
+          return this.selection.isListening(this);
+      }
       getActiveSheet() {
           return this.activeSheet;
       }
@@ -48222,6 +48288,9 @@
               },
           });
       }
+      isListening(owner) {
+          return this.stream.isListening(owner);
+      }
       /**
        * Process a new anchor selection event. If the new anchor is inside
        * the sheet boundaries, the event is pushed to the event stream to
@@ -50692,9 +50761,9 @@
   Object.defineProperty(exports, '__esModule', { value: true });
 
 
-  __info__.version = '16.4.8';
-  __info__.date = '2023-10-03T12:45:33.807Z';
-  __info__.hash = 'c614d64';
+  __info__.version = '16.4.10';
+  __info__.date = '2023-10-19T14:23:58.054Z';
+  __info__.hash = 'bc7546f';
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);