@antv/l7-map 2.25.7 → 2.25.9

package/es/map/handler_manager.js

@@ -0,0 +1,466 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import Point from '@mapbox/point-geometry';
+import { BoxZoomHandler } from "./handler/box_zoom";
+import { ClickZoomHandler } from "./handler/click_zoom";
+import { CooperativeGesturesHandler } from "./handler/cooperative_gestures";
+import { KeyboardHandler } from "./handler/keyboard";
+import { BlockableMapEventHandler, MapEventHandler } from "./handler/map_event";
+import { generateMousePanHandler, generateMousePitchHandler, generateMouseRotationHandler } from "./handler/mouse";
+import { ScrollZoomHandler } from "./handler/scroll_zoom";
+import { DoubleClickZoomHandler } from "./handler/shim/dblclick_zoom";
+import { DragPanHandler } from "./handler/shim/drag_pan";
+import { DragRotateHandler } from "./handler/shim/drag_rotate";
+import { TwoFingersTouchZoomRotateHandler } from "./handler/shim/two_fingers_touch";
+import { TapDragZoomHandler } from "./handler/tap_drag_zoom";
+import { TapZoomHandler } from "./handler/tap_zoom";
+import { TouchPanHandler } from "./handler/touch_pan";
+import { TwoFingersTouchPitchHandler, TwoFingersTouchRotateHandler, TwoFingersTouchZoomHandler } from "./handler/two_fingers_touch";
+import { HandlerInertia } from "./handler_inertia";
+import { browser } from "./util/browser";
+import { DOM } from "./util/dom";
+import { Event } from "./util/evented";
+import { extend } from "./util/util";
+const isMoving = p => p.zoom || p.drag || p.pitch || p.rotate;
+class RenderFrameEvent extends Event {
+  constructor(type, timeStamp) {
+    super(type);
+    _defineProperty(this, "type", 'renderFrame');
+    _defineProperty(this, "timeStamp", void 0);
+    this.timeStamp = timeStamp;
+  }
+}
+
+/**
+ * Handlers interpret dom events and return camera changes that should be
+ * applied to the map (`HandlerResult`s). The camera changes are all deltas.
+ * The handler itself should have no knowledge of the map's current state.
+ * This makes it easier to merge multiple results and keeps handlers simpler.
+ * For example, if there is a mousedown and mousemove, the mousePan handler
+ * would return a `panDelta` on the mousemove.
+ */
+
+/**
+ * All handler methods that are called with events can optionally return a `HandlerResult`.
+ */
+
+function hasChange(result) {
+  return result.panDelta && result.panDelta.mag() || result.zoomDelta || result.bearingDelta || result.pitchDelta;
+}
+export 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, "_zoom", void 0);
+    _defineProperty(this, "_previousActiveHandlers", void 0);
+    _defineProperty(this, "_listeners", void 0);
+    _defineProperty(this, "handleWindowEvent", e => {
+      this.handleEvent(e, `${e.type}Window`);
+    });
+    _defineProperty(this, "handleEvent", (e, eventName) => {
+      if (e.type === 'blur') {
+        this.stop(true);
+        return;
+      }
+      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.
+       */
+
+      const mergedHandlerResult = {
+        needsRenderFrame: false
+      };
+      const eventsInProgress = {};
+      const activeHandlers = {};
+      const eventTouches = e.touches;
+      const mapTouches = eventTouches ? this._getMapTouches(eventTouches) : undefined;
+      const points = mapTouches ? DOM.touchPos(this._map.getCanvasContainer(), mapTouches) : DOM.mousePos(this._map.getCanvasContainer(), e);
+      for (const {
+        handlerName,
+        handler,
+        allowed
+      } of this._handlers) {
+        if (!handler.isEnabled()) continue;
+        let data;
+        if (this._blockedByActive(activeHandlers, allowed, handlerName)) {
+          handler.reset();
+        } else {
+          if (handler[eventName || e.type]) {
+            data = handler[eventName || e.type](e, points, mapTouches);
+            this.mergeHandlerResult(mergedHandlerResult, eventsInProgress, data, handlerName, inputEvent);
+            if (data && data.needsRenderFrame) {
+              this._triggerRenderFrame();
+            }
+          }
+        }
+        if (data || handler.isActive()) {
+          activeHandlers[handlerName] = handler;
+        }
+      }
+      const deactivatedHandlers = {};
+      for (const name in this._previousActiveHandlers) {
+        if (!activeHandlers[name]) {
+          deactivatedHandlers[name] = inputEvent;
+        }
+      }
+      this._previousActiveHandlers = activeHandlers;
+      if (Object.keys(deactivatedHandlers).length || hasChange(mergedHandlerResult)) {
+        this._changes.push([mergedHandlerResult, eventsInProgress, deactivatedHandlers]);
+        this._triggerRenderFrame();
+      }
+      if (Object.keys(activeHandlers).length || hasChange(mergedHandlerResult)) {
+        this._map._stop(true);
+      }
+      this._updatingCamera = false;
+      const {
+        cameraAnimation
+      } = mergedHandlerResult;
+      if (cameraAnimation) {
+        this._inertia.clear();
+        this._fireEvents({}, {}, true);
+        this._changes = [];
+        cameraAnimation(this._map);
+      }
+    });
+    this._map = map;
+    this._el = this._map.getCanvasContainer();
+    this._handlers = [];
+    this._handlersById = {};
+    this._changes = [];
+    this._inertia = new HandlerInertia(map);
+    this._bearingSnap = options.bearingSnap || 7;
+    this._previousActiveHandlers = {};
+
+    // Track whether map is currently moving, to compute start/move/end events
+    this._eventsInProgress = {};
+    this._addDefaultHandlers(options);
+    const el = this._el;
+    this._listeners = [
+    // This needs to be `passive: true` so that a double tap fires two
+    // pairs of touchstart/end events in iOS Safari 13. If this is set to
+    // `passive: false` then the second pair of events is only fired if
+    // preventDefault() is called on the first touchstart. Calling preventDefault()
+    // undesirably prevents click events.
+    [el, 'touchstart', {
+      passive: true
+    }],
+    // This needs to be `passive: false` so that scrolls and pinches can be
+    // prevented in browsers that don't support `touch-actions: none`, for example iOS Safari 12.
+    [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.
+    [document, 'mousemove', {
+      capture: true
+    }], [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], [window, 'blur', undefined]];
+    for (const [target, type, listenerOptions] of this._listeners) {
+      DOM.addEventListener(target, type, target === document ? this.handleWindowEvent : this.handleEvent, listenerOptions);
+    }
+  }
+  destroy() {
+    for (const [target, type, listenerOptions] of this._listeners) {
+      DOM.removeEventListener(target, type, target === document ? this.handleWindowEvent : this.handleEvent, listenerOptions);
+    }
+  }
+  _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);
+    if (options.interactive && options.boxZoom) {
+      boxZoom.enable();
+    }
+    const cooperativeGestures = map.cooperativeGestures = new CooperativeGesturesHandler(map, options.cooperativeGestures);
+    this._add('cooperativeGestures', cooperativeGestures);
+    if (options.cooperativeGestures) {
+      cooperativeGestures.enable();
+    }
+    const tapZoom = new TapZoomHandler(map);
+    const clickZoom = new ClickZoomHandler(map);
+    map.doubleClickZoom = new DoubleClickZoomHandler(clickZoom, tapZoom);
+    this._add('tapZoom', tapZoom);
+    this._add('clickZoom', clickZoom);
+    if (options.interactive && options.doubleClickZoom) {
+      map.doubleClickZoom.enable();
+    }
+    const tapDragZoom = new TapDragZoomHandler();
+    this._add('tapDragZoom', tapDragZoom);
+    const touchPitch = map.touchPitch = new TwoFingersTouchPitchHandler(map);
+    this._add('touchPitch', touchPitch);
+    if (options.interactive && options.touchPitch) {
+      map.touchPitch.enable(options.touchPitch);
+    }
+    const mouseRotate = generateMouseRotationHandler(options);
+    const mousePitch = generateMousePitchHandler(options);
+    map.dragRotate = new DragRotateHandler(options, mouseRotate, mousePitch);
+    this._add('mouseRotate', mouseRotate, ['mousePitch']);
+    this._add('mousePitch', mousePitch, ['mouseRotate']);
+    if (options.interactive && options.dragRotate) {
+      map.dragRotate.enable();
+    }
+    const mousePan = generateMousePanHandler(options);
+    const touchPan = new TouchPanHandler(options, map);
+    map.dragPan = new DragPanHandler(el, mousePan, touchPan);
+    this._add('mousePan', mousePan);
+    this._add('touchPan', touchPan, ['touchZoom', 'touchRotate']);
+    if (options.interactive && options.dragPan) {
+      map.dragPan.enable(options.dragPan);
+    }
+    const touchRotate = new TwoFingersTouchRotateHandler();
+    const touchZoom = new TwoFingersTouchZoomHandler();
+    map.touchZoomRotate = new TwoFingersTouchZoomRotateHandler(el, touchZoom, touchRotate, tapDragZoom);
+    this._add('touchRotate', touchRotate, ['touchPan', 'touchZoom']);
+    this._add('touchZoom', touchZoom, ['touchPan', 'touchRotate']);
+    if (options.interactive && options.touchZoomRotate) {
+      map.touchZoomRotate.enable(options.touchZoomRotate);
+    }
+    const scrollZoom = map.scrollZoom = new ScrollZoomHandler(map, () => this._triggerRenderFrame());
+    this._add('scrollZoom', scrollZoom, ['mousePan']);
+    if (options.interactive && options.scrollZoom) {
+      map.scrollZoom.enable(options.scrollZoom);
+    }
+    const keyboard = map.keyboard = new KeyboardHandler(map);
+    this._add('keyboard', keyboard);
+    if (options.interactive && options.keyboard) {
+      map.keyboard.enable();
+    }
+    this._add('blockableMapEvent', new BlockableMapEventHandler(map));
+  }
+  _add(handlerName, handler, allowed) {
+    this._handlers.push({
+      handlerName,
+      handler,
+      allowed
+    });
+    this._handlersById[handlerName] = handler;
+  }
+  stop(allowEndAnimation) {
+    // do nothing if this method was triggered by a gesture update
+    if (this._updatingCamera) return;
+    for (const {
+      handler
+    } of this._handlers) {
+      handler.reset();
+    }
+    this._inertia.clear();
+    this._fireEvents({}, {}, allowEndAnimation);
+    this._changes = [];
+  }
+  isActive() {
+    for (const {
+      handler
+    } of this._handlers) {
+      if (handler.isActive()) return true;
+    }
+    return false;
+  }
+  isZooming() {
+    return !!this._eventsInProgress.zoom || this._map.scrollZoom.isZooming();
+  }
+  isRotating() {
+    return !!this._eventsInProgress.rotate;
+  }
+  isMoving() {
+    return Boolean(isMoving(this._eventsInProgress)) || this.isZooming();
+  }
+  _blockedByActive(activeHandlers, allowed, myName) {
+    for (const name in activeHandlers) {
+      if (name === myName) continue;
+      if (!allowed || allowed.indexOf(name) < 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  _getMapTouches(touches) {
+    const mapTouches = [];
+    for (const t of touches) {
+      const target = t.target;
+      if (this._el.contains(target)) {
+        mapTouches.push(t);
+      }
+    }
+    return mapTouches;
+  }
+  mergeHandlerResult(mergedHandlerResult, eventsInProgress, handlerResult, name, e) {
+    if (!handlerResult) return;
+    extend(mergedHandlerResult, handlerResult);
+    const 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;
+    }
+  }
+  _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);
+      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;
+      extend(combinedEventsInProgress, eventsInProgress);
+      extend(combinedDeactivatedHandlers, deactivatedHandlers);
+    }
+    this._updateMapTransform(combined, combinedEventsInProgress, combinedDeactivatedHandlers);
+    this._changes = [];
+  }
+  _updateMapTransform(combinedResult, combinedEventsInProgress, deactivatedHandlers) {
+    const map = this._map;
+    const tr = map._getTransformForUpdate();
+    if (!hasChange(combinedResult)) {
+      return this._fireEvents(combinedEventsInProgress, deactivatedHandlers, true);
+    }
+    const {
+      panDelta,
+      zoomDelta,
+      bearingDelta,
+      pitchDelta,
+      pinchAround
+    } = combinedResult;
+    let {
+      around
+    } = combinedResult;
+    if (pinchAround !== undefined) {
+      around = pinchAround;
+    }
+
+    // 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) tr.bearing += bearingDelta;
+    if (pitchDelta) tr.pitch += pitchDelta;
+    if (zoomDelta) tr.zoom += zoomDelta;
+    tr.setLocationAtPoint(loc, around);
+    map._applyUpdatedTransform(tr);
+    this._map._update();
+    if (!combinedResult.noInertia) this._inertia.record(combinedResult);
+    this._fireEvents(combinedEventsInProgress, deactivatedHandlers, true);
+  }
+  _fireEvents(newEventsInProgress, deactivatedHandlers, allowEndAnimation) {
+    const wasMoving = isMoving(this._eventsInProgress);
+    const nowMoving = isMoving(newEventsInProgress);
+    const startEvents = {};
+    for (const eventName in newEventsInProgress) {
+      const {
+        originalEvent
+      } = newEventsInProgress[eventName];
+      if (!this._eventsInProgress[eventName]) {
+        startEvents[`${eventName}start`] = originalEvent;
+      }
+      this._eventsInProgress[eventName] = newEventsInProgress[eventName];
+    }
+
+    // fire start events only after this._eventsInProgress has been updated
+    if (!wasMoving && nowMoving) {
+      this._fireEvent('movestart', nowMoving.originalEvent);
+    }
+    for (const name in startEvents) {
+      this._fireEvent(name, startEvents[name]);
+    }
+    if (nowMoving) {
+      this._fireEvent('move', nowMoving.originalEvent);
+    }
+    for (const eventName in newEventsInProgress) {
+      const {
+        originalEvent
+      } = newEventsInProgress[eventName];
+      this._fireEvent(eventName, originalEvent);
+    }
+    const endEvents = {};
+    let originalEndEvent;
+    for (const eventName in this._eventsInProgress) {
+      const {
+        handlerName,
+        originalEvent
+      } = this._eventsInProgress[eventName];
+      if (!this._handlersById[handlerName].isActive()) {
+        delete this._eventsInProgress[eventName];
+        originalEndEvent = deactivatedHandlers[handlerName] || originalEvent;
+        endEvents[`${eventName}end`] = originalEndEvent;
+      }
+    }
+    for (const name in endEvents) {
+      this._fireEvent(name, endEvents[name]);
+    }
+    const stillMoving = isMoving(this._eventsInProgress);
+    const finishedMoving = (wasMoving || nowMoving) && !stillMoving;
+    if (allowEndAnimation && finishedMoving) {
+      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 && (inertialEase.essential || !browser.prefersReducedMotion)) {
+        if (shouldSnapToNorth(inertialEase.bearing || this._map.getBearing())) {
+          inertialEase.bearing = 0;
+        }
+        inertialEase.freezeElevation = true;
+        this._map.easeTo(inertialEase, {
+          originalEvent: originalEndEvent
+        });
+      } else {
+        this._map.fire(new Event('moveend', {
+          originalEvent: originalEndEvent
+        }));
+        if (shouldSnapToNorth(this._map.getBearing())) {
+          this._map.resetNorth();
+        }
+      }
+      this._updatingCamera = false;
+    }
+  }
+  _fireEvent(type, e) {
+    this._map.fire(new Event(type, e ? {
+      originalEvent: e
+    } : {}));
+  }
+  _requestFrame() {
+    this._map.triggerRepaint();
+    return this._map._renderTaskQueue.add(timeStamp => {
+      delete this._frameId;
+      this.handleEvent(new RenderFrameEvent('renderFrame', timeStamp));
+      this._applyChanges();
+    });
+  }
+  _triggerRenderFrame() {
+    if (this._frameId === undefined) {
+      this._frameId = this._requestFrame();
+    }
+  }
+}