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

package/src/index.ts

@@ -2,16 +2,23 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-export type {MVTLoaderOptions} from './mvt-loader';
-export {MVTLoader, MVTWorkerLoader} from './mvt-loader';
+// TileJSONLoader
 
-export type {TileJSON} from './lib/parse-tilejson';
-export type {TileJSONLoaderOptions} from './tilejson-loader';
 export {TileJSONLoader} from './tilejson-loader';
+export type {TileJSONLoaderOptions} from './tilejson-loader';
+export type {TileJSON} from './lib/parse-tilejson';
+
+// MVTLoader
+
+export {MVTLoader, MVTWorkerLoader} from './mvt-loader';
+export type {MVTLoaderOptions} from './mvt-loader';
+
+// MVTSource
 
 export {MVTSource} from './mvt-source';
+export type {MVTTileSource, MVTTileSourceProps} from './mvt-source';
 
-// TableTileSource
+// TableTileSource (dynamically tiles a table)
 
-export type {TableTileSourceProps} from './table-tile-source';
 export {TableTileSource} from './table-tile-source';
+export type {DynamicVectorTileSource, DynamicVectorTileSourceProps} from './table-tile-source';

package/src/lib/get-schemas-from-tilejson.ts

@@ -0,0 +1,64 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Schema, Field, DataType, SchemaMetadata, FieldMetadata} from '@loaders.gl/schema';
+import type {TileJSONLayer, TileJSONField} from './parse-tilejson';
+
+// LAYERS
+
+export function getSchemaFromTileJSONLayer(layer: TileJSONLayer): Schema {
+  const fields: Field[] = [];
+  if (layer.fields) {
+    for (const field of layer.fields) {
+      fields.push({
+        name: field.name,
+        type: getDataTypeFromTileJSONField(field),
+        metadata: getMetadataFromTileJSONField(field)
+      });
+    }
+  }
+  return {
+    metadata: getMetadataFromTileJSONLayer(layer),
+    fields
+  };
+}
+
+function getMetadataFromTileJSONLayer(layer: TileJSONLayer): SchemaMetadata {
+  const metadata: Record<string, string> = {};
+  for (const [key, value] of Object.entries(layer)) {
+    if (key !== 'fields' && value) {
+      metadata[key] = JSON.stringify(value);
+    }
+  }
+  return metadata;
+}
+
+// FIELDS
+
+function getDataTypeFromTileJSONField(field: TileJSONField): DataType {
+  switch (field.type.toLowerCase()) {
+    case 'float32':
+      return 'float32';
+    case 'number':
+    case 'float64':
+      return 'float64';
+    case 'string':
+    case 'utf8':
+      return 'utf8';
+    case 'boolean':
+      return 'bool';
+    default:
+      return 'null';
+  }
+}
+
+function getMetadataFromTileJSONField(field: TileJSONField): FieldMetadata {
+  const metadata: Record<string, string> = {};
+  for (const [key, value] of Object.entries(field)) {
+    if (key !== 'name' && value) {
+      metadata[key] = JSON.stringify(value);
+    }
+  }
+  return metadata;
+}

package/src/lib/parse-tilejson.ts

