@loaders.gl/mvt 4.0.0-alpha.8 → 4.0.0-beta.1

package/dist/helpers/binary-util-functions.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readTag = exports.readFeature = exports.project = exports.classifyRings = void 0;
-const polygon_1 = require("@math.gl/polygon");
-/**
- * Classifies an array of rings into polygons with outer rings and holes
- * The function also detects holes which have zero area and
- * removes them. In doing so it modifies the input
- * `geom.data` array to remove the unneeded data
- *
- * @param geometry
- * @returns object
- */
-// eslint-disable-next-line max-statements
-function classifyRings(geom) {
-    const len = geom.indices.length;
-    const type = 'Polygon';
-    if (len <= 1) {
-        return {
-            type,
-            data: geom.data,
-            areas: [[(0, polygon_1.getPolygonSignedArea)(geom.data)]],
-            indices: [geom.indices]
-        };
-    }
-    const areas = [];
-    const polygons = [];
-    let ringAreas = [];
-    let polygon = [];
-    let ccw;
-    let offset = 0;
-    for (let endIndex, i = 0, startIndex; i < len; i++) {
-        startIndex = geom.indices[i] - offset;
-        endIndex = geom.indices[i + 1] - offset || geom.data.length;
-        const shape = geom.data.slice(startIndex, endIndex);
-        const area = (0, polygon_1.getPolygonSignedArea)(shape);
-        if (area === 0) {
-            // This polygon has no area, so remove it from the shape
-            // Remove the section from the data array
-            const before = geom.data.slice(0, startIndex);
-            const after = geom.data.slice(endIndex);
-            geom.data = before.concat(after);
-            // Need to offset any remaining indices as we have
-            // modified the data buffer
-            offset += endIndex - startIndex;
-            // Do not add this index to the output and process next shape
-            continue; // eslint-disable-line no-continue
-        }
-        if (ccw === undefined)
-            ccw = area < 0;
-        if (ccw === area < 0) {
-            if (polygon.length) {
-                areas.push(ringAreas);
-                polygons.push(polygon);
-            }
-            polygon = [startIndex];
-            ringAreas = [area];
-        }
-        else {
-            ringAreas.push(area);
-            polygon.push(startIndex);
-        }
-    }
-    if (ringAreas)
-        areas.push(ringAreas);
-    if (polygon.length)
-        polygons.push(polygon);
-    return { type, areas, indices: polygons, data: geom.data };
-}
-exports.classifyRings = classifyRings;
-/**
- *
- * @param data
- * @param x0
- * @param y0
- * @param size
- */
-function project(data, x0, y0, size) {
-    for (let j = 0, jl = data.length; j < jl; j += 2) {
-        data[j] = ((data[j] + x0) * 360) / size - 180;
-        const y2 = 180 - ((data[j + 1] + y0) * 360) / size;
-        data[j + 1] = (360 / Math.PI) * Math.atan(Math.exp((y2 * Math.PI) / 180)) - 90;
-    }
-}
-exports.project = project;
-/**
- * All code below is unchanged from the original Mapbox implemenation
- *
- * @param tag
- * @param feature
- * @param pbf
- */
-function readFeature(tag, feature, pbf) {
-    if (feature && pbf) {
-        if (tag === 1)
-            feature.id = pbf.readVarint();
-        else if (tag === 2)
-            readTag(pbf, feature);
-        else if (tag === 3)
-            feature.type = pbf.readVarint();
-        else if (tag === 4)
-            feature._geometry = pbf.pos;
-    }
-}
-exports.readFeature = readFeature;
-/**
- * @param pbf
- * @param feature
- */
-function readTag(pbf, feature) {
-    const end = pbf.readVarint() + pbf.pos;
-    while (pbf.pos < end) {
-        const key = feature._keys[pbf.readVarint()];
-        const value = feature._values[pbf.readVarint()];
-        feature.properties[key] = value;
-    }
-}
-exports.readTag = readTag;

