handsontable 0.0.0-next-be250b6-20230621 → 0.0.0-next-dcd0acc-20230621

package/3rdparty/walkontable/src/selection.mjs

@@ -0,0 +1,349 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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 _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/es.object.values.js";
+import "core-js/modules/es.symbol.to-primitive.js";
+import "core-js/modules/es.date.to-primitive.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.number.constructor.js";
+import "core-js/modules/es.symbol.iterator.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.regexp.to-string.js";
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.regexp.exec.js";
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+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, _toPropertyKey(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; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { addClass, hasClass } from "./../../../helpers/dom/element.mjs";
+import Border from "./border.mjs";
+/**
+ * @class Selection
+ */
+var Selection = /*#__PURE__*/function () {
+  /**
+   * @param {object} settings The selection settings object. @todo type.
+   * @param {CellRange} cellRange The cell range instance.
+   */
+  function Selection(settings, cellRange) {
+    _classCallCheck(this, Selection);
+    this.settings = settings;
+    this.cellRange = cellRange || null;
+    this.instanceBorders = {};
+    this.classNames = [this.settings.className];
+    this.classNameGenerator = this.linearClassNameGenerator(this.settings.className, this.settings.layerLevel);
+  }
+
+  /**
+   * Each Walkontable clone requires it's own border for every selection. This method creates and returns selection
+   * borders per instance.
+   *
+   * @param {WalkontableFacade} wotInstance The Walkontable instance.
+   * @returns {Border}
+   */
+  _createClass(Selection, [{
+    key: "getBorder",
+    value: function getBorder(wotInstance) {
+      if (!this.instanceBorders[wotInstance.guid]) {
+        this.instanceBorders[wotInstance.guid] = new Border(wotInstance, this.settings);
+      }
+      return this.instanceBorders[wotInstance.guid];
+    }
+
+    /**
+     * Checks if selection is empty.
+     *
+     * @returns {boolean}
+     */
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return this.cellRange === null;
+    }
+
+    /**
+     * Adds a cell coords to the selection.
+     *
+     * @param {CellCoords} coords The cell coordinates to add.
+     * @returns {Selection}
+     */
+  }, {
+    key: "add",
+    value: function add(coords) {
+      if (this.isEmpty()) {
+        this.cellRange = this.settings.createCellRange(coords);
+      } else {
+        this.cellRange.expand(coords);
+      }
+      return this;
+    }
+
+    /**
+     * If selection range from or to property equals oldCoords, replace it with newCoords. Return boolean
+     * information about success.
+     *
+     * @param {CellCoords} oldCoords An old cell coordinates to replace.
+     * @param {CellCoords} newCoords The new cell coordinates.
+     * @returns {boolean}
+     */
+  }, {
+    key: "replace",
+    value: function replace(oldCoords, newCoords) {
+      if (!this.isEmpty()) {
+        if (this.cellRange.from.isEqual(oldCoords)) {
+          this.cellRange.from = newCoords;
+          return true;
+        }
+        if (this.cellRange.to.isEqual(oldCoords)) {
+          this.cellRange.to = newCoords;
+          return true;
+        }
+      }
+      return false;
+    }
+
+    /**
+     * Clears selection.
+     *
+     * @returns {Selection}
+     */
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.cellRange = null;
+      return this;
+    }
+
+    /**
+     * Returns the top left (or top right in RTL) and bottom right (or bottom left in RTL) selection coordinates.
+     *
+     * @returns {Array} Returns array of coordinates for example `[1, 1, 5, 5]`.
+     */
+  }, {
+    key: "getCorners",
+    value: function getCorners() {
+      var topStart = this.cellRange.getOuterTopStartCorner();
+      var bottomEnd = this.cellRange.getOuterBottomEndCorner();
+      return [topStart.row, topStart.col, bottomEnd.row, bottomEnd.col];
+    }
+
+    /**
+     * Adds class name to cell element at given coords.
+     *
+     * @param {WalkontableFacade} wotInstance Walkontable instance.
+     * @param {number} sourceRow Cell row coord.
+     * @param {number} sourceColumn Cell column coord.
+     * @param {string} className Class name.
+     * @param {boolean} [markIntersections=false] If `true`, linear className generator will be used to add CSS classes
+     *                                            in a continuous way.
+     * @returns {Selection}
+     */
+  }, {
+    key: "addClassAtCoords",
+    value: function addClassAtCoords(wotInstance, sourceRow, sourceColumn, className) {
+      var markIntersections = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+      var TD = wotInstance.wtTable.getCell(this.settings.createCellCoords(sourceRow, sourceColumn));
+      if (_typeof(TD) === 'object') {
+        var cellClassName = className;
+        if (markIntersections) {
+          cellClassName = this.classNameGenerator(TD);
+          if (!this.classNames.includes(cellClassName)) {
+            this.classNames.push(cellClassName);
+          }
+        }
+        addClass(TD, cellClassName);
+      }
+      return this;
+    }
+
+    /**
+     * Generate helper for calculating classNames based on previously added base className.
+     * The generated className is always generated as a continuation of the previous className. For example, when
+     * the currently checked element has 'area-2' className the generated new className will be 'area-3'. When
+     * the element doesn't have any classNames than the base className will be returned ('area');.
+     *
+     * @param {string} baseClassName Base className to be used.
+     * @param {number} layerLevelOwner Layer level which the instance of the Selection belongs to.
+     * @returns {Function}
+     */
+  }, {
+    key: "linearClassNameGenerator",
+    value: function linearClassNameGenerator(baseClassName, layerLevelOwner) {
+      // TODO: Make this recursive function Proper Tail Calls (TCO/PTC) friendly.
+      return function calcClassName(element) {
+        var previousIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
+        if (layerLevelOwner === 0 || previousIndex === 0) {
+          return baseClassName;
+        }
+        var index = previousIndex >= 0 ? previousIndex : layerLevelOwner;
+        var className = baseClassName;
+        index -= 1;
+        var previousClassName = index === 0 ? baseClassName : "".concat(baseClassName, "-").concat(index);
+        if (hasClass(element, previousClassName)) {
+          var currentLayer = index + 1;
+          className = "".concat(baseClassName, "-").concat(currentLayer);
+        } else {
+          className = calcClassName(element, index);
+        }
+        return className;
+      };
+    }
+
+    /**
+     * @param {WalkontableFacade} wotInstance The Walkontable instance.
+     */
+  }, {
+    key: "draw",
+    value: function draw(wotInstance) {
+      if (this.isEmpty()) {
+        if (this.settings.border) {
+          this.getBorder(wotInstance).disappear();
+        }
+        return;
+      }
+      var renderedRows = wotInstance.wtTable.getRenderedRowsCount();
+      var renderedColumns = wotInstance.wtTable.getRenderedColumnsCount();
+      var corners = this.getCorners();
+      var _corners = _slicedToArray(corners, 4),
+        topRow = _corners[0],
+        topColumn = _corners[1],
+        bottomRow = _corners[2],
+        bottomColumn = _corners[3];
+      var _this$settings = this.settings,
+        highlightHeaderClassName = _this$settings.highlightHeaderClassName,
+        highlightColumnClassName = _this$settings.highlightColumnClassName,
+        highlightRowClassName = _this$settings.highlightRowClassName,
+        highlightOnlyClosestHeader = _this$settings.highlightOnlyClosestHeader,
+        selectionType = _this$settings.selectionType;
+      var isHeaderSelectionType = selectionType === void 0 || ['active-header', 'header'].includes(selectionType);
+      if (isHeaderSelectionType && topColumn !== null && bottomColumn !== null) {
+        var selectionColumnCursor = 0;
+        for (var column = 0; column < renderedColumns; column += 1) {
+          var sourceCol = wotInstance.wtTable.columnFilter.renderedToSource(column);
+          if (sourceCol >= topColumn && sourceCol <= bottomColumn) {
+            var THs = wotInstance.wtTable.getColumnHeaders(sourceCol);
+            var closestHeaderLevel = THs.length - 1;
+            if (highlightOnlyClosestHeader && THs.length > 1) {
+              THs = [THs[closestHeaderLevel]];
+            }
+            for (var headerLevel = 0; headerLevel < THs.length; headerLevel += 1) {
+              var newClasses = [];
+              var TH = THs[headerLevel];
+              if (highlightHeaderClassName) {
+                newClasses.push(highlightHeaderClassName);
+              }
+              if (highlightColumnClassName) {
+                newClasses.push(highlightColumnClassName);
+              }
+              headerLevel = highlightOnlyClosestHeader ? closestHeaderLevel : headerLevel;
+              var newSourceCol = wotInstance.getSetting('onBeforeHighlightingColumnHeader', sourceCol, headerLevel, {
+                selectionType: selectionType,
+                columnCursor: selectionColumnCursor,
+                selectionWidth: bottomColumn - topColumn + 1,
+                classNames: newClasses
+              });
+              if (newSourceCol !== sourceCol) {
+                TH = wotInstance.wtTable.getColumnHeader(newSourceCol, headerLevel);
+              }
+              addClass(TH, newClasses);
+            }
+            selectionColumnCursor += 1;
+          }
+        }
+      }
+      if (topRow !== null && bottomRow !== null) {
+        var selectionRowCursor = 0;
+        for (var row = 0; row < renderedRows; row += 1) {
+          var sourceRow = wotInstance.wtTable.rowFilter.renderedToSource(row);
+          if (isHeaderSelectionType && sourceRow >= topRow && sourceRow <= bottomRow) {
+            var _THs = wotInstance.wtTable.getRowHeaders(sourceRow);
+            var _closestHeaderLevel = _THs.length - 1;
+            if (highlightOnlyClosestHeader && _THs.length > 1) {
+              _THs = [_THs[_closestHeaderLevel]];
+            }
+            for (var _headerLevel = 0; _headerLevel < _THs.length; _headerLevel += 1) {
+              var _newClasses = [];
+              var _TH = _THs[_headerLevel];
+              if (highlightHeaderClassName) {
+                _newClasses.push(highlightHeaderClassName);
+              }
+              if (highlightRowClassName) {
+                _newClasses.push(highlightRowClassName);
+              }
+              _headerLevel = highlightOnlyClosestHeader ? _closestHeaderLevel : _headerLevel;
+              var newSourceRow = wotInstance.getSetting('onBeforeHighlightingRowHeader', sourceRow, _headerLevel, {
+                selectionType: selectionType,
+                rowCursor: selectionRowCursor,
+                selectionHeight: bottomRow - topRow + 1,
+                classNames: _newClasses
+              });
+              if (newSourceRow !== sourceRow) {
+                _TH = wotInstance.wtTable.getRowHeader(newSourceRow, _headerLevel);
+              }
+              addClass(_TH, _newClasses);
+            }
+            selectionRowCursor += 1;
+          }
+          if (topColumn !== null && bottomColumn !== null) {
+            for (var _column = 0; _column < renderedColumns; _column += 1) {
+              var _sourceCol = wotInstance.wtTable.columnFilter.renderedToSource(_column);
+              if (sourceRow >= topRow && sourceRow <= bottomRow && _sourceCol >= topColumn && _sourceCol <= bottomColumn) {
+                // selected cell
+                if (this.settings.className) {
+                  this.addClassAtCoords(wotInstance, sourceRow, _sourceCol, this.settings.className, this.settings.markIntersections);
+                }
+              } else if (sourceRow >= topRow && sourceRow <= bottomRow) {
+                // selection is in this row
+                if (highlightRowClassName) {
+                  this.addClassAtCoords(wotInstance, sourceRow, _sourceCol, highlightRowClassName);
+                }
+              } else if (_sourceCol >= topColumn && _sourceCol <= bottomColumn) {
+                // selection is in this column
+                if (highlightColumnClassName) {
+                  this.addClassAtCoords(wotInstance, sourceRow, _sourceCol, highlightColumnClassName);
+                }
+              }
+              var additionalSelectionClass = wotInstance.getSetting('onAfterDrawSelection', sourceRow, _sourceCol, this.settings.layerLevel);
+              if (typeof additionalSelectionClass === 'string') {
+                this.addClassAtCoords(wotInstance, sourceRow, _sourceCol, additionalSelectionClass);
+              }
+            }
+          }
+        }
+      }
+      wotInstance.getSetting('onBeforeDrawBorders', corners, this.settings.className);
+      if (this.settings.border) {
+        // warning! border.appear modifies corners!
+        this.getBorder(wotInstance).appear(corners);
+      }
+    }
+
+    /**
+     * Cleans up all the DOM state related to a Selection instance. Call this prior to deleting a Selection instance.
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      Object.values(this.instanceBorders).forEach(function (border) {
+        return border.destroy();
+      });
+    }
+  }]);
+  return Selection;
+}();
+export default Selection;

package/3rdparty/walkontable/src/table/mixin/calculatedColumns.js

@@ -83,15 +83,6 @@ var calculatedColumns = {
    */
   getVisibleColumnsCount: function getVisibleColumnsCount() {
     return this.dataAccessObject.countColumnsVisible;
-  },
-  /**
-   * Get the number of rendered row headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getRowHeadersCount: function getRowHeadersCount() {
-    return this.dataAccessObject.rowHeaders.length;
   }
 };
 (0, _object.defineGetter)(calculatedColumns, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/calculatedColumns.mjs

@@ -79,15 +79,6 @@ var calculatedColumns = {
    */
   getVisibleColumnsCount: function getVisibleColumnsCount() {
     return this.dataAccessObject.countColumnsVisible;
-  },
-  /**
-   * Get the number of rendered row headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getRowHeadersCount: function getRowHeadersCount() {
-    return this.dataAccessObject.rowHeaders.length;
   }
 };
 defineGetter(calculatedColumns, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/calculatedRows.js

@@ -83,15 +83,6 @@ var calculatedRows = {
    */
   getVisibleRowsCount: function getVisibleRowsCount() {
     return this.dataAccessObject.countRowsVisible;
-  },
-  /**
-   * Get the number of rendered column headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getColumnHeadersCount: function getColumnHeadersCount() {
-    return this.dataAccessObject.columnHeaders.length;
   }
 };
 (0, _object.defineGetter)(calculatedRows, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/calculatedRows.mjs

@@ -79,15 +79,6 @@ var calculatedRows = {
    */
   getVisibleRowsCount: function getVisibleRowsCount() {
     return this.dataAccessObject.countRowsVisible;
-  },
-  /**
-   * Get the number of rendered column headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getColumnHeadersCount: function getColumnHeadersCount() {
-    return this.dataAccessObject.columnHeaders.length;
   }
 };
 defineGetter(calculatedRows, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/stickyColumnsStart.js

@@ -75,15 +75,6 @@ var stickyColumnsStart = {
    */
   getVisibleColumnsCount: function getVisibleColumnsCount() {
     return this.getRenderedColumnsCount();
-  },
-  /**
-   * Get the number of rendered row headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getRowHeadersCount: function getRowHeadersCount() {
-    return this.dataAccessObject.rowHeaders.length;
   }
 };
 (0, _object.defineGetter)(stickyColumnsStart, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/stickyColumnsStart.mjs

@@ -71,15 +71,6 @@ var stickyColumnsStart = {
    */
   getVisibleColumnsCount: function getVisibleColumnsCount() {
     return this.getRenderedColumnsCount();
-  },
-  /**
-   * Get the number of rendered row headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getRowHeadersCount: function getRowHeadersCount() {
-    return this.dataAccessObject.rowHeaders.length;
   }
 };
 defineGetter(stickyColumnsStart, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/stickyRowsBottom.js

@@ -80,15 +80,6 @@ var stickyRowsBottom = {
    */
   getVisibleRowsCount: function getVisibleRowsCount() {
     return this.getRenderedRowsCount();
-  },
-  /**
-   * Get the number of rendered column headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getColumnHeadersCount: function getColumnHeadersCount() {
-    return 0;
   }
 };
 (0, _object.defineGetter)(stickyRowsBottom, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/stickyRowsBottom.mjs

@@ -76,15 +76,6 @@ var stickyRowsBottom = {
    */
   getVisibleRowsCount: function getVisibleRowsCount() {
     return this.getRenderedRowsCount();
-  },
-  /**
-   * Get the number of rendered column headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getColumnHeadersCount: function getColumnHeadersCount() {
-    return 0;
   }
 };
 defineGetter(stickyRowsBottom, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/stickyRowsTop.js

@@ -75,15 +75,6 @@ var stickyRowsTop = {
    */
   getVisibleRowsCount: function getVisibleRowsCount() {
     return this.getRenderedRowsCount();
-  },
-  /**
-   * Get the number of rendered column headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getColumnHeadersCount: function getColumnHeadersCount() {
-    return this.dataAccessObject.columnHeaders.length;
   }
 };
 (0, _object.defineGetter)(stickyRowsTop, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table/mixin/stickyRowsTop.mjs

@@ -71,15 +71,6 @@ var stickyRowsTop = {
    */
   getVisibleRowsCount: function getVisibleRowsCount() {
     return this.getRenderedRowsCount();
-  },
-  /**
-   * Get the number of rendered column headers.
-   *
-   * @returns {number}
-   * @this Table
-   */
-  getColumnHeadersCount: function getColumnHeadersCount() {
-    return this.dataAccessObject.columnHeaders.length;
   }
 };
 defineGetter(stickyRowsTop, 'MIXIN_NAME', MIXIN_NAME, {

package/3rdparty/walkontable/src/table.js

@@ -2,15 +2,16 @@
 
 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.slice.js");
 require("core-js/modules/es.regexp.to-string.js");
-require("core-js/modules/es.array.from.js");
 require("core-js/modules/es.regexp.exec.js");
 exports.__esModule = true;
 exports.default = void 0;
 require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/es.array.includes.js");
 require("core-js/modules/es.object.to-string.js");
 require("core-js/modules/web.dom-collections.for-each.js");
 require("core-js/modules/es.symbol.to-primitive.js");
@@ -387,7 +388,7 @@ var Table = /*#__PURE__*/function () {
         wtOverlays.refreshAll(); // `refreshAll()` internally already calls `refreshSelections()` method
         wtOverlays.adjustElementsSize();
       } else {
-        this.dataAccessObject.selectionManager.setActiveOverlay(this.facadeGetter()).render(runFastDraw);
+        this.refreshSelections(runFastDraw);
       }
       if (syncScroll) {
         wtOverlays.syncScrollWithMaster();
@@ -479,6 +480,74 @@ var Table = /*#__PURE__*/function () {
       }
     }
 
+    /**
+     * @param {string} className The CSS class name to remove from the table cells.
+     */
+  }, {
+    key: "removeClassFromCells",
+    value: function removeClassFromCells(className) {
+      var nodes = this.TABLE.querySelectorAll(".".concat(className));
+      for (var i = 0, len = nodes.length; i < len; i++) {
+        (0, _element.removeClass)(nodes[i], className);
+      }
+    }
+
+    /**
+     * Refresh the table selection by re-rendering Selection instances connected with that instance.
+     *
+     * @param {boolean} fastDraw If fast drawing is enabled than additionally className clearing is applied.
+     */
+  }, {
+    key: "refreshSelections",
+    value: function refreshSelections(fastDraw) {
+      var wtSettings = this.wtSettings;
+      var selections = this.dataAccessObject.selections;
+      if (!selections) {
+        return;
+      }
+      var highlights = Array.from(selections);
+      var len = highlights.length;
+      if (fastDraw) {
+        var classesToRemove = [];
+        for (var i = 0; i < len; i++) {
+          var _highlights$i$setting = highlights[i].settings,
+            highlightHeaderClassName = _highlights$i$setting.highlightHeaderClassName,
+            highlightRowClassName = _highlights$i$setting.highlightRowClassName,
+            highlightColumnClassName = _highlights$i$setting.highlightColumnClassName;
+          var classNames = highlights[i].classNames;
+          var classNamesLength = classNames.length;
+          for (var j = 0; j < classNamesLength; j++) {
+            if (!classesToRemove.includes(classNames[j])) {
+              classesToRemove.push(classNames[j]);
+            }
+          }
+          if (highlightHeaderClassName && !classesToRemove.includes(highlightHeaderClassName)) {
+            classesToRemove.push(highlightHeaderClassName);
+          }
+          if (highlightRowClassName && !classesToRemove.includes(highlightRowClassName)) {
+            classesToRemove.push(highlightRowClassName);
+          }
+          if (highlightColumnClassName && !classesToRemove.includes(highlightColumnClassName)) {
+            classesToRemove.push(highlightColumnClassName);
+          }
+        }
+        var additionalClassesToRemove = wtSettings.getSetting('onBeforeRemoveCellClassNames');
+        if (Array.isArray(additionalClassesToRemove)) {
+          for (var _i = 0; _i < additionalClassesToRemove.length; _i++) {
+            classesToRemove.push(additionalClassesToRemove[_i]);
+          }
+        }
+        var classesToRemoveLength = classesToRemove.length;
+        for (var _i2 = 0; _i2 < classesToRemoveLength; _i2++) {
+          // there was no rerender, so we need to remove classNames by ourselves
+          this.removeClassFromCells(classesToRemove[_i2]);
+        }
+      }
+      for (var _i3 = 0; _i3 < len; _i3++) {
+        highlights[_i3].draw(this.facadeGetter(), fastDraw);
+      }
+    }
+
     /**
      * Get cell element at coords.
      * Negative coords.row or coords.col are used to retrieve header cells. If there are multiple header levels, the
@@ -612,14 +681,14 @@ var Table = /*#__PURE__*/function () {
     key: "getRowHeader",
     value: function getRowHeader(row) {
       var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (this.columnFilter.sourceColumnToVisibleRowHeadedColumn(0) === 0) {
+        return;
+      }
       var rowHeadersCount = this.wtSettings.getSetting('rowHeaders').length;
       if (level >= rowHeadersCount) {
         return;
       }
-      var renderedRow = this.rowFilter.sourceToRendered(row);
-      var visibleRow = renderedRow < 0 ? this.rowFilter.sourceRowToVisibleColHeadedRow(row) : renderedRow;
-      var parentElement = renderedRow < 0 ? this.THEAD : this.TBODY;
-      var TR = parentElement.childNodes[visibleRow];
+      var TR = this.TBODY.childNodes[this.rowFilter.sourceToRendered(row)];
       return TR === null || TR === void 0 ? void 0 : TR.childNodes[level];
     }
 
@@ -632,6 +701,9 @@ var Table = /*#__PURE__*/function () {
   }, {
     key: "getRowHeaders",
     value: function getRowHeaders(row) {
+      if (this.columnFilter.sourceColumnToVisibleRowHeadedColumn(0) === 0) {
+        return [];
+      }
       var THs = [];
       var rowHeadersCount = this.wtSettings.getSetting('rowHeaders').length;
       for (var renderedRowIndex = 0; renderedRowIndex < rowHeadersCount; renderedRowIndex++) {