@loaders.gl/mvt 4.2.1 → 4.3.0-alpha.2

package/dist/table-tile-source.d.ts

@@ -0,0 +1,118 @@
+import type { VectorTileSourceProps, GetTileDataParameters, GetTileParameters } from '@loaders.gl/loader-utils';
+import { VectorTileSource } from '@loaders.gl/loader-utils';
+import { Schema, GeoJSONTable, Feature, BinaryFeatureCollection } from '@loaders.gl/schema';
+import { Stats } from '@probe.gl/stats';
+import type { TableTile, TableTileFeature } from "./lib/vector-tiler/tile.js";
+/** Options to configure tiling */
+export type TableTileSourceProps = VectorTileSourceProps & {
+    coordinates: 'local' | 'wgs84' | 'EPSG:4326';
+    /** max zoom to preserve detail on */
+    maxZoom?: number;
+    /** max zoom in the tile index */
+    indexMaxZoom?: number;
+    /** max number of points per tile in the tile index */
+    maxPointsPerTile?: number;
+    /** simplification tolerance (higher means simpler) */
+    tolerance?: number;
+    /** tile extent */
+    extent?: number;
+    /** tile buffer on each side */
+    buffer?: number;
+    /** name of a feature property to be promoted to feature.id */
+    promoteId?: string;
+    /** whether to generate feature ids. Cannot be used with promoteId */
+    generateId?: boolean;
+    /** logging level (0, 1 or 2) */
+    debug?: number;
+    /** whether to calculate line metrics */
+    lineMetrics?: boolean;
+};
+/**
+ * Dynamically vector tiles a table (the table needs a geometry column)
+ * - Tiles are generated when requested.
+ * - Each tile contains a tables of clipped features.
+ *
+ * @note - Currently only accepts `GeoJSONTable` tables
+ * @note - Currently only outputs `GeoJSONTable`
+ * @note - (can be initialized with a promise that resolves to GeoJSONTable).
+ *
+ * @todo - metadata should scan all rows to determine schema
+ * @todo - metadata scan all rows to determine tilestats (field values[] etc).
+ * @todo - handle binary input tables
+ * @todo - generate binary output tables
+ * @todo - how does TileSourceLayer specify coordinates / decided which layer to render with
+ */
+export declare class TableTileSource implements VectorTileSource<any> {
+    static defaultProps: Required<TableTileSourceProps>;
+    /** Global stats for all TableTileSources */
+    static stats: Stats;
+    /** Stats for this TableTileSource */
+    stats: Stats;
+    /** MIME type of the tiles emitted by this tile source */
+    readonly mimeType = "application/vnd.mapbox-vector-tile";
+    readonly localCoordinates = true;
+    /** The props that this tile source was created with */
+    props: Required<TableTileSourceProps>;
+    schema: Schema | null;
+    /** Map of generated tiles, indexed by stringified tile coordinates */
+    tiles: Record<string, TableTile>;
+    /** Array of tile coordinates */
+    tileCoords: {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+    /** Input data has loaded, initial top-level tiling is done, sync methods can now be called */
+    ready: Promise<void>;
+    /** Metadata for the tile source (generated TileJSON/tilestats */
+    metadata: Promise<unknown>;
+    constructor(table: GeoJSONTable | Promise<GeoJSONTable>, props?: TableTileSourceProps);
+    initializeTilesAsync(tablePromise: GeoJSONTable | Promise<GeoJSONTable>): Promise<void>;
+    getMetadata(): Promise<unknown>;
+    getSchema(): Promise<Schema>;
+    /**
+     * Get a tile at the specified index
+     * @param tileIndex z, x, y of tile
+     * @returns
+     */
+    getVectorTile(tileIndex: GetTileParameters): Promise<GeoJSONTable | null>;
+    getTile(tileIndex: {
+        z: number;
+        x: number;
+        y: number;
+    }): Promise<GeoJSONTable | null>;
+    getTileData(tileParams: GetTileDataParameters): Promise<Feature[] | BinaryFeatureCollection>;
+    /**
+     * Synchronously request a tile
+     * @note Application must await `source.ready` before calling sync methods.
+     */
+    getTileSync(tileIndex: {
+        z: number;
+        x: number;
+        y: number;
+    }): GeoJSONTable | null;
+    /**
+     * Create the initial tiles
+     * @note the tiles stores all the features together with additional data
+     */
+    createRootTiles(table: GeoJSONTable): void;
+    /**
+     * Return geojsonvt-style "half formed" vector tile
+     * @note Application must await `source.ready` before calling sync methods.
+     */
+    getRawTile(tileIndex: {
+        z: number;
+        x: number;
+        y: number;
+    }): TableTile | null;
+    /**
+     * splits features from a parent tile to sub-tiles.
+     * @param z, x, and y are the coordinates of the parent tile
+     * @param cz, cx, and cy are the coordinates of the target tile
+     *
+     * If no target tile is specified, splitting stops when we reach the maximum
+     * zoom or the number of points is low as specified in the props.
+     */
+    splitTile(features: TableTileFeature[], z: number, x: number, y: number, cz?: number, cx?: number, cy?: number): void;
+}
+//# sourceMappingURL=table-tile-source.d.ts.map

package/dist/table-tile-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-tile-source.d.ts","sourceRoot":"","sources":["../src/table-tile-source.ts"],"names":[],"mappings":"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"}

package/dist/table-tile-source.js

@@ -0,0 +1,370 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT AND ISC
+// Copyright (c) vis.gl contributors
+// Based on https://github.com/mapbox/geojson-vt under compatible ISC license
+import { log } from '@loaders.gl/loader-utils';
+import { deduceTableSchema } from '@loaders.gl/schema';
+import { Stats, Stat } from '@probe.gl/stats';
+import { convert } from "./lib/vector-tiler/convert.js"; // GeoJSON conversion and preprocessing
+import { clip } from "./lib/vector-tiler/clip.js"; // stripe clipping algorithm
+import { wrap } from "./lib/vector-tiler/wrap.js"; // date line processing
+import { transformTile } from "./lib/vector-tiler/transform.js"; // coordinate transformation
+import { createTile } from "./lib/vector-tiler/tile.js"; // final simplified tile generation
+import { projectToLngLat } from "./lib/utils/geometry-utils.js";
+import { convertToLocalCoordinates } from "./lib/utils/geometry-utils.js";
+/**
+ * Dynamically vector tiles a table (the table needs a geometry column)
+ * - Tiles are generated when requested.
+ * - Each tile contains a tables of clipped features.
+ *
+ * @note - Currently only accepts `GeoJSONTable` tables
+ * @note - Currently only outputs `GeoJSONTable`
+ * @note - (can be initialized with a promise that resolves to GeoJSONTable).
+ *
+ * @todo - metadata should scan all rows to determine schema
+ * @todo - metadata scan all rows to determine tilestats (field values[] etc).
+ * @todo - handle binary input tables
+ * @todo - generate binary output tables
+ * @todo - how does TileSourceLayer specify coordinates / decided which layer to render with
+ */
+export class TableTileSource {
+    static defaultProps = {
+        coordinates: 'wgs84', // coordinates in tile coordinates or lng/lat
+        maxZoom: 14, // max zoom to preserve detail on
+        indexMaxZoom: 5, // max zoom in the tile index
+        maxPointsPerTile: 100000, // max number of points per tile in the tile index
+        tolerance: 3, // simplification tolerance (higher means simpler)
+        extent: 4096, // tile extent
+        buffer: 64, // tile buffer on each side
+        lineMetrics: false, // whether to calculate line metrics
+        // @ts-expect-error
+        promoteId: undefined, // name of a feature property to be promoted to feature.id
+        generateId: false, // whether to generate feature ids. Cannot be used with promoteId
+        debug: 0 // logging level (0, 1 or 2)
+    };
+    /** Global stats for all TableTileSources */
+    static stats = new Stats({
+        id: 'table-tile-source-all',
+        stats: [new Stat('count', 'tiles'), new Stat('count', 'features')]
+    });
+    /** Stats for this TableTileSource */
+    stats = new Stats({
+        id: 'table-tile-source',
+        stats: [new Stat('tiles', 'count'), new Stat('features', 'count')]
+    });
+    /** MIME type of the tiles emitted by this tile source */
+    mimeType = 'application/vnd.mapbox-vector-tile';
+    localCoordinates = true;
+    /** The props that this tile source was created with */
+    props;
+    /* Schema of the data */
+    schema = null;
+    /** Map of generated tiles, indexed by stringified tile coordinates */
+    tiles = {};
+    /** Array of tile coordinates */
+    tileCoords = [];
+    /** Input data has loaded, initial top-level tiling is done, sync methods can now be called */
+    ready;
+    /** Metadata for the tile source (generated TileJSON/tilestats */
+    metadata;
+    constructor(table, props) {
+        this.props = { ...TableTileSource.defaultProps, ...props };
+        this.getTileData = this.getTileData.bind(this);
+        this.ready = this.initializeTilesAsync(table);
+        this.metadata = this.getMetadata();
+    }
+    async initializeTilesAsync(tablePromise) {
+        const table = await tablePromise;
+        this.schema = deduceTableSchema(table);
+        this.createRootTiles(table);
+    }
+    async getMetadata() {
+        await this.ready;
+        return { schema: this.schema, minZoom: 0, maxZoom: this.props.maxZoom };
+    }
+    async getSchema() {
+        await this.ready;
+        return this.schema;
+    }
+    /**
+     * Get a tile at the specified index
+     * @param tileIndex z, x, y of tile
+     * @returns
+     */
+    async getVectorTile(tileIndex) {
+        await this.ready;
+        const table = this.getTileSync(tileIndex);
+        log.info(2, 'getVectorTile', tileIndex, table)();
+        return table;
+    }
+    async getTile(tileIndex) {
+        await this.ready;
+        return this.getTileSync(tileIndex);
+    }
+    async getTileData(tileParams) {
+        const { x, y, z } = tileParams.index;
+        const tile = await this.getVectorTile({ x, y, z });
+        return tile?.features || [];
+    }
+    // Implementation
+    /**
+     * Synchronously request a tile
+     * @note Application must await `source.ready` before calling sync methods.
+     */
+    getTileSync(tileIndex) {
+        const rawTile = this.getRawTile(tileIndex);
+        if (!rawTile) {
+            return null;
+        }
+        return convertToGeoJSONTable(rawTile, {
+            coordinates: this.props.coordinates,
+            tileIndex,
+            extent: this.props.extent
+        });
+    }
+    /**
+     * Create the initial tiles
+     * @note the tiles stores all the features together with additional data
+     */
+    createRootTiles(table) {
+        if (this.props.maxZoom < 0 || this.props.maxZoom > 24) {
+            throw new Error('maxZoom should be in the 0-24 range');
+        }
+        if (this.props.promoteId && this.props.generateId) {
+            throw new Error('promoteId and generateId cannot be used together.');
+        }
+        log.log(1, 'TableTileSource creating root tiles', this.props)();
+        // projects and adds simplification info
+        log.time(1, 'preprocess table')();
+        let features = convert(table, this.props);
+        log.timeEnd(1, 'preprocess table')();
+        // wraps features (ie extreme west and extreme east)
+        log.time(1, 'generate tiles')();
+        features = wrap(features, this.props);
+        // start slicing from the top tile down
+        if (features.length === 0) {
+            log.log(1, 'TableTileSource: no features generated')();
+            return;
+        }
+        this.splitTile(features, 0, 0, 0);
+        const rootTile = this.tiles[0];
+        log.log(1, `root tile features: ${rootTile.numFeatures}, points: ${rootTile.numPoints}`)();
+        log.timeEnd(1, 'generate tiles')();
+        log.log(1, `TableTileSource: tiles generated: ${this.stats.get('total').count}`, this.stats)();
+    }
+    /**
+     * Return geojsonvt-style "half formed" vector tile
+     * @note Application must await `source.ready` before calling sync methods.
+     */
+    // eslint-disable-next-line complexity, max-statements
+    getRawTile(tileIndex) {
+        const { z, y } = tileIndex;
+        let { x } = tileIndex;
+        // z = +z;
+        // x = +x;
+        // y = +y;
+        const { extent } = this.props;
+        if (z < 0 || z > 24) {
+            return null;
+        }
+        const z2 = 1 << z;
+        x = (x + z2) & (z2 - 1); // wrap tile x coordinate
+        const id = toID(z, x, y);
+        if (this.tiles[id]) {
+            return transformTile(this.tiles[id], extent);
+        }
+        log.log(log, 'drilling down to z%d-%d-%d', z, x, y)();
+        let z0 = z;
+        let x0 = x;
+        let y0 = y;
+        let parent;
+        while (!parent && z0 > 0) {
+            z0--;
+            x0 = x0 >> 1;
+            y0 = y0 >> 1;
+            parent = this.tiles[toID(z0, x0, y0)];
+        }
+        if (!parent || !parent.source) {
+            return null;
+        }
+        // if we found a parent tile containing the original geometry, we can drill down from it
+        log.log(1, 'found parent tile z%d-%d-%d', z0, x0, y0)();
+        log.time(1, 'drilling down')();
+        this.splitTile(parent.source, z0, x0, y0, z, x, y);
+        log.timeEnd(1, 'drilling down')();
+        return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
+    }
+    /**
+     * splits features from a parent tile to sub-tiles.
+     * @param z, x, and y are the coordinates of the parent tile
+     * @param cz, cx, and cy are the coordinates of the target tile
+     *
+     * If no target tile is specified, splitting stops when we reach the maximum
+     * zoom or the number of points is low as specified in the props.
+     */
+    // eslint-disable-next-line max-params, max-statements, complexity
+    splitTile(features, z, x, y, cz, cx, cy) {
+        const stack = [features, z, x, y];
+        // avoid recursion by using a processing queue
+        while (stack.length) {
+            y = stack.pop();
+            x = stack.pop();
+            z = stack.pop();
+            features = stack.pop();
+            const z2 = 1 << z;
+            const id = toID(z, x, y);
+            let tile = this.tiles[id];
+            if (!tile) {
+                log.time(2, 'tile creation')();
+                tile = this.tiles[id] = createTile(features, z, x, y, this.props);
+                this.tileCoords.push({ z, x, y });
+                const key = `z${z}`;
+                let stat = this.stats.get(key, 'count');
+                stat.incrementCount();
+                stat = this.stats.get('total');
+                stat.incrementCount();
+                stat = TableTileSource.stats.get(key, 'count');
+                stat.incrementCount();
+                stat = TableTileSource.stats.get('total');
+                stat.incrementCount();
+                log.log(2, 'tile z%d-%d-%d (features: %d, points: %d, simplified: %d)', z, x, y, tile.numFeatures, tile.numPoints, tile.numSimplified)();
+                log.timeEnd(2, 'tile creation')();
+            }
+            // save reference to original geometry in tile so that we can drill down later if we stop now
+            tile.source = features;
+            /** eslint-disable no-continue */
+            // if it's the first-pass tiling
+            if (cz === undefined) {
+                // stop tiling if we reached max zoom, or if the tile is too simple
+                if (z === this.props.indexMaxZoom || tile.numPoints <= this.props.maxPointsPerTile) {
+                    continue;
+                }
+                // if a drilldown to a specific tile
+            }
+            else if (z === this.props.maxZoom || z === cz) {
+                // stop tiling if we reached base zoom or our target tile zoom
+                continue;
+            }
+            else if (cz !== undefined) {
+                // stop tiling if it's not an ancestor of the target tile
+                const zoomSteps = cz - z;
+                // @ts-expect-error TODO fix the types of cx cy
+                if (x !== cx >> zoomSteps || y !== cy >> zoomSteps) {
+                    continue;
+                }
+            }
+            // if we slice further down, no need to keep source geometry
+            tile.source = null;
+            if (features.length === 0)
+                continue;
+            log.time(2, 'clipping tile')();
+            // values we'll use for clipping
+            const k1 = (0.5 * this.props.buffer) / this.props.extent;
+            const k2 = 0.5 - k1;
+            const k3 = 0.5 + k1;
+            const k4 = 1 + k1;
+            let tl = null;
+            let bl = null;
+            let tr = null;
+            let br = null;
+            let left = clip(features, z2, x - k1, x + k3, 0, tile.minX, tile.maxX, this.props);
+            let right = clip(features, z2, x + k2, x + k4, 0, tile.minX, tile.maxX, this.props);
+            // @ts-expect-error - unclear why this is needed?
+            features = null;
+            if (left) {
+                tl = clip(left, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, this.props);
+                bl = clip(left, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, this.props);
+                left = null;
+            }
+            if (right) {
+                tr = clip(right, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, this.props);
+                br = clip(right, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, this.props);
+                right = null;
+            }
+            log.timeEnd(2, 'clipping tile')();
+            stack.push(tl || [], z + 1, x * 2, y * 2);
+            stack.push(bl || [], z + 1, x * 2, y * 2 + 1);
+            stack.push(tr || [], z + 1, x * 2 + 1, y * 2);
+            stack.push(br || [], z + 1, x * 2 + 1, y * 2 + 1);
+        }
+    }
+}
+function toID(z, x, y) {
+    return ((1 << z) * y + x) * 32 + z;
+}
+// eslint-disable-next-line max-statements, complexity
+function convertToGeoJSONTable(vtTile, props) {
+    const features = [];
+    for (const rawFeature of vtTile.features) {
+        if (!rawFeature || !rawFeature.geometry) {
+            continue;
+        }
+        let type;
+        let coordinates;
+        // raw geometry
+        switch (rawFeature.type) {
+            case 1:
+                if (rawFeature.geometry.length === 1) {
+                    type = 'Point';
+                    coordinates = rawFeature.geometry[0];
+                }
+                else {
+                    type = 'MultiPoint';
+                    coordinates = rawFeature.geometry;
+                }
+                break;
+            case 2:
+                if (rawFeature.geometry.length === 1) {
+                    type = 'LineString';
+                    coordinates = rawFeature.geometry[0];
+                }
+                else {
+                    type = 'MultiLineString';
+                    coordinates = rawFeature.geometry;
+                }
+                break;
+            case 3:
+                if (rawFeature.geometry.length > 1) {
+                    type = 'MultiPolygon';
+                    coordinates = [rawFeature.geometry];
+                }
+                else {
+                    type = 'Polygon';
+                    coordinates = rawFeature.geometry;
+                }
+                break;
+            default:
+                continue;
+        }
+        switch (props.coordinates) {
+            case 'EPSG:4326':
+            case 'wgs84':
+                projectToLngLat(coordinates, props.tileIndex, props.extent);
+                break;
+            case 'local':
+                convertToLocalCoordinates(coordinates, props.extent);
+                break;
+            default:
+                throw new Error(`Unsupported CRS ${props.coordinates}`);
+        }
+        const feature = {
+            type: 'Feature',
+            geometry: {
+                type,
+                coordinates
+            },
+            properties: rawFeature.tags || {},
+            id: rawFeature.id
+        };
+        features.push(feature);
+    }
+    if (features.length === 0) {
+        return null;
+    }
+    const table = {
+        shape: 'geojson-table',
+        type: 'FeatureCollection',
+        features
+    };
+    return table;
+}

package/dist/tilejson-loader.js

@@ -4,7 +4,7 @@
 import { parseTileJSON } from "./lib/parse-tilejson.js";
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "4.2.0" !== 'undefined' ? "4.2.0" : 'latest';
+const VERSION = typeof "4.3.0-alpha.1" !== 'undefined' ? "4.3.0-alpha.1" : 'latest';
 /**
  * Loader for TileJSON metadata
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/mvt",
   "description": "Loader for Mapbox Vector Tiles",
-  "version": "4.2.1",
+  "version": "4.3.0-alpha.2",
   "license": "MIT",
   "type": "module",
   "publishConfig": {
@@ -41,11 +41,12 @@
     "build-worker": "esbuild src/workers/mvt-worker.ts --bundle --outfile=dist/mvt-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/gis": "4.2.1",
-    "@loaders.gl/images": "4.2.1",
-    "@loaders.gl/loader-utils": "4.2.1",
-    "@loaders.gl/schema": "4.2.1",
+    "@loaders.gl/gis": "4.3.0-alpha.2",
+    "@loaders.gl/images": "4.3.0-alpha.2",
+    "@loaders.gl/loader-utils": "4.3.0-alpha.2",
+    "@loaders.gl/schema": "4.3.0-alpha.2",
     "@math.gl/polygon": "^4.0.0",
+    "@probe.gl/stats": "^4.0.0",
     "pbf": "^3.2.1"
   },
   "devDependencies": {
@@ -54,5 +55,5 @@
   "peerDependencies": {
     "@loaders.gl/core": "^4.0.0"
   },
-  "gitHead": "b2ea799ff9f233ab8af0a6c3696e28ddf6e3c5a3"
+  "gitHead": "77a3cb538ab7a1fbf74245f25590210451689f5c"
 }

package/src/index.ts

@@ -11,7 +11,7 @@ export {TileJSONLoader} from './tilejson-loader';
 
 export {MVTSource} from './mvt-source';
 
-// GeoJSONTiler
+// TableTileSource
 
-export type {GeoJSONTilerOptions} from './lib/geojson-tiler/geojson-tiler';
-export {GeoJSONTiler} from './lib/geojson-tiler/geojson-tiler';
+export type {TableTileSourceProps} from './table-tile-source';
+export {TableTileSource} from './table-tile-source';