@loaders.gl/mvt 3.1.0-alpha.3 → 3.1.0-beta.2

package/dist/lib/parse-mvt.d.ts

@@ -0,0 +1,85 @@
+import { MvtBinaryCoordinates, MvtMapboxCoordinates } from '../lib/types';
+import { LoaderOptions } from '@loaders.gl/loader-utils';
+/**
+ * Parse MVT arrayBuffer and return GeoJSON.
+ *
+ * @param arrayBuffer A MVT arrayBuffer
+ * @param options
+ * @returns A GeoJSON geometry object or a binary representation
+ */
+export default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptions): {
+    points: {
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        globalFeatureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        featureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        numericProps: object;
+        properties: {}[];
+        fields: {
+            id?: number | undefined;
+        }[];
+    };
+    lines: {
+        pathIndices: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        globalFeatureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        featureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        numericProps: object;
+        properties: {}[];
+        fields: {
+            id?: number | undefined;
+        }[];
+    };
+    polygons: {
+        polygonIndices: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        primitivePolygonIndices: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        triangles: {
+            value: Uint32Array;
+            size: number;
+        };
+        globalFeatureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        featureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        numericProps: object;
+        properties: {}[];
+        fields: {
+            id?: number | undefined;
+        }[];
+    };
+} | (MvtBinaryCoordinates | MvtMapboxCoordinates)[];
+//# sourceMappingURL=parse-mvt.d.ts.map

package/dist/lib/parse-mvt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-mvt.d.ts","sourceRoot":"","sources":["../../src/lib/parse-mvt.ts"],"names":[],"mappings":"AAMA,OAAO,EAAC,oBAAoB,EAAE,oBAAoB,EAAa,MAAM,cAAc,CAAC;AAGpF,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAEvD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAyDjF"}

package/dist/lib/parse-mvt.js