package/dist/helpers/mapbox-util-functions.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readTag = exports.readFeature = exports.signedArea = exports.classifyRings = void 0;
-/**
- * Classifies an array of rings into polygons with outer rings and holes
- * @param rings
- * @returns polygons
- */
-function classifyRings(rings) {
-    const len = rings.length;
-    if (len <= 1)
-        return [rings];
-    const polygons = [];
-    let polygon;
-    let ccw;
-    for (let i = 0; i < len; i++) {
-        const area = signedArea(rings[i]);
-        if (area === 0)
-            continue; // eslint-disable-line no-continue
-        if (ccw === undefined)
-            ccw = area < 0;
-        if (ccw === area < 0) {
-            if (polygon)
-                polygons.push(polygon);
-            polygon = [rings[i]];
-        }
-        else if (polygon)
-            polygon.push(rings[i]);
-    }
-    if (polygon)
-        polygons.push(polygon);
-    return polygons;
-}
-exports.classifyRings = classifyRings;
-/**
- *
- * @param ring
- * @returns sum
- */
-function signedArea(ring) {
-    let sum = 0;
-    for (let i = 0, j = ring.length - 1, p1, p2; i < ring.length; j = i++) {
-        p1 = ring[i];
-        p2 = ring[j];
-        sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
-    }
-    return sum;
-}
-exports.signedArea = signedArea;
-/**
- *
- * @param tag
- * @param feature
- * @param pbf
- */
-function readFeature(tag, feature, pbf) {
-    if (feature && pbf) {
-        if (tag === 1)
-            feature.id = pbf.readVarint();
-        else if (tag === 2)
-            readTag(pbf, feature);
-        else if (tag === 3)
-            feature.type = pbf.readVarint();
-        else if (tag === 4)
-            feature._geometry = pbf.pos;
-    }
-}
-exports.readFeature = readFeature;
-/**
- *
- * @param pbf
- * @param feature
- */
-function readTag(pbf, feature) {
-    const end = pbf.readVarint() + pbf.pos;
-    while (pbf.pos < end) {
-        const key = feature._keys[pbf.readVarint()];
-        const value = feature._values[pbf.readVarint()];
-        feature.properties[key] = value;
-    }
-}
-exports.readTag = readTag;

package/dist/index.js

@@ -1,9 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeoJSONTiler = exports.MVTWorkerLoader = exports.MVTLoader = void 0;
-var mvt_loader_1 = require("./mvt-loader");
-Object.defineProperty(exports, "MVTLoader", { enumerable: true, get: function () { return mvt_loader_1.MVTLoader; } });
-Object.defineProperty(exports, "MVTWorkerLoader", { enumerable: true, get: function () { return mvt_loader_1.MVTWorkerLoader; } });
-var geojson_tiler_1 = require("./lib/geojson-tiler/geojson-tiler");
-Object.defineProperty(exports, "GeoJSONTiler", { enumerable: true, get: function () { return geojson_tiler_1.GeoJSONTiler; } });

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

