@antv/l7-map 2.25.7 → 2.25.10

package/es/map/handler_inertia.js

@@ -0,0 +1,128 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import Point from '@mapbox/point-geometry';
+import { browser } from "./util/browser";
+import { bezier, clamp, extend } from "./util/util";
+const defaultInertiaOptions = {
+  linearity: 0.3,
+  easing: bezier(0, 0, 0.3, 1)
+};
+const defaultPanInertiaOptions = extend({
+  deceleration: 2500,
+  maxSpeed: 1400
+}, defaultInertiaOptions);
+const defaultZoomInertiaOptions = extend({
+  deceleration: 20,
+  maxSpeed: 1400
+}, defaultInertiaOptions);
+const defaultBearingInertiaOptions = extend({
+  deceleration: 1000,
+  maxSpeed: 360
+}, defaultInertiaOptions);
+const defaultPitchInertiaOptions = extend({
+  deceleration: 1000,
+  maxSpeed: 90
+}, defaultInertiaOptions);
+export class HandlerInertia {
+  constructor(map) {
+    _defineProperty(this, "_map", void 0);
+    _defineProperty(this, "_inertiaBuffer", void 0);
+    this._map = map;
+    this.clear();
+  }
+  clear() {
+    this._inertiaBuffer = [];
+  }
+  record(settings) {
+    this._drainInertiaBuffer();
+    this._inertiaBuffer.push({
+      time: browser.now(),
+      settings
+    });
+  }
+  _drainInertiaBuffer() {
+    const inertia = this._inertiaBuffer,
+      now = browser.now(),
+      cutoff = 160; //msec
+
+    while (inertia.length > 0 && now - inertia[0].time > cutoff) inertia.shift();
+  }
+  _onMoveEnd(panInertiaOptions) {
+    this._drainInertiaBuffer();
+    if (this._inertiaBuffer.length < 2) {
+      return;
+    }
+    const deltas = {
+      zoom: 0,
+      bearing: 0,
+      pitch: 0,
+      pan: new Point(0, 0),
+      pinchAround: undefined,
+      around: undefined
+    };
+    for (const {
+      settings
+    } of this._inertiaBuffer) {
+      deltas.zoom += settings.zoomDelta || 0;
+      deltas.bearing += settings.bearingDelta || 0;
+      deltas.pitch += settings.pitchDelta || 0;
+      if (settings.panDelta) deltas.pan._add(settings.panDelta);
+      if (settings.around) deltas.around = settings.around;
+      if (settings.pinchAround) deltas.pinchAround = settings.pinchAround;
+    }
+    const lastEntry = this._inertiaBuffer[this._inertiaBuffer.length - 1];
+    const duration = lastEntry.time - this._inertiaBuffer[0].time;
+    const easeOptions = {};
+    if (deltas.pan.mag()) {
+      const result = calculateEasing(deltas.pan.mag(), duration, extend({}, defaultPanInertiaOptions, panInertiaOptions || {}));
+      easeOptions.offset = deltas.pan.mult(result.amount / deltas.pan.mag());
+      easeOptions.center = this._map.transform.center;
+      extendDuration(easeOptions, result);
+    }
+    if (deltas.zoom) {
+      const result = calculateEasing(deltas.zoom, duration, defaultZoomInertiaOptions);
+      easeOptions.zoom = this._map.transform.zoom + result.amount;
+      extendDuration(easeOptions, result);
+    }
+    if (deltas.bearing) {
+      const result = calculateEasing(deltas.bearing, duration, defaultBearingInertiaOptions);
+      easeOptions.bearing = this._map.transform.bearing + clamp(result.amount, -179, 179);
+      extendDuration(easeOptions, result);
+    }
+    if (deltas.pitch) {
+      const result = calculateEasing(deltas.pitch, duration, defaultPitchInertiaOptions);
+      easeOptions.pitch = this._map.transform.pitch + result.amount;
+      extendDuration(easeOptions, result);
+    }
+    if (easeOptions.zoom || easeOptions.bearing) {
+      const last = deltas.pinchAround === undefined ? deltas.around : deltas.pinchAround;
+      easeOptions.around = last ? this._map.unproject(last) : this._map.getCenter();
+    }
+    this.clear();
+    return extend(easeOptions, {
+      noMoveStart: true
+    });
+  }
+}
+
+// Unfortunately zoom, bearing, etc can't have different durations and easings so
+// we need to choose one. We use the longest duration and it's corresponding easing.
+function extendDuration(easeOptions, result) {
+  if (!easeOptions.duration || easeOptions.duration < result.duration) {
+    easeOptions.duration = result.duration;
+    easeOptions.easing = result.easing;
+  }
+}
+function calculateEasing(amount, inertiaDuration, inertiaOptions) {
+  const {
+    maxSpeed,
+    linearity,
+    deceleration
+  } = inertiaOptions;
+  const speed = clamp(amount * linearity / (inertiaDuration / 1000), -maxSpeed, maxSpeed);
+  const duration = Math.abs(speed) / (deceleration * linearity);
+  return {
+    easing: inertiaOptions.easing,
+    duration: duration * 1000,
+    amount: speed * (duration / 2)
+  };
+}

package/es/map/handler_manager.d.ts

