@mapgis/mapbox-gl 16.0.1 → 16.2.0

package/src/data/segment.js

@@ -1,76 +0,0 @@
-// @flow
-
-import {warnOnce} from '../util/util';
-
-import {register} from '../util/web_worker_transfer';
-
-import type VertexArrayObject from '../render/vertex_array_object';
-import type {StructArray} from '../util/struct_array';
-
-export type Segment = {
-    sortKey: number | void,
-    vertexOffset: number,
-    primitiveOffset: number,
-    vertexLength: number,
-    primitiveLength: number,
-    vaos: {[_: string]: VertexArrayObject}
-}
-
-class SegmentVector {
-    static MAX_VERTEX_ARRAY_LENGTH: number;
-    segments: Array<Segment>;
-
-    constructor(segments?: Array<Segment> = []) {
-        this.segments = segments;
-    }
-
-    prepareSegment(numVertices: number, layoutVertexArray: StructArray, indexArray: StructArray, sortKey?: number): Segment {
-        let segment: Segment = this.segments[this.segments.length - 1];
-        if (numVertices > SegmentVector.MAX_VERTEX_ARRAY_LENGTH) warnOnce(`Max vertices per segment is ${SegmentVector.MAX_VERTEX_ARRAY_LENGTH}: bucket requested ${numVertices}`);
-        if (!segment || segment.vertexLength + numVertices > SegmentVector.MAX_VERTEX_ARRAY_LENGTH || segment.sortKey !== sortKey) {
-            segment = ({
-                vertexOffset: layoutVertexArray.length,
-                primitiveOffset: indexArray.length,
-                vertexLength: 0,
-                primitiveLength: 0
-            }: any);
-            if (sortKey !== undefined) segment.sortKey = sortKey;
-            this.segments.push(segment);
-        }
-        return segment;
-    }
-
-    get() {
-        return this.segments;
-    }
-
-    destroy() {
-        for (const segment of this.segments) {
-            for (const k in segment.vaos) {
-                segment.vaos[k].destroy();
-            }
-        }
-    }
-
-    static simpleSegment(vertexOffset: number, primitiveOffset: number, vertexLength: number, primitiveLength: number): SegmentVector {
-        return new SegmentVector([{
-            vertexOffset,
-            primitiveOffset,
-            vertexLength,
-            primitiveLength,
-            vaos: {},
-            sortKey: 0
-        }]);
-    }
-}
-
-/*
- * The maximum size of a vertex array. This limit is imposed by WebGL's 16 bit
- * addressing of vertex buffers.
- * @private
- * @readonly
- */
-SegmentVector.MAX_VERTEX_ARRAY_LENGTH = Math.pow(2, 16) - 1;
-
-register('SegmentVector', SegmentVector);
-export default SegmentVector;

package/src/geo/edge_insets.js

