@loaders.gl/mvt 3.1.0-alpha.5 → 3.1.0-beta.5

package/dist/lib/mapbox-vector-tile/vector-tile-feature.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mapbox_util_functions_1 = require("../../helpers/mapbox-util-functions");
+class VectorTileFeature {
+    constructor(pbf, end, extent, keys, values) {
+        // Public
+        this.properties = {};
+        this.extent = extent;
+        this.type = 0;
+        this.id = null;
+        // Private
+        this._pbf = pbf;
+        this._geometry = -1;
+        this._keys = keys;
+        this._values = values;
+        pbf.readFields(mapbox_util_functions_1.readFeature, this, end);
+    }
+    static get types() {
+        return ['Unknown', 'Point', 'LineString', 'Polygon'];
+    }
+    // eslint-disable-next-line complexity, max-statements
+    loadGeometry() {
+        const pbf = this._pbf;
+        pbf.pos = this._geometry;
+        const end = pbf.readVarint() + pbf.pos;
+        let cmd = 1;
+        let length = 0;
+        let x = 0;
+        let y = 0;
+        const lines = [];
+        let line;
+        while (pbf.pos < end) {
+            if (length <= 0) {
+                const cmdLen = pbf.readVarint();
+                cmd = cmdLen & 0x7;
+                length = cmdLen >> 3;
+            }
+            length--;
+            if (cmd === 1 || cmd === 2) {
+                x += pbf.readSVarint();
+                y += pbf.readSVarint();
+                if (cmd === 1) {
+                    // moveTo
+                    if (line)
+                        lines.push(line);
+                    line = [];
+                }
+                if (line)
+                    line.push([x, y]);
+            }
+            else if (cmd === 7) {
+                // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
+                if (line) {
+                    line.push(line[0].slice()); // closePolygon
+                }
+            }
+            else {
+                throw new Error(`unknown command ${cmd}`);
+            }
+        }
+        if (line)
+            lines.push(line);
+        return lines;
+    }
+    // eslint-disable-next-line max-statements
+    bbox() {
+        const pbf = this._pbf;
+        pbf.pos = this._geometry;
+        const end = pbf.readVarint() + pbf.pos;
+        let cmd = 1;
+        let length = 0;
+        let x = 0;
+        let y = 0;
+        let x1 = Infinity;
+        let x2 = -Infinity;
+        let y1 = Infinity;
+        let y2 = -Infinity;
+        while (pbf.pos < end) {
+            if (length <= 0) {
+                const cmdLen = pbf.readVarint();
+                cmd = cmdLen & 0x7;
+                length = cmdLen >> 3;
+            }
+            length--;
+            if (cmd === 1 || cmd === 2) {
+                x += pbf.readSVarint();
+                y += pbf.readSVarint();
+                if (x < x1)
+                    x1 = x;
+                if (x > x2)
+                    x2 = x;
+                if (y < y1)
+                    y1 = y;
+                if (y > y2)
+                    y2 = y;
+            }
+            else if (cmd !== 7) {
+                throw new Error(`unknown command ${cmd}`);
+            }
+        }
+        return [x1, y1, x2, y2];
+    }
+    _toGeoJSON(transform) {
+        let coords = this.loadGeometry();
+        let type = VectorTileFeature.types[this.type];
+        let i;
+        let j;
+        // eslint-disable-next-line default-case
+        switch (this.type) {
+            case 1:
+                const points = [];
+                for (i = 0; i < coords.length; i++) {
+                    points[i] = coords[i][0];
+                }
+                coords = points;
+                transform(coords, this);
+                break;
+            case 2:
+                for (i = 0; i < coords.length; i++) {
+                    transform(coords[i], this);
+                }
+                break;
+            case 3:
+                coords = (0, mapbox_util_functions_1.classifyRings)(coords);
+                for (i = 0; i < coords.length; i++) {
+                    for (j = 0; j < coords[i].length; j++) {
+                        transform(coords[i][j], this);
+                    }
+                }
+                break;
+        }
+        if (coords.length === 1) {
+            coords = coords[0];
+        }
+        else {
+            type = `Multi${type}`;
+        }
+        const result = {
+            type: 'Feature',
+            geometry: {
+                type,
+                coordinates: coords
+            },
+            properties: this.properties
+        };
+        if (this.id !== null) {
+            result.id = this.id;
+        }
+        return result;
+    }
+    toGeoJSON(options) {
+        if (typeof options === 'function') {
+            return this._toGeoJSON(options);
+        }
+        const { x, y, z } = options;
+        const size = this.extent * Math.pow(2, z);
+        const x0 = this.extent * x;
+        const y0 = this.extent * y;
+        function project(line) {
+            for (let j = 0; j < line.length; j++) {
+                const p = line[j];
+                p[0] = ((p[0] + x0) * 360) / size - 180;
+                const y2 = 180 - ((p[1] + y0) * 360) / size;
+                p[1] = (360 / Math.PI) * Math.atan(Math.exp((y2 * Math.PI) / 180)) - 90;
+            }
+        }
+        return this._toGeoJSON(project);
+    }
+}
+exports.default = VectorTileFeature;