@@ -0,0 +1,154 @@
+/// <reference types="mapbox__point-geometry" />
+import Point from '@mapbox/point-geometry';
+import { HandlerInertia } from './handler_inertia';
+import type { CompleteMapOptions, Map } from './map';
+import { Event } from './util/evented';
+/**
+ * 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.
+ */
+export interface Handler {
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    /**
+     * This is used to indicate if the handler is currently active or not.
+     * In case a handler is active, it will block other handlers from getting the relevant events.
+     * There is an allow list of handlers that can be active at the same time, which is configured when adding a handler.
+     */
+    isActive(): boolean;
+    /**
+     * `reset` can be called by the manager at any time and must reset everything to it's original state
+     */
+    reset(): void;
+    readonly touchstart?: (e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>) => HandlerResult | void;
+    readonly touchmove?: (e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>) => HandlerResult | void;
+    readonly touchmoveWindow?: (e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>) => HandlerResult | void;
+    readonly touchend?: (e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>) => HandlerResult | void;
+    readonly touchcancel?: (e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>) => HandlerResult | void;
+    readonly mousedown?: (e: MouseEvent, point: Point) => HandlerResult | void;
+    readonly mousemove?: (e: MouseEvent, point: Point) => HandlerResult | void;
+    readonly mousemoveWindow?: (e: MouseEvent, point: Point) => HandlerResult | void;
+    readonly mouseup?: (e: MouseEvent, point: Point) => HandlerResult | void;
+    readonly mouseupWindow?: (e: MouseEvent, point: Point) => HandlerResult | void;
+    readonly dblclick?: (e: MouseEvent, point: Point) => HandlerResult | void;
+    readonly contextmenu?: (e: MouseEvent) => HandlerResult | void;
+    readonly wheel?: (e: WheelEvent, point: Point) => HandlerResult | void;
+    readonly keydown?: (e: KeyboardEvent) => HandlerResult | void;
+    readonly keyup?: (e: KeyboardEvent) => HandlerResult | void;
+    /**
+     * `renderFrame` is the only non-dom event. It is called during render
+     * frames and can be used to smooth camera changes (see scroll handler).
+     */
+    readonly renderFrame?: () => HandlerResult | void;
+}
+/**
+ * All handler methods that are called with events can optionally return a `HandlerResult`.
+ */
+export type HandlerResult = {
+    panDelta?: Point;
+    zoomDelta?: number;
+    bearingDelta?: number;
+    pitchDelta?: number;
+    /**
+     * the point to not move when changing the camera
+     */
+    around?: Point | null;
+    /**
+     * same as above, except for pinch actions, which are given higher priority
+     */
+    pinchAround?: Point | null;
+    /**
+     * A method that can fire a one-off easing by directly changing the map's camera.
+     */
+    cameraAnimation?: (map: Map) => any;
+    /**
+     * The last three properties are needed by only one handler: scrollzoom.
+     * The DOM event to be used as the `originalEvent` on any camera change events.
+     */
+    originalEvent?: Event;
+    /**
+     * Makes the manager trigger a frame, allowing the handler to return multiple results over time (see scrollzoom).
+     */
+    needsRenderFrame?: boolean;
+    /**
+     * The camera changes won't get recorded for inertial zooming.
+     */
+    noInertia?: boolean;
+};
+export type EventInProgress = {
+    handlerName: string;
+    originalEvent: Event;
+};
+export type EventsInProgress = {
+    zoom?: EventInProgress;
+    pitch?: EventInProgress;
+    rotate?: EventInProgress;
+    drag?: EventInProgress;
+};
+export declare class HandlerManager {
+    _map: Map;
+    _el: HTMLElement;
+    _handlers: Array<{
+        handlerName: string;
+        handler: Handler;
+        allowed: Array<string>;
+    }>;
+    _eventsInProgress: EventsInProgress;
+    _frameId: number;
+    _inertia: HandlerInertia;
+    _bearingSnap: number;
+    _handlersById: {
+        [x: string]: Handler;
+    };
+    _updatingCamera: boolean;
+    _changes: Array<[HandlerResult, EventsInProgress, {
+        [handlerName: string]: Event;
+    }]>;
+    _zoom: {
+        handlerName: string;
+    };
+    _previousActiveHandlers: {
+        [x: string]: Handler;
+    };
+    _listeners: Array<[
+        Window | Document | HTMLElement,
+        string,
+        ({
+            passive?: boolean;
+            capture?: boolean;
+        } | undefined)
+    ]>;
+    constructor(map: Map, options: CompleteMapOptions);
+    destroy(): void;
+    _addDefaultHandlers(options: CompleteMapOptions): void;
+    _add(handlerName: string, handler: Handler, allowed?: Array<string>): void;
+    stop(allowEndAnimation: boolean): void;
+    isActive(): boolean;
+    isZooming(): boolean;
+    isRotating(): boolean;
+    isMoving(): boolean;
+    _blockedByActive(activeHandlers: {
+        [x: string]: Handler;
+    }, allowed: Array<string>, myName: string): boolean;
+    handleWindowEvent: (e: {
+        type: 'mousemove' | 'mouseup' | 'touchmove';
+    }) => void;
+    _getMapTouches(touches: TouchList): TouchList;
+    handleEvent: (e: Event, eventName?: keyof Handler) => void;
+    mergeHandlerResult(mergedHandlerResult: HandlerResult, eventsInProgress: EventsInProgress, handlerResult: HandlerResult, name: string, e?: UIEvent): void;
+    _applyChanges(): void;
+    _updateMapTransform(combinedResult: HandlerResult, combinedEventsInProgress: EventsInProgress, deactivatedHandlers: {
+        [handlerName: string]: Event;
+    }): void;
+    _fireEvents(newEventsInProgress: EventsInProgress, deactivatedHandlers: {
+        [handlerName: string]: Event;
+    }, allowEndAnimation: boolean): void;
+    _fireEvent(type: string, e?: Event): void;
+    _requestFrame(): number;
+    _triggerRenderFrame(): void;
+}