@odoo/o-spreadsheet 16.4.13 → 16.4.15

package/dist/o-spreadsheet.iife.js

@@ -669,8 +669,7 @@
    *
    * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Character_Classes
    */
-  const whiteSpaceCharacters = [
-      " ",
+  const whiteSpaceSpecialCharacters = [
       "\t",
       "\f",
       "\v",
@@ -685,8 +684,7 @@
       String.fromCharCode(parseInt("3000", 16)),
       String.fromCharCode(parseInt("feff", 16)),
   ];
-  const whiteSpaceRegexp = new RegExp(whiteSpaceCharacters.join("|"), "g");
-  const newLineRegex = /\r\n|\r|\n/g;
+  const whiteSpaceRegexp = new RegExp(whiteSpaceSpecialCharacters.join("|") + "|(\r\n|\r|\n)", "g");
   /**
    * Replace all the special spaces in a string (non-breaking, tabs, ...) by normal spaces, and all the
    * different newlines types by \n.
@@ -694,9 +692,9 @@
   function replaceSpecialSpaces(text) {
       if (!text)
           return "";
-      text = text.replace(whiteSpaceRegexp, " ");
-      text = text.replace(newLineRegex, NEWLINE);
-      return text;
+      if (!whiteSpaceRegexp.test(text))
+          return text;
+      return text.replace(whiteSpaceRegexp, (match, newLine) => (newLine ? NEWLINE : " "));
   }
   /**
    * Determine if the numbers are consecutive.
@@ -4266,6 +4264,7 @@
       CommandResult[CommandResult["NoActiveSheet"] = 94] = "NoActiveSheet";
       CommandResult[CommandResult["InvalidLocale"] = 95] = "InvalidLocale";
       CommandResult[CommandResult["AlreadyInPaintingFormatMode"] = 96] = "AlreadyInPaintingFormatMode";
+      CommandResult[CommandResult["NoChanges"] = 97] = "NoChanges";
   })(exports.CommandResult || (exports.CommandResult = {}));
 
   const borderStyles = ["thin", "medium", "thick", "dashed", "dotted"];
@@ -4355,12 +4354,12 @@
       }
   }
   /** Normalize string by setting it to lowercase and replacing accent letters with plain letters */
-  function normalizeString(str) {
+  const normalizeString = memoize(function normalizeString(str) {
       return str
           .toLowerCase()
           .normalize("NFD")
           .replace(/[\u0300-\u036f]/g, "");
-  }
+  });
   /**
    * Normalize a value.
    * If the cell value is a string, this will set it to lowercase and replacing accent letters with plain letters
@@ -14171,7 +14170,7 @@
       return result;
   }
   function tokenizeDebugger(chars) {
-      if (chars.current() === "?") {
+      if (chars.current === "?") {
           chars.shift();
           return { type: "DEBUGGER", value: "?" };
       }
@@ -14182,7 +14181,7 @@
       ")": "RIGHT_PAREN",
   };
   function tokenizeMisc(chars) {
-      if (chars.current() in misc) {
+      if (chars.current in misc) {
           const value = chars.shift();
           const type = misc[value];
           return { type, value };
@@ -14190,7 +14189,7 @@
       return null;
   }
   function tokenizeArgsSeparator(chars, locale) {
-      if (chars.current() === locale.formulaArgSeparator) {
+      if (chars.current === locale.formulaArgSeparator) {
           const value = chars.shift();
           const type = "ARG_SEPARATOR";
           return { type, value };
@@ -14215,14 +14214,13 @@
       return null;
   }
   function tokenizeString(chars) {
-      if (chars.current() === '"') {
+      if (chars.current === '"') {
           const startChar = chars.shift();
           let letters = startChar;
-          while (chars.current() &&
-              (chars.current() !== startChar || letters[letters.length - 1] === "\\")) {
+          while (chars.current && (chars.current !== startChar || letters[letters.length - 1] === "\\")) {
               letters += chars.shift();
           }
-          if (chars.current() === '"') {
+          if (chars.current === '"') {
               letters += chars.shift();
           }
           return {
@@ -14249,14 +14247,14 @@
       let result = "";
       // there are two main cases to manage: either something which starts with
       // a ', like 'Sheet 2'A2, or a word-like element.
-      if (chars.current() === "'") {
+      if (chars.current === "'") {
           let lastChar = chars.shift();
           result += lastChar;
-          while (chars.current()) {
+          while (chars.current) {
               lastChar = chars.shift();
               result += lastChar;
               if (lastChar === "'") {
-                  if (chars.current() && chars.current() === "'") {
+                  if (chars.current && chars.current === "'") {
                       lastChar = chars.shift();
                       result += lastChar;
                   }
@@ -14272,7 +14270,7 @@
               };
           }
       }
-      while (chars.current() && separatorRegexp.test(chars.current())) {
+      while (chars.current && separatorRegexp.test(chars.current)) {
           result += chars.shift();
       }
       if (result.length) {
@@ -14287,14 +14285,14 @@
   }
   function tokenizeSpace(chars) {
       let length = 0;
-      while (chars.current() === NEWLINE) {
+      while (chars.current === NEWLINE) {
           length++;
           chars.shift();
       }
       if (length) {
           return { type: "SPACE", value: NEWLINE.repeat(length) };
       }
-      while (chars.current() === " ") {
+      while (chars.current === " ") {
           length++;
           chars.shift();
       }
@@ -14313,17 +14311,20 @@
   class TokenizingChars {
       text;
       currentIndex = 0;
+      current;
       constructor(text) {
           this.text = text;
-      }
-      current() {
-          return this.text[this.currentIndex];
+          this.current = text[0];
       }
       shift() {
-          return this.text[this.currentIndex++];
+          const current = this.current;
+          const next = this.text[++this.currentIndex];
+          this.current = next;
+          return current;
       }
       advanceBy(length) {
           this.currentIndex += length;
+          this.current = this.text[this.currentIndex];
       }
       isOver() {
           return this.currentIndex >= this.text.length;
@@ -18566,6 +18567,17 @@
   //------------------------------------------------------------------------------
   const IS_ONLY_ONE_RANGE = (env) => {
       return env.model.getters.getSelectedZones().length === 1;
+  };
+  const CAN_INSERT_HEADER = (env, dimension) => {
+      if (!IS_ONLY_ONE_RANGE(env)) {
+          return false;
+      }
+      const activeHeaders = dimension === "COL" ? env.model.getters.getActiveCols() : env.model.getters.getActiveRows();
+      const ortogonalActiveHeaders = dimension === "COL" ? env.model.getters.getActiveRows() : env.model.getters.getActiveCols();
+      const sheetId = env.model.getters.getActiveSheetId();
+      const zone = env.model.getters.getSelectedZone();
+      const allSheetSelected = isEqual(zone, env.model.getters.getSheetZone(sheetId));
+      return isConsecutive(activeHeaders) && (ortogonalActiveHeaders.size === 0 || allSheetSelected);
   };
 
   const undo = {
@@ -18755,9 +18767,7 @@
           const number = getRowsNumber(env);
           return number === 1 ? _lt("Insert row") : _lt("Insert %s rows", number.toString());
       },
-      isVisible: (env) => isConsecutive(env.model.getters.getActiveRows()) &&
-          IS_ONLY_ONE_RANGE(env) &&
-          env.model.getters.getActiveCols().size === 0,
+      isVisible: (env) => CAN_INSERT_HEADER(env, "ROW"),
       icon: "o-spreadsheet-Icon.INSERT_ROW",
   };
   const rowInsertRowBefore = {
@@ -18766,9 +18776,7 @@
           return number === 1 ? _lt("Insert row above") : _lt("Insert %s rows above", number.toString());
       },
       execute: INSERT_ROWS_BEFORE_ACTION,
-      isVisible: (env) => isConsecutive(env.model.getters.getActiveRows()) &&
-          IS_ONLY_ONE_RANGE(env) &&
-          env.model.getters.getActiveCols().size === 0,
+      isVisible: (env) => CAN_INSERT_HEADER(env, "ROW"),
       icon: "o-spreadsheet-Icon.INSERT_ROW_BEFORE",
   };
   const topBarInsertRowsBefore = {
@@ -18799,9 +18807,7 @@
           const number = getRowsNumber(env);
           return number === 1 ? _lt("Insert row below") : _lt("Insert %s rows below", number.toString());
       },
-      isVisible: (env) => isConsecutive(env.model.getters.getActiveRows()) &&
-          IS_ONLY_ONE_RANGE(env) &&
-          env.model.getters.getActiveCols().size === 0,
+      isVisible: (env) => CAN_INSERT_HEADER(env, "ROW"),
       icon: "o-spreadsheet-Icon.INSERT_ROW_AFTER",
   };
   const topBarInsertRowsAfter = {
@@ -18819,9 +18825,7 @@
           const number = getColumnsNumber(env);
           return number === 1 ? _lt("Insert column") : _lt("Insert %s columns", number.toString());
       },
-      isVisible: (env) => isConsecutive(env.model.getters.getActiveCols()) &&
-          IS_ONLY_ONE_RANGE(env) &&
-          env.model.getters.getActiveRows().size === 0,
+      isVisible: (env) => CAN_INSERT_HEADER(env, "COL"),
       icon: "o-spreadsheet-Icon.INSERT_COL",
   };
   const colInsertColsBefore = {
@@ -18832,9 +18836,7 @@
               : _lt("Insert %s columns left", number.toString());
       },
       execute: INSERT_COLUMNS_BEFORE_ACTION,
-      isVisible: (env) => isConsecutive(env.model.getters.getActiveCols()) &&
-          IS_ONLY_ONE_RANGE(env) &&
-          env.model.getters.getActiveRows().size === 0,
+      isVisible: (env) => CAN_INSERT_HEADER(env, "COL"),
       icon: "o-spreadsheet-Icon.INSERT_COL_BEFORE",
   };
   const topBarInsertColsBefore = {
@@ -18867,9 +18869,7 @@
               : _lt("Insert %s columns right", number.toString());
       },
       execute: INSERT_COLUMNS_AFTER_ACTION,
-      isVisible: (env) => isConsecutive(env.model.getters.getActiveCols()) &&
-          IS_ONLY_ONE_RANGE(env) &&
-          env.model.getters.getActiveRows().size === 0,
+      isVisible: (env) => CAN_INSERT_HEADER(env, "COL"),
       icon: "o-spreadsheet-Icon.INSERT_COL_AFTER",
   };
   const topBarInsertColsAfter = {
@@ -22827,7 +22827,7 @@
       }
       .o-input-count {
         width: fit-content;
-        padding: 4 0 4 4;
+        padding: 4px 0 4px 4px;
       }
     }
   }
@@ -31168,6 +31168,14 @@
       // ---------------------------------------------------------------------------
       // Command Handling
       // ---------------------------------------------------------------------------
+      allowDispatch(cmd) {
+          switch (cmd.type) {
+              case "SET_BORDER":
+                  return this.checkBordersUnchanged(cmd);
+              default:
+                  return 0 /* CommandResult.Success */;
+          }
+      }
       handle(cmd) {
           switch (cmd.type) {
               case "ADD_MERGE":
@@ -31587,6 +31595,14 @@
               this.setBorders(sheetId, [{ ...zone, left: right }], "right", bordersTopLeft.right);
           }
       }
