@antv/l7-map 2.25.7 → 2.25.10

package/lib/map/handler/tap_recognizer.js

@@ -0,0 +1,116 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TapRecognizer = exports.SingleTapRecognizer = exports.MAX_TAP_INTERVAL = exports.MAX_DIST = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _pointGeometry = _interopRequireDefault(require("@mapbox/point-geometry"));
+var _handler_util = require("./handler_util");
+function getCentroid(points) {
+  const sum = new _pointGeometry.default(0, 0);
+  for (const point of points) {
+    sum._add(point);
+  }
+  return sum.div(points.length);
+}
+const MAX_TAP_INTERVAL = exports.MAX_TAP_INTERVAL = 500;
+const MAX_TOUCH_TIME = 500;
+const MAX_DIST = exports.MAX_DIST = 30;
+class SingleTapRecognizer {
+  constructor(options) {
+    (0, _defineProperty2.default)(this, "numTouches", void 0);
+    (0, _defineProperty2.default)(this, "centroid", void 0);
+    (0, _defineProperty2.default)(this, "startTime", void 0);
+    (0, _defineProperty2.default)(this, "aborted", void 0);
+    (0, _defineProperty2.default)(this, "touches", void 0);
+    this.reset();
+    this.numTouches = options.numTouches;
+  }
+  reset() {
+    delete this.centroid;
+    delete this.startTime;
+    delete this.touches;
+    this.aborted = false;
+  }
+  touchstart(e, points, mapTouches) {
+    if (this.centroid || mapTouches.length > this.numTouches) {
+      this.aborted = true;
+    }
+    if (this.aborted) {
+      return;
+    }
+    if (this.startTime === undefined) {
+      this.startTime = e.timeStamp;
+    }
+    if (mapTouches.length === this.numTouches) {
+      this.centroid = getCentroid(points);
+      this.touches = (0, _handler_util.indexTouches)(mapTouches, points);
+    }
+  }
+  touchmove(e, points, mapTouches) {
+    if (this.aborted || !this.centroid) return;
+    const newTouches = (0, _handler_util.indexTouches)(mapTouches, points);
+    for (const id in this.touches) {
+      const prevPos = this.touches[id];
+      const pos = newTouches[id];
+      if (!pos || pos.dist(prevPos) > MAX_DIST) {
+        this.aborted = true;
+      }
+    }
+  }
+  touchend(e, points, mapTouches) {
+    if (!this.centroid || e.timeStamp - this.startTime > MAX_TOUCH_TIME) {
+      this.aborted = true;
+    }
+    if (mapTouches.length === 0) {
+      const centroid = !this.aborted && this.centroid;
+      this.reset();
+      if (centroid) return centroid;
+    }
+  }
+}
+exports.SingleTapRecognizer = SingleTapRecognizer;
+class TapRecognizer {
+  constructor(options) {
+    (0, _defineProperty2.default)(this, "singleTap", void 0);
+    (0, _defineProperty2.default)(this, "numTaps", void 0);
+    (0, _defineProperty2.default)(this, "lastTime", void 0);
+    (0, _defineProperty2.default)(this, "lastTap", void 0);
+    (0, _defineProperty2.default)(this, "count", void 0);
+    this.singleTap = new SingleTapRecognizer(options);
+    this.numTaps = options.numTaps;
+    this.reset();
+  }
+  reset() {
+    this.lastTime = Infinity;
+    delete this.lastTap;
+    this.count = 0;
+    this.singleTap.reset();
+  }
+  touchstart(e, points, mapTouches) {
+    this.singleTap.touchstart(e, points, mapTouches);
+  }
+  touchmove(e, points, mapTouches) {
+    this.singleTap.touchmove(e, points, mapTouches);
+  }
+  touchend(e, points, mapTouches) {
+    const tap = this.singleTap.touchend(e, points, mapTouches);
+    if (tap) {
+      const soonEnough = e.timeStamp - this.lastTime < MAX_TAP_INTERVAL;
+      const closeEnough = !this.lastTap || this.lastTap.dist(tap) < MAX_DIST;
+      if (!soonEnough || !closeEnough) {
+        this.reset();
+      }
+      this.count++;
+      this.lastTime = e.timeStamp;
+      this.lastTap = tap;
+      if (this.count === this.numTaps) {
+        this.reset();
+        return tap;
+      }
+    }
+  }
+}
+exports.TapRecognizer = TapRecognizer;

