@loaders.gl/mvt 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/workers/mvt-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mvt-worker.d.ts.map

package/dist/workers/mvt-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mvt-worker.d.ts","sourceRoot":"","sources":["../../src/workers/mvt-worker.ts"],"names":[],"mappings":""}

package/dist/workers/mvt-worker.js

@@ -1,4 +1,5 @@
-import { MVTLoader } from '../mvt-loader';
-import { createLoaderWorker } from '@loaders.gl/loader-utils';
-createLoaderWorker(MVTLoader);
-//# sourceMappingURL=mvt-worker.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mvt_loader_1 = require("../mvt-loader");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+(0, loader_utils_1.createLoaderWorker)(mvt_loader_1.MVTLoader);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/mvt",
   "description": "Loader for Mapbox Vector Tiles",
-  "version": "4.0.0-alpha.1",
+  "version": "4.0.0-alpha.11",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -17,9 +17,9 @@
     "MVT",
     "Mapbox Vector Tiles"
   ],
-  "types": "src/index.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -28,17 +28,18 @@
   ],
   "scripts": {
     "pre-build": "npm run build-worker && npm run build-worker --env.dev && npm run build-bundle",
-    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js",
-    "build-worker": "esbuild src/workers/mvt-worker.ts --bundle --outfile=dist/mvt-worker.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js",
+    "build-worker": "esbuild src/workers/mvt-worker.ts --bundle --outfile=dist/mvt-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/gis": "4.0.0-alpha.1",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.1",
+    "@loaders.gl/gis": "4.0.0-alpha.11",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.11",
+    "@loaders.gl/schema": "4.0.0-alpha.11",
     "@math.gl/polygon": "^3.5.1",
     "pbf": "^3.2.1"
   },
   "devDependencies": {
     "@types/pbf": "^3.0.2"
   },
-  "gitHead": "e48f5534fe7188c810f23f965a440c144b3cf6d0"
+  "gitHead": "bc680098cfea790c67b7fb95bab96e8d9288d34f"
 }

package/src/helpers/binary-util-functions.ts

@@ -1,6 +1,6 @@
 import Protobuf from 'pbf';
 import {getPolygonSignedArea} from '@math.gl/polygon';
-import {MvtBinaryGeometry} from '../lib/types';
+import {FlatIndexedGeometry, FlatPolygon} from '@loaders.gl/schema';
 import VectorTileFeature from '../lib/binary-vector-tile/vector-tile-feature';
 
 /**
@@ -13,14 +13,16 @@ import VectorTileFeature from '../lib/binary-vector-tile/vector-tile-feature';
  * @returns object
  */
 // eslint-disable-next-line max-statements
