handsontable 0.0.0-next-9ec04ce-20221121

package/plugins/mergeCells/cellCoords.mjs

@@ -0,0 +1,342 @@
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.object.freeze.js";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+import { toSingleLine } from "../../helpers/templateLiteralTag.mjs";
+/**
+ * The `MergedCellCoords` class represents a single merged cell.
+ *
+ * @private
+ * @class MergedCellCoords
+ */
+var MergedCellCoords = /*#__PURE__*/function () {
+  function MergedCellCoords(row, column, rowspan, colspan, cellCoordsFactory, cellRangeFactory) {
+    _classCallCheck(this, MergedCellCoords);
+    /**
+     * The index of the topmost merged cell row.
+     *
+     * @type {number}
+     */
+    this.row = row;
+    /**
+     * The index of the leftmost column.
+     *
+     * @type {number}
+     */
+    this.col = column;
+    /**
+     * The `rowspan` value of the merged cell.
+     *
+     * @type {number}
+     */
+    this.rowspan = rowspan;
+    /**
+     * The `colspan` value of the merged cell.
+     *
+     * @type {number}
+     */
+    this.colspan = colspan;
+    /**
+     * `true` only if the merged cell is bound to be removed.
+     *
+     * @type {boolean}
+     */
+    this.removed = false;
+    /**
+     * The CellCoords function factory.
+     *
+     * @type {Function}
+     */
+    this.cellCoordsFactory = cellCoordsFactory;
+    /**
+     * The CellRange function factory.
+     *
+     * @type {Function}
+     */
+    this.cellRangeFactory = cellRangeFactory;
+  }
+
+  /**
+   * 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.
+   * @returns {string}
+   */
+  _createClass(MergedCellCoords, [{
+    key: "normalize",
+    value:
+    /**
+     * Sanitize (prevent from going outside the boundaries) the merged cell.
+     *
+     * @param {Core} hotInstance The Handsontable instance.
+     */
+    function normalize(hotInstance) {
+      var totalRows = hotInstance.countRows();
+      var totalColumns = hotInstance.countCols();
+      if (this.row < 0) {
+        this.row = 0;
+      } else if (this.row > totalRows - 1) {
+        this.row = totalRows - 1;
+      }
+      if (this.col < 0) {
+        this.col = 0;
+      } else if (this.col > totalColumns - 1) {
+        this.col = totalColumns - 1;
+      }
+      if (this.row + this.rowspan > totalRows - 1) {
+        this.rowspan = totalRows - this.row;
+      }
+      if (this.col + this.colspan > totalColumns - 1) {
+        this.colspan = totalColumns - this.col;
+      }
+    }
+
+    /**
+     * Returns `true` if the provided coordinates are inside the merged cell.
+     *
+     * @param {number} row The row index.
+     * @param {number} column The column index.
+     * @returns {boolean}
+     */
+  }, {
+    key: "includes",
+    value: function includes(row, column) {
+      return this.row <= row && this.col <= column && this.row + this.rowspan - 1 >= row && this.col + this.colspan - 1 >= column;
+    }
+
+    /**
+     * Returns `true` if the provided `column` property is within the column span of the merged cell.
+     *
+     * @param {number} column The column index.
+     * @returns {boolean}
+     */
+  }, {
+    key: "includesHorizontally",
+    value: function includesHorizontally(column) {
+      return this.col <= column && this.col + this.colspan - 1 >= column;
+    }
+
+    /**
+     * Returns `true` if the provided `row` property is within the row span of the merged cell.
+     *
+     * @param {number} row Row index.
+     * @returns {boolean}
+     */
+  }, {
+    key: "includesVertically",
+    value: function includesVertically(row) {
+      return this.row <= row && this.row + this.rowspan - 1 >= row;
+    }
+
+    /**
+     * Shift (and possibly resize, if needed) the merged cell.
+     *
+     * @param {Array} shiftVector 2-element array containing the information on the shifting in the `x` and `y` axis.
+     * @param {number} indexOfChange Index of the preceding change.
+     * @returns {boolean} Returns `false` if the whole merged cell was removed.
+     */
+  }, {
+    key: "shift",
+    value: function shift(shiftVector, indexOfChange) {
+      var shiftValue = shiftVector[0] || shiftVector[1];
+      var shiftedIndex = indexOfChange + Math.abs(shiftVector[0] || shiftVector[1]) - 1;
+      var span = shiftVector[0] ? 'colspan' : 'rowspan';
+      var index = shiftVector[0] ? 'col' : 'row';
+      var changeStart = Math.min(indexOfChange, shiftedIndex);
+      var changeEnd = Math.max(indexOfChange, shiftedIndex);
+      var mergeStart = this[index];
+      var mergeEnd = this[index] + this[span] - 1;
+      if (mergeStart >= indexOfChange) {
+        this[index] += shiftValue;
+      }
+
+      // adding rows/columns
+      if (shiftValue > 0) {
+        if (indexOfChange <= mergeEnd && indexOfChange > mergeStart) {
+          this[span] += shiftValue;
+        }
+
+        // removing rows/columns
+      } else if (shiftValue < 0) {
+        // removing the whole merge
+        if (changeStart <= mergeStart && changeEnd >= mergeEnd) {
+          this.removed = true;
+          return false;
+
+          // removing the merge partially, including the beginning
+        } else if (mergeStart >= changeStart && mergeStart <= changeEnd) {
+          var removedOffset = changeEnd - mergeStart + 1;
+          var preRemovedOffset = Math.abs(shiftValue) - removedOffset;
+          this[index] -= preRemovedOffset + shiftValue;
+          this[span] -= removedOffset;
+
+          // removing the middle part of the merge
+        } else if (mergeStart <= changeStart && mergeEnd >= changeEnd) {
+          this[span] += shiftValue;
+
+          // removing the end part of the merge
+        } else if (mergeStart <= changeStart && mergeEnd >= changeStart && mergeEnd < changeEnd) {
+          var removedPart = mergeEnd - changeStart + 1;
+          this[span] -= removedPart;
+        }
+      }
+      return true;
+    }
+
+    /**
+     * Check if the second provided merged cell is "farther" in the provided direction.
+     *
+     * @param {MergedCellCoords} mergedCell The merged cell to check.
+     * @param {string} direction Drag direction.
+     * @returns {boolean|null} `true` if the second provided merged cell is "farther".
+     */
+  }, {
+    key: "isFarther",
+    value: function isFarther(mergedCell, direction) {
+      if (!mergedCell) {
+        return true;
+      }
+      if (direction === 'down') {
+        return mergedCell.row + mergedCell.rowspan - 1 < this.row + this.rowspan - 1;
+      } else if (direction === 'up') {
+        return mergedCell.row > this.row;
+      } else if (direction === 'right') {
+        return mergedCell.col + mergedCell.colspan - 1 < this.col + this.colspan - 1;
+      } else if (direction === 'left') {
+        return mergedCell.col > this.col;
+      }
+      return null;
+    }
+
+    /**
+     * Get the bottom row index of the merged cell.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "getLastRow",
+    value: function getLastRow() {
+      return this.row + this.rowspan - 1;
+    }
+
+    /**
+     * Get the rightmost column index of the merged cell.
+     *
+     * @returns {number}
+     */
+  }, {
+    key: "getLastColumn",
+    value: function getLastColumn() {
+      return this.col + this.colspan - 1;
+    }
+
+    /**
+     * Get the range coordinates of the merged cell.
+     *
+     * @returns {CellRange}
+     */
+  }, {
+    key: "getRange",
+    value: function getRange() {
+      return this.cellRangeFactory(this.cellCoordsFactory(this.row, this.col), this.cellCoordsFactory(this.row, this.col), this.cellCoordsFactory(this.getLastRow(), this.getLastColumn()));
+    }
+  }], [{
+    key: "NEGATIVE_VALUES_WARNING",
+    value: function NEGATIVE_VALUES_WARNING(newMergedCell) {
+      return toSingleLine(_templateObject || (_templateObject = _taggedTemplateLiteral(["The merged cell declared with {row: ", ", col: ", ", \n      rowspan: ", ", colspan: ", "} contains negative values, which is \n      not supported. It will not be added to the collection."], ["The merged cell declared with {row: ", ", col: ", ",\\x20\n      rowspan: ", ", colspan: ", "} contains negative values, which is\\x20\n      not supported. It will not be added to the collection."])), newMergedCell.row, newMergedCell.col, newMergedCell.rowspan, newMergedCell.colspan);
+    }
+
+    /**
+     * 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.
+     * @returns {string}
+     */
+  }, {
+    key: "IS_OUT_OF_BOUNDS_WARNING",
+    value: function IS_OUT_OF_BOUNDS_WARNING(newMergedCell) {
+      return toSingleLine(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["The merged cell declared at [", ", ", "] is positioned \n      (or positioned partially) outside of the table range. It was not added to the table, please fix your setup."], ["The merged cell declared at [", ", ", "] is positioned\\x20\n      (or positioned partially) outside of the table range. It was not added to the table, please fix your setup."])), newMergedCell.row, newMergedCell.col);
+    }
+
+    /**
+     * 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.
+     * @returns {string}
+     */
+  }, {
+    key: "IS_SINGLE_CELL",
+    value: function IS_SINGLE_CELL(newMergedCell) {
+      return toSingleLine(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["The merged cell declared at [", ", ", "] has both \"rowspan\" \n      and \"colspan\" declared as \"1\", which makes it a single cell. It cannot be added to the collection."], ["The merged cell declared at [", ", ", "] has both \"rowspan\"\\x20\n      and \"colspan\" declared as \"1\", which makes it a single cell. It cannot be added to the collection."])), newMergedCell.row, newMergedCell.col);
+    }
+
+    /**
+     * 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.
+     * @returns {string}
+     */
+  }, {
+    key: "ZERO_SPAN_WARNING",
+    value: function ZERO_SPAN_WARNING(newMergedCell) {
+      return toSingleLine(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["The merged cell declared at [", ", ", "] has \"rowspan\" \n      or \"colspan\" declared as \"0\", which is not supported. It cannot be added to the collection."], ["The merged cell declared at [", ", ", "] has \"rowspan\"\\x20\n      or \"colspan\" declared as \"0\", which is not supported. It cannot be added to the collection."])), newMergedCell.row, newMergedCell.col);
+    }
+
+    /**
+     * 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.
+     * @returns {boolean}
+     */
+  }, {
+    key: "containsNegativeValues",
+    value: function containsNegativeValues(mergedCellInfo) {
+      return mergedCellInfo.row < 0 || mergedCellInfo.col < 0 || mergedCellInfo.rowspan < 0 || mergedCellInfo.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.
+     * @returns {boolean}
+     */
+  }, {
+    key: "isSingleCell",
+    value: function isSingleCell(mergedCellInfo) {
+      return mergedCellInfo.colspan === 1 && mergedCellInfo.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.
+     * @returns {boolean}
+     */
+  }, {
+    key: "containsZeroSpan",
+    value: function containsZeroSpan(mergedCellInfo) {
+      return mergedCellInfo.colspan === 0 || mergedCellInfo.rowspan === 0;
+    }
+
+    /**
+     * Check whether the provided merged cell object is to be declared out of bounds of the table.
+     *
+     * @param {object} mergeCell Object containing the `row`, `col`, `rowspan` and `colspan` properties.
+     * @param {number} rowCount Number of rows in the table.
+     * @param {number} columnCount Number of rows in the table.
+     * @returns {boolean}
+     */
+  }, {
+    key: "isOutOfBounds",
+    value: function isOutOfBounds(mergeCell, rowCount, columnCount) {
+      return mergeCell.row < 0 || mergeCell.col < 0 || mergeCell.row >= rowCount || mergeCell.row + mergeCell.rowspan - 1 >= rowCount || mergeCell.col >= columnCount || mergeCell.col + mergeCell.colspan - 1 >= columnCount;
+    }
+  }]);
+  return MergedCellCoords;
+}();
+export default MergedCellCoords;

