@antv/l7-map 2.25.7 → 2.25.10

package/lib/map/events.js

@@ -0,0 +1,240 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MapWheelEvent = exports.MapTouchEvent = exports.MapMouseEvent = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _evented = require("./util/evented");
+var _pointGeometry = _interopRequireDefault(require("@mapbox/point-geometry"));
+var _dom = require("./util/dom");
+var _simpleMapCoord = require("./util/simpleMapCoord");
+/**
+ * `MapEventType` - a mapping between the event name and the event value.
+ * These events are used with the {@link Map#on} method.
+ * When using a `layerId` with {@link Map#on} method, please refer to {@link MapLayerEventType}.
+ * The following example can be used for all the events.
+ *
+ * @group Event Related
+ * @example
+ * ```ts
+ * // Initialize the map
+ * let map = new Map({ // map options });
+ * // Set an event listener
+ * map.on('the-event-name', () => {
+ *   console.log('An event has occurred!');
+ * });
+ * ```
+ */
+
+/**
+ * The base event for MapLibre
+ *
+ * @group Event Related
+ */
+
+/**
+ * `MapMouseEvent` is the event type for mouse-related map events.
+ *
+ * @group Event Related
+ *
+ * @example
+ * ```ts
+ * // The `click` event is an example of a `MapMouseEvent`.
+ * // Set up an event listener on the map.
+ * map.on('click', (e) => {
+ *   // The event object (e) contains information like the
+ *   // coordinates of the point on the map that was clicked.
+ *   console.log('A click event has occurred at ' + e.lngLat);
+ * });
+ * ```
+ */
+class MapMouseEvent extends _evented.Event {
+  /**
+   * Prevents subsequent default processing of the event by the map.
+   *
+   * Calling this method will prevent the following default map behaviors:
+   *
+   *   * On `mousedown` events, the behavior of {@link DragPanHandler}
+   *   * On `mousedown` events, the behavior of {@link DragRotateHandler}
+   *   * On `mousedown` events, the behavior of {@link BoxZoomHandler}
+   *   * On `dblclick` events, the behavior of {@link DoubleClickZoomHandler}
+   *
+   */
+  preventDefault() {
+    this._defaultPrevented = true;
+  }
+
+  /**
+   * `true` if `preventDefault` has been called.
+   */
+  get defaultPrevented() {
+    return this._defaultPrevented;
+  }
+  constructor(type, map, originalEvent, data = {}) {
+    super(type, data);
+    /**
+     * The event type
+     */
+    /**
+     * The `Map` object that fired the event.
+     */
+    (0, _defineProperty2.default)(this, "target", void 0);
+    /**
+     * The DOM event which caused the map event.
+     */
+    (0, _defineProperty2.default)(this, "originalEvent", void 0);
+    /**
+     * The pixel coordinates of the mouse cursor, relative to the map and measured from the top left corner.
+     */
+    (0, _defineProperty2.default)(this, "point", void 0);
+    /**
+     * The geographic location on the map of the mouse cursor.
+     */
+    (0, _defineProperty2.default)(this, "lngLat", void 0);
+    (0, _defineProperty2.default)(this, "_defaultPrevented", void 0);
+    const point = _dom.DOM.mousePos(map.getCanvasContainer(), originalEvent);
+    const lngLat = map.unproject(point);
+    this.point = point;
+    this.lngLat = lngLat;
+    this.originalEvent = originalEvent;
+    this._defaultPrevented = false;
+    this.target = map;
+    if (map.version === 'SIMPLE') {
+      const simpleMapCoord = new _simpleMapCoord.SimpleMapCoord(map.mapSize);
+      const [lng, lat] = simpleMapCoord.project([lngLat.lng, lngLat.lat]);
+      this.lngLat = {
+        lng,
+        lat
+      };
+    }
+  }
+}
+
+/**
+ * `MapTouchEvent` is the event type for touch-related map events.
+ *
+ * @group Event Related
+ */
+exports.MapMouseEvent = MapMouseEvent;
+class MapTouchEvent extends _evented.Event {
+  /**
+   * Prevents subsequent default processing of the event by the map.
+   *
+   * Calling this method will prevent the following default map behaviors:
+   *
+   *   * On `touchstart` events, the behavior of {@link DragPanHandler}
+   *   * On `touchstart` events, the behavior of {@link TwoFingersTouchZoomRotateHandler}
+   *
+   */
+  preventDefault() {
+    this._defaultPrevented = true;
+  }
+
+  /**
+   * `true` if `preventDefault` has been called.
+   */
+  get defaultPrevented() {
+    return this._defaultPrevented;
+  }
+  constructor(type, map, originalEvent) {
+    super(type);
+    /**
+     * The event type.
+     */
+    /**
+     * The `Map` object that fired the event.
+     */
+    (0, _defineProperty2.default)(this, "target", void 0);
+    /**
+     * The DOM event which caused the map event.
+     */
+    (0, _defineProperty2.default)(this, "originalEvent", void 0);
+    /**
+     * The geographic location on the map of the center of the touch event points.
+     */
+    (0, _defineProperty2.default)(this, "lngLat", void 0);
+    /**
+     * The pixel coordinates of the center of the touch event points, relative to the map and measured from the top left
+     * corner.
+     */
+    (0, _defineProperty2.default)(this, "point", void 0);
+    /**
+     * The array of pixel coordinates corresponding to a
+     * [touch event's `touches`](https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent/touches) property.
+     */
+    (0, _defineProperty2.default)(this, "points", void 0);
+    /**
+     * The geographical locations on the map corresponding to a
+     * [touch event's `touches`](https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent/touches) property.
+     */
+    (0, _defineProperty2.default)(this, "lngLats", void 0);
+    (0, _defineProperty2.default)(this, "_defaultPrevented", void 0);
+    const touches = type === 'touchend' ? originalEvent.changedTouches : originalEvent.touches;
+    const points = _dom.DOM.touchPos(map.getCanvasContainer(), touches);
+    const lngLats = points.map(t => map.unproject(t));
+    const point = points.reduce((prev, curr, i, arr) => {
+      return prev.add(curr.div(arr.length));
+    }, new _pointGeometry.default(0, 0));
+    const lngLat = map.unproject(point);
+    this.target = map;
+    this.points = points;
+    this.point = point;
+    this.lngLats = lngLats;
+    this.lngLat = lngLat;
+    this.originalEvent = originalEvent;
+    this._defaultPrevented = false;
+  }
+}
+
+/**
+ * `MapWheelEvent` is the event type for the `wheel` map event.
+ *
+ * @group Event Related
+ *
+ */
+exports.MapTouchEvent = MapTouchEvent;
+class MapWheelEvent extends _evented.Event {
+  /**
+   * Prevents subsequent default processing of the event by the map.
+   *
+   * Calling this method will prevent the behavior of {@link ScrollZoomHandler}.
+   */
+  preventDefault() {
+    this._defaultPrevented = true;
+  }
+
+  /**
+   * `true` if `preventDefault` has been called.
+   */
+  get defaultPrevented() {
+    return this._defaultPrevented;
+  }
+  /** */
+  constructor(type, map, originalEvent) {
+    super(type);
+    /**
+     * The event type
+     */
+    /**
+     * The `Map` object that fired the event.
+     */
+    (0, _defineProperty2.default)(this, "target", void 0);
+    /**
+     * The DOM event which caused the map event.
+     */
+    (0, _defineProperty2.default)(this, "originalEvent", void 0);
+    (0, _defineProperty2.default)(this, "_defaultPrevented", void 0);
+    this.target = map;
+    this._defaultPrevented = false;
+    this.originalEvent = originalEvent;
+  }
+}
+
+/**
+ * A `MapLibreZoomEvent` is the event type for the boxzoom-related map events emitted by the {@link BoxZoomHandler}.
+ *
+ * @group Event Related
+ */
+exports.MapWheelEvent = MapWheelEvent;