-export function classifyRings(geom: MvtBinaryGeometry) {
-  const len = geom.lines.length;
+export function classifyRings(geom: FlatIndexedGeometry): FlatPolygon {
+  const len = geom.indices.length;
+  const type = 'Polygon';
 
   if (len <= 1) {
     return {
+      type,
       data: geom.data,
       areas: [[getPolygonSignedArea(geom.data)]],
-      lines: [geom.lines]
+      indices: [geom.indices]
     };
   }
 
@@ -32,9 +34,9 @@ export function classifyRings(geom: MvtBinaryGeometry) {
   let offset = 0;
 
   for (let endIndex: number, i = 0, startIndex: number; i < len; i++) {
-    startIndex = geom.lines[i] - offset;
+    startIndex = geom.indices[i] - offset;
 
-    endIndex = geom.lines[i + 1] - offset || geom.data.length;
+    endIndex = geom.indices[i + 1] - offset || geom.data.length;
     const shape = geom.data.slice(startIndex, endIndex);
     const area = getPolygonSignedArea(shape);
 
@@ -70,7 +72,7 @@ export function classifyRings(geom: MvtBinaryGeometry) {
   if (ringAreas) areas.push(ringAreas);
   if (polygon.length) polygons.push(polygon);
 
-  return {areas, lines: polygons, data: geom.data};
+  return {type, areas, indices: polygons, data: geom.data};
 }
 
 /**

package/src/helpers/mapbox-util-functions.ts

@@ -1,5 +1,5 @@
 import Protobuf from 'pbf';
-import {MvtMapboxGeometry} from '../lib/types';
+import {MVTMapboxGeometry} from '../lib/types';
 import VectorTileFeature from '../lib/mapbox-vector-tile/vector-tile-feature';
 
 /**
@@ -7,7 +7,7 @@ import VectorTileFeature from '../lib/mapbox-vector-tile/vector-tile-feature';
  * @param rings
  * @returns polygons
  */
-export function classifyRings(rings: MvtMapboxGeometry) {
+export function classifyRings(rings: MVTMapboxGeometry) {
   const len = rings.length;
 
   if (len <= 1) return [rings];

package/src/index.ts

@@ -1 +1,8 @@
+// loaders.gl, MIT license
+
 export {MVTLoader, MVTWorkerLoader} from './mvt-loader';
+
+// GeoJSONTiler
+
+export type {GeoJSONTilerOptions} from './lib/geojson-tiler/geojson-tiler';
+export {GeoJSONTiler} from './lib/geojson-tiler/geojson-tiler';

package/src/lib/binary-vector-tile/vector-tile-feature.ts

@@ -1,7 +1,7 @@
 // This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
 
 import Protobuf from 'pbf';
-import {MvtBinaryCoordinates, MvtBinaryGeometry, MvtFirstPassedData} from '../types';
+import {FlatFeature, FlatIndexedGeometry, GeojsonGeometryInfo} from '@loaders.gl/schema';
 import {classifyRings, project, readFeature} from '../../helpers/binary-util-functions';
 
 // Reduce GC by reusing variables
@@ -26,10 +26,7 @@ export default class VectorTileFeature {
   _geometry: number;
   _keys: string[];
   _values: (string | number | boolean | null)[];
-  _firstPassData: MvtFirstPassedData;
-  static get types() {
-    return ['Unknown', 'Point', 'LineString', 'Polygon'];
-  }
+  _geometryInfo: GeojsonGeometryInfo;
 
   // eslint-disable-next-line max-params
   constructor(
@@ -38,7 +35,7 @@ export default class VectorTileFeature {
     extent: any,
     keys: string[],
     values: (string | number | boolean | null)[],
-    firstPassData: MvtFirstPassedData
+    geometryInfo: GeojsonGeometryInfo
   ) {
     // Public
     this.properties = {};
@@ -51,13 +48,13 @@ export default class VectorTileFeature {
     this._geometry = -1;
     this._keys = keys;
     this._values = values;
-    this._firstPassData = firstPassData;
+    this._geometryInfo = geometryInfo;
 
     pbf.readFields(readFeature, this, end);
   }
 
   // eslint-disable-next-line complexity, max-statements
-  loadGeometry(): MvtBinaryGeometry {
+  loadGeometry(): FlatIndexedGeometry {
     const pbf = this._pbf;
     pbf.pos = this._geometry;
 
@@ -73,7 +70,7 @@ export default class VectorTileFeature {
     // `set()` and direct index access. Also, we cannot
     // know how large the buffer should be, so it would
     // increase memory usage
-    const lines: number[] = []; // Indices where lines start
+    const indices: number[] = []; // Indices where geometries start
     const data: number[] = []; // Flat array of coordinate data
 
     while (pbf.pos < endPos) {
@@ -91,14 +88,14 @@ export default class VectorTileFeature {
 
         if (cmd === 1) {
           // New line
-          lines.push(i);
+          indices.push(i);
         }
         data.push(x, y);
         i += 2;
       } else if (cmd === 7) {
         // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
         if (i > 0) {
-          const start = lines[lines.length - 1]; // start index of polygon
+          const start = indices[indices.length - 1]; // start index of polygon
           data.push(data[start], data[start + 1]); // closePolygon
           i += 2;
         }
@@ -107,7 +104,7 @@ export default class VectorTileFeature {
       }
     }
 
-    return {data, lines};
+    return {data, indices};
   }
 
   /**
@@ -116,27 +113,28 @@ export default class VectorTileFeature {
    * @returns result
    */
   _toBinaryCoordinates(transform) {
-    // Expands the protobuf data to an intermediate `lines`
+    // Expands the protobuf data to an intermediate Flat GeoJSON
     // data format, which maps closely to the binary data buffers.
     // It is similar to GeoJSON, but rather than storing the coordinates
     // in multidimensional arrays, we have a 1D `data` with all the
-    // coordinates, and then index into this using the `lines`
+    // coordinates, and then index into this using the `indices`
     // parameter, e.g.
     //
     // geometry: {
-    //   type: 'Point', data: [1,2], lines: [0]
+    //   type: 'Point', data: [1,2], indices: [0]
     // }
     // geometry: {
-    //   type: 'LineString', data: [1,2,3,4,...], lines: [0]
+    //   type: 'LineString', data: [1,2,3,4,...], indices: [0]
     // }
     // geometry: {
-    //   type: 'Polygon', data: [1,2,3,4,...], lines: [[0, 2]]
+    //   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
     // }
-    // Thus the lines member lets us look up the relevant range
+    // Thus the indices member lets us look up the relevant range
     // from the data array.
     // The Multi* versions of the above types share the same data
-    // structure, just with multiple elements in the lines array
-    let geom = this.loadGeometry();
+    // structure, just with multiple elements in the indices array
+    const geom = this.loadGeometry();
+    let geometry;
 
     // Apply the supplied transformation to data
     transform(geom.data, this);
@@ -146,43 +144,37 @@ export default class VectorTileFeature {
     // eslint-disable-next-line default-case
     switch (this.type) {
       case 1: // Point
-        this._firstPassData.pointFeaturesCount++;
-        this._firstPassData.pointPositionsCount += geom.lines.length;
+        this._geometryInfo.pointFeaturesCount++;
+        this._geometryInfo.pointPositionsCount += geom.indices.length;
+        geometry = {type: 'Point', ...geom};
         break;
 
       case 2: // LineString
-        this._firstPassData.lineFeaturesCount++;
-        this._firstPassData.linePathsCount += geom.lines.length;
-        this._firstPassData.linePositionsCount += geom.data.length / coordLength;
+        this._geometryInfo.lineFeaturesCount++;
+        this._geometryInfo.linePathsCount += geom.indices.length;
+        this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
+        geometry = {type: 'LineString', ...geom};
         break;
 
       case 3: // Polygon
-        const classified = classifyRings(geom);
+        geometry = classifyRings(geom);
 
-        // Unlike Point & LineString geom.lines is a 2D array, thanks
+        // Unlike Point & LineString geom.indices is a 2D array, thanks
         // to the classifyRings method
-        this._firstPassData.polygonFeaturesCount++;
-        this._firstPassData.polygonObjectsCount += classified.lines.length;
+        this._geometryInfo.polygonFeaturesCount++;
+        this._geometryInfo.polygonObjectsCount += geometry.indices.length;
 
-        for (const lines of classified.lines) {
-          this._firstPassData.polygonRingsCount += lines.length;
+        for (const indices of geometry.indices) {
+          this._geometryInfo.polygonRingsCount += indices.length;
         }
-        this._firstPassData.polygonPositionsCount += classified.data.length / coordLength;
+        this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
 
-        geom = classified;
         break;
+      default:
+        throw new Error(`Invalid geometry type: ${this.type}`);
     }
 
-    geom.type = VectorTileFeature.types[this.type];
-    if (geom.lines.length > 1) {
-      geom.type = `Multi${geom.type}`;
-    }
-
-    const result: MvtBinaryCoordinates = {
-      type: 'Feature',
-      geometry: geom,
-      properties: this.properties
-    };
+    const result: FlatFeature = {type: 'Feature', geometry, properties: this.properties};
 
     if (this.id !== null) {
       result.id = this.id;
@@ -193,10 +185,15 @@ export default class VectorTileFeature {
 
   toBinaryCoordinates(
     options: {x: number; y: number; z: number} | ((data: number[], feature: {extent: any}) => void)
-  ): MvtBinaryCoordinates {
+  ): FlatFeature {
     if (typeof options === 'function') {
       return this._toBinaryCoordinates(options);
     }
-    return this._toBinaryCoordinates(project);
+    const {x, y, z} = options;
+    const size = this.extent * Math.pow(2, z);
+    const x0 = this.extent * x;
+    const y0 = this.extent * y;
+
+    return this._toBinaryCoordinates((data: number[]) => project(data, x0, y0, size));
   }
 }

package/src/lib/binary-vector-tile/vector-tile-layer.ts

@@ -3,7 +3,7 @@
 
 import VectorTileFeature from './vector-tile-feature';
 import Protobuf from 'pbf';
-import {MvtFirstPassedData} from '../types';
+import {GeojsonGeometryInfo} from '@loaders.gl/schema';
 
 export default class VectorTileLayer {
   version: number;
@@ -36,10 +36,10 @@ export default class VectorTileLayer {
    * return feature `i` from this layer as a `VectorTileFeature`
    *
    * @param index
-   * @param firstPassData
+   * @param geometryInfo
    * @returns {VectorTileFeature}
    */
-  feature(i: number, firstPassData: MvtFirstPassedData): VectorTileFeature {
+  feature(i: number, geometryInfo: GeojsonGeometryInfo): VectorTileFeature {
     if (i < 0 || i >= this._features.length) {
       throw new Error('feature index out of bounds');
     }
@@ -53,7 +53,7 @@ export default class VectorTileLayer {
       this.extent,
       this._keys,
       this._values,
-      firstPassData
+      geometryInfo
     );
   }
 }

package/src/lib/geojson-tiler/LICENSE

@@ -0,0 +1,19 @@
+This directory is forked from Mapbox's https://github.com/mapbox/geojson-vt under ISC License.
+
+```
+ISC License
+
+Copyright (c) 2015, Mapbox
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+```

package/src/lib/geojson-tiler/clip.ts

@@ -0,0 +1,248 @@
+// loaders.gl, MIT license
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+import type {GeoJSONTileFeature} from './tile';
+import {createFeature} from './feature';
+
+/* eslint-disable no-continue */
+
+/**
+ * Clip features between two vertical or horizontal axis-parallel lines:
+ *     |        |
+ *  ___|___     |     /
+ * /   |   \____|____/
+ *     |        |
+ *
+ * @param k1 and k2 are the line coordinates
+ * @param axis: 0 for x, 1 for y
+ * @param minAll and maxAll: minimum and maximum coordinate value for all features
+ */
+// eslint-disable-next-line max-params, complexity, max-statements
+export function clip(
+  features: GeoJSONTileFeature[],
+  scale: number,
+  k1: number,
+  k2: number,
+  axis,
+  minAll: number,
+  maxAll: number,
+  options: {lineMetrics: boolean}
+): GeoJSONTileFeature[] | null {
+  k1 /= scale;
+  k2 /= scale;
+
+  if (minAll >= k1 && maxAll < k2) {
+    return features;
+  }
+  // trivial accept
+  else if (maxAll < k1 || minAll >= k2) {
+    return null; // trivial reject
+  }
+
+  const clipped: GeoJSONTileFeature[] = [];
+
+  for (const feature of features) {
+    const geometry = feature.geometry;
+    let type = feature.type;
+
+    const min = axis === 0 ? feature.minX : feature.minY;
+    const max = axis === 0 ? feature.maxX : feature.maxY;
+
+    if (min >= k1 && max < k2) {
+      // trivial accept
+      clipped.push(feature);
+      continue;
+    } else if (max < k1 || min >= k2) {
+      // trivial reject
+      continue;
+    }
+
+    let newGeometry: number[][][] | number[][] = [];
+
+    if (type === 'Point' || type === 'MultiPoint') {
+      clipPoints(geometry, newGeometry, k1, k2, axis);
+    } else if (type === 'LineString') {
+      clipLine(geometry, newGeometry, k1, k2, axis, false, options.lineMetrics);
+    } else if (type === 'MultiLineString') {
+      clipLines(geometry, newGeometry, k1, k2, axis, false);
+    } else if (type === 'Polygon') {
+      clipLines(geometry, newGeometry, k1, k2, axis, true);
+    } else if (type === 'MultiPolygon') {
+      for (const polygon of geometry) {
+        const newPolygon = [];
+        clipLines(polygon, newPolygon, k1, k2, axis, true);
+        if (newPolygon.length) {
+          newGeometry.push(newPolygon);
+        }
+      }
+    }
+
+    if (newGeometry.length) {
+      if (options.lineMetrics && type === 'LineString') {
+        for (const line of newGeometry) {
+          clipped.push(createFeature(feature.id, type, line, feature.tags));
+        }
+        continue;
+      }
+
+      if (type === 'LineString' || type === 'MultiLineString') {
+        if (newGeometry.length === 1) {
+          type = 'LineString';
+          // @ts-expect-error TODO - use proper GeoJSON geometry types
+          newGeometry = newGeometry[0];
+        } else {
+          type = 'MultiLineString';
+        }
+      }
+      if (type === 'Point' || type === 'MultiPoint') {
+        type = newGeometry.length === 3 ? 'Point' : 'MultiPoint';
+      }
+
+      clipped.push(createFeature(feature.id, type, newGeometry, feature.tags));
+    }
+  }
+
+  return clipped.length ? clipped : null;
+}
+
+function clipPoints(geom, newGeom, k1: number, k2: number, axis): void {
+  for (let i = 0; i < geom.length; i += 3) {
+    const a = geom[i + axis];
+
+    if (a >= k1 && a <= k2) {
+      addPoint(newGeom, geom[i], geom[i + 1], geom[i + 2]);
+    }
+  }
+}
+
+// eslint-disable-next-line max-params, complexity, max-statements
+function clipLine(
+  geom,
+  newGeom,
+  k1: number,
+  k2: number,
+  axis,
+  isPolygon: boolean,
+  trackMetrics: boolean
+): void {
+  let slice = newSlice(geom);
+  const intersect = axis === 0 ? intersectX : intersectY;
+  let len = geom.start;
+  let segLen;
+  let t;
+
+  for (let i = 0; i < geom.length - 3; i += 3) {
+    const ax = geom[i];
+    const ay = geom[i + 1];
+    const az = geom[i + 2];
+    const bx = geom[i + 3];
+    const by = geom[i + 4];
+    const a = axis === 0 ? ax : ay;
+    const b = axis === 0 ? bx : by;
+    let exited = false;
+
+    if (trackMetrics) {
+      segLen = Math.sqrt(Math.pow(ax - bx, 2) + Math.pow(ay - by, 2));
+    }
+
+    if (a < k1) {
+      // ---|-->  | (line enters the clip region from the left)
+      if (b > k1) {
+        t = intersect(slice, ax, ay, bx, by, k1);
+        if (trackMetrics) {
+          slice.start = len + segLen * t;
+        }
+      }
+    } else if (a > k2) {
+      // |  <--|--- (line enters the clip region from the right)
+      if (b < k2) {
+        t = intersect(slice, ax, ay, bx, by, k2);
+        if (trackMetrics) {
+          slice.start = len + segLen * t;
+        }
+      }
+    } else {
+      addPoint(slice, ax, ay, az);
+    }
+    if (b < k1 && a >= k1) {
+      // <--|---  | or <--|-----|--- (line exits the clip region on the left)
+      t = intersect(slice, ax, ay, bx, by, k1);
+      exited = true;
+    }
+    if (b > k2 && a <= k2) {
+      // |  ---|--> or ---|-----|--> (line exits the clip region on the right)
+      t = intersect(slice, ax, ay, bx, by, k2);
+      exited = true;
+    }
+
+    if (!isPolygon && exited) {
+      if (trackMetrics) {
+        slice.end = len + segLen * t;
+      }
+      newGeom.push(slice);
+      slice = newSlice(geom);
+    }
+
+    if (trackMetrics) {
+      len += segLen;
+    }
+  }
+
+  // add the last point
+  let last = geom.length - 3;
+  const ax = geom[last];
+  const ay = geom[last + 1];
+  const az = geom[last + 2];
+  const a = axis === 0 ? ax : ay;
+  if (a >= k1 && a <= k2) addPoint(slice, ax, ay, az);
+
+  // close the polygon if its endpoints are not the same after clipping
+  last = slice.length - 3;
+  if (isPolygon && last >= 3 && (slice[last] !== slice[0] || slice[last + 1] !== slice[1])) {
+    addPoint(slice, slice[0], slice[1], slice[2]);
+  }
+
+  // add the final slice
+  if (slice.length) {
+    newGeom.push(slice);
+  }
+}
+
+class Slice extends Array<number> {
+  size?: number;
+  start?: number;
+  end?: number;
+}
+
+function newSlice(line: {size: number; start: number; end: number}): Slice {
+  const slice: Slice = [];
+  slice.size = line.size;
+  slice.start = line.start;
+  slice.end = line.end;
+  return slice;
+}
+
+// eslint-disable-next-line max-params
+function clipLines(geom, newGeom, k1: number, k2: number, axis, isPolygon: boolean): void {
+  for (const line of geom) {
+    clipLine(line, newGeom, k1, k2, axis, isPolygon, false);
+  }
+}
+
+function addPoint(out: number[], x: number, y: number, z: number): void {
+  out.push(x, y, z);
+}
+
+// eslint-disable-next-line max-params
+function intersectX(out, ax: number, ay: number, bx: number, by: number, x: number): number {
+  const t = (x - ax) / (bx - ax);
+  addPoint(out, x, ay + (by - ay) * t, 1);
+  return t;
+}
+
+// eslint-disable-next-line max-params
+function intersectY(out, ax: number, ay: number, bx: number, by: number, y): number {
+  const t = (y - ay) / (by - ay);
+  addPoint(out, ax + (bx - ax) * t, y, 1);
+  return t;
+}