@@ -1,156 +0,0 @@
-"use strict";
-// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TEST_EXPORTS = void 0;
-const binary_util_functions_1 = require("../../helpers/binary-util-functions");
-// Reduce GC by reusing variables
-let endPos;
-let cmd;
-let cmdLen;
-let length;
-let x;
-let y;
-let i;
-exports.TEST_EXPORTS = {
-    classifyRings: binary_util_functions_1.classifyRings
-};
-class VectorTileFeature {
-    // eslint-disable-next-line max-params
-    constructor(pbf, end, extent, keys, values, geometryInfo) {
-        // 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;
-        this._geometryInfo = geometryInfo;
-        pbf.readFields(binary_util_functions_1.readFeature, this, end);
-    }
-    // eslint-disable-next-line complexity, max-statements
-    loadGeometry() {
-        const pbf = this._pbf;
-        pbf.pos = this._geometry;
-        endPos = pbf.readVarint() + pbf.pos;
-        cmd = 1;
-        length = 0;
-        x = 0;
-        y = 0;
-        i = 0;
-        // Note: I attempted to replace the `data` array with a
-        // Float32Array, but performance was worse, both using
-        // `set()` and direct index access. Also, we cannot
-        // know how large the buffer should be, so it would
-        // increase memory usage
-        const indices = []; // Indices where geometries start
-        const data = []; // Flat array of coordinate data
-        while (pbf.pos < endPos) {
-            if (length <= 0) {
-                cmdLen = pbf.readVarint();
-                cmd = cmdLen & 0x7;
-                length = cmdLen >> 3;
-            }
-            length--;
-            if (cmd === 1 || cmd === 2) {
-                x += pbf.readSVarint();
-                y += pbf.readSVarint();
-                if (cmd === 1) {
-                    // New line
-                    indices.push(i);
-                }
-                data.push(x, y);
-                i += 2;
-            }
-            else if (cmd === 7) {
-                // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
-                if (i > 0) {
-                    const start = indices[indices.length - 1]; // start index of polygon
-                    data.push(data[start], data[start + 1]); // closePolygon
-                    i += 2;
-                }
-            }
-            else {
-                throw new Error(`unknown command ${cmd}`);
-            }
-        }
-        return { data, indices };
-    }
-    /**
-     *
-     * @param transform
-     * @returns result
-     */
-    _toBinaryCoordinates(transform) {
-        // Expands the protobuf data to an intermediate Flat GeoJSON
-        // data format, which maps closely to the binary data buffers.
-        // It is similar to GeoJSON, but rather than storing the coordinates
-        // in multidimensional arrays, we have a 1D `data` with all the
-        // coordinates, and then index into this using the `indices`
-        // parameter, e.g.
-        //
-        // geometry: {
-        //   type: 'Point', data: [1,2], indices: [0]
-        // }
-        // geometry: {
-        //   type: 'LineString', data: [1,2,3,4,...], indices: [0]
-        // }
-        // geometry: {
-        //   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
-        // }
-        // Thus the indices member lets us look up the relevant range
-        // from the data array.
-        // The Multi* versions of the above types share the same data
-        // structure, just with multiple elements in the indices array
-        const geom = this.loadGeometry();
-        let geometry;
-        // Apply the supplied transformation to data
-        transform(geom.data, this);
-        const coordLength = 2;
-        // eslint-disable-next-line default-case
-        switch (this.type) {
-            case 1: // Point
-                this._geometryInfo.pointFeaturesCount++;
-                this._geometryInfo.pointPositionsCount += geom.indices.length;
-                geometry = { type: 'Point', ...geom };
-                break;
-            case 2: // LineString
-                this._geometryInfo.lineFeaturesCount++;
-                this._geometryInfo.linePathsCount += geom.indices.length;
-                this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
-                geometry = { type: 'LineString', ...geom };
-                break;
-            case 3: // Polygon
-                geometry = (0, binary_util_functions_1.classifyRings)(geom);
-                // Unlike Point & LineString geom.indices is a 2D array, thanks
-                // to the classifyRings method
-                this._geometryInfo.polygonFeaturesCount++;
-                this._geometryInfo.polygonObjectsCount += geometry.indices.length;
-                for (const indices of geometry.indices) {
-                    this._geometryInfo.polygonRingsCount += indices.length;
-                }
-                this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
-                break;
-            default:
-                throw new Error(`Invalid geometry type: ${this.type}`);
-        }
-        const result = { type: 'Feature', geometry, properties: this.properties };
-        if (this.id !== null) {
-            result.id = this.id;
-        }
-        return result;
-    }
-    toBinaryCoordinates(options) {
-        if (typeof options === 'function') {
-            return this._toBinaryCoordinates(options);
-        }
-        const { x, y, z } = options;
-        const size = this.extent * Math.pow(2, z);
-        const x0 = this.extent * x;
-        const y0 = this.extent * y;
-        return this._toBinaryCoordinates((data) => (0, binary_util_functions_1.project)(data, x0, y0, size));
-    }
-}
-exports.default = VectorTileFeature;

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

