handsontable 0.0.0-next-53a190b-20240403 → 0.0.0-next-5a535ed-20240403

package/plugins/manualColumnResize/manualColumnResize.js

@@ -1,7 +1,7 @@
 "use strict";
 
-exports.__esModule = true;
 require("core-js/modules/es.error.cause.js");
+exports.__esModule = true;
 require("core-js/modules/es.array.push.js");
 var _base = require("../base");
 var _element = require("../../helpers/dom/element");
@@ -11,9 +11,12 @@ var _translations = require("../../translations");
 function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
 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 _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+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; }
 // Developer note! Whenever you make a change in this file, make an analogous change in manualRowResize.js
 
 const PLUGIN_KEY = exports.PLUGIN_KEY = 'manualColumnResize';
@@ -50,7 +53,15 @@ var _dblclick = /*#__PURE__*/new WeakMap();
 var _autoresizeTimeout = /*#__PURE__*/new WeakMap();
 var _columnWidthsMap = /*#__PURE__*/new WeakMap();
 var _config = /*#__PURE__*/new WeakMap();
-var _ManualColumnResize_brand = /*#__PURE__*/new WeakSet();
+var _onMapInit = /*#__PURE__*/new WeakSet();
+var _onMouseOver = /*#__PURE__*/new WeakSet();
+var _onMouseDown = /*#__PURE__*/new WeakSet();
+var _onMouseMove = /*#__PURE__*/new WeakSet();
+var _onMouseUp = /*#__PURE__*/new WeakSet();
+var _onContextMenu = /*#__PURE__*/new WeakSet();
+var _onModifyColWidth = /*#__PURE__*/new WeakSet();
+var _onBeforeStretchingColumnWidth = /*#__PURE__*/new WeakSet();
+var _onBeforeColumnResize = /*#__PURE__*/new WeakSet();
 class ManualColumnResize extends _base.BasePlugin {
   static get PLUGIN_KEY() {
     return PLUGIN_KEY;
@@ -65,79 +76,176 @@ class ManualColumnResize extends _base.BasePlugin {
 
   constructor(hotInstance) {
     super(hotInstance);
+    /**
+     * `beforeColumnResize` hook callback.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeColumnResize);
+    /**
+     * Modifies the provided column stretched width. This hook decides if specified column should be stretched or not.
+     *
+     * @param {number} stretchedWidth Stretched width.
+     * @param {number} column Visual column index.
+     * @returns {number}
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeStretchingColumnWidth);
+    /**
+     * Modifies the provided column width, based on the plugin settings.
+     *
+     * @param {number} width Column width.
+     * @param {number} column Visual column index.
+     * @returns {number}
+     */
+    _classPrivateMethodInitSpec(this, _onModifyColWidth);
+    /**
+     * Callback for "contextmenu" event triggered on element showing move handle. It removes handle and guide elements.
+     */
+    _classPrivateMethodInitSpec(this, _onContextMenu);
+    /**
+     * 'mouseup' event callback - apply the column resizing.
+     *
+     * @fires Hooks#beforeColumnResize
+     * @fires Hooks#afterColumnResize
+     */
+    _classPrivateMethodInitSpec(this, _onMouseUp);
+    /**
+     * 'mousemove' event callback - refresh the handle and guide positions, cache the new column width.
+     *
+     * @param {MouseEvent} event The mouse event.
+     */
+    _classPrivateMethodInitSpec(this, _onMouseMove);
+    /**
+     * 'mousedown' event callback.
+     *
+     * @param {MouseEvent} event The mouse event.
+     */
+    _classPrivateMethodInitSpec(this, _onMouseDown);
+    /**
+     * 'mouseover' event callback - set the handle position.
+     *
+     * @param {MouseEvent} event The mouse event.
+     */
+    _classPrivateMethodInitSpec(this, _onMouseOver);
     /**
      * Callback to call on map's `init` local hook.
      *
      * @private
      */
-    _classPrivateMethodInitSpec(this, _ManualColumnResize_brand);
-    _classPrivateFieldInitSpec(this, _currentTH, null);
+    _classPrivateMethodInitSpec(this, _onMapInit);
+    _classPrivateFieldInitSpec(this, _currentTH, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _currentCol, null);
+    _classPrivateFieldInitSpec(this, _currentCol, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number[]}
      */
-    _classPrivateFieldInitSpec(this, _selectedCols, []);
+    _classPrivateFieldInitSpec(this, _selectedCols, {
+      writable: true,
+      value: []
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _currentWidth, null);
+    _classPrivateFieldInitSpec(this, _currentWidth, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _newSize, null);
+    _classPrivateFieldInitSpec(this, _newSize, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _startY, null);
+    _classPrivateFieldInitSpec(this, _startY, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _startWidth, null);
+    _classPrivateFieldInitSpec(this, _startWidth, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _startOffset, null);
+    _classPrivateFieldInitSpec(this, _startOffset, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {HTMLElement}
      */
-    _classPrivateFieldInitSpec(this, _handle, this.hot.rootDocument.createElement('DIV'));
+    _classPrivateFieldInitSpec(this, _handle, {
+      writable: true,
+      value: this.hot.rootDocument.createElement('DIV')
+    });
     /**
      * @type {HTMLElement}
      */
-    _classPrivateFieldInitSpec(this, _guide, this.hot.rootDocument.createElement('DIV'));
+    _classPrivateFieldInitSpec(this, _guide, {
+      writable: true,
+      value: this.hot.rootDocument.createElement('DIV')
+    });
     /**
      * @type {boolean}
      */
-    _classPrivateFieldInitSpec(this, _pressed, null);
+    _classPrivateFieldInitSpec(this, _pressed, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {boolean}
      */
-    _classPrivateFieldInitSpec(this, _isTriggeredByRMB, false);
+    _classPrivateFieldInitSpec(this, _isTriggeredByRMB, {
+      writable: true,
+      value: false
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _dblclick, 0);
+    _classPrivateFieldInitSpec(this, _dblclick, {
+      writable: true,
+      value: 0
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _autoresizeTimeout, null);
+    _classPrivateFieldInitSpec(this, _autoresizeTimeout, {
+      writable: true,
+      value: null
+    });
     /**
      * PhysicalIndexToValueMap to keep and track widths for physical column indexes.
      *
      * @type {PhysicalIndexToValueMap}
      */
-    _classPrivateFieldInitSpec(this, _columnWidthsMap, void 0);
+    _classPrivateFieldInitSpec(this, _columnWidthsMap, {
+      writable: true,
+      value: void 0
+    });
     /**
      * Private pool to save configuration from updateSettings.
      *
      * @type {object}
      */
-    _classPrivateFieldInitSpec(this, _config, void 0);
-    (0, _element.addClass)(_classPrivateFieldGet(_handle, this), 'manualColumnResizer');
-    (0, _element.addClass)(_classPrivateFieldGet(_guide, this), 'manualColumnResizerGuide');
+    _classPrivateFieldInitSpec(this, _config, {
+      writable: true,
+      value: void 0
+    });
+    (0, _element.addClass)(_classPrivateFieldGet(this, _handle), 'manualColumnResizer');
+    (0, _element.addClass)(_classPrivateFieldGet(this, _guide), 'manualColumnResizerGuide');
   }
 
   /**
@@ -165,12 +273,12 @@ class ManualColumnResize extends _base.BasePlugin {
     if (this.enabled) {
       return;
     }
-    _classPrivateFieldSet(_columnWidthsMap, this, new _translations.PhysicalIndexToValueMap());
-    _classPrivateFieldGet(_columnWidthsMap, this).addLocalHook('init', () => _assertClassBrand(_ManualColumnResize_brand, this, _onMapInit).call(this));
-    this.hot.columnIndexMapper.registerMap(this.pluginName, _classPrivateFieldGet(_columnWidthsMap, this));
-    this.addHook('modifyColWidth', (width, col) => _assertClassBrand(_ManualColumnResize_brand, this, _onModifyColWidth).call(this, width, col));
-    this.addHook('beforeStretchingColumnWidth', (stretchedWidth, column) => _assertClassBrand(_ManualColumnResize_brand, this, _onBeforeStretchingColumnWidth).call(this, stretchedWidth, column));
-    this.addHook('beforeColumnResize', (newSize, column, isDoubleClick) => _assertClassBrand(_ManualColumnResize_brand, this, _onBeforeColumnResize).call(this, newSize, column, isDoubleClick));
+    _classPrivateFieldSet(this, _columnWidthsMap, new _translations.PhysicalIndexToValueMap());
+    _classPrivateFieldGet(this, _columnWidthsMap).addLocalHook('init', () => _classPrivateMethodGet(this, _onMapInit, _onMapInit2).call(this));
+    this.hot.columnIndexMapper.registerMap(this.pluginName, _classPrivateFieldGet(this, _columnWidthsMap));
+    this.addHook('modifyColWidth', (width, col) => _classPrivateMethodGet(this, _onModifyColWidth, _onModifyColWidth2).call(this, width, col));
+    this.addHook('beforeStretchingColumnWidth', (stretchedWidth, column) => _classPrivateMethodGet(this, _onBeforeStretchingColumnWidth, _onBeforeStretchingColumnWidth2).call(this, stretchedWidth, column));
+    this.addHook('beforeColumnResize', (newSize, column, isDoubleClick) => _classPrivateMethodGet(this, _onBeforeColumnResize, _onBeforeColumnResize2).call(this, newSize, column, isDoubleClick));
     this.bindEvents();
     super.enablePlugin();
   }
@@ -191,7 +299,7 @@ class ManualColumnResize extends _base.BasePlugin {
    * Disables the plugin functionality for this Handsontable instance.
    */
   disablePlugin() {
-    _classPrivateFieldSet(_config, this, _classPrivateFieldGet(_columnWidthsMap, this).getValues());
+    _classPrivateFieldSet(this, _config, _classPrivateFieldGet(this, _columnWidthsMap).getValues());
     this.hot.columnIndexMapper.unregisterMap(this.pluginName);
     super.disablePlugin();
   }
@@ -202,7 +310,7 @@ class ManualColumnResize extends _base.BasePlugin {
    * @fires Hooks#persistentStateSave
    */
   saveManualColumnWidths() {
-    this.hot.runHooks('persistentStateSave', PERSISTENT_STATE_KEY, _classPrivateFieldGet(_columnWidthsMap, this).getValues());
+    this.hot.runHooks('persistentStateSave', PERSISTENT_STATE_KEY, _classPrivateFieldGet(this, _columnWidthsMap).getValues());
   }
 
   /**
@@ -227,7 +335,7 @@ class ManualColumnResize extends _base.BasePlugin {
   setManualSize(column, width) {
     const newWidth = Math.max(width, 20);
     const physicalColumn = this.hot.toPhysicalColumn(column);
-    _classPrivateFieldGet(_columnWidthsMap, this).setValueAtIndex(physicalColumn, newWidth);
+    _classPrivateFieldGet(this, _columnWidthsMap).setValueAtIndex(physicalColumn, newWidth);
     return newWidth;
   }
 
@@ -238,7 +346,7 @@ class ManualColumnResize extends _base.BasePlugin {
    */
   clearManualSize(column) {
     const physicalColumn = this.hot.toPhysicalColumn(column);
-    _classPrivateFieldGet(_columnWidthsMap, this).setValueAtIndex(physicalColumn, null);
+    _classPrivateFieldGet(this, _columnWidthsMap).setValueAtIndex(physicalColumn, null);
   }
   /**
    * Set the resize handle position.
@@ -250,34 +358,34 @@ class ManualColumnResize extends _base.BasePlugin {
     if (!TH.parentNode) {
       return;
     }
-    _classPrivateFieldSet(_currentTH, this, TH);
+    _classPrivateFieldSet(this, _currentTH, TH);
     const {
       _wt: wt
     } = this.hot.view;
-    const cellCoords = wt.wtTable.getCoords(_classPrivateFieldGet(_currentTH, this));
+    const cellCoords = wt.wtTable.getCoords(_classPrivateFieldGet(this, _currentTH));
     const col = cellCoords.col;
 
     // Ignore column headers.
     if (col < 0) {
       return;
     }
-    const headerHeight = (0, _element.outerHeight)(_classPrivateFieldGet(_currentTH, this));
-    const box = _classPrivateFieldGet(_currentTH, this).getBoundingClientRect();
+    const headerHeight = (0, _element.outerHeight)(_classPrivateFieldGet(this, _currentTH));
+    const box = _classPrivateFieldGet(this, _currentTH).getBoundingClientRect();
     // Read "fixedColumnsStart" through the Walkontable as in that context, the fixed columns
     // are modified (reduced by the number of hidden columns) by TableView module.
     const fixedColumn = col < wt.getSetting('fixedColumnsStart');
     let relativeHeaderPosition;
     if (fixedColumn) {
-      relativeHeaderPosition = wt.wtOverlays.topInlineStartCornerOverlay.getRelativeCellPosition(_classPrivateFieldGet(_currentTH, this), cellCoords.row, cellCoords.col);
+      relativeHeaderPosition = wt.wtOverlays.topInlineStartCornerOverlay.getRelativeCellPosition(_classPrivateFieldGet(this, _currentTH), cellCoords.row, cellCoords.col);
     }
 
     // If the TH is not a child of the top-left overlay, recalculate using
     // the top overlay - as this overlay contains the rest of the headers.
     if (!relativeHeaderPosition) {
-      relativeHeaderPosition = wt.wtOverlays.topOverlay.getRelativeCellPosition(_classPrivateFieldGet(_currentTH, this), cellCoords.row, cellCoords.col);
+      relativeHeaderPosition = wt.wtOverlays.topOverlay.getRelativeCellPosition(_classPrivateFieldGet(this, _currentTH), cellCoords.row, cellCoords.col);
     }
-    _classPrivateFieldSet(_currentCol, this, this.hot.columnIndexMapper.getVisualFromRenderableIndex(col));
-    _classPrivateFieldSet(_selectedCols, this, []);
+    _classPrivateFieldSet(this, _currentCol, this.hot.columnIndexMapper.getVisualFromRenderableIndex(col));
+    _classPrivateFieldSet(this, _selectedCols, []);
     const isFullColumnSelected = this.hot.selection.isSelectedByCorner() || this.hot.selection.isSelectedByColumnHeader();
     if (this.hot.selection.isSelected() && isFullColumnSelected) {
       const selectionRanges = this.hot.getSelectedRange();
@@ -287,23 +395,23 @@ class ManualColumnResize extends _base.BasePlugin {
 
         // Add every selected column for resize action.
         (0, _number.rangeEach)(fromColumn, toColumn, columnIndex => {
-          if (!_classPrivateFieldGet(_selectedCols, this).includes(columnIndex)) {
-            _classPrivateFieldGet(_selectedCols, this).push(columnIndex);
+          if (!_classPrivateFieldGet(this, _selectedCols).includes(columnIndex)) {
+            _classPrivateFieldGet(this, _selectedCols).push(columnIndex);
           }
         });
       });
     }
 
     // Resizing element beyond the current selection (also when there is no selection).
-    if (!_classPrivateFieldGet(_selectedCols, this).includes(_classPrivateFieldGet(_currentCol, this))) {
-      _classPrivateFieldSet(_selectedCols, this, [_classPrivateFieldGet(_currentCol, this)]);
+    if (!_classPrivateFieldGet(this, _selectedCols).includes(_classPrivateFieldGet(this, _currentCol))) {
+      _classPrivateFieldSet(this, _selectedCols, [_classPrivateFieldGet(this, _currentCol)]);
     }
-    _classPrivateFieldSet(_startOffset, this, relativeHeaderPosition.start - 6);
-    _classPrivateFieldSet(_startWidth, this, parseInt(box.width, 10));
-    _classPrivateFieldGet(_handle, this).style.top = `${relativeHeaderPosition.top}px`;
-    _classPrivateFieldGet(_handle, this).style[this.inlineDir] = `${_classPrivateFieldGet(_startOffset, this) + _classPrivateFieldGet(_startWidth, this)}px`;
-    _classPrivateFieldGet(_handle, this).style.height = `${headerHeight}px`;
-    this.hot.rootElement.appendChild(_classPrivateFieldGet(_handle, this));
+    _classPrivateFieldSet(this, _startOffset, relativeHeaderPosition.start - 6);
+    _classPrivateFieldSet(this, _startWidth, parseInt(box.width, 10));
+    _classPrivateFieldGet(this, _handle).style.top = `${relativeHeaderPosition.top}px`;
+    _classPrivateFieldGet(this, _handle).style[this.inlineDir] = `${_classPrivateFieldGet(this, _startOffset) + _classPrivateFieldGet(this, _startWidth)}px`;
+    _classPrivateFieldGet(this, _handle).style.height = `${headerHeight}px`;
+    this.hot.rootElement.appendChild(_classPrivateFieldGet(this, _handle));
   }
 
   /**
@@ -312,7 +420,7 @@ class ManualColumnResize extends _base.BasePlugin {
    * @private
    */
   refreshHandlePosition() {
-    _classPrivateFieldGet(_handle, this).style[this.inlineDir] = `${_classPrivateFieldGet(_startOffset, this) + _classPrivateFieldGet(_currentWidth, this)}px`;
+    _classPrivateFieldGet(this, _handle).style[this.inlineDir] = `${_classPrivateFieldGet(this, _startOffset) + _classPrivateFieldGet(this, _currentWidth)}px`;
   }
 
   /**
@@ -321,15 +429,15 @@ class ManualColumnResize extends _base.BasePlugin {
    * @private
    */
   setupGuidePosition() {
-    const handleHeight = parseInt((0, _element.outerHeight)(_classPrivateFieldGet(_handle, this)), 10);
-    const handleBottomPosition = parseInt(_classPrivateFieldGet(_handle, this).style.top, 10) + handleHeight;
+    const handleHeight = parseInt((0, _element.outerHeight)(_classPrivateFieldGet(this, _handle)), 10);
+    const handleBottomPosition = parseInt(_classPrivateFieldGet(this, _handle).style.top, 10) + handleHeight;
     const maximumVisibleElementHeight = parseInt(this.hot.view.maximumVisibleElementHeight(0), 10);
-    (0, _element.addClass)(_classPrivateFieldGet(_handle, this), 'active');
-    (0, _element.addClass)(_classPrivateFieldGet(_guide, this), 'active');
-    _classPrivateFieldGet(_guide, this).style.top = `${handleBottomPosition}px`;
+    (0, _element.addClass)(_classPrivateFieldGet(this, _handle), 'active');
+    (0, _element.addClass)(_classPrivateFieldGet(this, _guide), 'active');
+    _classPrivateFieldGet(this, _guide).style.top = `${handleBottomPosition}px`;
     this.refreshGuidePosition();
-    _classPrivateFieldGet(_guide, this).style.height = `${maximumVisibleElementHeight - handleHeight}px`;
-    this.hot.rootElement.appendChild(_classPrivateFieldGet(_guide, this));
+    _classPrivateFieldGet(this, _guide).style.height = `${maximumVisibleElementHeight - handleHeight}px`;
+    this.hot.rootElement.appendChild(_classPrivateFieldGet(this, _guide));
   }
 
   /**
@@ -338,7 +446,7 @@ class ManualColumnResize extends _base.BasePlugin {
    * @private
    */
   refreshGuidePosition() {
-    _classPrivateFieldGet(_guide, this).style[this.inlineDir] = _classPrivateFieldGet(_handle, this).style[this.inlineDir];
+    _classPrivateFieldGet(this, _guide).style[this.inlineDir] = _classPrivateFieldGet(this, _handle).style[this.inlineDir];
   }
 
   /**
@@ -347,8 +455,8 @@ class ManualColumnResize extends _base.BasePlugin {
    * @private
    */
   hideHandleAndGuide() {
-    (0, _element.removeClass)(_classPrivateFieldGet(_handle, this), 'active');
-    (0, _element.removeClass)(_classPrivateFieldGet(_guide, this), 'active');
+    (0, _element.removeClass)(_classPrivateFieldGet(this, _handle), 'active');
+    (0, _element.removeClass)(_classPrivateFieldGet(this, _guide), 'active');
   }
 
   /**
@@ -383,13 +491,6 @@ class ManualColumnResize extends _base.BasePlugin {
     }
     return null;
   }
-
-  /**
-   * 'mouseover' event callback - set the handle position.
-   *
-   * @param {MouseEvent} event The mouse event.
-   */
-
   /**
    * Auto-size row after doubleclick - callback.
    *
@@ -404,44 +505,37 @@ class ManualColumnResize extends _base.BasePlugin {
       this.hot.view.adjustElementsSize(true);
     };
     const resize = (column, forceRender) => {
-      const hookNewSize = this.hot.runHooks('beforeColumnResize', _classPrivateFieldGet(_newSize, this), column, true);
+      const hookNewSize = this.hot.runHooks('beforeColumnResize', _classPrivateFieldGet(this, _newSize), column, true);
       if (hookNewSize !== undefined) {
-        _classPrivateFieldSet(_newSize, this, hookNewSize);
+        _classPrivateFieldSet(this, _newSize, hookNewSize);
       }
       if (this.hot.getSettings().stretchH === 'all') {
         this.clearManualSize(column);
       } else {
-        this.setManualSize(column, _classPrivateFieldGet(_newSize, this)); // double click sets by auto row size plugin
+        this.setManualSize(column, _classPrivateFieldGet(this, _newSize)); // double click sets by auto row size plugin
       }
       this.saveManualColumnWidths();
-      this.hot.runHooks('afterColumnResize', _classPrivateFieldGet(_newSize, this), column, true);
+      this.hot.runHooks('afterColumnResize', _classPrivateFieldGet(this, _newSize), column, true);
       if (forceRender) {
         render();
       }
     };
-    if (_classPrivateFieldGet(_dblclick, this) >= 2) {
-      const selectedColsLength = _classPrivateFieldGet(_selectedCols, this).length;
+    if (_classPrivateFieldGet(this, _dblclick) >= 2) {
+      const selectedColsLength = _classPrivateFieldGet(this, _selectedCols).length;
       if (selectedColsLength > 1) {
-        (0, _array.arrayEach)(_classPrivateFieldGet(_selectedCols, this), selectedCol => {
+        (0, _array.arrayEach)(_classPrivateFieldGet(this, _selectedCols), selectedCol => {
           resize(selectedCol);
         });
         render();
       } else {
-        (0, _array.arrayEach)(_classPrivateFieldGet(_selectedCols, this), selectedCol => {
+        (0, _array.arrayEach)(_classPrivateFieldGet(this, _selectedCols), selectedCol => {
           resize(selectedCol, true);
         });
       }
     }
-    _classPrivateFieldSet(_dblclick, this, 0);
-    _classPrivateFieldSet(_autoresizeTimeout, this, null);
+    _classPrivateFieldSet(this, _dblclick, 0);
+    _classPrivateFieldSet(this, _autoresizeTimeout, null);
   }
-
-  /**
-   * 'mousedown' event callback.
-   *
-   * @param {MouseEvent} event The mouse event.
-   */
-
   /**
    * Binds the mouse events.
    *
@@ -452,21 +546,12 @@ class ManualColumnResize extends _base.BasePlugin {
       rootWindow,
       rootElement
     } = this.hot;
-    this.eventManager.addEventListener(rootElement, 'mouseover', e => _assertClassBrand(_ManualColumnResize_brand, this, _onMouseOver).call(this, e));
-    this.eventManager.addEventListener(rootElement, 'mousedown', e => _assertClassBrand(_ManualColumnResize_brand, this, _onMouseDown).call(this, e));
-    this.eventManager.addEventListener(rootWindow, 'mousemove', e => _assertClassBrand(_ManualColumnResize_brand, this, _onMouseMove).call(this, e));
-    this.eventManager.addEventListener(rootWindow, 'mouseup', () => _assertClassBrand(_ManualColumnResize_brand, this, _onMouseUp).call(this));
-    this.eventManager.addEventListener(_classPrivateFieldGet(_handle, this), 'contextmenu', () => _assertClassBrand(_ManualColumnResize_brand, this, _onContextMenu).call(this));
+    this.eventManager.addEventListener(rootElement, 'mouseover', e => _classPrivateMethodGet(this, _onMouseOver, _onMouseOver2).call(this, e));
+    this.eventManager.addEventListener(rootElement, 'mousedown', e => _classPrivateMethodGet(this, _onMouseDown, _onMouseDown2).call(this, e));
+    this.eventManager.addEventListener(rootWindow, 'mousemove', e => _classPrivateMethodGet(this, _onMouseMove, _onMouseMove2).call(this, e));
+    this.eventManager.addEventListener(rootWindow, 'mouseup', () => _classPrivateMethodGet(this, _onMouseUp, _onMouseUp2).call(this));
+    this.eventManager.addEventListener(_classPrivateFieldGet(this, _handle), 'contextmenu', () => _classPrivateMethodGet(this, _onContextMenu, _onContextMenu2).call(this));
   }
-
-  /**
-   * Modifies the provided column width, based on the plugin settings.
-   *
-   * @param {number} width Column width.
-   * @param {number} column Visual column index.
-   * @returns {number}
-   */
-
   /**
    * Destroys the plugin instance.
    */
@@ -475,31 +560,31 @@ class ManualColumnResize extends _base.BasePlugin {
   }
 }
 exports.ManualColumnResize = ManualColumnResize;
-function _onMapInit() {
+function _onMapInit2() {
   const initialSetting = this.hot.getSettings()[PLUGIN_KEY];
   const loadedManualColumnWidths = this.loadManualColumnWidths();
   if (typeof loadedManualColumnWidths !== 'undefined') {
     this.hot.batchExecution(() => {
       loadedManualColumnWidths.forEach((width, physicalIndex) => {
-        _classPrivateFieldGet(_columnWidthsMap, this).setValueAtIndex(physicalIndex, width);
+        _classPrivateFieldGet(this, _columnWidthsMap).setValueAtIndex(physicalIndex, width);
       });
     }, true);
   } else if (Array.isArray(initialSetting)) {
     this.hot.batchExecution(() => {
       initialSetting.forEach((width, physicalIndex) => {
-        _classPrivateFieldGet(_columnWidthsMap, this).setValueAtIndex(physicalIndex, width);
+        _classPrivateFieldGet(this, _columnWidthsMap).setValueAtIndex(physicalIndex, width);
       });
     }, true);
-    _classPrivateFieldSet(_config, this, initialSetting);
-  } else if (initialSetting === true && Array.isArray(_classPrivateFieldGet(_config, this))) {
+    _classPrivateFieldSet(this, _config, initialSetting);
+  } else if (initialSetting === true && Array.isArray(_classPrivateFieldGet(this, _config))) {
     this.hot.batchExecution(() => {
-      _classPrivateFieldGet(_config, this).forEach((width, physicalIndex) => {
-        _classPrivateFieldGet(_columnWidthsMap, this).setValueAtIndex(physicalIndex, width);
+      _classPrivateFieldGet(this, _config).forEach((width, physicalIndex) => {
+        _classPrivateFieldGet(this, _columnWidthsMap).setValueAtIndex(physicalIndex, width);
       });
     }, true);
   }
 }
-function _onMouseOver(event) {
+function _onMouseOver2(event) {
   // Workaround for #6926 - if the `event.target` is temporarily detached, we can skip this callback and wait for
   // the next `onmouseover`.
   if ((0, _element.isDetached)(event.target)) {
@@ -507,7 +592,7 @@ function _onMouseOver(event) {
   }
 
   // A "mouseover" action is triggered right after executing "contextmenu" event. It should be ignored.
-  if (_classPrivateFieldGet(_isTriggeredByRMB, this) === true) {
+  if (_classPrivateFieldGet(this, _isTriggeredByRMB) === true) {
     return;
   }
   if (this.checkIfColumnHeader(event.target)) {
@@ -517,129 +602,105 @@ function _onMouseOver(event) {
     }
     const colspan = th.getAttribute('colspan');
     if (th && (colspan === null || colspan === '1')) {
-      if (!_classPrivateFieldGet(_pressed, this)) {
+      if (!_classPrivateFieldGet(this, _pressed)) {
         this.setupHandlePosition(th);
       }
     }
   }
 }
-function _onMouseDown(event) {
+function _onMouseDown2(event) {
   if (event.target.parentNode !== this.hot.rootElement) {
     return;
   }
   if ((0, _element.hasClass)(event.target, 'manualColumnResizer')) {
-    this.setupHandlePosition(_classPrivateFieldGet(_currentTH, this));
+    this.setupHandlePosition(_classPrivateFieldGet(this, _currentTH));
     this.setupGuidePosition();
-    _classPrivateFieldSet(_pressed, this, true);
-    if (_classPrivateFieldGet(_autoresizeTimeout, this) === null) {
-      _classPrivateFieldSet(_autoresizeTimeout, this, setTimeout(() => this.afterMouseDownTimeout(), 500));
-      this.hot._registerTimeout(_classPrivateFieldGet(_autoresizeTimeout, this));
+    _classPrivateFieldSet(this, _pressed, true);
+    if (_classPrivateFieldGet(this, _autoresizeTimeout) === null) {
+      _classPrivateFieldSet(this, _autoresizeTimeout, setTimeout(() => this.afterMouseDownTimeout(), 500));
+      this.hot._registerTimeout(_classPrivateFieldGet(this, _autoresizeTimeout));
     }
-    _classPrivateFieldSet(_dblclick, this, _classPrivateFieldGet(_dblclick, this) + 1);
+    _classPrivateFieldSet(this, _dblclick, _classPrivateFieldGet(this, _dblclick) + 1);
     this.startX = event.pageX;
-    _classPrivateFieldSet(_newSize, this, _classPrivateFieldGet(_startWidth, this));
+    _classPrivateFieldSet(this, _newSize, _classPrivateFieldGet(this, _startWidth));
   }
 }
-/**
- * 'mousemove' event callback - refresh the handle and guide positions, cache the new column width.
- *
- * @param {MouseEvent} event The mouse event.
- */
-function _onMouseMove(event) {
-  if (_classPrivateFieldGet(_pressed, this)) {
+function _onMouseMove2(event) {
+  if (_classPrivateFieldGet(this, _pressed)) {
     const change = (event.pageX - this.startX) * this.hot.getDirectionFactor();
-    _classPrivateFieldSet(_currentWidth, this, _classPrivateFieldGet(_startWidth, this) + change);
-    (0, _array.arrayEach)(_classPrivateFieldGet(_selectedCols, this), selectedCol => {
-      _classPrivateFieldSet(_newSize, this, this.setManualSize(selectedCol, _classPrivateFieldGet(_currentWidth, this)));
+    _classPrivateFieldSet(this, _currentWidth, _classPrivateFieldGet(this, _startWidth) + change);
+    (0, _array.arrayEach)(_classPrivateFieldGet(this, _selectedCols), selectedCol => {
+      _classPrivateFieldSet(this, _newSize, this.setManualSize(selectedCol, _classPrivateFieldGet(this, _currentWidth)));
     });
     this.refreshHandlePosition();
     this.refreshGuidePosition();
   }
 }
-/**
- * 'mouseup' event callback - apply the column resizing.
- *
- * @fires Hooks#beforeColumnResize
- * @fires Hooks#afterColumnResize
- */
-function _onMouseUp() {
+function _onMouseUp2() {
   const render = () => {
     this.hot.forceFullRender = true;
     this.hot.view.render(); // updates all
     this.hot.view.adjustElementsSize(true);
   };
   const resize = (column, forceRender) => {
-    this.hot.runHooks('beforeColumnResize', _classPrivateFieldGet(_newSize, this), column, false);
+    this.hot.runHooks('beforeColumnResize', _classPrivateFieldGet(this, _newSize), column, false);
     if (forceRender) {
       render();
     }
     this.saveManualColumnWidths();
-    this.hot.runHooks('afterColumnResize', _classPrivateFieldGet(_newSize, this), column, false);
+    this.hot.runHooks('afterColumnResize', _classPrivateFieldGet(this, _newSize), column, false);
   };
-  if (_classPrivateFieldGet(_pressed, this)) {
+  if (_classPrivateFieldGet(this, _pressed)) {
     this.hideHandleAndGuide();
-    _classPrivateFieldSet(_pressed, this, false);
-    if (_classPrivateFieldGet(_newSize, this) !== _classPrivateFieldGet(_startWidth, this)) {
-      const selectedColsLength = _classPrivateFieldGet(_selectedCols, this).length;
+    _classPrivateFieldSet(this, _pressed, false);
+    if (_classPrivateFieldGet(this, _newSize) !== _classPrivateFieldGet(this, _startWidth)) {
+      const selectedColsLength = _classPrivateFieldGet(this, _selectedCols).length;
       if (selectedColsLength > 1) {
-        (0, _array.arrayEach)(_classPrivateFieldGet(_selectedCols, this), selectedCol => {
+        (0, _array.arrayEach)(_classPrivateFieldGet(this, _selectedCols), selectedCol => {
           resize(selectedCol);
         });
         render();
       } else {
-        (0, _array.arrayEach)(_classPrivateFieldGet(_selectedCols, this), selectedCol => {
+        (0, _array.arrayEach)(_classPrivateFieldGet(this, _selectedCols), selectedCol => {
           resize(selectedCol, true);
         });
       }
     }
-    this.setupHandlePosition(_classPrivateFieldGet(_currentTH, this));
+    this.setupHandlePosition(_classPrivateFieldGet(this, _currentTH));
   }
 }
-/**
- * Callback for "contextmenu" event triggered on element showing move handle. It removes handle and guide elements.
- */
-function _onContextMenu() {
+function _onContextMenu2() {
   this.hideHandleAndGuide();
-  this.hot.rootElement.removeChild(_classPrivateFieldGet(_handle, this));
-  this.hot.rootElement.removeChild(_classPrivateFieldGet(_guide, this));
-  _classPrivateFieldSet(_pressed, this, false);
-  _classPrivateFieldSet(_isTriggeredByRMB, this, true);
+  this.hot.rootElement.removeChild(_classPrivateFieldGet(this, _handle));
+  this.hot.rootElement.removeChild(_classPrivateFieldGet(this, _guide));
+  _classPrivateFieldSet(this, _pressed, false);
+  _classPrivateFieldSet(this, _isTriggeredByRMB, true);
 
   // There is thrown "mouseover" event right after opening a context menu. This flag inform that handle
   // shouldn't be drawn just after removing it.
   this.hot._registerImmediate(() => {
-    _classPrivateFieldSet(_isTriggeredByRMB, this, false);
+    _classPrivateFieldSet(this, _isTriggeredByRMB, false);
   });
 }
-function _onModifyColWidth(width, column) {
+function _onModifyColWidth2(width, column) {
   let newWidth = width;
   if (this.enabled) {
     const physicalColumn = this.hot.toPhysicalColumn(column);
-    const columnWidth = _classPrivateFieldGet(_columnWidthsMap, this).getValueAtIndex(physicalColumn);
+    const columnWidth = _classPrivateFieldGet(this, _columnWidthsMap).getValueAtIndex(physicalColumn);
     if (this.hot.getSettings()[PLUGIN_KEY] && columnWidth) {
       newWidth = columnWidth;
     }
   }
   return newWidth;
 }
-/**
- * Modifies the provided column stretched width. This hook decides if specified column should be stretched or not.
- *
- * @param {number} stretchedWidth Stretched width.
- * @param {number} column Visual column index.
- * @returns {number}
- */
-function _onBeforeStretchingColumnWidth(stretchedWidth, column) {
-  let width = _classPrivateFieldGet(_columnWidthsMap, this).getValueAtIndex(column);
+function _onBeforeStretchingColumnWidth2(stretchedWidth, column) {
+  let width = _classPrivateFieldGet(this, _columnWidthsMap).getValueAtIndex(column);
   if (width === null) {
     width = stretchedWidth;
   }
   return width;
 }
-/**
- * `beforeColumnResize` hook callback.
- */
-function _onBeforeColumnResize() {
+function _onBeforeColumnResize2() {
   // clear the header height cache information
   this.hot.view._wt.wtViewport.resetHasOversizedColumnHeadersMarked();
 }