@loaders.gl/mvt 3.0.12 → 3.1.0-alpha.4

package/src/lib/binary-vector-tile/{features-to-binary.js → features-to-binary.ts}

@@ -1,5 +1,14 @@
-// @ts-nocheck
+/* eslint-disable indent */
 import {earcut} from '@math.gl/polygon';
+import {
+  MvtBinaryCoordinates,
+  MvtBinaryGeometry,
+  MvtBinaryOptions,
+  MvtFirstPassedData,
+  MvtLines,
+  MvtPoints,
+  MvtPolygons
+} from '../types';
 
 /**
  * Convert binary features to flat binary arrays. Similar to
@@ -8,11 +17,20 @@ import {earcut} from '@math.gl/polygon';
  * 2X-3X speed increase in parse speed, compared to using
  * geoJSON. See `binary-vector-tile/VectorTileFeature` for
  * data format detais
+ *
+ * @param features
+ * @param firstPassData
+ * @param options
+ * @returns filled arrays
  */
-export function featuresToBinary(features, firstPassData, options = {}) {
+export function featuresToBinary(
+  features: MvtBinaryCoordinates[],
+  firstPassData: MvtFirstPassedData,
+  options?: MvtBinaryOptions
+) {
   return fillArrays(features, firstPassData, {
-    numericPropKeys: options.numericPropKeys || extractNumericPropKeys(features),
-    PositionDataType: options.PositionDataType || Float32Array
+    numericPropKeys: options ? options.numericPropKeys : extractNumericPropKeys(features),
+    PositionDataType: options ? options.PositionDataType : Float32Array
   });
 }
 
@@ -21,9 +39,13 @@ export const TEST_EXPORTS = {
   fillArrays
 };
 
-// Extracts properties that are always numeric
-// eslint-disable-next-line complexity, max-statements
-function extractNumericPropKeys(features) {
+/**
+ * Extracts properties that are always numeric
+ *
+ * @param features
+ * @returns object with numeric keys
+ */
+function extractNumericPropKeys(features: MvtBinaryCoordinates[]): string[] {
   const numericPropKeys = {};
   for (const feature of features) {
     if (feature.properties) {
@@ -32,7 +54,6 @@ function extractNumericPropKeys(features) {
         // in all previous features, check if numeric in this feature
         // If not numeric, false is stored to prevent rechecking in the future
         const numericSoFar = numericPropKeys[key];
-        // eslint-disable-next-line max-depth
         if (numericSoFar || numericSoFar === undefined) {
           const val = feature.properties[key];
           numericPropKeys[key] = isNumeric(val);
@@ -44,9 +65,20 @@ function extractNumericPropKeys(features) {
   return Object.keys(numericPropKeys).filter((k) => numericPropKeys[k]);
 }
 
-// Fills coordinates into pre-allocated typed arrays
+/**
+ * Fills coordinates into pre-allocated typed arrays
+ *
+ * @param features
+ * @param firstPassData
+ * @param options
+ * @returns an accessor object with value and size keys
+ */
 // eslint-disable-next-line complexity
-function fillArrays(features, firstPassData = {}, options = {}) {
+function fillArrays(
+  features: MvtBinaryCoordinates[],
+  firstPassData: MvtFirstPassedData,
+  options: MvtBinaryOptions
+) {
   const {
     pointPositionsCount,
     pointFeaturesCount,
@@ -62,7 +94,7 @@ function fillArrays(features, firstPassData = {}, options = {}) {
   const hasGlobalId = features[0] && 'id' in features[0];
   const coordLength = 2;
   const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
-  const points = {
+  const points: MvtPoints = {
     positions: new PositionDataType(pointPositionsCount * coordLength),
     globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
     featureIds:
@@ -73,7 +105,7 @@ function fillArrays(features, firstPassData = {}, options = {}) {
     properties: [],
     fields: []
   };
-  const lines = {
+  const lines: MvtLines = {
     pathIndices:
       linePositionsCount > 65535
         ? new Uint32Array(linePathsCount + 1)
@@ -88,7 +120,7 @@ function fillArrays(features, firstPassData = {}, options = {}) {
     properties: [],
     fields: []
   };
-  const polygons = {
+  const polygons: MvtPolygons = {
     polygonIndices:
       polygonPositionsCount > 65535
         ? new Uint32Array(polygonObjectsCount + 1)
@@ -179,8 +211,33 @@ function fillArrays(features, firstPassData = {}, options = {}) {
   return makeAccessorObjects(points, lines, polygons, coordLength);
 }
 
-// Fills (Multi)Point coordinates into points object of arrays
-function handlePoint(geometry, points, indexMap, coordLength, properties) {
+/**
+ * Fills (Multi)Point coordinates into points object of arrays
+ *
+ * @param geometry
+ * @param points
+ * @param indexMap
+ * @param coordLength
+ * @param properties
+ */
+function handlePoint(
+  geometry: MvtBinaryGeometry,
+  points: MvtPoints,
+  indexMap: {
+    pointPosition: number;
+    pointFeature: number;
+    linePosition?: number;
+    linePath?: number;
+    lineFeature?: number;
+    polygonPosition?: number;
+    polygonObject?: number;
+    polygonRing?: number;
+    polygonFeature?: number;
+    feature: number;
+  },
+  coordLength: number,
+  properties: {[x: string]: string | number | boolean | null}
+): void {
   points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
 
   const nPositions = geometry.data.length / coordLength;
@@ -199,8 +256,33 @@ function handlePoint(geometry, points, indexMap, coordLength, properties) {
   indexMap.pointPosition += nPositions;
 }
 
-// Fills (Multi)LineString coordinates into lines object of arrays
-function handleLineString(geometry, lines, indexMap, coordLength, properties) {
+/**
+ * Fills (Multi)LineString coordinates into lines object of arrays
+ *
+ * @param geometry
+ * @param lines
+ * @param indexMap
+ * @param coordLength
+ * @param properties
+ */
+function handleLineString(
+  geometry: MvtBinaryGeometry,
+  lines: MvtLines,
+  indexMap: {
+    pointPosition?: number;
+    pointFeature?: number;
+    linePosition: number;
+    linePath: number;
+    lineFeature: number;
+    polygonPosition?: number;
+    polygonObject?: number;
+    polygonRing?: number;
+    polygonFeature?: number;
+    feature: number;
+  },
+  coordLength: number,
+  properties: {[x: string]: string | number | boolean | null}
+): void {
   lines.positions.set(geometry.data, indexMap.linePosition * coordLength);
 
   const nPositions = geometry.data.length / coordLength;
@@ -231,8 +313,33 @@ function handleLineString(geometry, lines, indexMap, coordLength, properties) {
   }
 }
 
-// Fills (Multi)Polygon coordinates into polygons object of arrays
-function handlePolygon(geometry, polygons, indexMap, coordLength, properties) {
+/**
+ * Fills (Multi)Polygon coordinates into polygons object of arrays
+ *
+ * @param geometry
+ * @param polygons
+ * @param indexMap
+ * @param coordLength
+ * @param properties
+ */
+function handlePolygon(
+  geometry: MvtBinaryGeometry,
+  polygons: MvtPolygons,
+  indexMap: {
+    pointPosition?: number;
+    pointFeature?: number;
+    linePosition?: number;
+    linePath?: number;
+    lineFeature?: number;
+    polygonPosition: number;
+    polygonObject: number;
+    polygonRing: number;
+    polygonFeature: number;
+    feature: number;
+  },
+  coordLength: number,
+  properties: {[x: string]: string | number | boolean | null}
+): void {
   polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);
 
   const nPositions = geometry.data.length / coordLength;
@@ -253,7 +360,7 @@ function handlePolygon(geometry, polygons, indexMap, coordLength, properties) {
     const startPosition = indexMap.polygonPosition;
     polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
 
-    const areas = geometry.areas[l];
+    const areas = geometry.areas![l];
     const lines = geometry.lines[l];
     const nextLines = geometry.lines[l + 1];
 
@@ -278,8 +385,22 @@ function handlePolygon(geometry, polygons, indexMap, coordLength, properties) {
 
 /**
  * Triangulate polygon using earcut
+ *
+ * @param polygons
+ * @param areas
+ * @param lines
+ * @param param3
  */
-function triangulatePolygon(polygons, areas, lines, {startPosition, endPosition, coordLength}) {
+function triangulatePolygon(
+  polygons: MvtPolygons,
+  areas: number,
+  lines: number[],
+  {
+    startPosition,
+    endPosition,
+    coordLength
+  }: {startPosition: number; endPosition: number; coordLength: number}
+): void {
   const start = startPosition * coordLength;
   const end = endPosition * coordLength;
 
@@ -288,7 +409,7 @@ function triangulatePolygon(polygons, areas, lines, {startPosition, endPosition,
 
   // Holes are referenced relative to outer polygon
   const offset = lines[0];
-  const holes = lines.slice(1).map((n) => (n - offset) / coordLength);
+  const holes = lines.slice(1).map((n: number) => (n - offset) / coordLength);
 
   // Compute triangulation
   const indices = earcut(polygonPositions, holes, coordLength, areas);
@@ -300,8 +421,21 @@ function triangulatePolygon(polygons, areas, lines, {startPosition, endPosition,
   }
 }
 
-// Wrap each array in an accessor object with value and size keys
-function makeAccessorObjects(points, lines, polygons, coordLength) {
+/**
+ * Wrap each array in an accessor object with value and size keys
+ *
+ * @param points
+ * @param lines
+ * @param polygons
+ * @param coordLength
+ * @returns object
+ */
+function makeAccessorObjects(
+  points: MvtPoints,
+  lines: MvtLines,
+  polygons: MvtPolygons,
+  coordLength: number
+) {
   const returnObj = {
     points: {
       ...points,
@@ -338,8 +472,20 @@ function makeAccessorObjects(points, lines, polygons, coordLength) {
   return returnObj;
 }
 
-// Add numeric properties to object
-function fillNumericProperties(object, properties, index, length) {
+/**
+ * Add numeric properties to object
+ *
+ * @param object
+ * @param properties
+ * @param index
+ * @param length
+ */
+function fillNumericProperties(
+  object: MvtPoints,
+  properties: {[x: string]: string | number | boolean | null},
+  index: number,
+  length: number
+): void {
   for (const numericPropName in object.numericProps) {
     if (numericPropName in properties) {
       object.numericProps[numericPropName].fill(properties[numericPropName], index, index + length);
@@ -347,8 +493,17 @@ function fillNumericProperties(object, properties, index, length) {
   }
 }
 
-// Keep string properties in object
-function keepStringProperties(properties, numericKeys) {
+/**
+ * Keep string properties in object
+ *
+ * @param properties
+ * @param numericKeys
+ * @returns object
+ */
+function keepStringProperties(
+  properties: {[x: string]: string | number | boolean | null},
+  numericKeys: string[]
+) {
   const props = {};
   for (const key in properties) {
     if (!numericKeys.includes(key)) {
@@ -358,6 +513,6 @@ function keepStringProperties(properties, numericKeys) {
   return props;
 }
 
-function isNumeric(x) {
+function isNumeric(x: unknown) {
   return Number.isFinite(x);
 }

package/src/lib/binary-vector-tile/{vector-tile-feature.js → vector-tile-feature.ts}

@@ -1,21 +1,45 @@
 // This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
-/* eslint-disable */
 
-import {getPolygonSignedArea} from '@math.gl/polygon';
+import Protobuf from 'pbf';
+import {MvtBinaryCoordinates, MvtBinaryGeometry, MvtFirstPassedData} from '../types';
+import {classifyRings, project, readFeature} from '../../helpers/binary-util-functions';
 
 // Reduce GC by reusing variables
-let endPos, cmd, cmdLen, length, x, y, i;
+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 default 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)[];
+  _firstPassData: MvtFirstPassedData;
   static get types() {
     return ['Unknown', 'Point', 'LineString', 'Polygon'];
   }
 
-  constructor(pbf, end, extent, keys, values, firstPassData) {
+  // eslint-disable-next-line max-params
+  constructor(
+    pbf: Protobuf,
+    end: number,
+    extent: any,
+    keys: string[],
+    values: (string | number | boolean | null)[],
+    firstPassData: MvtFirstPassedData
+  ) {
     // Public
     this.properties = {};
     this.extent = extent;
@@ -33,7 +57,7 @@ export default class VectorTileFeature {
   }
 
   // eslint-disable-next-line complexity, max-statements
-  loadGeometry() {
+  loadGeometry(): MvtBinaryGeometry {
     const pbf = this._pbf;
     pbf.pos = this._geometry;
 
@@ -49,8 +73,8 @@ export default class VectorTileFeature {
     // `set()` and direct index access. Also, we cannot
     // know how large the buffer should be, so it would
     // increase memory usage
-    const lines = []; // Indices where lines start
-    const data = []; // Flat array of coordinate data
+    const lines: number[] = []; // Indices where lines start
+    const data: number[] = []; // Flat array of coordinate data
 
     while (pbf.pos < endPos) {
       if (length <= 0) {
@@ -86,6 +110,11 @@ export default class VectorTileFeature {
     return {data, lines};
   }
 
+  /**
+   *
+   * @param transform
+   * @returns result
+   */
   _toBinaryCoordinates(transform) {
     // Expands the protobuf data to an intermediate `lines`
     // data format, which maps closely to the binary data buffers.
@@ -114,6 +143,7 @@ export default class VectorTileFeature {
 
     const coordLength = 2;
 
+    // eslint-disable-next-line default-case
     switch (this.type) {
       case 1: // Point
         this._firstPassData.pointFeaturesCount++;
@@ -139,7 +169,6 @@ export default class VectorTileFeature {
         }
         this._firstPassData.polygonPositionsCount += classified.data.length / coordLength;
 
-        // @ts-ignore
         geom = classified;
         break;
     }
@@ -149,7 +178,7 @@ export default class VectorTileFeature {
       geom.type = `Multi${geom.type}`;
     }
 
-    const result = {
+    const result: MvtBinaryCoordinates = {
       type: 'Feature',
       geometry: geom,
       properties: this.properties
@@ -162,109 +191,12 @@ export default class VectorTileFeature {
     return result;
   }
 
-  toBinaryCoordinates(options) {
+  toBinaryCoordinates(
+    options: {x: number; y: number; z: number} | ((data: number[], feature: {extent: any}) => void)
+  ): MvtBinaryCoordinates {
     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;
-
-    function project(data) {
-      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;
-      }
-    }
     return this._toBinaryCoordinates(project);
   }
 }
-
-/**
- * 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
- */
-function classifyRings(geom) {
-  const len = geom.lines.length;
-
-  if (len <= 1) {
-    return {
-      data: geom.data,
-      areas: [[getPolygonSignedArea(geom.data)]],
-      lines: [geom.lines]
-    };
-  }
-
-  const areas = [];
-  const polygons = [];
-  let ringAreas;
-  let polygon;
-  let ccw;
-  let offset = 0;
-
-  for (let i = 0, startIndex, endIndex; i < len; i++) {
-    startIndex = geom.lines[i] - offset;
-
-    endIndex = geom.lines[i + 1] - offset || geom.data.length;
-    const shape = geom.data.slice(startIndex, endIndex);
-    const area = getPolygonSignedArea(shape);
-
-    if (area === 0) {
-      // This polygon has no area, so remove it from the shape
-      // Remove the section from the data array
-      const before = geom.data.slice(0, startIndex);
-      const after = geom.data.slice(endIndex);
-      geom.data = before.concat(after);
-
-      // Need to offset any remaining indices as we have
-      // modified the data buffer
-      offset += endIndex - startIndex;
-
-      // Do not add this index to the output and process next shape
-      continue;
-    }
-
-    if (ccw === undefined) ccw = area < 0;
-
-    if (ccw === area < 0) {
-      if (polygon) {
-        areas.push(ringAreas);
-        polygons.push(polygon);
-      }
-      polygon = [startIndex];
-      ringAreas = [area];
-    } else {
-      // @ts-ignore
-      ringAreas.push(area);
-      // @ts-ignore
-      polygon.push(startIndex);
-    }
-  }
-  if (ringAreas) areas.push(ringAreas);
-  if (polygon) polygons.push(polygon);
-
-  return {areas, lines: polygons, data: geom.data};
-}
-
-// All code below is unchanged from the original Mapbox implemenation
-
-function readFeature(tag, 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;
-}
-
-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;
-  }
-}