@antv/l7-map 2.21.11-beta.5 → 2.21.11-beta.6

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/{geo → map/geo}/edge_insets.js

@@ -4,27 +4,34 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.EdgeInsets = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _util = require("../util");
-var _point = _interopRequireDefault(require("./point"));
-// @ts-ignore
-
+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.
  *
- * @param {number} [top=0]
- * @param {number} [bottom=0]
- * @param {number} [left=0]
- * @param {number} [right=0]
+ * @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');
@@ -38,25 +45,16 @@ class EdgeInsets {
   /**
    * Interpolates the inset in-place.
    * This maintains the current inset value for any inset not present in `target`.
-   *
-   * @param {PaddingOptions} target
-   * @param {number} t
-   * @returns {EdgeInsets}
-   * @memberof EdgeInsets
+   * @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 = (0, _util.interpolate)(start.top, target.top, t);
-    }
-    if (target.bottom != null && start.bottom != null) {
-      this.bottom = (0, _util.interpolate)(start.bottom, target.bottom, t);
-    }
-    if (target.left != null && start.left != null) {
-      this.left = (0, _util.interpolate)(start.left, target.left, t);
-    }
-    if (target.right != null && start.right != null) {
-      this.right = (0, _util.interpolate)(start.right, target.right, 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;
   }
 
@@ -64,16 +62,15 @@ class 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 {number} width
-   * @param {number} height
-   * @returns {Point}
-   * @memberof EdgeInsets
+   * @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 _point.default(x, y);
+    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;
@@ -83,11 +80,10 @@ class EdgeInsets {
   }
 
   /**
-   * Returns the current sdtate as json, useful when you want to have a
+   * Returns the current state as json, useful when you want to have a
    * read-only representation of the inset.
    *
-   * @returns {PaddingOptions}
-   * @memberof EdgeInsets
+   * @returns state as json
    */
   toJSON() {
     return {
@@ -98,4 +94,29 @@ class EdgeInsets {
     };
   }
 }
-exports.default = EdgeInsets;
+
+/**
+ * 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;
+}

package/lib/map/geo/lng_lat.js

@@ -0,0 +1,166 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.earthRadius = exports.LngLat = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _util = require("../util/util");
+/*
+ * Approximate radius of the earth in meters.
+ * Uses the WGS-84 approximation. The radius at the equator is ~6378137 and at the poles is ~6356752. https://en.wikipedia.org/wiki/World_Geodetic_System#WGS84
+ * 6371008.8 is one published "average radius" see https://en.wikipedia.org/wiki/Earth_radius#Mean_radius, or ftp://athena.fsv.cvut.cz/ZFG/grs80-Moritz.pdf p.4
+ */
+const earthRadius = exports.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};
+ * ```
+ */
+
+/**
+ * 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/)
+ */
+class LngLat {
+  /**
+   * @param lng - Longitude, measured in degrees.
+   * @param lat - Latitude, measured in degrees.
+   */
+  constructor(lng, lat) {
+    (0, _defineProperty2.default)(this, "lng", void 0);
+    (0, _defineProperty2.default)(this, "lat", void 0);
+    if (isNaN(lng) || isNaN(lat)) {
+      throw new Error(`Invalid LngLat object: (${lng}, ${lat})`);
+    }
+    this.lng = +lng;
+    this.lat = +lat;
+    if (this.lat > 90 || this.lat < -90) {
+      throw new Error('Invalid LngLat latitude value: must be between -90 and 90');
+    }
+  }
+
+  /**
+   * 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() {
+    return new LngLat((0, _util.wrap)(this.lng, -180, 180), this.lat);
+  }
+
+  /**
+   * 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() {
+    return [this.lng, this.lat];
+  }
+
+  /**
+   * 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() {
+    return `LngLat(${this.lng}, ${this.lat})`;
+  }
+
+  /**
+   * 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) {
+    const rad = Math.PI / 180;
+    const lat1 = this.lat * rad;
+    const lat2 = lngLat.lat * rad;
+    const a = Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) * Math.cos((lngLat.lng - this.lng) * rad);
+    const maxMeters = earthRadius * Math.acos(Math.min(a, 1));
+    return maxMeters;
+  }
+
+  /**
+   * 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) {
+    if (input instanceof LngLat) {
+      return input;
+    }
+    if (Array.isArray(input) && (input.length === 2 || input.length === 3)) {
+      return new LngLat(Number(input[0]), Number(input[1]));
+    }
+    if (!Array.isArray(input) && typeof input === 'object' && input !== null) {
+      return new LngLat(
+      // flow can't refine this to have one of lng or lat, so we have to cast to any
+      Number('lng' in input ? input.lng : input.lon), Number(input.lat));
+    }
+    throw new Error('`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, an object {lon: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]');
+  }
+}
+exports.LngLat = LngLat;