handsontable 0.0.0-next-fcd6191-20240619 → 0.0.0-next-3c01700-20240619

package/plugins/comments/comments.mjs

@@ -9,7 +9,7 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
 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"); }
-import { addClass, closest, isChildOf, hasClass, outerWidth, outerHeight } from "../../helpers/dom/element.mjs";
+import { addClass, closest, isChildOf, hasClass, outerHeight } from "../../helpers/dom/element.mjs";
 import { stopImmediatePropagation } from "../../helpers/dom/event.mjs";
 import { deepClone, deepExtend, isObject } from "../../helpers/object.mjs";
 import { BasePlugin } from "../base/index.mjs";
@@ -122,7 +122,6 @@ var _editor = /*#__PURE__*/new WeakMap();
 var _displaySwitch = /*#__PURE__*/new WeakMap();
 var _preventEditorAutoSwitch = /*#__PURE__*/new WeakMap();
 var _preventEditorHiding = /*#__PURE__*/new WeakMap();
-var _tempEditorDimensions = /*#__PURE__*/new WeakMap();
 var _cellBelowCursor = /*#__PURE__*/new WeakMap();
 var _commentValueBeforeSave = /*#__PURE__*/new WeakMap();
 var _Comments_brand = /*#__PURE__*/new WeakSet();