package/lib/map/handler/tap_zoom.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="mapbox__point-geometry" />
+import type Point from '@mapbox/point-geometry';
+import type { Handler } from '../handler_manager';
+import type { Map } from '../map';
+import { TapRecognizer } from './tap_recognizer';
+import { TransformProvider } from './transform-provider';
+/**
+ * A `TapZoomHandler` allows the user to zoom the map at a point by double tapping
+ */
+export declare class TapZoomHandler implements Handler {
+    _tr: TransformProvider;
+    _enabled: boolean;
+    _active: boolean;
+    _zoomIn: TapRecognizer;
+    _zoomOut: TapRecognizer;
+    constructor(map: Map);
+    reset(): void;
+    touchstart(e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>): void;
+    touchmove(e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>): void;
+    touchend(e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>): {
+        cameraAnimation: (map: Map) => Map;
+    };
+    touchcancel(): void;
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    isActive(): boolean;
+}

package/lib/map/handler/tap_zoom.js

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TapZoomHandler = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _tap_recognizer = require("./tap_recognizer");
+var _transformProvider = require("./transform-provider");
+/**
+ * A `TapZoomHandler` allows the user to zoom the map at a point by double tapping
+ */
+class TapZoomHandler {
+  constructor(map) {
+    (0, _defineProperty2.default)(this, "_tr", void 0);
+    (0, _defineProperty2.default)(this, "_enabled", void 0);
+    (0, _defineProperty2.default)(this, "_active", void 0);
+    (0, _defineProperty2.default)(this, "_zoomIn", void 0);
+    (0, _defineProperty2.default)(this, "_zoomOut", void 0);
+    this._tr = new _transformProvider.TransformProvider(map);
+    this._zoomIn = new _tap_recognizer.TapRecognizer({
+      numTouches: 1,
+      numTaps: 2
+    });
+    this._zoomOut = new _tap_recognizer.TapRecognizer({
+      numTouches: 2,
+      numTaps: 1
+    });
+    this.reset();
+  }
+  reset() {
+    this._active = false;
+    this._zoomIn.reset();
+    this._zoomOut.reset();
+  }
+  touchstart(e, points, mapTouches) {
+    this._zoomIn.touchstart(e, points, mapTouches);
+    this._zoomOut.touchstart(e, points, mapTouches);
+  }
+  touchmove(e, points, mapTouches) {
+    this._zoomIn.touchmove(e, points, mapTouches);
+    this._zoomOut.touchmove(e, points, mapTouches);
+  }
+  touchend(e, points, mapTouches) {
+    const zoomInPoint = this._zoomIn.touchend(e, points, mapTouches);
+    const zoomOutPoint = this._zoomOut.touchend(e, points, mapTouches);
+    const tr = this._tr;
+    if (zoomInPoint) {
+      this._active = true;
+      e.preventDefault();
+      setTimeout(() => this.reset(), 0);
+      return {
+        cameraAnimation: map => map.easeTo({
+          duration: 300,
+          zoom: tr.zoom + 1,
+          around: tr.unproject(zoomInPoint)
+        }, {
+          originalEvent: e
+        })
+      };
+    } else if (zoomOutPoint) {
+      this._active = true;
+      e.preventDefault();
+      setTimeout(() => this.reset(), 0);
+      return {
+        cameraAnimation: map => map.easeTo({
+          duration: 300,
+          zoom: tr.zoom - 1,
+          around: tr.unproject(zoomOutPoint)
+        }, {
+          originalEvent: e
+        })
+      };
+    }
+  }
+  touchcancel() {
+    this.reset();
+  }
+  enable() {
+    this._enabled = true;
+  }
+  disable() {
+    this._enabled = false;
+    this.reset();
+  }
+  isEnabled() {
+    return this._enabled;
+  }
+  isActive() {
+    return this._active;
+  }
+}
+exports.TapZoomHandler = TapZoomHandler;

package/lib/map/handler/touch_pan.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="mapbox__point-geometry" />
+import Point from '@mapbox/point-geometry';
+import type { Handler } from '../handler_manager';
+import type { Map } from '../map';
+/**
+ * A `TouchPanHandler` allows the user to pan the map using touch gestures.
+ */
+export declare class TouchPanHandler implements Handler {
+    _enabled: boolean;
+    _active: boolean;
+    _touches: {
+        [k in string | number]: Point;
+    };
+    _clickTolerance: number;
+    _sum: Point;
+    _map: Map;
+    constructor(options: {
+        clickTolerance: number;
+    }, map: Map);
+    reset(): void;
+    minTouchs(): 1 | 2;
+    touchstart(e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>): {
+        around: Point;
+        panDelta: Point;
+    };
+    touchmove(e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>): {
+        around: Point;
+        panDelta: Point;
+    };
+    touchend(e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>): void;
+    touchcancel(): void;
+    _calculateTransform(e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>): {
+        around: Point;
+        panDelta: Point;
+    };
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    isActive(): boolean;
+}

