@loaders.gl/tiles 5.0.0-alpha.12 → 5.0.0-alpha.13

package/src/mvt/lib/vector-tiler/proto-tile.ts

@@ -0,0 +1,217 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+import type {ProtoFeature} from './features/proto-feature';
+
+export type ProtoTile = {
+  /** Processed features */
+  protoFeatures: ProtoFeature[];
+  /** if we slice further down, no need to keep source geometry */
+  sourceFeatures: ProtoFeature[] | null;
+
+  /** Properties */
+  tags?: Record<string, string>;
+
+  /** tile x coordinate */
+  x: number;
+  /** tile y coordinate */
+  y: number;
+  /** tile z coordinate */
+  z: number;
+
+  /** spatial extent */
+  minX: number;
+  /** spatial extent */
+  maxX: number;
+  /** spatial extent */
+  minY: number;
+  /** spatial extent */
+  maxY: number;
+
+  /** Whether this tile has been transformed */
+  transformed: boolean;
+  numPoints: number;
+  numSimplified: number;
+  /** Number of features in this tile */
+  numFeatures: number;
+};
+
+export type CreateTileOptions = {
+  maxZoom?: number;
+  tolerance: number;
+  extent: number;
+  lineMetrics: boolean;
+};
+
+/**
+ * Create a tile from features and tile index
+ */
+export function createProtoTile(
+  features: ProtoFeature[],
+  z,
+  tx,
+  ty,
+  options: CreateTileOptions
+): ProtoTile {
+  const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
+  const tile: ProtoTile = {
+    protoFeatures: [],
+    sourceFeatures: null,
+    numPoints: 0,
+    numSimplified: 0,
+    numFeatures: features.length,
+    x: tx,
+    y: ty,
+    z,
+    transformed: false,
+    minX: 2,
+    minY: 1,
+    maxX: -1,
+    maxY: 0
+  };
+  for (const feature of features) {
+    addProtoFeature(tile, feature, tolerance, options);
+  }
+  return tile;
+}
+
+// eslint-disable-next-line complexity, max-statements
+function addProtoFeature(
+  tile: ProtoTile,
+  feature: ProtoFeature,
+  tolerance: number,
+  options: CreateTileOptions
+) {
+  const geometry = feature.geometry;
+  const type = feature.type;
+  const simplifiedGeometry: number[] = [];
+
+  tile.minX = Math.min(tile.minX, feature.minX);
+  tile.minY = Math.min(tile.minY, feature.minY);
+  tile.maxX = Math.max(tile.maxX, feature.maxX);
+  tile.maxY = Math.max(tile.maxY, feature.maxY);
+
+  let simplifiedType: 1 | 2 | 3;
+  switch (type) {
+    case 'Point':
+    case 'MultiPoint':
+      simplifiedType = 1;
+      for (let i = 0; i < geometry.length; i += 3) {
+        simplifiedGeometry.push(geometry[i], geometry[i + 1]);
+        tile.numPoints++;
+        tile.numSimplified++;
+      }
+      break;
+
+    case 'LineString':
+      simplifiedType = 2;
+      addProtoLine(simplifiedGeometry, geometry, tile, tolerance, false, false);
+      break;
+
+    case 'MultiLineString':
+      simplifiedType = 2;
+      for (let i = 0; i < geometry.length; i++) {
+        addProtoLine(simplifiedGeometry, geometry[i], tile, tolerance, false, i === 0);
+      }
+      break;
+
+    case 'Polygon':
+      simplifiedType = 3;
+      for (let i = 0; i < geometry.length; i++) {
+        addProtoLine(simplifiedGeometry, geometry[i], tile, tolerance, true, i === 0);
+      }
+      break;
+
+    case 'MultiPolygon':
+      simplifiedType = 3;
+      for (let k = 0; k < geometry.length; k++) {
+        const polygon = geometry[k];
+        for (let i = 0; i < polygon.length; i++) {
+          addProtoLine(simplifiedGeometry, polygon[i], tile, tolerance, true, i === 0);
+        }
+      }
+      break;
+
+    default:
+      throw new Error(`Unknown geometry type: ${type}`);
+  }
+
+  if (simplifiedGeometry.length) {
+    let tags: Record<string, unknown> | null = feature.tags || null;
+
+    if (type === 'LineString' && options.lineMetrics) {
+      tags = {};
+      for (const key in feature.tags) {
+        tags[key] = feature.tags[key];
+      }
+      // @ts-expect-error adding fields to arrays
+      // eslint-disable-next-line camelcase
+      tags.mapbox_clip_start = geometry.start / geometry.size;
+      // @ts-expect-error adding fields to arrays
+      // eslint-disable-next-line camelcase
+      tags.mapbox_clip_end = geometry.end / geometry.size;
+    }
+
+    const tileFeature: ProtoFeature = {
+      geometry: simplifiedGeometry,
+      simplifiedType,
+      // @ts-expect-error
+      tags
+    };
+    if (feature.id !== null) {
+      tileFeature.id = feature.id;
+    }
+
+    tile.protoFeatures.push(tileFeature);
+  }
+}
+
+// eslint-disable-next-line max-params, max-statements
+function addProtoLine(
+  result: any[],
+  geometry: any,
+  tile: ProtoTile,
+  tolerance: number,
+  isPolygon: boolean,
+  isOuter: boolean
+): void {
+  const sqTolerance = tolerance * tolerance;
+
+  if (tolerance > 0 && geometry.size < (isPolygon ? sqTolerance : tolerance)) {
+    tile.numPoints += geometry.length / 3;
+    return;
+  }
+
+  const ring: number[] = [];
+
+  for (let i = 0; i < geometry.length; i += 3) {
+    if (tolerance === 0 || geometry[i + 2] > sqTolerance) {
+      tile.numSimplified++;
+      ring.push(geometry[i], geometry[i + 1]);
+    }
+    tile.numPoints++;
+  }
+
+  if (isPolygon) rewind(ring, isOuter);
+
+  result.push(ring);
+}
+
+function rewind(ring: number[], clockwise?: boolean): void {
+  let area = 0;
+  for (let i = 0, j = ring.length - 2; i < ring.length; j = i, i += 2) {
+    area += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
+  }
+  if (area > 0 === clockwise) {
+    for (let i = 0, len = ring.length; i < len / 2; i += 2) {
+      const x = ring[i];
+      const y = ring[i + 1];
+      ring[i] = ring[len - 2 - i];
+      ring[i + 1] = ring[len - 1 - i];
+      ring[len - 2 - i] = x;
+      ring[len - 1 - i] = y;
+    }
+  }
+}

