@loaders.gl/mvt 4.2.1 → 4.3.0-alpha.1

package/src/helpers/mapbox-util-functions.ts

@@ -1,82 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright vis.gl contributors
-
-import Protobuf from 'pbf';
-import {MVTMapboxGeometry} from '../lib/types';
-import {VectorTileFeature} from '../lib/mapbox-vector-tile/vector-tile-feature';
-
-/**
- * Classifies an array of rings into polygons with outer rings and holes
- * @param rings
- * @returns polygons
- */
-export function classifyRings(rings: MVTMapboxGeometry) {
-  const len = rings.length;
-
-  if (len <= 1) return [rings];
-
-  const polygons: number[][][] = [];
-  let polygon: number[][] | undefined;
-  let ccw: boolean | undefined;
-
-  for (let i = 0; i < len; i++) {
-    const area = signedArea(rings[i]);
-    if (area === 0) continue; // eslint-disable-line no-continue
-
-    if (ccw === undefined) ccw = area < 0;
-
-    if (ccw === area < 0) {
-      if (polygon) polygons.push(polygon);
-      polygon = [rings[i]];
-    } else if (polygon) polygon.push(rings[i]);
-  }
-  if (polygon) polygons.push(polygon);
-
-  return polygons;
-}
-
-/**
- *
- * @param ring
- * @returns sum
- */
-export function signedArea(ring: number[][]) {
-  let sum = 0;
-  for (let i = 0, j = ring.length - 1, p1: number[], p2: number[]; i < ring.length; j = i++) {
-    p1 = ring[i];
-    p2 = ring[j];
-    sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
-  }
-  return sum;
-}
-
-/**
- *
- * @param tag
- * @param feature
- * @param pbf
- */
-export function readFeature(tag: number, feature?: VectorTileFeature, pbf?: Protobuf): void {
-  if (feature && pbf) {
-    if (tag === 1) feature.id = pbf.readVarint();
-    else if (tag === 2) readTag(pbf, feature);
-    else if (tag === 3) feature.type = pbf.readVarint();
-    else if (tag === 4) feature._geometry = pbf.pos;
-  }
-}
-
-/**
- *
- * @param pbf
- * @param feature
- */
-export function readTag(pbf: Protobuf, feature: VectorTileFeature): void {
-  const end = pbf.readVarint() + pbf.pos;
-
-  while (pbf.pos < end) {
-    const key = feature._keys[pbf.readVarint()];
-    const value = feature._values[pbf.readVarint()];
-    feature.properties[key] = value;
-  }
-}

package/src/lib/binary-vector-tile/vector-tile-feature.ts