package/dist/lib/mapbox-vector-tile/vector-tile-layer.d.ts

@@ -17,3 +17,4 @@ export default class VectorTileLayer {
      */
     feature(i: number): VectorTileFeature;
 }
+//# sourceMappingURL=vector-tile-layer.d.ts.map

package/dist/lib/mapbox-vector-tile/vector-tile-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-tile-layer.d.ts","sourceRoot":"","sources":["../../../src/lib/mapbox-vector-tile/vector-tile-layer.ts"],"names":[],"mappings":"AAGA,OAAO,QAAQ,MAAM,KAAK,CAAC;AAC3B,OAAO,iBAAiB,MAAM,uBAAuB,CAAC;AAEtD,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC;IAC9C,SAAS,EAAE,MAAM,EAAE,CAAC;gBACR,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM;IAkBtC;;;;OAIG;IAEH,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,iBAAiB;CAUtC"}

package/dist/lib/mapbox-vector-tile/vector-tile-layer.js

@@ -0,0 +1,89 @@
+"use strict";
+/* eslint-disable indent */
+// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vector_tile_feature_1 = __importDefault(require("./vector-tile-feature"));
+class VectorTileLayer {
+    constructor(pbf, end) {
+        // Public
+        this.version = 1;
+        this.name = '';
+        this.extent = 4096;
+        this.length = 0;
+        // Private
+        this._pbf = pbf;
+        this._keys = [];
+        this._values = [];
+        this._features = [];
+        pbf.readFields(readLayer, this, end);
+        this.length = this._features.length;
+    }
+    /**
+     * return feature `i` from this layer as a `VectorTileFeature`
+     * @param index
+     * @returns feature
+     */
+    feature(i) {
+        if (i < 0 || i >= this._features.length) {
+            throw new Error('feature index out of bounds');
+        }
+        this._pbf.pos = this._features[i];
+        const end = this._pbf.readVarint() + this._pbf.pos;
+        return new vector_tile_feature_1.default(this._pbf, end, this.extent, this._keys, this._values);
+    }
+}
+exports.default = VectorTileLayer;
+/**
+ *
+ * @param tag
+ * @param layer
+ * @param pbf
+ */
+function readLayer(tag, layer, pbf) {
+    if (layer && pbf) {
+        if (tag === 15)
+            layer.version = pbf.readVarint();
+        else if (tag === 1)
+            layer.name = pbf.readString();
+        else if (tag === 5)
+            layer.extent = pbf.readVarint();
+        else if (tag === 2)
+            layer._features.push(pbf.pos);
+        else if (tag === 3)
+            layer._keys.push(pbf.readString());
+        else if (tag === 4)
+            layer._values.push(readValueMessage(pbf));
+    }
+}
+/**
+ *
+ * @param pbf
+ * @returns value
+ */
+function readValueMessage(pbf) {
+    let value = null;
+    const end = pbf.readVarint() + pbf.pos;
+    while (pbf.pos < end) {
+        const tag = pbf.readVarint() >> 3;
+        value =
+            tag === 1
+                ? pbf.readString()
+                : tag === 2
+                    ? pbf.readFloat()
+                    : tag === 3
+                        ? pbf.readDouble()
+                        : tag === 4
+                            ? pbf.readVarint64()
+                            : tag === 5
+                                ? pbf.readVarint()
+                                : tag === 6
+                                    ? pbf.readSVarint()
+                                    : tag === 7
+                                        ? pbf.readBoolean()
+                                        : null;
+    }
+    return value;
+}