package/src/mvt/lib/vector-tiler/tile-to-geojson.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
+
+import {ProtoTile} from './proto-tile';
+import {Feature, GeoJSONTable} from '@loaders.gl/core/schema';
+
+import {projectToLngLat, convertToLocalCoordinates} from '../utils/geometry-utils';
+
+// eslint-disable-next-line max-statements, complexity
+export function convertTileToGeoJSON(
+  protoTile: ProtoTile,
+  props: {
+    coordinates: 'EPSG:4326' | 'wgs84' | 'local';
+    tileIndex: {x: number; y: number; z: number};
+    extent: number;
+  }
+): GeoJSONTable | null {
+  const features: Feature[] = [];
+  for (const rawFeature of protoTile.protoFeatures) {
+    if (!rawFeature || !rawFeature.geometry) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    let type:
+      | 'Point'
+      | 'MultiPoint'
+      | 'LineString'
+      | 'MultiLineString'
+      | 'Polygon'
+      | 'MultiPolygon';
+
+    let coordinates: any;
+
+    // raw geometry
+    switch (rawFeature.simplifiedType) {
+      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:
+        throw new Error(`${rawFeature.simplifiedType}is not a valid simplified type`);
+    }
+
+    switch (props.coordinates) {
+      case 'EPSG:4326':
+      case 'wgs84':
+        projectToLngLat(coordinates, props.tileIndex, props.extent);
+        break;
+      default:
+        convertToLocalCoordinates(coordinates, props.extent);
+        break;
+    }
+
+    const feature: Feature = {
+      type: 'Feature',
+      geometry: {
+        type,
+        coordinates
+      },
+      properties: rawFeature.tags || {},
+      id: rawFeature.id
+    };
+
+    features.push(feature);
+  }
+
+  if (features.length === 0) {
+    return null;
+  }
+
+  const table: GeoJSONTable = {
+    shape: 'geojson-table',
+    type: 'FeatureCollection',
+    features
+  };
+
+  return table;
+}