@@ -1,203 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright vis.gl contributors
-
-// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
-
-import Protobuf from 'pbf';
-import {FlatFeature, FlatIndexedGeometry, GeojsonGeometryInfo} from '@loaders.gl/schema';
-import {classifyRings, project, readFeature} from '../../helpers/binary-util-functions';
-
-// Reduce GC by reusing variables
-let endPos: number;
-let cmd: number;
-let cmdLen: number;
-let length: number;
-let x: number;
-let y: number;
-let i: number;
-
-export const TEST_EXPORTS = {
-  classifyRings
-};
-
-export class BinaryVectorTileFeature {
-  properties: {[x: string]: string | number | boolean | null};
-  extent: any;
-  type: number;
-  id: number | null;
-  _pbf: Protobuf;
-  _geometry: number;
-  _keys: string[];
-  _values: (string | number | boolean | null)[];
-  _geometryInfo: GeojsonGeometryInfo;
-
-  // eslint-disable-next-line max-params
-  constructor(
-    pbf: Protobuf,
-    end: number,
-    extent: any,
-    keys: string[],
-    values: (string | number | boolean | null)[],
-    geometryInfo: GeojsonGeometryInfo
-  ) {
-    // Public
-    this.properties = {};
-    this.extent = extent;
-    this.type = 0;
-    this.id = null;
-
-    // Private
-    this._pbf = pbf;
-    this._geometry = -1;
-    this._keys = keys;
-    this._values = values;
-    this._geometryInfo = geometryInfo;
-
-    pbf.readFields(readFeature, this, end);
-  }
-
-  // eslint-disable-next-line complexity, max-statements
-  loadGeometry(): FlatIndexedGeometry {
-    const pbf = this._pbf;
-    pbf.pos = this._geometry;
-
-    endPos = pbf.readVarint() + pbf.pos;
-    cmd = 1;
-    length = 0;
-    x = 0;
-    y = 0;
-    i = 0;
-
-    // Note: I attempted to replace the `data` array with a
-    // Float32Array, but performance was worse, both using
-    // `set()` and direct index access. Also, we cannot
-    // know how large the buffer should be, so it would
-    // increase memory usage
-    const indices: number[] = []; // Indices where geometries start
-    const data: number[] = []; // Flat array of coordinate data
-
-    while (pbf.pos < endPos) {
-      if (length <= 0) {
-        cmdLen = pbf.readVarint();
-        cmd = cmdLen & 0x7;
-        length = cmdLen >> 3;
-      }
-
-      length--;
-
-      if (cmd === 1 || cmd === 2) {
-        x += pbf.readSVarint();
-        y += pbf.readSVarint();
-
-        if (cmd === 1) {
-          // New line
-          indices.push(i);
-        }
-        data.push(x, y);
-        i += 2;
-      } else if (cmd === 7) {
-        // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
-        if (i > 0) {
-          const start = indices[indices.length - 1]; // start index of polygon
-          data.push(data[start], data[start + 1]); // closePolygon
-          i += 2;
-        }
-      } else {
-        throw new Error(`unknown command ${cmd}`);
-      }
-    }
-
-    return {data, indices};
-  }
-
-  /**
-   *
-   * @param transform
-   * @returns result
-   */
-  _toBinaryCoordinates(transform) {
-    // Expands the protobuf data to an intermediate Flat GeoJSON
-    // data format, which maps closely to the binary data buffers.
-    // It is similar to GeoJSON, but rather than storing the coordinates
-    // in multidimensional arrays, we have a 1D `data` with all the
-    // coordinates, and then index into this using the `indices`
-    // parameter, e.g.
-    //
-    // geometry: {
-    //   type: 'Point', data: [1,2], indices: [0]
-    // }
-    // geometry: {
-    //   type: 'LineString', data: [1,2,3,4,...], indices: [0]
-    // }
-    // geometry: {
-    //   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
-    // }
-    // Thus the indices member lets us look up the relevant range
-    // from the data array.
-    // The Multi* versions of the above types share the same data
-    // structure, just with multiple elements in the indices array
-    const geom = this.loadGeometry();
-    let geometry;
-
-    // Apply the supplied transformation to data
-    transform(geom.data, this);
-
-    const coordLength = 2;
-
-    // eslint-disable-next-line default-case
-    switch (this.type) {
-      case 1: // Point
-        this._geometryInfo.pointFeaturesCount++;
-        this._geometryInfo.pointPositionsCount += geom.indices.length;
-        geometry = {type: 'Point', ...geom};
-        break;
-
-      case 2: // LineString
-        this._geometryInfo.lineFeaturesCount++;
-        this._geometryInfo.linePathsCount += geom.indices.length;
-        this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
-        geometry = {type: 'LineString', ...geom};
-        break;
-
-      case 3: // Polygon
-        geometry = classifyRings(geom);
-
-        // Unlike Point & LineString geom.indices is a 2D array, thanks
-        // to the classifyRings method
-        this._geometryInfo.polygonFeaturesCount++;
-        this._geometryInfo.polygonObjectsCount += geometry.indices.length;
-
-        for (const indices of geometry.indices) {
-          this._geometryInfo.polygonRingsCount += indices.length;
-        }
-        this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
-
-        break;
-      default:
-        throw new Error(`Invalid geometry type: ${this.type}`);
-    }
-
-    const result: FlatFeature = {type: 'Feature', geometry, properties: this.properties};
-
-    if (this.id !== null) {
-      result.id = this.id;
-    }
-
-    return result;
-  }
-
-  toBinaryCoordinates(
-    options: {x: number; y: number; z: number} | ((data: number[], feature: {extent: any}) => void)
-  ): FlatFeature {
-    if (typeof options === 'function') {
-      return this._toBinaryCoordinates(options);
-    }
-    const {x, y, z} = options;
-    const size = this.extent * Math.pow(2, z);
-    const x0 = this.extent * x;
-    const y0 = this.extent * y;
-
-    return this._toBinaryCoordinates((data: number[]) => project(data, x0, y0, size));
-  }
-}

package/src/lib/binary-vector-tile/vector-tile-layer.ts

