@loaders.gl/mvt 4.0.0-alpha.4 → 4.0.0-alpha.5

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

@@ -1,7 +1,7 @@
 // This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
 
 import Protobuf from 'pbf';
-import {MvtBinaryCoordinates, MvtBinaryGeometry, MvtFirstPassedData} from '../types';
+import {FlatFeature, FlatIndexedGeometry, GeojsonGeometryInfo} from '@loaders.gl/schema';
 import {classifyRings, project, readFeature} from '../../helpers/binary-util-functions';
 
 // Reduce GC by reusing variables
@@ -26,10 +26,7 @@ export default class VectorTileFeature {
   _geometry: number;
   _keys: string[];
   _values: (string | number | boolean | null)[];
-  _firstPassData: MvtFirstPassedData;
-  static get types() {
-    return ['Unknown', 'Point', 'LineString', 'Polygon'];
-  }
+  _geometryInfo: GeojsonGeometryInfo;
 
   // eslint-disable-next-line max-params
   constructor(
@@ -38,7 +35,7 @@ export default class VectorTileFeature {
     extent: any,
     keys: string[],
     values: (string | number | boolean | null)[],
-    firstPassData: MvtFirstPassedData
+    geometryInfo: GeojsonGeometryInfo
   ) {
     // Public
     this.properties = {};
@@ -51,13 +48,13 @@ export default class VectorTileFeature {
     this._geometry = -1;
     this._keys = keys;
     this._values = values;
-    this._firstPassData = firstPassData;
+    this._geometryInfo = geometryInfo;
 
     pbf.readFields(readFeature, this, end);
   }
 
   // eslint-disable-next-line complexity, max-statements
-  loadGeometry(): MvtBinaryGeometry {
+  loadGeometry(): FlatIndexedGeometry {
     const pbf = this._pbf;
     pbf.pos = this._geometry;
 
@@ -73,7 +70,7 @@ 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: number[] = []; // Indices where lines start
+    const indices: number[] = []; // Indices where geometries start
     const data: number[] = []; // Flat array of coordinate data
 
     while (pbf.pos < endPos) {
@@ -91,14 +88,14 @@ export default class VectorTileFeature {
 
         if (cmd === 1) {
           // New line
-          lines.push(i);
+          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 = lines[lines.length - 1]; // start index of polygon
+          const start = indices[indices.length - 1]; // start index of polygon
           data.push(data[start], data[start + 1]); // closePolygon
           i += 2;
         }
@@ -107,7 +104,7 @@ export default class VectorTileFeature {
       }
     }
 
-    return {data, lines};
+    return {data, indices};
   }
 
   /**
@@ -116,27 +113,28 @@ export default class VectorTileFeature {
    * @returns result
    */
   _toBinaryCoordinates(transform) {
-    // Expands the protobuf data to an intermediate `lines`
+    // 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 `lines`
+    // coordinates, and then index into this using the `indices`
     // parameter, e.g.
     //
     // geometry: {
-    //   type: 'Point', data: [1,2], lines: [0]
+    //   type: 'Point', data: [1,2], indices: [0]
     // }
     // geometry: {
-    //   type: 'LineString', data: [1,2,3,4,...], lines: [0]
+    //   type: 'LineString', data: [1,2,3,4,...], indices: [0]
     // }
     // geometry: {
-    //   type: 'Polygon', data: [1,2,3,4,...], lines: [[0, 2]]
+    //   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
     // }
-    // Thus the lines member lets us look up the relevant range
+    // 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 lines array
-    let geom = this.loadGeometry();
+    // 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);
@@ -146,43 +144,37 @@ export default class VectorTileFeature {
     // eslint-disable-next-line default-case
     switch (this.type) {
       case 1: // Point
-        this._firstPassData.pointFeaturesCount++;
-        this._firstPassData.pointPositionsCount += geom.lines.length;
+        this._geometryInfo.pointFeaturesCount++;
+        this._geometryInfo.pointPositionsCount += geom.indices.length;
+        geometry = {type: 'Point', ...geom};
         break;
 
       case 2: // LineString
-        this._firstPassData.lineFeaturesCount++;
-        this._firstPassData.linePathsCount += geom.lines.length;
-        this._firstPassData.linePositionsCount += geom.data.length / coordLength;
+        this._geometryInfo.lineFeaturesCount++;
+        this._geometryInfo.linePathsCount += geom.indices.length;
+        this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
+        geometry = {type: 'LineString', ...geom};
         break;
 
       case 3: // Polygon
-        const classified = classifyRings(geom);
+        geometry = classifyRings(geom);
 
-        // Unlike Point & LineString geom.lines is a 2D array, thanks
+        // Unlike Point & LineString geom.indices is a 2D array, thanks
         // to the classifyRings method
-        this._firstPassData.polygonFeaturesCount++;
-        this._firstPassData.polygonObjectsCount += classified.lines.length;
+        this._geometryInfo.polygonFeaturesCount++;
+        this._geometryInfo.polygonObjectsCount += geometry.indices.length;
 
-        for (const lines of classified.lines) {
-          this._firstPassData.polygonRingsCount += lines.length;
+        for (const indices of geometry.indices) {
+          this._geometryInfo.polygonRingsCount += indices.length;
         }
-        this._firstPassData.polygonPositionsCount += classified.data.length / coordLength;
+        this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
 
-        geom = classified;
         break;
+      default:
+        throw new Error(`Invalid geometry type: ${this.type}`);
     }
 
-    geom.type = VectorTileFeature.types[this.type];
-    if (geom.lines.length > 1) {
-      geom.type = `Multi${geom.type}`;
-    }
-
-    const result: MvtBinaryCoordinates = {
-      type: 'Feature',
-      geometry: geom,
-      properties: this.properties
-    };
+    const result: FlatFeature = {type: 'Feature', geometry, properties: this.properties};
 
     if (this.id !== null) {
       result.id = this.id;
@@ -193,7 +185,7 @@ export default class VectorTileFeature {
 
   toBinaryCoordinates(
     options: {x: number; y: number; z: number} | ((data: number[], feature: {extent: any}) => void)
-  ): MvtBinaryCoordinates {
+  ): FlatFeature {
     if (typeof options === 'function') {
       return this._toBinaryCoordinates(options);
     }

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

@@ -3,7 +3,7 @@
 
 import VectorTileFeature from './vector-tile-feature';
 import Protobuf from 'pbf';
-import {MvtFirstPassedData} from '../types';
+import {GeojsonGeometryInfo} from '@loaders.gl/schema';
 
 export default class VectorTileLayer {
   version: number;
@@ -36,10 +36,10 @@ export default class VectorTileLayer {
    * return feature `i` from this layer as a `VectorTileFeature`
    *
    * @param index
-   * @param firstPassData
+   * @param geometryInfo
    * @returns {VectorTileFeature}
    */
-  feature(i: number, firstPassData: MvtFirstPassedData): VectorTileFeature {
+  feature(i: number, geometryInfo: GeojsonGeometryInfo): VectorTileFeature {
     if (i < 0 || i >= this._features.length) {
       throw new Error('feature index out of bounds');
     }
@@ -53,7 +53,7 @@ export default class VectorTileLayer {
       this.extent,
       this._keys,
       this._values,
-      firstPassData
+      geometryInfo
     );
   }
 }

package/src/lib/parse-mvt.ts

@@ -2,12 +2,13 @@
 import VectorTile from './mapbox-vector-tile/vector-tile';
 import BinaryVectorTile from './binary-vector-tile/vector-tile';
 
-import {featuresToBinary} from './binary-vector-tile/features-to-binary';
+import {flatGeojsonToBinary} from '@loaders.gl/gis';
 import Protobuf from 'pbf';
-import {MvtBinaryCoordinates, MvtMapboxCoordinates, MvtOptions} from '../lib/types';
+import type {FlatFeature} from '@loaders.gl/schema';
+import type {MvtMapboxCoordinates, MvtOptions} from '../lib/types';
 import VectorTileFeatureBinary from './binary-vector-tile/vector-tile-feature';
 import VectorTileFeatureMapBox from './mapbox-vector-tile/vector-tile-feature';
-import {LoaderOptions} from '@loaders.gl/loader-utils/';
+import {LoaderOptions} from '@loaders.gl/loader-utils';
 
 /**
  * Parse MVT arrayBuffer and return GeoJSON.
@@ -18,11 +19,12 @@ import {LoaderOptions} from '@loaders.gl/loader-utils/';
  */
 export default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptions) {
   options = normalizeOptions(options);
-  const features: (MvtBinaryCoordinates | MvtMapboxCoordinates)[] = [];
+  const features: (FlatFeature | MvtMapboxCoordinates)[] = [];
 
   if (options) {
     const binary = options.gis.format === 'binary';
-    const firstPassData = {
+    const geometryInfo = {
+      coordLength: 2,
       pointPositionsCount: 0,
       pointFeaturesCount: 0,
       linePositionsCount: 0,
@@ -53,7 +55,7 @@ export default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptio
         }
 
         for (let i = 0; i < vectorTileLayer.length; i++) {
-          const vectorTileFeature = vectorTileLayer.feature(i, firstPassData);
+          const vectorTileFeature = vectorTileLayer.feature(i, geometryInfo);
 
           const decodedFeature = binary
             ? getDecodedFeatureBinary(vectorTileFeature as VectorTileFeatureBinary, featureOptions)
@@ -64,7 +66,7 @@ export default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptio
     }
 
     if (binary) {
-      const data = featuresToBinary(features as MvtBinaryCoordinates[], firstPassData);
+      const data = flatGeojsonToBinary(features as FlatFeature[], geometryInfo);
       // Add the original byteLength (as a reasonable approximation of the size of the binary data)
       // TODO decide where to store extra fields like byteLength (header etc) and document
       // @ts-ignore
@@ -134,13 +136,13 @@ function getDecodedFeature(
 function getDecodedFeatureBinary(
   feature: VectorTileFeatureBinary,
   options: MvtOptions
-): MvtBinaryCoordinates {
+): FlatFeature {
   const decodedFeature = feature.toBinaryCoordinates(
     options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinatesBinary
   );
 
   // Add layer name to GeoJSON properties
-  if (options.layerProperty) {
+  if (options.layerProperty && decodedFeature.properties) {
     decodedFeature.properties[options.layerProperty] = options.layerName;
   }
 

package/src/lib/types.ts

@@ -5,14 +5,6 @@ export type MvtOptions = {
   layerName: string;
 };
 
-export type MvtBinaryGeometry = {
-  data: number[];
-  lines: any[];
-  areas?: number[];
-  type?: string;
-  id?: number;
-};
-
 export type MvtMapboxGeometry = {
   type?: string;
   id?: number;
@@ -20,13 +12,6 @@ export type MvtMapboxGeometry = {
   coordinates?: any[];
 };
 
-export type MvtBinaryCoordinates = {
-  type: string;
-  geometry: MvtBinaryGeometry;
-  properties: {[x: string]: string | number | boolean | null};
-  id?: number;
-};
-
 export type MvtMapboxCoordinates = {
   type: string;
   geometry: {
@@ -36,57 +21,3 @@ export type MvtMapboxCoordinates = {
   properties: {[x: string]: string | number | boolean | null};
   id?: number;
 };
-
-export type MvtBinaryOptions = {
-  numericPropKeys: string[];
-  PositionDataType: Float32ArrayConstructor;
-};
-
-export type MvtFirstPassedData = {
-  pointPositionsCount: number;
-  pointFeaturesCount: number;
-  linePositionsCount: number;
-  linePathsCount: number;
-  lineFeaturesCount: number;
-  polygonPositionsCount: number;
-  polygonObjectsCount: number;
-  polygonRingsCount: number;
-  polygonFeaturesCount: number;
-};
-
-export type MvtPoints = {
-  positions: Float32Array;
-  globalFeatureIds: Uint16Array | Uint32Array;
-  featureIds: Uint16Array | Uint32Array;
-  numericProps: object;
-  properties: {}[];
-  fields: {
-    id?: number;
-  }[];
-};
-
-export type MvtLines = {
-  pathIndices: Uint16Array | Uint32Array;
-  positions: Float32Array;
-  globalFeatureIds: Uint16Array | Uint32Array;
-  featureIds: Uint16Array | Uint32Array;
-  numericProps: object;
-  properties: {}[];
-  fields: {
-    id?: number;
-  }[];
-};
-
-export type MvtPolygons = {
-  polygonIndices: Uint16Array | Uint32Array;
-  primitivePolygonIndices: Uint16Array | Uint32Array;
-  positions: Float32Array;
-  triangles: number[];
-  globalFeatureIds: Uint16Array | Uint32Array;
-  featureIds: Uint16Array | Uint32Array;
-  numericProps: object;
-  properties: {}[];
-  fields: {
-    id?: number;
-  }[];
-};

package/dist/lib/binary-vector-tile/features-to-binary.js

@@ -1,327 +0,0 @@
-import { earcut } from '@math.gl/polygon';
-export function featuresToBinary(features, firstPassData, options) {
-  return fillArrays(features, firstPassData, {
-    numericPropKeys: options ? options.numericPropKeys : extractNumericPropKeys(features),
-    PositionDataType: options ? options.PositionDataType : Float32Array
-  });
-}
-export const TEST_EXPORTS = {
-  extractNumericPropKeys,
-  fillArrays
-};
-
-function extractNumericPropKeys(features) {
-  const numericPropKeys = {};
-
-  for (const feature of features) {
-    if (feature.properties) {
-      for (const key in feature.properties) {
-        const numericSoFar = numericPropKeys[key];
-
-        if (numericSoFar || numericSoFar === undefined) {
-          const val = feature.properties[key];
-          numericPropKeys[key] = isNumeric(val);
-        }
-      }
-    }
-  }
-
-  return Object.keys(numericPropKeys).filter(k => numericPropKeys[k]);
-}
-
-function fillArrays(features, firstPassData, options) {
-  const {
-    pointPositionsCount,
-    pointFeaturesCount,
-    linePositionsCount,
-    linePathsCount,
-    lineFeaturesCount,
-    polygonPositionsCount,
-    polygonObjectsCount,
-    polygonRingsCount,
-    polygonFeaturesCount
-  } = firstPassData;
-  const {
-    numericPropKeys,
-    PositionDataType = Float32Array
-  } = options;
-  const hasGlobalId = features[0] && 'id' in features[0];
-  const coordLength = 2;
-  const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
-  const points = {
-    positions: new PositionDataType(pointPositionsCount * coordLength),
-    globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
-    featureIds: pointFeaturesCount > 65535 ? new Uint32Array(pointPositionsCount) : new Uint16Array(pointPositionsCount),
-    numericProps: {},
-    properties: [],
-    fields: []
-  };
-  const lines = {
-    pathIndices: linePositionsCount > 65535 ? new Uint32Array(linePathsCount + 1) : new Uint16Array(linePathsCount + 1),
-    positions: new PositionDataType(linePositionsCount * coordLength),
-    globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
-    featureIds: lineFeaturesCount > 65535 ? new Uint32Array(linePositionsCount) : new Uint16Array(linePositionsCount),
-    numericProps: {},
-    properties: [],
-    fields: []
-  };
-  const polygons = {
-    polygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonObjectsCount + 1) : new Uint16Array(polygonObjectsCount + 1),
-    primitivePolygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonRingsCount + 1) : new Uint16Array(polygonRingsCount + 1),
-    positions: new PositionDataType(polygonPositionsCount * coordLength),
-    triangles: [],
-    globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
-    featureIds: polygonFeaturesCount > 65535 ? new Uint32Array(polygonPositionsCount) : new Uint16Array(polygonPositionsCount),
-    numericProps: {},
-    properties: [],
-    fields: []
-  };
-
-  for (const object of [points, lines, polygons]) {
-    for (const propName of numericPropKeys) {
-      object.numericProps[propName] = new Float32Array(object.positions.length / coordLength);
-    }
-  }
-
-  lines.pathIndices[linePathsCount] = linePositionsCount;
-  polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;
-  polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;
-  const indexMap = {
-    pointPosition: 0,
-    pointFeature: 0,
-    linePosition: 0,
-    linePath: 0,
-    lineFeature: 0,
-    polygonPosition: 0,
-    polygonObject: 0,
-    polygonRing: 0,
-    polygonFeature: 0,
-    feature: 0
-  };
-
-  for (const feature of features) {
-    const geometry = feature.geometry;
-    const properties = feature.properties || {};
-
-    switch (geometry.type) {
-      case 'Point':
-      case 'MultiPoint':
-        handlePoint(geometry, points, indexMap, coordLength, properties);
-        points.properties.push(keepStringProperties(properties, numericPropKeys));
-
-        if (hasGlobalId) {
-          points.fields.push({
-            id: feature.id
-          });
-        }
-
-        indexMap.pointFeature++;
-        break;
-
-      case 'LineString':
-      case 'MultiLineString':
-        handleLineString(geometry, lines, indexMap, coordLength, properties);
-        lines.properties.push(keepStringProperties(properties, numericPropKeys));
-
-        if (hasGlobalId) {
-          lines.fields.push({
-            id: feature.id
-          });
-        }
-
-        indexMap.lineFeature++;
-        break;
-
-      case 'Polygon':
-      case 'MultiPolygon':
-        handlePolygon(geometry, polygons, indexMap, coordLength, properties);
-        polygons.properties.push(keepStringProperties(properties, numericPropKeys));
-
-        if (hasGlobalId) {
-          polygons.fields.push({
-            id: feature.id
-          });
-        }
-
-        indexMap.polygonFeature++;
-        break;
-
-      default:
-        throw new Error('Invalid geometry type');
-    }
-
-    indexMap.feature++;
-  }
-
-  return makeAccessorObjects(points, lines, polygons, coordLength);
-}
-
-function handlePoint(geometry, points, indexMap, coordLength, properties) {
-  points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
-  const nPositions = geometry.data.length / coordLength;
-  fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);
-  points.globalFeatureIds.fill(indexMap.feature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
-  points.featureIds.fill(indexMap.pointFeature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
-  indexMap.pointPosition += nPositions;
-}
-
-function handleLineString(geometry, lines, indexMap, coordLength, properties) {
-  lines.positions.set(geometry.data, indexMap.linePosition * coordLength);
-  const nPositions = geometry.data.length / coordLength;
-  fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
-  lines.globalFeatureIds.fill(indexMap.feature, indexMap.linePosition, indexMap.linePosition + nPositions);
-  lines.featureIds.fill(indexMap.lineFeature, indexMap.linePosition, indexMap.linePosition + nPositions);
-
-  for (let i = 0, il = geometry.lines.length; i < il; ++i) {
-    const start = geometry.lines[i];
-    const end = i === il - 1 ? geometry.data.length : geometry.lines[i + 1];
-    lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
-    indexMap.linePosition += (end - start) / coordLength;
-  }
-}
-
-function handlePolygon(geometry, polygons, indexMap, coordLength, properties) {
-  polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);
-  const nPositions = geometry.data.length / coordLength;
-  fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
-  polygons.globalFeatureIds.fill(indexMap.feature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
-  polygons.featureIds.fill(indexMap.polygonFeature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
-
-  for (let l = 0, ll = geometry.lines.length; l < ll; ++l) {
-    const startPosition = indexMap.polygonPosition;
-    polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
-    const areas = geometry.areas[l];
-    const lines = geometry.lines[l];
-    const nextLines = geometry.lines[l + 1];
-
-    for (let i = 0, il = lines.length; i < il; ++i) {
-      const start = lines[i];
-      const end = i === il - 1 ? nextLines === undefined ? geometry.data.length : nextLines[0] : lines[i + 1];
-      polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
-      indexMap.polygonPosition += (end - start) / coordLength;
-    }
-
-    const endPosition = indexMap.polygonPosition;
-    triangulatePolygon(polygons, areas, lines, {
-      startPosition,
-      endPosition,
-      coordLength
-    });
-  }
-}
-
-function triangulatePolygon(polygons, areas, lines, {
-  startPosition,
-  endPosition,
-  coordLength
-}) {
-  const start = startPosition * coordLength;
-  const end = endPosition * coordLength;
-  const polygonPositions = polygons.positions.subarray(start, end);
-  const offset = lines[0];
-  const holes = lines.slice(1).map(n => (n - offset) / coordLength);
-  const indices = earcut(polygonPositions, holes, coordLength, areas);
-
-  for (let t = 0, tl = indices.length; t < tl; ++t) {
-    polygons.triangles.push(startPosition + indices[t]);
-  }
-}
-
-function makeAccessorObjects(points, lines, polygons, coordLength) {
-  const returnObj = {
-    points: { ...points,
-      positions: {
-        value: points.positions,
-        size: coordLength
-      },
-      globalFeatureIds: {
-        value: points.globalFeatureIds,
-        size: 1
-      },
-      featureIds: {
-        value: points.featureIds,
-        size: 1
-      }
-    },
-    lines: { ...lines,
-      pathIndices: {
-        value: lines.pathIndices,
-        size: 1
-      },
-      positions: {
-        value: lines.positions,
-        size: coordLength
-      },
-      globalFeatureIds: {
-        value: lines.globalFeatureIds,
-        size: 1
-      },
-      featureIds: {
-        value: lines.featureIds,
-        size: 1
-      }
-    },
-    polygons: { ...polygons,
-      polygonIndices: {
-        value: polygons.polygonIndices,
-        size: 1
-      },
-      primitivePolygonIndices: {
-        value: polygons.primitivePolygonIndices,
-        size: 1
-      },
-      positions: {
-        value: polygons.positions,
-        size: coordLength
-      },
-      triangles: {
-        value: new Uint32Array(polygons.triangles),
-        size: 1
-      },
-      globalFeatureIds: {
-        value: polygons.globalFeatureIds,
-        size: 1
-      },
-      featureIds: {
-        value: polygons.featureIds,
-        size: 1
-      }
-    }
-  };
-
-  for (const geomType in returnObj) {
-    for (const numericProp in returnObj[geomType].numericProps) {
-      returnObj[geomType].numericProps[numericProp] = {
-        value: returnObj[geomType].numericProps[numericProp],
-        size: 1
-      };
-    }
-  }
-
-  return returnObj;
-}
-
-function fillNumericProperties(object, properties, index, length) {
-  for (const numericPropName in object.numericProps) {
-    if (numericPropName in properties) {
-      object.numericProps[numericPropName].fill(properties[numericPropName], index, index + length);
-    }
-  }
-}
-
-function keepStringProperties(properties, numericKeys) {
-  const props = {};
-
-  for (const key in properties) {
-    if (!numericKeys.includes(key)) {
-      props[key] = properties[key];
-    }
-  }
-
-  return props;
-}
-
-function isNumeric(x) {
-  return Number.isFinite(x);
-}
-//# sourceMappingURL=features-to-binary.js.map