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

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

@@ -0,0 +1,184 @@
+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 {};

package/dist/lib/binary-vector-tile/vector-tile-feature.d.ts

@@ -0,0 +1,35 @@
+import Protobuf from 'pbf';
+import { MvtBinaryCoordinates, MvtBinaryGeometry, MvtFirstPassedData } from '../types';
+import { classifyRings } from '../../helpers/binary-util-functions';
+export declare const TEST_EXPORTS: {
+    classifyRings: typeof classifyRings;
+};
+export default class VectorTileFeature {
+    properties: {
+        [x: string]: string | number | boolean | null;
+    };
+    extent: any;
+    type: number;
+    id: number | null;
+    _pbf: Protobuf;
+    _geometry: number;
+    _keys: string[];
+    _values: (string | number | boolean | null)[];
+    _firstPassData: MvtFirstPassedData;
+    static get types(): string[];
+    constructor(pbf: Protobuf, end: number, extent: any, keys: string[], values: (string | number | boolean | null)[], firstPassData: MvtFirstPassedData);
+    loadGeometry(): MvtBinaryGeometry;
+    /**
+     *
+     * @param transform
+     * @returns result
+     */
+    _toBinaryCoordinates(transform: any): MvtBinaryCoordinates;
+    toBinaryCoordinates(options: {
+        x: number;
+        y: number;
+        z: number;
+    } | ((data: number[], feature: {
+        extent: any;
+    }) => void)): MvtBinaryCoordinates;
+}

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

@@ -0,0 +1,22 @@
+import VectorTileFeature from './vector-tile-feature';
+import Protobuf from 'pbf';
+import { MvtFirstPassedData } from '../types';
+export default class VectorTileLayer {
+    version: number;
+    name: string;
+    extent: number;
+    length: number;
+    _pbf: Protobuf;
+    _keys: string[];
+    _values: (string | number | boolean | null)[];
+    _features: number[];
+    constructor(pbf: Protobuf, end: number);
+    /**
+     * return feature `i` from this layer as a `VectorTileFeature`
+     *
+     * @param index
+     * @param firstPassData
+     * @returns {VectorTileFeature}
+     */
+    feature(i: number, firstPassData: MvtFirstPassedData): VectorTileFeature;
+}

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

@@ -0,0 +1,8 @@
+import VectorTileLayer from './vector-tile-layer';
+import Protobuf from 'pbf';
+export default class VectorTile {
+    layers: {
+        [x: string]: VectorTileLayer;
+    };
+    constructor(pbf: Protobuf, end?: number);
+}

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

@@ -0,0 +1,26 @@
+import Protobuf from 'pbf';
+import { MvtMapboxCoordinates, MvtMapboxGeometry } from '../types';
+export default class VectorTileFeature {
+    properties: {
+        [x: string]: string | number | boolean | null;
+    };
+    extent: any;
+    type: number;
+    id: number | null;
+    _pbf: Protobuf;
+    _geometry: number;
+    _keys: string[];
+    _values: (string | number | boolean | null)[];
+    static get types(): string[];
+    constructor(pbf: Protobuf, end: number, extent: any, keys: string[], values: (string | number | boolean | null)[]);
+    loadGeometry(): MvtMapboxGeometry;
+    bbox(): number[];
+    _toGeoJSON(transform: any): MvtMapboxCoordinates;
+    toGeoJSON(options: {
+        x: number;
+        y: number;
+        z: number;
+    } | ((data: number[], feature: {
+        extent: any;
+    }) => void)): MvtMapboxCoordinates;
+}

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

@@ -0,0 +1,19 @@
+import Protobuf from 'pbf';
+import VectorTileFeature from './vector-tile-feature';
+export default class VectorTileLayer {
+    version: number;
+    name: string;
+    extent: number;
+    length: number;
+    _pbf: Protobuf;
+    _keys: string[];
+    _values: (string | number | boolean | null)[];
+    _features: number[];
+    constructor(pbf: Protobuf, end: number);
+    /**
+     * return feature `i` from this layer as a `VectorTileFeature`
+     * @param index
+     * @returns feature
+     */
+    feature(i: number): VectorTileFeature;
+}

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

@@ -0,0 +1,8 @@
+import VectorTileLayer from './vector-tile-layer';
+import Protobuf from 'pbf';
+export default class VectorTile {
+    layers: {
+        [x: string]: VectorTileLayer;
+    };
+    constructor(pbf: Protobuf, end?: number);
+}

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

@@ -0,0 +1,84 @@
+import { MvtBinaryCoordinates, MvtMapboxCoordinates } from '../lib/types';
+import { LoaderOptions } from '@loaders.gl/loader-utils/';
+/**
+ * Parse MVT arrayBuffer and return GeoJSON.
+ *
+ * @param arrayBuffer A MVT arrayBuffer
+ * @param options
+ * @returns A GeoJSON geometry object or a binary representation
+ */
+export default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptions): {
+    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;
+        }[];
+    };
+} | (MvtBinaryCoordinates | MvtMapboxCoordinates)[];

package/dist/lib/types.d.ts

@@ -0,0 +1,91 @@
+export declare type MvtOptions = {
+    coordinates: string | number[];
+    tileIndex: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    layerProperty: string | number;
+    layerName: string;
+};
+export declare type MvtBinaryGeometry = {
+    data: number[];
+    lines: any[];
+    areas?: number[];
+    type?: string;
+    id?: number;
+};
+export declare type MvtMapboxGeometry = {
+    type?: string;
+    id?: number;
+    length: number;
+    coordinates?: any[];
+};
+export declare type MvtBinaryCoordinates = {
+    type: string;
+    geometry: MvtBinaryGeometry;
+    properties: {
+        [x: string]: string | number | boolean | null;
+    };
+    id?: number;
+};
+export declare type MvtMapboxCoordinates = {
+    type: string;
+    geometry: {
+        type: string;
+        coordinates: MvtMapboxGeometry;
+    };
+    properties: {
+        [x: string]: string | number | boolean | null;
+    };
+    id?: number;
+};
+export declare type MvtBinaryOptions = {
+    numericPropKeys: string[];
+    PositionDataType: Float32ArrayConstructor;
+};
+export declare type MvtFirstPassedData = {
+    pointPositionsCount: number;
+    pointFeaturesCount: number;
+    linePositionsCount: number;
+    linePathsCount: number;
+    lineFeaturesCount: number;
+    polygonPositionsCount: number;
+    polygonObjectsCount: number;
+    polygonRingsCount: number;
+    polygonFeaturesCount: number;
+};
+export declare type MvtPoints = {
+    positions: Float32Array;
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: object;
+    properties: {}[];
+    fields: {
+        id?: number;
+    }[];
+};
+export declare type MvtLines = {
+    pathIndices: Uint16Array | Uint32Array;
+    positions: Float32Array;
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: object;
+    properties: {}[];
+    fields: {
+        id?: number;
+    }[];
+};
+export declare type MvtPolygons = {
+    polygonIndices: Uint16Array | Uint32Array;
+    primitivePolygonIndices: Uint16Array | Uint32Array;
+    positions: Float32Array;
+    triangles: number[];
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: object;
+    properties: {}[];
+    fields: {
+        id?: number;
+    }[];
+};

package/dist/mvt-loader.d.ts

@@ -0,0 +1,9 @@
+import type { Loader, LoaderWithParser } from '@loaders.gl/loader-utils';
+/**
+ * Worker loader for the Mapbox Vector Tile format
+ */
+export declare const MVTWorkerLoader: Loader;
+/**
+ * Loader for the Mapbox Vector Tile format
+ */
+export declare const MVTLoader: LoaderWithParser;