package/lib/map/geo/edge_insets.d.ts

@@ -0,0 +1,97 @@
+/// <reference types="mapbox__point-geometry" />
+import Point from '@mapbox/point-geometry';
+/**
+ * An `EdgeInset` object represents screen space padding applied to the edges of the viewport.
+ * This shifts the apprent center or the vanishing point of the map. This is useful for adding floating UI elements
+ * on top of the map and having the vanishing point shift as UI elements resize.
+ *
+ * @group Geography and Geometry
+ */
+export declare class EdgeInsets {
+    /**
+     * @defaultValue 0
+     */
+    top: number;
+    /**
+     * @defaultValue 0
+     */
+    bottom: number;
+    /**
+     * @defaultValue 0
+     */
+    left: number;
+    /**
+     * @defaultValue 0
+     */
+    right: number;
+    constructor(top?: number, bottom?: number, left?: number, right?: number);
+    /**
+     * Interpolates the inset in-place.
+     * This maintains the current inset value for any inset not present in `target`.
+     * @param start - interpolation start
+     * @param target - interpolation target
+     * @param t - interpolation step/weight
+     * @returns the insets
+     */
+    interpolate(start: PaddingOptions | EdgeInsets, target: PaddingOptions, t: number): EdgeInsets;
+    /**
+     * Utility method that computes the new apprent center or vanishing point after applying insets.
+     * This is in pixels and with the top left being (0.0) and +y being downwards.
+     *
+     * @param width - the width
+     * @param height - the height
+     * @returns the point
+     */
+    getCenter(width: number, height: number): Point;
+    equals(other: PaddingOptions): boolean;
+    clone(): EdgeInsets;
+    /**
+     * Returns the current state as json, useful when you want to have a
+     * read-only representation of the inset.
+     *
+     * @returns state as json
+     */
+    toJSON(): PaddingOptions;
+}
+/**
+ * Options for setting padding on calls to methods such as {@link Map#fitBounds}, {@link Map#fitScreenCoordinates}, and {@link Map#setPadding}. Adjust these options to set the amount of padding in pixels added to the edges of the canvas. Set a uniform padding on all edges or individual values for each edge. All properties of this object must be
+ * non-negative integers.
+ *
+ * @group Geography and Geometry
+ *
+ * @example
+ * ```ts
+ * let bbox = [[-79, 43], [-73, 45]];
+ * map.fitBounds(bbox, {
+ *   padding: {top: 10, bottom:25, left: 15, right: 5}
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * let bbox = [[-79, 43], [-73, 45]];
+ * map.fitBounds(bbox, {
+ *   padding: 20
+ * });
+ * ```
+ * @see [Fit to the bounds of a LineString](https://maplibre.org/maplibre-gl-js/docs/examples/zoomto-linestring/)
+ * @see [Fit a map to a bounding box](https://maplibre.org/maplibre-gl-js/docs/examples/fitbounds/)
+ */
+export type PaddingOptions = {
+    /**
+     * Padding in pixels from the top of the map canvas.
+     */
+    top: number;
+    /**
+     * Padding in pixels from the bottom of the map canvas.
+     */
+    bottom: number;
+    /**
+     * Padding in pixels from the left of the map canvas.
+     */
+    right: number;
+    /**
+     * Padding in pixels from the right of the map canvas.
+     */
+    left: number;
+};

