handsontable 11.0.0 → 12.0.0

package/3rdparty/walkontable/src/event.js

@@ -17,25 +17,21 @@ require("core-js/modules/web.timers.js");
 
 require("core-js/modules/es.array.includes.js");
 
-var _element = require("./../../../helpers/dom/element");
+var _element = require("../../../helpers/dom/element");
 
-var _function = require("./../../../helpers/function");
+var _function = require("../../../helpers/function");
 
-var _feature = require("./../../../helpers/feature");
+var _feature = require("../../../helpers/feature");
 
-var _browser = require("./../../../helpers/browser");
-
-var _eventManager = _interopRequireDefault(require("./../../../eventManager"));
+var _browser = require("../../../helpers/browser");
 
 var _mixed = require("../../../helpers/mixed");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
 var privatePool = new WeakMap();
 /**
@@ -44,26 +40,44 @@ var privatePool = new WeakMap();
 
 var Event = /*#__PURE__*/function () {
   /**
-   * @param {*} instance Walkontable instance.
+   * @param {FacadeGetter} facadeGetter Gets an instance facade.
+   * @param {DomBindings} domBindings Bindings into dom.
+   * @param {Settings} wtSettings The walkontable settings.
+   * @param {EventManager} eventManager The walkontable event manager.
+   * @param {Table} wtTable The table.
+   * @param {Selections} selections Selections.
+   * @param {Event} [parent=null] The main Event instance.
    */
-  function Event(instance) {
+  function Event(facadeGetter, domBindings, wtSettings, eventManager, wtTable, selections) {
+    var parent = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
+
     _classCallCheck(this, Event);
 
+    this.wtSettings = wtSettings;
+    this.domBindings = domBindings;
+    this.wtTable = wtTable;
+    this.selections = selections;
+    this.parent = parent;
     /**
-     * Instance of {@link Walkontable}.
+     * Instance of {@link EventManager}.
      *
      * @private
-     * @type {Walkontable}
+     * @type {EventManager}
      */
-    this.instance = instance;
+
+    this.eventManager = eventManager;
     /**
-     * Instance of {@link EventManager}.
+     * Should be use only for passing face called external origin methods, like registered event listeners.
+     * It provides backward compatibility by getting instance facade.
      *
+     * @todo Consider about removing this from Event class, because it make relationship into facade (implicit circular dependency).
+     * @todo Con. Maybe passing listener caller as an ioc from faced resolves this issue. To rethink later.
+     *
+     * @type {FacadeGetter}
      * @private
-     * @type {EventManager}
      */
 
-    this.eventManager = new _eventManager.default(instance);
+    this.facadeGetter = facadeGetter;
     privatePool.set(this, {
       selectedCellBeforeTouchEnd: void 0,
       dblClickTimeout: [null, null],
@@ -83,53 +97,53 @@ var Event = /*#__PURE__*/function () {
     value: function registerEvents() {
       var _this = this;
 
-      this.eventManager.addEventListener(this.instance.wtTable.holder, 'contextmenu', function (event) {
+      this.eventManager.addEventListener(this.wtTable.holder, 'contextmenu', function (event) {
         return _this.onContextMenu(event);
       });
-      this.eventManager.addEventListener(this.instance.wtTable.TABLE, 'mouseover', function (event) {
+      this.eventManager.addEventListener(this.wtTable.TABLE, 'mouseover', function (event) {
         return _this.onMouseOver(event);
       });
-      this.eventManager.addEventListener(this.instance.wtTable.TABLE, 'mouseout', function (event) {
+      this.eventManager.addEventListener(this.wtTable.TABLE, 'mouseout', function (event) {
         return _this.onMouseOut(event);
       });
 
       var initTouchEvents = function initTouchEvents() {
-        _this.eventManager.addEventListener(_this.instance.wtTable.holder, 'touchstart', function (event) {
+        _this.eventManager.addEventListener(_this.wtTable.holder, 'touchstart', function (event) {
           return _this.onTouchStart(event);
         });
 
-        _this.eventManager.addEventListener(_this.instance.wtTable.holder, 'touchend', function (event) {
+        _this.eventManager.addEventListener(_this.wtTable.holder, 'touchend', function (event) {
           return _this.onTouchEnd(event);
         });
 
-        if (!_this.instance.momentumScrolling) {
-          _this.instance.momentumScrolling = {};
+        if (!_this.momentumScrolling) {
+          _this.momentumScrolling = {};
         }
 
-        _this.eventManager.addEventListener(_this.instance.wtTable.holder, 'scroll', function () {
-          clearTimeout(_this.instance.momentumScrolling._timeout);
+        _this.eventManager.addEventListener(_this.wtTable.holder, 'scroll', function () {
+          clearTimeout(_this.momentumScrolling._timeout);
 
-          if (!_this.instance.momentumScrolling.ongoing) {
-            _this.instance.getSetting('onBeforeTouchScroll');
+          if (!_this.momentumScrolling.ongoing) {
+            _this.wtSettings.getSetting('onBeforeTouchScroll');
           }
 
-          _this.instance.momentumScrolling.ongoing = true;
-          _this.instance.momentumScrolling._timeout = setTimeout(function () {
-            if (!_this.instance.touchApplied) {
-              _this.instance.momentumScrolling.ongoing = false;
+          _this.momentumScrolling.ongoing = true;
+          _this.momentumScrolling._timeout = setTimeout(function () {
+            if (!_this.touchApplied) {
+              _this.momentumScrolling.ongoing = false;
 
-              _this.instance.getSetting('onAfterMomentumScroll');
+              _this.wtSettings.getSetting('onAfterMomentumScroll');
             }
           }, 200);
         });
       };
 
       var initMouseEvents = function initMouseEvents() {
-        _this.eventManager.addEventListener(_this.instance.wtTable.holder, 'mouseup', function (event) {
+        _this.eventManager.addEventListener(_this.wtTable.holder, 'mouseup', function (event) {
           return _this.onMouseUp(event);
         });
 
-        _this.eventManager.addEventListener(_this.instance.wtTable.holder, 'mousedown', function (event) {
+        _this.eventManager.addEventListener(_this.wtTable.holder, 'mousedown', function (event) {
           return _this.onMouseDown(event);
         });
       };
@@ -184,19 +198,19 @@ var Event = /*#__PURE__*/function () {
     key: "parentCell",
     value: function parentCell(elem) {
       var cell = {};
-      var TABLE = this.instance.wtTable.TABLE;
+      var TABLE = this.wtTable.TABLE;
       var TD = (0, _element.closestDown)(elem, ['TD', 'TH'], TABLE);
 
       if (TD) {
-        cell.coords = this.instance.wtTable.getCoords(TD);
+        cell.coords = this.wtTable.getCoords(TD);
         cell.TD = TD;
       } else if ((0, _element.hasClass)(elem, 'wtBorder') && (0, _element.hasClass)(elem, 'current')) {
-        cell.coords = this.instance.selections.getCell().cellRange.highlight;
-        cell.TD = this.instance.wtTable.getCell(cell.coords);
+        cell.coords = this.selections.getCell().cellRange.highlight;
+        cell.TD = this.wtTable.getCell(cell.coords);
       } else if ((0, _element.hasClass)(elem, 'wtBorder') && (0, _element.hasClass)(elem, 'area')) {
-        if (this.instance.selections.createOrGetArea().cellRange) {
-          cell.coords = this.instance.selections.createOrGetArea().cellRange.to;
-          cell.TD = this.instance.wtTable.getCell(cell.coords);
+        if (this.selections.createOrGetArea().cellRange) {
+          cell.coords = this.selections.createOrGetArea().cellRange.to;
+          cell.TD = this.wtTable.getCell(cell.coords);
         }
       }
 
@@ -213,7 +227,7 @@ var Event = /*#__PURE__*/function () {
     key: "onMouseDown",
     value: function onMouseDown(event) {
       var priv = privatePool.get(this);
-      var activeElement = this.instance.rootDocument.activeElement;
+      var activeElement = this.domBindings.rootDocument.activeElement;
       var getParentNode = (0, _function.partial)(_element.getParent, event.target);
       var realTarget = event.target; // ignore focusable element from mouse down processing (https://github.com/handsontable/handsontable/issues/3555)
 
@@ -224,13 +238,13 @@ var Event = /*#__PURE__*/function () {
       var cell = this.parentCell(realTarget);
 
       if ((0, _element.hasClass)(realTarget, 'corner')) {
-        this.instance.getSetting('onCellCornerMouseDown', event, realTarget);
-      } else if (cell.TD && this.instance.hasSetting('onCellMouseDown')) {
-        this.instance.getSetting('onCellMouseDown', event, cell.coords, cell.TD, this.instance);
+        this.wtSettings.getSetting('onCellCornerMouseDown', event, realTarget);
+      } else if (cell.TD && this.wtSettings.has('onCellMouseDown')) {
+        this.callListener('onCellMouseDown', event, cell.coords, cell.TD);
       } // doubleclick reacts only for left mouse button or from touch events
 
 
-      if ((event.button === 0 || this.instance.touchApplied) && cell.TD) {
+      if ((event.button === 0 || this.touchApplied) && cell.TD) {
         priv.dblClickOrigin[0] = cell.TD;
         clearTimeout(priv.dblClickTimeout[0]);
         priv.dblClickTimeout[0] = setTimeout(function () {
@@ -248,11 +262,11 @@ var Event = /*#__PURE__*/function () {
   }, {
     key: "onContextMenu",
     value: function onContextMenu(event) {
-      if (this.instance.hasSetting('onCellContextMenu')) {
+      if (this.wtSettings.has('onCellContextMenu')) {
         var cell = this.parentCell(event.target);
 
         if (cell.TD) {
-          this.instance.getSetting('onCellContextMenu', event, cell.coords, cell.TD, this.instance);
+          this.callListener('onCellContextMenu', event, cell.coords, cell.TD);
         }
       }
     }
@@ -266,17 +280,17 @@ var Event = /*#__PURE__*/function () {
   }, {
     key: "onMouseOver",
     value: function onMouseOver(event) {
-      if (!this.instance.hasSetting('onCellMouseOver')) {
+      if (!this.wtSettings.has('onCellMouseOver')) {
         return;
       }
 
-      var table = this.instance.wtTable.TABLE;
+      var table = this.wtTable.TABLE;
       var td = (0, _element.closestDown)(event.target, ['TD', 'TH'], table);
-      var mainWOT = this.instance.cloneSource || this.instance;
+      var parent = this.parent || this;
 
-      if (td && td !== mainWOT.lastMouseOver && (0, _element.isChildOf)(td, table)) {
-        mainWOT.lastMouseOver = td;
-        this.instance.getSetting('onCellMouseOver', event, this.instance.wtTable.getCoords(td), td, this.instance);
+      if (td && td !== parent.lastMouseOver && (0, _element.isChildOf)(td, table)) {
+        parent.lastMouseOver = td;
+        this.callListener('onCellMouseOver', event, this.wtTable.getCoords(td), td);
       }
     }
     /**
@@ -289,16 +303,16 @@ var Event = /*#__PURE__*/function () {
   }, {
     key: "onMouseOut",
     value: function onMouseOut(event) {
-      if (!this.instance.hasSetting('onCellMouseOut')) {
+      if (!this.wtSettings.has('onCellMouseOut')) {
         return;
       }
 
-      var table = this.instance.wtTable.TABLE;
+      var table = this.wtTable.TABLE;
       var lastTD = (0, _element.closestDown)(event.target, ['TD', 'TH'], table);
       var nextTD = (0, _element.closestDown)(event.relatedTarget, ['TD', 'TH'], table);
 
       if (lastTD && lastTD !== nextTD && (0, _element.isChildOf)(lastTD, table)) {
-        this.instance.getSetting('onCellMouseOut', event, this.instance.wtTable.getCoords(lastTD), lastTD, this.instance);
+        this.callListener('onCellMouseOut', event, this.wtTable.getCoords(lastTD), lastTD);
       }
     }
     /**
@@ -314,20 +328,20 @@ var Event = /*#__PURE__*/function () {
       var priv = privatePool.get(this);
       var cell = this.parentCell(event.target);
 
-      if (cell.TD && this.instance.hasSetting('onCellMouseUp')) {
-        this.instance.getSetting('onCellMouseUp', event, cell.coords, cell.TD, this.instance);
+      if (cell.TD && this.wtSettings.has('onCellMouseUp')) {
+        this.callListener('onCellMouseUp', event, cell.coords, cell.TD);
       } // if not left mouse button, and the origin event is not comes from touch
 
 
-      if (event.button !== 0 && !this.instance.touchApplied) {
+      if (event.button !== 0 && !this.touchApplied) {
         return;
       }
 
       if (cell.TD === priv.dblClickOrigin[0] && cell.TD === priv.dblClickOrigin[1]) {
         if ((0, _element.hasClass)(event.target, 'corner')) {
-          this.instance.getSetting('onCellCornerDblClick', event, cell.coords, cell.TD, this.instance);
+          this.callListener('onCellCornerDblClick', event, cell.coords, cell.TD);
         } else {
-          this.instance.getSetting('onCellDblClick', event, cell.coords, cell.TD, this.instance);
+          this.callListener('onCellDblClick', event, cell.coords, cell.TD);
         }
 
         priv.dblClickOrigin[0] = null;
@@ -351,8 +365,8 @@ var Event = /*#__PURE__*/function () {
     key: "onTouchStart",
     value: function onTouchStart(event) {
       var priv = privatePool.get(this);
-      priv.selectedCellBeforeTouchEnd = this.instance.selections.getCell().cellRange;
-      this.instance.touchApplied = true;
+      priv.selectedCellBeforeTouchEnd = this.selections.getCell().cellRange;
+      this.touchApplied = true;
       this.onMouseDown(event);
     }
     /**
@@ -370,7 +384,7 @@ var Event = /*#__PURE__*/function () {
       var target = event.target;
       var parentCellCoords = (_this$parentCell = this.parentCell(target)) === null || _this$parentCell === void 0 ? void 0 : _this$parentCell.coords;
       var isCellsRange = (0, _mixed.isDefined)(parentCellCoords) && parentCellCoords.row >= 0 && parentCellCoords.col >= 0;
-      var isEventCancelable = event.cancelable && isCellsRange && this.instance.getSetting('isDataViewInstance'); // To prevent accidental redirects or other actions that the interactive elements (e.q "A" link) do
+      var isEventCancelable = event.cancelable && isCellsRange && this.wtSettings.getSetting('isDataViewInstance'); // To prevent accidental redirects or other actions that the interactive elements (e.q "A" link) do
       // while the cell is highlighted, all touch events that are triggered on different cells are
       // "preventDefault"'ed. The user can interact with the element (e.q. click on the link that opens
       // a new page) only when the same cell was previously selected (see related PR #7980).
@@ -392,7 +406,26 @@ var Event = /*#__PURE__*/function () {
       }
 
       this.onMouseUp(event);
-      this.instance.touchApplied = false;
+      this.touchApplied = false;
+    }
+    /**
+     * Call listener with backward compatibility.
+     *
+     * @private
+     * @param {string} name Name of listener.
+     * @param {MouseEvent} event The event object.
+     * @param {CellCoords} coords Coordinates.
+     * @param {HTMLElement} target Event target.
+     */
+
+  }, {
+    key: "callListener",
+    value: function callListener(name, event, coords, target) {
+      var listener = this.wtSettings.getSettingPure(name);
+
+      if (listener) {
+        listener(event, coords, target, this.facadeGetter());
+      }
     }
     /**
      * Clears double-click timeouts and destroys the internal eventManager instance.