+      checkBordersUnchanged(cmd) {
+          const currentBorder = this.getCellBorder(cmd);
+          const areAllNewBordersUndefined = !cmd.border?.bottom && !cmd.border?.left && !cmd.border?.right && !cmd.border?.top;
+          if ((!currentBorder && areAllNewBordersUndefined) || deepEquals(currentBorder, cmd.border)) {
+              return 97 /* CommandResult.NoChanges */;
+          }
+          return 0 /* CommandResult.Success */;
+      }
       // ---------------------------------------------------------------------------
       // Import/Export
       // ---------------------------------------------------------------------------
@@ -31694,8 +31710,9 @@
       allowDispatch(cmd) {
           switch (cmd.type) {
               case "UPDATE_CELL":
+                  return this.checkCellOutOfSheet(cmd);
               case "CLEAR_CELL":
-                  return this.checkCellOutOfSheet(cmd.sheetId, cmd.col, cmd.row);
+                  return this.checkValidations(cmd, this.chainValidations(this.checkCellOutOfSheet, this.checkUselessClearCell));
               default:
                   return 0 /* CommandResult.Success */;
           }
@@ -31854,14 +31871,9 @@
        */
       getCellById(cellId) {
           // this must be as fast as possible
-          for (const sheetId in this.cells) {
-              const sheet = this.cells[sheetId];
-              const cell = sheet[cellId];
-              if (cell) {
-                  return cell;
-              }
-          }
-          return undefined;
+          const position = this.getters.getCellPosition(cellId);
+          const sheet = this.cells[position.sheetId];
+          return sheet[cellId];
       }
       /*
        * Reconstructs the original formula string based on a normalized form and its dependencies
@@ -32087,13 +32099,23 @@
               dependencies: [],
           };
       }
-      checkCellOutOfSheet(sheetId, col, row) {
+      checkCellOutOfSheet(cmd) {
+          const { sheetId, col, row } = cmd;
           const sheet = this.getters.tryGetSheet(sheetId);
           if (!sheet)
               return 28 /* CommandResult.InvalidSheetId */;
           const sheetZone = this.getters.getSheetZone(sheetId);
           return isInside(col, row, sheetZone) ? 0 /* CommandResult.Success */ : 19 /* CommandResult.TargetOutOfSheet */;
       }
