targetj 1.0.74 → 1.0.76

package/build/EventListener.js

@@ -0,0 +1,664 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EventListener = void 0;
+var _$Dom = require("./$Dom.js");
+var _Browser = require("./Browser.js");
+var _SearchUtil = require("./SearchUtil.js");
+var _TUtil = require("./TUtil.js");
+var _App = require("./App.js");
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var EventListener = exports.EventListener = /*#__PURE__*/function () {
+  function EventListener() {
+    var _this = this;
+    _classCallCheck(this, EventListener);
+    this.currentTouch = {
+      deltaY: 0,
+      deltaX: 0,
+      pinchDelta: 0,
+      key: '',
+      manualMomentumFlag: false,
+      orientation: "none",
+      dir: "",
+      source: ""
+    };
+    this.touchTimeStamp = 0;
+    this.cursor = {
+      x: 0,
+      y: 0
+    };
+    this.start0 = undefined;
+    this.start1 = undefined;
+    this.end0 = undefined;
+    this.end1 = undefined;
+    this.touchCount = 0;
+    this.currentEvent = "";
+    this.currentHandlers = {
+      touch: null,
+      scrollLeft: null,
+      scrollTop: null,
+      pinch: null
+    };
+    this.eventQueue = [];
+    this.eventMap = {
+      touchstart: {
+        to: 'touchstart',
+        inputType: 'touch',
+        eventType: 'start',
+        order: 1,
+        windowEvent: false
+      },
+      touchmove: {
+        to: 'touchmove',
+        inputType: 'touch',
+        eventType: 'move',
+        order: 1,
+        windowEvent: false
+      },
+      touchend: {
+        to: 'touchend',
+        inputType: 'touch',
+        eventType: 'end',
+        order: 1,
+        windowEvent: false
+      },
+      touchcancel: {
+        to: 'touchend',
+        inputType: 'touch',
+        eventType: 'cancel',
+        order: 1,
+        windowEvent: false
+      },
+      mousedown: {
+        to: 'mousedown',
+        inputType: 'mouse',
+        eventType: 'start',
+        order: 2,
+        windowEvent: false
+      },
+      mousemove: {
+        to: 'mousemove',
+        inputType: 'mouse',
+        eventType: 'move',
+        order: 2,
+        windowEvent: false
+      },
+      mouseup: {
+        to: 'mouseup',
+        inputType: 'mouse',
+        eventType: 'end',
+        order: 2,
+        windowEvent: false
+      },
+      mousecancel: {
+        to: 'mouseup',
+        inputType: 'mouse',
+        eventType: 'cancel',
+        order: 2,
+        windowEvent: false
+      },
+      pointerdown: {
+        to: 'mousedown',
+        inputType: 'pointer',
+        eventType: 'start',
+        order: 3,
+        windowEvent: false
+      },
+      pointermove: {
+        to: 'mousemove',
+        inputType: 'pointer',
+        eventType: 'move',
+        order: 3,
+        windowEvent: false
+      },
+      pointerup: {
+        to: 'mouseup',
+        inputType: 'pointer',
+        eventType: 'end',
+        order: 3,
+        windowEvent: false
+      },
+      pointercancel: {
+        to: 'mousecancel',
+        inputType: 'pointer',
+        eventType: 'cancel',
+        order: 3,
+        windowEvent: false
+      },
+      wheel: {
+        to: 'wheel',
+        inputType: '',
+        eventType: 'wheel',
+        order: 1,
+        windowEvent: false
+      },
+      DOMMouseScroll: {
+        to: 'wheel',
+        inputType: '',
+        eventType: 'wheel',
+        order: 1,
+        windowEvent: false
+      },
+      mousewheel: {
+        to: 'wheel',
+        inputType: '',
+        eventType: 'wheel',
+        order: 1,
+        windowEvent: false
+      },
+      keyup: {
+        to: 'key',
+        inputType: '',
+        eventType: 'key',
+        order: 1,
+        windowEvent: true
+      },
+      keydown: {
+        to: 'key',
+        inputType: '',
+        eventType: 'key',
+        order: 1,
+        windowEvent: true
+      },
+      resize: {
+        to: 'resize',
+        inputType: '',
+        eventType: 'resize',
+        order: 1,
+        windowEvent: true
+      },
+      orientationchange: {
+        to: 'resize',
+        inputType: '',
+        eventType: 'resize',
+        order: 1,
+        windowEvent: true
+      }
+    };
+    this.domEvents = Object.keys(this.eventMap).filter(function (key) {
+      return !_this.eventMap[key].windowEvent;
+    });
+    this.windowEvents = Object.keys(this.eventMap).filter(function (key) {
+      return _this.eventMap[key].windowEvent;
+    });
+    this.bindedHandleEvent = this.bindedHandleEvent || this.handleEvent.bind(this);
+  }
+  return _createClass(EventListener, [{
+    key: "removeHandlers",
+    value: function removeHandlers($dom) {
+      var _this2 = this;
+      this.domEvents.forEach(function (key) {
+        $dom.detachEvent(key, _this2.bindedHandleEvent);
+      });
+    }
+  }, {
+    key: "addHandlers",
+    value: function addHandlers($dom) {
+      var _this3 = this;
+      this.domEvents.forEach(function (key) {
+        $dom.addEvent(key, _this3.bindedHandleEvent);
+      });
+    }
+  }, {
+    key: "removeWindowHandlers",
+    value: function removeWindowHandlers() {
+      var _this4 = this;
+      this.windowEvents.forEach(function (key) {
+        _App.tApp.$window.detachEvent(key, _this4.bindedHandleEvent);
+      });
+    }
+  }, {
+    key: "addWindowHandlers",
+    value: function addWindowHandlers() {
+      var _this5 = this;
+      this.windowEvents.forEach(function (key) {
+        _App.tApp.$window.addEvent(key, _this5.bindedHandleEvent);
+      });
+    }
+  }, {
+    key: "captureEvents",
+    value: function captureEvents() {
+      if (this.eventQueue.length === 0) {
+        this.currentEvent = "";
+        this.currentKey = "";
+        return;
+      }
+      var lastEvent = this.eventQueue.shift();
+      if (lastEvent.eventName === 'resize') {
+        _App.tApp.dim.measureScreen();
+      } else {
+        if (lastEvent.tmodel) {
+          this.findEventHandlers(lastEvent.tmodel);
+        }
+        this.currentEvent = lastEvent.eventName;
+        this.currentKey = this.currentTouch.key;
+        this.currentTouch.key = "";
+      }
+      _App.tApp.manager.scheduleRun(10, "captureEvents-".concat(lastEvent));
+    }
+  }, {
+    key: "handleEvent",
+    value: function handleEvent(event) {
+      if (!event) {
+        return;
+      }
+      var originalName = event.type;
+      var eventItem = this.eventMap[originalName];
+      if (!eventItem) {
+        return;
+      }
+      var eventName = eventItem.to,
+        inputType = eventItem.inputType,
+        eventType = eventItem.eventType,
+        eventOrder = eventItem.order;
+      var now = _Browser.browser.now();
+      this.touchTimeStamp = Math.max(now, this.touchTimeStamp);
+      var tmodel = this.getTModelFromEvent(event);
+      var lastEvent = this.eventQueue.length > 0 ? this.eventQueue[this.eventQueue.length - 1] : null;
+      if (lastEvent) {
+        var lastEventItem = lastEvent.eventItem;
+        var rate = now - lastEvent.timeStamp;
+        if (inputType && lastEventItem.inputType && lastEventItem.inputType !== inputType && eventOrder > lastEventItem.order) {
+          return;
+        } else if (this.eventQueue.length > 10 && rate < 50) {
+          var capacity = 0;
+          for (var i = this.eventQueue.length - 1; i >= 0 && this.eventQueue[i].eventItem.eventType === eventType; i--) {
+            if (++capacity > 5) {
+              return;
+            }
+          }
+        }
+      }
+      this.eventQueue.push({
+        eventName: eventName,
+        eventItem: eventItem,
+        originalName: originalName,
+        tmodel: tmodel,
+        timeStamp: now
+      });
+      switch (eventName) {
+        case 'mousedown':
+        case 'touchstart':
+          this.clearStart();
+          this.clearTouch();
+          this.touchCount = this.countTouches(event);
+          if (this.preventDefault(tmodel, eventName)) {
+            event.preventDefault();
+          }
+          this.start0 = this.getTouch(event);
+          this.start1 = this.getTouch(event, 1);
+          this.cursor.x = this.start0.x;
+          this.cursor.y = this.start0.y;
+          event.stopPropagation();
+          break;
+        case 'mousemove':
+        case 'touchmove':
+          {
+            var touch = this.getTouch(event);
+            this.cursor.x = touch.x;
+            this.cursor.y = touch.y;
+            if (this.preventDefault(tmodel, eventName)) {
+              event.preventDefault();
+            }
+            if (this.touchCount > 0) {
+              this.move(event);
+              event.stopPropagation();
+            }
+            break;
+          }
+        case 'mouseup':
+        case 'touchend':
+          if (this.preventDefault(tmodel, eventName)) {
+            event.preventDefault();
+          }
+          this.end(event);
+          if (this.start0) {
+            var deltaX = this.end0 ? Math.abs(this.end0.originalX - this.start0.originalX) : 0;
+            var deltaY = this.end0 ? Math.abs(this.end0.originalY - this.start0.originalY) : 0;
+            var period = this.end0 ? Math.abs(this.end0.timeStamp - this.start0.timeStamp) : 300;
+            if (deltaX <= 1 && deltaY <= 1 && period <= 300) {
+              this.eventQueue.push({
+                eventName: 'click',
+                eventItem: eventItem,
+                originalName: originalName,
+                tmodel: tmodel,
+                timeStamp: now
+              });
+            }
+          }
+          this.clearStart();
+          this.touchCount = 0;
+          event.stopPropagation();
+          break;
+        case 'wheel':
+          if (this.preventDefault(tmodel, eventName)) {
+            event.preventDefault();
+          }
+          this.wheel(event);
+          break;
+        case 'key':
+          this.currentTouch.key = event.which || event.keyCode;
+          break;
+      }
+      _App.tApp.manager.scheduleRun(0, "".concat(originalName, "-").concat(eventName, "-").concat((event.target.tagName || "").toUpperCase()));
+    }
+  }, {
+    key: "findEventHandlers",
+    value: function findEventHandlers(tmodel) {
+      var touchHandler = tmodel ? _SearchUtil.SearchUtil.findFirstTouchHandler(tmodel) : null;
+      var scrollLeftHandler = this.end0 ? this.currentHandlers.scrollLeft : tmodel ? _SearchUtil.SearchUtil.findFirstScrollLeftHandler(tmodel) : null;
+      var scrollTopHandler = this.end0 ? this.currentHandlers.scrollTop : tmodel ? _SearchUtil.SearchUtil.findFirstScrollTopHandler(tmodel) : null;
+      var pinchHandler = tmodel ? _SearchUtil.SearchUtil.findFirstPinchHandler(tmodel) : null;
+      if (this.currentHandlers.scrollLeft !== scrollLeftHandler || this.currentHandlers.scrollTop !== scrollTopHandler) {
+        this.clearTouch();
+      }
+      this.currentHandlers.touch = touchHandler;
+      this.currentHandlers.scrollLeft = scrollLeftHandler;
+      this.currentHandlers.scrollTop = scrollTopHandler;
+      this.currentHandlers.pinch = pinchHandler;
+    }
+  }, {
+    key: "preventDefault",
+    value: function preventDefault(tmodel, eventName) {
+      if (tmodel && (tmodel.keepEventDefault() === true || Array.isArray(tmodel.keepEventDefault()) && tmodel.keepEventDefault().includes(eventName))) {
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "getTModelFromEvent",
+    value: function getTModelFromEvent(event) {
+      var oid = typeof event.target.getAttribute === 'function' ? event.target.getAttribute('id') : '';
+      if (!oid || !_App.tApp.manager.visibleOidMap[oid]) {
+        oid = _$Dom.$Dom.findNearestParentWithId(event.target);
+      }
+      return _App.tApp.manager.visibleOidMap[oid];
+    }
+  }, {
+    key: "clearStart",
+    value: function clearStart() {
+      this.start0 = undefined;
+      this.start1 = undefined;
+      this.end0 = undefined;
+      this.end1 = undefined;
+      this.touchCount = 0;
+    }
+  }, {
+    key: "clearTouch",
+    value: function clearTouch() {
+      this.currentTouch = {
+        deltaY: 0,
+        deltaX: 0,
+        pinchDelta: 0,
+        key: '',
+        manualMomentumFlag: false,
+        orientation: "none",
+        dir: "",
+        source: ""
+      };
+    }
+  }, {
+    key: "clearAll",
+    value: function clearAll() {
+      this.clearStart();
+      this.clearTouch();
+      this.eventQueue.length = 0;
+      this.touchTimeStamp = 0;
+    }
+  }, {
+    key: "resetEventsOnTimeout",
+    value: function resetEventsOnTimeout() {
+      if (this.touchTimeStamp > 0) {
+        var diff = _Browser.browser.now() - this.touchTimeStamp;
+        var runDelay = 0;
+        if (Math.abs(this.currentTouch.deltaY) > 0.001 || Math.abs(this.currentTouch.deltaX) > 0.001 || Math.abs(this.currentTouch.pinchDelta) > 0.001) {
+          if (diff > 70) {
+            this.clearTouch();
+          } else if (this.currentTouch.manualMomentumFlag) {
+            this.currentTouch.deltaY *= 0.85;
+            this.currentTouch.deltaX *= 0.85;
+            runDelay = 10;
+          }
+        } else if (diff > 600) {
+          this.clearTouch();
+          this.touchTimeStamp = 0;
+        }
+        _App.tApp.manager.scheduleRun(runDelay, "scroll decay");
+      }
+    }
+  }, {
+    key: "deltaX",
+    value: function deltaX() {
+      return this.currentTouch.deltaX;
+    }
+  }, {
+    key: "deltaY",
+    value: function deltaY() {
+      return this.currentTouch.deltaY;
+    }
+  }, {
+    key: "pinchDelta",
+    value: function pinchDelta() {
+      return this.currentTouch.pinchDelta;
+    }
+  }, {
+    key: "dir",
+    value: function dir() {
+      return this.currentTouch.dir;
+    }
+  }, {
+    key: "getScrollLeftHandler",
+    value: function getScrollLeftHandler() {
+      return this.currentHandlers.scrollLeft;
+    }
+  }, {
+    key: "getScrollTopHandler",
+    value: function getScrollTopHandler() {
+      return this.currentHandlers.scrollTop;
+    }
+  }, {
+    key: "getPinchHandler",
+    value: function getPinchHandler() {
+      return this.currentHandlers.pinch;
+    }
+  }, {
+    key: "getTouchHandler",
+    value: function getTouchHandler() {
+      return this.currentHandlers.touch;
+    }
+  }, {
+    key: "getTouchHandlerType",
+    value: function getTouchHandlerType() {
+      return this.currentHandlers.touch ? this.currentHandlers.touch.type : null;
+    }
+  }, {
+    key: "getTouchHandlerOid",
+    value: function getTouchHandlerOid() {
+      return this.currentHandlers.touch ? this.currentHandlers.touch.oid : null;
+    }
+  }, {
+    key: "isClickEvent",
+    value: function isClickEvent() {
+      return this.currentEvent === 'click';
+    }
+  }, {
+    key: "isResizeEvent",
+    value: function isResizeEvent() {
+      return this.currentEvent === 'resize';
+    }
+  }, {
+    key: "getCurrentEvent",
+    value: function getCurrentEvent() {
+      return this.currentEvent;
+    }
+  }, {
+    key: "isClickHandler",
+    value: function isClickHandler(target) {
+      return this.getTouchHandler() === target && this.isClickEvent();
+    }
+  }, {
+    key: "isClickHandlerType",
+    value: function isClickHandlerType(type) {
+      return this.getTouchHandlerType() === type && this.isClickEvent();
+    }
+  }, {
+    key: "isTouchHandler",
+    value: function isTouchHandler(handler) {
+      return this.getTouchHandler() === handler && handler.canHandleEvents('touch');
+    }
+  }, {
+    key: "isScrollLeftHandler",
+    value: function isScrollLeftHandler(handler) {
+      return this.currentHandlers.scrollLeft === handler;
+    }
+  }, {
+    key: "isScrollTopHandler",
+    value: function isScrollTopHandler(handler) {
+      return this.currentHandlers.scrollTop === handler;
+    }
+  }, {
+    key: "isPinchHandler",
+    value: function isPinchHandler(handler) {
+      return this.currentHandlers.pinch === handler;
+    }
+  }, {
+    key: "isCurrentSource",
+    value: function isCurrentSource(source) {
+      return this.currentTouch.source === source;
+    }
+  }, {
+    key: "isTouchHandlerType",
+    value: function isTouchHandlerType(type) {
+      return this.getTouchHandlerType() === type;
+    }
+  }, {
+    key: "isTouchHandlerOrAncestor",
+    value: function isTouchHandlerOrAncestor(target) {
+      var handler = this.getTouchHandler();
+      while (handler) {
+        if (handler === target) {
+          return true;
+        }
+        handler = handler.getParent();
+      }
+      return false;
+    }
+  }, {
+    key: "countTouches",
+    value: function countTouches(event) {
+      var _event$touches, _event$originalEvent;
+      return ((_event$touches = event.touches) === null || _event$touches === void 0 ? void 0 : _event$touches.length) || ((_event$originalEvent = event.originalEvent) === null || _event$originalEvent === void 0 || (_event$originalEvent = _event$originalEvent.touches) === null || _event$originalEvent === void 0 ? void 0 : _event$originalEvent.length) || 1;
+    }
+  }, {
+    key: "getTouch",
+    value: function getTouch(event) {
+      var _event$touches2, _event$originalEvent2;
+      var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var e = ((_event$touches2 = event.touches) === null || _event$touches2 === void 0 ? void 0 : _event$touches2[index]) || ((_event$originalEvent2 = event.originalEvent) === null || _event$originalEvent2 === void 0 || (_event$originalEvent2 = _event$originalEvent2.touches) === null || _event$originalEvent2 === void 0 ? void 0 : _event$originalEvent2[index]) || event;
+      var x = _TUtil.TUtil.isDefined(e.clientX) ? e.clientX : e.pageX || 0;
+      var y = _TUtil.TUtil.isDefined(e.clientY) ? e.clientY : e.pageY || 0;
+      return {
+        x: x,
+        y: y,
+        originalX: x,
+        originalY: y,
+        target: e.target,
+        timeStamp: _Browser.browser.now()
+      };
+    }
+  }, {
+    key: "move",
+    value: function move(event) {
+      if (this.touchCount === 1) {
+        this.start0.y = this.end0 ? this.end0.y : this.start0.y;
+        this.start0.x = this.end0 ? this.end0.x : this.start0.x;
+        this.end0 = this.getTouch(event);
+        if (_TUtil.TUtil.isDefined(this.end0)) {
+          var deltaX = this.start0.x - this.end0.x;
+          var deltaY = this.start0.y - this.end0.y;
+          this.setDeltaXDeltaY(deltaX, deltaY, 'touch');
+        }
+      } else if (this.touchCount >= 2) {
+        this.end0 = this.getTouch(event);
+        this.end1 = this.getTouch(event, 1);
+        var length1 = _TUtil.TUtil.distance(this.start0.x, this.start0.y, this.start1.x, this.start1.y);
+        var length2 = _TUtil.TUtil.distance(this.end0.x, this.end0.y, this.end1.x, this.end1.y);
+        var diff = length2 - length1;
+        this.currentTouch.pinchDelta = diff > 0 ? 0.3 : diff < 0 ? -0.3 : 0;
+      }
+    }
+  }, {
+    key: "end",
+    value: function end() {
+      if (this.touchCount <= 1 && this.start0) {
+        var deltaX = this.end0 ? this.start0.x - this.end0.x : 0;
+        var deltaY = this.end0 ? this.start0.y - this.end0.y : 0;
+        var period = this.end0 ? this.end0.timeStamp - this.start0.timeStamp : 0;
+        var momentum;
+        if (this.currentTouch.orientation === "horizontal" && Math.abs(deltaX) > 1) {
+          momentum = _TUtil.TUtil.momentum(0, deltaX, period);
+          this.currentTouch.deltaX = momentum.distance;
+          this.currentTouch.manualMomentumFlag = true;
+          this.touchTimeStamp = _Browser.browser.now() + momentum.duration;
+        } else if (this.currentTouch.orientation === "vertical" && Math.abs(deltaY) > 1) {
+          momentum = _TUtil.TUtil.momentum(0, deltaY, period);
+          this.currentTouch.deltaY = momentum.distance;
+          this.currentTouch.manualMomentumFlag = true;
+          this.touchTimeStamp = _Browser.browser.now() + momentum.duration;
+        }
+      }
+    }
+  }, {
+    key: "setDeltaXDeltaY",
+    value: function setDeltaXDeltaY(deltaX, deltaY, source) {
+      var diff = Math.abs(deltaX) - Math.abs(deltaY);
+      if (diff >= 1) {
+        if (this.currentTouch.orientation === "none" || this.currentTouch.orientation === "vertical" && diff > 3 || this.currentTouch.orientation === "horizontal") {
+          this.currentTouch.orientation = "horizontal";
+          this.currentTouch.dir = deltaX <= -1 ? "left" : deltaX >= 1 ? "right" : this.currentTouch.dir;
+          this.currentTouch.source = source;
+          this.currentTouch.deltaX = deltaX;
+          this.currentTouch.deltaY = 0;
+        }
+      } else if (this.currentTouch.orientation === "none" || this.currentTouch.orientation === "horizontal" && diff < -3 || this.currentTouch.orientation === "vertical") {
+        this.currentTouch.orientation = "vertical";
+        this.currentTouch.dir = deltaY <= -1 ? "up" : deltaY >= 1 ? "down" : this.currentTouch.dir;
+        this.currentTouch.source = source;
+        this.currentTouch.deltaY = deltaY;
+        this.currentTouch.deltaX = 0;
+      } else {
+        this.currentTouch.deltaY = 0;
+        this.currentTouch.deltaX = 0;
+      }
+    }
+  }, {
+    key: "wheel",
+    value: function wheel(event) {
+      var deltaX = 0;
+      var deltaY = 0;
+      this.currentTouch.pinchDelta = 0;
+      this.start0 = this.getTouch(event);
+      if (event.ctrlKey && 'deltaY' in event) {
+        this.currentTouch.pinchDelta = -event.deltaY / 10;
+      } else if ('deltaX' in event) {
+        deltaX = event.deltaX;
+        deltaY = event.deltaY;
+      } else if ('wheelDeltaX' in event) {
+        deltaX = -event.wheelDeltaX / 120;
+        deltaY = -event.wheelDeltaY / 120;
+      } else if ('wheelDelta' in event) {
+        deltaX = -event.wheelDelta / 120;
+      } else if ('detail' in event) {
+        deltaX = event.detail / 3;
+      }
+      this.setDeltaXDeltaY(deltaX, deltaY, 'wheel');
+    }
+  }]);
+}();