@@ -1,116 +1,142 @@
-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 Protobuf from 'pbf';
-export default function parseMVT(arrayBuffer, options) {
-  options = normalizeOptions(options);
-  const features = [];
-
-  if (options) {
-    const binary = options.gis.format === 'binary';
-    const firstPassData = {
-      pointPositionsCount: 0,
-      pointFeaturesCount: 0,
-      linePositionsCount: 0,
-      linePathsCount: 0,
-      lineFeaturesCount: 0,
-      polygonPositionsCount: 0,
-      polygonObjectsCount: 0,
-      polygonRingsCount: 0,
-      polygonFeaturesCount: 0
-    };
-
-    if (arrayBuffer.byteLength > 0) {
-      const tile = binary ? new BinaryVectorTile(new Protobuf(arrayBuffer)) : new VectorTile(new Protobuf(arrayBuffer));
-      const loaderOptions = options.mvt;
-      const selectedLayers = Array.isArray(loaderOptions.layers) ? loaderOptions.layers : Object.keys(tile.layers);
-      selectedLayers.forEach(layerName => {
-        const vectorTileLayer = tile.layers[layerName];
-        const featureOptions = { ...loaderOptions,
-          layerName
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// import {VectorTile} from '@mapbox/vector-tile';
+const vector_tile_1 = __importDefault(require("./mapbox-vector-tile/vector-tile"));
+const vector_tile_2 = __importDefault(require("./binary-vector-tile/vector-tile"));
+const features_to_binary_1 = require("./binary-vector-tile/features-to-binary");
+const pbf_1 = __importDefault(require("pbf"));
+/**
+ * Parse MVT arrayBuffer and return GeoJSON.
+ *
+ * @param arrayBuffer A MVT arrayBuffer
+ * @param options
+ * @returns A GeoJSON geometry object or a binary representation
+ */
+function parseMVT(arrayBuffer, options) {
+    options = normalizeOptions(options);
+    const features = [];
+    if (options) {
+        const binary = options.gis.format === 'binary';
+        const firstPassData = {
+            pointPositionsCount: 0,
+            pointFeaturesCount: 0,
+            linePositionsCount: 0,
+            linePathsCount: 0,
+            lineFeaturesCount: 0,
+            polygonPositionsCount: 0,
+            polygonObjectsCount: 0,
+            polygonRingsCount: 0,
+            polygonFeaturesCount: 0
         };
-
-        if (!vectorTileLayer) {
-          return;
+        if (arrayBuffer.byteLength > 0) {
+            const tile = binary
+                ? new vector_tile_2.default(new pbf_1.default(arrayBuffer))
+                : new vector_tile_1.default(new pbf_1.default(arrayBuffer));
+            const loaderOptions = options.mvt;
+            const selectedLayers = Array.isArray(loaderOptions.layers)
+                ? loaderOptions.layers
+                : Object.keys(tile.layers);
+            selectedLayers.forEach((layerName) => {
+                const vectorTileLayer = tile.layers[layerName];
+                const featureOptions = { ...loaderOptions, layerName };
+                if (!vectorTileLayer) {
+                    return;
+                }
+                for (let i = 0; i < vectorTileLayer.length; i++) {
+                    const vectorTileFeature = vectorTileLayer.feature(i, firstPassData);
+                    const decodedFeature = binary
+                        ? getDecodedFeatureBinary(vectorTileFeature, featureOptions)
+                        : getDecodedFeature(vectorTileFeature, featureOptions);
+                    features.push(decodedFeature);
+                }
+            });
         }
-
-        for (let i = 0; i < vectorTileLayer.length; i++) {
-          const vectorTileFeature = vectorTileLayer.feature(i, firstPassData);
-          const decodedFeature = binary ? getDecodedFeatureBinary(vectorTileFeature, featureOptions) : getDecodedFeature(vectorTileFeature, featureOptions);
-          features.push(decodedFeature);
+        if (binary) {
+            const data = (0, features_to_binary_1.featuresToBinary)(features, firstPassData);
+            // 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
+            data.byteLength = arrayBuffer.byteLength;
+            return data;
         }
-      });
     }
-
-    if (binary) {
-      const data = featuresToBinary(features, firstPassData);
-      data.byteLength = arrayBuffer.byteLength;
-      return data;
-    }
-  }
-
-  return features;
+    return features;
 }
-
+exports.default = parseMVT;
+/**
+ * @param options
+ * @returns options
+ */
 function normalizeOptions(options) {
-  if (options) {
-    options = { ...options,
-      mvt: options.mvt || {},
-      gis: options.gis || {}
-    };
-    const wgs84Coordinates = options.coordinates === 'wgs84';
-    const {
-      tileIndex
-    } = options;
-    const hasTileIndex = tileIndex && Number.isFinite(tileIndex.x) && Number.isFinite(tileIndex.y) && Number.isFinite(tileIndex.z);
-
-    if (wgs84Coordinates && !hasTileIndex) {
-      throw new Error('MVT Loader: WGS84 coordinates need tileIndex property. Check documentation.');
+    if (options) {
+        options = {
+            ...options,
+            mvt: options.mvt || {},
+            gis: options.gis || {}
+        };
+        // Validate
+        const wgs84Coordinates = options.coordinates === 'wgs84';
+        const { tileIndex } = options;
+        const hasTileIndex = tileIndex &&
+            Number.isFinite(tileIndex.x) &&
+            Number.isFinite(tileIndex.y) &&
+            Number.isFinite(tileIndex.z);
+        if (wgs84Coordinates && !hasTileIndex) {
+            throw new Error('MVT Loader: WGS84 coordinates need tileIndex property. Check documentation.');
+        }
     }
-  }
-
-  return options;
+    return options;
 }
-
+/**
+ * @param feature
+ * @param options
+ * @returns decoded feature
+ */
 function getDecodedFeature(feature, options) {
-  const decodedFeature = feature.toGeoJSON(options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinates);
-
-  if (options.layerProperty) {
-    decodedFeature.properties[options.layerProperty] = options.layerName;
-  }
-
-  return decodedFeature;
+    const decodedFeature = feature.toGeoJSON(options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinates);
+    // Add layer name to GeoJSON properties
+    if (options.layerProperty) {
+        decodedFeature.properties[options.layerProperty] = options.layerName;
+    }
+    return decodedFeature;
 }
-
+/**
+ * @param feature
+ * @param options
+ * @returns decoded binary feature
+ */
 function getDecodedFeatureBinary(feature, options) {
-  const decodedFeature = feature.toBinaryCoordinates(options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinatesBinary);
-
-  if (options.layerProperty) {
-    decodedFeature.properties[options.layerProperty] = options.layerName;
-  }
-
-  return decodedFeature;
+    const decodedFeature = feature.toBinaryCoordinates(options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinatesBinary);
+    // Add layer name to GeoJSON properties
+    if (options.layerProperty) {
+        decodedFeature.properties[options.layerProperty] = options.layerName;
+    }
+    return decodedFeature;
 }
-
+/**
+ * @param line
+ * @param feature
+ */
 function transformToLocalCoordinates(line, feature) {
-  const {
-    extent
-  } = feature;
-
-  for (let i = 0; i < line.length; i++) {
-    const p = line[i];
-    p[0] /= extent;
-    p[1] /= extent;
-  }
+    // This function transforms local coordinates in a
+    // [0 - bufferSize, this.extent + bufferSize] range to a
+    // [0 - (bufferSize / this.extent), 1 + (bufferSize / this.extent)] range.
+    // The resulting extent would be 1.
+    const { extent } = feature;
+    for (let i = 0; i < line.length; i++) {
+        const p = line[i];
+        p[0] /= extent;
+        p[1] /= extent;
+    }
 }
-
 function transformToLocalCoordinatesBinary(data, feature) {
-  const {
-    extent
-  } = feature;
-
-  for (let i = 0, il = data.length; i < il; ++i) {
-    data[i] /= extent;
-  }
+    // For the binary code path, the feature data is just
+    // one big flat array, so we just divide each value
+    const { extent } = feature;
+    for (let i = 0, il = data.length; i < il; ++i) {
+        data[i] /= extent;
+    }
 }
-//# sourceMappingURL=parse-mvt.js.map

package/dist/lib/types.d.ts

@@ -0,0 +1,92 @@
+export declare type MvtOptions = {
+    coordinates: string | number[];
+    tileIndex: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    layerProperty: string | number;
+    layerName: string;
+};
+export declare type MvtBinaryGeometry = {
+    data: number[];
+    lines: any[];
+    areas?: number[];
+    type?: string;
+    id?: number;
+};
+export declare type MvtMapboxGeometry = {
+    type?: string;
+    id?: number;
+    length: number;
+    coordinates?: any[];
+};
+export declare type MvtBinaryCoordinates = {
+    type: string;
+    geometry: MvtBinaryGeometry;
+    properties: {
+        [x: string]: string | number | boolean | null;
+    };
+    id?: number;
+};
+export declare type MvtMapboxCoordinates = {
+    type: string;
+    geometry: {
+        type: string;
+        coordinates: MvtMapboxGeometry;
+    };
+    properties: {
+        [x: string]: string | number | boolean | null;
+    };
+    id?: number;
+};
+export declare type MvtBinaryOptions = {
+    numericPropKeys: string[];
+    PositionDataType: Float32ArrayConstructor;
+};
+export declare type MvtFirstPassedData = {
+    pointPositionsCount: number;
+    pointFeaturesCount: number;
+    linePositionsCount: number;
+    linePathsCount: number;
+    lineFeaturesCount: number;
+    polygonPositionsCount: number;
+    polygonObjectsCount: number;
+    polygonRingsCount: number;
+    polygonFeaturesCount: number;
+};
+export declare type MvtPoints = {
+    positions: Float32Array;
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: object;
+    properties: {}[];
+    fields: {
+        id?: number;
+    }[];
+};
+export declare type MvtLines = {
+    pathIndices: Uint16Array | Uint32Array;
+    positions: Float32Array;
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: object;
+    properties: {}[];
+    fields: {
+        id?: number;
+    }[];
+};
+export declare type MvtPolygons = {
+    polygonIndices: Uint16Array | Uint32Array;
+    primitivePolygonIndices: Uint16Array | Uint32Array;
+    positions: Float32Array;
+    triangles: number[];
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: object;
+    properties: {}[];
+    fields: {
+        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":"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"}

package/dist/lib/types.js

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=types.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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,26 +1,45 @@
-import parseMVT from './lib/parse-mvt';
-const VERSION = typeof "3.1.0-alpha.3" !== 'undefined' ? "3.1.0-alpha.3" : 'latest';
-export const MVTWorkerLoader = {
-  name: 'Mapbox Vector Tile',
-  id: 'mvt',
-  module: 'mvt',
-  version: VERSION,
-  extensions: ['mvt', 'pbf'],
-  mimeTypes: ['application/vnd.mapbox-vector-tile', 'application/x-protobuf'],
-  worker: true,
-  category: 'geometry',
-  options: {
-    mvt: {
-      coordinates: 'local',
-      layerProperty: 'layerName',
-      layers: null,
-      tileIndex: null
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MVTLoader = exports.MVTWorkerLoader = void 0;
+const parse_mvt_1 = __importDefault(require("./lib/parse-mvt"));
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+/**
+ * Worker loader for the Mapbox Vector Tile format
+ */
+exports.MVTWorkerLoader = {
+    name: 'Mapbox Vector Tile',
+    id: 'mvt',
+    module: 'mvt',
+    version: VERSION,
+    // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'
+    extensions: ['mvt', 'pbf'],
+    mimeTypes: [
+        'application/vnd.mapbox-vector-tile',
+        'application/x-protobuf'
+        // 'application/octet-stream'
+    ],
+    worker: true,
+    category: 'geometry',
+    options: {
+        mvt: {
+            coordinates: 'local',
+            layerProperty: 'layerName',
+            layers: null,
+            tileIndex: null
+        }
     }
-  }
 };
-export const MVTLoader = { ...MVTWorkerLoader,
-  parse: async (arrayBuffer, options) => parseMVT(arrayBuffer, options),
-  parseSync: parseMVT,
-  binary: true
+/**
+ * Loader for the Mapbox Vector Tile format
+ */
+exports.MVTLoader = {
+    ...exports.MVTWorkerLoader,
+    parse: async (arrayBuffer, options) => (0, parse_mvt_1.default)(arrayBuffer, options),
+    parseSync: parse_mvt_1.default,
+    binary: true
 };
-//# sourceMappingURL=mvt-loader.js.map