@@ -1,91 +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
-     * @param geometryInfo
-     * @returns {VectorTileFeature}
-     */
-    feature(i, geometryInfo) {
-        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, geometryInfo);
-    }
-}
-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/binary-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/geojson-tiler/clip.js

@@ -1,209 +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.clip = void 0;
-const feature_1 = require("./feature");
-/* eslint-disable no-continue */
-/**
- * Clip features between two vertical or horizontal axis-parallel lines:
- *     |        |
- *  ___|___     |     /
- * /   |   \____|____/
- *     |        |
- *
- * @param k1 and k2 are the line coordinates
- * @param axis: 0 for x, 1 for y
- * @param minAll and maxAll: minimum and maximum coordinate value for all features
- */
-// eslint-disable-next-line max-params, complexity, max-statements
-function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
-    k1 /= scale;
-    k2 /= scale;
-    if (minAll >= k1 && maxAll < k2) {
-        return features;
-    }
-    // trivial accept
-    else if (maxAll < k1 || minAll >= k2) {
-        return null; // trivial reject
-    }
-    const clipped = [];
-    for (const feature of features) {
-        const geometry = feature.geometry;
-        let type = feature.type;
-        const min = axis === 0 ? feature.minX : feature.minY;
-        const max = axis === 0 ? feature.maxX : feature.maxY;
-        if (min >= k1 && max < k2) {
-            // trivial accept
-            clipped.push(feature);
-            continue;
-        }
-        else if (max < k1 || min >= k2) {
-            // trivial reject
-            continue;
-        }
-        let newGeometry = [];
-        if (type === 'Point' || type === 'MultiPoint') {
-            clipPoints(geometry, newGeometry, k1, k2, axis);
-        }
-        else if (type === 'LineString') {
-            clipLine(geometry, newGeometry, k1, k2, axis, false, options.lineMetrics);
-        }
-        else if (type === 'MultiLineString') {
-            clipLines(geometry, newGeometry, k1, k2, axis, false);
-        }
-        else if (type === 'Polygon') {
-            clipLines(geometry, newGeometry, k1, k2, axis, true);
-        }
-        else if (type === 'MultiPolygon') {
-            for (const polygon of geometry) {
-                const newPolygon = [];
-                clipLines(polygon, newPolygon, k1, k2, axis, true);
-                if (newPolygon.length) {
-                    newGeometry.push(newPolygon);
-                }
-            }
-        }
-        if (newGeometry.length) {
-            if (options.lineMetrics && type === 'LineString') {
-                for (const line of newGeometry) {
-                    clipped.push((0, feature_1.createFeature)(feature.id, type, line, feature.tags));
-                }
-                continue;
-            }
-            if (type === 'LineString' || type === 'MultiLineString') {
-                if (newGeometry.length === 1) {
-                    type = 'LineString';
-                    // @ts-expect-error TODO - use proper GeoJSON geometry types
-                    newGeometry = newGeometry[0];
-                }
-                else {
-                    type = 'MultiLineString';
-                }
-            }
-            if (type === 'Point' || type === 'MultiPoint') {
-                type = newGeometry.length === 3 ? 'Point' : 'MultiPoint';
-            }
-            clipped.push((0, feature_1.createFeature)(feature.id, type, newGeometry, feature.tags));
-        }
-    }
-    return clipped.length ? clipped : null;
-}
-exports.clip = clip;
-function clipPoints(geom, newGeom, k1, k2, axis) {
-    for (let i = 0; i < geom.length; i += 3) {
-        const a = geom[i + axis];
-        if (a >= k1 && a <= k2) {
-            addPoint(newGeom, geom[i], geom[i + 1], geom[i + 2]);
-        }
-    }
-}
-// eslint-disable-next-line max-params, complexity, max-statements
-function clipLine(geom, newGeom, k1, k2, axis, isPolygon, trackMetrics) {
-    let slice = newSlice(geom);
-    const intersect = axis === 0 ? intersectX : intersectY;
-    let len = geom.start;
-    let segLen;
-    let t;
-    for (let i = 0; i < geom.length - 3; i += 3) {
-        const ax = geom[i];
-        const ay = geom[i + 1];
-        const az = geom[i + 2];
-        const bx = geom[i + 3];
-        const by = geom[i + 4];
-        const a = axis === 0 ? ax : ay;
-        const b = axis === 0 ? bx : by;
-        let exited = false;
-        if (trackMetrics) {
-            segLen = Math.sqrt(Math.pow(ax - bx, 2) + Math.pow(ay - by, 2));
-        }
-        if (a < k1) {
-            // ---|-->  | (line enters the clip region from the left)
-            if (b > k1) {
-                t = intersect(slice, ax, ay, bx, by, k1);
-                if (trackMetrics) {
-                    slice.start = len + segLen * t;
-                }
-            }
-        }
-        else if (a > k2) {
-            // |  <--|--- (line enters the clip region from the right)
-            if (b < k2) {
-                t = intersect(slice, ax, ay, bx, by, k2);
-                if (trackMetrics) {
-                    slice.start = len + segLen * t;
-                }
-            }
-        }
-        else {
-            addPoint(slice, ax, ay, az);
-        }
-        if (b < k1 && a >= k1) {
-            // <--|---  | or <--|-----|--- (line exits the clip region on the left)
-            t = intersect(slice, ax, ay, bx, by, k1);
-            exited = true;
-        }
-        if (b > k2 && a <= k2) {
-            // |  ---|--> or ---|-----|--> (line exits the clip region on the right)
-            t = intersect(slice, ax, ay, bx, by, k2);
-            exited = true;
-        }
-        if (!isPolygon && exited) {
-            if (trackMetrics) {
-                slice.end = len + segLen * t;
-            }
-            newGeom.push(slice);
-            slice = newSlice(geom);
-        }
-        if (trackMetrics) {
-            len += segLen;
-        }
-    }
-    // add the last point
-    let last = geom.length - 3;
-    const ax = geom[last];
-    const ay = geom[last + 1];
-    const az = geom[last + 2];
-    const a = axis === 0 ? ax : ay;
-    if (a >= k1 && a <= k2)
-        addPoint(slice, ax, ay, az);
-    // close the polygon if its endpoints are not the same after clipping
-    last = slice.length - 3;
-    if (isPolygon && last >= 3 && (slice[last] !== slice[0] || slice[last + 1] !== slice[1])) {
-        addPoint(slice, slice[0], slice[1], slice[2]);
-    }
-    // add the final slice
-    if (slice.length) {
-        newGeom.push(slice);
-    }
-}
-class Slice extends Array {
-}
-function newSlice(line) {
-    const slice = [];
-    slice.size = line.size;
-    slice.start = line.start;
-    slice.end = line.end;
-    return slice;
-}
-// eslint-disable-next-line max-params
-function clipLines(geom, newGeom, k1, k2, axis, isPolygon) {
-    for (const line of geom) {
-        clipLine(line, newGeom, k1, k2, axis, isPolygon, false);
-    }
-}
-function addPoint(out, x, y, z) {
-    out.push(x, y, z);
-}
-// eslint-disable-next-line max-params
-function intersectX(out, ax, ay, bx, by, x) {
-    const t = (x - ax) / (bx - ax);
-    addPoint(out, x, ay + (by - ay) * t, 1);
-    return t;
-}
-// eslint-disable-next-line max-params
-function intersectY(out, ax, ay, bx, by, y) {
-    const t = (y - ay) / (by - ay);
-    addPoint(out, ax + (bx - ax) * t, y, 1);
-    return t;
-}