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

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/geojson-tiler/geojson-tiler.ts

@@ -1,283 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
-
-/* eslint-disable no-console, no-continue */
-
-import type {GeoJSONTile, GeoJSONTileFeature} from './tile';
-
-import {convert} from './convert'; // GeoJSON conversion and preprocessing
-import {clip} from './clip'; // stripe clipping algorithm
-import {wrap} from './wrap'; // date line processing
-import {transformTile} from './transform'; // coordinate transformation
-import {createTile} from './tile'; // final simplified tile generation
-
-/** Options to configure tiling */
-export type GeoJSONTilerOptions = {
-  maxZoom?: number /** max zoom to preserve detail on */;
-  indexMaxZoom?: number /** max zoom in the tile index */;
-  indexMaxPoints?: number /** max number of points per tile in the tile index */;
-  tolerance?: number /** simplification tolerance (higher means simpler) */;
-  extent?: number /** tile extent */;
-  buffer?: number /** tile buffer on each side */;
-  lineMetrics?: boolean /** whether to calculate line metrics */;
-  promoteId?: string /** name of a feature property to be promoted to feature.id */;
-  generateId?: boolean /** whether to generate feature ids. Cannot be used with promoteId */;
-  debug?: number /** logging level (0, 1 or 2) */;
-};
-
-const DEFAULT_OPTIONS: Required<GeoJSONTilerOptions> = {
-  maxZoom: 14, // max zoom to preserve detail on
-  indexMaxZoom: 5, // max zoom in the tile index
-  indexMaxPoints: 100000, // max number of points per tile in the tile index
-  tolerance: 3, // simplification tolerance (higher means simpler)
-  extent: 4096, // tile extent
-  buffer: 64, // tile buffer on each side
-  lineMetrics: false, // whether to calculate line metrics
-  // @ts-expect-error Ensures all these required params have defaults
-  promoteId: undefined, // name of a feature property to be promoted to feature.id
-  generateId: false, // whether to generate feature ids. Cannot be used with promoteId
-  debug: 0 // logging level (0, 1 or 2)
-};
-
-export class GeoJSONTiler {
-  options: Required<GeoJSONTilerOptions>;
-
-  // tiles and tileCoords are part of the public API
-  tiles: Record<string, GeoJSONTile> = {};
-  tileCoords: {x: number; y: number; z: number}[] = [];
-
-  stats: Record<string, number> = {};
-  total: number = 0;
-
-  constructor(data, options?: GeoJSONTilerOptions) {
-    this.options = {...DEFAULT_OPTIONS, ...options};
-    options = this.options;
-
-    const debug = options.debug;
-
-    if (debug) console.time('preprocess data');
-
-    if (this.options.maxZoom < 0 || this.options.maxZoom > 24) {
-      throw new Error('maxZoom should be in the 0-24 range');
-    }
-    if (options.promoteId && this.options.generateId) {
-      throw new Error('promoteId and generateId cannot be used together.');
-    }
-
-    // projects and adds simplification info
-    let features = convert(data, options);
-
-    if (debug) {
-      console.timeEnd('preprocess data');
-      console.log(
-        'index: maxZoom: %d, maxPoints: %d',
-        options.indexMaxZoom,
-        options.indexMaxPoints
-      );
-      console.time('generate tiles');
-    }
-
-    // wraps features (ie extreme west and extreme east)
-    features = wrap(features, this.options);
-
-    // start slicing from the top tile down
-    if (features.length) {
-      this.splitTile(features, 0, 0, 0);
-    }
-
-    if (debug) {
-      if (features.length) {
-        console.log('features: %d, points: %d', this.tiles[0].numFeatures, this.tiles[0].numPoints);
-      }
-      console.timeEnd('generate tiles');
-      console.log('tiles generated:', this.total, JSON.stringify(this.stats));
-    }
-  }
-
-  /**
-   * Get a tile at the specified index
-   * @param z
-   * @param x
-   * @param y
-   * @returns
-   */
-  // eslint-disable-next-line complexity, max-statements
-  getTile(z: number, x: number, y: number): GeoJSONTile | null {
-    // z = +z;
-    // x = +x;
-    // y = +y;
-
-    const {extent, debug} = this.options;
-
-    if (z < 0 || z > 24) {
-      return null;
-    }
-
-    const z2 = 1 << z;
-    x = (x + z2) & (z2 - 1); // wrap tile x coordinate
-
-    const id = toID(z, x, y);
-    if (this.tiles[id]) {
-      return transformTile(this.tiles[id], extent);
-    }
-
-    if (debug > 1) console.log('drilling down to z%d-%d-%d', z, x, y);
-
-    let z0 = z;
-    let x0 = x;
-    let y0 = y;
-    let parent;
-
-    while (!parent && z0 > 0) {
-      z0--;
-      x0 = x0 >> 1;
-      y0 = y0 >> 1;
-      parent = this.tiles[toID(z0, x0, y0)];
-    }
-
-    if (!parent || !parent.source) {
-      return null;
-    }
-
-    // if we found a parent tile containing the original geometry, we can drill down from it
-    if (debug > 1) {
-      console.log('found parent tile z%d-%d-%d', z0, x0, y0);
-      console.time('drilling down');
-    }
-    this.splitTile(parent.source, z0, x0, y0, z, x, y);
-    if (debug > 1) {
-      console.timeEnd('drilling down');
-    }
-
-    return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
-  }
-
-  /**
-   * splits features from a parent tile to sub-tiles.
-   * @param z, x, and y are the coordinates of the parent tile
-   * @param cz, cx, and cy are the coordinates of the target tile
-   *
-   * If no target tile is specified, splitting stops when we reach the maximum
-   * zoom or the number of points is low as specified in the options.
-   */
-  // eslint-disable-next-line max-params, max-statements, complexity
-  splitTile(
-    features: GeoJSONTileFeature[],
-    z: number,
-    x: number,
-    y: number,
-    cz?: number,
-    cx?: number,
-    cy?: number
-  ): void {
-    const stack: any[] = [features, z, x, y];
-    const options = this.options;
-    const debug = options.debug;
-
-    // avoid recursion by using a processing queue
-    while (stack.length) {
-      y = stack.pop();
-      x = stack.pop();
-      z = stack.pop();
-      features = stack.pop();
-
-      const z2 = 1 << z;
-      const id = toID(z, x, y);
-      let tile = this.tiles[id];
-
-      if (!tile) {
-        if (debug > 1) {
-          console.time('creation');
-        }
-
-        tile = this.tiles[id] = createTile(features, z, x, y, options);
-        this.tileCoords.push({z, x, y});
-
-        if (debug) {
-          if (debug > 1) {
-            console.log(
-              'tile z%d-%d-%d (features: %d, points: %d, simplified: %d)',
-              z,
-              x,
-              y,
-              tile.numFeatures,
-              tile.numPoints,
-              tile.numSimplified
-            );
-            console.timeEnd('creation');
-          }
-          const key = `z${z}`;
-          this.stats[key] = (this.stats[key] || 0) + 1;
-          this.total++;
-        }
-      }
-
-      // save reference to original geometry in tile so that we can drill down later if we stop now
-      tile.source = features;
-
-      // if it's the first-pass tiling
-      if (cz === undefined) {
-        // stop tiling if we reached max zoom, or if the tile is too simple
-        if (z === options.indexMaxZoom || tile.numPoints <= options.indexMaxPoints) continue;
-        // if a drilldown to a specific tile
-      } else if (z === options.maxZoom || z === cz) {
-        // stop tiling if we reached base zoom or our target tile zoom
-        continue;
-      } else if (cz !== undefined) {
-        // stop tiling if it's not an ancestor of the target tile
-        const zoomSteps = cz - z;
-        // @ts-expect-error TODO fix the types of cx cy
-        if (x !== cx >> zoomSteps || y !== cy >> zoomSteps) continue;
-      }
-
-      // if we slice further down, no need to keep source geometry
-      tile.source = null;
-
-      if (features.length === 0) continue;
-
-      if (debug > 1) console.time('clipping');
-
-      // values we'll use for clipping
-      const k1 = (0.5 * options.buffer) / options.extent;
-      const k2 = 0.5 - k1;
-      const k3 = 0.5 + k1;
-      const k4 = 1 + k1;
-
-      let tl: GeoJSONTileFeature[] | null = null;
-      let bl: GeoJSONTileFeature[] | null = null;
-      let tr: GeoJSONTileFeature[] | null = null;
-      let br: GeoJSONTileFeature[] | null = null;
-
-      let left = clip(features, z2, x - k1, x + k3, 0, tile.minX, tile.maxX, options);
-      let right = clip(features, z2, x + k2, x + k4, 0, tile.minX, tile.maxX, options);
-
-      // @ts-expect-error - unclear why this is needed?
-      features = null;
-
-      if (left) {
-        tl = clip(left, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, options);
-        bl = clip(left, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, options);
-        left = null;
-      }
-
-      if (right) {
-        tr = clip(right, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, options);
-        br = clip(right, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, options);
-        right = null;
-      }
-
-      if (debug > 1) console.timeEnd('clipping');
-
-      stack.push(tl || [], z + 1, x * 2, y * 2);
-      stack.push(bl || [], z + 1, x * 2, y * 2 + 1);
-      stack.push(tr || [], z + 1, x * 2 + 1, y * 2);
-      stack.push(br || [], z + 1, x * 2 + 1, y * 2 + 1);
-    }
-  }
-}
-
-function toID(z, x, y) {
-  return ((1 << z) * y + x) * 32 + z;
-}

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.