@loaders.gl/mvt 4.0.0-alpha.23 → 4.0.0-alpha.25

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

@@ -1,125 +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.createTile = void 0;
-/**
- * Create a tile from features and tile index
- */
-function createTile(features, z, tx, ty, options) {
-    const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
-    const tile = {
-        features: [],
-        numPoints: 0,
-        numSimplified: 0,
-        numFeatures: features.length,
-        source: null,
-        x: tx,
-        y: ty,
-        z,
-        transformed: false,
-        minX: 2,
-        minY: 1,
-        maxX: -1,
-        maxY: 0
-    };
-    for (const feature of features) {
-        addFeature(tile, feature, tolerance, options);
-    }
-    return tile;
-}
-exports.createTile = createTile;
-// eslint-disable-next-line complexity, max-statements
-function addFeature(tile, feature, tolerance, options) {
-    const geom = feature.geometry;
-    const type = feature.type;
-    const simplified = [];
-    tile.minX = Math.min(tile.minX, feature.minX);
-    tile.minY = Math.min(tile.minY, feature.minY);
-    tile.maxX = Math.max(tile.maxX, feature.maxX);
-    tile.maxY = Math.max(tile.maxY, feature.maxY);
-    if (type === 'Point' || type === 'MultiPoint') {
-        for (let i = 0; i < geom.length; i += 3) {
-            simplified.push(geom[i], geom[i + 1]);
-            tile.numPoints++;
-            tile.numSimplified++;
-        }
-    }
-    else if (type === 'LineString') {
-        addLine(simplified, geom, tile, tolerance, false, false);
-    }
-    else if (type === 'MultiLineString' || type === 'Polygon') {
-        for (let i = 0; i < geom.length; i++) {
-            addLine(simplified, geom[i], tile, tolerance, type === 'Polygon', i === 0);
-        }
-    }
-    else if (type === 'MultiPolygon') {
-        for (let k = 0; k < geom.length; k++) {
-            const polygon = geom[k];
-            for (let i = 0; i < polygon.length; i++) {
-                addLine(simplified, polygon[i], tile, tolerance, true, i === 0);
-            }
-        }
-    }
-    if (simplified.length) {
-        let tags = feature.tags || null;
-        if (type === 'LineString' && options.lineMetrics) {
-            tags = {};
-            for (const key in feature.tags)
-                tags[key] = feature.tags[key];
-            // eslint-disable-next-line camelcase
-            tags.mapbox_clip_start = geom.start / geom.size;
-            // eslint-disable-next-line camelcase
-            tags.mapbox_clip_end = geom.end / geom.size;
-        }
-        // @ts-expect-error TODO - create sub type?
-        const tileFeature = {
-            geometry: simplified,
-            type: type === 'Polygon' || type === 'MultiPolygon'
-                ? 3
-                : type === 'LineString' || type === 'MultiLineString'
-                    ? 2
-                    : 1,
-            tags
-        };
-        if (feature.id !== null) {
-            tileFeature.id = feature.id;
-        }
-        tile.features.push(tileFeature);
-    }
-}
-// eslint-disable-next-line max-params, max-statements
-function addLine(result, geom, tile, tolerance, isPolygon, isOuter) {
-    const sqTolerance = tolerance * tolerance;
-    if (tolerance > 0 && geom.size < (isPolygon ? sqTolerance : tolerance)) {
-        tile.numPoints += geom.length / 3;
-        return;
-    }
-    const ring = [];
-    for (let i = 0; i < geom.length; i += 3) {
-        if (tolerance === 0 || geom[i + 2] > sqTolerance) {
-            tile.numSimplified++;
-            ring.push(geom[i], geom[i + 1]);
-        }
-        tile.numPoints++;
-    }
-    if (isPolygon)
-        rewind(ring, isOuter);
-    result.push(ring);
-}
-function rewind(ring, clockwise) {
-    let area = 0;
-    for (let i = 0, j = ring.length - 2; i < ring.length; j = i, i += 2) {
-        area += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
-    }
-    if (area > 0 === clockwise) {
-        for (let i = 0, len = ring.length; i < len / 2; i += 2) {
-            const x = ring[i];
-            const y = ring[i + 1];
-            ring[i] = ring[len - 2 - i];
-            ring[i + 1] = ring[len - 1 - i];
-            ring[len - 2 - i] = x;
-            ring[len - 1 - i] = y;
-        }
-    }
-}

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

@@ -1,43 +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.transformTile = void 0;
-/**
- * Transforms the coordinates of each feature in the given tile from
- * mercator-projected space into (extent x extent) tile space.
- */
-function transformTile(tile, extent) {
-    if (tile.transformed) {
-        return tile;
-    }
-    const z2 = 1 << tile.z;
-    const tx = tile.x;
-    const ty = tile.y;
-    for (const feature of tile.features) {
-        const geom = feature.geometry;
-        const type = feature.type;
-        feature.geometry = [];
-        if (type === 1) {
-            for (let j = 0; j < geom.length; j += 2) {
-                feature.geometry.push(transformPoint(geom[j], geom[j + 1], extent, z2, tx, ty));
-            }
-        }
-        else {
-            for (let j = 0; j < geom.length; j++) {
-                const ring = [];
-                for (let k = 0; k < geom[j].length; k += 2) {
-                    ring.push(transformPoint(geom[j][k], geom[j][k + 1], extent, z2, tx, ty));
-                }
-                feature.geometry.push(ring);
-            }
-        }
-    }
-    tile.transformed = true;
-    return tile;
-}
-exports.transformTile = transformTile;
-// eslint-disable-next-line max-params
-function transformPoint(x, y, extent, z2, tx, ty) {
-    return [Math.round(extent * (x * z2 - tx)), Math.round(extent * (y * z2 - ty))];
-}

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;
-            }
-        }
-    }
-}