@antv/l7-map 2.9.33 → 2.9.34

package/lib/handler/handler_manager.js

@@ -1,455 +1,714 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-// src/handler/handler_manager.ts
-var handler_manager_exports = {};
-__export(handler_manager_exports, {
-  default: () => handler_manager_default
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(handler_manager_exports);
-var import_l7_utils = require("@antv/l7-utils");
-var import_lodash = require("lodash");
-var import_point = __toESM(require("../geo/point"));
-var import_dom = __toESM(require("../utils/dom"));
-var import_blockable_map_event = __toESM(require("./blockable_map_event"));
-var import_box_zoom = __toESM(require("./box_zoom"));
-var import_click_zoom = __toESM(require("./click_zoom"));
-var import_event = require("./events/event");
-var import_render_event = __toESM(require("./events/render_event"));
-var import_handler_inertia = __toESM(require("./handler_inertia"));
-var import_keyboard = __toESM(require("./keyboard"));
-var import_map_event = __toESM(require("./map_event"));
-var import_mouse = require("./mouse");
-var import_scroll_zoom = __toESM(require("./scroll_zoom"));
-var import_dblclick_zoom = __toESM(require("./shim/dblclick_zoom"));
-var import_drag_pan = __toESM(require("./shim/drag_pan"));
-var import_drag_rotate = __toESM(require("./shim/drag_rotate"));
-var import_touch_zoom_rotate = __toESM(require("./shim/touch_zoom_rotate"));
-var import_tap_drag_zoom = __toESM(require("./tap/tap_drag_zoom"));
-var import_tap_zoom = __toESM(require("./tap/tap_zoom"));
-var import_touch = require("./touch");
-var isMoving = (p) => p.zoom || p.drag || p.pitch || p.rotate;
+exports.default = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _l7Utils = require("@antv/l7-utils");
+
+var _lodash = require("lodash");
+
+var _point = _interopRequireDefault(require("../geo/point"));
+
+var _dom = _interopRequireDefault(require("../utils/dom"));
+
+var _blockable_map_event = _interopRequireDefault(require("./blockable_map_event"));
+
+var _box_zoom = _interopRequireDefault(require("./box_zoom"));
+
+var _click_zoom = _interopRequireDefault(require("./click_zoom"));
+
+var _event = require("./events/event");
+
+var _render_event = _interopRequireDefault(require("./events/render_event"));
+
+var _handler_inertia = _interopRequireDefault(require("./handler_inertia"));
+
+var _keyboard = _interopRequireDefault(require("./keyboard"));
+
+var _map_event = _interopRequireDefault(require("./map_event"));
+
+var _mouse = require("./mouse");
+
+var _scroll_zoom = _interopRequireDefault(require("./scroll_zoom"));
+
+var _dblclick_zoom = _interopRequireDefault(require("./shim/dblclick_zoom"));
+
+var _drag_pan = _interopRequireDefault(require("./shim/drag_pan"));
+
+var _drag_rotate = _interopRequireDefault(require("./shim/drag_rotate"));
+
+var _touch_zoom_rotate = _interopRequireDefault(require("./shim/touch_zoom_rotate"));
+
+var _tap_drag_zoom = _interopRequireDefault(require("./tap/tap_drag_zoom"));
+
+var _tap_zoom = _interopRequireDefault(require("./tap/tap_zoom"));
+
+var _touch = require("./touch");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var _isMoving = function isMoving(p) {
+  return p.zoom || p.drag || p.pitch || p.rotate;
+};
+
 function hasChange(result) {
   return result.panDelta && result.panDelta.mag() || result.zoomDelta || result.bearingDelta || result.pitchDelta;
 }
-var HandlerManager = class {
-  constructor(map, options) {
-    this.handleWindowEvent = (e) => {
-      this.handleEvent(e, `${e.type}Window`);
-    };
-    this.handleEvent = (e, eventName) => {
-      if (e.type === "blur") {
-        this.stop();
+
+var HandlerManager = /*#__PURE__*/function () {
+  function HandlerManager(map, options) {
+    var _this = this;
+
+    (0, _classCallCheck2.default)(this, HandlerManager);
+    (0, _defineProperty2.default)(this, "handleWindowEvent", function (e) {
+      _this.handleEvent(e, "".concat(e.type, "Window"));
+    });
+    (0, _defineProperty2.default)(this, "handleEvent", function (e, eventName) {
+      if (e.type === 'blur') {
+        _this.stop();
+
         return;
       }
-      this.updatingCamera = true;
-      const inputEvent = e.type === "renderFrame" ? void 0 : e;
-      const mergedIHandlerResult = { needsRenderFrame: false };
-      const eventsInProgress = {};
-      const activeHandlers = {};
-      const mapTouches = e.touches ? this.getMapTouches(e.touches) : void 0;
-      const points = mapTouches ? import_dom.default.touchPos(this.el, mapTouches) : import_dom.default.mousePos(this.el, e);
-      for (const { handlerName, handler, allowed } of this.handlers) {
-        if (!handler.isEnabled()) {
-          continue;
-        }
-        let data;
-        if (this.blockedByActive(activeHandlers, allowed, handlerName)) {
-          handler.reset();
-        } else {
-          const handerName = eventName || e.type;
-          if (handler && handler[handerName]) {
-            data = handler[handerName](e, points, mapTouches);
-            this.mergeIHandlerResult(mergedIHandlerResult, eventsInProgress, data, handlerName, inputEvent);
-            if (data && data.needsRenderFrame) {
-              this.triggerRenderFrame();
+
+      _this.updatingCamera = true;
+      var inputEvent = e.type === 'renderFrame' ? undefined : e;
+      /*
+       * We don't call e.preventDefault() for any events by default.
+       * Handlers are responsible for calling it where necessary.
+       */
+
+      var mergedIHandlerResult = {
+        needsRenderFrame: false
+      };
+      var eventsInProgress = {};
+      var activeHandlers = {}; // @ts-ignore
+
+      var mapTouches = e.touches ? // @ts-ignore
+      _this.getMapTouches(e.touches) : undefined;
+      var points = mapTouches ? _dom.default.touchPos(_this.el, mapTouches) : _dom.default.mousePos(_this.el, e);
+
+      var _iterator = _createForOfIteratorHelper(_this.handlers),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _step.value,
+              handlerName = _step$value.handlerName,
+              handler = _step$value.handler,
+              allowed = _step$value.allowed;
+
+          if (!handler.isEnabled()) {
+            continue;
+          }
+
+          var data = void 0;
+
+          if (_this.blockedByActive(activeHandlers, allowed, handlerName)) {
+            handler.reset();
+          } else {
+            var handerName = eventName || e.type; // @ts-ignore
+
+            if (handler && handler[handerName]) {
+              // @ts-ignore
+              data = handler[handerName](e, points, mapTouches);
+
+              _this.mergeIHandlerResult(mergedIHandlerResult, eventsInProgress, data, handlerName, inputEvent);
+
+              if (data && data.needsRenderFrame) {
+                _this.triggerRenderFrame();
+              }
             }
+          } // @ts-ignore
+
+
+          if (data || handler.isActive()) {
+            activeHandlers[handlerName] = handler;
           }
         }
-        if (data || handler.isActive()) {
-          activeHandlers[handlerName] = handler;
-        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
-      const deactivatedHandlers = {};
-      for (const name in this.previousActiveHandlers) {
+
+      var deactivatedHandlers = {};
+
+      for (var name in _this.previousActiveHandlers) {
         if (!activeHandlers[name]) {
           deactivatedHandlers[name] = inputEvent;
         }
       }
-      this.previousActiveHandlers = activeHandlers;
+
+      _this.previousActiveHandlers = activeHandlers;
+
       if (Object.keys(deactivatedHandlers).length || hasChange(mergedIHandlerResult)) {
-        this.changes.push([
-          mergedIHandlerResult,
-          eventsInProgress,
-          deactivatedHandlers
-        ]);
-        this.triggerRenderFrame();
+        _this.changes.push([mergedIHandlerResult, eventsInProgress, deactivatedHandlers]);
+
+        _this.triggerRenderFrame();
       }
+
       if (Object.keys(activeHandlers).length || hasChange(mergedIHandlerResult)) {
-        this.map.stop(true);
+        _this.map.stop(true);
       }
-      this.updatingCamera = false;
-      const { cameraAnimation } = mergedIHandlerResult;
+
+      _this.updatingCamera = false;
+      var cameraAnimation = mergedIHandlerResult.cameraAnimation;
+
       if (cameraAnimation) {
-        this.inertia.clear();
-        this.fireEvents({}, {});
-        this.changes = [];
-        cameraAnimation(this.map);
+        _this.inertia.clear();
+
+        _this.fireEvents({}, {});
+
+        _this.changes = [];
+        cameraAnimation(_this.map);
       }
-    };
+    });
     this.map = map;
     this.el = this.map.getCanvasContainer();
     this.handlers = [];
     this.handlersById = {};
     this.changes = [];
-    this.inertia = new import_handler_inertia.default(map);
+    this.inertia = new _handler_inertia.default(map);
     this.bearingSnap = options.bearingSnap;
     this.rotateEnabled = options.rotateEnabled;
     this.pitchEnabled = options.pitchEnabled;
-    this.previousActiveHandlers = {};
+    this.previousActiveHandlers = {}; // Track whether map is currently moving, to compute start/move/end events
+
     this.eventsInProgress = {};
     this.addDefaultHandlers(options);
-    const el = this.el;
+    var el = this.el;
     this.listeners = [];
-    if (!import_l7_utils.isMini) {
-      this.listeners = [
-        [el, "touchstart", { passive: false }],
-        [el, "touchmove", { passive: false }],
-        [el, "touchend", void 0],
-        [el, "touchcancel", void 0],
-        [el, "mousedown", void 0],
-        [el, "mousemove", void 0],
-        [el, "mouseup", void 0],
-        [window.document, "mousemove", { capture: true }],
-        [window.document, "mouseup", void 0],
-        [el, "mouseover", void 0],
-        [el, "mouseout", void 0],
-        [el, "dblclick", void 0],
-        [el, "click", void 0],
-        [el, "keydown", { capture: false }],
-        [el, "keyup", void 0],
-        [el, "wheel", { passive: false }],
-        [el, "contextmenu", void 0],
-        [window, "blur", void 0]
-      ];
-      for (const [target, type, listenerOptions] of this.listeners) {
-        import_dom.default.addEventListener(target, type, target === window.document ? this.handleWindowEvent : this.handleEvent, listenerOptions);
+
+    if (!_l7Utils.isMini) {
+      // l7 - mini
+      this.listeners = [// Bind touchstart and touchmove with passive: false because, even though
+      // they only fire a map events and therefore could theoretically be
+      // passive, binding with passive: true causes iOS not to respect
+      // e.preventDefault() in _other_ handlers, even if they are non-passive
+      // (see https://bugs.webkit.org/show_bug.cgi?id=184251)
+      [el, 'touchstart', {
+        passive: false
+      }], [el, 'touchmove', {
+        passive: false
+      }], [el, 'touchend', undefined], [el, 'touchcancel', undefined], [el, 'mousedown', undefined], [el, 'mousemove', undefined], [el, 'mouseup', undefined], // Bind window-level event listeners for move and up/end events. In the absence of
+      // the pointer capture API, which is not supported by all necessary platforms,
+      // window-level event listeners give us the best shot at capturing events that
+      // fall outside the map canvas element. Use `{capture: true}` for the move event
+      // to prevent map move events from being fired during a drag.
+      // @ts-ignore
+      [window.document, 'mousemove', {
+        capture: true
+      }], // @ts-ignore
+      [window.document, 'mouseup', undefined], [el, 'mouseover', undefined], [el, 'mouseout', undefined], [el, 'dblclick', undefined], [el, 'click', undefined], [el, 'keydown', {
+        capture: false
+      }], [el, 'keyup', undefined], [el, 'wheel', {
+        passive: false
+      }], [el, 'contextmenu', undefined], // @ts-ignore
+      [window, 'blur', undefined]];
+
+      var _iterator2 = _createForOfIteratorHelper(this.listeners),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = (0, _slicedToArray2.default)(_step2.value, 3),
+              target = _step2$value[0],
+              type = _step2$value[1],
+              listenerOptions = _step2$value[2];
+
+          // @ts-ignore
+          _dom.default.addEventListener(target, type, // @ts-ignore
+          target === window.document ? this.handleWindowEvent : this.handleEvent, listenerOptions);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
       }
     } else {
-      import_l7_utils.$window.document.addEventListener("touchstart", (e) => {
-        this.handleEvent(e);
+      _l7Utils.$window.document.addEventListener('touchstart', function (e) {
+        _this.handleEvent(e);
       }, {});
-      import_l7_utils.$window.document.addEventListener("touchmove", (e) => {
-        this.handleEvent(e);
+
+      _l7Utils.$window.document.addEventListener('touchmove', function (e) {
+        _this.handleEvent(e);
       }, {});
-      import_l7_utils.$window.document.addEventListener("touchend", (e) => {
-        this.handleEvent(e);
+
+      _l7Utils.$window.document.addEventListener('touchend', function (e) {
+        _this.handleEvent(e);
       }, {});
-      import_l7_utils.$window.document.addEventListener("touchcancel", (e) => {
-        this.handleEvent(e);
+
+      _l7Utils.$window.document.addEventListener('touchcancel', function (e) {
+        _this.handleEvent(e);
       }, {});
     }
   }
-  destroy() {
-    for (const [target, type, listenerOptions] of this.listeners) {
-      import_dom.default.removeEventListener(target, type, target === window.document ? this.handleWindowEvent : this.handleEvent, listenerOptions);
-    }
-  }
-  stop() {
-    if (this.updatingCamera) {
-      return;
+
+  (0, _createClass2.default)(HandlerManager, [{
+    key: "destroy",
+    value: function destroy() {
+      var _iterator3 = _createForOfIteratorHelper(this.listeners),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _step3$value = (0, _slicedToArray2.default)(_step3.value, 3),
+              target = _step3$value[0],
+              type = _step3$value[1],
+              listenerOptions = _step3$value[2];
+
+          // @ts-ignore
+          _dom.default.removeEventListener(target, type, // @ts-ignore
+          target === window.document ? this.handleWindowEvent : this.handleEvent, listenerOptions);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
     }
-    for (const { handler } of this.handlers) {
-      handler.reset();
+  }, {
+    key: "stop",
+    value: function stop() {
+      // do nothing if this method was triggered by a gesture update
+      if (this.updatingCamera) {
+        return;
+      }
+
+      var _iterator4 = _createForOfIteratorHelper(this.handlers),
+          _step4;
+
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var handler = _step4.value.handler;
+          handler.reset();
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+
+      this.inertia.clear();
+      this.fireEvents({}, {});
+      this.changes = [];
     }
-    this.inertia.clear();
-    this.fireEvents({}, {});
-    this.changes = [];
-  }
-  isActive() {
-    for (const { handler } of this.handlers) {
-      if (handler.isActive()) {
-        return true;
+  }, {
+    key: "isActive",
+    value: function isActive() {
+      var _iterator5 = _createForOfIteratorHelper(this.handlers),
+          _step5;
+
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var handler = _step5.value.handler;
+
+          if (handler.isActive()) {
+            return true;
+          }
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
       }
+
+      return false;
     }
-    return false;
-  }
-  isZooming() {
-    return !!this.eventsInProgress.zoom || this.map.scrollZoom.isZooming();
-  }
-  isRotating() {
-    return !!this.eventsInProgress.rotate;
-  }
-  isMoving() {
-    return Boolean(isMoving(this.eventsInProgress)) || this.isZooming();
-  }
-  mergeIHandlerResult(mergedIHandlerResult, eventsInProgress, HandlerResult, name, e) {
-    if (!HandlerResult) {
-      return;
+  }, {
+    key: "isZooming",
+    value: function isZooming() {
+      return !!this.eventsInProgress.zoom || this.map.scrollZoom.isZooming();
+    }
+  }, {
+    key: "isRotating",
+    value: function isRotating() {
+      return !!this.eventsInProgress.rotate;
     }
-    (0, import_lodash.merge)(mergedIHandlerResult, HandlerResult);
-    const eventData = {
-      handlerName: name,
-      originalEvent: HandlerResult.originalEvent || e
-    };
-    if (HandlerResult.zoomDelta !== void 0) {
-      eventsInProgress.zoom = eventData;
+  }, {
+    key: "isMoving",
+    value: function isMoving() {
+      return Boolean(_isMoving(this.eventsInProgress)) || this.isZooming();
     }
-    if (HandlerResult.panDelta !== void 0) {
-      eventsInProgress.drag = eventData;
+  }, {
+    key: "mergeIHandlerResult",
+    value: function mergeIHandlerResult(mergedIHandlerResult, eventsInProgress, HandlerResult, name, e) {
+      if (!HandlerResult) {
+        return;
+      }
+
+      (0, _lodash.merge)(mergedIHandlerResult, HandlerResult);
+      var eventData = {
+        handlerName: name,
+        originalEvent: HandlerResult.originalEvent || e
+      }; // track which handler changed which camera property
+
+      if (HandlerResult.zoomDelta !== undefined) {
+        eventsInProgress.zoom = eventData;
+      }
+
+      if (HandlerResult.panDelta !== undefined) {
+        eventsInProgress.drag = eventData;
+      }
+
+      if (HandlerResult.pitchDelta !== undefined) {
+        eventsInProgress.pitch = eventData;
+      }
+
+      if (HandlerResult.bearingDelta !== undefined) {
+        eventsInProgress.rotate = eventData;
+      }
     }
-    if (HandlerResult.pitchDelta !== void 0) {
-      eventsInProgress.pitch = eventData;
+  }, {
+    key: "triggerRenderFrame",
+    value: function triggerRenderFrame() {
+      var _this2 = this;
+
+      if (this.frameId === undefined) {
+        this.frameId = this.map.requestRenderFrame(function (timeStamp) {
+          // @ts-ignore
+          delete _this2.frameId;
+
+          _this2.handleEvent(new _render_event.default('renderFrame', {
+            timeStamp: timeStamp
+          }));
+
+          _this2.applyChanges();
+        });
+      }
     }
-    if (HandlerResult.bearingDelta !== void 0) {
-      eventsInProgress.rotate = eventData;
+  }, {
+    key: "addDefaultHandlers",
+    value: function addDefaultHandlers(options) {
+      var map = this.map;
+      var el = map.getCanvasContainer();
+      this.add('mapEvent', new _map_event.default(map, options));
+      var boxZoom = map.boxZoom = new _box_zoom.default(map, options);
+      this.add('boxZoom', boxZoom);
+      var tapZoom = new _tap_zoom.default();
+      var clickZoom = new _click_zoom.default();
+      map.doubleClickZoom = new _dblclick_zoom.default(clickZoom, tapZoom);
+      this.add('tapZoom', tapZoom);
+      this.add('clickZoom', clickZoom);
+      var tapDragZoom = new _tap_drag_zoom.default();
+      this.add('tapDragZoom', tapDragZoom);
+      var touchPitch = map.touchPitch = new _touch.TouchPitchHandler();
+      this.add('touchPitch', touchPitch);
+      var mouseRotate = new _mouse.MouseRotateHandler(options);
+      var mousePitch = new _mouse.MousePitchHandler(options);
+      map.dragRotate = new _drag_rotate.default(options, mouseRotate, mousePitch);
+      this.add('mouseRotate', mouseRotate, ['mousePitch']);
+      this.add('mousePitch', mousePitch, ['mouseRotate']);
+      var mousePan = new _mouse.MousePanHandler(options);
+      var touchPan = new _touch.TouchPanHandler(options);
+      map.dragPan = new _drag_pan.default(el, mousePan, touchPan);
+      this.add('mousePan', mousePan);
+      this.add('touchPan', touchPan, ['touchZoom', 'touchRotate']);
+      var touchRotate = new _touch.TouchRotateHandler();
+      var touchZoom = new _touch.TouchZoomHandler();
+      map.touchZoomRotate = new _touch_zoom_rotate.default(el, touchZoom, touchRotate, tapDragZoom);
+      this.add('touchRotate', touchRotate, ['touchPan', 'touchZoom']);
+      this.add('touchZoom', touchZoom, ['touchPan', 'touchRotate']);
+      var scrollZoom = map.scrollZoom = new _scroll_zoom.default(map, this);
+      this.add('scrollZoom', scrollZoom, ['mousePan']);
+      var keyboard = map.keyboard = new _keyboard.default();
+      this.add('keyboard', keyboard);
+      this.add('blockableMapEvent', new _blockable_map_event.default(map));
+
+      for (var _i = 0, _arr = ['boxZoom', 'doubleClickZoom', 'tapDragZoom', 'touchPitch', 'dragRotate', 'dragPan', 'touchZoomRotate', 'scrollZoom', 'keyboard']; _i < _arr.length; _i++) {
+        var name = _arr[_i];
+
+        // @ts-ignore
+        if (options.interactive && options[name]) {
+          // @ts-ignore
+          map[name].enable(options[name]);
+        }
+      }
     }
-  }
-  triggerRenderFrame() {
-    if (this.frameId === void 0) {
-      this.frameId = this.map.requestRenderFrame((timeStamp) => {
-        delete this.frameId;
-        this.handleEvent(new import_render_event.default("renderFrame", { timeStamp }));
-        this.applyChanges();
+  }, {
+    key: "add",
+    value: function add(handlerName, handler, allowed) {
+      this.handlers.push({
+        handlerName: handlerName,
+        handler: handler,
+        allowed: allowed
       });
+      this.handlersById[handlerName] = handler;
     }
-  }
-  addDefaultHandlers(options) {
-    const map = this.map;
-    const el = map.getCanvasContainer();
-    this.add("mapEvent", new import_map_event.default(map, options));
-    const boxZoom = map.boxZoom = new import_box_zoom.default(map, options);
-    this.add("boxZoom", boxZoom);
-    const tapZoom = new import_tap_zoom.default();
-    const clickZoom = new import_click_zoom.default();
-    map.doubleClickZoom = new import_dblclick_zoom.default(clickZoom, tapZoom);
-    this.add("tapZoom", tapZoom);
-    this.add("clickZoom", clickZoom);
-    const tapDragZoom = new import_tap_drag_zoom.default();
-    this.add("tapDragZoom", tapDragZoom);
-    const touchPitch = map.touchPitch = new import_touch.TouchPitchHandler();
-    this.add("touchPitch", touchPitch);
-    const mouseRotate = new import_mouse.MouseRotateHandler(options);
-    const mousePitch = new import_mouse.MousePitchHandler(options);
-    map.dragRotate = new import_drag_rotate.default(options, mouseRotate, mousePitch);
-    this.add("mouseRotate", mouseRotate, ["mousePitch"]);
-    this.add("mousePitch", mousePitch, ["mouseRotate"]);
-    const mousePan = new import_mouse.MousePanHandler(options);
-    const touchPan = new import_touch.TouchPanHandler(options);
-    map.dragPan = new import_drag_pan.default(el, mousePan, touchPan);
-    this.add("mousePan", mousePan);
-    this.add("touchPan", touchPan, ["touchZoom", "touchRotate"]);
-    const touchRotate = new import_touch.TouchRotateHandler();
-    const touchZoom = new import_touch.TouchZoomHandler();
-    map.touchZoomRotate = new import_touch_zoom_rotate.default(el, touchZoom, touchRotate, tapDragZoom);
-    this.add("touchRotate", touchRotate, ["touchPan", "touchZoom"]);
-    this.add("touchZoom", touchZoom, ["touchPan", "touchRotate"]);
-    const scrollZoom = map.scrollZoom = new import_scroll_zoom.default(map, this);
-    this.add("scrollZoom", scrollZoom, ["mousePan"]);
-    const keyboard = map.keyboard = new import_keyboard.default();
-    this.add("keyboard", keyboard);
-    this.add("blockableMapEvent", new import_blockable_map_event.default(map));
-    for (const name of [
-      "boxZoom",
-      "doubleClickZoom",
-      "tapDragZoom",
-      "touchPitch",
-      "dragRotate",
-      "dragPan",
-      "touchZoomRotate",
-      "scrollZoom",
-      "keyboard"
-    ]) {
-      if (options.interactive && options[name]) {
-        map[name].enable(options[name]);
+  }, {
+    key: "blockedByActive",
+    value: function blockedByActive(activeHandlers, allowed, myName) {
+      for (var name in activeHandlers) {
+        if (name === myName) {
+          continue;
+        }
+
+        if (!allowed || allowed.indexOf(name) < 0) {
+          return true;
+        }
       }
+
+      return false;
     }
-  }
-  add(handlerName, handler, allowed) {
-    this.handlers.push({ handlerName, handler, allowed });
-    this.handlersById[handlerName] = handler;
-  }
-  blockedByActive(activeHandlers, allowed, myName) {
-    for (const name in activeHandlers) {
-      if (name === myName) {
-        continue;
-      }
-      if (!allowed || allowed.indexOf(name) < 0) {
-        return true;
+  }, {
+    key: "getMapTouches",
+    value: function getMapTouches(touches) {
+      var mapTouches = [];
+
+      var _iterator6 = _createForOfIteratorHelper(touches),
+          _step6;
+
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var t = _step6.value;
+          var target = t.target;
+
+          if (_l7Utils.isMini || this.el.contains(target)) {
+            mapTouches.push(t);
+          }
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
       }
+
+      return mapTouches;
     }
-    return false;
-  }
-  getMapTouches(touches) {
-    const mapTouches = [];
-    for (const t of touches) {
-      const target = t.target;
-      if (import_l7_utils.isMini || this.el.contains(target)) {
-        mapTouches.push(t);
+  }, {
+    key: "applyChanges",
+    value: function applyChanges() {
+      var combined = {};
+      var combinedEventsInProgress = {};
+      var combinedDeactivatedHandlers = {};
+
+      var _iterator7 = _createForOfIteratorHelper(this.changes),
+          _step7;
+
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var _step7$value = (0, _slicedToArray2.default)(_step7.value, 3),
+              change = _step7$value[0],
+              eventsInProgress = _step7$value[1],
+              deactivatedHandlers = _step7$value[2];
+
+          if (change.panDelta) {
+            combined.panDelta = (combined.panDelta || new _point.default(0, 0))._add(change.panDelta);
+          }
+
+          if (change.zoomDelta) {
+            combined.zoomDelta = (combined.zoomDelta || 0) + change.zoomDelta;
+          }
+
+          if (change.bearingDelta) {
+            combined.bearingDelta = (combined.bearingDelta || 0) + change.bearingDelta;
+          }
+
+          if (change.pitchDelta) {
+            combined.pitchDelta = (combined.pitchDelta || 0) + change.pitchDelta;
+          }
+
+          if (change.around !== undefined) {
+            combined.around = change.around;
+          }
+
+          if (change.pinchAround !== undefined) {
+            combined.pinchAround = change.pinchAround;
+          }
+
+          if (change.noInertia) {
+            combined.noInertia = change.noInertia;
+          }
+
+          (0, _lodash.merge)(combinedEventsInProgress, eventsInProgress);
+          (0, _lodash.merge)(combinedDeactivatedHandlers, deactivatedHandlers);
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
       }
+
+      this.updateMapTransform(combined, combinedEventsInProgress, combinedDeactivatedHandlers);
+      this.changes = [];
     }
-    return mapTouches;
-  }
-  applyChanges() {
-    const combined = {};
-    const combinedEventsInProgress = {};
-    const combinedDeactivatedHandlers = {};
-    for (const [change, eventsInProgress, deactivatedHandlers] of this.changes) {
-      if (change.panDelta) {
-        combined.panDelta = (combined.panDelta || new import_point.default(0, 0))._add(change.panDelta);
-      }
-      if (change.zoomDelta) {
-        combined.zoomDelta = (combined.zoomDelta || 0) + change.zoomDelta;
-      }
-      if (change.bearingDelta) {
-        combined.bearingDelta = (combined.bearingDelta || 0) + change.bearingDelta;
+  }, {
+    key: "updateMapTransform",
+    value: function updateMapTransform(combinedResult, combinedEventsInProgress, deactivatedHandlers) {
+      var map = this.map;
+      var tr = map.transform;
+
+      if (!hasChange(combinedResult)) {
+        return this.fireEvents(combinedEventsInProgress, deactivatedHandlers);
       }
-      if (change.pitchDelta) {
-        combined.pitchDelta = (combined.pitchDelta || 0) + change.pitchDelta;
+
+      var panDelta = combinedResult.panDelta,
+          zoomDelta = combinedResult.zoomDelta,
+          bearingDelta = combinedResult.bearingDelta,
+          pitchDelta = combinedResult.pitchDelta,
+          pinchAround = combinedResult.pinchAround;
+      var around = combinedResult.around;
+
+      if (pinchAround !== undefined) {
+        around = pinchAround;
+      } // stop any ongoing camera animations (easeTo, flyTo)
+
+
+      map.stop(true);
+      around = around || map.transform.centerPoint;
+      var loc = tr.pointLocation(panDelta ? around.sub(panDelta) : around);
+
+      if (bearingDelta && this.rotateEnabled) {
+        tr.bearing += bearingDelta;
       }
-      if (change.around !== void 0) {
-        combined.around = change.around;
+
+      if (pitchDelta && this.pitchEnabled) {
+        tr.pitch += pitchDelta;
       }
-      if (change.pinchAround !== void 0) {
-        combined.pinchAround = change.pinchAround;
+
+      if (zoomDelta) {
+        tr.zoom += zoomDelta;
       }
-      if (change.noInertia) {
-        combined.noInertia = change.noInertia;
+
+      tr.setLocationAtPoint(loc, around);
+      this.map.update();
+
+      if (!combinedResult.noInertia) {
+        this.inertia.record(combinedResult);
       }
-      (0, import_lodash.merge)(combinedEventsInProgress, eventsInProgress);
-      (0, import_lodash.merge)(combinedDeactivatedHandlers, deactivatedHandlers);
-    }
-    this.updateMapTransform(combined, combinedEventsInProgress, combinedDeactivatedHandlers);
-    this.changes = [];
-  }
-  updateMapTransform(combinedResult, combinedEventsInProgress, deactivatedHandlers) {
-    const map = this.map;
-    const tr = map.transform;
-    if (!hasChange(combinedResult)) {
-      return this.fireEvents(combinedEventsInProgress, deactivatedHandlers);
-    }
-    const {
-      panDelta,
-      zoomDelta,
-      bearingDelta,
-      pitchDelta,
-      pinchAround
-    } = combinedResult;
-    let { around } = combinedResult;
-    if (pinchAround !== void 0) {
-      around = pinchAround;
-    }
-    map.stop(true);
-    around = around || map.transform.centerPoint;
-    const loc = tr.pointLocation(panDelta ? around.sub(panDelta) : around);
-    if (bearingDelta && this.rotateEnabled) {
-      tr.bearing += bearingDelta;
-    }
-    if (pitchDelta && this.pitchEnabled) {
-      tr.pitch += pitchDelta;
-    }
-    if (zoomDelta) {
-      tr.zoom += zoomDelta;
-    }
-    tr.setLocationAtPoint(loc, around);
-    this.map.update();
-    if (!combinedResult.noInertia) {
-      this.inertia.record(combinedResult);
+
+      this.fireEvents(combinedEventsInProgress, deactivatedHandlers);
     }
-    this.fireEvents(combinedEventsInProgress, deactivatedHandlers);
-  }
-  fireEvents(newEventsInProgress, deactivatedHandlers) {
-    const wasMoving = isMoving(this.eventsInProgress);
-    const nowMoving = isMoving(newEventsInProgress);
-    const startEvents = {};
-    for (const eventName in newEventsInProgress) {
-      if (newEventsInProgress[eventName]) {
-        const { originalEvent } = newEventsInProgress[eventName];
-        if (!this.eventsInProgress[eventName]) {
-          startEvents[`${eventName}start`] = originalEvent;
+  }, {
+    key: "fireEvents",
+    value: function fireEvents(newEventsInProgress, deactivatedHandlers) {
+      var _this3 = this;
+
+      var wasMoving = _isMoving(this.eventsInProgress);
+
+      var nowMoving = _isMoving(newEventsInProgress);
+
+      var startEvents = {};
+
+      for (var eventName in newEventsInProgress) {
+        if (newEventsInProgress[eventName]) {
+          var originalEvent = newEventsInProgress[eventName].originalEvent;
+
+          if (!this.eventsInProgress[eventName]) {
+            startEvents["".concat(eventName, "start")] = originalEvent;
+          }
+
+          this.eventsInProgress[eventName] = newEventsInProgress[eventName];
         }
-        this.eventsInProgress[eventName] = newEventsInProgress[eventName];
+      } // fire start events only after this.eventsInProgress has been updated
+
+
+      if (!wasMoving && nowMoving) {
+        this.fireEvent('movestart', nowMoving.originalEvent);
       }
-    }
-    if (!wasMoving && nowMoving) {
-      this.fireEvent("movestart", nowMoving.originalEvent);
-    }
-    for (const name in startEvents) {
-      if (startEvents[name]) {
-        this.fireEvent(name, startEvents[name]);
+
+      for (var name in startEvents) {
+        if (startEvents[name]) {
+          this.fireEvent(name, startEvents[name]);
+        }
       }
-    }
-    if (newEventsInProgress.rotate) {
-      this.bearingChanged = true;
-    }
-    if (nowMoving) {
-      this.fireEvent("move", nowMoving.originalEvent);
-    }
-    for (const eventName in newEventsInProgress) {
-      if (newEventsInProgress[eventName]) {
-        const { originalEvent } = newEventsInProgress[eventName];
-        this.fireEvent(eventName, originalEvent);
+
+      if (newEventsInProgress.rotate) {
+        this.bearingChanged = true;
       }
-    }
-    const endEvents = {};
-    let originalEndEvent;
-    for (const eventName in this.eventsInProgress) {
-      if (this.eventsInProgress[eventName]) {
-        const { handlerName, originalEvent } = this.eventsInProgress[eventName];
-        if (!this.handlersById[handlerName].isActive()) {
-          delete this.eventsInProgress[eventName];
-          originalEndEvent = deactivatedHandlers[handlerName] || originalEvent;
-          endEvents[`${eventName}end`] = originalEndEvent;
+
+      if (nowMoving) {
+        this.fireEvent('move', nowMoving.originalEvent);
+      }
+
+      for (var _eventName in newEventsInProgress) {
+        if (newEventsInProgress[_eventName]) {
+          var _originalEvent = newEventsInProgress[_eventName].originalEvent;
+          this.fireEvent(_eventName, _originalEvent);
         }
       }
-    }
-    for (const name in endEvents) {
-      if (endEvents[name]) {
-        this.fireEvent(name, endEvents[name]);
+
+      var endEvents = {};
+      var originalEndEvent;
+
+      for (var _eventName2 in this.eventsInProgress) {
+        if (this.eventsInProgress[_eventName2]) {
+          var _this$eventsInProgres = this.eventsInProgress[_eventName2],
+              handlerName = _this$eventsInProgres.handlerName,
+              _originalEvent2 = _this$eventsInProgres.originalEvent;
+
+          if (!this.handlersById[handlerName].isActive()) {
+            delete this.eventsInProgress[_eventName2];
+            originalEndEvent = deactivatedHandlers[handlerName] || _originalEvent2;
+            endEvents["".concat(_eventName2, "end")] = originalEndEvent;
+          }
+        }
       }
-    }
-    const stillMoving = isMoving(this.eventsInProgress);
-    if ((wasMoving || nowMoving) && !stillMoving) {
-      this.updatingCamera = true;
-      const inertialEase = this.inertia.onMoveEnd(this.map.dragPan.inertiaOptions);
-      const shouldSnapToNorth = (bearing) => bearing !== 0 && -this.bearingSnap < bearing && bearing < this.bearingSnap;
-      if (inertialEase) {
-        if (shouldSnapToNorth(inertialEase.bearing || this.map.getBearing())) {
-          inertialEase.bearing = 0;
+
+      for (var _name in endEvents) {
+        if (endEvents[_name]) {
+          this.fireEvent(_name, endEvents[_name]);
         }
-        this.map.easeTo(inertialEase, { originalEvent: originalEndEvent });
-      } else {
-        this.map.emit("moveend", new import_event.Event("moveend", { originalEvent: originalEndEvent }));
-        if (shouldSnapToNorth(this.map.getBearing())) {
-          this.map.resetNorth();
+      }
+
+      var stillMoving = _isMoving(this.eventsInProgress);
+
+      if ((wasMoving || nowMoving) && !stillMoving) {
+        this.updatingCamera = true;
+        var inertialEase = this.inertia.onMoveEnd(this.map.dragPan.inertiaOptions);
+
+        var shouldSnapToNorth = function shouldSnapToNorth(bearing) {
+          return bearing !== 0 && -_this3.bearingSnap < bearing && bearing < _this3.bearingSnap;
+        };
+
+        if (inertialEase) {
+          if (shouldSnapToNorth(inertialEase.bearing || this.map.getBearing())) {
+            inertialEase.bearing = 0;
+          }
+
+          this.map.easeTo(inertialEase, {
+            originalEvent: originalEndEvent
+          });
+        } else {
+          this.map.emit('moveend', new _event.Event('moveend', {
+            originalEvent: originalEndEvent
+          }));
+
+          if (shouldSnapToNorth(this.map.getBearing())) {
+            this.map.resetNorth();
+          }
         }
+
+        this.bearingChanged = false;
+        this.updatingCamera = false;
       }
-      this.bearingChanged = false;
-      this.updatingCamera = false;
     }
-  }
-  fireEvent(type, e) {
-    this.map.emit(type, new import_event.Event(type, e ? { originalEvent: e } : {}));
-  }
-};
-var handler_manager_default = HandlerManager;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+  }, {
+    key: "fireEvent",
+    value: function fireEvent(type, e) {
+      this.map.emit(type, new _event.Event(type, e ? {
+        originalEvent: e
+      } : {}));
+    }
+  }]);
+  return HandlerManager;
+}();
+
+var _default = HandlerManager;
+exports.default = _default;