@@ -170,13 +169,6 @@ export class Comments extends BasePlugin {
      * @type {boolean}
      */
     _classPrivateFieldInitSpec(this, _preventEditorHiding, false);
-    /**
-     * The property for holding editor dimensions for further processing.
-     *
-     * @private
-     * @type {object}
-     */
-    _classPrivateFieldInitSpec(this, _tempEditorDimensions, {});
     /**
      * The flag that allows processing mousedown event correctly when comments editor is triggered.
      *
@@ -212,11 +204,18 @@ export class Comments extends BasePlugin {
    * Enables the plugin functionality for this Handsontable instance.
    */
   enablePlugin() {
+    var _this = this;
     if (this.enabled) {
       return;
     }
     if (!_classPrivateFieldGet(_editor, this)) {
       _classPrivateFieldSet(_editor, this, new CommentEditor(this.hot.rootDocument, this.hot.isRtl()));
+      _classPrivateFieldGet(_editor, this).addLocalHook('resize', function () {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        return _assertClassBrand(_Comments_brand, _this, _onEditorResize).call(_this, ...args);
+      });
     }
     if (!_classPrivateFieldGet(_displaySwitch, this)) {
       _classPrivateFieldSet(_displaySwitch, this, new DisplaySwitch(this.getDisplayDelaySetting()));
@@ -328,8 +327,6 @@ export class Comments extends BasePlugin {
     this.eventManager.addEventListener(rootDocument, 'mouseup', () => _assertClassBrand(_Comments_brand, this, _onMouseUp).call(this));
     this.eventManager.addEventListener(editorElement, 'focus', () => _assertClassBrand(_Comments_brand, this, _onEditorFocus).call(this));
     this.eventManager.addEventListener(editorElement, 'blur', () => _assertClassBrand(_Comments_brand, this, _onEditorBlur).call(this));
-    this.eventManager.addEventListener(editorElement, 'mousedown', event => _assertClassBrand(_Comments_brand, this, _onEditorMouseDown).call(this, event));
-    this.eventManager.addEventListener(editorElement, 'mouseup', event => _assertClassBrand(_Comments_brand, this, _onEditorMouseUp).call(this, event));
   }
 
   /**
@@ -603,6 +600,7 @@ export class Comments extends BasePlugin {
     }
     _classPrivateFieldGet(_editor, this).setPosition(x, y);
     _classPrivateFieldGet(_editor, this).setReadOnlyState(this.getCommentMeta(visualRow, visualColumn, META_READONLY));
+    _classPrivateFieldGet(_editor, this).observeSize();
   }
 
   /**
@@ -685,12 +683,9 @@ export class Comments extends BasePlugin {
    * Destroys the plugin instance.
    */
   destroy() {
-    if (_classPrivateFieldGet(_editor, this)) {
-      _classPrivateFieldGet(_editor, this).destroy();
-    }
-    if (_classPrivateFieldGet(_displaySwitch, this)) {
-      _classPrivateFieldGet(_displaySwitch, this).destroy();
-    }
+    var _classPrivateFieldGet2, _classPrivateFieldGet3;
+    (_classPrivateFieldGet2 = _classPrivateFieldGet(_editor, this)) === null || _classPrivateFieldGet2 === void 0 || _classPrivateFieldGet2.destroy();
+    (_classPrivateFieldGet3 = _classPrivateFieldGet(_displaySwitch, this)) === null || _classPrivateFieldGet3 === void 0 || _classPrivateFieldGet3.destroy();
     super.destroy();
   }
 }
@@ -765,33 +760,19 @@ function _onEditorFocus() {
   this.hot.getShortcutManager().setActiveContextName(SHORTCUTS_CONTEXT_NAME);
 }
 /**
- * `mousedown` hook. Along with `onEditorMouseUp` used to simulate the textarea resizing event.
+ * Saves the comments editor size to the cell meta.
  *
- * @param {MouseEvent} event The `mousedown` event.
+ * @param {number} width The new width of the editor.
+ * @param {number} height The new height of the editor.
  */
-function _onEditorMouseDown(event) {
-  _classPrivateFieldSet(_tempEditorDimensions, this, {
-    width: outerWidth(event.target),
-    height: outerHeight(event.target)
+function _onEditorResize(width, height) {
+  this.updateCommentMeta(this.range.from.row, this.range.from.col, {
+    [META_STYLE]: {
+      width,
+      height
+    }
   });
 }
-/**
- * `mouseup` hook. Along with `onEditorMouseDown` used to simulate the textarea resizing event.
- *
- * @param {MouseEvent} event The `mouseup` event.
- */
-function _onEditorMouseUp(event) {
-  const currentWidth = outerWidth(event.target);
-  const currentHeight = outerHeight(event.target);
-  if (currentWidth !== _classPrivateFieldGet(_tempEditorDimensions, this).width + 1 || currentHeight !== _classPrivateFieldGet(_tempEditorDimensions, this).height + 2) {
-    this.updateCommentMeta(this.range.from.row, this.range.from.col, {
-      [META_STYLE]: {
-        width: currentWidth,
-        height: currentHeight
-      }
-    });
-  }
-}
 /**
  * Observes the pressed keys and if there is already opened the comment editor prevents open
  * the table editor into the fast edit mode.

package/plugins/comments/editorResizeObserver.js

@@ -0,0 +1,100 @@
+"use strict";
+
+exports.__esModule = true;
+require("core-js/modules/es.error.cause.js");
+var _object = require("../../helpers/object");
+var _localHooks = _interopRequireDefault(require("../../mixins/localHooks"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+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"); }
+/**
+ * Module that observes the editor size after it has been resized by the user.
+ *
+ * @private
+ * @class EditorResizeObserver
+ */
+var _ignoreInitialCall = /*#__PURE__*/new WeakMap();
+var _observedElement = /*#__PURE__*/new WeakMap();
+var _observer = /*#__PURE__*/new WeakMap();
+var _EditorResizeObserver_brand = /*#__PURE__*/new WeakSet();
+class EditorResizeObserver {
+  constructor() {
+    /**
+     * Listens for event from the ResizeObserver and forwards the through the local hooks.
+     *
+     * @param {*} entries The entries from the ResizeObserver.
+     */
+    _classPrivateMethodInitSpec(this, _EditorResizeObserver_brand);
+    /**
+     * The flag that indicates if the initial call should be ignored. It is used to prevent the initial call
+     * that happens after the observer is attached to the element.
+     *
+     * @type {boolean}
+     */
+    _classPrivateFieldInitSpec(this, _ignoreInitialCall, true);
+    /**
+     * The element that is observed by the observer.
+     *
+     * @type {HTMLElement}
+     */
+    _classPrivateFieldInitSpec(this, _observedElement, null);
+    /**
+     * The ResizeObserver instance.
+     *
+     * @type {ResizeObserver}
+     */
+    _classPrivateFieldInitSpec(this, _observer, new ResizeObserver(entries => _assertClassBrand(_EditorResizeObserver_brand, this, _onResize).call(this, entries)));
+  }
+  /**
+   * Sets the observed element.
+   *
+   * @param {HTMLElement} element The element to observe.
+   */
+  setObservedElement(element) {
+    _classPrivateFieldSet(_observedElement, this, element);
+  }
+
+  /**
+   * Stops observing the element.
+   */
+  unobserve() {
+    _classPrivateFieldGet(_observer, this).unobserve(_classPrivateFieldGet(_observedElement, this));
+  }
+
+  /**
+   * Starts observing the element.
+   */
+  observe() {
+    _classPrivateFieldSet(_ignoreInitialCall, this, true);
+    _classPrivateFieldGet(_observer, this).observe(_classPrivateFieldGet(_observedElement, this));
+  }
+
+  /**
+   * Destroys the observer.
+   */
+  destroy() {
+    _classPrivateFieldGet(_observer, this).disconnect();
+  }
+}
+exports.EditorResizeObserver = EditorResizeObserver;
+function _onResize(entries) {
+  if (_classPrivateFieldGet(_ignoreInitialCall, this) || !Array.isArray(entries) || !entries.length) {
+    _classPrivateFieldSet(_ignoreInitialCall, this, false);
+    return;
+  }
+  entries.forEach(_ref => {
+    let {
+      borderBoxSize
+    } = _ref;
+    const {
+      inlineSize,
+      blockSize
+    } = borderBoxSize[0];
+    this.runLocalHooks('resize', inlineSize, blockSize);
+  });
+}
+(0, _object.mixin)(EditorResizeObserver, _localHooks.default);

package/plugins/comments/editorResizeObserver.mjs

@@ -0,0 +1,95 @@
+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(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+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"); }
+import { mixin } from "../../helpers/object.mjs";
+import localHooks from "../../mixins/localHooks.mjs";
+/**
+ * Module that observes the editor size after it has been resized by the user.
+ *
+ * @private
+ * @class EditorResizeObserver
+ */
+var _ignoreInitialCall = /*#__PURE__*/new WeakMap();
+var _observedElement = /*#__PURE__*/new WeakMap();
+var _observer = /*#__PURE__*/new WeakMap();
+var _EditorResizeObserver_brand = /*#__PURE__*/new WeakSet();
+export class EditorResizeObserver {
+  constructor() {
+    /**
+     * Listens for event from the ResizeObserver and forwards the through the local hooks.
+     *
+     * @param {*} entries The entries from the ResizeObserver.
+     */
+    _classPrivateMethodInitSpec(this, _EditorResizeObserver_brand);
+    /**
+     * The flag that indicates if the initial call should be ignored. It is used to prevent the initial call
+     * that happens after the observer is attached to the element.
+     *
+     * @type {boolean}
+     */
+    _classPrivateFieldInitSpec(this, _ignoreInitialCall, true);
+    /**
+     * The element that is observed by the observer.
+     *
+     * @type {HTMLElement}
+     */
+    _classPrivateFieldInitSpec(this, _observedElement, null);
+    /**
+     * The ResizeObserver instance.
+     *
+     * @type {ResizeObserver}
+     */
+    _classPrivateFieldInitSpec(this, _observer, new ResizeObserver(entries => _assertClassBrand(_EditorResizeObserver_brand, this, _onResize).call(this, entries)));
+  }
+  /**
+   * Sets the observed element.
+   *
+   * @param {HTMLElement} element The element to observe.
+   */
+  setObservedElement(element) {
+    _classPrivateFieldSet(_observedElement, this, element);
+  }
+
+  /**
+   * Stops observing the element.
+   */
+  unobserve() {
+    _classPrivateFieldGet(_observer, this).unobserve(_classPrivateFieldGet(_observedElement, this));
+  }
+
+  /**
+   * Starts observing the element.
+   */
+  observe() {
+    _classPrivateFieldSet(_ignoreInitialCall, this, true);
+    _classPrivateFieldGet(_observer, this).observe(_classPrivateFieldGet(_observedElement, this));
+  }
+
+  /**
+   * Destroys the observer.
+   */
+  destroy() {
+    _classPrivateFieldGet(_observer, this).disconnect();
+  }
+}
+function _onResize(entries) {
+  if (_classPrivateFieldGet(_ignoreInitialCall, this) || !Array.isArray(entries) || !entries.length) {
+    _classPrivateFieldSet(_ignoreInitialCall, this, false);
+    return;
+  }
+  entries.forEach(_ref => {
+    let {
+      borderBoxSize
+    } = _ref;
+    const {
+      inlineSize,
+      blockSize
+    } = borderBoxSize[0];
+    this.runLocalHooks('resize', inlineSize, blockSize);
+  });
+}
+mixin(EditorResizeObserver, localHooks);