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

package/dist/lib/parse-mvt.js

@@ -1,116 +1,167 @@
-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
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gis_1 = require("@loaders.gl/gis");
+const pbf_1 = __importDefault(require("pbf"));
+const vector_tile_1 = __importDefault(require("./mapbox-vector-tile/vector-tile"));
+const vector_tile_2 = __importDefault(require("./binary-vector-tile/vector-tile"));
+/**
+ * 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) {
+    const mvtOptions = normalizeOptions(options);
+    const shape = options?.gis?.format || options?.mvt?.shape;
+    switch (shape) {
+        case 'columnar-table': // binary + some JS arrays
+            return { shape: 'columnar-table', data: parseToBinary(arrayBuffer, mvtOptions) };
+        case 'geojson-row-table': {
+            const table = {
+                shape: 'geojson-row-table',
+                data: parseToGeojson(arrayBuffer, mvtOptions)
+            };
+            return table;
+        }
+        case 'geojson':
+            return parseToGeojson(arrayBuffer, mvtOptions);
+        case 'binary-geometry':
+            return parseToBinary(arrayBuffer, mvtOptions);
+        case 'binary':
+            return parseToBinary(arrayBuffer, mvtOptions);
+        default:
+            throw new Error(shape);
+    }
+}
+exports.default = parseMVT;
+function parseToBinary(arrayBuffer, options) {
+    const [flatGeoJsonFeatures, geometryInfo] = parseToFlatGeoJson(arrayBuffer, options);
+    const binaryData = (0, gis_1.flatGeojsonToBinary)(flatGeoJsonFeatures, 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
+    binaryData.byteLength = arrayBuffer.byteLength;
+    return binaryData;
+}
+function parseToFlatGeoJson(arrayBuffer, options) {
+    const features = [];
+    const geometryInfo = {
+        coordLength: 2,
+        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 => {
+    if (arrayBuffer.byteLength <= 0) {
+        return [features, geometryInfo];
+    }
+    const tile = new vector_tile_2.default(new pbf_1.default(arrayBuffer));
+    const selectedLayers = options && Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
+    selectedLayers.forEach((layerName) => {
         const vectorTileLayer = tile.layers[layerName];
-        const featureOptions = { ...loaderOptions,
-          layerName
-        };
-
         if (!vectorTileLayer) {
-          return;
+            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);
+            const vectorTileFeature = vectorTileLayer.feature(i, geometryInfo);
+            const decodedFeature = getDecodedFeatureBinary(vectorTileFeature, options, layerName);
+            features.push(decodedFeature);
         }
-      });
-    }
-
-    if (binary) {
-      const data = featuresToBinary(features, firstPassData);
-      data.byteLength = arrayBuffer.byteLength;
-      return data;
+    });
+    return [features, geometryInfo];
+}
+function parseToGeojson(arrayBuffer, options) {
+    if (arrayBuffer.byteLength <= 0) {
+        return [];
     }
-  }
-
-  return features;
+    const features = [];
+    const tile = new vector_tile_1.default(new pbf_1.default(arrayBuffer));
+    const selectedLayers = Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
+    selectedLayers.forEach((layerName) => {
+        const vectorTileLayer = tile.layers[layerName];
+        if (!vectorTileLayer) {
+            return;
+        }
+        for (let i = 0; i < vectorTileLayer.length; i++) {
+            const vectorTileFeature = vectorTileLayer.feature(i);
+            const decodedFeature = getDecodedFeature(vectorTileFeature, options, layerName);
+            features.push(decodedFeature);
+        }
+    });
+    return features;
 }
-
 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 (!options?.mvt) {
+        throw new Error('mvt options required');
+    }
+    // Validate
+    const wgs84Coordinates = options.mvt?.coordinates === 'wgs84';
+    const { tileIndex } = options.mvt;
+    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.');
+        throw new Error('MVT Loader: WGS84 coordinates need tileIndex property');
     }
-  }
-
-  return options;
+    return options.mvt;
 }
-
-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;
+/**
+ * @param feature
+ * @param options
+ * @returns decoded feature
+ */
+function getDecodedFeature(feature, options, layerName) {
+    const decodedFeature = feature.toGeoJSON(options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinates);
+    // Add layer name to GeoJSON properties
+    if (options.layerProperty) {
+        decodedFeature.properties[options.layerProperty] = layerName;
+    }
+    return decodedFeature;
 }