package/src/mvt/lib/vector-tiler/transform-tile.ts

@@ -0,0 +1,57 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+import type {ProtoTile} from './proto-tile';
+
+/**
+ * Transforms the coordinates of each protoFeature in the given protoTile from
+ * mercator-projected space into (extent x extent) protoTile space.
+ */
+export function transformTile(protoTile: ProtoTile, extent: number): ProtoTile {
+  if (protoTile.transformed) {
+    return protoTile;
+  }
+
+  const z2 = 1 << protoTile.z;
+  const tx = protoTile.x;
+  const ty = protoTile.y;
+
+  for (const protoFeature of protoTile.protoFeatures) {
+    const geom = protoFeature.geometry;
+    const simplifiedType = protoFeature.simplifiedType;
+
+    protoFeature.geometry = [];
+
+    if (simplifiedType === 1) {
+      for (let j = 0; j < geom.length; j += 2) {
+        protoFeature.geometry.push(transformPoint(geom[j], geom[j + 1], extent, z2, tx, ty));
+      }
+    } else {
+      for (let j = 0; j < geom.length; j++) {
+        const ring: number[][] = [];
+        for (let k = 0; k < geom[j].length; k += 2) {
+          ring.push(transformPoint(geom[j][k], geom[j][k + 1], extent, z2, tx, ty));
+        }
+        protoFeature.geometry.push(ring);
+      }
+    }
+  }
+
+  protoTile.transformed = true;
+
+  return protoTile;
+}
+
+// eslint-disable-next-line max-params
+function transformPoint(
+  x: number,
+  y: number,
+  extent: number,
+  z2: number,
+  tx: number,
+  ty: number
+): number[] {
+  return [Math.round(extent * (x * z2 - tx)), Math.round(extent * (y * z2 - ty))];
+}

package/src/mvt/map-style-format.ts

@@ -0,0 +1,18 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Format} from '@loaders.gl/core/loader-utils';
+
+/** Map style JSON format. */
+export const MapStyleFormat = {
+  name: 'Map Style',
+  id: 'map-style',
+  module: 'tiles',
+  encoding: 'json',
+  format: 'map-style',
+  extensions: ['json'],
+  mimeTypes: ['application/json'],
+  category: 'metadata',
+  text: true
+} as const satisfies Format;

package/src/mvt/map-style-loader-with-parser.ts

@@ -0,0 +1,62 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderContext, LoaderWithParser} from '@loaders.gl/core/loader-utils';
+import {ResolvedMapStyleSchema} from './map-style-schema';
+import {
+  getMapStyleLoadOptions,
+  resolveMapStyle,
+  type MapStyle,
+  type MapStyleLoadOptions,
+  type ResolvedMapStyle
+} from './map-style';
+import {MapStyleLoader as MapStyleLoaderMetadata} from './map-style-loader';
+
+const {preload: _MapStyleLoaderPreload, ...MapStyleLoaderMetadataWithoutPreload} =
+  MapStyleLoaderMetadata;
+
+/**
+ * Loader for MapLibre / Mapbox style JSON metadata.
+ */
+export const MapStyleLoaderWithParser = {
+  ...MapStyleLoaderMetadataWithoutPreload,
+  parseText: async (text: string, options?: MapStyleLoadOptions, context?: LoaderContext) => {
+    return await parseMapStyleText(text, options, context);
+  },
+  parse: async (
+    data: ArrayBuffer | ArrayBufferView | string,
+    options?: MapStyleLoadOptions,
+    context?: LoaderContext
+  ) => {
+    return await parseMapStyleData(data, options, context);
+  }
+} as const satisfies LoaderWithParser<ResolvedMapStyle, never, MapStyleLoadOptions>;
+
+/**
+ * Parses raw map-style loader input that may arrive as text or bytes.
+ */
+async function parseMapStyleData(
+  data: ArrayBuffer | ArrayBufferView | string,
+  options?: MapStyleLoadOptions,
+  context?: LoaderContext
+): Promise<ResolvedMapStyle> {
+  const text = typeof data === 'string' ? data : new TextDecoder().decode(data);
+  return await parseMapStyleText(text, options, context);
+}
+
+/**
+ * Parses and resolves a MapLibre / Mapbox style JSON document from text.
+ */
+async function parseMapStyleText(
+  text: string,
+  options?: MapStyleLoadOptions,
+  context?: LoaderContext
+): Promise<ResolvedMapStyle> {
+  const style = JSON.parse(text) as MapStyle;
+  const resolvedStyle = await resolveMapStyle(style, {
+    ...options,
+    mapStyle: getMapStyleLoadOptions(options, context)
+  });
+  return ResolvedMapStyleSchema.parse(resolvedStyle);
+}