package/lib/map/handler/touch_pan.js

@@ -0,0 +1,92 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TouchPanHandler = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _pointGeometry = _interopRequireDefault(require("@mapbox/point-geometry"));
+var _handler_util = require("./handler_util");
+/**
+ * A `TouchPanHandler` allows the user to pan the map using touch gestures.
+ */
+class TouchPanHandler {
+  constructor(options, map) {
+    (0, _defineProperty2.default)(this, "_enabled", void 0);
+    (0, _defineProperty2.default)(this, "_active", void 0);
+    (0, _defineProperty2.default)(this, "_touches", void 0);
+    (0, _defineProperty2.default)(this, "_clickTolerance", void 0);
+    (0, _defineProperty2.default)(this, "_sum", void 0);
+    (0, _defineProperty2.default)(this, "_map", void 0);
+    this._clickTolerance = options.clickTolerance || 1;
+    this._map = map;
+    this.reset();
+  }
+  reset() {
+    this._active = false;
+    this._touches = {};
+    this._sum = new _pointGeometry.default(0, 0);
+  }
+  minTouchs() {
+    return this._map.cooperativeGestures.isEnabled() ? 2 : 1;
+  }
+  touchstart(e, points, mapTouches) {
+    return this._calculateTransform(e, points, mapTouches);
+  }
+  touchmove(e, points, mapTouches) {
+    if (!this._active || mapTouches.length < this.minTouchs()) return;
+    e.preventDefault();
+    return this._calculateTransform(e, points, mapTouches);
+  }
+  touchend(e, points, mapTouches) {
+    this._calculateTransform(e, points, mapTouches);
+    if (this._active && mapTouches.length < this.minTouchs()) {
+      this.reset();
+    }
+  }
+  touchcancel() {
+    this.reset();
+  }
+  _calculateTransform(e, points, mapTouches) {
+    if (mapTouches.length > 0) this._active = true;
+    const touches = (0, _handler_util.indexTouches)(mapTouches, points);
+    const touchPointSum = new _pointGeometry.default(0, 0);
+    const touchDeltaSum = new _pointGeometry.default(0, 0);
+    let touchDeltaCount = 0;
+    for (const identifier in touches) {
+      const point = touches[identifier];
+      const prevPoint = this._touches[identifier];
+      if (prevPoint) {
+        touchPointSum._add(point);
+        touchDeltaSum._add(point.sub(prevPoint));
+        touchDeltaCount++;
+        touches[identifier] = point;
+      }
+    }
+    this._touches = touches;
+    if (touchDeltaCount < this.minTouchs() || !touchDeltaSum.mag()) return;
+    const panDelta = touchDeltaSum.div(touchDeltaCount);
+    this._sum._add(panDelta);
+    if (this._sum.mag() < this._clickTolerance) return;
+    const around = touchPointSum.div(touchDeltaCount);
+    return {
+      around,
+      panDelta
+    };
+  }
+  enable() {
+    this._enabled = true;
+  }
+  disable() {
+    this._enabled = false;
+    this.reset();
+  }
+  isEnabled() {
+    return this._enabled;
+  }
+  isActive() {
+    return this._active;
+  }
+}
+exports.TouchPanHandler = TouchPanHandler;

package/lib/map/handler/transform-provider.d.ts

@@ -0,0 +1,23 @@
+import type { PointLike } from '../camera';
+import type { LngLat } from '../geo/lng_lat';
+import type { Transform } from '../geo/transform';
+import type { Map } from '../map';
+/**
+ * @internal
+ * Shared utilities for the Handler classes to access the correct camera state.
+ * If Camera.transformCameraUpdate is specified, the "desired state" of camera may differ from the state used for rendering.
+ * The handlers need the "desired state" to track accumulated changes.
+ */
+export declare class TransformProvider {
+    _map: Map;
+    constructor(map: Map);
+    get transform(): Transform;
+    get center(): {
+        lng: number;
+        lat: number;
+    };
+    get zoom(): number;
+    get pitch(): number;
+    get bearing(): number;
+    unproject(point: PointLike): LngLat;
+}

