handsontable 14.4.0 → 14.5.0-next-ede811d-20240717

package/plugins/mergeCells/cellCoords.mjs

@@ -1,7 +1,12 @@
 import "core-js/modules/es.error.cause.js";
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
 import { toSingleLine } from "../../helpers/templateLiteralTag.mjs";
 /**
  * The `MergedCellCoords` class represents a single merged cell.
@@ -9,6 +14,7 @@ import { toSingleLine } from "../../helpers/templateLiteralTag.mjs";
  * @private
  * @class MergedCellCoords
  */
+var _cellRange = /*#__PURE__*/new WeakMap();
 class MergedCellCoords {
   constructor(row, column, rowspan, colspan, cellCoordsFactory, cellRangeFactory) {
     /**
@@ -53,6 +59,12 @@ class MergedCellCoords {
      * @type {Function}
      */
     _defineProperty(this, "cellRangeFactory", void 0);
+    /**
+     * The cached range coordinates of the merged cell.
+     *
+     * @type {CellRange}
+     */
+    _classPrivateFieldInitSpec(this, _cellRange, null);
     this.row = row;
     this.col = column;
     this.rowspan = rowspan;
@@ -64,78 +76,117 @@ class MergedCellCoords {
   /**
    * Get a warning message for when the declared merged cell data contains negative values.
    *
-   * @param {object} newMergedCell Object containg information about the merged cells that was about to be added.
+   * @param {{ row: number, col: number, rowspan: number, colspan: number }} mergedCell Object containing information
+   * about the merged cells that was about to be added.
    * @returns {string}
    */
-  static NEGATIVE_VALUES_WARNING(newMergedCell) {
-    return toSingleLine`The merged cell declared with {row: ${newMergedCell.row}, col: ${newMergedCell.col},\x20
-      rowspan: ${newMergedCell.rowspan}, colspan: ${newMergedCell.colspan}} contains negative values, which is\x20
+  static NEGATIVE_VALUES_WARNING(_ref) {
+    let {
+      row,
+      col,
+      rowspan,
+      colspan
+    } = _ref;
+    return toSingleLine`The merged cell declared with {row: ${row}, col: ${col},\x20
+      rowspan: ${rowspan}, colspan: ${colspan}} contains negative values, which is\x20
       not supported. It will not be added to the collection.`;
   }
 
   /**
    * Get a warning message for when the declared merged cell data contains values exceeding the table limits.
    *
-   * @param {object} newMergedCell Object containg information about the merged cells that was about to be added.
+   * @param {{ row: number, col: number, rowspan: number, colspan: number }} mergedCell Object containing information
+   * about the merged cells that was about to be added.
    * @returns {string}
    */
-  static IS_OUT_OF_BOUNDS_WARNING(newMergedCell) {
-    return toSingleLine`The merged cell declared at [${newMergedCell.row}, ${newMergedCell.col}] is positioned\x20
+  static IS_OUT_OF_BOUNDS_WARNING(_ref2) {
+    let {
+      row,
+      col
+    } = _ref2;
+    return toSingleLine`The merged cell declared at [${row}, ${col}] is positioned\x20
       (or positioned partially) outside of the table range. It was not added to the table, please fix your setup.`;
   }
 
   /**
    * Get a warning message for when the declared merged cell data represents a single cell.
    *
-   * @param {object} newMergedCell Object containg information about the merged cells that was about to be added.
+   * @param {{ row: number, col: number, rowspan: number, colspan: number }} mergedCell Object containing information
+   * about the merged cells that was about to be added.
    * @returns {string}
    */
-  static IS_SINGLE_CELL(newMergedCell) {
-    return toSingleLine`The merged cell declared at [${newMergedCell.row}, ${newMergedCell.col}] has both "rowspan"\x20
+  static IS_SINGLE_CELL(_ref3) {
+    let {
+      row,
+      col
+    } = _ref3;
+    return toSingleLine`The merged cell declared at [${row}, ${col}] has both "rowspan"\x20
       and "colspan" declared as "1", which makes it a single cell. It cannot be added to the collection.`;
   }
 
   /**
    * Get a warning message for when the declared merged cell data contains "colspan" or "rowspan", that equals 0.
    *
-   * @param {object} newMergedCell Object containg information about the merged cells that was about to be added.
+   * @param {{ row: number, col: number, rowspan: number, colspan: number }} mergedCell Object containing information
+   * about the merged cells that was about to be added.
    * @returns {string}
    */
-  static ZERO_SPAN_WARNING(newMergedCell) {
-    return toSingleLine`The merged cell declared at [${newMergedCell.row}, ${newMergedCell.col}] has "rowspan"\x20
+  static ZERO_SPAN_WARNING(_ref4) {
+    let {
+      row,
+      col
+    } = _ref4;
+    return toSingleLine`The merged cell declared at [${row}, ${col}] has "rowspan"\x20
       or "colspan" declared as "0", which is not supported. It cannot be added to the collection.`;
   }
 
   /**
    * Check whether the values provided for a merged cell contain any negative values.
    *
-   * @param {object} mergedCellInfo Object containing the `row`, `col`, `rowspan` and `colspan` properties.
+   * @param {{ row: number, col: number, rowspan: number, colspan: number }} mergedCell Object containing information
+   * about the merged cells that was about to be added.
    * @returns {boolean}
    */
-  static containsNegativeValues(mergedCellInfo) {
-    return mergedCellInfo.row < 0 || mergedCellInfo.col < 0 || mergedCellInfo.rowspan < 0 || mergedCellInfo.colspan < 0;
+  static containsNegativeValues(_ref5) {
+    let {
+      row,
+      col,
+      rowspan,
+      colspan
+    } = _ref5;
+    return row < 0 || col < 0 || rowspan < 0 || colspan < 0;
   }
 
   /**
    * Check whether the provided merged cell information object represents a single cell.
    *
    * @private
-   * @param {object} mergedCellInfo An object with `row`, `col`, `rowspan` and `colspan` properties.
+   * @param {{ row: number, col: number, rowspan: number, colspan: number }} mergedCell Object containing information
+   * about the merged cells that was about to be added.
    * @returns {boolean}
    */
-  static isSingleCell(mergedCellInfo) {
-    return mergedCellInfo.colspan === 1 && mergedCellInfo.rowspan === 1;
+  static isSingleCell(_ref6) {
+    let {
+      rowspan,
+      colspan
+    } = _ref6;
+    return colspan === 1 && rowspan === 1;
   }
 
   /**
    * Check whether the provided merged cell information object contains a rowspan or colspan of 0.
    *
    * @private
-   * @param {object} mergedCellInfo An object with `row`, `col`, `rowspan` and `colspan` properties.
+   * @param {{ row: number, col: number, rowspan: number, colspan: number }} mergedCell Object containing information
+   * about the merged cells that was about to be added.
    * @returns {boolean}
    */
-  static containsZeroSpan(mergedCellInfo) {
-    return mergedCellInfo.colspan === 0 || mergedCellInfo.rowspan === 0;
+  static containsZeroSpan(_ref7) {
+    let {
+      rowspan,
+      colspan
+    } = _ref7;
+    return colspan === 0 || rowspan === 0;
   }
 
   /**
@@ -174,6 +225,7 @@ class MergedCellCoords {
     if (this.col + this.colspan > totalColumns - 1) {
       this.colspan = totalColumns - this.col;
     }
+    _classPrivateFieldSet(_cellRange, this, null);
   }
 
   /**
@@ -238,6 +290,7 @@ class MergedCellCoords {
       // removing the whole merge
       if (changeStart <= mergeStart && changeEnd >= mergeEnd) {
         this.removed = true;
+        _classPrivateFieldSet(_cellRange, this, null);
         return false;
 
         // removing the merge partially, including the beginning
@@ -257,6 +310,7 @@ class MergedCellCoords {
         this[span] -= removedPart;
       }
     }
+    _classPrivateFieldSet(_cellRange, this, null);
     return true;
   }
 
@@ -307,7 +361,10 @@ class MergedCellCoords {
    * @returns {CellRange}
    */
   getRange() {
-    return this.cellRangeFactory(this.cellCoordsFactory(this.row, this.col), this.cellCoordsFactory(this.row, this.col), this.cellCoordsFactory(this.getLastRow(), this.getLastColumn()));
+    if (!_classPrivateFieldGet(_cellRange, this)) {
+      _classPrivateFieldSet(_cellRange, this, this.cellRangeFactory(this.cellCoordsFactory(this.row, this.col), this.cellCoordsFactory(this.row, this.col), this.cellCoordsFactory(this.getLastRow(), this.getLastColumn())));
+    }
+    return _classPrivateFieldGet(_cellRange, this);
   }
 }
 export default MergedCellCoords;

package/plugins/mergeCells/cellsCollection.js

@@ -15,12 +15,11 @@ var _cellCoords = _interopRequireDefault(require("./cellCoords"));
 var _number = require("../../helpers/number");
 var _console = require("../../helpers/console");
 var _array = require("../../helpers/array");
-var _utils = require("./utils");
 var _templateLiteralTag = require("../../helpers/templateLiteralTag");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
-function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
@@ -51,9 +50,15 @@ class MergedCellsCollection {
     /**
      * Array of merged cells.
      *
-     * @type {Array}
+     * @type {MergedCellCoords[]}
      */
     _defineProperty(this, "mergedCells", []);
+    /**
+     * Matrix of cells (row, col) that points to the instances of the MergedCellCoords objects.
+     *
+     * @type {Array}
+     */
+    _defineProperty(this, "mergedCellsMatrix", new Map());
     /**
      * The Handsontable instance.
      *
@@ -67,11 +72,16 @@ class MergedCellsCollection {
   /**
    * Get a warning message for when the declared merged cell data overlaps already existing merged cells.
    *
-   * @param {object} newMergedCell Object containg information about the merged cells that was about to be added.
+   * @param {{ row: number, col: number, rowspan: number, colspan: number }} mergedCell Object containing information
+   * about the merged cells that was about to be added.
    * @returns {string}
    */
-  static IS_OVERLAPPING_WARNING(newMergedCell) {
-    return (0, _templateLiteralTag.toSingleLine)`The merged cell declared at [${newMergedCell.row}, ${newMergedCell.col}], overlaps\x20
+  static IS_OVERLAPPING_WARNING(_ref) {
+    let {
+      row,
+      col
+    } = _ref;
+    return (0, _templateLiteralTag.toSingleLine)`The merged cell declared at [${row}, ${col}], overlaps\x20
       with the other declared merged cell. The overlapping merged cell was not added to the table, please\x20
       fix your setup.`;
   }
@@ -85,16 +95,11 @@ class MergedCellsCollection {
    * @returns {MergedCellCoords|boolean} Returns a wanted merged cell on success and `false` on failure.
    */
   get(row, column) {
-    const mergedCells = this.mergedCells;
-    let result = false;
-    (0, _array.arrayEach)(mergedCells, mergedCell => {
-      if (mergedCell.row <= row && mergedCell.row + mergedCell.rowspan - 1 >= row && mergedCell.col <= column && mergedCell.col + mergedCell.colspan - 1 >= column) {
-        result = mergedCell;
-        return false;
-      }
-      return true;
-    });
-    return result;
+    var _this$mergedCellsMatr;
+    if (!this.mergedCellsMatrix.has(row)) {
+      return false;
+    }
+    return (_this$mergedCellsMatr = this.mergedCellsMatrix.get(row).get(column)) !== null && _this$mergedCellsMatr !== void 0 ? _this$mergedCellsMatr : false;
   }
 
   /**
@@ -104,9 +109,8 @@ class MergedCellsCollection {
    * @returns {MergedCellCoords|boolean}
    */
   getByRange(range) {
-    const mergedCells = this.mergedCells;
     let result = false;
-    (0, _array.arrayEach)(mergedCells, mergedCell => {
+    (0, _array.arrayEach)(this.mergedCells, mergedCell => {
       if (mergedCell.row <= range.from.row && mergedCell.row + mergedCell.rowspan - 1 >= range.to.row && mergedCell.col <= range.from.col && mergedCell.col + mergedCell.colspan - 1 >= range.to.col) {
         result = mergedCell;
         return result;
@@ -116,58 +120,110 @@ class MergedCellsCollection {
     return result;
   }
 
+  /**
+   * Filters merge cells objects provided by users from overlapping cells.
+   *
+   * @param {{ row: number, col: number, rowspan: number, colspan: number }} mergedCellsInfo The merged cell information object.
+   * Has to contain `row`, `col`, `colspan` and `rowspan` properties.
+   * @returns {Array<{ row: number, col: number, rowspan: number, colspan: number }>}
+   */
+  filterOverlappingMergeCells(mergedCellsInfo) {
+    const occupiedCells = new Set();
+    this.mergedCells.forEach(mergedCell => {
+      const {
+        row,
+        col,
+        colspan,
+        rowspan
+      } = mergedCell;
+      for (let r = row; r < row + rowspan; r++) {
+        for (let c = col; c < col + colspan; c++) {
+          occupiedCells.add(`r${r},c${c}`);
+        }
+      }
+    });
+    const filteredMergeCells = mergedCellsInfo.filter(mergedCell => {
+      const {
+        row,
+        col,
+        colspan,
+        rowspan
+      } = mergedCell;
+      const localOccupiedCells = new Set();
+      let isOverlapping = false;
+      for (let r = row; r < row + rowspan; r++) {
+        for (let c = col; c < col + colspan; c++) {
+          const cellId = `r${r},c${c}`;
+          if (occupiedCells.has(cellId)) {
+            (0, _console.warn)(MergedCellsCollection.IS_OVERLAPPING_WARNING(mergedCell));
+            isOverlapping = true;
+            break;
+          }
+          localOccupiedCells.add(cellId);
+        }
+        if (isOverlapping) {
+          break;
+        }
+      }
+      if (!isOverlapping) {
+        occupiedCells.add(...localOccupiedCells);
+      }
+      return !isOverlapping;
+    });
+    return filteredMergeCells;
+  }
+
   /**
    * Get a merged cell contained in the provided range.
    *
-   * @param {CellRange|object} range The range to search merged cells in.
+   * @param {CellRange} range The range to search merged cells in.
    * @param {boolean} [countPartials=false] If set to `true`, all the merged cells overlapping the range will be taken into calculation.
-   * @returns {Array|boolean} Array of found merged cells of `false` if none were found.
+   * @returns {MergedCellCoords[]} Array of found merged cells.
    */
   getWithinRange(range) {
     let countPartials = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    const mergedCells = this.mergedCells;
-    const foundMergedCells = [];
-    let testedRange = range;
-    if (!testedRange.includesRange) {
-      const from = this.hot._createCellCoords(testedRange.from.row, testedRange.from.col);
-      const to = this.hot._createCellCoords(testedRange.to.row, testedRange.to.col);
-      testedRange = this.hot._createCellRange(from, from, to);
-    }
-    (0, _array.arrayEach)(mergedCells, mergedCell => {
-      const mergedCellTopLeft = this.hot._createCellCoords(mergedCell.row, mergedCell.col);
-      const mergedCellBottomRight = this.hot._createCellCoords(mergedCell.row + mergedCell.rowspan - 1, mergedCell.col + mergedCell.colspan - 1);
-      const mergedCellRange = this.hot._createCellRange(mergedCellTopLeft, mergedCellTopLeft, mergedCellBottomRight);
-      if (countPartials) {
-        if (testedRange.overlaps(mergedCellRange)) {
-          foundMergedCells.push(mergedCell);
+    const {
+      row: rowStart,
+      col: columnStart
+    } = range.getTopStartCorner();
+    const {
+      row: rowEnd,
+      col: columnEnd
+    } = range.getBottomEndCorner();
+    const result = [];
+    for (let row = rowStart; row <= rowEnd; row++) {
+      for (let column = columnStart; column <= columnEnd; column++) {
+        const mergedCell = this.get(row, column);
+        if (mergedCell && (countPartials || !countPartials && mergedCell.row === row && mergedCell.col === column)) {
+          result.push(mergedCell);
         }
-      } else if (testedRange.includesRange(mergedCellRange)) {
-        foundMergedCells.push(mergedCell);
       }
-    });
-    return foundMergedCells.length ? foundMergedCells : false;
+    }
+    return result;
   }
 
   /**
    * Add a merged cell to the container.
    *
    * @param {object} mergedCellInfo The merged cell information object. Has to contain `row`, `col`, `colspan` and `rowspan` properties.
+   * @param {boolean} [auto=false] `true` if called internally by the plugin (usually in batch).
    * @returns {MergedCellCoords|boolean} Returns the new merged cell on success and `false` on failure.
    */
   add(mergedCellInfo) {
-    const mergedCells = this.mergedCells;
+    let auto = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const row = mergedCellInfo.row;
     const column = mergedCellInfo.col;
     const rowspan = mergedCellInfo.rowspan;
     const colspan = mergedCellInfo.colspan;
     const newMergedCell = new _cellCoords.default(row, column, rowspan, colspan, this.hot._createCellCoords, this.hot._createCellRange);
     const alreadyExists = this.get(row, column);
-    const isOverlapping = this.isOverlapping(newMergedCell);
+    const isOverlapping = auto ? false : this.isOverlapping(newMergedCell);
     if (!alreadyExists && !isOverlapping) {
       if (this.hot) {
         newMergedCell.normalize(this.hot);
       }
-      mergedCells.push(newMergedCell);
+      this.mergedCells.push(newMergedCell);
+      _assertClassBrand(_MergedCellsCollection_brand, this, _addMergedCellToMatrix).call(this, newMergedCell);
       return newMergedCell;
     }
     (0, _console.warn)(MergedCellsCollection.IS_OVERLAPPING_WARNING(newMergedCell));
@@ -183,12 +239,12 @@ class MergedCellsCollection {
    * @returns {MergedCellCoords|boolean} Returns the removed merged cell on success and `false` on failure.
    */
   remove(row, column) {
-    const mergedCells = this.mergedCells;
-    const wantedCollection = this.get(row, column);
-    const wantedCollectionIndex = wantedCollection ? this.mergedCells.indexOf(wantedCollection) : -1;
-    if (wantedCollection && wantedCollectionIndex !== -1) {
-      mergedCells.splice(wantedCollectionIndex, 1);
-      return wantedCollection;
+    const mergedCell = this.get(row, column);
+    const mergedCellIndex = mergedCell ? this.mergedCells.indexOf(mergedCell) : -1;
+    if (mergedCell && mergedCellIndex !== -1) {
+      this.mergedCells.splice(mergedCellIndex, 1);
+      _assertClassBrand(_MergedCellsCollection_brand, this, _removeMergedCellFromMatrix).call(this, mergedCell);
+      return mergedCell;
     }
     return false;
   }
@@ -197,55 +253,44 @@ class MergedCellsCollection {
    * Clear all the merged cells.
    */
   clear() {
-    const mergedCells = this.mergedCells;
-    const mergedCellParentsToClear = [];
-    const hiddenCollectionElements = [];
-    (0, _array.arrayEach)(mergedCells, mergedCell => {
-      const TD = this.hot.getCell(mergedCell.row, mergedCell.col);
-      if (TD) {
-        mergedCellParentsToClear.push([TD, this.get(mergedCell.row, mergedCell.col), mergedCell.row, mergedCell.col]);
-      }
-    });
-    this.mergedCells.length = 0;
-    (0, _array.arrayEach)(mergedCellParentsToClear, (mergedCell, i) => {
-      (0, _number.rangeEach)(0, mergedCell.rowspan - 1, j => {
-        (0, _number.rangeEach)(0, mergedCell.colspan - 1, k => {
-          if (k !== 0 || j !== 0) {
-            const TD = this.hot.getCell(mergedCell.row + j, mergedCell.col + k);
-            if (TD) {
-              hiddenCollectionElements.push([TD, null, null, null]);
-            }
+    (0, _array.arrayEach)(this.mergedCells, _ref2 => {
+      let {
+        row,
+        col,
+        rowspan,
+        colspan
+      } = _ref2;
+      (0, _number.rangeEach)(row, row + rowspan, r => {
+        (0, _number.rangeEach)(col, col + colspan, c => {
+          const TD = this.hot.getCell(r, c);
+          if (TD) {
+            TD.removeAttribute('rowspan');
+            TD.removeAttribute('colspan');
+            TD.style.display = '';
           }
         });
       });
-      mergedCellParentsToClear[i][1] = null;
-    });
-    (0, _array.arrayEach)(mergedCellParentsToClear, mergedCellParents => {
-      (0, _utils.applySpanProperties)(...mergedCellParents);
-    });
-    (0, _array.arrayEach)(hiddenCollectionElements, hiddenCollectionElement => {
-      (0, _utils.applySpanProperties)(...hiddenCollectionElement);
     });
+    this.mergedCells.length = 0;
+    this.mergedCellsMatrix = new Map();
   }
 
   /**
-   * Check if the provided merged cell overlaps with the others in the container.
+   * Check if the provided merged cell overlaps with the others already added.
    *
    * @param {MergedCellCoords} mergedCell The merged cell to check against all others in the container.
    * @returns {boolean} `true` if the provided merged cell overlaps with the others, `false` otherwise.
    */
   isOverlapping(mergedCell) {
-    const mergedCellRange = this.hot._createCellRange(this.hot._createCellCoords(0, 0), this.hot._createCellCoords(mergedCell.row, mergedCell.col), this.hot._createCellCoords(mergedCell.row + mergedCell.rowspan - 1, mergedCell.col + mergedCell.colspan - 1));
-    let result = false;
-    (0, _array.arrayEach)(this.mergedCells, col => {
-      const currentRange = this.hot._createCellRange(this.hot._createCellCoords(0, 0), this.hot._createCellCoords(col.row, col.col), this.hot._createCellCoords(col.row + col.rowspan - 1, col.col + col.colspan - 1));
-      if (currentRange.overlaps(mergedCellRange)) {
-        result = true;
-        return false;
+    const mergedCellRange = mergedCell.getRange();
+    for (let i = 0; i < this.mergedCells.length; i++) {
+      const otherMergedCell = this.mergedCells[i];
+      const otherMergedCellRange = otherMergedCell.getRange();
+      if (otherMergedCellRange.overlaps(mergedCellRange)) {
+        return true;
       }
-      return true;
-    });
-    return result;
+    }
+    return false;
   }
 
   /**
@@ -380,15 +425,24 @@ class MergedCellsCollection {
       default:
     }
     (0, _array.arrayEach)(this.mergedCells, currentMerge => {
+      _assertClassBrand(_MergedCellsCollection_brand, this, _removeMergedCellFromMatrix).call(this, currentMerge);
       currentMerge.shift(shiftVector, index);
+      _assertClassBrand(_MergedCellsCollection_brand, this, _addMergedCellToMatrix).call(this, currentMerge);
     });
     (0, _number.rangeEachReverse)(this.mergedCells.length - 1, 0, i => {
       const currentMerge = this.mergedCells[i];
       if (currentMerge && currentMerge.removed) {
         this.mergedCells.splice(this.mergedCells.indexOf(currentMerge), 1);
+        _assertClassBrand(_MergedCellsCollection_brand, this, _removeMergedCellFromMatrix).call(this, currentMerge);
       }
     });
   }
+
+  /**
+   * Adds a merged cell to the matrix.
+   *
+   * @param {MergedCellCoords} mergedCell The merged cell to add.
+   */
 }
 function _getNonIntersectingIndexes(range, axis) {
   let scanDirection = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
@@ -409,12 +463,34 @@ function _getNonIntersectingIndexes(range, axis) {
       indexes.get(index).add(lastIndex);
     }
   }
-  return Array.from(new Set(Array.from(indexes.entries()).filter(_ref => {
-    let [, set] = _ref;
+  return Array.from(new Set(Array.from(indexes.entries()).filter(_ref3 => {
+    let [, set] = _ref3;
     return set.size === 1;
-  }).flatMap(_ref2 => {
-    let [, set] = _ref2;
+  }).flatMap(_ref4 => {
+    let [, set] = _ref4;
     return Array.from(set);
   })));
 }
+function _addMergedCellToMatrix(mergedCell) {
+  for (let row = mergedCell.row; row < mergedCell.row + mergedCell.rowspan; row++) {
+    for (let col = mergedCell.col; col < mergedCell.col + mergedCell.colspan; col++) {
+      if (!this.mergedCellsMatrix.has(row)) {
+        this.mergedCellsMatrix.set(row, new Map());
+      }
+      this.mergedCellsMatrix.get(row).set(col, mergedCell);
+    }
+  }
+}
+/**
+ * Removes a merged cell from the matrix.
+ *
+ * @param {MergedCellCoords} mergedCell The merged cell to remove.
+ */
+function _removeMergedCellFromMatrix(mergedCell) {
+  for (let row = mergedCell.row; row < mergedCell.row + mergedCell.rowspan; row++) {
+    for (let col = mergedCell.col; col < mergedCell.col + mergedCell.colspan; col++) {
+      this.mergedCellsMatrix.get(row).delete(col);
+    }
+  }
+}
 var _default = exports.default = MergedCellsCollection;