@loaders.gl/mvt 4.0.0-alpha.5 → 4.0.0-alpha.7

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.5",
+  "version": "4.0.0-alpha.7",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -18,8 +18,8 @@
     "Mapbox Vector Tiles"
   ],
   "types": "dist/index.d.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -32,14 +32,14 @@
     "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.5",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.5",
-    "@loaders.gl/schema": "4.0.0-alpha.5",
+    "@loaders.gl/gis": "4.0.0-alpha.7",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.7",
+    "@loaders.gl/schema": "4.0.0-alpha.7",
     "@math.gl/polygon": "^3.5.1",
     "pbf": "^3.2.1"
   },
   "devDependencies": {
     "@types/pbf": "^3.0.2"
   },
-  "gitHead": "7a71a54bdf1ddf985cc3af3db90b82e7fa97d025"
+  "gitHead": "afb59c4d8e5d8ebb9c28f111cb0c96c5527d0ffd"
 }

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

@@ -189,6 +189,11 @@ export default class VectorTileFeature {
     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/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;
+}

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

@@ -0,0 +1,158 @@
+// loaders.gl, MIT license
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+/* eslint-disable */
+// @ts-nocheck
+
+import type {Feature} from '@loaders.gl/schema';
+import type {GeoJSONTileFeature} from './tile';
+
+import {simplify} from './simplify';
+import {createFeature} from './feature';
+
+// converts GeoJSON feature into an intermediate projected JSON vector format with simplification data
+
+export function convert(data: Feature, options): GeoJSONTileFeature[] {
+  const features = [];
+  if (data.type === 'FeatureCollection') {
+    for (let i = 0; i < data.features.length; i++) {
+      convertFeature(features, data.features[i], options, i);
+    }
+  } else if (data.type === 'Feature') {
+    convertFeature(features, data, options);
+  } else {
+    // single geometry or a geometry collection
+    convertFeature(features, {geometry: data}, options);
+  }
+
+  return features;
+}
+
+export type ConvertFeatureOptions = {
+  maxZoom?: number;
+  tolerance: number;
+  extent: number;
+  lineMetrics: boolean;
+};
+
+function convertFeature(
+  features: GeoJSONTileFeature[],
+  geojson: Feature,
+  options: ConvertFeatureOptions,
+  index: number
+): void {
+  if (!geojson.geometry) {
+    return;
+  }
+
+  const coords = geojson.geometry.coordinates;
+  const type = geojson.geometry.type;
+  const tolerance = Math.pow(options.tolerance / ((1 << options.maxZoom) * options.extent), 2);
+  let geometry = [];
+  let id = geojson.id;
+  if (options.promoteId) {
+    id = geojson.properties[options.promoteId];
+  } else if (options.generateId) {
+    id = index || 0;
+  }
+  if (type === 'Point') {
+    convertPoint(coords, geometry);
+  } else if (type === 'MultiPoint') {
+    for (const p of coords) {
+      convertPoint(p, geometry);
+    }
+  } else if (type === 'LineString') {
+    convertLine(coords, geometry, tolerance, false);
+  } else if (type === 'MultiLineString') {
+    if (options.lineMetrics) {
+      // explode into linestrings to be able to track metrics
+      for (const line of coords) {
+        geometry = [];
+        convertLine(line, geometry, tolerance, false);
+        features.push(createFeature(id, 'LineString', geometry, geojson.properties));
+      }
+      return;
+    } else {
+      convertLines(coords, geometry, tolerance, false);
+    }
+  } else if (type === 'Polygon') {
+    convertLines(coords, geometry, tolerance, true);
+  } else if (type === 'MultiPolygon') {
+    for (const polygon of coords) {
+      const newPolygon = [];
+      convertLines(polygon, newPolygon, tolerance, true);
+      geometry.push(newPolygon);
+    }
+  } else if (type === 'GeometryCollection') {
+    for (const singleGeometry of geojson.geometry.geometries) {
+      convertFeature(
+        features,
+        {
+          id,
+          geometry: singleGeometry,
+          properties: geojson.properties
+        },
+        options,
+        index
+      );
+    }
+    return;
+  } else {
+    throw new Error('Input data is not a valid GeoJSON object.');
+  }
+
+  features.push(createFeature(id, type, geometry, geojson.properties));
+}
+
+function convertPoint(coords, out): void {
+  out.push(projectX(coords[0]), projectY(coords[1]), 0);
+}
+
+function convertLine(ring: number[], out, tolerance: number, isPolygon: boolean): void {
+  let x0, y0;
+  let size = 0;
+
+  for (let j = 0; j < ring.length; j++) {
+    const x = projectX(ring[j][0]);
+    const y = projectY(ring[j][1]);
+
+    out.push(x, y, 0);
+
+    if (j > 0) {
+      if (isPolygon) {
+        size += (x0 * y - x * y0) / 2; // area
+      } else {
+        size += Math.sqrt(Math.pow(x - x0, 2) + Math.pow(y - y0, 2)); // length
+      }
+    }
+    x0 = x;
+    y0 = y;
+  }
+
+  const last = out.length - 3;
+  out[2] = 1;
+  simplify(out, 0, last, tolerance);
+  out[last + 2] = 1;
+
+  out.size = Math.abs(size);
+  out.start = 0;
+  out.end = out.size;
+}
+
+function convertLines(rings: number[][], out, tolerance: number, isPolygon: boolean): void {
+  for (let i = 0; i < rings.length; i++) {
+    const geom = [];
+    convertLine(rings[i], geom, tolerance, isPolygon);
+    out.push(geom);
+  }
+}
+
+function projectX(x: number): number {
+  return x / 360 + 0.5;
+}
+
+function projectY(y: number): number {
+  const sin = Math.sin((y * Math.PI) / 180);
+  const y2 = 0.5 - (0.25 * Math.log((1 + sin) / (1 - sin))) / Math.PI;
+  return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
+}

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

@@ -0,0 +1,45 @@
+// loaders.gl, MIT license
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+import {GeoJSONTileFeature} from './tile';
+
+export function createFeature(id, type, geom, tags): GeoJSONTileFeature {
+  const feature: GeoJSONTileFeature = {
+    // eslint-disable-next-line
+    id: id == null ? null : id,
+    type,
+    geometry: geom,
+    tags,
+    minX: Infinity,
+    minY: Infinity,
+    maxX: -Infinity,
+    maxY: -Infinity
+  };
+
+  if (type === 'Point' || type === 'MultiPoint' || type === 'LineString') {
+    calcLineBBox(feature, geom);
+  } else if (type === 'Polygon') {
+    // the outer ring (ie [0]) contains all inner rings
+    calcLineBBox(feature, geom[0]);
+  } else if (type === 'MultiLineString') {
+    for (const line of geom) {
+      calcLineBBox(feature, line);
+    }
+  } else if (type === 'MultiPolygon') {
+    for (const polygon of geom) {
+      // the outer ring (ie [0]) contains all inner rings
+      calcLineBBox(feature, polygon[0]);
+    }
+  }
+
+  return feature;
+}
+
+function calcLineBBox(feature, geom) {
+  for (let i = 0; i < geom.length; i += 3) {
+    feature.minX = Math.min(feature.minX, geom[i]);
+    feature.minY = Math.min(feature.minY, geom[i + 1]);
+    feature.maxX = Math.max(feature.maxX, geom[i]);
+    feature.maxY = Math.max(feature.maxY, geom[i + 1]);
+  }
+}