package/plugins/mergeCells/cellsCollection.js

@@ -0,0 +1,344 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.symbol.iterator.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.object.freeze.js");
+exports.__esModule = true;
+exports.default = void 0;
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.array.splice.js");
+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");
+var _templateObject;
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+/**
+ * Defines a container object for the merged cells.
+ *
+ * @private
+ * @class MergedCellsCollection
+ */
+var MergedCellsCollection = /*#__PURE__*/function () {
+  function MergedCellsCollection(plugin) {
+    _classCallCheck(this, MergedCellsCollection);
+    /**
+     * Reference to the Merge Cells plugin.
+     *
+     * @type {MergeCells}
+     */
+    this.plugin = plugin;
+    /**
+     * Array of merged cells.
+     *
+     * @type {Array}
+     */
+    this.mergedCells = [];
+    /**
+     * The Handsontable instance.
+     *
+     * @type {Handsontable}
+     */
+    this.hot = plugin.hot;
+  }
+
+  /**
+   * 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.
+   * @returns {string}
+   */
+  _createClass(MergedCellsCollection, [{
+    key: "get",
+    value:
+    /**
+     * Get a merged cell from the container, based on the provided arguments. You can provide either the "starting coordinates"
+     * of a merged cell, or any coordinates from the body of the merged cell.
+     *
+     * @param {number} row Row index.
+     * @param {number} column Column index.
+     * @returns {MergedCellCoords|boolean} Returns a wanted merged cell on success and `false` on failure.
+     */
+    function get(row, column) {
+      var mergedCells = this.mergedCells;
+      var result = false;
+      (0, _array.arrayEach)(mergedCells, function (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;
+    }
+
+    /**
+     * Get a merged cell containing the provided range.
+     *
+     * @param {CellRange|object} range The range to search merged cells for.
+     * @returns {MergedCellCoords|boolean}
+     */
+  }, {
+    key: "getByRange",
+    value: function getByRange(range) {
+      var mergedCells = this.mergedCells;
+      var result = false;
+      (0, _array.arrayEach)(mergedCells, function (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;
+        }
+        return true;
+      });
+      return result;
+    }
+
+    /**
+     * Get a merged cell contained in the provided range.
+     *
+     * @param {CellRange|object} 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.
+     */
+  }, {
+    key: "getWithinRange",
+    value: function getWithinRange(range) {
+      var _this = this;
+      var countPartials = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var mergedCells = this.mergedCells;
+      var foundMergedCells = [];
+      var testedRange = range;
+      if (!testedRange.includesRange) {
+        var from = this.hot._createCellCoords(testedRange.from.row, testedRange.from.col);
+        var to = this.hot._createCellCoords(testedRange.to.row, testedRange.to.col);
+        testedRange = this.hot._createCellRange(from, from, to);
+      }
+      (0, _array.arrayEach)(mergedCells, function (mergedCell) {
+        var mergedCellTopLeft = _this.hot._createCellCoords(mergedCell.row, mergedCell.col);
+        var mergedCellBottomRight = _this.hot._createCellCoords(mergedCell.row + mergedCell.rowspan - 1, mergedCell.col + mergedCell.colspan - 1);
+        var mergedCellRange = _this.hot._createCellRange(mergedCellTopLeft, mergedCellTopLeft, mergedCellBottomRight);
+        if (countPartials) {
+          if (testedRange.overlaps(mergedCellRange)) {
+            foundMergedCells.push(mergedCell);
+          }
+        } else if (testedRange.includesRange(mergedCellRange)) {
+          foundMergedCells.push(mergedCell);
+        }
+      });
+      return foundMergedCells.length ? foundMergedCells : false;
+    }
+
+    /**
+     * Add a merged cell to the container.
+     *
+     * @param {object} mergedCellInfo The merged cell information object. Has to contain `row`, `col`, `colspan` and `rowspan` properties.
+     * @returns {MergedCellCoords|boolean} Returns the new merged cell on success and `false` on failure.
+     */
+  }, {
+    key: "add",
+    value: function add(mergedCellInfo) {
+      var mergedCells = this.mergedCells;
+      var row = mergedCellInfo.row;
+      var column = mergedCellInfo.col;
+      var rowspan = mergedCellInfo.rowspan;
+      var colspan = mergedCellInfo.colspan;
+      var newMergedCell = new _cellCoords.default(row, column, rowspan, colspan, this.hot._createCellCoords, this.hot._createCellRange);
+      var alreadyExists = this.get(row, column);
+      var isOverlapping = this.isOverlapping(newMergedCell);
+      if (!alreadyExists && !isOverlapping) {
+        if (this.hot) {
+          newMergedCell.normalize(this.hot);
+        }
+        mergedCells.push(newMergedCell);
+        return newMergedCell;
+      }
+      (0, _console.warn)(MergedCellsCollection.IS_OVERLAPPING_WARNING(newMergedCell));
+      return false;
+    }
+
+    /**
+     * Remove a merged cell from the container. You can provide either the "starting coordinates"
+     * of a merged cell, or any coordinates from the body of the merged cell.
+     *
+     * @param {number} row Row index.
+     * @param {number} column Column index.
+     * @returns {MergedCellCoords|boolean} Returns the removed merged cell on success and `false` on failure.
+     */
+  }, {
+    key: "remove",
+    value: function remove(row, column) {
+      var mergedCells = this.mergedCells;
+      var wantedCollection = this.get(row, column);
+      var wantedCollectionIndex = wantedCollection ? this.mergedCells.indexOf(wantedCollection) : -1;
+      if (wantedCollection && wantedCollectionIndex !== -1) {
+        mergedCells.splice(wantedCollectionIndex, 1);
+        return wantedCollection;
+      }
+      return false;
+    }
+
+    /**
+     * Clear all the merged cells.
+     */
+  }, {
+    key: "clear",
+    value: function clear() {
+      var _this2 = this;
+      var mergedCells = this.mergedCells;
+      var mergedCellParentsToClear = [];
+      var hiddenCollectionElements = [];
+      (0, _array.arrayEach)(mergedCells, function (mergedCell) {
+        var TD = _this2.hot.getCell(mergedCell.row, mergedCell.col);
+        if (TD) {
+          mergedCellParentsToClear.push([TD, _this2.get(mergedCell.row, mergedCell.col), mergedCell.row, mergedCell.col]);
+        }
+      });
+      this.mergedCells.length = 0;
+      (0, _array.arrayEach)(mergedCellParentsToClear, function (mergedCell, i) {
+        (0, _number.rangeEach)(0, mergedCell.rowspan - 1, function (j) {
+          (0, _number.rangeEach)(0, mergedCell.colspan - 1, function (k) {
+            if (k !== 0 || j !== 0) {
+              var TD = _this2.hot.getCell(mergedCell.row + j, mergedCell.col + k);
+              if (TD) {
+                hiddenCollectionElements.push([TD, null, null, null]);
+              }
+            }
+          });
+        });
+        mergedCellParentsToClear[i][1] = null;
+      });
+      (0, _array.arrayEach)(mergedCellParentsToClear, function (mergedCellParents) {
+        _utils.applySpanProperties.apply(void 0, _toConsumableArray(mergedCellParents));
+      });
+      (0, _array.arrayEach)(hiddenCollectionElements, function (hiddenCollectionElement) {
+        _utils.applySpanProperties.apply(void 0, _toConsumableArray(hiddenCollectionElement));
+      });
+    }
+
+    /**
+     * Check if the provided merged cell overlaps with the others in the container.
+     *
+     * @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.
+     */
+  }, {
+    key: "isOverlapping",
+    value: function isOverlapping(mergedCell) {
+      var _this3 = this;
+      var 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));
+      var result = false;
+      (0, _array.arrayEach)(this.mergedCells, function (col) {
+        var currentRange = _this3.hot._createCellRange(_this3.hot._createCellCoords(0, 0), _this3.hot._createCellCoords(col.row, col.col), _this3.hot._createCellCoords(col.row + col.rowspan - 1, col.col + col.colspan - 1));
+        if (currentRange.overlaps(mergedCellRange)) {
+          result = true;
+          return false;
+        }
+        return true;
+      });
+      return result;
+    }
+
+    /**
+     * Check whether the provided row/col coordinates direct to a first not hidden cell within merge area.
+     *
+     * @param {number} row Visual row index.
+     * @param {number} column Visual column index.
+     * @returns {boolean}
+     */
+  }, {
+    key: "isFirstRenderableMergedCell",
+    value: function isFirstRenderableMergedCell(row, column) {
+      var mergeParent = this.get(row, column);
+
+      // Return if row and column indexes are within merge area and if they are first rendered indexes within the area.
+      return mergeParent && this.hot.rowIndexMapper.getNearestNotHiddenIndex(mergeParent.row, 1) === row && this.hot.columnIndexMapper.getNearestNotHiddenIndex(mergeParent.col, 1) === column;
+    }
+
+    /**
+     * Get the first renderable coords of the merged cell at the provided coordinates.
+     *
+     * @param {number} row Visual row index.
+     * @param {number} column Visual column index.
+     * @returns {CellCoords} A `CellCoords` object with the coordinates to the first renderable cell within the
+     *                        merged cell.
+     */
+  }, {
+    key: "getFirstRenderableCoords",
+    value: function getFirstRenderableCoords(row, column) {
+      var mergeParent = this.get(row, column);
+      if (!mergeParent || this.isFirstRenderableMergedCell(row, column)) {
+        return this.hot._createCellCoords(row, column);
+      }
+      var firstRenderableRow = this.hot.rowIndexMapper.getNearestNotHiddenIndex(mergeParent.row, 1);
+      var firstRenderableColumn = this.hot.columnIndexMapper.getNearestNotHiddenIndex(mergeParent.col, 1);
+      return this.hot._createCellCoords(firstRenderableRow, firstRenderableColumn);
+    }
+
+    /**
+     * Shift the merged cell in the direction and by an offset defined in the arguments.
+     *
+     * @param {string} direction `right`, `left`, `up` or `down`.
+     * @param {number} index Index where the change, which caused the shifting took place.
+     * @param {number} count Number of rows/columns added/removed in the preceding action.
+     */
+  }, {
+    key: "shiftCollections",
+    value: function shiftCollections(direction, index, count) {
+      var _this4 = this;
+      var shiftVector = [0, 0];
+      switch (direction) {
+        case 'right':
+          shiftVector[0] += count;
+          break;
+        case 'left':
+          shiftVector[0] -= count;
+          break;
+        case 'down':
+          shiftVector[1] += count;
+          break;
+        case 'up':
+          shiftVector[1] -= count;
+          break;
+        default:
+      }
+      (0, _array.arrayEach)(this.mergedCells, function (currentMerge) {
+        currentMerge.shift(shiftVector, index);
+      });
+      (0, _number.rangeEachReverse)(this.mergedCells.length - 1, 0, function (i) {
+        var currentMerge = _this4.mergedCells[i];
+        if (currentMerge && currentMerge.removed) {
+          _this4.mergedCells.splice(_this4.mergedCells.indexOf(currentMerge), 1);
+        }
+      });
+    }
+  }], [{
+    key: "IS_OVERLAPPING_WARNING",
+    value: function IS_OVERLAPPING_WARNING(newMergedCell) {
+      return (0, _templateLiteralTag.toSingleLine)(_templateObject || (_templateObject = _taggedTemplateLiteral(["The merged cell declared at [", ", ", "], overlaps \n      with the other declared merged cell. The overlapping merged cell was not added to the table, please \n      fix your setup."], ["The merged cell declared at [", ", ", "], overlaps\\x20\n      with the other declared merged cell. The overlapping merged cell was not added to the table, please\\x20\n      fix your setup."])), newMergedCell.row, newMergedCell.col);
+    }
+  }]);
+  return MergedCellsCollection;
+}();
+var _default = MergedCellsCollection;
+exports.default = _default;