package/lib/map/geo/edge_insets.js

@@ -0,0 +1,122 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EdgeInsets = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _pointGeometry = _interopRequireDefault(require("@mapbox/point-geometry"));
+var _util = require("../util/util");
+/**
+ * An `EdgeInset` object represents screen space padding applied to the edges of the viewport.
+ * This shifts the apprent center or the vanishing point of the map. This is useful for adding floating UI elements
+ * on top of the map and having the vanishing point shift as UI elements resize.
+ *
+ * @group Geography and Geometry
+ */
+class EdgeInsets {
+  constructor(top = 0, bottom = 0, left = 0, right = 0) {
+    /**
+     * @defaultValue 0
+     */
+    (0, _defineProperty2.default)(this, "top", void 0);
+    /**
+     * @defaultValue 0
+     */
+    (0, _defineProperty2.default)(this, "bottom", void 0);
+    /**
+     * @defaultValue 0
+     */
+    (0, _defineProperty2.default)(this, "left", void 0);
+    /**
+     * @defaultValue 0
+     */
+    (0, _defineProperty2.default)(this, "right", void 0);
+    if (isNaN(top) || top < 0 || isNaN(bottom) || bottom < 0 || isNaN(left) || left < 0 || isNaN(right) || right < 0) {
+      throw new Error('Invalid value for edge-insets, top, bottom, left and right must all be numbers');
+    }
+    this.top = top;
+    this.bottom = bottom;
+    this.left = left;
+    this.right = right;
+  }
+
+  /**
+   * Interpolates the inset in-place.
+   * This maintains the current inset value for any inset not present in `target`.
+   * @param start - interpolation start
+   * @param target - interpolation target
+   * @param t - interpolation step/weight
+   * @returns the insets
+   */
+  interpolate(start, target, t) {
+    if (target.top != null && start.top != null) this.top = _util.interpolates.number(start.top, target.top, t);
+    if (target.bottom != null && start.bottom != null) this.bottom = _util.interpolates.number(start.bottom, target.bottom, t);
+    if (target.left != null && start.left != null) this.left = _util.interpolates.number(start.left, target.left, t);
+    if (target.right != null && start.right != null) this.right = _util.interpolates.number(start.right, target.right, t);
+    return this;
+  }
+
+  /**
+   * Utility method that computes the new apprent center or vanishing point after applying insets.
+   * This is in pixels and with the top left being (0.0) and +y being downwards.
+   *
+   * @param width - the width
+   * @param height - the height
+   * @returns the point
+   */
+  getCenter(width, height) {
+    // Clamp insets so they never overflow width/height and always calculate a valid center
+    const x = (0, _util.clamp)((this.left + width - this.right) / 2, 0, width);
+    const y = (0, _util.clamp)((this.top + height - this.bottom) / 2, 0, height);
+    return new _pointGeometry.default(x, y);
+  }
+  equals(other) {
+    return this.top === other.top && this.bottom === other.bottom && this.left === other.left && this.right === other.right;
+  }
+  clone() {
+    return new EdgeInsets(this.top, this.bottom, this.left, this.right);
+  }
+
+  /**
+   * Returns the current state as json, useful when you want to have a
+   * read-only representation of the inset.
+   *
+   * @returns state as json
+   */
+  toJSON() {
+    return {
+      top: this.top,
+      bottom: this.bottom,
+      left: this.left,
+      right: this.right
+    };
+  }
+}
+
+/**
+ * Options for setting padding on calls to methods such as {@link Map#fitBounds}, {@link Map#fitScreenCoordinates}, and {@link Map#setPadding}. Adjust these options to set the amount of padding in pixels added to the edges of the canvas. Set a uniform padding on all edges or individual values for each edge. All properties of this object must be
+ * non-negative integers.
+ *
+ * @group Geography and Geometry
+ *
+ * @example
+ * ```ts
+ * let bbox = [[-79, 43], [-73, 45]];
+ * map.fitBounds(bbox, {
+ *   padding: {top: 10, bottom:25, left: 15, right: 5}
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * let bbox = [[-79, 43], [-73, 45]];
+ * map.fitBounds(bbox, {
+ *   padding: 20
+ * });
+ * ```
+ * @see [Fit to the bounds of a LineString](https://maplibre.org/maplibre-gl-js/docs/examples/zoomto-linestring/)
+ * @see [Fit a map to a bounding box](https://maplibre.org/maplibre-gl-js/docs/examples/fitbounds/)
+ */
+exports.EdgeInsets = EdgeInsets;

