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

package/dist/lib/parse-mvt.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/lib/parse-mvt.ts"],"names":["VectorTile","BinaryVectorTile","featuresToBinary","Protobuf","parseMVT","arrayBuffer","options","normalizeOptions","features","binary","gis","format","firstPassData","pointPositionsCount","pointFeaturesCount","linePositionsCount","linePathsCount","lineFeaturesCount","polygonPositionsCount","polygonObjectsCount","polygonRingsCount","polygonFeaturesCount","byteLength","tile","loaderOptions","mvt","selectedLayers","Array","isArray","layers","Object","keys","forEach","layerName","vectorTileLayer","featureOptions","i","length","vectorTileFeature","feature","decodedFeature","getDecodedFeatureBinary","getDecodedFeature","push","data","wgs84Coordinates","coordinates","tileIndex","hasTileIndex","Number","isFinite","x","y","z","Error","toGeoJSON","transformToLocalCoordinates","layerProperty","properties","toBinaryCoordinates","transformToLocalCoordinatesBinary","line","extent","p","il"],"mappings":"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","sourcesContent":["// import {VectorTile} from '@mapbox/vector-tile';\nimport VectorTile from './mapbox-vector-tile/vector-tile';\nimport BinaryVectorTile from './binary-vector-tile/vector-tile';\n\nimport {featuresToBinary} from './binary-vector-tile/features-to-binary';\nimport Protobuf from 'pbf';\nimport {MvtBinaryCoordinates, MvtMapboxCoordinates, MvtOptions} from '../lib/types';\nimport VectorTileFeatureBinary from './binary-vector-tile/vector-tile-feature';\nimport VectorTileFeatureMapBox from './mapbox-vector-tile/vector-tile-feature';\nimport {LoaderOptions} from '@loaders.gl/loader-utils/';\n\n/**\n * Parse MVT arrayBuffer and return GeoJSON.\n *\n * @param arrayBuffer A MVT arrayBuffer\n * @param options\n * @returns A GeoJSON geometry object or a binary representation\n */\nexport default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptions) {\n  options = normalizeOptions(options);\n  const features: (MvtBinaryCoordinates | MvtMapboxCoordinates)[] = [];\n\n  if (options) {\n    const binary = options.gis.format === 'binary';\n    const firstPassData = {\n      pointPositionsCount: 0,\n      pointFeaturesCount: 0,\n      linePositionsCount: 0,\n      linePathsCount: 0,\n      lineFeaturesCount: 0,\n      polygonPositionsCount: 0,\n      polygonObjectsCount: 0,\n      polygonRingsCount: 0,\n      polygonFeaturesCount: 0\n    };\n\n    if (arrayBuffer.byteLength > 0) {\n      const tile = binary\n        ? new BinaryVectorTile(new Protobuf(arrayBuffer))\n        : new VectorTile(new Protobuf(arrayBuffer));\n      const loaderOptions = options.mvt;\n\n      const selectedLayers = Array.isArray(loaderOptions.layers)\n        ? loaderOptions.layers\n        : Object.keys(tile.layers);\n\n      selectedLayers.forEach((layerName: string) => {\n        const vectorTileLayer = tile.layers[layerName];\n        const featureOptions = {...loaderOptions, layerName};\n\n        if (!vectorTileLayer) {\n          return;\n        }\n\n        for (let i = 0; i < vectorTileLayer.length; i++) {\n          const vectorTileFeature = vectorTileLayer.feature(i, firstPassData);\n\n          const decodedFeature = binary\n            ? getDecodedFeatureBinary(vectorTileFeature as VectorTileFeatureBinary, featureOptions)\n            : getDecodedFeature(vectorTileFeature as VectorTileFeatureMapBox, featureOptions);\n          features.push(decodedFeature);\n        }\n      });\n    }\n\n    if (binary) {\n      const data = featuresToBinary(features as MvtBinaryCoordinates[], firstPassData);\n      // Add the original byteLength (as a reasonable approximation of the size of the binary data)\n      // TODO decide where to store extra fields like byteLength (header etc) and document\n      // @ts-ignore\n      data.byteLength = arrayBuffer.byteLength;\n      return data;\n    }\n  }\n  return features;\n}\n\n/**\n * @param options\n * @returns options\n */\nfunction normalizeOptions(options: LoaderOptions | undefined) {\n  if (options) {\n    options = {\n      ...options,\n      mvt: options.mvt || {},\n      gis: options.gis || {}\n    };\n\n    // Validate\n    const wgs84Coordinates = options.coordinates === 'wgs84';\n    const {tileIndex} = options;\n    const hasTileIndex =\n      tileIndex &&\n      Number.isFinite(tileIndex.x) &&\n      Number.isFinite(tileIndex.y) &&\n      Number.isFinite(tileIndex.z);\n\n    if (wgs84Coordinates && !hasTileIndex) {\n      throw new Error(\n        'MVT Loader: WGS84 coordinates need tileIndex property. Check documentation.'\n      );\n    }\n  }\n  return options;\n}\n\n/**\n * @param feature\n * @param options\n * @returns decoded feature\n */\nfunction getDecodedFeature(\n  feature: VectorTileFeatureMapBox,\n  options: MvtOptions\n): MvtMapboxCoordinates {\n  const decodedFeature = feature.toGeoJSON(\n    options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinates\n  );\n\n  // Add layer name to GeoJSON properties\n  if (options.layerProperty) {\n    decodedFeature.properties[options.layerProperty] = options.layerName;\n  }\n\n  return decodedFeature;\n}\n\n/**\n * @param feature\n * @param options\n * @returns decoded binary feature\n */\nfunction getDecodedFeatureBinary(\n  feature: VectorTileFeatureBinary,\n  options: MvtOptions\n): MvtBinaryCoordinates {\n  const decodedFeature = feature.toBinaryCoordinates(\n    options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinatesBinary\n  );\n\n  // Add layer name to GeoJSON properties\n  if (options.layerProperty) {\n    decodedFeature.properties[options.layerProperty] = options.layerName;\n  }\n\n  return decodedFeature;\n}\n\n/**\n * @param line\n * @param feature\n */\nfunction transformToLocalCoordinates(line: number[], feature: {extent: any}): void {\n  // This function transforms local coordinates in a\n  // [0 - bufferSize, this.extent + bufferSize] range to a\n  // [0 - (bufferSize / this.extent), 1 + (bufferSize / this.extent)] range.\n  // The resulting extent would be 1.\n  const {extent} = feature;\n  for (let i = 0; i < line.length; i++) {\n    const p = line[i];\n    p[0] /= extent;\n    p[1] /= extent;\n  }\n}\n\nfunction transformToLocalCoordinatesBinary(data: number[], feature: {extent: any}) {\n  // For the binary code path, the feature data is just\n  // one big flat array, so we just divide each value\n  const {extent} = feature;\n  for (let i = 0, il = data.length; i < il; ++i) {\n    data[i] /= extent;\n  }\n}\n"],"file":"parse-mvt.js"}
+{"version":3,"sources":["../../src/lib/parse-mvt.ts"],"names":["VectorTile","BinaryVectorTile","flatGeojsonToBinary","Protobuf","parseMVT","arrayBuffer","options","normalizeOptions","features","binary","gis","format","geometryInfo","coordLength","pointPositionsCount","pointFeaturesCount","linePositionsCount","linePathsCount","lineFeaturesCount","polygonPositionsCount","polygonObjectsCount","polygonRingsCount","polygonFeaturesCount","byteLength","tile","loaderOptions","mvt","selectedLayers","Array","isArray","layers","Object","keys","forEach","layerName","vectorTileLayer","featureOptions","i","length","vectorTileFeature","feature","decodedFeature","getDecodedFeatureBinary","getDecodedFeature","push","data","wgs84Coordinates","coordinates","tileIndex","hasTileIndex","Number","isFinite","x","y","z","Error","toGeoJSON","transformToLocalCoordinates","layerProperty","properties","toBinaryCoordinates","transformToLocalCoordinatesBinary","line","extent","p","il"],"mappings":"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","sourcesContent":["// import {VectorTile} from '@mapbox/vector-tile';\nimport VectorTile from './mapbox-vector-tile/vector-tile';\nimport BinaryVectorTile from './binary-vector-tile/vector-tile';\n\nimport {flatGeojsonToBinary} from '@loaders.gl/gis';\nimport Protobuf from 'pbf';\nimport type {FlatFeature} from '@loaders.gl/schema';\nimport type {MvtMapboxCoordinates, MvtOptions} from '../lib/types';\nimport VectorTileFeatureBinary from './binary-vector-tile/vector-tile-feature';\nimport VectorTileFeatureMapBox from './mapbox-vector-tile/vector-tile-feature';\nimport {LoaderOptions} from '@loaders.gl/loader-utils';\n\n/**\n * Parse MVT arrayBuffer and return GeoJSON.\n *\n * @param arrayBuffer A MVT arrayBuffer\n * @param options\n * @returns A GeoJSON geometry object or a binary representation\n */\nexport default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptions) {\n  options = normalizeOptions(options);\n  const features: (FlatFeature | MvtMapboxCoordinates)[] = [];\n\n  if (options) {\n    const binary = options.gis.format === 'binary';\n    const geometryInfo = {\n      coordLength: 2,\n      pointPositionsCount: 0,\n      pointFeaturesCount: 0,\n      linePositionsCount: 0,\n      linePathsCount: 0,\n      lineFeaturesCount: 0,\n      polygonPositionsCount: 0,\n      polygonObjectsCount: 0,\n      polygonRingsCount: 0,\n      polygonFeaturesCount: 0\n    };\n\n    if (arrayBuffer.byteLength > 0) {\n      const tile = binary\n        ? new BinaryVectorTile(new Protobuf(arrayBuffer))\n        : new VectorTile(new Protobuf(arrayBuffer));\n      const loaderOptions = options.mvt;\n\n      const selectedLayers = Array.isArray(loaderOptions.layers)\n        ? loaderOptions.layers\n        : Object.keys(tile.layers);\n\n      selectedLayers.forEach((layerName: string) => {\n        const vectorTileLayer = tile.layers[layerName];\n        const featureOptions = {...loaderOptions, layerName};\n\n        if (!vectorTileLayer) {\n          return;\n        }\n\n        for (let i = 0; i < vectorTileLayer.length; i++) {\n          const vectorTileFeature = vectorTileLayer.feature(i, geometryInfo);\n\n          const decodedFeature = binary\n            ? getDecodedFeatureBinary(vectorTileFeature as VectorTileFeatureBinary, featureOptions)\n            : getDecodedFeature(vectorTileFeature as VectorTileFeatureMapBox, featureOptions);\n          features.push(decodedFeature);\n        }\n      });\n    }\n\n    if (binary) {\n      const data = flatGeojsonToBinary(features as FlatFeature[], geometryInfo);\n      // Add the original byteLength (as a reasonable approximation of the size of the binary data)\n      // TODO decide where to store extra fields like byteLength (header etc) and document\n      // @ts-ignore\n      data.byteLength = arrayBuffer.byteLength;\n      return data;\n    }\n  }\n  return features;\n}\n\n/**\n * @param options\n * @returns options\n */\nfunction normalizeOptions(options: LoaderOptions | undefined) {\n  if (options) {\n    options = {\n      ...options,\n      mvt: options.mvt || {},\n      gis: options.gis || {}\n    };\n\n    // Validate\n    const wgs84Coordinates = options.coordinates === 'wgs84';\n    const {tileIndex} = options;\n    const hasTileIndex =\n      tileIndex &&\n      Number.isFinite(tileIndex.x) &&\n      Number.isFinite(tileIndex.y) &&\n      Number.isFinite(tileIndex.z);\n\n    if (wgs84Coordinates && !hasTileIndex) {\n      throw new Error(\n        'MVT Loader: WGS84 coordinates need tileIndex property. Check documentation.'\n      );\n    }\n  }\n  return options;\n}\n\n/**\n * @param feature\n * @param options\n * @returns decoded feature\n */\nfunction getDecodedFeature(\n  feature: VectorTileFeatureMapBox,\n  options: MvtOptions\n): MvtMapboxCoordinates {\n  const decodedFeature = feature.toGeoJSON(\n    options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinates\n  );\n\n  // Add layer name to GeoJSON properties\n  if (options.layerProperty) {\n    decodedFeature.properties[options.layerProperty] = options.layerName;\n  }\n\n  return decodedFeature;\n}\n\n/**\n * @param feature\n * @param options\n * @returns decoded binary feature\n */\nfunction getDecodedFeatureBinary(\n  feature: VectorTileFeatureBinary,\n  options: MvtOptions\n): FlatFeature {\n  const decodedFeature = feature.toBinaryCoordinates(\n    options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinatesBinary\n  );\n\n  // Add layer name to GeoJSON properties\n  if (options.layerProperty && decodedFeature.properties) {\n    decodedFeature.properties[options.layerProperty] = options.layerName;\n  }\n\n  return decodedFeature;\n}\n\n/**\n * @param line\n * @param feature\n */\nfunction transformToLocalCoordinates(line: number[], feature: {extent: any}): void {\n  // This function transforms local coordinates in a\n  // [0 - bufferSize, this.extent + bufferSize] range to a\n  // [0 - (bufferSize / this.extent), 1 + (bufferSize / this.extent)] range.\n  // The resulting extent would be 1.\n  const {extent} = feature;\n  for (let i = 0; i < line.length; i++) {\n    const p = line[i];\n    p[0] /= extent;\n    p[1] /= extent;\n  }\n}\n\nfunction transformToLocalCoordinatesBinary(data: number[], feature: {extent: any}) {\n  // For the binary code path, the feature data is just\n  // one big flat array, so we just divide each value\n  const {extent} = feature;\n  for (let i = 0, il = data.length; i < il; ++i) {\n    data[i] /= extent;\n  }\n}\n"],"file":"parse-mvt.js"}

