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

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

@@ -0,0 +1,407 @@
+// 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 {Feature} from '@loaders.gl/schema';
+import {FlatFeature, FlatIndexedGeometry, GeojsonGeometryInfo} from '@loaders.gl/schema';
+import Protobuf from 'pbf';
+import {classifyRings, classifyRingsFlat, projectToLngLatFlat} from '../utils/geometry-utils';
+
+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)[];
+  _geometryInfo: GeojsonGeometryInfo;
+
+  static types: Readonly<string[]> = ['Unknown', 'Point', 'LineString', 'Polygon'];
+
+  // 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;
+
+    // Only used by binary tiles
+    this._geometryInfo = geometryInfo!;
+
+    pbf.readFields(readFeature, this, end);
+  }
+
+  toGeoJSON(
+    options: {x: number; y: number; z: number} | ((data: number[], feature: {extent: any}) => void)
+  ): Feature {
+    const coords = this.loadGeometry();
+
+    if (typeof options === 'function') {
+      return _toGeoJSON(this, coords, 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 _toGeoJSON(this, coords, project);
+  }
+
+  /**
+   *
+   * @param options
+   * @returns
+   */
+  toBinaryCoordinates(
+    options: {x: number; y: number; z: number} | ((data: number[], feature: {extent: any}) => void)
+  ): FlatFeature {
+    if (typeof options === 'function') {
+      return this._toBinaryCoordinates(options);
+    }
+    const tileIndex = options;
+    return this._toBinaryCoordinates((data: number[]) =>
+      projectToLngLatFlat(data, tileIndex, this.extent)
+    );
+  }
+
+  // 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];
+  }
+
+  // BINARY HELPERS
+
+  /**
+   *
+   * @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.loadFlatGeometry();
+    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 = classifyRingsFlat(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;
+  }
+
+  // GEOJSON HELPER
+
+  // eslint-disable-next-line complexity, max-statements
+  loadGeometry(): number[][][] {
+    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--;
+
+      switch (cmd) {
+        case 1:
+        case 2:
+          x += pbf.readSVarint();
+          y += pbf.readSVarint();
+
+          if (cmd === 1) {
+            // moveTo
+            if (line) lines.push(line);
+            line = [];
+          }
+          if (line) line.push([x, y]);
+          break;
+        case 7:
+          // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
+          if (line) {
+            line.push(line[0].slice()); // closePolygon
+          }
+          break;
+        default:
+          throw new Error(`unknown command ${cmd}`);
+      }
+    }
+
+    if (line) lines.push(line);
+
+    return lines;
+  }
+
+  // eslint-disable-next-line complexity, max-statements
+  loadFlatGeometry(): FlatIndexedGeometry {
+    const pbf = this._pbf;
+    pbf.pos = this._geometry;
+
+    const endPos = pbf.readVarint() + pbf.pos;
+    let cmd = 1;
+    let cmdLen: number;
+    let length = 0;
+    let x = 0;
+    let y = 0;
+    let 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};
+  }
+}
+
+function _toGeoJSON(vtFeature: VectorTileFeature, coords: number[][][], transform): Feature {
+  let type = VectorTileFeature.types[vtFeature.type];
+  let i: number;
+  let j: number;
+
+  let coordinates: number[][] | number[][][] | number[][][][];
+  switch (vtFeature.type) {
+    case 1:
+      const points: number[][] = [];
+      for (i = 0; i < coords.length; i++) {
+        points[i] = coords[i][0];
+      }
+      coordinates = points;
+      transform(coordinates, vtFeature);
+      break;
+
+    case 2:
+      coordinates = coords;
+      for (i = 0; i < coordinates.length; i++) {
+        transform(coordinates[i], vtFeature);
+      }
+      break;
+
+    case 3:
+      coordinates = classifyRings(coords);
+      for (i = 0; i < coordinates.length; i++) {
+        for (j = 0; j < coordinates[i].length; j++) {
+          transform(coordinates[i][j], vtFeature);
+        }
+      }
+      break;
+
+    default:
+      throw new Error('illegal vector tile type');
+  }
+
+  if (coordinates.length === 1) {
+    // @ts-expect-error
+    coordinates = coordinates[0];
+  } else {
+    type = `Multi${type}`;
+  }
+
+  const result: Feature = {
+    type: 'Feature',
+    geometry: {
+      type: type as any,
+      coordinates: coordinates as any
+    },
+    properties: vtFeature.properties
+  };
+
+  if (vtFeature.id !== null) {
+    result.id = vtFeature.id;
+  }
+
+  return result;
+}
+
+// PBF READER UTILS
+
+/**
+ *
+ * @param tag
+ * @param feature
+ * @param pbf
+ */
+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
+ */
+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/{mapbox-vector-tile → vector-tile}/vector-tile-layer.ts

@@ -7,6 +7,7 @@
 
 import Protobuf from 'pbf';
 import {VectorTileFeature} from './vector-tile-feature';
+import {GeojsonGeometryInfo} from '@loaders.gl/schema';
 
 export class VectorTileLayer {
   version: number;
@@ -17,6 +18,7 @@ export class VectorTileLayer {
   _keys: string[];
   _values: (string | number | boolean | null)[];
   _features: number[];
+
   constructor(pbf: Protobuf, end: number) {
     // Public
     this.version = 1;
@@ -40,8 +42,7 @@ export class VectorTileLayer {
    * @param index
    * @returns feature
    */
-
-  feature(i: number): VectorTileFeature {
+  getGeoJSONFeature(i: number): VectorTileFeature {
     if (i < 0 || i >= this._features.length) {
       throw new Error('feature index out of bounds');
     }
@@ -51,6 +52,31 @@ export class VectorTileLayer {
     const end = this._pbf.readVarint() + this._pbf.pos;
     return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
   }
+
+  /**
+   * return binary feature `i` from this layer as a `VectorTileFeature`
+   *
+   * @param index
+   * @param geometryInfo
+   * @returns binary feature
+   */
+  getBinaryFeature(i: number, geometryInfo: GeojsonGeometryInfo): VectorTileFeature {
+    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 VectorTileFeature(
+      this._pbf,
+      end,
+      this.extent,
+      this._keys,
+      this._values,
+      geometryInfo
+    );
+  }
 }
 
 /**

package/src/mvt-loader.ts

@@ -3,21 +3,29 @@
 // Copyright vis.gl contributors
 
 import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+// import type {MVTOptions} from './lib/types';
 import {parseMVT} from './lib/parse-mvt';
-import type {MVTOptions} from './lib/types';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
 const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 
 export type MVTLoaderOptions = LoaderOptions & {
-  mvt?: MVTOptions & {
+  mvt?: {
+    /** Shape of returned data */
+    shape?: 'geojson-table' | 'columnar-table' | 'geojson' | 'binary' | 'binary-geometry';
+    /** `wgs84`: coordinates in long, lat (`tileIndex` must be provided. `local` coordinates are `0-1` from tile origin */
+    coordinates?: 'wgs84' | 'local';
+    /** An object containing tile index values (`x`, `y`, `z`) to reproject features' coordinates into WGS84. Mandatory with `wgs84` coordinates option. */
+    tileIndex?: {x: number; y: number; z: number};
+    /** If provided, stored the layer name of each feature is added to `feature.properties[layerProperty]`. */
+    layerProperty?: string | number;
+    /** layer filter. If provided, only features belonging to the named layers will be included, otherwise features from all layers are returned. */
+    layers?: string[];
     /** Override the URL to the worker bundle (by default loads from unpkg.com) */
     workerUrl?: string;
   };
   gis?: {
-    /** `true`: parser will output the data in binary format. Equivalent to loading the data as GeoJSON and then applying geojsonToBinary */
-    binary?: boolean;
     /** @deprecated. Use options.mvt.shape */
     format?: 'geojson-table' | 'columnar-table' | 'geojson' | 'binary' | 'binary-geometry';
   };
@@ -49,8 +57,8 @@ export const MVTWorkerLoader = {
       shape: 'geojson',
       coordinates: 'local',
       layerProperty: 'layerName',
-      layers: undefined,
-      tileIndex: null
+      layers: undefined!,
+      tileIndex: undefined!
     }
   }
 } as const satisfies Loader<

package/src/mvt-source.ts

@@ -102,7 +102,7 @@ export class MVTSource extends DataSource implements ImageTileSource, VectorTile
   }
 
   async getTile(tileParams: GetTileParameters): Promise<ArrayBuffer | null> {
-    const {x, y, zoom: z} = tileParams;
+    const {x, y, z} = tileParams;
     const tileUrl = this.getTileURL(x, y, z);
     const response = await this.fetch(tileUrl);
     if (!response.ok) {
@@ -120,7 +120,7 @@ export class MVTSource extends DataSource implements ImageTileSource, VectorTile
     // const metadata = await this.metadata;
     // mimeType = metadata?.tileMIMEType || 'application/vnd.mapbox-vector-tile';
 
-    const arrayBuffer = await this.getTile({x, y, zoom: z, layers: []});
+    const arrayBuffer = await this.getTile({x, y, z, layers: []});
     if (arrayBuffer === null) {
       return null;
     }
@@ -130,7 +130,7 @@ export class MVTSource extends DataSource implements ImageTileSource, VectorTile
       this.mimeType || imageMetadata?.mimeType || 'application/vnd.mapbox-vector-tile';
     switch (this.mimeType) {
       case 'application/vnd.mapbox-vector-tile':
-        return await this._parseVectorTile(arrayBuffer, {x, y, zoom: z, layers: []});
+        return await this._parseVectorTile(arrayBuffer, {x, y, z, layers: []});
       default:
         return await this._parseImageTile(arrayBuffer);
     }
@@ -162,7 +162,7 @@ export class MVTSource extends DataSource implements ImageTileSource, VectorTile
       shape: 'geojson-table',
       mvt: {
         coordinates: 'wgs84',
-        tileIndex: {x: tileParams.x, y: tileParams.y, z: tileParams.zoom},
+        tileIndex: {x: tileParams.x, y: tileParams.y, z: tileParams.z},
         ...(this.loadOptions as MVTLoaderOptions)?.mvt
       },
       ...this.loadOptions

package/dist/helpers/binary-util-functions.d.ts

@@ -1,35 +0,0 @@
-import Protobuf from 'pbf';
-import { FlatIndexedGeometry, FlatPolygon } from '@loaders.gl/schema';
-import { BinaryVectorTileFeature } from "../lib/binary-vector-tile/vector-tile-feature.js";
-/**
- * Classifies an array of rings into polygons with outer rings and holes
- * The function also detects holes which have zero area and
- * removes them. In doing so it modifies the input
- * `geom.data` array to remove the unneeded data
- *
- * @param geometry
- * @returns object
- */
-export declare function classifyRings(geom: FlatIndexedGeometry): FlatPolygon;
-/**
- *
- * @param data
- * @param x0
- * @param y0
- * @param size
- */
-export declare function project(data: number[], x0: number, y0: number, size: number): void;
-/**
- * All code below is unchanged from the original Mapbox implemenation
- *
- * @param tag
- * @param feature
- * @param pbf
- */
-export declare function readFeature(tag: number, feature?: BinaryVectorTileFeature, pbf?: Protobuf): void;
-/**
- * @param pbf
- * @param feature
- */
-export declare function readTag(pbf: Protobuf, feature: BinaryVectorTileFeature): void;
-//# sourceMappingURL=binary-util-functions.d.ts.map

package/dist/helpers/binary-util-functions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"binary-util-functions.d.ts","sourceRoot":"","sources":["../../src/helpers/binary-util-functions.ts"],"names":[],"mappings":"AAIA,OAAO,QAAQ,MAAM,KAAK,CAAC;AAE3B,OAAO,EAAC,mBAAmB,EAAE,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACpE,OAAO,EAAC,uBAAuB,EAAC,yDAAsD;AAEtF;;;;;;;;GAQG;AAEH,wBAAgB,aAAa,CAAC,IAAI,EAAE,mBAAmB,GAAG,WAAW,CA4DpE;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAMlF;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,uBAAuB,EAAE,GAAG,CAAC,EAAE,QAAQ,GAAG,IAAI,CAOhG;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,uBAAuB,GAAG,IAAI,CAQ7E"}

package/dist/helpers/mapbox-util-functions.d.ts

@@ -1,29 +0,0 @@
-import Protobuf from 'pbf';
-import { MVTMapboxGeometry } from "../lib/types.js";
-import { VectorTileFeature } from "../lib/mapbox-vector-tile/vector-tile-feature.js";
-/**
- * Classifies an array of rings into polygons with outer rings and holes
- * @param rings
- * @returns polygons
- */
-export declare function classifyRings(rings: MVTMapboxGeometry): MVTMapboxGeometry[] | number[][][];
-/**
- *
- * @param ring
- * @returns sum
- */
-export declare function signedArea(ring: number[][]): number;
-/**
- *
- * @param tag
- * @param feature
- * @param pbf
- */
-export declare function readFeature(tag: number, feature?: VectorTileFeature, pbf?: Protobuf): void;
-/**
- *
- * @param pbf
- * @param feature
- */
-export declare function readTag(pbf: Protobuf, feature: VectorTileFeature): void;
-//# sourceMappingURL=mapbox-util-functions.d.ts.map

package/dist/helpers/mapbox-util-functions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mapbox-util-functions.d.ts","sourceRoot":"","sources":["../../src/helpers/mapbox-util-functions.ts"],"names":[],"mappings":"AAIA,OAAO,QAAQ,MAAM,KAAK,CAAC;AAC3B,OAAO,EAAC,iBAAiB,EAAC,wBAAqB;AAC/C,OAAO,EAAC,iBAAiB,EAAC,yDAAsD;AAEhF;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,iBAAiB,sCAuBrD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,UAQ1C;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,EAAE,GAAG,CAAC,EAAE,QAAQ,GAAG,IAAI,CAO1F;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAQvE"}

package/dist/helpers/mapbox-util-functions.js

@@ -1,78 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright vis.gl contributors
-/**
- * Classifies an array of rings into polygons with outer rings and holes
- * @param rings
- * @returns polygons
- */
-export function classifyRings(rings) {
-    const len = rings.length;
-    if (len <= 1)
-        return [rings];
-    const polygons = [];
-    let polygon;
-    let ccw;
-    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) {
-    let sum = 0;
-    for (let i = 0, j = ring.length - 1, p1, p2; 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, feature, pbf) {
-    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, feature) {
-    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/dist/lib/binary-vector-tile/vector-tile-feature.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vector-tile-feature.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-vector-tile/vector-tile-feature.ts"],"names":[],"mappings":"AAMA,OAAO,QAAQ,MAAM,KAAK,CAAC;AAC3B,OAAO,EAAC,WAAW,EAAE,mBAAmB,EAAE,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AACzF,OAAO,EAAC,aAAa,EAAuB,+CAA4C;AAWxF,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,qBAAa,uBAAuB;IAClC,UAAU,EAAE;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;KAAC,CAAC;IAC5D,MAAM,EAAE,GAAG,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC;IAC9C,aAAa,EAAE,mBAAmB,CAAC;gBAIjC,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,GAAG,EACX,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,EAC5C,YAAY,EAAE,mBAAmB;IAmBnC,YAAY,IAAI,mBAAmB;IAqDnC;;;;OAIG;IACH,oBAAoB,CAAC,SAAS,KAAA;;;;;;;IAuE9B,mBAAmB,CACjB,OAAO,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE;QAAC,MAAM,EAAE,GAAG,CAAA;KAAC,KAAK,IAAI,CAAC,GAC9F,WAAW;CAWf"}