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

package/dist/{mvt-loader.js → esm/mvt-loader.js}

@@ -1,5 +1,5 @@
 import parseMVT from './lib/parse-mvt';
-const VERSION = typeof "3.1.0-alpha.1" !== 'undefined' ? "3.1.0-alpha.1" : 'latest';
+const VERSION = typeof "3.1.0-alpha.5" !== 'undefined' ? "3.1.0-alpha.5" : 'latest';
 export const MVTWorkerLoader = {
   name: 'Mapbox Vector Tile',
   id: 'mvt',

package/dist/esm/mvt-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/mvt-loader.ts"],"names":["parseMVT","VERSION","MVTWorkerLoader","name","id","module","version","extensions","mimeTypes","worker","category","options","mvt","coordinates","layerProperty","layers","tileIndex","MVTLoader","parse","arrayBuffer","parseSync","binary"],"mappings":"AACA,OAAOA,QAAP,MAAqB,iBAArB;AAIA,MAAMC,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAKA,OAAO,MAAMC,eAAuB,GAAG;AACrCC,EAAAA,IAAI,EAAE,oBAD+B;AAErCC,EAAAA,EAAE,EAAE,KAFiC;AAGrCC,EAAAA,MAAM,EAAE,KAH6B;AAIrCC,EAAAA,OAAO,EAAEL,OAJ4B;AAMrCM,EAAAA,UAAU,EAAE,CAAC,KAAD,EAAQ,KAAR,CANyB;AAOrCC,EAAAA,SAAS,EAAE,CACT,oCADS,EAET,wBAFS,CAP0B;AAYrCC,EAAAA,MAAM,EAAE,IAZ6B;AAarCC,EAAAA,QAAQ,EAAE,UAb2B;AAcrCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,GAAG,EAAE;AACHC,MAAAA,WAAW,EAAE,OADV;AAEHC,MAAAA,aAAa,EAAE,WAFZ;AAGHC,MAAAA,MAAM,EAAE,IAHL;AAIHC,MAAAA,SAAS,EAAE;AAJR;AADE;AAd4B,CAAhC;AA2BP,OAAO,MAAMC,SAA2B,GAAG,EACzC,GAAGf,eADsC;AAEzCgB,EAAAA,KAAK,EAAE,OAAOC,WAAP,EAAoBR,OAApB,KAAgCX,QAAQ,CAACmB,WAAD,EAAcR,OAAd,CAFN;AAGzCS,EAAAA,SAAS,EAAEpB,QAH8B;AAIzCqB,EAAAA,MAAM,EAAE;AAJiC,CAApC","sourcesContent":["import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport parseMVT from './lib/parse-mvt';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/**\n * Worker loader for the Mapbox Vector Tile format\n */\nexport const MVTWorkerLoader: Loader = {\n  name: 'Mapbox Vector Tile',\n  id: 'mvt',\n  module: 'mvt',\n  version: VERSION,\n  // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'\n  extensions: ['mvt', 'pbf'],\n  mimeTypes: [\n    'application/vnd.mapbox-vector-tile',\n    'application/x-protobuf'\n    // 'application/octet-stream'\n  ],\n  worker: true,\n  category: 'geometry',\n  options: {\n    mvt: {\n      coordinates: 'local',\n      layerProperty: 'layerName',\n      layers: null,\n      tileIndex: null\n    }\n  }\n};\n\n/**\n * Loader for the Mapbox Vector Tile format\n */\nexport const MVTLoader: LoaderWithParser = {\n  ...MVTWorkerLoader,\n  parse: async (arrayBuffer, options) => parseMVT(arrayBuffer, options),\n  parseSync: parseMVT,\n  binary: true\n};\n"],"file":"mvt-loader.js"}

package/dist/esm/workers/mvt-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/workers/mvt-worker.ts"],"names":["MVTLoader","createLoaderWorker"],"mappings":"AAAA,SAAQA,SAAR,QAAwB,eAAxB;AACA,SAAQC,kBAAR,QAAiC,0BAAjC;AAEAA,kBAAkB,CAACD,SAAD,CAAlB","sourcesContent":["import {MVTLoader} from '../mvt-loader';\nimport {createLoaderWorker} from '@loaders.gl/loader-utils';\n\ncreateLoaderWorker(MVTLoader);\n"],"file":"mvt-worker.js"}

package/dist/helpers/binary-util-functions.d.ts

@@ -0,0 +1,38 @@
+import Protobuf from 'pbf';
+import { MvtBinaryGeometry } from '../lib/types';
+import VectorTileFeature from '../lib/binary-vector-tile/vector-tile-feature';
+/**
+ * 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
+ */
+export declare function classifyRings(geom: MvtBinaryGeometry): {
+    areas: any[];
+    lines: any[];
+    data: number[];
+};
+/**
+ *
+ * @param data
+ * @param x0
+ * @param y0
+ * @param size
+ */
+export declare function project(data: number[], x0: number, y0: number, size: number): void;
+/**
+ * All code below is unchanged from the original Mapbox implemenation
+ *
+ * @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;

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

@@ -0,0 +1,28 @@
+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;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { MVTLoader, MVTWorkerLoader } from './mvt-loader';

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;