@loaders.gl/mvt 4.0.0-alpha.9 → 4.0.0-beta.2

package/dist/lib/geojson-tiler/wrap.js

@@ -1,86 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrap = void 0;
-const clip_1 = require("./clip");
-const feature_1 = require("./feature");
-/**
- * Wrap across antemeridian, by clipping into two tiles, shifting the overflowing x coordinates
- * @param features list of features to be wrapped
- * @param options buffer and extent
- * @returns
- */
-function wrap(features, options) {
-    const buffer = options.buffer / options.extent;
-    let merged = features;
-    const left = (0, clip_1.clip)(features, 1, -1 - buffer, buffer, 0, -1, 2, options); // left world copy
-    const right = (0, clip_1.clip)(features, 1, 1 - buffer, 2 + buffer, 0, -1, 2, options); // right world copy
-    if (left || right) {
-        merged = (0, clip_1.clip)(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || []; // center world copy
-        if (left) {
-            merged = shiftFeatureCoords(left, 1).concat(merged); // merge left into center
-        }
-        if (right) {
-            merged = merged.concat(shiftFeatureCoords(right, -1)); // merge right into center
-        }
-    }
-    return merged;
-}
-exports.wrap = wrap;
-/**
- * Shift the x coordinates of a list of features
- * @param features list of features to shift x coordinates for
- * @param offset
- * @returns
- */
-function shiftFeatureCoords(features, offset) {
-    const newFeatures = [];
-    for (let i = 0; i < features.length; i++) {
-        const feature = features[i];
-        const type = feature.type;
-        let newGeometry;
-        if (type === 'Point' || type === 'MultiPoint' || type === 'LineString') {
-            newGeometry = shiftCoords(feature.geometry, offset);
-        }
-        else if (type === 'MultiLineString' || type === 'Polygon') {
-            newGeometry = [];
-            for (const line of feature.geometry) {
-                newGeometry.push(shiftCoords(line, offset));
-            }
-        }
-        else if (type === 'MultiPolygon') {
-            newGeometry = [];
-            for (const polygon of feature.geometry) {
-                const newPolygon = [];
-                for (const line of polygon) {
-                    // @ts-expect-error TODO
-                    newPolygon.push(shiftCoords(line, offset));
-                }
-                newGeometry.push(newPolygon);
-            }
-        }
-        newFeatures.push((0, feature_1.createFeature)(feature.id, type, newGeometry, feature.tags));
-    }
-    return newFeatures;
-}
-class Points extends Array {
-}
-/**
- * Shift the x coordinate of every point
- * @param points
- * @param offset
- * @returns
- */
-function shiftCoords(points, offset) {
-    const newPoints = [];
-    newPoints.size = points.size;
-    if (points.start !== undefined) {
-        newPoints.start = points.start;
-        newPoints.end = points.end;
-    }
-    for (let i = 0; i < points.length; i += 3) {
-        newPoints.push(points[i] + offset, points[i + 1], points[i + 2]);
-    }
-    return newPoints;
-}

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

@@ -1,170 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const mapbox_util_functions_1 = require("../../helpers/mapbox-util-functions");
-class VectorTileFeature {
-    static get types() {
-        return ['Unknown', 'Point', 'LineString', 'Polygon'];
-    }
-    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);
-    }
-    // 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.js

@@ -1,89 +0,0 @@
-"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.js

@@ -1,29 +0,0 @@
-"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.js

@@ -1,167 +0,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) {
-        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];
-        if (!vectorTileLayer) {
-            return;
-        }
-        for (let i = 0; i < vectorTileLayer.length; i++) {
-            const vectorTileFeature = vectorTileLayer.feature(i, geometryInfo);
-            const decodedFeature = getDecodedFeatureBinary(vectorTileFeature, options, layerName);
-            features.push(decodedFeature);
-        }
-    });
-    return [features, geometryInfo];
-}
-function parseToGeojson(arrayBuffer, options) {
-    if (arrayBuffer.byteLength <= 0) {
-        return [];
-    }
-    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?.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');
-    }
-    return options.mvt;
-}
-/**
- * @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;
-}
-/**
- * @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) {
-    // 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.js

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

package/dist/mvt-loader.js

@@ -1,47 +0,0 @@
-"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: {
-        shape: 'geojson',
-        coordinates: 'local',
-        layerProperty: 'layerName',
-        layers: undefined,
-        tileIndex: null
-    }
-};
-/**
- * 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
-};

package/dist/workers/mvt-worker.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const mvt_loader_1 = require("../mvt-loader");
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-(0, loader_utils_1.createLoaderWorker)(mvt_loader_1.MVTLoader);