+      checkUselessClearCell(cmd) {
+          const cell = this.getters.getCell(cmd);
+          if (!cell)
+              return 97 /* CommandResult.NoChanges */;
+          if (!cell.content && !cell.style && !cell.format) {
+              return 97 /* CommandResult.NoChanges */;
+          }
+          return 0 /* CommandResult.Success */;
+      }
   }
   class FormulaCellWithDependencies {
       id;
@@ -33074,6 +33096,13 @@
       }
       onDeleteColumnsRows(cmd) {
           for (const table of this.getFilterTables(cmd.sheetId)) {
+              // Remove the filter tables whose data filter headers are in the removed rows.
+              if (cmd.dimension === "ROW" && cmd.elements.includes(table.zone.top)) {
+                  const tables = { ...this.tables[cmd.sheetId] };
+                  delete tables[table.id];
+                  this.history.update("tables", cmd.sheetId, tables);
+                  continue;
+              }
               const zone = reduceZoneOnDeletion(table.zone, cmd.dimension === "COL" ? "left" : "top", cmd.elements);
               if (!zone) {
                   const tables = { ...this.tables[cmd.sheetId] };
@@ -35155,10 +35184,13 @@
           // begin with the end.
           rows.sort((a, b) => b - a);
           for (let group of groupConsecutive(rows)) {
+              // indexes are sorted in the descending order
+              const from = group[group.length - 1];
+              const to = group[0];
               // Move the cells.
-              this.moveCellOnRowsDeletion(sheet, group[group.length - 1], group[0]);
-              // Effectively delete the element and recompute the left-right/top-bottom.
-              group.map((row) => this.updateRowsStructureOnDeletion(row, sheet));
+              this.moveCellOnRowsDeletion(sheet, from, to);
+              // Effectively delete the rows
+              this.updateRowsStructureOnDeletion(sheet, from, to);
           }
           const count = rows.filter((row) => row < sheet.panes.ySplit).length;
           if (count) {
@@ -35180,8 +35212,6 @@
           this.addEmptyRows(sheet, quantity);
           // Move the cells.
           this.moveCellsOnAddition(sheet, index, quantity, "rows");
-          // Recompute the left-right/top-bottom.
-          this.updateRowsStructureOnAddition(sheet, row, quantity);
           if (index < sheet.panes.ySplit) {
               this.setPaneDivisions(sheet.id, sheet.panes.ySplit + quantity, "ROW");
           }
@@ -35282,35 +35312,20 @@
               }
           }
       }
-      updateRowsStructureOnDeletion(index, sheet) {
+      updateRowsStructureOnDeletion(sheet, deleteFromRow, deleteToRow) {
           const rows = [];
-          const cellsQueue = sheet.rows.map((row) => row.cells);
+          const cellsQueue = sheet.rows.map((row) => row.cells).reverse();
           for (let i in sheet.rows) {
-              if (Number(i) === index) {
+              const row = Number(i);
+              if (row >= deleteFromRow && row <= deleteToRow) {
                   continue;
               }
               rows.push({
-                  cells: cellsQueue.shift(),
+                  cells: cellsQueue.pop(),
               });
           }
           this.history.update("sheets", sheet.id, "rows", rows);
       }
-      /**
-       * Update the rows of the sheet after an addition:
-       * - Rename the rows
-       *
-       * @param sheet Sheet on which the deletion occurs
-       * @param addedRow Index of the added row
-       * @param rowsToAdd Number of the rows to add
-       */
-      updateRowsStructureOnAddition(sheet, addedRow, rowsToAdd) {
-          const rows = [];
-          const cellsQueue = sheet.rows.map((row) => row.cells);
-          sheet.rows.forEach(() => rows.push({
-              cells: cellsQueue.shift(),
-          }));
-          this.history.update("sheets", sheet.id, "rows", rows);
-      }
       /**
        * Add empty rows at the end of the rows
        *
@@ -35426,6 +35441,7 @@
       getters;
       computeCell;
       evalContext;
+      rangeCache = {};
       constructor(context, getters, computeCell) {
           this.getters = getters;
           this.computeCell = computeCell;
@@ -35511,25 +35527,32 @@
           if (!_zone) {
               return { value: [[]], format: [[]] };
           }
+          const { top, left, bottom, right } = zone;
+          const cacheKey = `${sheetId}-${top}-${left}-${bottom}-${right}`;
+          if (cacheKey in this.rangeCache) {
+              return this.rangeCache[cacheKey];
+          }
           const height = _zone.bottom - _zone.top + 1;
           const width = _zone.right - _zone.left + 1;
-          const value = Array.from({ length: width }, () => Array.from({ length: height }));
-          const format = Array.from({ length: width }, () => Array.from({ length: height }));
+          const value = new Array(width);
+          const format = new Array(width);
           // Performance issue: nested loop is faster than a map here
           for (let col = _zone.left; col <= _zone.right; col++) {
+              const colIndex = col - _zone.left;
+              value[colIndex] = new Array(height);
+              format[colIndex] = new Array(height);
               for (let row = _zone.top; row <= _zone.bottom; row++) {
-                  const evaluatedCell = this.getEvaluatedCellIfNotEmpty({ sheetId: sheetId, col, row });
-                  if (evaluatedCell) {
-                      const colIndex = col - _zone.left;
-                      const rowIndex = row - _zone.top;
-                      value[colIndex][rowIndex] = evaluatedCell.value;
-                      if (evaluatedCell.format !== undefined) {
-                          format[colIndex][rowIndex] = evaluatedCell.format;
-                      }
+                  const evaluatedCell = this.getEvaluatedCellIfNotEmpty({ sheetId, col, row });
+                  const rowIndex = row - _zone.top;
+                  value[colIndex][rowIndex] = evaluatedCell?.value;
+                  if (evaluatedCell?.format !== undefined) {
+                      format[colIndex][rowIndex] = evaluatedCell.format;
                   }
               }
           }
-          return { value, format };
+          const result = { value, format };
+          this.rangeCache[cacheKey] = result;
+          return result;
       }
   }
 
@@ -35727,6 +35750,7 @@
           this.formulaDependencies().addDependencies(positionId, dependencies);
       }
       updateCompilationParameters() {
+          // rebuild the compilation parameters (with a clean cache)
           this.compilationParams = buildCompilationParameters(this.context, this.getters, this.computeAndSave.bind(this));
       }
       evaluateCells(positions) {
@@ -35770,6 +35794,15 @@
           this.evaluatedCells = new Map();
           this.evaluate(this.getAllCells());
       }
+      evaluateFormula(sheetId, formulaString) {
+          const compiledFormula = compile(formulaString);
+          const ranges = [];
+          for (let xc of compiledFormula.dependencies) {
+              ranges.push(this.getters.getRangeFromSheetXC(sheetId, xc));
+          }
+          this.updateCompilationParameters();
+          return compiledFormula.execute(ranges, ...this.compilationParams).value;
+      }
       getAllCells() {
           const positionIds = new JetSet();
           for (const sheetId of this.getters.getSheetIds()) {
@@ -35796,6 +35829,7 @@
           this.nextPositionsToUpdate = cells;
           let currentIteration = 0;
           while (this.nextPositionsToUpdate.size && currentIteration++ < MAX_ITERATION) {
+              this.updateCompilationParameters();
               const positionIds = Array.from(this.nextPositionsToUpdate);
               this.nextPositionsToUpdate.clear();
               for (let i = 0; i < positionIds.length; ++i) {
@@ -36180,7 +36214,6 @@
   // of other cells depending on it, at the next iteration.
   //#endregion
   class EvaluationPlugin extends UIPlugin {
-      config;
       static getters = [
           "evaluateFormula",
           "getRangeFormattedValues",
@@ -36192,12 +36225,9 @@
       ];
       shouldRebuildDependenciesGraph = true;
       evaluator;
-      compilationParams;
       positionsToUpdate = [];
       constructor(config) {
           super(config);
-          this.config = config;
-          this.compilationParams = this.getCompilationParameters();
           this.evaluator = new Evaluator(config.custom, this.getters);
       }
       // ---------------------------------------------------------------------------
@@ -36222,10 +36252,6 @@
               case "EVALUATE_CELLS":
                   this.evaluator.evaluateAllCells();
                   break;
-              case "UPDATE_LOCALE":
-                  this.compilationParams = this.getCompilationParameters();
-                  this.evaluator.updateCompilationParameters();
-                  break;
           }
       }
       finalize() {
@@ -36243,12 +36269,7 @@
       // Getters
       // ---------------------------------------------------------------------------
       evaluateFormula(sheetId, formulaString) {
-          const compiledFormula = compile(formulaString);
-          const ranges = [];
-          for (let xc of compiledFormula.dependencies) {
-              ranges.push(this.getters.getRangeFromSheetXC(sheetId, xc));
-          }
-          return compiledFormula.execute(ranges, ...this.compilationParams).value;
+          return this.evaluator.evaluateFormula(sheetId, formulaString);
       }
       /**
        * Return the value of each cell in the range as they are displayed in the grid.
@@ -36347,9 +36368,6 @@
           }
           return undefined;
       }
-      getCompilationParameters() {
-          return buildCompilationParameters(this.config.custom, this.getters, (position) => this.evaluator.getEvaluatedCell(position));
-      }
   }
   function isBadExpression(formula) {
       try {
@@ -36522,22 +36540,20 @@
               invalidateCFEvaluationCommands.has(cmd.type) ||
               cmd.type === "EVALUATE_CELLS" ||
               cmd.type === "UPDATE_CELL") {
-              if (cmd.type !== "UNDO" && cmd.type !== "REDO") {
-                  for (const chartId in this.charts) {
-                      this.history.update("charts", chartId, undefined);
-                  }
+              for (const chartId in this.charts) {
+                  this.charts[chartId] = undefined;
               }
           }
           switch (cmd.type) {
               case "UPDATE_CHART":
               case "CREATE_CHART":
               case "DELETE_FIGURE":
-                  this.history.update("charts", cmd.id, undefined);
+                  this.charts[cmd.id] = undefined;
                   break;
               case "DELETE_SHEET":
                   for (let chartId in this.charts) {
                       if (!this.getters.isChartDefined(chartId)) {
-                          this.history.update("charts", chartId, undefined);
+                          this.charts[chartId] = undefined;
                       }
                   }
                   break;
@@ -36549,7 +36565,7 @@
               if (!chart) {
                   throw new Error(`No chart for the given id: ${figureId}`);
               }
-              this.history.update("charts", figureId, this.createRuntimeChart(chart));
+              this.charts[figureId] = this.createRuntimeChart(chart);
           }
           return this.charts[figureId];
       }
@@ -42068,8 +42084,8 @@
                   this.lastPasteState = this.state;
                   if (this.paintFormatStatus === "oneOff") {
                       this.paintFormatStatus = "inactive";
-                      this.status = "invisible";
                   }
+                  this.status = "invisible";
                   break;
               case "CLEAN_CLIPBOARD_HIGHLIGHT":
                   this.status = "invisible";
@@ -43013,6 +43029,8 @@
               case "EVALUATE_CELLS":
               case "ACTIVATE_SHEET":
               case "REMOVE_FILTER_TABLE":
+              case "ADD_COLUMNS_ROWS":
+              case "REMOVE_COLUMNS_ROWS":
                   this.isEvaluationDirty = true;
                   break;
               case "START":
@@ -47884,9 +47902,9 @@
    * Apply the changes of the given HistoryChange to the state
    */
   function applyChange(change, target) {
-      let val = change.root;
-      let key = change.path[change.path.length - 1];
-      for (let pathIndex = 0; pathIndex < change.path.slice(0, -1).length; pathIndex++) {
+      let val = change.path[0];
+      const key = change.path[change.path.length - 1];
+      for (let pathIndex = 1; pathIndex < change.path.slice(0, -1).length; pathIndex++) {
           const p = change.path[pathIndex];
           if (val[p] === undefined) {
               const nextPath = change.path[pathIndex + 1];
@@ -48567,13 +48585,14 @@
       }
       addChange(...args) {
           const val = args.pop();
-          const [root, ...path] = args;
+          const root = args[0];
           let value = root;
-          let key = path[path.length - 1];
-          for (let pathIndex = 0; pathIndex <= path.length - 2; pathIndex++) {
-              const p = path[pathIndex];
+          let key = args[args.length - 1];
+          const pathLength = args.length - 2;
+          for (let pathIndex = 1; pathIndex <= pathLength; pathIndex++) {
+              const p = args[pathIndex];
               if (value[p] === undefined) {
-                  const nextPath = path[pathIndex + 1];
+                  const nextPath = args[pathIndex + 1];
                   value[p] = createEmptyStructure(nextPath);
               }
               value = value[p];
@@ -48582,8 +48601,7 @@
               return;
           }
           this.changes.push({
-              root,
-              path,
+              path: args,
               before: value[key],
               after: val,
           });
@@ -50433,19 +50451,22 @@
        * Check if the given command is allowed by all the plugins and the history.
        */
       checkDispatchAllowed(command) {
-          if (isCoreCommand(command)) {
-              return this.checkDispatchAllowedCoreCommand(command);
+          const results = isCoreCommand(command)
+              ? this.checkDispatchAllowedCoreCommand(command)
+              : this.checkDispatchAllowedLocalCommand(command);
+          if (results.some((r) => r !== 0 /* CommandResult.Success */)) {
+              return new DispatchResult(results.flat());
           }
-          return this.checkDispatchAllowedLocalCommand(command);
+          return DispatchResult.Success;
       }
       checkDispatchAllowedCoreCommand(command) {
           const results = this.corePlugins.map((handler) => handler.allowDispatch(command));
           results.push(this.range.allowDispatch(command));
-          return new DispatchResult(results.flat());
+          return results;
       }
       checkDispatchAllowedLocalCommand(command) {
           const results = this.uiHandlers.map((handler) => handler.allowDispatch(command));
-          return new DispatchResult(results.flat());
+          return results;
       }
       finalize() {
           this.status = 3 /* Status.Finalizing */;
@@ -50771,9 +50792,9 @@
   Object.defineProperty(exports, '__esModule', { value: true });
 
 
-  __info__.version = '16.4.13';
-  __info__.date = '2023-11-03T12:21:08.124Z';
-  __info__.hash = '001985e';
+  __info__.version = '16.4.15';
+  __info__.date = '2023-11-24T13:12:26.608Z';
+  __info__.hash = '141943d';
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);