package/src/mvt/map-style-loader.ts

@@ -0,0 +1,31 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Loader} from '@loaders.gl/core/loader-utils';
+import {type MapStyleLoadOptions, type ResolvedMapStyle} from './map-style';
+import {MapStyleFormat} from './map-style-format';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+/** Preloads the parser-bearing map style loader implementation. */
+async function preload() {
+  const {MapStyleLoaderWithParser} = await import('./map-style-loader-with-parser');
+  return MapStyleLoaderWithParser;
+}
+
+/** Metadata-only loader for MapLibre / Mapbox style JSON metadata. */
+export const MapStyleLoader = {
+  dataType: null as unknown as ResolvedMapStyle,
+  batchType: null as never,
+
+  ...MapStyleFormat,
+  version: VERSION,
+  worker: false,
+  options: {
+    mapStyle: {}
+  },
+  preload
+} as const satisfies Loader<ResolvedMapStyle, never, MapStyleLoadOptions>;

package/src/mvt/map-style-schema.ts

@@ -0,0 +1,53 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {z} from 'zod';
+import type {MapStyle, MapStyleLayer, MapStyleSource, ResolvedMapStyle} from './map-style';
+
+const MapStyleSourceSchemaInternal = z
+  .object({
+    type: z.string().optional(),
+    url: z.string().optional(),
+    tiles: z.array(z.string()).optional(),
+    minzoom: z.number().optional(),
+    maxzoom: z.number().optional(),
+    tileSize: z.number().optional()
+  })
+  .catchall(z.unknown()) satisfies z.ZodType<MapStyleSource>;
+
+const MapStyleLayerSchemaInternal = z
+  .object({
+    id: z.string(),
+    type: z.string(),
+    source: z.string().optional(),
+    'source-layer': z.string().optional(),
+    minzoom: z.number().optional(),
+    maxzoom: z.number().optional(),
+    filter: z.array(z.unknown()).optional(),
+    paint: z.record(z.string(), z.unknown()).optional(),
+    layout: z.record(z.string(), z.unknown()).optional()
+  })
+  .catchall(z.unknown()) satisfies z.ZodType<MapStyleLayer>;
+
+/** Zod schema for a MapLibre / Mapbox style document. */
+export const MapStyleSchema = z
+  .object({
+    version: z.number().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    sources: z.record(z.string(), MapStyleSourceSchemaInternal).optional(),
+    layers: z.array(MapStyleLayerSchemaInternal).optional()
+  })
+  .catchall(z.unknown()) satisfies z.ZodType<MapStyle>;
+
+/** Zod schema for a fully resolved style document. */
+export const ResolvedMapStyleSchema = z
+  .object({
+    version: z.number().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    sources: z.record(z.string(), MapStyleSourceSchemaInternal),
+    layers: z.array(MapStyleLayerSchemaInternal)
+  })
+  .catchall(z.unknown()) satisfies z.ZodType<ResolvedMapStyle>;
+
+export const MapStyleSourceSchema = MapStyleSourceSchemaInternal;