-
-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;
+/**
+ * @param feature
+ * @param options
+ * @returns decoded binary feature
+ */
+function getDecodedFeatureBinary(feature, options, layerName) {
+    const decodedFeature = feature.toBinaryCoordinates(options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinatesBinary);
+    // Add layer name to GeoJSON properties
+    if (options.layerProperty && decodedFeature.properties) {
+        decodedFeature.properties[options.layerProperty] = 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,69 @@
+import type { LoaderOptions } from '@loaders.gl/loader-utils';
+/** For local coordinates, the tileIndex is not required */
+type MVTLocalCoordinatesOptions = {
+    /**
+     * When set to `local`, the parser will return a flat array of GeoJSON objects with local coordinates decoded from tile origin.
+     */
+    coordinates: 'local';
+    tileIndex: null;
+};
+/** In WGS84 coordinates, the tileIndex is required */
+type MVTWgs84CoordinatesOptions = {
+    /**
+     * When set to `wgs84`, the parser will return a flat array of GeoJSON objects with coordinates in longitude, latitude decoded from the provided tile index.
+     */
+    coordinates: 'wgs84';
+    /**
+     * Mandatory with `wgs84` coordinates option. An object containing tile index values (`x`, `y`,
+     * `z`) to reproject features' coordinates into WGS84.
+     */
+    tileIndex: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+export type MVTOptions = (MVTLocalCoordinatesOptions | MVTWgs84CoordinatesOptions) & {
+    /**
+     * When non-`null`, the layer name of each feature is added to
+     * `feature.properties[layerProperty]`. (A `feature.properties` object is created if the feature
+     * has no existing properties). If set to `null`, a layer name property will not be added.
+     */
+    layerProperty?: string | number;
+    /**
+     * Optional list of layer names. If not `null`, only features belonging to the named layers will
+     * be included in the output. If `null`, features from all layers are returned.
+     */
+    layers?: string[];
+    shape?: 'geojson-row-table' | 'columnar-table' | 'geojson' | 'binary' | 'binary-geometry';
+};
+export type MVTMapboxGeometry = {
+    type?: string;
+    id?: number;
+    length: number;
+    coordinates?: any[];
+};
+export type MVTMapboxCoordinates = {
+    type: string;
+    geometry: {
+        type: string;
+        coordinates: MVTMapboxGeometry;
+    };
+    properties: {
+        [x: string]: string | number | boolean | null;
+    };
+    id?: number;
+};
+export type MVTLoaderOptions = LoaderOptions & {
+    mvt?: MVTOptions;
+    gis?: {
+        /**
+         * When set to `true`, the parser will output the data in binary format. This is equivalent to loading the data as GeoJSON and then applying [geojsonToBinary](https://loaders.gl/modules/gis/docs/api-reference/geojson-to-binary).
+         */
+        binary?: boolean;
+        /** @deprecated. Use options.mvt.shape */
+        format?: 'geojson-row-table' | 'columnar-table' | 'geojson' | 'binary' | 'binary-geometry';
+    };
+};
+export {};
+//# 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,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE5D,2DAA2D;AAC3D,KAAK,0BAA0B,GAAG;IAChC;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,IAAI,CAAC;CACjB,CAAC;AAEF,sDAAsD;AACtD,KAAK,0BAA0B,GAAG;IAChC;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,SAAS,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,0BAA0B,GAAG,0BAA0B,CAAC,GAAG;IACnF;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAEhC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,iBAAiB,CAAC;CAC3F,CAAC;AAEF,MAAM,MAAM,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,MAAM,MAAM,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;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,GAAG,CAAC,EAAE;QACJ;;WAEG;QACH,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,yCAAyC;QACzC,MAAM,CAAC,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,iBAAiB,CAAC;KAC5F,CAAC;CACH,CAAC"}

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;AAkBvE;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,MAe7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,gBAKvB,CAAC"}

package/dist/mvt-loader.js

@@ -1,26 +1,47 @@
-import parseMVT from './lib/parse-mvt';
-const VERSION = typeof "4.0.0-alpha.4" !== 'undefined' ? "4.0.0-alpha.4" : '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: {
+"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';
+const DEFAULT_MVT_LOADER_OPTIONS = {
     mvt: {
-      coordinates: 'local',
-      layerProperty: 'layerName',
-      layers: null,
-      tileIndex: null
+        shape: 'geojson',
+        coordinates: 'local',
+        layerProperty: 'layerName',
+        layers: undefined,
+        tileIndex: null
     }
-  }
 };
-export const MVTLoader = { ...MVTWorkerLoader,
-  parse: async (arrayBuffer, options) => parseMVT(arrayBuffer, options),
-  parseSync: parseMVT,
-  binary: true
+/**
+ * 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: DEFAULT_MVT_LOADER_OPTIONS
+};
+/**
+ * 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