handsontable 14.0.0-next-1127661-20231114 → 14.0.0-next-bdc44e7-20231115

package/plugins/manualRowResize/manualRowResize.js

@@ -1,8 +1,8 @@
 "use strict";
 
+require("core-js/modules/es.error.cause.js");
 exports.__esModule = true;
 require("core-js/modules/es.array.push.js");
-require("core-js/modules/es.error.cause.js");
 var _base = require("../base");
 var _element = require("../../helpers/dom/element");
 var _array = require("../../helpers/array");
@@ -12,15 +12,12 @@ var _src = require("../../3rdparty/walkontable/src");
 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 _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(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); }
-function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
-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; }
 function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
-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 _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 _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+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 manualColumnResize.js
 
 const PLUGIN_KEY = exports.PLUGIN_KEY = 'manualRowResize';
@@ -41,6 +38,21 @@ const PERSISTENT_STATE_KEY = 'manualRowHeights';
  * - handle - the draggable element that sets the desired height of the row.
  * - guide - the helper guide that shows the desired height as a horizontal guide.
  */
+var _currentTH = /*#__PURE__*/new WeakMap();
+var _currentRow = /*#__PURE__*/new WeakMap();
+var _selectedRows = /*#__PURE__*/new WeakMap();
+var _currentHeight = /*#__PURE__*/new WeakMap();
+var _newSize = /*#__PURE__*/new WeakMap();
+var _startY = /*#__PURE__*/new WeakMap();
+var _startHeight = /*#__PURE__*/new WeakMap();
+var _startOffset = /*#__PURE__*/new WeakMap();
+var _handle = /*#__PURE__*/new WeakMap();
+var _guide = /*#__PURE__*/new WeakMap();
+var _pressed = /*#__PURE__*/new WeakMap();
+var _isTriggeredByRMB = /*#__PURE__*/new WeakMap();
+var _dblclick = /*#__PURE__*/new WeakMap();
+var _autoresizeTimeout = /*#__PURE__*/new WeakMap();
+var _rowHeightsMap = /*#__PURE__*/new WeakMap();
 var _config = /*#__PURE__*/new WeakMap();
 var _onMouseOver = /*#__PURE__*/new WeakSet();
 var _onMouseDown = /*#__PURE__*/new WeakSet();
