handsontable 0.0.0-next-bfb0e3a-20240403 → 0.0.0-next-5a535ed-20240403

package/plugins/nestedHeaders/nestedHeaders.mjs

@@ -1,14 +1,17 @@
-import "core-js/modules/es.error.cause.js";
 import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.error.cause.js";
 function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
 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 _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(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 _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
-function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
-function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
-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"); }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 import { addClass, removeClass } from "../../helpers/dom/element.mjs";
 import { isNumeric, clamp } from "../../helpers/number.mjs";
 import { toSingleLine } from "../../helpers/templateLiteralTag.mjs";
@@ -70,40 +73,203 @@ var _stateManager = /*#__PURE__*/new WeakMap();
 var _hidingIndexMapObserver = /*#__PURE__*/new WeakMap();
 var _focusInitialCoords = /*#__PURE__*/new WeakMap();
 var _isColumnsSelectionInProgress = /*#__PURE__*/new WeakMap();
-var _NestedHeaders_brand = /*#__PURE__*/new WeakSet();
+var _updateFocusHighlightPosition = /*#__PURE__*/new WeakSet();
+var _onBeforeViewportScrollHorizontally = /*#__PURE__*/new WeakSet();
+var _onBeforeHighlightingColumnHeader = /*#__PURE__*/new WeakSet();
+var _onBeforeCopy = /*#__PURE__*/new WeakSet();
+var _onBeforeOnCellMouseDown = /*#__PURE__*/new WeakSet();
+var _onAfterOnCellMouseDown = /*#__PURE__*/new WeakSet();
+var _onBeforeOnCellMouseOver = /*#__PURE__*/new WeakSet();
+var _onBeforeOnCellMouseUp = /*#__PURE__*/new WeakSet();
+var _onBeforeSelectionHighlightSet = /*#__PURE__*/new WeakSet();
+var _onModifyTransformStart = /*#__PURE__*/new WeakSet();
+var _onBeforeSelectColumns = /*#__PURE__*/new WeakSet();
+var _onAfterGetColumnHeaderRenderers = /*#__PURE__*/new WeakSet();
+var _onAfterViewportColumnCalculatorOverride = /*#__PURE__*/new WeakSet();
+var _onModifyColWidth = /*#__PURE__*/new WeakSet();
+var _onModifyColumnHeaderValue = /*#__PURE__*/new WeakSet();
+var _onModifyFocusedElement = /*#__PURE__*/new WeakSet();
+var _onInit = /*#__PURE__*/new WeakSet();
+var _onAfterLoadData = /*#__PURE__*/new WeakSet();
 export class NestedHeaders extends BasePlugin {
   constructor() {
     super(...arguments);
+    /**
+     * Updates the plugin state after new dataset load.
+     *
+     * @param {Array[]} sourceData Array of arrays or array of objects containing data.
+     * @param {boolean} initialLoad Flag that determines whether the data has been loaded
+     *                              during the initialization.
+     */
+    _classPrivateMethodInitSpec(this, _onAfterLoadData);
+    /**
+     * Updates the plugin state after HoT initialization.
+     */
+    _classPrivateMethodInitSpec(this, _onInit);
+    /**
+     * `modifyFocusedElement` hook callback.
+     *
+     * @param {number} row Row index.
+     * @param {number} column Column index.
+     * @returns {HTMLTableCellElement} The `TH` element to be focused.
+     */
+    _classPrivateMethodInitSpec(this, _onModifyFocusedElement);
+    /**
+     * Listens the `modifyColumnHeaderValue` hook that overwrites the column headers values based on
+     * the internal state and settings of the plugin.
+     *
+     * @param {string} value The column header value.
+     * @param {number} visualColumnIndex The visual column index.
+     * @param {number} headerLevel The index of header level. The header level accepts positive (0 to N)
+     *                             and negative (-1 to -N) values. For positive values, 0 points to the
+     *                             top most header, and for negative direction, -1 points to the most bottom
+     *                             header (the header closest to the cells).
+     * @returns {string} Returns the column header value to update.
+     */
+    _classPrivateMethodInitSpec(this, _onModifyColumnHeaderValue);
+    /**
+     * `modifyColWidth` hook callback - returns width from cache, when is greater than incoming from hook.
+     *
+     * @param {number} width Width from hook.
+     * @param {number} column Visual index of an column.
+     * @returns {number}
+     */
+    _classPrivateMethodInitSpec(this, _onModifyColWidth);
+    /**
+     * Make the renderer render the first nested column in its entirety.
+     *
+     * @param {object} calc Viewport column calculator.
+     */
+    _classPrivateMethodInitSpec(this, _onAfterViewportColumnCalculatorOverride);
+    /**
+     * `afterGetColumnHeader` hook callback - prepares the header structure.
+     *
+     * @param {Array} renderersArray Array of renderers.
+     */
+    _classPrivateMethodInitSpec(this, _onAfterGetColumnHeaderRenderers);
+    /**
+     * The hook observes the column selection from the Selection API and modifies the column range to
+     * ensure that the whole nested column will be covered.
+     *
+     * @param {CellCoords} from The coords object where the selection starts.
+     * @param {CellCoords} to The coords object where the selection ends.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeSelectColumns);
+    /**
+     * `modifyTransformStart` hook is called every time the keyboard navigation is used.
+     *
+     * @param {object} delta The transformation delta.
+     */
+    _classPrivateMethodInitSpec(this, _onModifyTransformStart);
+    /**
+     * The hook checks and ensures that the focus position that depends on the selected columns
+     * range is always positioned within the range.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeSelectionHighlightSet);
+    /**
+     * Switches internal flag about selection progress to `false`.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeOnCellMouseUp);
+    /**
+     * Makes the header-selection properly select the nested headers.
+     *
+     * @param {MouseEvent} event Mouse event.
+     * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell.
+     * @param {HTMLElement} TD The cell element.
+     * @param {object} controller An object with properties `row`, `column` and `cell`. Each property contains
+     *                            a boolean value that allows or disallows changing the selection for that particular area.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeOnCellMouseOver);
+    /**
+     * Allows to control how the column selection based on the coordinates and the nested headers is made.
+     *
+     * @param {MouseEvent} event Mouse event.
+     * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell.
+     */
+    _classPrivateMethodInitSpec(this, _onAfterOnCellMouseDown);
+    /**
+     * Allows blocking the column selection that is controlled by the core Selection module.
+     *
+     * @param {MouseEvent} event Mouse event.
+     * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell.
+     * @param {CellCoords} TD The table cell or header element.
+     * @param {object} controller An object with properties `row`, `column` and `cell`. Each property contains
+     *                            a boolean value that allows or disallows changing the selection for that particular area.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeOnCellMouseDown);
+    /**
+     * Listens the `beforeCopy` hook that allows processing the copied column headers so that the
+     * merged column headers do not propagate the value for each column but only once at the beginning
+     * of the column.
+     *
+     * @private
+     * @param {Array[]} data An array of arrays which contains data to copied.
+     * @param {object[]} copyableRanges An array of objects with ranges of the visual indexes (`startRow`, `startCol`, `endRow`, `endCol`)
+     *                                  which will copied.
+     * @param {{ columnHeadersCount: number }} copiedHeadersCount An object with keys that holds information with
+     *                                                            the number of copied headers.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeCopy);
+    /**
+     * Allows to control which header DOM element will be used to highlight.
+     *
+     * @param {number} visualColumn A visual column index of the highlighted row header.
+     * @param {number} headerLevel A row header level that is currently highlighted.
+     * @param {object} highlightMeta An object with meta data that describes the highlight state.
+     * @returns {number}
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeHighlightingColumnHeader);
+    /**
+     * Allows to control to which column index the viewport will be scrolled. To ensure that the viewport
+     * is scrolled to the correct column for the nested header the most left and the most right visual column
+     * indexes are used.
+     *
+     * @param {number} visualColumn A visual column index to which the viewport will be scrolled.
+     * @returns {number}
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeViewportScrollHorizontally);
     /**
      * Updates the selection focus highlight position to point to the nested header root element (TH)
      * even when the logical coordinates point in-between the header.
      */
-    _classPrivateMethodInitSpec(this, _NestedHeaders_brand);
+    _classPrivateMethodInitSpec(this, _updateFocusHighlightPosition);
     /**
      * The state manager for the nested headers.
      *
      * @type {StateManager}
      */
-    _classPrivateFieldInitSpec(this, _stateManager, new StateManager());
+    _classPrivateFieldInitSpec(this, _stateManager, {
+      writable: true,
+      value: new StateManager()
+    });
     /**
      * The instance of the ChangesObservable class that allows track the changes that happens in the
      * column indexes.
      *
      * @type {ChangesObservable}
      */
-    _classPrivateFieldInitSpec(this, _hidingIndexMapObserver, null);
+    _classPrivateFieldInitSpec(this, _hidingIndexMapObserver, {
+      writable: true,
+      value: null
+    });
     /**
      * Holds the coords that points to the place where the column selection starts.
      *
      * @type {number|null}
      */
-    _classPrivateFieldInitSpec(this, _focusInitialCoords, null);
+    _classPrivateFieldInitSpec(this, _focusInitialCoords, {
+      writable: true,
+      value: null
+    });
     /**
      * Determines if there is performed the column selection.
      *
      * @type {boolean}
      */
-    _classPrivateFieldInitSpec(this, _isColumnsSelectionInProgress, false);
+    _classPrivateFieldInitSpec(this, _isColumnsSelectionInProgress, {
+      writable: true,
+      value: false
+    });
     /**
      * Custom helper for getting widths of the nested headers.
      *
@@ -150,102 +316,101 @@ export class NestedHeaders extends BasePlugin {
       warn(toSingleLine`Your Nested Headers plugin configuration is invalid. The settings has to be\x20
                         passed as an array of arrays e.q. [['A1', { label: 'A2', colspan: 2 }]]`);
     }
-    this.addHook('init', () => _assertClassBrand(_NestedHeaders_brand, this, _onInit).call(this));
+    this.addHook('init', () => _classPrivateMethodGet(this, _onInit, _onInit2).call(this));
     this.addHook('afterLoadData', function () {
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onAfterLoadData).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onAfterLoadData, _onAfterLoadData2).call(_this, ...args);
     });
     this.addHook('beforeOnCellMouseDown', function () {
       for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
         args[_key2] = arguments[_key2];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onBeforeOnCellMouseDown).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onBeforeOnCellMouseDown, _onBeforeOnCellMouseDown2).call(_this, ...args);
     });
     this.addHook('afterOnCellMouseDown', function () {
       for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
         args[_key3] = arguments[_key3];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onAfterOnCellMouseDown).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onAfterOnCellMouseDown, _onAfterOnCellMouseDown2).call(_this, ...args);
     });
     this.addHook('beforeOnCellMouseOver', function () {
       for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
         args[_key4] = arguments[_key4];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onBeforeOnCellMouseOver).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onBeforeOnCellMouseOver, _onBeforeOnCellMouseOver2).call(_this, ...args);
     });
     this.addHook('beforeOnCellMouseUp', function () {
       for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
         args[_key5] = arguments[_key5];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onBeforeOnCellMouseUp).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onBeforeOnCellMouseUp, _onBeforeOnCellMouseUp2).call(_this, ...args);
     });
     this.addHook('beforeSelectionHighlightSet', function () {
       for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
         args[_key6] = arguments[_key6];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onBeforeSelectionHighlightSet).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onBeforeSelectionHighlightSet, _onBeforeSelectionHighlightSet2).call(_this, ...args);
     });
     this.addHook('modifyTransformStart', function () {
       for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
         args[_key7] = arguments[_key7];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onModifyTransformStart).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onModifyTransformStart, _onModifyTransformStart2).call(_this, ...args);
     });
-    this.addHook('afterSelection', () => _assertClassBrand(_NestedHeaders_brand, this, _updateFocusHighlightPosition).call(this));
-    this.addHook('afterSelectionFocusSet', () => _assertClassBrand(_NestedHeaders_brand, this, _updateFocusHighlightPosition).call(this));
+    this.addHook('afterSelection', () => _classPrivateMethodGet(this, _updateFocusHighlightPosition, _updateFocusHighlightPosition2).call(this));
     this.addHook('beforeViewportScrollHorizontally', function () {
       for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
         args[_key8] = arguments[_key8];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onBeforeViewportScrollHorizontally).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onBeforeViewportScrollHorizontally, _onBeforeViewportScrollHorizontally2).call(_this, ...args);
     });
-    this.addHook('afterGetColumnHeaderRenderers', array => _assertClassBrand(_NestedHeaders_brand, this, _onAfterGetColumnHeaderRenderers).call(this, array));
+    this.addHook('afterGetColumnHeaderRenderers', array => _classPrivateMethodGet(this, _onAfterGetColumnHeaderRenderers, _onAfterGetColumnHeaderRenderers2).call(this, array));
     this.addHook('modifyColWidth', function () {
       for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
         args[_key9] = arguments[_key9];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onModifyColWidth).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onModifyColWidth, _onModifyColWidth2).call(_this, ...args);
     });
     this.addHook('modifyColumnHeaderValue', function () {
       for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
         args[_key10] = arguments[_key10];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onModifyColumnHeaderValue).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onModifyColumnHeaderValue, _onModifyColumnHeaderValue2).call(_this, ...args);
     });
     this.addHook('beforeHighlightingColumnHeader', function () {
       for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
         args[_key11] = arguments[_key11];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onBeforeHighlightingColumnHeader).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onBeforeHighlightingColumnHeader, _onBeforeHighlightingColumnHeader2).call(_this, ...args);
     });
     this.addHook('beforeCopy', function () {
       for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
         args[_key12] = arguments[_key12];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onBeforeCopy).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onBeforeCopy, _onBeforeCopy2).call(_this, ...args);
     });
     this.addHook('beforeSelectColumns', function () {
       for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
         args[_key13] = arguments[_key13];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onBeforeSelectColumns).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onBeforeSelectColumns, _onBeforeSelectColumns2).call(_this, ...args);
     });
     this.addHook('afterViewportColumnCalculatorOverride', function () {
       for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
         args[_key14] = arguments[_key14];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onAfterViewportColumnCalculatorOverride).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onAfterViewportColumnCalculatorOverride, _onAfterViewportColumnCalculatorOverride2).call(_this, ...args);
     });
     this.addHook('modifyFocusedElement', function () {
       for (var _len15 = arguments.length, args = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {
         args[_key15] = arguments[_key15];
       }
-      return _assertClassBrand(_NestedHeaders_brand, _this, _onModifyFocusedElement).call(_this, ...args);
+      return _classPrivateMethodGet(_this, _onModifyFocusedElement, _onModifyFocusedElement2).call(_this, ...args);
     });
-    this.hot.columnIndexMapper.addLocalHook('cacheUpdated', () => _assertClassBrand(_NestedHeaders_brand, this, _updateFocusHighlightPosition).call(this));
-    this.hot.rowIndexMapper.addLocalHook('cacheUpdated', () => _assertClassBrand(_NestedHeaders_brand, this, _updateFocusHighlightPosition).call(this));
+    this.hot.columnIndexMapper.addLocalHook('cacheUpdated', () => _classPrivateMethodGet(this, _updateFocusHighlightPosition, _updateFocusHighlightPosition2).call(this));
+    this.hot.rowIndexMapper.addLocalHook('cacheUpdated', () => _classPrivateMethodGet(this, _updateFocusHighlightPosition, _updateFocusHighlightPosition2).call(this));
     super.enablePlugin();
     this.updatePlugin(); // @TODO: Workaround for broken plugin initialization abstraction.
   }
@@ -264,9 +429,9 @@ export class NestedHeaders extends BasePlugin {
     const {
       nestedHeaders
     } = this.hot.getSettings();
-    _classPrivateFieldGet(_stateManager, this).setColumnsLimit(this.hot.countCols());
+    _classPrivateFieldGet(this, _stateManager).setColumnsLimit(this.hot.countCols());
     if (Array.isArray(nestedHeaders)) {
-      this.detectedOverlappedHeaders = _classPrivateFieldGet(_stateManager, this).setState(nestedHeaders);
+      this.detectedOverlappedHeaders = _classPrivateFieldGet(this, _stateManager).setState(nestedHeaders);
     }
     if (this.detectedOverlappedHeaders) {
       warn(toSingleLine`Your Nested Headers plugin setup contains overlapping headers. This kind of configuration\x20
@@ -278,11 +443,11 @@ export class NestedHeaders extends BasePlugin {
       // as if all the columns are visible, needs to be modified to be in sync with a dataset.
       this.hot.columnIndexMapper.hidingMapsCollection.getMergedValues().forEach((isColumnHidden, physicalColumnIndex) => {
         const actionName = isColumnHidden === true ? 'hide-column' : 'show-column';
-        _classPrivateFieldGet(_stateManager, this).triggerColumnModification(actionName, physicalColumnIndex);
+        _classPrivateFieldGet(this, _stateManager).triggerColumnModification(actionName, physicalColumnIndex);
       });
     }
-    if (!_classPrivateFieldGet(_hidingIndexMapObserver, this) && this.enabled) {
-      _classPrivateFieldSet(_hidingIndexMapObserver, this, this.hot.columnIndexMapper.createChangesObserver('hiding').subscribe(changes => {
+    if (!_classPrivateFieldGet(this, _hidingIndexMapObserver) && this.enabled) {
+      _classPrivateFieldSet(this, _hidingIndexMapObserver, this.hot.columnIndexMapper.createChangesObserver('hiding').subscribe(changes => {
         changes.forEach(_ref => {
           let {
             op,
@@ -291,7 +456,7 @@ export class NestedHeaders extends BasePlugin {
           } = _ref;
           if (op === 'replace') {
             const actionName = newValue === true ? 'hide-column' : 'show-column';
-            _classPrivateFieldGet(_stateManager, this).triggerColumnModification(actionName, columnIndex);
+            _classPrivateFieldGet(this, _stateManager).triggerColumnModification(actionName, columnIndex);
           }
         });
         this.ghostTable.buildWidthsMap();
@@ -306,9 +471,9 @@ export class NestedHeaders extends BasePlugin {
    */
   disablePlugin() {
     this.clearColspans();
-    _classPrivateFieldGet(_stateManager, this).clear();
-    _classPrivateFieldGet(_hidingIndexMapObserver, this).unsubscribe();
-    _classPrivateFieldSet(_hidingIndexMapObserver, this, null);
+    _classPrivateFieldGet(this, _stateManager).clear();
+    _classPrivateFieldGet(this, _hidingIndexMapObserver).unsubscribe();
+    _classPrivateFieldSet(this, _hidingIndexMapObserver, null);
     this.ghostTable.clear();
     super.disablePlugin();
   }
@@ -320,7 +485,7 @@ export class NestedHeaders extends BasePlugin {
    * @returns {StateManager}
    */
   getStateManager() {
-    return _classPrivateFieldGet(_stateManager, this);
+    return _classPrivateFieldGet(this, _stateManager);
   }
 
   /**
@@ -330,7 +495,7 @@ export class NestedHeaders extends BasePlugin {
    * @returns {number}
    */
   getLayersCount() {
-    return _classPrivateFieldGet(_stateManager, this).getLayersCount();
+    return _classPrivateFieldGet(this, _stateManager).getLayersCount();
   }
 
   /**
@@ -344,7 +509,7 @@ export class NestedHeaders extends BasePlugin {
    * @returns {object}
    */
   getHeaderSettings(headerLevel, columnIndex) {
-    return _classPrivateFieldGet(_stateManager, this).getHeaderSettings(headerLevel, columnIndex);
+    return _classPrivateFieldGet(this, _stateManager).getHeaderSettings(headerLevel, columnIndex);
   }
 
   /**
@@ -413,7 +578,7 @@ export class NestedHeaders extends BasePlugin {
         colspan,
         isHidden,
         isPlaceholder
-      } = (_classPrivateFieldGet2 = _classPrivateFieldGet(_stateManager, this).getHeaderSettings(headerLevel, visualColumnIndex)) !== null && _classPrivateFieldGet2 !== void 0 ? _classPrivateFieldGet2 : {
+      } = (_classPrivateFieldGet2 = _classPrivateFieldGet(this, _stateManager).getHeaderSettings(headerLevel, visualColumnIndex)) !== null && _classPrivateFieldGet2 !== void 0 ? _classPrivateFieldGet2 : {
         label: ''
       };
       if (isPlaceholder || isHidden) {
@@ -454,7 +619,7 @@ export class NestedHeaders extends BasePlugin {
     const {
       isHidden,
       isPlaceholder
-    } = (_classPrivateFieldGet3 = _classPrivateFieldGet(_stateManager, this).getHeaderSettings(headerLevel, visualColumnIndex)) !== null && _classPrivateFieldGet3 !== void 0 ? _classPrivateFieldGet3 : {};
+    } = (_classPrivateFieldGet3 = _classPrivateFieldGet(this, _stateManager).getHeaderSettings(headerLevel, visualColumnIndex)) !== null && _classPrivateFieldGet3 !== void 0 ? _classPrivateFieldGet3 : {};
     if (isPlaceholder || isHidden) {
       return '';
     }
@@ -464,10 +629,10 @@ export class NestedHeaders extends BasePlugin {
    * Destroys the plugin instance.
    */
   destroy() {
-    _classPrivateFieldSet(_stateManager, this, null);
-    if (_classPrivateFieldGet(_hidingIndexMapObserver, this) !== null) {
-      _classPrivateFieldGet(_hidingIndexMapObserver, this).unsubscribe();
-      _classPrivateFieldSet(_hidingIndexMapObserver, this, null);
+    _classPrivateFieldSet(this, _stateManager, null);
+    if (_classPrivateFieldGet(this, _hidingIndexMapObserver) !== null) {
+      _classPrivateFieldGet(this, _hidingIndexMapObserver).unsubscribe();
+      _classPrivateFieldSet(this, _hidingIndexMapObserver, null);
     }
     super.destroy();
   }
@@ -483,10 +648,10 @@ export class NestedHeaders extends BasePlugin {
     if (coords.row >= 0 || coords.col < 0) {
       return;
     }
-    return _classPrivateFieldGet(_stateManager, this).getHeaderTreeNodeData(coords.row, coords.col);
+    return _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(coords.row, coords.col);
   }
 }
-function _updateFocusHighlightPosition() {
+function _updateFocusHighlightPosition2() {
   var _this$hot;
   const selection = (_this$hot = this.hot) === null || _this$hot === void 0 ? void 0 : _this$hot.getSelectedRangeLast();
   if (!selection) {
@@ -497,7 +662,7 @@ function _updateFocusHighlightPosition() {
   } = selection;
   const isNestedHeadersRange = highlight.isHeader() && highlight.col >= 0;
   if (isNestedHeadersRange) {
-    const columnIndex = _classPrivateFieldGet(_stateManager, this).findLeftMostColumnIndex(highlight.row, highlight.col);
+    const columnIndex = _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(highlight.row, highlight.col);
     const focusHighlight = this.hot.selection.highlight.getFocus();
 
     // Correct the highlight/focus selection to highlight the correct TH element
@@ -507,15 +672,7 @@ function _updateFocusHighlightPosition() {
     focusHighlight.commit();
   }
 }
-/**
- * Allows to control to which column index the viewport will be scrolled. To ensure that the viewport
- * is scrolled to the correct column for the nested header the most left and the most right visual column
- * indexes are used.
- *
- * @param {number} visualColumn A visual column index to which the viewport will be scrolled.
- * @returns {number}
- */
-function _onBeforeViewportScrollHorizontally(visualColumn) {
+function _onBeforeViewportScrollHorizontally2(visualColumn) {
   const selection = this.hot.getSelectedRangeLast();
   if (!selection) {
     return visualColumn;
@@ -529,8 +686,8 @@ function _onBeforeViewportScrollHorizontally(visualColumn) {
   }
   const firstColumn = this.hot.view.getFirstFullyVisibleColumn();
   const lastColumn = this.hot.view.getLastFullyVisibleColumn();
-  const mostLeftColumnIndex = _classPrivateFieldGet(_stateManager, this).findLeftMostColumnIndex(highlight.row, highlight.col);
-  const mostRightColumnIndex = _classPrivateFieldGet(_stateManager, this).findRightMostColumnIndex(highlight.row, highlight.col);
+  const mostLeftColumnIndex = _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(highlight.row, highlight.col);
+  const mostRightColumnIndex = _classPrivateFieldGet(this, _stateManager).findRightMostColumnIndex(highlight.row, highlight.col);
 
   // do not scroll the viewport when the header is wider than the viewport
   if (mostLeftColumnIndex < firstColumn && mostRightColumnIndex > lastColumn) {
@@ -538,16 +695,8 @@ function _onBeforeViewportScrollHorizontally(visualColumn) {
   }
   return mostLeftColumnIndex < firstColumn ? mostLeftColumnIndex : mostRightColumnIndex;
 }
-/**
- * Allows to control which header DOM element will be used to highlight.
- *
- * @param {number} visualColumn A visual column index of the highlighted row header.
- * @param {number} headerLevel A row header level that is currently highlighted.
- * @param {object} highlightMeta An object with meta data that describes the highlight state.
- * @returns {number}
- */
-function _onBeforeHighlightingColumnHeader(visualColumn, headerLevel, highlightMeta) {
-  const headerNodeData = _classPrivateFieldGet(_stateManager, this).getHeaderTreeNodeData(headerLevel, visualColumn);
+function _onBeforeHighlightingColumnHeader2(visualColumn, headerLevel, highlightMeta) {
+  const headerNodeData = _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(headerLevel, visualColumn);
   if (!headerNodeData) {
     return visualColumn;
   }
@@ -559,7 +708,7 @@ function _onBeforeHighlightingColumnHeader(visualColumn, headerLevel, highlightM
   const {
     isRoot,
     colspan
-  } = _classPrivateFieldGet(_stateManager, this).getHeaderSettings(headerLevel, visualColumn);
+  } = _classPrivateFieldGet(this, _stateManager).getHeaderSettings(headerLevel, visualColumn);
   if (selectionType === HEADER_TYPE) {
     if (!isRoot) {
       return headerNodeData.columnIndex;
@@ -572,19 +721,7 @@ function _onBeforeHighlightingColumnHeader(visualColumn, headerLevel, highlightM
   }
   return visualColumn;
 }
-/**
- * Listens the `beforeCopy` hook that allows processing the copied column headers so that the
- * merged column headers do not propagate the value for each column but only once at the beginning
- * of the column.
- *
- * @private
- * @param {Array[]} data An array of arrays which contains data to copied.
- * @param {object[]} copyableRanges An array of objects with ranges of the visual indexes (`startRow`, `startCol`, `endRow`, `endCol`)
- *                                  which will copied.
- * @param {{ columnHeadersCount: number }} copiedHeadersCount An object with keys that holds information with
- *                                                            the number of copied headers.
- */
-function _onBeforeCopy(data, copyableRanges, _ref2) {
+function _onBeforeCopy2(data, copyableRanges, _ref2) {
   let {
     columnHeadersCount
   } = _ref2;
@@ -613,7 +750,7 @@ function _onBeforeCopy(data, copyableRanges, _ref2) {
         if (zeroBasedColumnIndex === 0) {
           continue; // eslint-disable-line no-continue
         }
-        const isRoot = (_classPrivateFieldGet4 = _classPrivateFieldGet(_stateManager, this).getHeaderTreeNodeData(row, column)) === null || _classPrivateFieldGet4 === void 0 ? void 0 : _classPrivateFieldGet4.isRoot;
+        const isRoot = (_classPrivateFieldGet4 = _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(row, column)) === null || _classPrivateFieldGet4 === void 0 ? void 0 : _classPrivateFieldGet4.isRoot;
         if (isRoot === false) {
           data[zeroBasedColumnHeaderLevel][zeroBasedColumnIndex] = '';
         }
@@ -621,16 +758,7 @@ function _onBeforeCopy(data, copyableRanges, _ref2) {
     }
   }
 }
-/**
- * Allows blocking the column selection that is controlled by the core Selection module.
- *
- * @param {MouseEvent} event Mouse event.
- * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell.
- * @param {CellCoords} TD The table cell or header element.
- * @param {object} controller An object with properties `row`, `column` and `cell`. Each property contains
- *                            a boolean value that allows or disallows changing the selection for that particular area.
- */
-function _onBeforeOnCellMouseDown(event, coords, TD, controller) {
+function _onBeforeOnCellMouseDown2(event, coords, TD, controller) {
   const headerNodeData = this._getHeaderTreeNodeDataByCoords(coords);
   if (headerNodeData) {
     // Block the Selection module in controlling how the columns are selected. Pass the
@@ -638,19 +766,13 @@ function _onBeforeOnCellMouseDown(event, coords, TD, controller) {
     controller.column = true;
   }
 }
-/**
- * Allows to control how the column selection based on the coordinates and the nested headers is made.
- *
- * @param {MouseEvent} event Mouse event.
- * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell.
- */
-function _onAfterOnCellMouseDown(event, coords) {
+function _onAfterOnCellMouseDown2(event, coords) {
   const headerNodeData = this._getHeaderTreeNodeDataByCoords(coords);
   if (!headerNodeData) {
     return;
   }
-  _classPrivateFieldSet(_focusInitialCoords, this, coords.clone());
-  _classPrivateFieldSet(_isColumnsSelectionInProgress, this, true);
+  _classPrivateFieldSet(this, _focusInitialCoords, coords.clone());
+  _classPrivateFieldSet(this, _isColumnsSelectionInProgress, true);
   const {
     selection
   } = this.hot;
@@ -681,16 +803,7 @@ function _onAfterOnCellMouseDown(event, coords) {
   // The plugin takes control of how the columns are selected.
   selection.selectColumns(...columnsToSelect);
 }
-/**
- * Makes the header-selection properly select the nested headers.
- *
- * @param {MouseEvent} event Mouse event.
- * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell.
- * @param {HTMLElement} TD The cell element.
- * @param {object} controller An object with properties `row`, `column` and `cell`. Each property contains
- *                            a boolean value that allows or disallows changing the selection for that particular area.
- */
-function _onBeforeOnCellMouseOver(event, coords, TD, controller) {
+function _onBeforeOnCellMouseOver2(event, coords, TD, controller) {
   if (!this.hot.view.isMouseDown()) {
     return;
   }
@@ -724,21 +837,14 @@ function _onBeforeOnCellMouseOver(event, coords, TD, controller) {
   }
   this.hot.selection.selectColumns(...columnsToSelect);
 }
-/**
- * Switches internal flag about selection progress to `false`.
- */
-function _onBeforeOnCellMouseUp() {
-  _classPrivateFieldSet(_isColumnsSelectionInProgress, this, false);
+function _onBeforeOnCellMouseUp2() {
+  _classPrivateFieldSet(this, _isColumnsSelectionInProgress, false);
 }
-/**
- * The hook checks and ensures that the focus position that depends on the selected columns
- * range is always positioned within the range.
- */
-function _onBeforeSelectionHighlightSet() {
+function _onBeforeSelectionHighlightSet2() {
   const {
     navigableHeaders
   } = this.hot.getSettings();
-  if (!this.hot.view.isMouseDown() || !_classPrivateFieldGet(_isColumnsSelectionInProgress, this) || !navigableHeaders) {
+  if (!this.hot.view.isMouseDown() || !_classPrivateFieldGet(this, _isColumnsSelectionInProgress) || !navigableHeaders) {
     return;
   }
   const selectedRange = this.hot.getSelectedRangeLast();
@@ -747,20 +853,15 @@ function _onBeforeSelectionHighlightSet() {
   const {
     columnIndex,
     origColspan
-  } = _classPrivateFieldGet(_stateManager, this).getHeaderTreeNodeData(_classPrivateFieldGet(_focusInitialCoords, this).row, _classPrivateFieldGet(_focusInitialCoords, this).col);
-  selectedRange.setHighlight(_classPrivateFieldGet(_focusInitialCoords, this));
+  } = _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(_classPrivateFieldGet(this, _focusInitialCoords).row, _classPrivateFieldGet(this, _focusInitialCoords).col);
+  selectedRange.setHighlight(_classPrivateFieldGet(this, _focusInitialCoords));
   if (origColspan > selectedRange.getWidth() || columnIndex < columnStart || columnIndex + origColspan - 1 > columnEnd) {
-    const headerLevel = _classPrivateFieldGet(_stateManager, this).findTopMostEntireHeaderLevel(clamp(columnStart, columnIndex, columnIndex + origColspan - 1), clamp(columnEnd, columnIndex, columnIndex + origColspan - 1));
+    const headerLevel = _classPrivateFieldGet(this, _stateManager).findTopMostEntireHeaderLevel(clamp(columnStart, columnIndex, columnIndex + origColspan - 1), clamp(columnEnd, columnIndex, columnIndex + origColspan - 1));
     selectedRange.highlight.row = headerLevel;
     selectedRange.highlight.col = selectedRange.from.col;
   }
 }
-/**
- * `modifyTransformStart` hook is called every time the keyboard navigation is used.
- *
- * @param {object} delta The transformation delta.
- */
-function _onModifyTransformStart(delta) {
+function _onModifyTransformStart2(delta) {
   const {
     highlight
   } = this.hot.getSelectedRangeLast();
@@ -769,8 +870,8 @@ function _onModifyTransformStart(delta) {
   if (!isNestedHeadersRange) {
     return;
   }
-  const visualColumnIndexStart = _classPrivateFieldGet(_stateManager, this).findLeftMostColumnIndex(nextCoords.row, nextCoords.col);
-  const visualColumnIndexEnd = _classPrivateFieldGet(_stateManager, this).findRightMostColumnIndex(nextCoords.row, nextCoords.col);
+  const visualColumnIndexStart = _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(nextCoords.row, nextCoords.col);
+  const visualColumnIndexEnd = _classPrivateFieldGet(this, _stateManager).findRightMostColumnIndex(nextCoords.row, nextCoords.col);
   if (delta.col < 0) {
     const nextColumn = highlight.col >= visualColumnIndexStart && highlight.col <= visualColumnIndexEnd ? visualColumnIndexStart - 1 : visualColumnIndexEnd;
     const notHiddenColumnIndex = this.hot.columnIndexMapper.getNearestNotHiddenIndex(nextColumn, -1);
@@ -793,14 +894,7 @@ function _onModifyTransformStart(delta) {
     }
   }
 }
-/**
- * The hook observes the column selection from the Selection API and modifies the column range to
- * ensure that the whole nested column will be covered.
- *
- * @param {CellCoords} from The coords object where the selection starts.
- * @param {CellCoords} to The coords object where the selection ends.
- */
-function _onBeforeSelectColumns(from, to) {
+function _onBeforeSelectColumns2(from, to) {
   const headerLevel = from.row;
   const startNodeData = this._getHeaderTreeNodeDataByCoords({
     row: headerLevel,
@@ -828,28 +922,18 @@ function _onBeforeSelectColumns(from, to) {
     }
   }
 }
-/**
- * `afterGetColumnHeader` hook callback - prepares the header structure.
- *
- * @param {Array} renderersArray Array of renderers.
- */
-function _onAfterGetColumnHeaderRenderers(renderersArray) {
+function _onAfterGetColumnHeaderRenderers2(renderersArray) {
   renderersArray.length = 0;
-  for (let headerLayer = 0; headerLayer < _classPrivateFieldGet(_stateManager, this).getLayersCount(); headerLayer++) {
+  for (let headerLayer = 0; headerLayer < _classPrivateFieldGet(this, _stateManager).getLayersCount(); headerLayer++) {
     renderersArray.push(this.headerRendererFactory(headerLayer));
   }
 }
-/**
- * Make the renderer render the first nested column in its entirety.
- *
- * @param {object} calc Viewport column calculator.
- */
-function _onAfterViewportColumnCalculatorOverride(calc) {
-  const headerLayersCount = _classPrivateFieldGet(_stateManager, this).getLayersCount();
+function _onAfterViewportColumnCalculatorOverride2(calc) {
+  const headerLayersCount = _classPrivateFieldGet(this, _stateManager).getLayersCount();
   let newStartColumn = calc.startColumn;
   let nonRenderable = !!headerLayersCount;
   for (let headerLayer = 0; headerLayer < headerLayersCount; headerLayer++) {
-    const startColumn = _classPrivateFieldGet(_stateManager, this).findLeftMostColumnIndex(headerLayer, calc.startColumn);
+    const startColumn = _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(headerLayer, calc.startColumn);
     const renderedStartColumn = this.hot.columnIndexMapper.getRenderableFromVisualIndex(startColumn);
 
     // If any of the headers for that column index is rendered, all of them should be rendered properly, see
@@ -868,67 +952,31 @@ function _onAfterViewportColumnCalculatorOverride(calc) {
 
   // If no headers for the provided column index are renderable, start rendering from the beginning of the upmost
   // header for that position.
-  calc.startColumn = nonRenderable ? _classPrivateFieldGet(_stateManager, this).getHeaderTreeNodeData(0, newStartColumn).columnIndex : newStartColumn;
+  calc.startColumn = nonRenderable ? _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(0, newStartColumn).columnIndex : newStartColumn;
 }
-/**
- * `modifyColWidth` hook callback - returns width from cache, when is greater than incoming from hook.
- *
- * @param {number} width Width from hook.
- * @param {number} column Visual index of an column.
- * @returns {number}
- */
-function _onModifyColWidth(width, column) {
+function _onModifyColWidth2(width, column) {
   const cachedWidth = this.ghostTable.getWidth(column);
   return width > cachedWidth ? width : cachedWidth;
 }
-/**
- * Listens the `modifyColumnHeaderValue` hook that overwrites the column headers values based on
- * the internal state and settings of the plugin.
- *
- * @param {string} value The column header value.
- * @param {number} visualColumnIndex The visual column index.
- * @param {number} headerLevel The index of header level. The header level accepts positive (0 to N)
- *                             and negative (-1 to -N) values. For positive values, 0 points to the
- *                             top most header, and for negative direction, -1 points to the most bottom
- *                             header (the header closest to the cells).
- * @returns {string} Returns the column header value to update.
- */
-function _onModifyColumnHeaderValue(value, visualColumnIndex, headerLevel) {
+function _onModifyColumnHeaderValue2(value, visualColumnIndex, headerLevel) {
   var _classPrivateFieldGet5;
   const {
     label
-  } = (_classPrivateFieldGet5 = _classPrivateFieldGet(_stateManager, this).getHeaderTreeNodeData(headerLevel, visualColumnIndex)) !== null && _classPrivateFieldGet5 !== void 0 ? _classPrivateFieldGet5 : {
+  } = (_classPrivateFieldGet5 = _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(headerLevel, visualColumnIndex)) !== null && _classPrivateFieldGet5 !== void 0 ? _classPrivateFieldGet5 : {
     label: ''
   };
   return label;
 }
-/**
- * `modifyFocusedElement` hook callback.
- *
- * @param {number} row Row index.
- * @param {number} column Column index.
- * @returns {HTMLTableCellElement} The `TH` element to be focused.
- */
-function _onModifyFocusedElement(row, column) {
+function _onModifyFocusedElement2(row, column) {
   if (row < 0) {
-    return this.hot.getCell(row, _classPrivateFieldGet(_stateManager, this).findLeftMostColumnIndex(row, column), true);
+    return this.hot.getCell(row, _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(row, column), true);
   }
 }
-/**
- * Updates the plugin state after HoT initialization.
- */
-function _onInit() {
+function _onInit2() {
   // @TODO: Workaround for broken plugin initialization abstraction.
   this.updatePlugin();
 }
-/**
- * Updates the plugin state after new dataset load.
- *
- * @param {Array[]} sourceData Array of arrays or array of objects containing data.
- * @param {boolean} initialLoad Flag that determines whether the data has been loaded
- *                              during the initialization.
- */
-function _onAfterLoadData(sourceData, initialLoad) {
+function _onAfterLoadData2(sourceData, initialLoad) {
   if (!initialLoad) {
     this.updatePlugin();
   }