@loaders.gl/mvt 3.1.0-alpha.4 → 3.1.0-beta.3

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

@@ -0,0 +1,116 @@
+"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.lines.length;
+    if (len <= 1) {
+        return {
+            data: geom.data,
+            areas: [[(0, polygon_1.getPolygonSignedArea)(geom.data)]],
+            lines: [geom.lines]
+        };
+    }
+    const areas = [];
+    const polygons = [];
+    let ringAreas = [];
+    let polygon = [];
+    let ccw;
+    let offset = 0;
+    for (let endIndex, i = 0, startIndex; i < len; i++) {
+        startIndex = geom.lines[i] - offset;
+        endIndex = geom.lines[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 { areas, lines: 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.d.ts

@@ -0,0 +1,29 @@
+import Protobuf from 'pbf';
+import { MvtMapboxGeometry } from '../lib/types';
+import VectorTileFeature from '../lib/mapbox-vector-tile/vector-tile-feature';
+/**
+ * Classifies an array of rings into polygons with outer rings and holes
+ * @param rings
+ * @returns polygons
+ */
+export declare function classifyRings(rings: MvtMapboxGeometry): MvtMapboxGeometry[] | number[][][];
+/**
+ *
+ * @param ring
+ * @returns sum
+ */
+export declare function signedArea(ring: number[][]): number;
+/**
+ *
+ * @param tag
+ * @param feature
+ * @param pbf
+ */
+export declare function readFeature(tag: number, feature?: VectorTileFeature, pbf?: Protobuf): void;
+/**
+ *
+ * @param pbf
+ * @param feature
+ */
+export declare function readTag(pbf: Protobuf, feature: VectorTileFeature): void;
+//# sourceMappingURL=mapbox-util-functions.d.ts.map

package/dist/helpers/mapbox-util-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapbox-util-functions.d.ts","sourceRoot":"","sources":["../../src/helpers/mapbox-util-functions.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,KAAK,CAAC;AAC3B,OAAO,EAAC,iBAAiB,EAAC,MAAM,cAAc,CAAC;AAC/C,OAAO,iBAAiB,MAAM,+CAA+C,CAAC;AAE9E;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,iBAAiB,sCAuBrD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,UAQ1C;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,EAAE,GAAG,CAAC,EAAE,QAAQ,GAAG,IAAI,CAO1F;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAQvE"}

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

@@ -0,0 +1,82 @@
+"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.d.ts

@@ -0,0 +1,2 @@
+export { MVTLoader, MVTWorkerLoader } from './mvt-loader';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,eAAe,EAAC,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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; } });

package/dist/lib/binary-vector-tile/features-to-binary.d.ts

@@ -0,0 +1,185 @@
+import { MvtBinaryCoordinates, MvtBinaryOptions, MvtFirstPassedData } from '../types';
+/**
+ * Convert binary features to flat binary arrays. Similar to
+ * `geojsonToBinary` helper function, except that it expects
+ * a binary representation of the feature data, which enables
+ * 2X-3X speed increase in parse speed, compared to using
+ * geoJSON. See `binary-vector-tile/VectorTileFeature` for
+ * data format detais
+ *
+ * @param features
+ * @param firstPassData
+ * @param options
+ * @returns filled arrays
+ */
+export declare function featuresToBinary(features: MvtBinaryCoordinates[], firstPassData: MvtFirstPassedData, options?: MvtBinaryOptions): {
+    points: {
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        globalFeatureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        featureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        numericProps: object;
+        properties: {}[];
+        fields: {
+            id?: number | undefined;
+        }[];
+    };
+    lines: {
+        pathIndices: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        globalFeatureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        featureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        numericProps: object;
+        properties: {}[];
+        fields: {
+            id?: number | undefined;
+        }[];
+    };
+    polygons: {
+        polygonIndices: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        primitivePolygonIndices: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        triangles: {
+            value: Uint32Array;
+            size: number;
+        };
+        globalFeatureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        featureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        numericProps: object;
+        properties: {}[];
+        fields: {
+            id?: number | undefined;
+        }[];
+    };
+};
+export declare const TEST_EXPORTS: {
+    extractNumericPropKeys: typeof extractNumericPropKeys;
+    fillArrays: typeof fillArrays;
+};
+/**
+ * Extracts properties that are always numeric
+ *
+ * @param features
+ * @returns object with numeric keys
+ */
+declare function extractNumericPropKeys(features: MvtBinaryCoordinates[]): string[];
+/**
+ * Fills coordinates into pre-allocated typed arrays
+ *
+ * @param features
+ * @param firstPassData
+ * @param options
+ * @returns an accessor object with value and size keys
+ */
+declare function fillArrays(features: MvtBinaryCoordinates[], firstPassData: MvtFirstPassedData, options: MvtBinaryOptions): {
+    points: {
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        globalFeatureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        featureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        numericProps: object;
+        properties: {}[];
+        fields: {
+            id?: number | undefined;
+        }[];
+    };
+    lines: {
+        pathIndices: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        globalFeatureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        featureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        numericProps: object;
+        properties: {}[];
+        fields: {
+            id?: number | undefined;
+        }[];
+    };
+    polygons: {
+        polygonIndices: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        primitivePolygonIndices: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        positions: {
+            value: Float32Array;
+            size: number;
+        };
+        triangles: {
+            value: Uint32Array;
+            size: number;
+        };
+        globalFeatureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        featureIds: {
+            value: Uint16Array | Uint32Array;
+            size: number;
+        };
+        numericProps: object;
+        properties: {}[];
+        fields: {
+            id?: number | undefined;
+        }[];
+    };
+};
+export {};
+//# sourceMappingURL=features-to-binary.d.ts.map

package/dist/lib/binary-vector-tile/features-to-binary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"features-to-binary.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-vector-tile/features-to-binary.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,oBAAoB,EAEpB,gBAAgB,EAChB,kBAAkB,EAInB,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,oBAAoB,EAAE,EAChC,aAAa,EAAE,kBAAkB,EACjC,OAAO,CAAC,EAAE,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM3B;AAED,eAAO,MAAM,YAAY;;;CAGxB,CAAC;AAEF;;;;;GAKG;AACH,iBAAS,sBAAsB,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,CAkB1E;AAED;;;;;;;GAOG;AAEH,iBAAS,UAAU,CACjB,QAAQ,EAAE,oBAAoB,EAAE,EAChC,aAAa,EAAE,kBAAkB,EACjC,OAAO,EAAE,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoI1B"}