@@ -1,102 +0,0 @@
-// @flow
-import {number} from "../style-spec/util/interpolate";
-import Point  from "@mapbox/point-geometry";
-import {clamp} from "../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]
- */
-class EdgeInsets {
-    top: number;
-    bottom: number;
-    left: number;
-    right: number;
-
-    constructor(top: number = 0, bottom: number = 0, left: number = 0, right: number = 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 {PaddingOptions} target
-     * @param {number} t
-     * @returns {EdgeInsets}
-     * @memberof EdgeInsets
-     */
-    interpolate(start: PaddingOptions | EdgeInsets, target: PaddingOptions, t: number): EdgeInsets {
-        if (target.top != null && start.top != null) this.top = number(start.top, target.top, t);
-        if (target.bottom != null && start.bottom != null) this.bottom = number(start.bottom, target.bottom, t);
-        if (target.left != null && start.left != null) this.left = number(start.left, target.left, t);
-        if (target.right != null && start.right != null) this.right = 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 {number} width
-     * @param {number} height
-     * @returns {Point}
-     * @memberof EdgeInsets
-     */
-    getCenter(width: number, height: number): Point {
-        // Clamp insets so they never overflow width/height and always calculate a valid center
-        const x = clamp((this.left + width - this.right) / 2, 0, width);
-        const y = clamp((this.top + height - this.bottom) / 2, 0, height);
-
-        return new Point(x, y);
-    }
-
-    equals(other: PaddingOptions): boolean {
-        return this.top === other.top &&
-            this.bottom === other.bottom &&
-            this.left === other.left &&
-            this.right === other.right;
-    }
-
-    clone(): EdgeInsets {
-        return new EdgeInsets(this.top, this.bottom, this.left, this.right);
-    }
-
-    /**
-     * Returns the current sdtate as json, useful when you want to have a
-     * read-only representation of the inset.
-     *
-     * @returns {PaddingOptions}
-     * @memberof EdgeInsets
-     */
-    toJSON(): PaddingOptions {
-        return {
-            top: this.top,
-            bottom: this.bottom,
-            left: this.left,
-            right: this.right
-        };
-    }
-}
-
-export type PaddingOptions = {top: ?number, bottom: ?number, right: ?number, left: ?number};
-
-export default EdgeInsets;

package/src/geo/lng_lat.js

@@ -1,165 +0,0 @@
-// @flow
-
-import {wrap} from '../util/util';
-import LngLatBounds from './lng_lat_bounds';
-
-/*
-* 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
-*/
-export const earthRadius = 6371008.8;
-
-/**
- * A `LngLat` object represents a given longitude and latitude coordinate, measured in degrees.
- *
- * Mapbox GL uses longitude, latitude coordinate order (as opposed to latitude, longitude) to match GeoJSON.
- *
- * Note that any Mapbox GL 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}.
- *
- * @param {number} lng Longitude, measured in degrees.
- * @param {number} lat Latitude, measured in degrees.
- * @example
- * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);
- * @see [Get coordinates of the mouse pointer](https://www.mapbox.com/mapbox-gl-js/example/mouse-position/)
- * @see [Display a popup](https://www.mapbox.com/mapbox-gl-js/example/popup/)
- * @see [Highlight features within a bounding box](https://www.mapbox.com/mapbox-gl-js/example/using-box-queryrenderedfeatures/)
- * @see [Create a timeline animation](https://www.mapbox.com/mapbox-gl-js/example/timeline-animation/)
- */
-class LngLat {
-    lng: number;
-    lat: number;
-
-    constructor(lng: number, lat: number) {
-        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 {LngLat} The wrapped `LngLat` object.
-     * @example
-     * var ll = new mapboxgl.LngLat(286.0251, 40.7736);
-     * var wrapped = ll.wrap();
-     * wrapped.lng; // = -73.9749
-     */
-    wrap() {
-        return new LngLat(wrap(this.lng, -180, 180), this.lat);
-    }
-
-    /**
-     * Returns the coordinates represented as an array of two numbers.
-     *
-     * @returns {Array<number>} The coordinates represeted as an array of longitude and latitude.
-     * @example
-     * var ll = new mapboxgl.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 {string} The coordinates represented as a string of the format `'LngLat(lng, lat)'`.
-     * @example
-     * var ll = new mapboxgl.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} lngLat coordinates to compute the distance to
-     * @returns {number} Distance in meters between the two coordinates.
-     * @example
-     * var new_york = new mapboxgl.LngLat(-74.0060, 40.7128);
-     * var los_angeles = new mapboxgl.LngLat(-118.2437, 34.0522);
-     * new_york.distanceTo(los_angeles); // = 3935751.690893987, "true distance" using a non-spherical approximation is ~3966km
-     */
-    distanceTo(lngLat: 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;
-    }
-
-    /**
-     * Returns a `LngLatBounds` from the coordinates extended by a given `radius`. The returned `LngLatBounds` completely contains the `radius`.
-     *
-     * @param {number} [radius=0] Distance in meters from the coordinates to extend the bounds.
-     * @returns {LngLatBounds} A new `LngLatBounds` object representing the coordinates extended by the `radius`.
-     * @example
-     * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);
-     * ll.toBounds(100).toArray(); // = [[-73.97501862141328, 40.77351016847229], [-73.97478137858673, 40.77368983152771]]
-     */
-    toBounds(radius?: number = 0) {
-        const earthCircumferenceInMetersAtEquator = 40075017;
-        const latAccuracy = 360 * radius / earthCircumferenceInMetersAtEquator,
-            lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
-
-        return new LngLatBounds(new LngLat(this.lng - lngAccuracy, this.lat - latAccuracy),
-            new LngLat(this.lng + lngAccuracy, this.lat + latAccuracy));
-    }
-
-    /**
-     * 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 {LngLatLike} input An array of two numbers or object to convert, or a `LngLat` object to return.
-     * @returns {LngLat} A new `LngLat` object, if a conversion occurred, or the original `LngLat` object.
-     * @example
-     * var arr = [-73.9749, 40.7736];
-     * var ll = mapboxgl.LngLat.convert(arr);
-     * ll;   // = LngLat {lng: -73.9749, lat: 40.7736}
-     */
-    static convert(input: LngLatLike): LngLat {
-        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: any).lng : (input: any).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>]");
-    }
-}
-
-/**
- * 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.
- *
- * @typedef {LngLat | {lng: number, lat: number} | {lon: number, lat: number} | [number, number]} LngLatLike
- * @example
- * var v1 = new mapboxgl.LngLat(-122.420679, 37.772537);
- * var v2 = [-122.420679, 37.772537];
- * var v3 = {lon: -122.420679, lat: 37.772537};
- */
-export type LngLatLike = LngLat | {lng: number, lat: number} | {lon: number, lat: number} | [number, number];
-
-export default LngLat;

package/src/geo/lng_lat_bounds.js

@@ -1,267 +0,0 @@
-// @flow
-
-import LngLat from './lng_lat';
-
-import type {LngLatLike} from './lng_lat';
-
-/**
- * A `LngLatBounds` object represents a geographical bounding box,
- * defined by its southwest and northeast points in longitude and latitude.
- *
- * If no arguments are provided to the constructor, a `null` bounding box is created.
- *
- * Note that any Mapbox GL method that accepts a `LngLatBounds` object as an argument or option
- * can also accept an `Array` of two {@link LngLatLike} constructs and will perform an implicit conversion.
- * This flexible type is documented as {@link LngLatBoundsLike}.
- *
- * @param {LngLatLike} [sw] The southwest corner of the bounding box.
- * @param {LngLatLike} [ne] The northeast corner of the bounding box.
- * @example
- * var sw = new mapboxgl.LngLat(-73.9876, 40.7661);
- * var ne = new mapboxgl.LngLat(-73.9397, 40.8002);
- * var llb = new mapboxgl.LngLatBounds(sw, ne);
- */
-class LngLatBounds {
-    _ne: LngLat;
-    _sw: LngLat;
-
-    // This constructor is too flexible to type. It should not be so flexible.
-    constructor(sw: any, ne: any) {
-        if (!sw) {
-            // noop
-        } else if (ne) {
-            this.setSouthWest(sw).setNorthEast(ne);
-        } else if (sw.length === 4) {
-            this.setSouthWest([sw[0], sw[1]]).setNorthEast([sw[2], sw[3]]);
-        } else {
-            this.setSouthWest(sw[0]).setNorthEast(sw[1]);
-        }
-    }
-
-    /**
-     * Set the northeast corner of the bounding box
-     *
-     * @param {LngLatLike} ne a {@link LngLatLike} object describing the northeast corner of the bounding box.
-     * @returns {LngLatBounds} `this`
-     */
-    setNorthEast(ne: LngLatLike) {
-        this._ne = ne instanceof LngLat ? new LngLat(ne.lng, ne.lat) : LngLat.convert(ne);
-        return this;
-    }
-
-    /**
-     * Set the southwest corner of the bounding box
-     *
-     * @param {LngLatLike} sw a {@link LngLatLike} object describing the southwest corner of the bounding box.
-     * @returns {LngLatBounds} `this`
-     */
-    setSouthWest(sw: LngLatLike) {
-        this._sw = sw instanceof LngLat ? new LngLat(sw.lng, sw.lat) : LngLat.convert(sw);
-        return this;
-    }
-
-    /**
-     * Extend the bounds to include a given LngLatLike or LngLatBoundsLike.
-     *
-     * @param {LngLatLike|LngLatBoundsLike} obj object to extend to
-     * @returns {LngLatBounds} `this`
-     */
-    extend(obj: LngLatLike | LngLatBoundsLike) {
-        const sw = this._sw,
-            ne = this._ne;
-        let sw2, ne2;
-
-        if (obj instanceof LngLat) {
-            sw2 = obj;
-            ne2 = obj;
-
-        } else if (obj instanceof LngLatBounds) {
-            sw2 = obj._sw;
-            ne2 = obj._ne;
-
-            if (!sw2 || !ne2) return this;
-
-        } else {
-            if (Array.isArray(obj)) {
-                if (obj.length === 4 || obj.every(Array.isArray)) {
-                    const lngLatBoundsObj = ((obj: any): LngLatBoundsLike);
-                    return this.extend(LngLatBounds.convert(lngLatBoundsObj));
-                } else {
-                    const lngLatObj = ((obj: any): LngLatLike);
-                    return this.extend(LngLat.convert(lngLatObj));
-                }
-            }
-            return this;
-        }
-
-        if (!sw && !ne) {
-            this._sw = new LngLat(sw2.lng, sw2.lat);
-            this._ne = new LngLat(ne2.lng, ne2.lat);
-
-        } else {
-            sw.lng = Math.min(sw2.lng, sw.lng);
-            sw.lat = Math.min(sw2.lat, sw.lat);
-            ne.lng = Math.max(ne2.lng, ne.lng);
-            ne.lat = Math.max(ne2.lat, ne.lat);
-        }
-
-        return this;
-    }
-
-    /**
-     * Returns the geographical coordinate equidistant from the bounding box's corners.
-     *
-     * @returns {LngLat} The bounding box's center.
-     * @example
-     * var llb = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
-     * llb.getCenter(); // = LngLat {lng: -73.96365, lat: 40.78315}
-     */
-    getCenter(): LngLat {
-        return new LngLat((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);
-    }
-
-    /**
-     * Returns the southwest corner of the bounding box.
-     *
-     * @returns {LngLat} The southwest corner of the bounding box.
-     */
-    getSouthWest(): LngLat { return this._sw; }
-
-    /**
-    * Returns the northeast corner of the bounding box.
-    *
-    * @returns {LngLat} The northeast corner of the bounding box.
-     */
-    getNorthEast(): LngLat { return this._ne; }
-
-    /**
-    * Returns the northwest corner of the bounding box.
-    *
-    * @returns {LngLat} The northwest corner of the bounding box.
-     */
-    getNorthWest(): LngLat { return new LngLat(this.getWest(), this.getNorth()); }
-
-    /**
-    * Returns the southeast corner of the bounding box.
-    *
-    * @returns {LngLat} The southeast corner of the bounding box.
-     */
-    getSouthEast(): LngLat { return new LngLat(this.getEast(), this.getSouth()); }
-
-    /**
-    * Returns the west edge of the bounding box.
-    *
-    * @returns {number} The west edge of the bounding box.
-     */
-    getWest(): number { return this._sw.lng; }
-
-    /**
-    * Returns the south edge of the bounding box.
-    *
-    * @returns {number} The south edge of the bounding box.
-     */
-    getSouth(): number { return this._sw.lat; }
-
-    /**
-    * Returns the east edge of the bounding box.
-    *
-    * @returns {number} The east edge of the bounding box.
-     */
-    getEast(): number { return this._ne.lng; }
-
-    /**
-    * Returns the north edge of the bounding box.
-    *
-    * @returns {number} The north edge of the bounding box.
-     */
-    getNorth(): number { return this._ne.lat; }
-
-    /**
-     * Returns the bounding box represented as an array.
-     *
-     * @returns {Array<Array<number>>} The bounding box represented as an array, consisting of the
-     *   southwest and northeast coordinates of the bounding represented as arrays of numbers.
-     * @example
-     * var llb = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
-     * llb.toArray(); // = [[-73.9876, 40.7661], [-73.9397, 40.8002]]
-     */
-    toArray() {
-        return [this._sw.toArray(), this._ne.toArray()];
-    }
-
-    /**
-     * Return the bounding box represented as a string.
-     *
-     * @returns {string} The bounding box represents as a string of the format
-     *   `'LngLatBounds(LngLat(lng, lat), LngLat(lng, lat))'`.
-     * @example
-     * var llb = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
-     * llb.toString(); // = "LngLatBounds(LngLat(-73.9876, 40.7661), LngLat(-73.9397, 40.8002))"
-     */
-    toString() {
-        return `LngLatBounds(${this._sw.toString()}, ${this._ne.toString()})`;
-    }
-
-    /**
-     * Check if the bounding box is an empty/`null`-type box.
-     *
-     * @returns {boolean} True if bounds have been defined, otherwise false.
-     */
-    isEmpty() {
-        return !(this._sw && this._ne);
-    }
-
-    /**
-    * Check if the point is within the bounding box.
-    *
-    * @param {LngLatLike} lnglat geographic point to check against.
-    * @returns {boolean} True if the point is within the bounding box.
-    */
-    contains(lnglat: LngLatLike) {
-        const {lng, lat} = LngLat.convert(lnglat);
-
-        const containsLatitude = this._sw.lat <= lat && lat <= this._ne.lat;
-        let containsLongitude = this._sw.lng <= lng && lng <= this._ne.lng;
-        if (this._sw.lng > this._ne.lng) { // wrapped coordinates
-            containsLongitude = this._sw.lng >= lng && lng >= this._ne.lng;
-        }
-
-        return containsLatitude && containsLongitude;
-    }
-
-    /**
-     * Converts an array to a `LngLatBounds` object.
-     *
-     * If a `LngLatBounds` object is passed in, the function returns it unchanged.
-     *
-     * Internally, the function calls `LngLat#convert` to convert arrays to `LngLat` values.
-     *
-     * @param {LngLatBoundsLike} input An array of two coordinates to convert, or a `LngLatBounds` object to return.
-     * @returns {LngLatBounds} A new `LngLatBounds` object, if a conversion occurred, or the original `LngLatBounds` object.
-     * @example
-     * var arr = [[-73.9876, 40.7661], [-73.9397, 40.8002]];
-     * var llb = mapboxgl.LngLatBounds.convert(arr);
-     * llb;   // = LngLatBounds {_sw: LngLat {lng: -73.9876, lat: 40.7661}, _ne: LngLat {lng: -73.9397, lat: 40.8002}}
-     */
-    static convert(input: LngLatBoundsLike): LngLatBounds {
-        if (!input || input instanceof LngLatBounds) return input;
-        return new LngLatBounds(input);
-    }
-}
-
-/**
- * A {@link LngLatBounds} object, an array of {@link LngLatLike} objects in [sw, ne] order,
- * or an array of numbers in [west, south, east, north] order.
- *
- * @typedef {LngLatBounds | [LngLatLike, LngLatLike] | [number, number, number, number]} LngLatBoundsLike
- * @example
- * var v1 = new mapboxgl.LngLatBounds(
- *   new mapboxgl.LngLat(-73.9876, 40.7661),
- *   new mapboxgl.LngLat(-73.9397, 40.8002)
- * );
- * var v2 = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002])
- * var v3 = [[-73.9876, 40.7661], [-73.9397, 40.8002]];
- */
-export type LngLatBoundsLike = LngLatBounds | [LngLatLike, LngLatLike] | [number, number, number, number];
-
-export default LngLatBounds;