handsontable 0.0.0-next-7026906-20231107 → 0.0.0-next-7b93b7d-20231107

package/plugins/manualColumnFreeze/manualColumnFreeze.mjs

@@ -1,4 +1,14 @@
 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 _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 _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 _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; }
 import { BasePlugin } from "../base/index.mjs";
 import Hooks from "../../pluginHooks.mjs";
 import freezeColumnItem from "./contextMenuItem/freezeColumn.mjs";
@@ -9,7 +19,6 @@ Hooks.getSingleton().register('beforeColumnUnfreeze');
 Hooks.getSingleton().register('afterColumnUnfreeze');
 export const PLUGIN_KEY = 'manualColumnFreeze';
 export const PLUGIN_PRIORITY = 110;
-const privatePool = new WeakMap();
 
 /* eslint-disable jsdoc/require-description-complete-sentence */
 
@@ -27,20 +36,44 @@ const privatePool = new WeakMap();
  * manualColumnFreeze: true,
  * ```
  */
+var _afterFirstUse = /*#__PURE__*/new WeakMap();
+var _addContextMenuEntry = /*#__PURE__*/new WeakSet();
+var _onBeforeColumnMove = /*#__PURE__*/new WeakSet();
 export class ManualColumnFreeze extends BasePlugin {
+  constructor() {
+    super(...arguments);
+    /**
+     * Prevents moving the columns from/to fixed area.
+     *
+     * @private
+     * @param {Array} columns Array of visual column indexes to be moved.
+     * @param {number} finalIndex Visual column index, being a start index for the moved columns. Points to where the elements will be placed after the moving action.
+     * @returns {boolean|undefined}
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeColumnMove);
+    /**
+     * Adds the manualColumnFreeze context menu entries.
+     *
+     * @private
+     * @param {object} options Context menu options.
+     */
+    _classPrivateMethodInitSpec(this, _addContextMenuEntry);
+    /**
+     * Determines when the moving operation is allowed.
+     *
+     * @type {boolean}
+     */
+    _classPrivateFieldInitSpec(this, _afterFirstUse, {
+      writable: true,
+      value: false
+    });
+  }
   static get PLUGIN_KEY() {
     return PLUGIN_KEY;
   }
   static get PLUGIN_PRIORITY() {
     return PLUGIN_PRIORITY;
   }
-  constructor(hotInstance) {
-    super(hotInstance);
-    privatePool.set(this, {
-      afterFirstUse: false
-    });
-  }
-
   /**
    * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit}
    * hook and if it returns `true` then the {@link ManualColumnFreeze#enablePlugin} method is called.
@@ -58,8 +91,8 @@ export class ManualColumnFreeze extends BasePlugin {
     if (this.enabled) {
       return;
     }
-    this.addHook('afterContextMenuDefaultOptions', options => this.addContextMenuEntry(options));
-    this.addHook('beforeColumnMove', (columns, finalIndex) => this.onBeforeColumnMove(columns, finalIndex));
+    this.addHook('afterContextMenuDefaultOptions', options => _classPrivateMethodGet(this, _addContextMenuEntry, _addContextMenuEntry2).call(this, options));
+    this.addHook('beforeColumnMove', (columns, finalIndex) => _classPrivateMethodGet(this, _onBeforeColumnMove, _onBeforeColumnMove2).call(this, columns, finalIndex));
     super.enablePlugin();
   }
 
@@ -67,8 +100,7 @@ export class ManualColumnFreeze extends BasePlugin {
    * Disables the plugin functionality for this Handsontable instance.
    */
   disablePlugin() {
-    const priv = privatePool.get(this);
-    priv.afterFirstUse = false;
+    _classPrivateFieldSet(this, _afterFirstUse, false);
     super.disablePlugin();
   }
 
@@ -93,12 +125,11 @@ export class ManualColumnFreeze extends BasePlugin {
    * @param {number} column Visual column index.
    */
   freezeColumn(column) {
-    const priv = privatePool.get(this);
     const settings = this.hot.getSettings();
     // columns are already fixed (frozen)
     const freezePerformed = settings.fixedColumnsStart < this.hot.countCols() && column > settings.fixedColumnsStart - 1;
-    if (!priv.afterFirstUse) {
-      priv.afterFirstUse = true;
+    if (!_classPrivateFieldGet(this, _afterFirstUse)) {
+      _classPrivateFieldSet(this, _afterFirstUse, true);
     }
     const beforeColumnFreezeHook = this.hot.runHooks('beforeColumnFreeze', column, freezePerformed);
     if (beforeColumnFreezeHook === false) {
@@ -122,12 +153,11 @@ export class ManualColumnFreeze extends BasePlugin {
    * @param {number} column Visual column index.
    */
   unfreezeColumn(column) {
-    const priv = privatePool.get(this);
     const settings = this.hot.getSettings();
     // columns are not fixed (not frozen)
     const unfreezePerformed = settings.fixedColumnsStart > 0 && column <= settings.fixedColumnsStart - 1;
-    if (!priv.afterFirstUse) {
-      priv.afterFirstUse = true;
+    if (!_classPrivateFieldGet(this, _afterFirstUse)) {
+      _classPrivateFieldSet(this, _afterFirstUse, true);
     }
     const beforeColumnUnfreezeHook = this.hot.runHooks('beforeColumnUnfreeze', column, unfreezePerformed);
     if (beforeColumnUnfreezeHook === false) {
@@ -143,41 +173,24 @@ export class ManualColumnFreeze extends BasePlugin {
     }
     this.hot.runHooks('afterColumnUnfreeze', column, unfreezePerformed);
   }
+}
+function _addContextMenuEntry2(options) {
+  options.items.push({
+    name: '---------'
+  }, freezeColumnItem(this), unfreezeColumnItem(this));
+}
+function _onBeforeColumnMove2(columns, finalIndex) {
+  if (_classPrivateFieldGet(this, _afterFirstUse)) {
+    const freezeLine = this.hot.getSettings().fixedColumnsStart;
 
-  /**
-   * Adds the manualColumnFreeze context menu entries.
-   *
-   * @private
-   * @param {object} options Context menu options.
-   */
-  addContextMenuEntry(options) {
-    options.items.push({
-      name: '---------'
-    }, freezeColumnItem(this), unfreezeColumnItem(this));
-  }
-
-  /**
-   * Prevents moving the columns from/to fixed area.
-   *
-   * @private
-   * @param {Array} columns Array of visual column indexes to be moved.
-   * @param {number} finalIndex Visual column index, being a start index for the moved columns. Points to where the elements will be placed after the moving action.
-   * @returns {boolean|undefined}
-   */
-  onBeforeColumnMove(columns, finalIndex) {
-    const priv = privatePool.get(this);
-    if (priv.afterFirstUse) {
-      const freezeLine = this.hot.getSettings().fixedColumnsStart;
-
-      // Moving any column before the "freeze line" isn't possible.
-      if (finalIndex < freezeLine) {
-        return false;
-      }
+    // Moving any column before the "freeze line" isn't possible.
+    if (finalIndex < freezeLine) {
+      return false;
+    }
 
-      // Moving frozen column isn't possible.
-      if (columns.some(column => column < freezeLine)) {
-        return false;
-      }
+    // Moving frozen column isn't possible.
+    if (columns.some(column => column < freezeLine)) {
+      return false;
     }
   }
 }