@mapwhit/tilerenderer 0.47.1

package/src/data/raster_bounds_attributes.js

@@ -0,0 +1,6 @@
+const { createLayout } = require('../util/struct_array');
+
+module.exports = createLayout([
+  { name: 'a_pos', type: 'Int16', components: 2 },
+  { name: 'a_texture_pos', type: 'Int16', components: 2 }
+]);

package/src/data/segment.js

@@ -0,0 +1,63 @@
+const warn = require('../util/warn');
+
+const { register } = require('../util/web_worker_transfer');
+
+class SegmentVector {
+  constructor(segments = []) {
+    this.segments = segments;
+  }
+
+  prepareSegment(numVertices, layoutVertexArray, indexArray) {
+    let segment = this.segments[this.segments.length - 1];
+    if (numVertices > SegmentVector.MAX_VERTEX_ARRAY_LENGTH)
+      warn.once(
+        `Max vertices per segment is ${SegmentVector.MAX_VERTEX_ARRAY_LENGTH}: bucket requested ${numVertices}`
+      );
+    if (!segment || segment.vertexLength + numVertices > SegmentVector.MAX_VERTEX_ARRAY_LENGTH) {
+      segment = {
+        vertexOffset: layoutVertexArray.length,
+        primitiveOffset: indexArray.length,
+        vertexLength: 0,
+        primitiveLength: 0
+      };
+      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, primitiveOffset, vertexLength, primitiveLength) {
+    return new SegmentVector([
+      {
+        vertexOffset: vertexOffset,
+        primitiveOffset: primitiveOffset,
+        vertexLength: vertexLength,
+        primitiveLength: primitiveLength,
+        vaos: {}
+      }
+    ]);
+  }
+}
+
+/*
+ * 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 = 2 ** 16 - 1;
+
+register('SegmentVector', SegmentVector);
+
+module.exports = SegmentVector;

package/src/geo/coordinate.js

@@ -0,0 +1,78 @@
+/**
+ * A coordinate is a column, row, zoom combination, often used
+ * as the data component of a tile.
+ *
+ * @param {number} column
+ * @param {number} row
+ * @param {number} zoom
+ * @private
+ */
+class Coordinate {
+  constructor(column, row, zoom) {
+    this.column = column;
+    this.row = row;
+    this.zoom = zoom;
+  }
+
+  /**
+   * Create a clone of this coordinate that can be mutated without
+   * changing the original coordinate
+   *
+   * @returns {Coordinate} clone
+   * @private
+   * var coord = new Coordinate(0, 0, 0);
+   * var c2 = coord.clone();
+   * // since coord is cloned, modifying a property of c2 does
+   * // not modify it.
+   * c2.zoom = 2;
+   */
+  clone() {
+    return new Coordinate(this.column, this.row, this.zoom);
+  }
+
+  /**
+   * Zoom this coordinate to a given zoom level. This returns a new
+   * coordinate object, not mutating the old one.
+   *
+   * @param {number} zoom
+   * @returns {Coordinate} zoomed coordinate
+   * @private
+   * @example
+   * var coord = new Coordinate(0, 0, 0);
+   * var c2 = coord.zoomTo(1);
+   * c2 // equals new Coordinate(0, 0, 1);
+   */
+  zoomTo(zoom) {
+    return this.clone()._zoomTo(zoom);
+  }
+
+  /**
+   * Subtract the column and row values of this coordinate from those
+   * of another coordinate. The other coordinat will be zoomed to the
+   * same level as `this` before the subtraction occurs
+   *
+   * @param {Coordinate} c other coordinate
+   * @returns {Coordinate} result
+   * @private
+   */
+  sub(c) {
+    return this.clone()._sub(c);
+  }
+
+  _zoomTo(zoom) {
+    const scale = 2 ** (zoom - this.zoom);
+    this.column *= scale;
+    this.row *= scale;
+    this.zoom = zoom;
+    return this;
+  }
+
+  _sub(c) {
+    c = c.zoomTo(this.zoom);
+    this.column -= c.column;
+    this.row -= c.row;
+    return this;
+  }
+}
+
+module.exports = Coordinate;

package/src/geo/lng_lat.js

@@ -0,0 +1,129 @@
+const { wrap } = require('../util/util');
+
+/**
+ * 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 {
+  constructor(lng, lat) {
+    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 a `LngLatBounds` from the coordinates extended by a given `radius`.
+   *
+   * @param {number} radius 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) {
+    const earthCircumferenceInMetersAtEquator = 40075017;
+    const latAccuracy = (360 * radius) / earthCircumferenceInMetersAtEquator;
+    const lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
+    const LngLatBounds = require('./lng_lat_bounds');
+
+    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 to a `LngLat` object.
+   *
+   * If a `LngLat` object is passed in, the function returns it unchanged.
+   *
+   * @param {LngLatLike} input An array of two numbers 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) {
+    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(Number(input.lng), Number(input.lat));
+    }
+    throw new Error(
+      '`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <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` properties.
+ *
+ * @typedef {LngLat | {lng: number, lat: number} | [number, number]} LngLatLike
+ * @example
+ * var v1 = new mapboxgl.LngLat(-122.420679, 37.772537);
+ * var v2 = [-122.420679, 37.772537];
+ */
+
+module.exports = LngLat;

package/src/geo/lng_lat_bounds.js

@@ -0,0 +1,253 @@
+const LngLat = require('./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 {
+  // This constructor is too flexible to type. It should not be so flexible.
+  constructor(sw, ne) {
+    if (!sw) {
+      return;
+    }
+    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
+   * @returns {LngLatBounds} `this`
+   */
+  setNorthEast(ne) {
+    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
+   * @returns {LngLatBounds} `this`
+   */
+  setSouthWest(sw) {
+    this._sw = sw instanceof LngLat ? new LngLat(sw.lng, sw.lat) : LngLat.convert(sw);
+    return this;
+  }
+
+  /**
+   * Extend the bounds to include a given LngLat or LngLatBounds.
+   *
+   * @param {LngLat|LngLatBounds} obj object to extend to
+   * @returns {LngLatBounds} `this`
+   */
+  extend(obj) {
+    const sw = this._sw;
+    const ne = this._ne;
+    let sw2;
+    let 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.every(Array.isArray)) {
+          return this.extend(LngLatBounds.convert(obj));
+        }
+        return this.extend(LngLat.convert(obj));
+      }
+      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() {
+    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() {
+    return this._sw;
+  }
+
+  /**
+   * Returns the northeast corner of the bounding box.
+   *
+   * @returns {LngLat} The northeast corner of the bounding box.
+   */
+  getNorthEast() {
+    return this._ne;
+  }
+
+  /**
+   * Returns the northwest corner of the bounding box.
+   *
+   * @returns {LngLat} The northwest corner of the bounding box.
+   */
+  getNorthWest() {
+    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() {
+    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() {
+    return this._sw.lng;
+  }
+
+  /**
+   * Returns the south edge of the bounding box.
+   *
+   * @returns {number} The south edge of the bounding box.
+   */
+  getSouth() {
+    return this._sw.lat;
+  }
+
+  /**
+   * Returns the east edge of the bounding box.
+   *
+   * @returns {number} The east edge of the bounding box.
+   */
+  getEast() {
+    return this._ne.lng;
+  }
+
+  /**
+   * Returns the north edge of the bounding box.
+   *
+   * @returns {number} The north edge of the bounding box.
+   */
+  getNorth() {
+    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);
+  }
+
+  /**
+   * 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) {
+    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]];
+ */
+
+module.exports = LngLatBounds;