@antv/l7-map 2.21.0 → 2.21.2

package/es/handler/handler_manager.js

@@ -1,10 +1,4 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-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; }
 // @ts-ignore
 // tslint:disable-next-line: no-submodule-imports
 import { lodashUtil } from '@antv/l7-utils';
@@ -27,100 +21,107 @@ import TouchZoomRotateHandler from "./shim/touch_zoom_rotate";
 import TapDragZoomHandler from "./tap/tap_drag_zoom";
 import TapZoomHandler from "./tap/tap_zoom";
 import { TouchPanHandler, TouchPitchHandler, TouchRotateHandler, TouchZoomHandler } from "./touch";
-var merge = lodashUtil.merge;
-var _isMoving = function isMoving(p) {
-  return p.zoom || p.drag || p.pitch || p.rotate;
-};
+const {
+  merge
+} = lodashUtil;
+const isMoving = p => 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 = /*#__PURE__*/function () {
-  function HandlerManager(map, options) {
-    var _this = this;
-    _classCallCheck(this, HandlerManager);
-    _defineProperty(this, "handleWindowEvent", function (e) {
-      _this.handleEvent(e, "".concat(e.type, "Window"));
+class HandlerManager {
+  constructor(map, options) {
+    _defineProperty(this, "map", void 0);
+    _defineProperty(this, "el", void 0);
+    _defineProperty(this, "handlers", void 0);
+    _defineProperty(this, "eventsInProgress", void 0);
+    _defineProperty(this, "frameId", void 0);
+    _defineProperty(this, "inertia", void 0);
+    _defineProperty(this, "bearingSnap", void 0);
+    _defineProperty(this, "handlersById", void 0);
+    _defineProperty(this, "updatingCamera", void 0);
+    _defineProperty(this, "changes", void 0);
+    _defineProperty(this, "previousActiveHandlers", void 0);
+    _defineProperty(this, "bearingChanged", void 0);
+    _defineProperty(this, "rotateEnabled", void 0);
+    _defineProperty(this, "pitchEnabled", void 0);
+    _defineProperty(this, "listeners", void 0);
+    _defineProperty(this, "handleWindowEvent", e => {
+      this.handleEvent(e, `${e.type}Window`);
     });
-    _defineProperty(this, "handleEvent", function (e, eventName) {
+    _defineProperty(this, "handleEvent", (e, eventName) => {
       if (e.type === 'blur') {
-        _this.stop();
+        this.stop();
         return;
       }
-      _this.updatingCamera = true;
-      var inputEvent = e.type === 'renderFrame' ? undefined : e;
+      this.updatingCamera = true;
+      const 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 = {
+      const mergedIHandlerResult = {
         needsRenderFrame: false
       };
-      var eventsInProgress = {};
-      var activeHandlers = {};
+      const eventsInProgress = {};
+      const activeHandlers = {};
       // @ts-ignore
-      var mapTouches = e.touches ?
+      const mapTouches = e.touches ?
       // @ts-ignore
-      _this.getMapTouches(e.touches) : undefined;
-      var points = mapTouches ? DOM.touchPos(_this.el, mapTouches) : DOM.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;
+      this.getMapTouches(e.touches) : undefined;
+      const points = mapTouches ? DOM.touchPos(this.el, mapTouches) : DOM.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;
+          // @ts-ignore
+          if (handler && handler[handerName]) {
             // @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();
-              }
+            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;
-          }
         }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
+        // @ts-ignore
+        if (data || handler.isActive()) {
+          activeHandlers[handlerName] = handler;
+        }
       }
-      var deactivatedHandlers = {};
-      for (var name in _this.previousActiveHandlers) {
+      const deactivatedHandlers = {};
+      for (const 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;
-      var cameraAnimation = mergedIHandlerResult.cameraAnimation;
+      this.updatingCamera = false;
+      const {
+        cameraAnimation
+      } = mergedIHandlerResult;
       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;
@@ -137,7 +138,7 @@ var HandlerManager = /*#__PURE__*/function () {
     // Track whether map is currently moving, to compute start/move/end events
     this.eventsInProgress = {};
     this.addDefaultHandlers(options);
-    var el = this.el;
+    const el = this.el;
     this.listeners = [];
     // l7 - mini
     this.listeners = [
@@ -168,410 +169,321 @@ var HandlerManager = /*#__PURE__*/function () {
     }], [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 = _slicedToArray(_step2.value, 3),
-          target = _step2$value[0],
-          type = _step2$value[1],
-          listenerOptions = _step2$value[2];
-        // @ts-ignore
-        DOM.addEventListener(target, type,
-        // @ts-ignore
-        target === window.document ? this.handleWindowEvent : this.handleEvent, listenerOptions);
-      }
-    } catch (err) {
-      _iterator2.e(err);
-    } finally {
-      _iterator2.f();
+    for (const [target, type, listenerOptions] of this.listeners) {
+      // @ts-ignore
+      DOM.addEventListener(target, type,
+      // @ts-ignore
+      target === window.document ? this.handleWindowEvent : this.handleEvent, listenerOptions);
     }
   }
-  _createClass(HandlerManager, [{
-    key: "destroy",
-    value: function destroy() {
-      var _iterator3 = _createForOfIteratorHelper(this.listeners),
-        _step3;
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var _step3$value = _slicedToArray(_step3.value, 3),
-            target = _step3$value[0],
-            type = _step3$value[1],
-            listenerOptions = _step3$value[2];
-          // @ts-ignore
-          DOM.removeEventListener(target, type,
-          // @ts-ignore
-          target === window.document ? this.handleWindowEvent : this.handleEvent, listenerOptions);
-        }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
-      }
+  destroy() {
+    for (const [target, type, listenerOptions] of this.listeners) {
+      // @ts-ignore
+      DOM.removeEventListener(target, type,
+      // @ts-ignore
+      target === window.document ? this.handleWindowEvent : this.handleEvent, listenerOptions);
     }
-  }, {
-    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 = [];
+  }
+  stop() {
+    // do nothing if this method was triggered by a gesture update
+    if (this.updatingCamera) {
+      return;
     }
-  }, {
-    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();
+    for (const {
+      handler
+    } of this.handlers) {
+      handler.reset();
+    }
+    this.inertia.clear();
+    this.fireEvents({}, {});
+    this.changes = [];
+  }
+  isActive() {
+    for (const {
+      handler
+    } of this.handlers) {
+      if (handler.isActive()) {
+        return true;
       }
-      return false;
     }
-  }, {
-    key: "isZooming",
-    value: function isZooming() {
-      return !!this.eventsInProgress.zoom || this.map.scrollZoom.isZooming();
+    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: "isRotating",
-    value: function isRotating() {
-      return !!this.eventsInProgress.rotate;
+    merge(mergedIHandlerResult, HandlerResult);
+    const eventData = {
+      handlerName: name,
+      originalEvent: HandlerResult.originalEvent || e
+    };
+
+    // track which handler changed which camera property
+    if (HandlerResult.zoomDelta !== undefined) {
+      eventsInProgress.zoom = eventData;
     }
-  }, {
-    key: "isMoving",
-    value: function isMoving() {
-      return Boolean(_isMoving(this.eventsInProgress)) || this.isZooming();
+    if (HandlerResult.panDelta !== undefined) {
+      eventsInProgress.drag = eventData;
     }
-  }, {
-    key: "mergeIHandlerResult",
-    value: function mergeIHandlerResult(mergedIHandlerResult, eventsInProgress, HandlerResult, name, e) {
-      if (!HandlerResult) {
-        return;
-      }
-      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 !== undefined) {
+      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 RenderFrameEvent('renderFrame', {
-            timeStamp: timeStamp
-          }));
-          _this2.applyChanges();
-        });
-      }
+    if (HandlerResult.bearingDelta !== undefined) {
+      eventsInProgress.rotate = eventData;
     }
-  }, {
-    key: "addDefaultHandlers",
-    value: function addDefaultHandlers(options) {
-      var map = this.map;
-      var el = map.getCanvasContainer();
-      this.add('mapEvent', new MapEventHandler(map, options));
-      var boxZoom = map.boxZoom = new BoxZoomHandler(map, options);
-      this.add('boxZoom', boxZoom);
-      var tapZoom = new TapZoomHandler();
-      var clickZoom = new ClickZoomHandler();
-      map.doubleClickZoom = new DoubleClickZoomHandler(clickZoom, tapZoom);
-      this.add('tapZoom', tapZoom);
-      this.add('clickZoom', clickZoom);
-      var tapDragZoom = new TapDragZoomHandler();
-      this.add('tapDragZoom', tapDragZoom);
-      var touchPitch = map.touchPitch = new TouchPitchHandler();
-      this.add('touchPitch', touchPitch);
-      var mouseRotate = new MouseRotateHandler(options);
-      var mousePitch = new MousePitchHandler(options);
-      map.dragRotate = new DragRotateHandler(options, mouseRotate, mousePitch);
-      this.add('mouseRotate', mouseRotate, ['mousePitch']);
-      this.add('mousePitch', mousePitch, ['mouseRotate']);
-      var mousePan = new MousePanHandler(options);
-      var touchPan = new TouchPanHandler(options);
-      map.dragPan = new DragPanHandler(el, mousePan, touchPan);
-      this.add('mousePan', mousePan);
-      this.add('touchPan', touchPan, ['touchZoom', 'touchRotate']);
-      var touchRotate = new TouchRotateHandler();
-      var touchZoom = new TouchZoomHandler();
-      map.touchZoomRotate = new TouchZoomRotateHandler(el, touchZoom, touchRotate, tapDragZoom);
-      this.add('touchRotate', touchRotate, ['touchPan', 'touchZoom']);
-      this.add('touchZoom', touchZoom, ['touchPan', 'touchRotate']);
-      var scrollZoom = map.scrollZoom = new ScrollZoomHandler(map, this);
-      this.add('scrollZoom', scrollZoom, ['mousePan']);
-      var keyboard = map.keyboard = new KeyboardHandler();
-      this.add('keyboard', keyboard);
-      this.add('blockableMapEvent', new BlockableMapEventHandler(map));
-      for (var _i = 0, _arr = ['boxZoom', 'doubleClickZoom', 'tapDragZoom', 'touchPitch', 'dragRotate', 'dragPan', 'touchZoomRotate', 'scrollZoom', 'keyboard']; _i < _arr.length; _i++) {
-        var name = _arr[_i];
+  }
+  triggerRenderFrame() {
+    if (this.frameId === undefined) {
+      this.frameId = this.map.requestRenderFrame(timeStamp => {
         // @ts-ignore
-        if (options.interactive && options[name]) {
-          // @ts-ignore
-          map[name].enable(options[name]);
-        }
-      }
-    }
-  }, {
-    key: "add",
-    value: function add(handlerName, handler, allowed) {
-      this.handlers.push({
-        handlerName: handlerName,
-        handler: handler,
-        allowed: allowed
+        delete this.frameId;
+        this.handleEvent(new RenderFrameEvent('renderFrame', {
+          timeStamp
+        }));
+        this.applyChanges();
       });
-      this.handlersById[handlerName] = handler;
     }
-  }, {
-    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;
-        }
+  }
+  addDefaultHandlers(options) {
+    const map = this.map;
+    const el = map.getCanvasContainer();
+    this.add('mapEvent', new MapEventHandler(map, options));
+    const boxZoom = map.boxZoom = new BoxZoomHandler(map, options);
+    this.add('boxZoom', boxZoom);
+    const tapZoom = new TapZoomHandler();
+    const clickZoom = new ClickZoomHandler();
+    map.doubleClickZoom = new DoubleClickZoomHandler(clickZoom, tapZoom);
+    this.add('tapZoom', tapZoom);
+    this.add('clickZoom', clickZoom);
+    const tapDragZoom = new TapDragZoomHandler();
+    this.add('tapDragZoom', tapDragZoom);
+    const touchPitch = map.touchPitch = new TouchPitchHandler();
+    this.add('touchPitch', touchPitch);
+    const mouseRotate = new MouseRotateHandler(options);
+    const mousePitch = new MousePitchHandler(options);
+    map.dragRotate = new DragRotateHandler(options, mouseRotate, mousePitch);
+    this.add('mouseRotate', mouseRotate, ['mousePitch']);
+    this.add('mousePitch', mousePitch, ['mouseRotate']);
+    const mousePan = new MousePanHandler(options);
+    const touchPan = new TouchPanHandler(options);
+    map.dragPan = new DragPanHandler(el, mousePan, touchPan);
+    this.add('mousePan', mousePan);
+    this.add('touchPan', touchPan, ['touchZoom', 'touchRotate']);
+    const touchRotate = new TouchRotateHandler();
+    const touchZoom = new TouchZoomHandler();
+    map.touchZoomRotate = new TouchZoomRotateHandler(el, touchZoom, touchRotate, tapDragZoom);
+    this.add('touchRotate', touchRotate, ['touchPan', 'touchZoom']);
+    this.add('touchZoom', touchZoom, ['touchPan', 'touchRotate']);
+    const scrollZoom = map.scrollZoom = new ScrollZoomHandler(map, this);
+    this.add('scrollZoom', scrollZoom, ['mousePan']);
+    const keyboard = map.keyboard = new KeyboardHandler();
+    this.add('keyboard', keyboard);
+    this.add('blockableMapEvent', new BlockableMapEventHandler(map));
+    for (const name of ['boxZoom', 'doubleClickZoom', 'tapDragZoom', 'touchPitch', 'dragRotate', 'dragPan', 'touchZoomRotate', 'scrollZoom', 'keyboard']) {
+      // @ts-ignore
+      if (options.interactive && options[name]) {
+        // @ts-ignore
+        map[name].enable(options[name]);
       }
-      return false;
     }
-  }, {
-    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 (this.el.contains(target)) {
-            mapTouches.push(t);
-          }
-        }
-      } catch (err) {
-        _iterator6.e(err);
-      } finally {
-        _iterator6.f();
+  }
+  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;
       }
-      return mapTouches;
     }
-  }, {
-    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 = _slicedToArray(_step7.value, 3),
-            change = _step7$value[0],
-            eventsInProgress = _step7$value[1],
-            deactivatedHandlers = _step7$value[2];
-          if (change.panDelta) {
-            combined.panDelta = (combined.panDelta || new Point(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;
-          }
-          merge(combinedEventsInProgress, eventsInProgress);
-          merge(combinedDeactivatedHandlers, deactivatedHandlers);
-        }
-      } catch (err) {
-        _iterator7.e(err);
-      } finally {
-        _iterator7.f();
+    return false;
+  }
+  getMapTouches(touches) {
+    const mapTouches = [];
+    for (const t of touches) {
+      const target = t.target;
+      if (this.el.contains(target)) {
+        mapTouches.push(t);
       }
-      this.updateMapTransform(combined, combinedEventsInProgress, combinedDeactivatedHandlers);
-      this.changes = [];
     }
-  }, {
-    key: "updateMapTransform",
-    value: function updateMapTransform(combinedResult, combinedEventsInProgress, deactivatedHandlers) {
-      var map = this.map;
-      var tr = map.transform;
-      if (!hasChange(combinedResult)) {
-        return this.fireEvents(combinedEventsInProgress, deactivatedHandlers);
+    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 Point(0, 0))._add(change.panDelta);
       }
-      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;
+      if (change.zoomDelta) {
+        combined.zoomDelta = (combined.zoomDelta || 0) + change.zoomDelta;
       }
-
-      // 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.bearingDelta) {
+        combined.bearingDelta = (combined.bearingDelta || 0) + change.bearingDelta;
       }
-      if (pitchDelta && this.pitchEnabled) {
-        tr.pitch += pitchDelta;
+      if (change.pitchDelta) {
+        combined.pitchDelta = (combined.pitchDelta || 0) + change.pitchDelta;
       }
-      if (zoomDelta) {
-        tr.zoom += zoomDelta;
+      if (change.around !== undefined) {
+        combined.around = change.around;
       }
-      tr.setLocationAtPoint(loc, around);
-      this.map.update();
-      if (!combinedResult.noInertia) {
-        this.inertia.record(combinedResult);
+      if (change.pinchAround !== undefined) {
+        combined.pinchAround = change.pinchAround;
       }
-      this.fireEvents(combinedEventsInProgress, deactivatedHandlers);
-    }
-  }, {
-    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];
-        }
+      if (change.noInertia) {
+        combined.noInertia = change.noInertia;
       }
+      merge(combinedEventsInProgress, eventsInProgress);
+      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 !== undefined) {
+      around = pinchAround;
+    }
 
-      // fire start events only after this.eventsInProgress has been updated
-      if (!wasMoving && nowMoving) {
-        this.fireEvent('movestart', nowMoving.originalEvent);
-      }
-      for (var name in startEvents) {
-        if (startEvents[name]) {
-          this.fireEvent(name, startEvents[name]);
+    // stop any ongoing camera animations (easeTo, flyTo)
+    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);
+  }
+  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;
         }
+        this.eventsInProgress[eventName] = newEventsInProgress[eventName];
       }
-      if (newEventsInProgress.rotate) {
-        this.bearingChanged = true;
+    }
+
+    // fire start events only after this.eventsInProgress has been updated
+    if (!wasMoving && nowMoving) {
+      this.fireEvent('movestart', nowMoving.originalEvent);
+    }
+    for (const name in startEvents) {
+      if (startEvents[name]) {
+        this.fireEvent(name, startEvents[name]);
       }
-      if (nowMoving) {
-        this.fireEvent('move', nowMoving.originalEvent);
+    }
+    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);
       }
-      for (var _eventName in newEventsInProgress) {
-        if (newEventsInProgress[_eventName]) {
-          var _originalEvent = newEventsInProgress[_eventName].originalEvent;
-          this.fireEvent(_eventName, _originalEvent);
+    }
+    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;
         }
       }
-      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;
-          }
-        }
+    }
+    for (const name in endEvents) {
+      if (endEvents[name]) {
+        this.fireEvent(name, endEvents[name]);
       }
-      for (var _name in endEvents) {
-        if (endEvents[_name]) {
-          this.fireEvent(_name, endEvents[_name]);
+    }
+    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;
         }
-      }
-      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('moveend', {
-            originalEvent: originalEndEvent
-          }));
-          if (shouldSnapToNorth(this.map.getBearing())) {
-            this.map.resetNorth();
-          }
+        this.map.easeTo(inertialEase, {
+          originalEvent: originalEndEvent
+        });
+      } else {
+        this.map.emit('moveend', new Event('moveend', {
+          originalEvent: originalEndEvent
+        }));
+        if (shouldSnapToNorth(this.map.getBearing())) {
+          this.map.resetNorth();
         }
-        this.bearingChanged = false;
-        this.updatingCamera = false;
       }
+      this.bearingChanged = false;
+      this.updatingCamera = false;
     }
-  }, {
-    key: "fireEvent",
-    value: function fireEvent(type, e) {
-      this.map.emit(type, new Event(type, e ? {
-        originalEvent: e
-      } : {}));
-    }
-  }]);
-  return HandlerManager;
-}();
+  }
+  fireEvent(type, e) {
+    this.map.emit(type, new Event(type, e ? {
+      originalEvent: e
+    } : {}));
+  }
+}
 export default HandlerManager;