package/lib/map/geo/lng_lat.d.ts

@@ -0,0 +1,116 @@
+export declare const earthRadius = 6371008.8;
+/**
+ * A {@link LngLat} object, an array of two numbers representing longitude and latitude,
+ * or an object with `lng` and `lat` or `lon` and `lat` properties.
+ *
+ * @group Geography and Geometry
+ *
+ * @example
+ * ```ts
+ * let v1 = new LngLat(-122.420679, 37.772537);
+ * let v2 = [-122.420679, 37.772537];
+ * let v3 = {lon: -122.420679, lat: 37.772537};
+ * ```
+ */
+export type LngLatLike = LngLat | {
+    lng: number;
+    lat: number;
+} | {
+    lon: number;
+    lat: number;
+} | [number, number];
+/**
+ * A `LngLat` object represents a given longitude and latitude coordinate, measured in degrees.
+ * These coordinates are based on the [WGS84 (EPSG:4326) standard](https://en.wikipedia.org/wiki/World_Geodetic_System#WGS84).
+ *
+ * MapLibre GL JS uses longitude, latitude coordinate order (as opposed to latitude, longitude) to match the
+ * [GeoJSON specification](https://tools.ietf.org/html/rfc7946).
+ *
+ * Note that any MapLibre GL JS method that accepts a `LngLat` object as an argument or option
+ * can also accept an `Array` of two numbers and will perform an implicit conversion.
+ * This flexible type is documented as {@link LngLatLike}.
+ *
+ * @group Geography and Geometry
+ *
+ * @example
+ * ```ts
+ * let ll = new LngLat(-123.9749, 40.7736);
+ * ll.lng; // = -123.9749
+ * ```
+ * @see [Get coordinates of the mouse pointer](https://maplibre.org/maplibre-gl-js/docs/examples/mouse-position/)
+ * @see [Display a popup](https://maplibre.org/maplibre-gl-js/docs/examples/popup/)
+ * @see [Create a timeline animation](https://maplibre.org/maplibre-gl-js/docs/examples/timeline-animation/)
+ */
+export declare class LngLat {
+    lng: number;
+    lat: number;
+    /**
+     * @param lng - Longitude, measured in degrees.
+     * @param lat - Latitude, measured in degrees.
+     */
+    constructor(lng: number, lat: number);
+    /**
+     * Returns a new `LngLat` object whose longitude is wrapped to the range (-180, 180).
+     *
+     * @returns The wrapped `LngLat` object.
+     * @example
+     * ```ts
+     * let ll = new LngLat(286.0251, 40.7736);
+     * let wrapped = ll.wrap();
+     * wrapped.lng; // = -73.9749
+     * ```
+     */
+    wrap(): LngLat;
+    /**
+     * Returns the coordinates represented as an array of two numbers.
+     *
+     * @returns The coordinates represented as an array of longitude and latitude.
+     * @example
+     * ```ts
+     * let ll = new LngLat(-73.9749, 40.7736);
+     * ll.toArray(); // = [-73.9749, 40.7736]
+     * ```
+     */
+    toArray(): [number, number];
+    /**
+     * Returns the coordinates represent as a string.
+     *
+     * @returns The coordinates represented as a string of the format `'LngLat(lng, lat)'`.
+     * @example
+     * ```ts
+     * let ll = new LngLat(-73.9749, 40.7736);
+     * ll.toString(); // = "LngLat(-73.9749, 40.7736)"
+     * ```
+     */
+    toString(): string;
+    /**
+     * Returns the approximate distance between a pair of coordinates in meters
+     * Uses the Haversine Formula (from R.W. Sinnott, "Virtues of the Haversine", Sky and Telescope, vol. 68, no. 2, 1984, p. 159)
+     *
+     * @param lngLat - coordinates to compute the distance to
+     * @returns Distance in meters between the two coordinates.
+     * @example
+     * ```ts
+     * let new_york = new LngLat(-74.0060, 40.7128);
+     * let los_angeles = new LngLat(-118.2437, 34.0522);
+     * new_york.distanceTo(los_angeles); // = 3935751.690893987, "true distance" using a non-spherical approximation is ~3966km
+     * ```
+     */
+    distanceTo(lngLat: LngLat): number;
+    /**
+     * Converts an array of two numbers or an object with `lng` and `lat` or `lon` and `lat` properties
+     * to a `LngLat` object.
+     *
+     * If a `LngLat` object is passed in, the function returns it unchanged.
+     *
+     * @param input - An array of two numbers or object to convert, or a `LngLat` object to return.
+     * @returns A new `LngLat` object, if a conversion occurred, or the original `LngLat` object.
+     * @example
+     * ```ts
+     * let arr = [-73.9749, 40.7736];
+     * let ll = LngLat.convert(arr);
+     * ll;   // = LngLat {lng: -73.9749, lat: 40.7736}
+     * ```
+     */
+    static convert(input: LngLatLike): LngLat;
+}