@@ -1,113 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright vis.gl contributors
-
-/* eslint-disable indent */
-// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
-
-import {BinaryVectorTileFeature} from './vector-tile-feature';
-import Protobuf from 'pbf';
-import {GeojsonGeometryInfo} from '@loaders.gl/schema';
-
-export class BinaryVectorTileLayer {
-  version: number;
-  name: string;
-  extent: number;
-  length: number;
-  _pbf: Protobuf;
-  _keys: string[];
-  _values: (string | number | boolean | null)[];
-  _features: number[];
-  constructor(pbf: Protobuf, end: number) {
-    // Public
-    this.version = 1;
-    this.name = '';
-    this.extent = 4096;
-    this.length = 0;
-
-    // Private
-    this._pbf = pbf;
-    this._keys = [];
-    this._values = [];
-    this._features = [];
-
-    pbf.readFields(readLayer, this, end);
-
-    this.length = this._features.length;
-  }
-
-  /**
-   * return feature `i` from this layer as a `BinaryVectorTileFeature`
-   *
-   * @param index
-   * @param geometryInfo
-   * @returns {BinaryVectorTileFeature}
-   */
-  feature(i: number, geometryInfo: GeojsonGeometryInfo): BinaryVectorTileFeature {
-    if (i < 0 || i >= this._features.length) {
-      throw new Error('feature index out of bounds');
-    }
-
-    this._pbf.pos = this._features[i];
-
-    const end = this._pbf.readVarint() + this._pbf.pos;
-    return new BinaryVectorTileFeature(
-      this._pbf,
-      end,
-      this.extent,
-      this._keys,
-      this._values,
-      geometryInfo
-    );
-  }
-}
-
-/**
- *
- * @param tag
- * @param layer
- * @param pbf
- */
-function readLayer(tag: number, layer?: BinaryVectorTileLayer, pbf?: Protobuf): void {
-  if (layer && pbf) {
-    if (tag === 15) layer.version = pbf.readVarint();
-    else if (tag === 1) layer.name = pbf.readString();
-    else if (tag === 5) layer.extent = pbf.readVarint();
-    else if (tag === 2) layer._features.push(pbf.pos);
-    else if (tag === 3) layer._keys.push(pbf.readString());
-    else if (tag === 4) layer._values.push(readValueMessage(pbf));
-  }
-}
-
-/**
- *
- * @param pbf
- * @returns value
- */
-function readValueMessage(pbf: Protobuf) {
-  let value: string | number | boolean | null = null;
-  const end = pbf.readVarint() + pbf.pos;
-
-  while (pbf.pos < end) {
-    const tag = pbf.readVarint() >> 3;
-
-    value =
-      tag === 1
-        ? pbf.readString()
-        : tag === 2
-        ? pbf.readFloat()
-        : tag === 3
-        ? pbf.readDouble()
-        : tag === 4
-        ? pbf.readVarint64()
-        : tag === 5
-        ? pbf.readVarint()
-        : tag === 6
-        ? pbf.readSVarint()
-        : tag === 7
-        ? pbf.readBoolean()
-        : null;
-  }
-
-  return value;
-}

package/src/lib/binary-vector-tile/vector-tile.ts

@@ -1,36 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright vis.gl contributors
-
-// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
-
-import {BinaryVectorTileLayer} from './vector-tile-layer';
-import Protobuf from 'pbf';
-
-export class BinaryVectorTile {
-  layers: {[x: string]: BinaryVectorTileLayer};
-  constructor(pbf: Protobuf, end?: number) {
-    this.layers = pbf.readFields(readTile, {}, end);
-  }
-}
-
-/**
- *
- * @param tag
- * @param layers
- * @param pbf
- */
-function readTile(
-  tag: number,
-  layers?: {[x: string]: BinaryVectorTileLayer},
-  pbf?: Protobuf
-): void {
-  if (tag === 3) {
-    if (pbf) {
-      const layer = new BinaryVectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
-      if (layer.length && layers) {
-        layers[layer.name] = layer;
-      }
-    }
-  }
-}

package/src/lib/mapbox-vector-tile/LICENSE.txt

@@ -1,31 +0,0 @@
-This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
-
----
-
-Copyright (c) 2014, Mapbox
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimer in the documentation
-      and/or other materials provided with the distribution.
-    * Neither the name of Mapbox nor the names of its contributors
-      may be used to endorse or promote products derived from this software
-      without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/src/lib/mapbox-vector-tile/vector-tile-feature.ts