package/dist/lib/mapbox-vector-tile/vector-tile.d.ts

@@ -6,3 +6,4 @@ export default class VectorTile {
     };
     constructor(pbf: Protobuf, end?: number);
 }
+//# sourceMappingURL=vector-tile.d.ts.map

package/dist/lib/mapbox-vector-tile/vector-tile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-tile.d.ts","sourceRoot":"","sources":["../../../src/lib/mapbox-vector-tile/vector-tile.ts"],"names":[],"mappings":"AAEA,OAAO,eAAe,MAAM,qBAAqB,CAAC;AAClD,OAAO,QAAQ,MAAM,KAAK,CAAC;AAE3B,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,MAAM,EAAE;QAAC,CAAC,CAAC,EAAE,MAAM,GAAG,eAAe,CAAA;KAAC,CAAC;gBAC3B,GAAG,EAAE,QAAQ,EAAE,GAAG,CAAC,EAAE,MAAM;CAGxC"}

package/dist/lib/mapbox-vector-tile/vector-tile.js

@@ -0,0 +1,29 @@
+"use strict";
+// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vector_tile_layer_1 = __importDefault(require("./vector-tile-layer"));
+class VectorTile {
+    constructor(pbf, end) {
+        this.layers = pbf.readFields(readTile, {}, end);
+    }
+}
+exports.default = VectorTile;
+/**
+ *
+ * @param tag
+ * @param layers
+ * @param pbf
+ */
+function readTile(tag, layers, pbf) {
+    if (tag === 3) {
+        if (pbf) {
+            const layer = new vector_tile_layer_1.default(pbf, pbf.readVarint() + pbf.pos);
+            if (layer.length && layers) {
+                layers[layer.name] = layer;
+            }
+        }
+    }
+}

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

@@ -1,5 +1,5 @@
 import { MvtBinaryCoordinates, MvtMapboxCoordinates } from '../lib/types';
-import { LoaderOptions } from '@loaders.gl/loader-utils/';
+import { LoaderOptions } from '@loaders.gl/loader-utils';
 /**
  * Parse MVT arrayBuffer and return GeoJSON.
  *
@@ -82,3 +82,4 @@ export default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptio
         }[];
     };
 } | (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

@@ -0,0 +1,142 @@
+"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 (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);
+                }
+            });
+        }
+        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;
+        }
+    }
+    return features;
+}
+exports.default = parseMVT;
+/**
+ * @param options
+ * @returns options
+ */
+function normalizeOptions(options) {
+    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;
+}
+/**
+ * @param feature
+ * @param options
+ * @returns decoded feature
+ */
+function getDecodedFeature(feature, options) {
+    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);
+    // 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) {
+    // 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) {
+    // 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;
+    }
+}

package/dist/lib/types.d.ts

@@ -89,3 +89,4 @@ export declare type MvtPolygons = {
         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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mvt-loader.d.ts

@@ -7,3 +7,4 @@ 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

@@ -0,0 +1,45 @@
+"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
+        }
+    }
+};
+/**
+ * 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
+};