@@ -104,66 +116,110 @@ class ManualRowResize extends _base.BasePlugin {
      * @param {MouseEvent} event The mouse event.
      */
     _classPrivateMethodInitSpec(this, _onMouseOver);
-    _defineProperty(this, "currentTH", null);
+    _classPrivateFieldInitSpec(this, _currentTH, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "currentRow", null);
+    _classPrivateFieldInitSpec(this, _currentRow, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number[]}
      */
-    _defineProperty(this, "selectedRows", []);
+    _classPrivateFieldInitSpec(this, _selectedRows, {
+      writable: true,
+      value: []
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "currentHeight", null);
+    _classPrivateFieldInitSpec(this, _currentHeight, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "newSize", null);
+    _classPrivateFieldInitSpec(this, _newSize, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "startY", null);
+    _classPrivateFieldInitSpec(this, _startY, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "startHeight", null);
+    _classPrivateFieldInitSpec(this, _startHeight, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "startOffset", null);
+    _classPrivateFieldInitSpec(this, _startOffset, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {HTMLElement}
      */
-    _defineProperty(this, "handle", this.hot.rootDocument.createElement('DIV'));
+    _classPrivateFieldInitSpec(this, _handle, {
+      writable: true,
+      value: this.hot.rootDocument.createElement('DIV')
+    });
     /**
      * @type {HTMLElement}
      */
-    _defineProperty(this, "guide", this.hot.rootDocument.createElement('DIV'));
+    _classPrivateFieldInitSpec(this, _guide, {
+      writable: true,
+      value: this.hot.rootDocument.createElement('DIV')
+    });
     /**
      * @type {boolean}
      */
-    _defineProperty(this, "pressed", false);
+    _classPrivateFieldInitSpec(this, _pressed, {
+      writable: true,
+      value: false
+    });
     /**
      * @type {boolean}
      */
-    _defineProperty(this, "isTriggeredByRMB", false);
+    _classPrivateFieldInitSpec(this, _isTriggeredByRMB, {
+      writable: true,
+      value: false
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "dblclick", 0);
+    _classPrivateFieldInitSpec(this, _dblclick, {
+      writable: true,
+      value: 0
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "autoresizeTimeout", null);
+    _classPrivateFieldInitSpec(this, _autoresizeTimeout, {
+      writable: true,
+      value: null
+    });
     /**
      * PhysicalIndexToValueMap to keep and track widths for physical row indexes.
      *
-     * @private
      * @type {PhysicalIndexToValueMap}
      */
-    _defineProperty(this, "rowHeightsMap", void 0);
+    _classPrivateFieldInitSpec(this, _rowHeightsMap, {
+      writable: true,
+      value: void 0
+    });
     /**
      * Private pool to save configuration from updateSettings.
      *
@@ -173,8 +229,8 @@ class ManualRowResize extends _base.BasePlugin {
       writable: true,
       value: void 0
     });
-    (0, _element.addClass)(this.handle, 'manualRowResizer');
-    (0, _element.addClass)(this.guide, 'manualRowResizerGuide');
+    (0, _element.addClass)(_classPrivateFieldGet(this, _handle), 'manualRowResizer');
+    (0, _element.addClass)(_classPrivateFieldGet(this, _guide), 'manualRowResizerGuide');
   }
 
   /**
@@ -202,9 +258,9 @@ class ManualRowResize extends _base.BasePlugin {
     if (this.enabled) {
       return;
     }
-    this.rowHeightsMap = new _translations.PhysicalIndexToValueMap();
-    this.rowHeightsMap.addLocalHook('init', () => _classPrivateMethodGet(this, _onMapInit, _onMapInit2).call(this));
-    this.hot.rowIndexMapper.registerMap(this.pluginName, this.rowHeightsMap);
+    _classPrivateFieldSet(this, _rowHeightsMap, new _translations.PhysicalIndexToValueMap());
+    _classPrivateFieldGet(this, _rowHeightsMap).addLocalHook('init', () => _classPrivateMethodGet(this, _onMapInit, _onMapInit2).call(this));
+    this.hot.rowIndexMapper.registerMap(this.pluginName, _classPrivateFieldGet(this, _rowHeightsMap));
     this.addHook('modifyRowHeight', (height, row) => _classPrivateMethodGet(this, _onModifyRowHeight, _onModifyRowHeight2).call(this, height, row));
     this.bindEvents();
     super.enablePlugin();
@@ -226,7 +282,7 @@ class ManualRowResize extends _base.BasePlugin {
    * Disables the plugin functionality for this Handsontable instance.
    */
   disablePlugin() {
-    _classPrivateFieldSet(this, _config, this.rowHeightsMap.getValues());
+    _classPrivateFieldSet(this, _config, _classPrivateFieldGet(this, _rowHeightsMap).getValues());
     this.hot.rowIndexMapper.unregisterMap(this.pluginName);
     super.disablePlugin();
   }
@@ -238,7 +294,7 @@ class ManualRowResize extends _base.BasePlugin {
    * @fires Hooks#persistentStateSave
    */
   saveManualRowHeights() {
-    this.hot.runHooks('persistentStateSave', PERSISTENT_STATE_KEY, this.rowHeightsMap.getValues());
+    this.hot.runHooks('persistentStateSave', PERSISTENT_STATE_KEY, _classPrivateFieldGet(this, _rowHeightsMap).getValues());
   }
 
   /**
@@ -264,7 +320,7 @@ class ManualRowResize extends _base.BasePlugin {
   setManualSize(row, height) {
     const physicalRow = this.hot.toPhysicalRow(row);
     const newHeight = Math.max(height, _src.ViewportRowsCalculator.DEFAULT_HEIGHT);
-    this.rowHeightsMap.setValueAtIndex(physicalRow, newHeight);
+    _classPrivateFieldGet(this, _rowHeightsMap).setValueAtIndex(physicalRow, newHeight);
     return newHeight;
   }
 
@@ -275,40 +331,40 @@ class ManualRowResize extends _base.BasePlugin {
    * @param {HTMLCellElement} TH TH HTML element.
    */
   setupHandlePosition(TH) {
-    this.currentTH = TH;
+    _classPrivateFieldSet(this, _currentTH, TH);
     const {
       view
     } = this.hot;
     const {
       _wt: wt
     } = view;
-    const cellCoords = wt.wtTable.getCoords(this.currentTH);
+    const cellCoords = wt.wtTable.getCoords(_classPrivateFieldGet(this, _currentTH));
     const row = cellCoords.row;
 
     // Ignore row headers.
     if (row < 0) {
       return;
     }
-    const headerWidth = (0, _element.outerWidth)(this.currentTH);
-    const box = this.currentTH.getBoundingClientRect();
+    const headerWidth = (0, _element.outerWidth)(_classPrivateFieldGet(this, _currentTH));
+    const box = _classPrivateFieldGet(this, _currentTH).getBoundingClientRect();
     // Read "fixedRowsTop" and "fixedRowsBottom" through the Walkontable as in that context, the fixed
     // rows are modified (reduced by the number of hidden rows) by TableView module.
     const fixedRowTop = row < wt.getSetting('fixedRowsTop');
     const fixedRowBottom = row >= view.countNotHiddenRowIndexes(0, 1) - wt.getSetting('fixedRowsBottom');
     let relativeHeaderPosition;
     if (fixedRowTop) {
-      relativeHeaderPosition = wt.wtOverlays.topInlineStartCornerOverlay.getRelativeCellPosition(this.currentTH, cellCoords.row, cellCoords.col);
+      relativeHeaderPosition = wt.wtOverlays.topInlineStartCornerOverlay.getRelativeCellPosition(_classPrivateFieldGet(this, _currentTH), cellCoords.row, cellCoords.col);
     } else if (fixedRowBottom) {
-      relativeHeaderPosition = wt.wtOverlays.bottomInlineStartCornerOverlay.getRelativeCellPosition(this.currentTH, cellCoords.row, cellCoords.col);
+      relativeHeaderPosition = wt.wtOverlays.bottomInlineStartCornerOverlay.getRelativeCellPosition(_classPrivateFieldGet(this, _currentTH), cellCoords.row, cellCoords.col);
     }
 
     // If the TH is not a child of the top-left/bottom-left overlay, recalculate using
     // the left overlay - as this overlay contains the rest of the headers.
     if (!relativeHeaderPosition) {
-      relativeHeaderPosition = wt.wtOverlays.inlineStartOverlay.getRelativeCellPosition(this.currentTH, cellCoords.row, cellCoords.col);
+      relativeHeaderPosition = wt.wtOverlays.inlineStartOverlay.getRelativeCellPosition(_classPrivateFieldGet(this, _currentTH), cellCoords.row, cellCoords.col);
     }
-    this.currentRow = this.hot.rowIndexMapper.getVisualFromRenderableIndex(row);
-    this.selectedRows = [];
+    _classPrivateFieldSet(this, _currentRow, this.hot.rowIndexMapper.getVisualFromRenderableIndex(row));
+    _classPrivateFieldSet(this, _selectedRows, []);
     const isFullRowSelected = this.hot.selection.isSelectedByCorner() || this.hot.selection.isSelectedByRowHeader();
     if (this.hot.selection.isSelected() && isFullRowSelected) {
       const selectionRanges = this.hot.getSelectedRange();
@@ -318,23 +374,23 @@ class ManualRowResize extends _base.BasePlugin {
 
         // Add every selected row for resize action.
         (0, _number.rangeEach)(fromRow, toRow, rowIndex => {
-          if (!this.selectedRows.includes(rowIndex)) {
-            this.selectedRows.push(rowIndex);
+          if (!_classPrivateFieldGet(this, _selectedRows).includes(rowIndex)) {
+            _classPrivateFieldGet(this, _selectedRows).push(rowIndex);
           }
         });
       });
     }
 
     // Resizing element beyond the current selection (also when there is no selection).
-    if (!this.selectedRows.includes(this.currentRow)) {
-      this.selectedRows = [this.currentRow];
+    if (!_classPrivateFieldGet(this, _selectedRows).includes(_classPrivateFieldGet(this, _currentRow))) {
+      _classPrivateFieldSet(this, _selectedRows, [_classPrivateFieldGet(this, _currentRow)]);
     }
-    this.startOffset = relativeHeaderPosition.top - 6;
-    this.startHeight = parseInt(box.height, 10);
-    this.handle.style.top = `${this.startOffset + this.startHeight}px`;
-    this.handle.style[this.inlineDir] = `${relativeHeaderPosition.start}px`;
-    this.handle.style.width = `${headerWidth}px`;
-    this.hot.rootElement.appendChild(this.handle);
+    _classPrivateFieldSet(this, _startOffset, relativeHeaderPosition.top - 6);
+    _classPrivateFieldSet(this, _startHeight, parseInt(box.height, 10));
+    _classPrivateFieldGet(this, _handle).style.top = `${_classPrivateFieldGet(this, _startOffset) + _classPrivateFieldGet(this, _startHeight)}px`;
+    _classPrivateFieldGet(this, _handle).style[this.inlineDir] = `${relativeHeaderPosition.start}px`;
+    _classPrivateFieldGet(this, _handle).style.width = `${headerWidth}px`;
+    this.hot.rootElement.appendChild(_classPrivateFieldGet(this, _handle));
   }
 
   /**
@@ -343,7 +399,7 @@ class ManualRowResize extends _base.BasePlugin {
    * @private
    */
   refreshHandlePosition() {
-    this.handle.style.top = `${this.startOffset + this.currentHeight}px`;
+    _classPrivateFieldGet(this, _handle).style.top = `${_classPrivateFieldGet(this, _startOffset) + _classPrivateFieldGet(this, _currentHeight)}px`;
   }
 
   /**
@@ -352,15 +408,15 @@ class ManualRowResize extends _base.BasePlugin {
    * @private
    */
   setupGuidePosition() {
-    const handleWidth = parseInt((0, _element.outerWidth)(this.handle), 10);
-    const handleEndPosition = parseInt(this.handle.style[this.inlineDir], 10) + handleWidth;
+    const handleWidth = parseInt((0, _element.outerWidth)(_classPrivateFieldGet(this, _handle)), 10);
+    const handleEndPosition = parseInt(_classPrivateFieldGet(this, _handle).style[this.inlineDir], 10) + handleWidth;
     const maximumVisibleElementWidth = parseInt(this.hot.view.maximumVisibleElementWidth(0), 10);
-    (0, _element.addClass)(this.handle, 'active');
-    (0, _element.addClass)(this.guide, 'active');
-    this.guide.style.top = this.handle.style.top;
-    this.guide.style[this.inlineDir] = `${handleEndPosition}px`;
-    this.guide.style.width = `${maximumVisibleElementWidth - handleWidth}px`;
-    this.hot.rootElement.appendChild(this.guide);
+    (0, _element.addClass)(_classPrivateFieldGet(this, _handle), 'active');
+    (0, _element.addClass)(_classPrivateFieldGet(this, _guide), 'active');
+    _classPrivateFieldGet(this, _guide).style.top = _classPrivateFieldGet(this, _handle).style.top;
+    _classPrivateFieldGet(this, _guide).style[this.inlineDir] = `${handleEndPosition}px`;
+    _classPrivateFieldGet(this, _guide).style.width = `${maximumVisibleElementWidth - handleWidth}px`;
+    this.hot.rootElement.appendChild(_classPrivateFieldGet(this, _guide));
   }
 
   /**
@@ -369,7 +425,7 @@ class ManualRowResize extends _base.BasePlugin {
    * @private
    */
   refreshGuidePosition() {
-    this.guide.style.top = this.handle.style.top;
+    _classPrivateFieldGet(this, _guide).style.top = _classPrivateFieldGet(this, _handle).style.top;
   }
 
   /**
@@ -378,8 +434,8 @@ class ManualRowResize extends _base.BasePlugin {
    * @private
    */
   hideHandleAndGuide() {
-    (0, _element.removeClass)(this.handle, 'active');
-    (0, _element.removeClass)(this.guide, 'active');
+    (0, _element.removeClass)(_classPrivateFieldGet(this, _handle), 'active');
+    (0, _element.removeClass)(_classPrivateFieldGet(this, _guide), 'active');
   }
 
   /**
@@ -422,10 +478,10 @@ class ManualRowResize extends _base.BasePlugin {
   getActualRowHeight(row) {
     // TODO: this should utilize `this.hot.getRowHeight` after it's fixed and working properly.
     const walkontableHeight = this.hot.view._wt.wtTable.getRowHeight(row);
-    if (walkontableHeight !== undefined && this.newSize < walkontableHeight) {
+    if (walkontableHeight !== undefined && _classPrivateFieldGet(this, _newSize) < walkontableHeight) {
       return walkontableHeight;
     }
-    return this.newSize;
+    return _classPrivateFieldGet(this, _newSize);
   }
   /**
    * Auto-size row after doubleclick - callback.
@@ -443,30 +499,30 @@ class ManualRowResize extends _base.BasePlugin {
     const resize = (row, forceRender) => {
       const hookNewSize = this.hot.runHooks('beforeRowResize', this.getActualRowHeight(row), row, true);
       if (hookNewSize !== undefined) {
-        this.newSize = hookNewSize;
+        _classPrivateFieldSet(this, _newSize, hookNewSize);
       }
-      this.setManualSize(row, this.newSize); // double click sets auto row size
+      this.setManualSize(row, _classPrivateFieldGet(this, _newSize)); // double click sets auto row size
 
       this.hot.runHooks('afterRowResize', this.getActualRowHeight(row), row, true);
       if (forceRender) {
         render();
       }
     };
-    if (this.dblclick >= 2) {
-      const selectedRowsLength = this.selectedRows.length;
+    if (_classPrivateFieldGet(this, _dblclick) >= 2) {
+      const selectedRowsLength = _classPrivateFieldGet(this, _selectedRows).length;
       if (selectedRowsLength > 1) {
-        (0, _array.arrayEach)(this.selectedRows, selectedRow => {
+        (0, _array.arrayEach)(_classPrivateFieldGet(this, _selectedRows), selectedRow => {
           resize(selectedRow);
         });
         render();
       } else {
-        (0, _array.arrayEach)(this.selectedRows, selectedRow => {
+        (0, _array.arrayEach)(_classPrivateFieldGet(this, _selectedRows), selectedRow => {
           resize(selectedRow, true);
         });
       }
     }
-    this.dblclick = 0;
-    this.autoresizeTimeout = null;
+    _classPrivateFieldSet(this, _dblclick, 0);
+    _classPrivateFieldSet(this, _autoresizeTimeout, null);
   }
   /**
    * Binds the mouse events.
@@ -482,7 +538,7 @@ class ManualRowResize extends _base.BasePlugin {
     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(this.handle, 'contextmenu', () => _classPrivateMethodGet(this, _onContextMenu, _onContextMenu2).call(this));
+    this.eventManager.addEventListener(_classPrivateFieldGet(this, _handle), 'contextmenu', () => _classPrivateMethodGet(this, _onContextMenu, _onContextMenu2).call(this));
   }
   /**
    * Destroys the plugin instance.
@@ -500,13 +556,13 @@ function _onMouseOver2(event) {
   }
 
   // A "mouseover" action is triggered right after executing "contextmenu" event. It should be ignored.
-  if (this.isTriggeredByRMB === true) {
+  if (_classPrivateFieldGet(this, _isTriggeredByRMB) === true) {
     return;
   }
   if (this.checkIfRowHeader(event.target)) {
     const th = this.getClosestTHParent(event.target);
     if (th) {
-      if (!this.pressed) {
+      if (!_classPrivateFieldGet(this, _pressed)) {
         this.setupHandlePosition(th);
       }
     }
@@ -514,23 +570,23 @@ function _onMouseOver2(event) {
 }
 function _onMouseDown2(event) {
   if ((0, _element.hasClass)(event.target, 'manualRowResizer')) {
-    this.setupHandlePosition(this.currentTH);
+    this.setupHandlePosition(_classPrivateFieldGet(this, _currentTH));
     this.setupGuidePosition();
-    this.pressed = true;
-    if (this.autoresizeTimeout === null) {
-      this.autoresizeTimeout = setTimeout(() => this.afterMouseDownTimeout(), 500);
-      this.hot._registerTimeout(this.autoresizeTimeout);
+    _classPrivateFieldSet(this, _pressed, true);
+    if (_classPrivateFieldGet(this, _autoresizeTimeout) === null) {
+      _classPrivateFieldSet(this, _autoresizeTimeout, setTimeout(() => this.afterMouseDownTimeout(), 500));
+      this.hot._registerTimeout(_classPrivateFieldGet(this, _autoresizeTimeout));
     }
-    this.dblclick += 1;
-    this.startY = event.pageY;
-    this.newSize = this.startHeight;
+    _classPrivateFieldSet(this, _dblclick, _classPrivateFieldGet(this, _dblclick) + 1);
+    _classPrivateFieldSet(this, _startY, event.pageY);
+    _classPrivateFieldSet(this, _newSize, _classPrivateFieldGet(this, _startHeight));
   }
 }
 function _onMouseMove2(event) {
-  if (this.pressed) {
-    this.currentHeight = this.startHeight + (event.pageY - this.startY);
-    (0, _array.arrayEach)(this.selectedRows, selectedRow => {
-      this.newSize = this.setManualSize(selectedRow, this.currentHeight);
+  if (_classPrivateFieldGet(this, _pressed)) {
+    _classPrivateFieldSet(this, _currentHeight, _classPrivateFieldGet(this, _startHeight) + (event.pageY - _classPrivateFieldGet(this, _startY)));
+    (0, _array.arrayEach)(_classPrivateFieldGet(this, _selectedRows), selectedRow => {
+      _classPrivateFieldSet(this, _newSize, this.setManualSize(selectedRow, _classPrivateFieldGet(this, _currentHeight)));
     });
     this.refreshHandlePosition();
     this.refreshGuidePosition();
@@ -550,43 +606,43 @@ function _onMouseUp2() {
     this.saveManualRowHeights();
     this.hot.runHooks('afterRowResize', this.getActualRowHeight(row), row, false);
   };
-  if (this.pressed) {
+  if (_classPrivateFieldGet(this, _pressed)) {
     this.hideHandleAndGuide();
-    this.pressed = false;
-    if (this.newSize !== this.startHeight) {
-      const selectedRowsLength = this.selectedRows.length;
+    _classPrivateFieldSet(this, _pressed, false);
+    if (_classPrivateFieldGet(this, _newSize) !== _classPrivateFieldGet(this, _startHeight)) {
+      const selectedRowsLength = _classPrivateFieldGet(this, _selectedRows).length;
       if (selectedRowsLength > 1) {
-        (0, _array.arrayEach)(this.selectedRows, selectedRow => {
+        (0, _array.arrayEach)(_classPrivateFieldGet(this, _selectedRows), selectedRow => {
           runHooks(selectedRow);
         });
         render();
       } else {
-        (0, _array.arrayEach)(this.selectedRows, selectedRow => {
+        (0, _array.arrayEach)(_classPrivateFieldGet(this, _selectedRows), selectedRow => {
           runHooks(selectedRow, true);
         });
       }
     }
-    this.setupHandlePosition(this.currentTH);
+    this.setupHandlePosition(_classPrivateFieldGet(this, _currentTH));
   }
 }
 function _onContextMenu2() {
   this.hideHandleAndGuide();
-  this.hot.rootElement.removeChild(this.handle);
-  this.hot.rootElement.removeChild(this.guide);
-  this.pressed = false;
-  this.isTriggeredByRMB = 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(() => {
-    this.isTriggeredByRMB = false;
+    _classPrivateFieldSet(this, _isTriggeredByRMB, false);
   });
 }
 function _onModifyRowHeight2(height, row) {
   let newHeight = height;
   if (this.enabled) {
     const physicalRow = this.hot.toPhysicalRow(row);
-    const rowHeight = this.rowHeightsMap.getValueAtIndex(physicalRow);
+    const rowHeight = _classPrivateFieldGet(this, _rowHeightsMap).getValueAtIndex(physicalRow);
     if (this.hot.getSettings()[PLUGIN_KEY] && rowHeight) {
       newHeight = rowHeight;
     }
@@ -599,16 +655,16 @@ function _onMapInit2() {
   this.hot.batchExecution(() => {
     if (typeof loadedManualRowHeights !== 'undefined') {
       loadedManualRowHeights.forEach((height, index) => {
-        this.rowHeightsMap.setValueAtIndex(index, height);
+        _classPrivateFieldGet(this, _rowHeightsMap).setValueAtIndex(index, height);
       });
     } else if (Array.isArray(initialSetting)) {
       initialSetting.forEach((height, index) => {
-        this.rowHeightsMap.setValueAtIndex(index, height);
+        _classPrivateFieldGet(this, _rowHeightsMap).setValueAtIndex(index, height);
       });
       _classPrivateFieldSet(this, _config, initialSetting);
     } else if (initialSetting === true && Array.isArray(_classPrivateFieldGet(this, _config))) {
       _classPrivateFieldGet(this, _config).forEach((height, index) => {
-        this.rowHeightsMap.setValueAtIndex(index, height);
+        _classPrivateFieldGet(this, _rowHeightsMap).setValueAtIndex(index, height);
       });
     }
   }, true);