package/dist/lib/types.d.ts

@@ -0,0 +1,28 @@
+export declare type MvtOptions = {
+    coordinates: string | number[];
+    tileIndex: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    layerProperty: string | number;
+    layerName: string;
+};
+export declare type MvtMapboxGeometry = {
+    type?: string;
+    id?: number;
+    length: number;
+    coordinates?: any[];
+};
+export declare type MvtMapboxCoordinates = {
+    type: string;
+    geometry: {
+        type: string;
+        coordinates: MvtMapboxGeometry;
+    };
+    properties: {
+        [x: string]: string | number | boolean | null;
+    };
+    id?: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,oBAAY,UAAU,GAAG;IACvB,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC/B,SAAS,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;IAC7C,aAAa,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,oBAAY,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC;CACrB,CAAC;AAEF,oBAAY,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,iBAAiB,CAAC;KAChC,CAAC;IACF,UAAU,EAAE;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;KAAC,CAAC;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC"}

package/dist/mvt-loader.d.ts

@@ -0,0 +1,10 @@
+import type { Loader, LoaderWithParser } from '@loaders.gl/loader-utils';
+/**
+ * Worker loader for the Mapbox Vector Tile format
+ */
+export declare const MVTWorkerLoader: Loader;
+/**
+ * Loader for the Mapbox Vector Tile format
+ */
+export declare const MVTLoader: LoaderWithParser;
+//# sourceMappingURL=mvt-loader.d.ts.map

package/dist/mvt-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mvt-loader.d.ts","sourceRoot":"","sources":["../src/mvt-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAOvE;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,MAsB7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,gBAKvB,CAAC"}

package/dist/mvt-loader.js

@@ -1,5 +1,5 @@
 import parseMVT from './lib/parse-mvt';
-const VERSION = typeof "4.0.0-alpha.4" !== 'undefined' ? "4.0.0-alpha.4" : 'latest';
+const VERSION = typeof "4.0.0-alpha.5" !== 'undefined' ? "4.0.0-alpha.5" : 'latest';
 export const MVTWorkerLoader = {
   name: 'Mapbox Vector Tile',
   id: 'mvt',

package/dist/mvt-worker.js

@@ -1525,12 +1525,14 @@
 
   // src/helpers/binary-util-functions.ts
   function classifyRings2(geom) {
-    const len = geom.lines.length;
+    const len = geom.indices.length;
+    const type = "Polygon";
     if (len <= 1) {
       return {
+        type,
         data: geom.data,
         areas: [[getPolygonSignedArea(geom.data)]],
-        lines: [geom.lines]
+        indices: [geom.indices]
       };
     }
     const areas = [];
@@ -1540,8 +1542,8 @@
     let ccw;
     let offset = 0;
     for (let endIndex, i2 = 0, startIndex; i2 < len; i2++) {
-      startIndex = geom.lines[i2] - offset;
-      endIndex = geom.lines[i2 + 1] - offset || geom.data.length;
+      startIndex = geom.indices[i2] - offset;
+      endIndex = geom.indices[i2 + 1] - offset || geom.data.length;
       const shape = geom.data.slice(startIndex, endIndex);
       const area2 = getPolygonSignedArea(shape);
       if (area2 === 0) {
@@ -1569,7 +1571,7 @@
       areas.push(ringAreas);
     if (polygon.length)
       polygons.push(polygon);
-    return { areas, lines: polygons, data: geom.data };
+    return { type, areas, indices: polygons, data: geom.data };
   }
   function project(data, x0, y0, size) {
     for (let j = 0, jl = data.length; j < jl; j += 2) {
@@ -1608,10 +1610,7 @@
   var y;
   var i;
   var VectorTileFeature2 = class {
-    static get types() {
-      return ["Unknown", "Point", "LineString", "Polygon"];
-    }
-    constructor(pbf, end, extent, keys, values, firstPassData) {
+    constructor(pbf, end, extent, keys, values, geometryInfo) {
       this.properties = {};
       this.extent = extent;
       this.type = 0;
@@ -1620,7 +1619,7 @@
       this._geometry = -1;
       this._keys = keys;
       this._values = values;
-      this._firstPassData = firstPassData;
+      this._geometryInfo = geometryInfo;
       pbf.readFields(readFeature2, this, end);
     }
     loadGeometry() {
@@ -1632,7 +1631,7 @@
       x = 0;
       y = 0;
       i = 0;
-      const lines = [];
+      const indices = [];
       const data = [];
       while (pbf.pos < endPos) {
         if (length <= 0) {
@@ -1645,13 +1644,13 @@
           x += pbf.readSVarint();
           y += pbf.readSVarint();
           if (cmd === 1) {
-            lines.push(i);
+            indices.push(i);
           }
           data.push(x, y);
           i += 2;
         } else if (cmd === 7) {
           if (i > 0) {
-            const start = lines[lines.length - 1];
+            const start = indices[indices.length - 1];
             data.push(data[start], data[start + 1]);
             i += 2;
           }
@@ -1659,42 +1658,38 @@
           throw new Error(`unknown command ${cmd}`);
         }
       }
-      return { data, lines };
+      return { data, indices };
     }
     _toBinaryCoordinates(transform) {
-      let geom = this.loadGeometry();
+      const geom = this.loadGeometry();
+      let geometry;
       transform(geom.data, this);
       const coordLength = 2;
       switch (this.type) {
         case 1:
-          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:
-          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:
-          const classified = classifyRings2(geom);
-          this._firstPassData.polygonFeaturesCount++;
-          this._firstPassData.polygonObjectsCount += classified.lines.length;
-          for (const lines of classified.lines) {
-            this._firstPassData.polygonRingsCount += lines.length;
+          geometry = classifyRings2(geom);
+          this._geometryInfo.polygonFeaturesCount++;
+          this._geometryInfo.polygonObjectsCount += geometry.indices.length;
+          for (const indices of geometry.indices) {
+            this._geometryInfo.polygonRingsCount += indices.length;
           }
-          this._firstPassData.polygonPositionsCount += classified.data.length / coordLength;
-          geom = classified;
+          this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
           break;
+        default:
+          throw new Error(`Invalid geometry type: ${this.type}`);
       }
-      geom.type = VectorTileFeature2.types[this.type];
-      if (geom.lines.length > 1) {
-        geom.type = `Multi${geom.type}`;
-      }
-      const result = {
-        type: "Feature",
-        geometry: geom,
-        properties: this.properties
-      };
+      const result = { type: "Feature", geometry, properties: this.properties };
       if (this.id !== null) {
         result.id = this.id;
       }
@@ -1722,13 +1717,13 @@
       pbf.readFields(readLayer2, this, end);
       this.length = this._features.length;
     }
-    feature(i2, firstPassData) {
+    feature(i2, geometryInfo) {
       if (i2 < 0 || i2 >= this._features.length) {
         throw new Error("feature index out of bounds");
       }
       this._pbf.pos = this._features[i2];
       const end = this._pbf.readVarint() + this._pbf.pos;
-      return new VectorTileFeature2(this._pbf, end, this.extent, this._keys, this._values, firstPassData);
+      return new VectorTileFeature2(this._pbf, end, this.extent, this._keys, this._values, geometryInfo);
     }
   };
   function readLayer2(tag, layer, pbf) {
@@ -1774,29 +1769,31 @@
     }
   }
 
-  // src/lib/binary-vector-tile/features-to-binary.ts
-  function featuresToBinary(features, firstPassData, options) {
-    return fillArrays(features, firstPassData, {
-      numericPropKeys: options ? options.numericPropKeys : extractNumericPropKeys(features),
+  // ../gis/src/lib/flat-geojson-to-binary.ts
+  function flatGeojsonToBinary(features, geometryInfo, options) {
+    const propArrayTypes = extractNumericPropTypes(features);
+    const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
+    return fillArrays(features, {
+      propArrayTypes,
+      ...geometryInfo
+    }, {
+      numericPropKeys: options && options.numericPropKeys || numericPropKeys,
       PositionDataType: options ? options.PositionDataType : Float32Array
     });
   }
-  function extractNumericPropKeys(features) {
-    const numericPropKeys = {};
+  function extractNumericPropTypes(features) {
+    const propArrayTypes = {};
     for (const feature of features) {
       if (feature.properties) {
         for (const key in feature.properties) {
-          const numericSoFar = numericPropKeys[key];
-          if (numericSoFar || numericSoFar === void 0) {
-            const val = feature.properties[key];
-            numericPropKeys[key] = isNumeric(val);
-          }
+          const val = feature.properties[key];
+          propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);
         }
       }
     }
-    return Object.keys(numericPropKeys).filter((k) => numericPropKeys[k]);
+    return propArrayTypes;
   }
-  function fillArrays(features, firstPassData, options) {
+  function fillArrays(features, geometryInfo, options) {
     const {
       pointPositionsCount,
       pointFeaturesCount,
@@ -1806,13 +1803,15 @@
       polygonPositionsCount,
       polygonObjectsCount,
       polygonRingsCount,
-      polygonFeaturesCount
-    } = firstPassData;
-    const { numericPropKeys, PositionDataType = Float32Array } = options;
+      polygonFeaturesCount,
+      propArrayTypes,
+      coordLength
+    } = geometryInfo;
+    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 = {
+      type: "Point",
       positions: new PositionDataType(pointPositionsCount * coordLength),
       globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
       featureIds: pointFeaturesCount > 65535 ? new Uint32Array(pointPositionsCount) : new Uint16Array(pointPositionsCount),
@@ -1821,6 +1820,7 @@
       fields: []
     };
     const lines = {
+      type: "LineString",
       pathIndices: linePositionsCount > 65535 ? new Uint32Array(linePathsCount + 1) : new Uint16Array(linePathsCount + 1),
       positions: new PositionDataType(linePositionsCount * coordLength),
       globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
@@ -1830,6 +1830,7 @@
       fields: []
     };
     const polygons = {
+      type: "Polygon",
       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),
@@ -1842,7 +1843,8 @@
     };
     for (const object of [points, lines, polygons]) {
       for (const propName of numericPropKeys) {
-        object.numericProps[propName] = new Float32Array(object.positions.length / coordLength);
+        const T = propArrayTypes[propName];
+        object.numericProps[propName] = new T(object.positions.length / coordLength);
       }
     }
     lines.pathIndices[linePathsCount] = linePositionsCount;
@@ -1865,7 +1867,6 @@
       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) {
@@ -1874,7 +1875,6 @@
           indexMap.pointFeature++;
           break;
         case "LineString":
-        case "MultiLineString":
           handleLineString(geometry, lines, indexMap, coordLength, properties);
           lines.properties.push(keepStringProperties(properties, numericPropKeys));
           if (hasGlobalId) {
@@ -1883,7 +1883,6 @@
           indexMap.lineFeature++;
           break;
         case "Polygon":
-        case "MultiPolygon":
           handlePolygon(geometry, polygons, indexMap, coordLength, properties);
           polygons.properties.push(keepStringProperties(properties, numericPropKeys));
           if (hasGlobalId) {
@@ -1912,9 +1911,9 @@
     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 i2 = 0, il = geometry.lines.length; i2 < il; ++i2) {
-      const start = geometry.lines[i2];
-      const end = i2 === il - 1 ? geometry.data.length : geometry.lines[i2 + 1];
+    for (let i2 = 0, il = geometry.indices.length; i2 < il; ++i2) {
+      const start = geometry.indices[i2];
+      const end = i2 === il - 1 ? geometry.data.length : geometry.indices[i2 + 1];
       lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
       indexMap.linePosition += (end - start) / coordLength;
     }
@@ -1925,23 +1924,23 @@
     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) {
+    for (let l = 0, ll = geometry.indices.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 i2 = 0, il = lines.length; i2 < il; ++i2) {
-        const start = lines[i2];
-        const end = i2 === il - 1 ? nextLines === void 0 ? geometry.data.length : nextLines[0] : lines[i2 + 1];
+      const indices = geometry.indices[l];
+      const nextIndices = geometry.indices[l + 1];
+      for (let i2 = 0, il = indices.length; i2 < il; ++i2) {
+        const start = indices[i2];
+        const end = i2 === il - 1 ? nextIndices === void 0 ? geometry.data.length : nextIndices[0] : indices[i2 + 1];
         polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
         indexMap.polygonPosition += (end - start) / coordLength;
       }
       const endPosition = indexMap.polygonPosition;
-      triangulatePolygon(polygons, areas, lines, { startPosition, endPosition, coordLength });
+      triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength });
     }
   }
-  function triangulatePolygon(polygons, areas, lines, {
+  function triangulatePolygon(polygons, areas, indices, {
     startPosition,
     endPosition,
     coordLength
@@ -1949,52 +1948,54 @@
     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]);
+    const offset = indices[0];
+    const holes = indices.slice(1).map((n) => (n - offset) / coordLength);
+    const triangles = earcut(polygonPositions, holes, coordLength, areas);
+    for (let t = 0, tl = triangles.length; t < tl; ++t) {
+      polygons.triangles.push(startPosition + triangles[t]);
+    }
+  }
+  function wrapProps(obj, size) {
+    const returnObj = {};
+    for (const key in obj) {
+      returnObj[key] = { value: obj[key], size };
     }
+    return returnObj;
   }
   function makeAccessorObjects(points, lines, polygons, coordLength) {
-    const returnObj = {
+    return {
       points: {
         ...points,
         positions: { value: points.positions, size: coordLength },
         globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
-        featureIds: { value: points.featureIds, size: 1 }
+        featureIds: { value: points.featureIds, size: 1 },
+        numericProps: wrapProps(points.numericProps, 1)
       },
       lines: {
         ...lines,
-        pathIndices: { value: lines.pathIndices, size: 1 },
         positions: { value: lines.positions, size: coordLength },
+        pathIndices: { value: lines.pathIndices, size: 1 },
         globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
-        featureIds: { value: lines.featureIds, size: 1 }
+        featureIds: { value: lines.featureIds, size: 1 },
+        numericProps: wrapProps(lines.numericProps, 1)
       },
       polygons: {
         ...polygons,
+        positions: { value: polygons.positions, size: coordLength },
         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 }
+        featureIds: { value: polygons.featureIds, size: 1 },
+        numericProps: wrapProps(polygons.numericProps, 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, length2) {
     for (const numericPropName in object.numericProps) {
       if (numericPropName in properties) {
-        object.numericProps[numericPropName].fill(properties[numericPropName], index, index + length2);
+        const value = properties[numericPropName];
+        object.numericProps[numericPropName].fill(value, index, index + length2);
       }
     }
   }
@@ -2007,8 +2008,11 @@
     }
     return props;
   }
-  function isNumeric(x2) {
-    return Number.isFinite(x2);
+  function deduceArrayType(x2, constructor) {
+    if (constructor === Array || !Number.isFinite(x2)) {
+      return Array;
+    }
+    return constructor === Float64Array || Math.fround(x2) !== x2 ? Float64Array : Float32Array;
   }
 
   // src/lib/parse-mvt.ts
@@ -2018,7 +2022,8 @@
     const features = [];
     if (options) {
       const binary = options.gis.format === "binary";
-      const firstPassData = {
+      const geometryInfo = {
+        coordLength: 2,
         pointPositionsCount: 0,
         pointFeaturesCount: 0,
         linePositionsCount: 0,
@@ -2040,14 +2045,14 @@
             return;
           }
           for (let i2 = 0; i2 < vectorTileLayer.length; i2++) {
-            const vectorTileFeature = vectorTileLayer.feature(i2, firstPassData);
+            const vectorTileFeature = vectorTileLayer.feature(i2, geometryInfo);
             const decodedFeature = binary ? getDecodedFeatureBinary(vectorTileFeature, featureOptions) : getDecodedFeature(vectorTileFeature, featureOptions);
             features.push(decodedFeature);
           }
         });
       }
       if (binary) {
-        const data = featuresToBinary(features, firstPassData);
+        const data = flatGeojsonToBinary(features, geometryInfo);
         data.byteLength = arrayBuffer.byteLength;
         return data;
       }
@@ -2079,7 +2084,7 @@
   }
   function getDecodedFeatureBinary(feature, options) {
     const decodedFeature = feature.toBinaryCoordinates(options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinatesBinary);
-    if (options.layerProperty) {
+    if (options.layerProperty && decodedFeature.properties) {
       decodedFeature.properties[options.layerProperty] = options.layerName;
     }
     return decodedFeature;
@@ -2100,7 +2105,7 @@
   }
 
   // src/mvt-loader.ts
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION = true ? "4.0.0-alpha.5" : "latest";
   var MVTWorkerLoader = {
     name: "Mapbox Vector Tile",
     id: "mvt",

package/dist/workers/mvt-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mvt-worker.d.ts.map

package/dist/workers/mvt-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mvt-worker.d.ts","sourceRoot":"","sources":["../../src/workers/mvt-worker.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/mvt",
   "description": "Loader for Mapbox Vector Tiles",
-  "version": "4.0.0-alpha.4",
+  "version": "4.0.0-alpha.5",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -17,7 +17,7 @@
     "MVT",
     "Mapbox Vector Tiles"
   ],
-  "types": "src/index.ts",
+  "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "sideEffects": false,
@@ -28,17 +28,18 @@
   ],
   "scripts": {
     "pre-build": "npm run build-worker && npm run build-worker --env.dev && npm run build-bundle",
-    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js",
-    "build-worker": "esbuild src/workers/mvt-worker.ts --bundle --outfile=dist/mvt-worker.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js",
+    "build-worker": "esbuild src/workers/mvt-worker.ts --bundle --outfile=dist/mvt-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/gis": "4.0.0-alpha.4",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.4",
+    "@loaders.gl/gis": "4.0.0-alpha.5",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.5",
+    "@loaders.gl/schema": "4.0.0-alpha.5",
     "@math.gl/polygon": "^3.5.1",
     "pbf": "^3.2.1"
   },
   "devDependencies": {
     "@types/pbf": "^3.0.2"
   },
-  "gitHead": "53026061b3c8871f7e96d3a5826125cc6613bddc"
+  "gitHead": "7a71a54bdf1ddf985cc3af3db90b82e7fa97d025"
 }

package/src/helpers/binary-util-functions.ts

@@ -1,6 +1,6 @@
 import Protobuf from 'pbf';
 import {getPolygonSignedArea} from '@math.gl/polygon';
-import {MvtBinaryGeometry} from '../lib/types';
+import {FlatIndexedGeometry, FlatPolygon} from '@loaders.gl/schema';
 import VectorTileFeature from '../lib/binary-vector-tile/vector-tile-feature';
 
 /**
@@ -13,14 +13,16 @@ import VectorTileFeature from '../lib/binary-vector-tile/vector-tile-feature';
  * @returns object
  */
 // eslint-disable-next-line max-statements
-export function classifyRings(geom: MvtBinaryGeometry) {
-  const len = geom.lines.length;
+export function classifyRings(geom: FlatIndexedGeometry): FlatPolygon {
+  const len = geom.indices.length;
+  const type = 'Polygon';
 
   if (len <= 1) {
     return {
+      type,
       data: geom.data,
       areas: [[getPolygonSignedArea(geom.data)]],
-      lines: [geom.lines]
+      indices: [geom.indices]
     };
   }
 
@@ -32,9 +34,9 @@ export function classifyRings(geom: MvtBinaryGeometry) {
   let offset = 0;
 
   for (let endIndex: number, i = 0, startIndex: number; i < len; i++) {
-    startIndex = geom.lines[i] - offset;
+    startIndex = geom.indices[i] - offset;
 
-    endIndex = geom.lines[i + 1] - offset || geom.data.length;
+    endIndex = geom.indices[i + 1] - offset || geom.data.length;
     const shape = geom.data.slice(startIndex, endIndex);
     const area = getPolygonSignedArea(shape);
 
@@ -70,7 +72,7 @@ export function classifyRings(geom: MvtBinaryGeometry) {
   if (ringAreas) areas.push(ringAreas);
   if (polygon.length) polygons.push(polygon);
 
-  return {areas, lines: polygons, data: geom.data};
+  return {type, areas, indices: polygons, data: geom.data};
 }
 
 /**