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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/mvt",
   "description": "Loader for Mapbox Vector Tiles",
-  "version": "4.2.1",
+  "version": "4.3.0-alpha.1",
   "license": "MIT",
   "type": "module",
   "publishConfig": {
@@ -41,10 +41,10 @@
     "build-worker": "esbuild src/workers/mvt-worker.ts --bundle --outfile=dist/mvt-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/gis": "4.2.1",
-    "@loaders.gl/images": "4.2.1",
-    "@loaders.gl/loader-utils": "4.2.1",
-    "@loaders.gl/schema": "4.2.1",
+    "@loaders.gl/gis": "4.3.0-alpha.1",
+    "@loaders.gl/images": "4.3.0-alpha.1",
+    "@loaders.gl/loader-utils": "4.3.0-alpha.1",
+    "@loaders.gl/schema": "4.3.0-alpha.1",
     "@math.gl/polygon": "^4.0.0",
     "pbf": "^3.2.1"
   },
@@ -54,5 +54,5 @@
   "peerDependencies": {
     "@loaders.gl/core": "^4.0.0"
   },
-  "gitHead": "b2ea799ff9f233ab8af0a6c3696e28ddf6e3c5a3"
+  "gitHead": "568446ea69eb590f0c42d965459b636216cda74e"
 }

package/src/{lib/geojson-tiler/geojson-tiler.ts → geojson-tile-source.ts}

@@ -1,20 +1,26 @@
 // loaders.gl
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: MIT AND ISC
 // Copyright (c) vis.gl contributors
-// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+// Based on https://github.com/mapbox/geojson-vt under compatible ISC license
 
 /* eslint-disable no-console, no-continue */
 
-import type {GeoJSONTile, GeoJSONTileFeature} from './tile';
+import {
+  VectorTileSource,
+  VectorTileSourceProps,
+  TileLoadParameters
+} from '@loaders.gl/loader-utils';
+import {Feature, GeoJSONTable} from '@loaders.gl/schema';
 
-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
+import type {GeoJSONTile, GeoJSONTileFeature} from './lib/geojsonvt/tile';
+import {convert} from './lib/geojsonvt/convert'; // GeoJSON conversion and preprocessing
+import {clip} from './lib/geojsonvt/clip'; // stripe clipping algorithm
+import {wrap} from './lib/geojsonvt/wrap'; // date line processing
+import {transformTile} from './lib/geojsonvt/transform'; // coordinate transformation
+import {createTile} from './lib/geojsonvt/tile'; // final simplified tile generation
 
 /** Options to configure tiling */