package/lib/map/handler/transform-provider.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TransformProvider = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _pointGeometry = _interopRequireDefault(require("@mapbox/point-geometry"));
+/**
+ * @internal
+ * Shared utilities for the Handler classes to access the correct camera state.
+ * If Camera.transformCameraUpdate is specified, the "desired state" of camera may differ from the state used for rendering.
+ * The handlers need the "desired state" to track accumulated changes.
+ */
+class TransformProvider {
+  constructor(map) {
+    (0, _defineProperty2.default)(this, "_map", void 0);
+    this._map = map;
+  }
+  get transform() {
+    return this._map._requestedCameraState || this._map.transform;
+  }
+  get center() {
+    return {
+      lng: this.transform.center.lng,
+      lat: this.transform.center.lat
+    };
+  }
+  get zoom() {
+    return this.transform.zoom;
+  }
+  get pitch() {
+    return this.transform.pitch;
+  }
+  get bearing() {
+    return this.transform.bearing;
+  }
+  unproject(point) {
+    return this.transform.pointLocation(_pointGeometry.default.convert(point));
+  }
+}
+exports.TransformProvider = TransformProvider;

package/lib/map/handler/two_fingers_touch.d.ts

@@ -0,0 +1,107 @@
+/// <reference types="mapbox__point-geometry" />
+import type Point from '@mapbox/point-geometry';
+import type { Handler, HandlerResult } from '../handler_manager';
+import type { Map } from '../map';
+/**
+ * An options object sent to the enable function of some of the handlers
+ */
+export type AroundCenterOptions = {
+    /**
+     * If "center" is passed, map will zoom around the center of map
+     */
+    around: 'center';
+};
+/**
+ * The `TwoFingersTouchHandler`s allows the user to zoom, pitch and rotate the map using two fingers
+ *
+ */
+declare abstract class TwoFingersTouchHandler implements Handler {
+    _enabled?: boolean;
+    _active?: boolean;
+    _firstTwoTouches?: [number, number];
+    _vector?: Point;
+    _startVector?: Point;
+    _aroundCenter?: boolean;
+    /** @internal */
+    constructor();
+    reset(): void;
+    abstract _start(points: [Point, Point]): void;
+    abstract _move(points: [Point, Point], pinchAround: Point | null, e: TouchEvent): HandlerResult | void;
+    touchstart(e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>): void;
+    touchmove(e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>): HandlerResult | void;
+    touchend(e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>): void;
+    touchcancel(): void;
+    /**
+     * Enables the "drag to pitch" interaction.
+     *
+     * @example
+     * ```ts
+     * map.touchPitch.enable();
+     * ```
+     */
+    enable(options?: AroundCenterOptions | boolean | null): void;
+    /**
+     * Disables the "drag to pitch" interaction.
+     *
+     * @example
+     * ```ts
+     * map.touchPitch.disable();
+     * ```
+     */
+    disable(): void;
+    /**
+     * Returns a Boolean indicating whether the "drag to pitch" interaction is enabled.
+     *
+     * @returns  `true` if the "drag to pitch" interaction is enabled.
+     */
+    isEnabled(): boolean;
+    /**
+     * Returns a Boolean indicating whether the "drag to pitch" interaction is active, i.e. currently being used.
+     *
+     * @returns `true` if the "drag to pitch" interaction is active.
+     */
+    isActive(): boolean;
+}
+/**
+ * The `TwoFingersTouchHandler`s allows the user to zoom the map two fingers
+ *
+ * @group Handlers
+ */
+export declare class TwoFingersTouchZoomHandler extends TwoFingersTouchHandler {
+    _distance?: number;
+    _startDistance?: number;
+    reset(): void;
+    _start(points: [Point, Point]): void;
+    _move(points: [Point, Point], pinchAround: Point | null): HandlerResult | void;
+}
+/**
+ * The `TwoFingersTouchHandler`s allows the user to rotate the map two fingers
+ *
+ * @group Handlers
+ */
+export declare class TwoFingersTouchRotateHandler extends TwoFingersTouchHandler {
+    _minDiameter?: number;
+    reset(): void;
+    _start(points: [Point, Point]): void;
+    _move(points: [Point, Point], pinchAround: Point | null, _e: TouchEvent): HandlerResult | void;
+    _isBelowThreshold(vector: Point): boolean;
+}
+/**
+ * The `TwoFingersTouchPitchHandler` allows the user to pitch the map by dragging up and down with two fingers.
+ *
+ * @group Handlers
+ */
+export declare class TwoFingersTouchPitchHandler extends TwoFingersTouchHandler {
+    _valid?: boolean;
+    _firstMove?: number;
+    _lastPoints?: [Point, Point];
+    _map: Map;
+    _currentTouchCount: number;
+    constructor(map: Map);
+    reset(): void;
+    touchstart(e: TouchEvent, points: Array<Point>, mapTouches: Array<Touch>): void;
+    _start(points: [Point, Point]): void;
+    _move(points: [Point, Point], center: Point | null, e: TouchEvent): HandlerResult | void;
+    gestureBeginsVertically(vectorA: Point, vectorB: Point, timeStamp: number): boolean | undefined;
+}
+export {};