@@ -2,6 +2,9 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import {Schema} from '@loaders.gl/schema';
+import {getSchemaFromTileJSONLayer} from './get-schemas-from-tilejson';
+
 export type TileJSONOptions = {
   /** max number of values. If not provided, include all values in the source tilestats */
   maxValues?: number;
@@ -9,13 +12,21 @@ export type TileJSONOptions = {
 
 /** Parsed and typed TileJSON, merges Tilestats information if present */
 export type TileJSON = {
+  /** Name of the tileset (for presentation in UI) */
   name?: string;
+  /** A description of the contents or purpose of the tileset */
   description?: string;
+  /** The version of the tileset */
   version?: string;
 
   tileFormat?: string;
   tilesetType?: string;
 
+  /** Generating application. Tippecanoe adds this. */
+  generator?: string;
+  /** Generating application options. Tippecanoe adds this. */
+  generatorOptions?: string;
+
   /** Tile indexing scheme */
   scheme?: 'xyz' | 'tms';
   /** Sharded URLs */
@@ -33,11 +44,6 @@ export type TileJSON = {
   // Combination of tilestats (if present) and tilejson layer information
   layers?: TileJSONLayer[];
 
-  /** Generating application. Tippecanoe adds this. */
-  generator?: string;
-  /** Generating application options. Tippecanoe adds this. */
-  generatorOptions?: string;
-
   /** Any nested JSON metadata */
   metaJson?: any | null;
 };
@@ -61,6 +67,8 @@ export type TileJSONLayer = {
   minZoom?: number;
   maxZoom?: number;
   fields: TileJSONField[];
+
+  schema?: Schema;
 };
 
 export type TileJSONField = {
@@ -262,17 +270,16 @@ function parseTilestatsForLayer(layer: TilestatsLayer, options: TileJSONOptions)
 }
 
 function mergeLayers(layers: TileJSONLayer[], tilestatsLayers: TileJSONLayer[]): TileJSONLayer[] {
-  return layers.map((layer) => {
+  return layers.map((layer: TileJSONLayer): TileJSONLayer => {
     const tilestatsLayer = tilestatsLayers.find((tsLayer) => tsLayer.name === layer.name);
-    // For aesthetics in JSON dumps, we preserve field order (make sure layers is last)
-    const fields = tilestatsLayer?.fields || [];
-    const layer2: Partial<TileJSONLayer> = {...layer};
-    delete layer2.fields;
-    return {
-      ...layer2,
+    const fields = tilestatsLayer?.fields || layer.fields || [];
+    const mergedLayer = {
+      ...layer,
       ...tilestatsLayer,
       fields
     } as TileJSONLayer;
+    mergedLayer.schema = getSchemaFromTileJSONLayer(mergedLayer);
+    return mergedLayer;
   });
 }
 

package/src/lib/types.ts

@@ -1,8 +1,46 @@
 // loaders.gl
 // SPDX-License-Identifier: MIT
-// Copyright vis.gl contributors
+// Copyright (c) vis.gl contributors
+
+/** For local coordinates, the tileIndex is not required */
+type MVTLocalCoordinatesOptions = {
+  /**
+   * When set to `local`, the parser will return a flat array of GeoJSON objects with local coordinates decoded from tile origin.
+   */
+  coordinates: 'local';
+  tileIndex: null;
+};
+
+/** In WGS84 coordinates, the tileIndex is required */
+type MVTWgs84CoordinatesOptions = {
+  /**
+   * When set to `wgs84`, the parser will return a flat array of GeoJSON objects with coordinates in longitude, latitude decoded from the provided tile index.
+   */
+  coordinates?: 'wgs84';
+
+  /**
+   * Mandatory with `wgs84` coordinates option. An object containing tile index values (`x`, `y`,
+   * `z`) to reproject features' coordinates into WGS84.
+   */
+  tileIndex?: {x: number; y: number; z: number};
+};
+
+export type MVTOptions = (MVTLocalCoordinatesOptions | MVTWgs84CoordinatesOptions) & {
+  shape?: 'geojson-table' | 'columnar-table' | 'geojson' | 'binary' | 'binary-geometry';
+  /**
+   * When non-`null`, the layer name of each feature is added to
+   * `feature.properties[layerProperty]`. (A `feature.properties` object is created if the feature
+   * has no existing properties). If set to `null`, a layer name property will not be added.
+   */
+  layerProperty?: string | number;
+
+  /**
+   * Optional list of layer names. If not `null`, only features belonging to the named layers will
+   * be included in the output. If `null`, features from all layers are returned.
+   */
+  layers?: string[];
+};
 
-/** TODO where is this used? */
 export type MVTMapboxGeometry = {
   type?: string;
   id?: number;

package/src/lib/utils/geometry-utils.ts

@@ -52,7 +52,7 @@ export function convertToLocalCoordinates(
  * @param feature
  */
 export function convertToLocalCoordinatesFlat(data: number[], extent: number): void {
-  for (let i = 0, il = data.length; i < il; ++i) {
+  for (let i = 0; i < data.length; ++i) {
     data[i] /= extent;
   }
 }

package/src/lib/vector-tiler/{clip.ts → features/clip-features.ts}

@@ -3,8 +3,8 @@
 // Copyright (c) vis.gl contributors
 // Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
 
-import type {TableTileFeature} from './tile';
-import {createFeature} from './feature';
+import type {ProtoFeature} from './proto-feature';
+import {createProtoFeature} from './proto-feature';
 
 /* eslint-disable no-continue */
 
@@ -20,8 +20,8 @@ import {createFeature} from './feature';
  * @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: TableTileFeature[],
+export function clipFeatures(
+  features: ProtoFeature[],
   scale: number,
   k1: number,
   k2: number,
@@ -29,7 +29,7 @@ export function clip(
   minAll: number,
   maxAll: number,
   options: {lineMetrics: boolean}
-): TableTileFeature[] | null {
+): ProtoFeature[] | null {
   k1 /= scale;
   k2 /= scale;
 
@@ -41,7 +41,7 @@ export function clip(
     return null; // trivial reject
   }
 
-  const clipped: TableTileFeature[] = [];
+  const clipped: ProtoFeature[] = [];
 
   for (const feature of features) {
     const geometry = feature.geometry;
@@ -82,7 +82,7 @@ export function clip(
     if (newGeometry.length) {
       if (options.lineMetrics && type === 'LineString') {
         for (const line of newGeometry) {
-          clipped.push(createFeature(feature.id, type, line, feature.tags));
+          clipped.push(createProtoFeature(feature.id, type, line, feature.tags));
         }
         continue;
       }
@@ -100,7 +100,7 @@ export function clip(
         type = newGeometry.length === 3 ? 'Point' : 'MultiPoint';
       }
 
-      clipped.push(createFeature(feature.id, type, newGeometry, feature.tags));
+      clipped.push(createProtoFeature(feature.id, type, newGeometry, feature.tags));
     }
   }
 

package/src/lib/vector-tiler/{convert.ts → features/convert-feature.ts}

@@ -7,30 +7,10 @@
 // @ts-nocheck
 
 import type {Feature, FeatureCollection} from '@loaders.gl/schema';
-import type {TableTileFeature} from './tile';
+import type {ProtoFeature} from './proto-feature';
 
-import {simplify} from './simplify';
-import {createFeature} from './feature';
-
-/**
- * converts a GeoJSON feature into an intermediate projected JSON vector format
- * with simplification data
- */
-export function convert(data: Feature | FeatureCollection, options): TableTileFeature[] {
-  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;
-}
+import {createProtoFeature} from './proto-feature';
+import {simplifyPath} from './simplify-path';
 
 export type ConvertFeatureOptions = {
   /** max zoom to preserve detail on */
@@ -43,16 +23,43 @@ export type ConvertFeatureOptions = {
   lineMetrics?: boolean;
 };
 
+/**
+ * converts a GeoJSON feature into an intermediate projected JSON vector format
+ * with simplification data
+ */
+export function convertFeaturesToProtoFeature(
+  data: Feature | FeatureCollection,
+  options: ConvertFeatureOptions
+): ProtoFeature[] {
+  const protoFeatures = [];
+  switch (data.type) {
+    case 'FeatureCollection':
+      let i = 0;
+      for (const feature of data.features) {
+        protoFeatures.push(convertFeature(feature, options, i++));
+      }
+      break;
+    case 'Feature':
+      protoFeatures.push(convertFeature(data, options));
+      break;
+    default:
+      // single geometry or a geometry collection
+      protoFeatures.push(convertFeature({geometry: data}, options));
+  }
+
+  return protoFeatures;
+}
+
 /**
  * converts a GeoJSON feature into an intermediate projected JSON vector format
  * with simplification data
  */
 function convertFeature(
-  features: TableTileFeature[],
   geojson: Feature,
   options: ConvertFeatureOptions,
   index: number
-): void {
+): ProtoFeature {
+  // GeoJSON geometries can be null, but no vector tile will include them.
   if (!geojson.geometry) {
     return;
   }
@@ -67,53 +74,67 @@ function convertFeature(
   } 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));
+
+  switch (type) {
+    case 'Point':
+      convertPoint(coords, geometry);
+      break;
+
+    case 'MultiPoint':
+      for (const p of coords) {
+        convertPoint(p, geometry);
       }
-      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.');
+      break;
+
+    case 'LineString':
+      convertLine(coords, geometry, tolerance, false);
+      break;
+
+    case '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(createProtoFeature(id, 'LineString', geometry, geojson.properties));
+        }
+        return;
+        convertLines(coords, geometry, tolerance, false);
+      }
+      break;
+
+    case 'Polygon':
+      convertLines(coords, geometry, tolerance, true);
+      break;
+
+    case 'MultiPolygon':
+      for (const polygon of coords) {
+        const newPolygon = [];
+        convertLines(polygon, newPolygon, tolerance, true);
+        geometry.push(newPolygon);
+      }
+      break;
+
+    case 'GeometryCollection':
+      for (const singleGeometry of geojson.geometry.geometries) {
+        convertFeature(
+          features,
+          {
+            id,
+            geometry: singleGeometry,
+            properties: geojson.properties
+          },
+          options,
+          index
+        );
+      }
+      break;
+
+    default:
+      throw new Error('Input data is not a valid GeoJSON object.');
   }
 
-  features.push(createFeature(id, type, geometry, geojson.properties));
+  return createProtoFeature(id, type, geometry, geojson.properties);
 }
 
 function convertPoint(coords, out): void {
@@ -143,7 +164,7 @@ function convertLine(ring: number[], out, tolerance: number, isPolygon: boolean)
 
   const last = out.length - 3;
   out[2] = 1;
-  simplify(out, 0, last, tolerance);
+  simplifyPath(out, 0, last, tolerance);
   out[last + 2] = 1;
 
   out.size = Math.abs(size);

package/src/lib/vector-tiler/features/proto-feature.ts

@@ -0,0 +1,104 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+export type ProtoFeature = {
+  type: 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon';
+  simplifiedType: 1 | 2 | 3;
+  geometry: any[];
+
+  // book keeping
+  id?: string;
+  tags?: Record<string, unknown>;
+
+  /** spatial extents */
+  minX: number;
+  /** spatial extents */
+  maxX: number;
+  /** spatial extents */
+  minY: number;
+  /** spatial extents */
+  maxY: number;
+};
+
+export type GeoJSONTileGeometry =
+  | GeoJSONTilePointGeometry
+  | GeoJSONTileLineGeometry
+  | GeoJSONTilePolygonGeometry;
+
+export type GeoJSONTilePointGeometry = {
+  simplifiedType: 1;
+  geometry: number[];
+};
+
+export type GeoJSONTileLineGeometry = {
+  simplifiedType: 1;
+  geometry: number[][];
+};
+
+export type GeoJSONTilePolygonGeometry = {
+  simplifiedType: 1;
+  geometry: number[][][];
+};
+
+export function createProtoFeature(
+  id: any,
+  type: 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon',
+  geometry: any[],
+  tags
+): ProtoFeature {
+  const feature: ProtoFeature = {
+    // eslint-disable-next-line
+    id: id == null ? null : id,
+    type,
+    simplifiedType: undefined!, // TODO
+    geometry,
+    tags,
+    minX: Infinity,
+    minY: Infinity,
+    maxX: -Infinity,
+    maxY: -Infinity
+  };
+
+  // TODO break out into separate function
+  switch (type) {
+    case 'Point':
+    case 'MultiPoint':
+    case 'LineString':
+      calcLineBBox(feature, geometry);
+      break;
+
+    case 'MultiLineString':
+      for (const line of geometry) {
+        calcLineBBox(feature, line);
+      }
+      break;
+
+    case 'Polygon':
+      // the outer ring (ie [0]) contains all inner rings
+      calcLineBBox(feature, geometry[0]);
+      break;
+
+    case 'MultiPolygon':
+      for (const polygon of geometry) {
+        // the outer ring (ie [0]) contains all inner rings
+        calcLineBBox(feature, polygon[0]);
+      }
+      break;
+
+    default:
+      throw new Error(String(type));
+  }
+
+  return feature;
+}
+
+function calcLineBBox(feature, geometry) {
+  for (let i = 0; i < geometry.length; i += 3) {
+    feature.minX = Math.min(feature.minX, geometry[i]);
+    feature.minY = Math.min(feature.minY, geometry[i + 1]);
+    feature.maxX = Math.max(feature.maxX, geometry[i]);
+    feature.maxY = Math.max(feature.maxY, geometry[i + 1]);
+  }
+}

package/src/lib/vector-tiler/{simplify.ts → features/simplify-path.ts}

@@ -11,7 +11,12 @@
  * @param last last coord to simplify
  * @param sqTolerance tolerance (square distance)
  */
-export function simplify(coords: number[], first: number, last: number, sqTolerance: number): void {
+export function simplifyPath(
+  coords: number[],
+  first: number,
+  last: number,
+  sqTolerance: number
+): void {
   let maxSqDist = sqTolerance;
   const mid = (last - first) >> 1;
   let minPosToMid = last - first;
@@ -41,9 +46,9 @@ export function simplify(coords: number[], first: number, last: number, sqTolera
   }
 
   if (maxSqDist > sqTolerance) {
-    if (index - first > 3) simplify(coords, first, index, sqTolerance);
+    if (index - first > 3) simplifyPath(coords, first, index, sqTolerance);
     coords[index + 2] = maxSqDist;
-    if (last - index > 3) simplify(coords, index, last, sqTolerance);
+    if (last - index > 3) simplifyPath(coords, index, last, sqTolerance);
   }
 }