-export type GeoJSONTilerOptions = {
+export type GeoJSONTileSourceOptions = VectorTileSourceProps & {
   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 */;
@@ -27,22 +33,24 @@ export type GeoJSONTilerOptions = {
   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>;
+export class GeoJSONTileSource implements VectorTileSource<any> {
+  static defaultOptions: Required<GeoJSONTileSourceOptions> = {
+    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
+    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)
+  };
+
+  mimeType = 'application/vnd.mapbox-vector-tile';
+
+  options: Required<GeoJSONTileSourceOptions>;
 
   // tiles and tileCoords are part of the public API
   tiles: Record<string, GeoJSONTile> = {};
@@ -51,10 +59,22 @@ export class GeoJSONTiler {
   stats: Record<string, number> = {};
   total: number = 0;
 
-  constructor(data, options?: GeoJSONTilerOptions) {
-    this.options = {...DEFAULT_OPTIONS, ...options};
-    options = this.options;
+  /** Sync methods can be called: the input data promise has been resolved and initial top-level tiling is done */
+  ready: Promise<void>;
+
+  constructor(data: GeoJSONTable | Promise<GeoJSONTable>, options?: GeoJSONTileSourceOptions) {
+    this.options = {...GeoJSONTileSource.defaultOptions, ...options};
+    this.getTileData = this.getTileData.bind(this);
+    this.ready = this.initializeTilesAsync(data);
+  }
+
+  async initializeTilesAsync(dataPromise: GeoJSONTable | Promise<GeoJSONTable>): Promise<void> {
+    const data = await dataPromise;
+    this.initializeTilesSync(data);
+  }
 
+  initializeTilesSync(data: GeoJSONTable): void {
+    const options = this.options;
     const debug = options.debug;
 
     if (debug) console.time('preprocess data');
@@ -96,15 +116,54 @@ export class GeoJSONTiler {
     }
   }
 
+  async getMetadata(): Promise<unknown> {
+    return {};
+  }
+
   /**
    * Get a tile at the specified index
-   * @param z
-   * @param x
-   * @param y
+   * @param tileIndex z, x, y of tile
    * @returns
    */
+  async getVectorTile(tileIndex: {z: number; x: number; y: number}): Promise<GeoJSONTable | null> {
+    await this.ready;
+    const table = this.getTileSync(tileIndex);
+    return table;
+  }
+
+  async getTile(tileIndex: {z: number; x: number; y: number}): Promise<GeoJSONTable | null> {
+    await this.ready;
+    return this.getTileSync(tileIndex);
+  }
+
+  async getTileData(tileParams: TileLoadParameters): Promise<unknown | null> {
+    const {x, y, z} = tileParams.index;
+    return await this.getVectorTile({x, y, z});
+  }
+
+  // Implementation
+
+  /**
+   * Synchronously request a tile
+   * @note Application must await `source.ready` before calling sync methods.
+   */
+  getTileSync(tileIndex: {z: number; x: number; y: number}): GeoJSONTable | null {
+    const rawTile = this.getRawTile(tileIndex);
+    if (!rawTile) {
+      return null;
+    }
+
+    return convertToGeoJSONTable(rawTile, this.options.extent);
+  }
+
+  /**
+   * Return geojsonvt-style "half formed" vector tile
+   * @note Application must await `source.ready` before calling sync methods.
+   */
   // eslint-disable-next-line complexity, max-statements
-  getTile(z: number, x: number, y: number): GeoJSONTile | null {
+  getRawTile(tileIndex: {z: number; x: number; y: number}): GeoJSONTile | null {
+    const {z, y} = tileIndex;
+    let {x} = tileIndex;
     // z = +z;
     // x = +x;
     // y = +y;
@@ -278,6 +337,86 @@ export class GeoJSONTiler {
   }
 }
 
-function toID(z, x, y) {
+function toID(z, x, y): number {
   return ((1 << z) * y + x) * 32 + z;
 }
+
+function convertToGeoJSONTable(vtTile: GeoJSONTile, extent: number): GeoJSONTable {
+  const features: Feature[] = [];
+  for (const rawFeature of vtTile.features) {
+    if (!rawFeature || !rawFeature.geometry) {
+      continue;
+    }
+
+    let type:
+      | 'Point'
+      | 'MultiPoint'
+      | 'LineString'
+      | 'MultiLineString'
+      | 'Polygon'
+      | 'MultiPolygon';
+
+    let coordinates: any;
+
+    // raw geometry
+    switch (rawFeature.type) {
+      case 1:
+        if (rawFeature.geometry.length === 1) {
+          type = 'Point';
+          coordinates = rawFeature.geometry[0];
+        } else {
+          type = 'MultiPoint';
+          coordinates = rawFeature.geometry;
+        }
+        break;
+      case 2:
+        if (rawFeature.geometry.length === 1) {
+          type = 'LineString';
+          coordinates = rawFeature.geometry[0];
+        } else {
+          type = 'MultiLineString';
+          coordinates = rawFeature.geometry;
+        }
+        break;
+      case 3:
+        if (rawFeature.geometry.length > 1) {
+          type = 'MultiPolygon';
+          coordinates = [rawFeature.geometry];
+        } else {
+          type = 'Polygon';
+          coordinates = rawFeature.geometry;
+        }
+        break;
+      default:
+        continue;
+    }
+
+    coordinates = toLngLat(coordinates, extent);
+
+    const feature: Feature = {
+      type: 'Feature',
+      geometry: {
+        type,
+        coordinates
+      },
+      properties: rawFeature.tags || {}
+    };
+
+    features.push(feature);
+  }
+
+  const table: GeoJSONTable = {
+    shape: 'geojson-table',
+    type: 'FeatureCollection',
+    features
+  };
+
+  return table;
+}
+
+function toLngLat(coords: any, extent: number): any {
+  if (Array.isArray(coords[0])) {
+    return coords.map((c) => toLngLat(c, extent));
+  }
+  return [coords[0] / extent, coords[1] / extent];
+}

package/src/index.ts

@@ -11,7 +11,7 @@ export {TileJSONLoader} from './tilejson-loader';
 
 export {MVTSource} from './mvt-source';
 
-// GeoJSONTiler
+// GeoJSONTileSource
 
-export type {GeoJSONTilerOptions} from './lib/geojson-tiler/geojson-tiler';
-export {GeoJSONTiler} from './lib/geojson-tiler/geojson-tiler';
+export type {GeoJSONTileSourceOptions} from './geojson-tile-source';
+export {GeoJSONTileSource} from './geojson-tile-source';

package/src/lib/{geojson-tiler → geojsonvt}/convert.ts

@@ -6,7 +6,7 @@
 /* eslint-disable */
 // @ts-nocheck
 
-import type {Feature} from '@loaders.gl/schema';
+import type {Feature, FeatureCollection} from '@loaders.gl/schema';
 import type {GeoJSONTileFeature} from './tile';
 
 import {simplify} from './simplify';
@@ -14,7 +14,7 @@ import {createFeature} from './feature';
 
 // converts GeoJSON feature into an intermediate projected JSON vector format with simplification data
 
-export function convert(data: Feature, options): GeoJSONTileFeature[] {
+export function convert(data: Feature | FeatureCollection, options): GeoJSONTileFeature[] {
   const features = [];
   if (data.type === 'FeatureCollection') {
     for (let i = 0; i < data.features.length; i++) {

package/src/lib/{geojson-tiler → geojsonvt}/tile.ts

@@ -127,8 +127,8 @@ function addFeature(tile: GeoJSONTile, feature, tolerance: number, options: Crea
         type === 'Polygon' || type === 'MultiPolygon'
           ? 3
           : type === 'LineString' || type === 'MultiLineString'
-            ? 2
-            : 1,
+          ? 2
+          : 1,
       tags
     };
     if (feature.id !== null) {

package/src/lib/parse-mvt.ts

@@ -2,23 +2,17 @@
 // SPDX-License-Identifier: MIT
 // Copyright vis.gl contributors
 
+import type {FlatFeature, Feature, GeojsonGeometryInfo} from '@loaders.gl/schema';
+import type {GeoJSONTable, BinaryFeatureCollection} from '@loaders.gl/schema';
 import {flatGeojsonToBinary} from '@loaders.gl/gis';
-import type {
-  FlatFeature,
-  Feature,
-  GeojsonGeometryInfo,
-  BinaryFeatureCollection,
-  GeoJSONTable
-} from '@loaders.gl/schema';
+import {log} from '@loaders.gl/loader-utils';
 import Protobuf from 'pbf';
 
-import type {MVTMapboxCoordinates, MVTOptions} from '../lib/types';
-import type {MVTLoaderOptions} from '../mvt-loader';
+import {VectorTile} from './vector-tile/vector-tile';
+import {VectorTileFeature} from './vector-tile/vector-tile-feature';
 
-import {VectorTile} from './mapbox-vector-tile/vector-tile';
-import {BinaryVectorTile} from './binary-vector-tile/vector-tile';
-import {BinaryVectorTileFeature} from './binary-vector-tile/vector-tile-feature';
-import {VectorTileFeature as VectorTileFeatureMapBox} from './mapbox-vector-tile/vector-tile-feature';
+import type {MVTLoaderOptions} from '../mvt-loader';
+type MVTOptions = Required<MVTLoaderOptions>['mvt'];
 
 /**
  * Parse MVT arrayBuffer and return GeoJSON.
@@ -28,7 +22,7 @@ import {VectorTileFeature as VectorTileFeatureMapBox} from './mapbox-vector-tile
  * @returns A GeoJSON geometry object or a binary representation
  */
 export function parseMVT(arrayBuffer: ArrayBuffer, options?: MVTLoaderOptions) {
-  const mvtOptions = normalizeOptions(options);
+  const mvtOptions = checkOptions(options);
 
   const shape: string | undefined =
     options?.gis?.format || options?.mvt?.shape || (options?.shape as string);
@@ -87,7 +81,7 @@ function parseToFlatGeoJson(
     return [features, geometryInfo];
   }
 
-  const tile = new BinaryVectorTile(new Protobuf(arrayBuffer));
+  const tile = new VectorTile(new Protobuf(arrayBuffer));
 
   const selectedLayers =
     options && Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
@@ -99,7 +93,7 @@ function parseToFlatGeoJson(
     }
 
     for (let i = 0; i < vectorTileLayer.length; i++) {
-      const vectorTileFeature = vectorTileLayer.feature(i, geometryInfo);
+      const vectorTileFeature = vectorTileLayer.getBinaryFeature(i, geometryInfo);
       const decodedFeature = getDecodedFeatureBinary(vectorTileFeature, options, layerName);
       features.push(decodedFeature);
     }
@@ -113,7 +107,7 @@ function parseToGeojsonFeatures(arrayBuffer: ArrayBuffer, options: MVTOptions):
     return [];
   }
 
-  const features: MVTMapboxCoordinates[] = [];
+  const features: Feature[] = [];
   const tile = new VectorTile(new Protobuf(arrayBuffer));
 
   const selectedLayers = Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
@@ -125,33 +119,29 @@ function parseToGeojsonFeatures(arrayBuffer: ArrayBuffer, options: MVTOptions):
     }
 
     for (let i = 0; i < vectorTileLayer.length; i++) {
-      const vectorTileFeature = vectorTileLayer.feature(i);
+      const vectorTileFeature = vectorTileLayer.getGeoJSONFeature(i);
       const decodedFeature = getDecodedFeature(vectorTileFeature, options, layerName);
       features.push(decodedFeature);
     }
   });
 
-  return features as Feature[];
+  return features;
 }
 
-function normalizeOptions(options?: MVTLoaderOptions): MVTOptions {
+/** Check that options are good */
+function checkOptions(options?: MVTLoaderOptions): MVTOptions {
   if (!options?.mvt) {
     throw new Error('mvt options required');
   }
 
-  // Validate
-  const wgs84Coordinates = options.mvt?.coordinates === 'wgs84';
-  const {tileIndex} = options.mvt;
-  const hasTileIndex =
-    tileIndex &&
-    Number.isFinite(tileIndex.x) &&
-    Number.isFinite(tileIndex.y) &&
-    Number.isFinite(tileIndex.z);
-
-  if (wgs84Coordinates && !hasTileIndex) {
+  if (options.mvt?.coordinates === 'wgs84' && !options.mvt.tileIndex) {
     throw new Error('MVT Loader: WGS84 coordinates need tileIndex property');
   }
 
+  if (options.gis) {
+    log.warn('MVTLoader: "options.gis" is deprecated, use "options.mvt.shape" instead')();
+  }
+
   return options.mvt;
 }
 
@@ -161,10 +151,10 @@ function normalizeOptions(options?: MVTLoaderOptions): MVTOptions {
  * @returns decoded feature
  */
 function getDecodedFeature(
-  feature: VectorTileFeatureMapBox,
+  feature: VectorTileFeature,
   options: MVTOptions,
   layerName: string
-): MVTMapboxCoordinates {
+): Feature {
   const decodedFeature = feature.toGeoJSON(
     // @ts-expect-error What is going on here?
     options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinates
@@ -172,6 +162,7 @@ function getDecodedFeature(
 
   // Add layer name to GeoJSON properties
   if (options.layerProperty) {
+    decodedFeature.properties ||= {};
     decodedFeature.properties[options.layerProperty] = layerName;
   }
 
@@ -184,7 +175,7 @@ function getDecodedFeature(
  * @returns decoded binary feature
  */
 function getDecodedFeatureBinary(
-  feature: BinaryVectorTileFeature,
+  feature: VectorTileFeature,
   options: MVTOptions,
   layerName: string
 ): FlatFeature {

package/src/lib/types.ts

@@ -2,45 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright vis.gl contributors
 
-/** For local coordinates, the tileIndex is not required */
-type MVTLocalCoordinatesOptions = {
-  /**
-   * When set to `local`, the parser will return a flat array of GeoJSON objects with local coordinates decoded from tile origin.
-   */
-  coordinates: 'local';
-  tileIndex: null;
-};
-
-/** In WGS84 coordinates, the tileIndex is required */
-type MVTWgs84CoordinatesOptions = {
-  /**
-   * When set to `wgs84`, the parser will return a flat array of GeoJSON objects with coordinates in longitude, latitude decoded from the provided tile index.
-   */
-  coordinates?: 'wgs84';
-
-  /**
-   * Mandatory with `wgs84` coordinates option. An object containing tile index values (`x`, `y`,
-   * `z`) to reproject features' coordinates into WGS84.
-   */
-  tileIndex?: {x: number; y: number; z: number};
-};
-
-export type MVTOptions = (MVTLocalCoordinatesOptions | MVTWgs84CoordinatesOptions) & {
-  shape?: 'geojson-table' | 'columnar-table' | 'geojson' | 'binary' | 'binary-geometry';
-  /**
-   * When non-`null`, the layer name of each feature is added to
-   * `feature.properties[layerProperty]`. (A `feature.properties` object is created if the feature
-   * has no existing properties). If set to `null`, a layer name property will not be added.
-   */
-  layerProperty?: string | number;
-
-  /**
-   * Optional list of layer names. If not `null`, only features belonging to the named layers will
-   * be included in the output. If `null`, features from all layers are returned.
-   */
-  layers?: string[];
-};
-
+/** TODO where is this used? */
 export type MVTMapboxGeometry = {
   type?: string;
   id?: number;

package/src/{helpers/binary-util-functions.ts → lib/utils/geometry-utils.ts}

@@ -2,10 +2,99 @@
 // SPDX-License-Identifier: MIT
 // Copyright vis.gl contributors
 
-import Protobuf from 'pbf';
 import {getPolygonSignedArea} from '@math.gl/polygon';
 import {FlatIndexedGeometry, FlatPolygon} from '@loaders.gl/schema';
-import {BinaryVectorTileFeature} from '../lib/binary-vector-tile/vector-tile-feature';
+
+/**
+ *
+ * @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;
+}
+
+/**
+ * Projects local tile coordinates to lngLat in place.
+ * @param points
+ * @param tileIndex
+ */
+export function projectTileCoordinatesToLngLat(
+  points: number[][],
+  tileIndex: {x: number; y: number; z: number},
+  extent: number
+) {
+  const {x, y, z} = tileIndex;
+  const size = extent * Math.pow(2, z);
+  const x0 = extent * x;
+  const y0 = extent * y;
+
+  for (const p of points) {
+    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;
+  }
+}
+
+/**
+ *
+ * @param data
+ * @param x0
+ * @param y0
+ * @param size
+ */
+export function projectToLngLatFlat(
+  data: number[],
+  tileIndex: {x: number; y: number; z: number},
+  extent: number
+): void {
+  const {x, y, z} = tileIndex;
+  const size = extent * Math.pow(2, z);
+  const x0 = extent * x;
+  const y0 = extent * y;
+
+  for (let j = 0, jl = data.length; j < jl; j += 2) {
+    data[j] = ((data[j] + x0) * 360) / size - 180;
+    const y2 = 180 - ((data[j + 1] + y0) * 360) / size;
+    data[j + 1] = (360 / Math.PI) * Math.atan(Math.exp((y2 * Math.PI) / 180)) - 90;
+  }
+}
+
+/**
+ * Classifies an array of rings into polygons with outer rings and holes
+ * @param rings
+ * @returns polygons
+ */
+export function classifyRings(rings: number[][][]): number[][][][] {
+  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;
+}
 
 /**
  * Classifies an array of rings into polygons with outer rings and holes
@@ -17,7 +106,7 @@ import {BinaryVectorTileFeature} from '../lib/binary-vector-tile/vector-tile-fea
  * @returns object
  */
 // eslint-disable-next-line max-statements
-export function classifyRings(geom: FlatIndexedGeometry): FlatPolygon {
+export function classifyRingsFlat(geom: FlatIndexedGeometry): FlatPolygon {
   const len = geom.indices.length;
   const type = 'Polygon';
 
@@ -78,48 +167,3 @@ export function classifyRings(geom: FlatIndexedGeometry): FlatPolygon {
 
   return {type, areas, indices: polygons, data: geom.data};
 }
-
-/**
- *
- * @param data
- * @param x0
- * @param y0
- * @param size
- */
-export function project(data: number[], x0: number, y0: number, size: number): void {
-  for (let j = 0, jl = data.length; j < jl; j += 2) {
-    data[j] = ((data[j] + x0) * 360) / size - 180;
-    const y2 = 180 - ((data[j + 1] + y0) * 360) / size;
-    data[j + 1] = (360 / Math.PI) * Math.atan(Math.exp((y2 * Math.PI) / 180)) - 90;
-  }
-}
-
-/**
- * All code below is unchanged from the original Mapbox implemenation
- *
- * @param tag
- * @param feature
- * @param pbf
- */
-export function readFeature(tag: number, feature?: BinaryVectorTileFeature, 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: BinaryVectorTileFeature): 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;
-  }
-}