@@ -1,207 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright vis.gl contributors
-
-// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
-import Protobuf from 'pbf';
-import {MVTMapboxCoordinates, MVTMapboxGeometry} from '../types';
-import {readFeature, classifyRings} from '../../helpers/mapbox-util-functions';
-
-export class VectorTileFeature {
-  properties: {[x: string]: string | number | boolean | null};
-  extent: any;
-  type: number;
-  id: number | null;
-  _pbf: Protobuf;
-  _geometry: number;
-  _keys: string[];
-  _values: (string | number | boolean | null)[];
-  static get types() {
-    return ['Unknown', 'Point', 'LineString', 'Polygon'];
-  }
-
-  constructor(
-    pbf: Protobuf,
-    end: number,
-    extent: any,
-    keys: string[],
-    values: (string | number | boolean | null)[]
-  ) {
-    // Public
-    this.properties = {};
-    this.extent = extent;
-    this.type = 0;
-    this.id = null;
-
-    // Private
-    this._pbf = pbf;
-    this._geometry = -1;
-    this._keys = keys;
-    this._values = values;
-
-    pbf.readFields(readFeature, this, end);
-  }
-
-  // eslint-disable-next-line complexity, max-statements
-  loadGeometry(): MVTMapboxGeometry {
-    const pbf = this._pbf;
-    pbf.pos = this._geometry;
-
-    const end = pbf.readVarint() + pbf.pos;
-    let cmd = 1;
-    let length = 0;
-    let x = 0;
-    let y = 0;
-    const lines: number[][][] = [];
-    let line: number[][] | undefined;
-
-    while (pbf.pos < end) {
-      if (length <= 0) {
-        const cmdLen = pbf.readVarint();
-        cmd = cmdLen & 0x7;
-        length = cmdLen >> 3;
-      }
-
-      length--;
-
-      if (cmd === 1 || cmd === 2) {
-        x += pbf.readSVarint();
-        y += pbf.readSVarint();
-
-        if (cmd === 1) {
-          // moveTo
-          if (line) lines.push(line);
-          line = [];
-        }
-        if (line) line.push([x, y]);
-      } else if (cmd === 7) {
-        // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
-        if (line) {
-          line.push(line[0].slice()); // closePolygon
-        }
-      } else {
-        throw new Error(`unknown command ${cmd}`);
-      }
-    }
-
-    if (line) lines.push(line);
-
-    return lines;
-  }
-
-  // eslint-disable-next-line max-statements
-  bbox() {
-    const pbf = this._pbf;
-    pbf.pos = this._geometry;
-
-    const end = pbf.readVarint() + pbf.pos;
-    let cmd = 1;
-    let length = 0;
-    let x = 0;
-    let y = 0;
-    let x1 = Infinity;
-    let x2 = -Infinity;
-    let y1 = Infinity;
-    let y2 = -Infinity;
-
-    while (pbf.pos < end) {
-      if (length <= 0) {
-        const cmdLen = pbf.readVarint();
-        cmd = cmdLen & 0x7;
-        length = cmdLen >> 3;
-      }
-
-      length--;
-
-      if (cmd === 1 || cmd === 2) {
-        x += pbf.readSVarint();
-        y += pbf.readSVarint();
-        if (x < x1) x1 = x;
-        if (x > x2) x2 = x;
-        if (y < y1) y1 = y;
-        if (y > y2) y2 = y;
-      } else if (cmd !== 7) {
-        throw new Error(`unknown command ${cmd}`);
-      }
-    }
-
-    return [x1, y1, x2, y2];
-  }
-
-  _toGeoJSON(transform) {
-    let coords = this.loadGeometry();
-    let type = VectorTileFeature.types[this.type];
-    let i: number;
-    let j: number;
-
-    // eslint-disable-next-line default-case
-    switch (this.type) {
-      case 1:
-        const points: number[] = [];
-        for (i = 0; i < coords.length; i++) {
-          points[i] = coords[i][0];
-        }
-        coords = points;
-        transform(coords, this);
-        break;
-
-      case 2:
-        for (i = 0; i < coords.length; i++) {
-          transform(coords[i], this);
-        }
-        break;
-
-      case 3:
-        coords = classifyRings(coords);
-        for (i = 0; i < coords.length; i++) {
-          for (j = 0; j < coords[i].length; j++) {
-            transform(coords[i][j], this);
-          }
-        }
-        break;
-    }
-
-    if (coords.length === 1) {
-      coords = coords[0];
-    } else {
-      type = `Multi${type}`;
-    }
-
-    const result: MVTMapboxCoordinates = {
-      type: 'Feature',
-      geometry: {
-        type,
-        coordinates: coords
-      },
-      properties: this.properties
-    };
-
-    if (this.id !== null) {
-      result.id = this.id;
-    }
-
-    return result;
-  }
-
-  toGeoJSON(
-    options: {x: number; y: number; z: number} | ((data: number[], feature: {extent: any}) => void)
-  ): MVTMapboxCoordinates {
-    if (typeof options === 'function') {
-      return this._toGeoJSON(options);
-    }
-    const {x, y, z} = options;
-    const size = this.extent * Math.pow(2, z);
-    const x0 = this.extent * x;
-    const y0 = this.extent * y;
-
-    function project(line: number[]) {
-      for (let j = 0; j < line.length; j++) {
-        const p = line[j];
-        p[0] = ((p[0] + x0) * 360) / size - 180;
-        const y2 = 180 - ((p[1] + y0) * 360) / size;
-        p[1] = (360 / Math.PI) * Math.atan(Math.exp((y2 * Math.PI) / 180)) - 90;
-      }
-    }
-    return this._toGeoJSON(project);
-  }
-}