leaflet-city-mapper 0.0.6 → 0.0.8

package/src/gpu/initializeRendererResources.js

@@ -1,9 +1,10 @@
-import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+
 import { sceneSunlightUniforms } from '../globals/sceneSunlightUniforms.js';
 import { resizeSunlight } from '../shadows/resizeSunlight.js';
 
 export function initializeRendererResources(layer, device) {
+  const renderer = rendererByLayer.get(layer);
   const layout = device.createBindGroupLayout(/* alloc */ {
     entries: /* alloc */ [
       /* alloc */ { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: /* alloc */ { type: 'uniform' } },
@@ -12,16 +13,13 @@ export function initializeRendererResources(layer, device) {
       /* alloc */ { binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: /* alloc */ { type: 'read-only-storage' } },
     ]
   });
-  const buffer = rendererByLayer.get(layer).device.createBuffer(/* alloc */ { size: 80, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-  const sampler = rendererByLayer.get(layer).device.createSampler(/* alloc */ { compare: 'less-equal', minFilter: 'linear', magFilter: 'linear' });
-  const lights = rendererByLayer.get(layer).device.createBuffer(/* alloc */ { size: 32, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
-  rendererByLayer.get(layer).sunlight = /* alloc */ { layout, buffer, sampler, lights, size: 0 };
-  rendererByLayer.get(layer).device.queue.writeBuffer(buffer, 0, sceneSunlightUniforms);
+  const buffer = device.createBuffer(/* alloc */ { size: 80, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+  const sampler = device.createSampler(/* alloc */ { compare: 'less-equal', minFilter: 'linear', magFilter: 'linear' });
+  const lights = device.createBuffer(/* alloc */ { size: 32, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+  renderer.sunlight = /* alloc */ { layout, buffer, sampler, lights, size: 0 };
+  device.queue.writeBuffer(buffer, 0, sceneSunlightUniforms);
   resizeSunlight(layer, 1);
-  const emptyImage = document.createElement('canvas');
-  emptyImage.width = 1;
-  emptyImage.height = 1;
-  rendererByLayer.get(layer).roofFallbackTexture = /* alloc */ {
+  renderer.roofFallbackTexture = /* alloc */ {
     device,
     texture: device.createTexture(/* alloc */ {
       size: /* alloc */ [1, 1],
@@ -31,6 +29,6 @@ export function initializeRendererResources(layer, device) {
     sampler: device.createSampler(/* alloc */ {
       addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge',
     }),
-    image: emptyImage, format: 'rgba8unorm', srgb: false, uploaded: null,
+    image: null, format: 'rgba8unorm', srgb: false, uploaded: null,
   };
 }

package/src/gpu/mountRenderer.js

@@ -1,5 +1,5 @@
-import { sizeByLayer } from '../weakmaps/sizeByLayer.js';
-
+import { sizeByLayer } from '../weakmaps/sizeByLayer.js';
+
 import { onMapChange } from '../scene/onMapChange.js';
 import { startZoom } from '../animations/startZoom.js';
 import { onZoomAnim } from '../animations/onZoomAnim.js';
@@ -8,17 +8,10 @@ import { endZoom } from '../animations/endZoom.js';
 export function mountRenderer(layer, map, canvas) {
   sizeByLayer.set(layer, null);
   canvas.className = 'leaflet-3d';
-  canvas.style.cssText = 'position:absolute;top:0;left:0;pointer-events:none';
+  canvas.style.cssText = 'position:absolute;top:0;left:0;z-index:1;pointer-events:none';
   canvas.setAttribute('role', 'img');
   canvas.setAttribute('aria-label', layer.options.ariaLabel ?? '3D scene');
-  let pane = map.getPane('webgpuPane');
-  if (!pane) {
-    pane = map.createPane('webgpuPane', map.getContainer());
-    // The pitch sky uses 0 and may be inserted after this pane.
-    pane.style.zIndex = 1;
-    pane.style.pointerEvents = 'none';
-  }
-  pane.append(canvas);
+  map.getPane('mapPane').before(canvas);
   map.on('move zoom rotate pitch resize viewreset layeradd layerremove', onMapChange, layer);
   map.on('zoomstart', startZoom, layer);
   map.on('zoomanim', onZoomAnim, layer);

package/src/gpu/releaseRenderer.js

@@ -2,6 +2,7 @@ export async function releaseRenderer(renderer, layer) {
   try {
     await renderer.device.queue.onSubmittedWorkDone();
     renderer.depthTexture?.destroy();
+    renderer.colorTexture?.destroy();
     renderer.roofFallbackTexture?.texture?.destroy();
     renderer.uniformBuffer?.destroy();
     renderer.sunlight?.texture?.destroy();

package/src/index.js

@@ -1,26 +1,24 @@
 import { L } from './globals/L.js';
 import { layerProto } from './globals/layerProto.js';
-import { layerCallInitHooks as sharedLayerCallInitHooks } from './globals/layerCallInitHooks.js';
 import { removeLayer as sharedRemoveLayer } from './globals/removeLayer.js';
 
 import './camera/mapCamera.js';
-import { init3D } from './scene/init3D.js';
-import { initNativeGPU } from './native/initNativeGPU.js';
-import { initRaster } from './raster/initRaster.js';
-import { setGeoJSONData } from './sources/setGeoJSONData.js';
-import { initTerrain } from './terrain/initTerrain.js';
 import './sunlight/initSunlight.js';
-import { initTraffic } from './traffic/initTraffic.js';
 import './walk/initWalk.js';
 
-import { initializeNativeLayer } from './core/initializeNativeLayer.js';
 import { layerLayerAdd } from './scene/addRegisteredLayer.js';
 import { layerInitialize } from './scene/layerInitialize.js';
 import { removeLayer } from './core/removeLayer.js';
 import { getPitch } from './camera/getPitch.js';
 import { getBearing } from './camera/getBearing.js';
+import { setPitch } from './camera/setPitch.js';
+import { setBearing } from './camera/setBearing.js';
 import { setRotation } from './core/setRotation.js';
 import { layerCallInitHooks } from './core/layerCallInitHooks.js';
+import { leafletLayer } from './globals/leafletLayer.js';
+import { constructLayer } from './core/constructLayer.js';
+import { layerAddInitHook } from './core/layerAddInitHook.js';
+import { layerMergeOptions } from './core/layerMergeOptions.js';
 
 /**
  * `new L.Layer({ source: { type, url, ...settings }, pane, attribution })`: layers with a `source`
@@ -39,19 +37,36 @@ import { layerCallInitHooks } from './core/layerCallInitHooks.js';
  * Operations receive the layer explicitly, without subclasses or prototype replacement.
  * Dataset-specific code and data (routes, timetables, API loaders) belong to the application, e.g. misc/.
  *
- * When `type` is omitted, inline FeatureCollections use 'geojson'; *.pmtiles URLs use
- * 'pmtiles', *.tif/*.tiff URLs use 'cog', and other sources use '3d'.
+ * When `type` is omitted, *.pmtiles and *.tif/*.tiff URLs use 'raster'; other sources use 'vector'.
  */
 
-layerProto.value = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Layer.prototype));
-sharedLayerCallInitHooks.value = L.Layer.prototype.callInitHooks;
+layerProto.value = Object.defineProperties({}, Object.getOwnPropertyDescriptors(leafletLayer.prototype));
+layerProto.value._layerAdd = leafletLayer.prototype._layerAdd;
+layerProto.value.callInitHooks = leafletLayer.prototype.callInitHooks;
+
+if (L.version.startsWith('2.')) {
+  // Keep the native prototype and instanceof contract, but finish options before init hooks.
+  Object.setPrototypeOf(constructLayer, leafletLayer);
+  constructLayer.prototype = leafletLayer.prototype;
+  constructLayer.initHooks = true;
+  constructLayer.addInitHook = layerAddInitHook;
+  constructLayer.mergeOptions = layerMergeOptions;
+  L.Layer = constructLayer;
+  leafletLayer.prototype.constructor = L.Layer;
+  leafletLayer.addInitHook(layerCallInitHooks);
+} else {
+  leafletLayer.prototype.initialize = layerInitialize;
+  leafletLayer.prototype.callInitHooks = layerCallInitHooks;
+}
+
+Object.assign(leafletLayer.prototype, { _layerAdd: layerLayerAdd });
 
 /**
- * The '3d' layer type: native WebGPU scene synchronized with the map camera.
+ * The 'vector' layer type: native WebGPU scene synchronized with the map camera.
  * Layers on one map share a canvas, scene and camera; each has its own root transform.
  *
  * @typedef {Object} Layer3DOptions Layer options; pane and attribution remain standard L.Layer options.
- * @property {string} [type] '3d', 'geojson', 'pmtiles', 'cog', 'terrain' or 'traffic'.
+ * @property {'vector'|'raster'|'terrain'|'traffic'} [type]
  * @property {number[]} [center] Local origin [lat,lng]; defaults to the first map center.
  * @property {number} [terrainOffset=0] Vertical offset in metres when terrain is enabled.
  * @property {boolean} [terrainConform=false] Fit lower model geometry to local terrain elevation.
@@ -101,12 +116,6 @@ sharedLayerCallInitHooks.value = L.Layer.prototype.callInitHooks;
  * @param {Layer3DOptions} [options] World origin comes from center or the first map centre.
  */
 
-L.Layer.include({
-  initialize: layerInitialize,
-  _layerAdd: layerLayerAdd,
-  callInitHooks: layerCallInitHooks,
-});
-
 sharedRemoveLayer.value = L.Map.prototype.removeLayer;
-L.Map.include({ removeLayer, getPitch, getBearing });
-L.Marker.include({ setRotation });
+Object.assign(L.Map.prototype, { removeLayer, getPitch, getBearing, setPitch, setBearing });
+Object.assign(L.Marker.prototype, { setRotation });

package/src/layer-controls/layerControlInputId.js

@@ -0,0 +1,11 @@
+import { L } from '../globals/L.js';
+import { layerControlAddItem } from '../globals/layerControlAddItem.js';
+
+// Leaflet 2 stores layer associations on its control, not on the input.
+if (layerControlAddItem && !L.Control.Layers) L.LayersControl.prototype._addItem = addLayerControlInputId;
+
+export function addLayerControlInputId(entry) {
+  const label = layerControlAddItem.call(this, entry);
+  label.querySelector('.leaflet-control-layers-selector').layerId = L.Util.stamp(entry.layer);
+  return label;
+}

package/src/layer-controls/placeEntry.js

@@ -1,5 +1,7 @@
 import { L } from '../globals/L.js';
 import { placeEntryElement } from './placeEntryElement.js';
+import './layerControlInputId.js';
+
 export function placeEntry(map, layer, element) {
   let input, entry;
   for (input of map.getContainer().querySelectorAll('.leaflet-control-layers-selector')) {

package/src/materials/createProgram.js

@@ -19,17 +19,18 @@ import { materialShaders } from '../shaders/materialShaders.js';
 import { reportCompilation } from '../gpu/reportShaderCompilation.js';
 
 export function createProgram(layer, material = defaultMaterial) {
+  const renderer = rendererByLayer.get(layer), { device } = renderer;
   const shaders = materialShaders(
     material,
     !!layer.options.nightSparkle,
     material.terrain ? elevationWGSL : ''
   );
-  const vertex = rendererByLayer.get(layer).device.createShaderModule((
+  const vertex = device.createShaderModule((
     vertexShader.code = shaders.vertex,
     vertexShader
   ));
   vertexShader.code = null;
-  const fragment = rendererByLayer.get(layer).device.createShaderModule((
+  const fragment = device.createShaderModule((
     fragmentShader.code = shaders.fragment,
     fragmentShader
   ));
@@ -45,17 +46,17 @@ export function createProgram(layer, material = defaultMaterial) {
     shaders.textured ? uVLayout : null,
   ];
   if (material.instanced) vertexBuffers.push(instanceLayout);
-  const bindGroupLayout = createProgramLayout(rendererByLayer.get(layer).device, shaders);
-  const pipelineLayout = rendererByLayer.get(layer).device.createPipelineLayout((
+  const bindGroupLayout = createProgramLayout(device, shaders);
+  const pipelineLayout = device.createPipelineLayout((
     sharedPipelineLayout.bindGroupLayouts[0] = bindGroupLayout,
-    sharedPipelineLayout.bindGroupLayouts[1] = rendererByLayer.get(layer).sunlight.layout,
+    sharedPipelineLayout.bindGroupLayouts[1] = renderer.sunlight.layout,
     sharedPipelineLayout
   ));
   sharedPipelineLayout.bindGroupLayouts[0] = null;
   sharedPipelineLayout.bindGroupLayouts[1] = null;
   const uniforms = createProgramUniforms(material);
   return /* alloc */ {
-    device: rendererByLayer.get(layer).device,
+    device,
     vertex,
     fragment,
     bindings: shaders.bindings,

package/src/materials/createProgramUniforms.js

@@ -13,5 +13,6 @@ export function createProgramUniforms(material) {
   if (material.emissiveTexture) uniforms.emissiveTexture = /* alloc */ { value: material.emissiveTexture };
   if (material.occlusionTexture) uniforms.occlusionTexture = /* alloc */ { value: material.occlusionTexture };
   if (material.roofTexture || material.wallTexture) uniforms.roofTexture = /* alloc */ { value: null };
+  if (material.nativeStroke) uniforms.strokeScale = /* alloc */ { value: 1 };
   return uniforms;
 }

package/src/models/loadModel.js

@@ -3,14 +3,14 @@ import { modelByLayer } from '../weakmaps/modelByLayer.js';
 import { modelUrlByLayer } from '../weakmaps/modelUrlByLayer.js';
 import { rootByLayer } from '../weakmaps/rootByLayer.js';
 import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
 
 
 
-import { decodeModel } from './decodeModel.js';
+import { runSourceWorker } from '../workers/runSourceWorker.js';
 import { setParent } from '../scene/setParent.js';
 import { emptyNode } from '../scene/createSceneNode.js';
 import { conformModelToTerrain } from '../geometry/conformModelToTerrain.js';
-import { loadModelResources } from './loadModelResources.js';
 import { createModelContext } from './createModelContext.js';
 import { buildModelNodes } from './buildModelNodes.js';
 import { applyModelTransform } from './applyModelTransform.js';
@@ -22,14 +22,10 @@ import { applyModelTransform } from './applyModelTransform.js';
 export async function loadModel(layer) {
   await addedByLayer.get(layer).promise;
   const url = /* alloc */ new URL(modelUrlByLayer.get(layer), document.baseURI).href;
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw /* alloc */ new Error(`Unable to load model: HTTP ${response.status}`);
-  }
-  const data = await response.arrayBuffer();
-  const description = decodeModel(data);
-  const directory = /* alloc */ new URL('.', url).href;
-  const images = await loadModelResources(layer, description, directory);
+  const { description, images } = await runSourceWorker(layer._map, layer.options.workerUrl,
+    /* alloc */ { type: 'model', url });
+  await addedByLayer.get(layer).promise;
+  await cameraViewByMap.get(layer._map);
   const context = createModelContext(layer, description, images);
   const scene = description.scenes?.[description.scene || 0];
   if (!scene) throw /* alloc */ new Error('Missing glTF scene');

package/src/models/loadModelResources.js

@@ -1,20 +1,14 @@
-import { addedByLayer } from '../weakmaps/addedByLayer.js';
-import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
-
 import { geometryEmpty } from '../globals/geometryEmpty.js';
 import { loadBuffer } from './loadBuffer.js';
 import { loadImage } from '../textures/loadModelImage.js';
 
-export async function loadModelResources(layer, description, directory) {
+export async function loadModelResources(description, directory) {
   const bufferRequests = /* alloc */ [];
   let buffer;
   for (buffer of description.buffers || geometryEmpty) bufferRequests.push(loadBuffer(buffer, directory));
   await Promise.all(bufferRequests);
-  await addedByLayer.get(layer).promise;
   const imageRequests = /* alloc */ [];
   let image;
   for (image of description.images || geometryEmpty) imageRequests.push(loadImage(description, directory, image));
-  const images = await Promise.all(imageRequests);
-  await cameraViewByMap.get(layer._map);
-  return images;
+  return Promise.all(imageRequests);
 }

package/src/models/modelNode.js

@@ -4,8 +4,6 @@ import { geometryEmpty } from '../globals/geometryEmpty.js';
 import { emptyNode } from '../scene/createSceneNode.js';
 import { nodeMatrix } from '../transforms/modelNodeMatrix.js';
 import { setParent } from '../scene/setParent.js';
-import { readModelAttributes } from './readModelAttributes.js';
-import { readModelIndices } from './readModelIndices.js';
 import { createModelGeometry } from '../geometry/createModelGeometry.js';
 
 export function modelNode(context, index) {
@@ -20,13 +18,11 @@ export function modelNode(context, index) {
     name: spec.name
   };
   group.matrix = nodeMatrix(spec);
-  let primitive, attributeData, attributes, vertexCount, built, mesh, child;
+  let primitive, attributes, built, mesh, child;
   if (spec.mesh !== undefined) {
     for (primitive of description.meshes[spec.mesh].primitives) {
-      attributeData = readModelAttributes(description, primitive);
-      attributes = attributeData.attributes;
-      vertexCount = attributeData.vertexCount;
-      readModelIndices(description, primitive, attributes, vertexCount);
+      // Node instances own their CPU data and GPU buffers, even when they share a glTF mesh.
+      attributes = structuredClone(primitive.preparedAttributes);
       built = createModelGeometry(context, primitive, attributes);
       mesh = /* alloc */ {
         ...emptyNode(),

package/src/models/prepareModel.js

@@ -0,0 +1,19 @@
+import { decodeModel } from './decodeModel.js';
+import { loadModelResources } from './loadModelResources.js';
+import { prepareModelGeometry } from './prepareModelGeometry.js';
+
+export async function prepareModel(url) {
+  const response = await fetch(url);
+  if (!response.ok) throw /* alloc */ new Error(`Unable to load model: HTTP ${response.status}`);
+  const description = decodeModel(await response.arrayBuffer());
+  const scene = description.scenes?.[description.scene || 0];
+  if (!scene) throw /* alloc */ new Error('Missing glTF scene');
+  const images = await loadModelResources(description, /* alloc */ new URL('.', url).href);
+  const transfers = prepareModelGeometry(description, scene);
+  let image;
+  for (image of images) transfers.push(image);
+  delete description.buffers;
+  delete description.bufferViews;
+  delete description.accessors;
+  return /* alloc */ { description, images, transfers };
+}

package/src/models/prepareModelGeometry.js

@@ -0,0 +1,25 @@
+import { geometryEmpty } from '../globals/geometryEmpty.js';
+import { prepareModelPrimitive } from './prepareModelPrimitive.js';
+
+export function prepareModelGeometry(description, scene) {
+  const pending = scene.nodes.slice(), visited = /* alloc */ new Set();
+  const meshes = /* alloc */ new Set(), transfers = /* alloc */ new Set();
+  let index, spec, primitive, attribute, child;
+  while (pending.length) {
+    index = pending.pop();
+    if (visited.has(index)) continue;
+    visited.add(index);
+    spec = description.nodes[index];
+    if (!spec) throw /* alloc */ new Error('Invalid glTF node');
+    if (spec.mesh !== undefined) meshes.add(spec.mesh);
+    for (child of spec.children || geometryEmpty) pending.push(child);
+  }
+  for (index of meshes) {
+    for (primitive of description.meshes[index].primitives) {
+      for (attribute of Object.values(prepareModelPrimitive(description, primitive))) {
+        transfers.add(attribute.data.buffer);
+      }
+    }
+  }
+  return /* alloc */ [...transfers];
+}

package/src/models/prepareModelPrimitive.js

@@ -0,0 +1,17 @@
+import { readModelAttributes } from './readModelAttributes.js';
+import { readModelIndices } from './readModelIndices.js';
+import { vertexNormals } from '../geometry/vertexNormals.js';
+
+export function prepareModelPrimitive(description, primitive) {
+  const { attributes, vertexCount } = readModelAttributes(description, primitive);
+  readModelIndices(description, primitive, attributes, vertexCount);
+  if (!attributes.normal) {
+    attributes.normal = /* alloc */ { size: 3,
+      data: vertexNormals(attributes.position.data, attributes.index?.data) };
+  }
+  if (attributes.index?.data instanceof Uint8Array) {
+    attributes.index.data = Uint16Array.from(attributes.index.data);
+  }
+  primitive.preparedAttributes = attributes;
+  return attributes;
+}

package/src/mvt/addMvtCrossings.js

@@ -0,0 +1,17 @@
+import { mvtEdgeX } from './mvtEdgeX.js';
+
+export function addMvtCrossings(edges, levels) {
+  let i = 0, j, a, b, top, bottom, start, end;
+  for (; i < edges.length; i++) {
+    a = edges[i];
+    for (j = i + 1; j < edges.length; j++) {
+      b = edges[j];
+      top = Math.max(a[0][1], b[0][1]);
+      bottom = Math.min(a[1][1], b[1][1]);
+      if (top >= bottom) continue;
+      start = mvtEdgeX(a, top) - mvtEdgeX(b, top);
+      end = mvtEdgeX(a, bottom) - mvtEdgeX(b, bottom);
+      if (start * end < 0) levels.add(top + (bottom - top) * start / (start - end));
+    }
+  }
+}

package/src/mvt/appendMvtBandTriangles.js

@@ -0,0 +1,31 @@
+import { mvtEdgeX } from './mvtEdgeX.js';
+import { sortMvtActiveEdges } from './sortMvtActiveEdges.js';
+
+export function appendMvtBandTriangles(edges, top, bottom, triangles) {
+  const mid = (top + bottom) / 2, active = /* alloc */ [];
+  let edge, i = 0, leftTop, leftBottom, rightTop, rightBottom;
+  for (edge of edges) {
+    if (edge[0][1] < mid && edge[1][1] > mid) {
+      active.push(/* alloc */ { edge, x: mvtEdgeX(edge, mid) });
+    }
+  }
+  sortMvtActiveEdges(active);
+  if (active.length % 2) throw /* alloc */ new Error('Unbalanced MVT polygon edges');
+  for (; i < active.length; i += 2) {
+    leftTop = mvtEdgeX(active[i].edge, top);
+    leftBottom = mvtEdgeX(active[i].edge, bottom);
+    rightTop = mvtEdgeX(active[i + 1].edge, top);
+    rightBottom = mvtEdgeX(active[i + 1].edge, bottom);
+    if (rightTop < leftTop - 1e-8 || rightBottom < leftBottom - 1e-8) {
+      throw /* alloc */ new Error('Crossing MVT polygon edges');
+    }
+    if ((rightTop - leftTop) * (bottom - top) > 1e-6) {
+      triangles.push(/* alloc */ [/* alloc */ [leftTop, top], /* alloc */ [rightTop, top],
+        /* alloc */ [leftBottom, bottom]]);
+    }
+    if ((rightBottom - leftBottom) * (bottom - top) > 1e-6) {
+      triangles.push(/* alloc */ [/* alloc */ [rightTop, top], /* alloc */ [rightBottom, bottom],
+        /* alloc */ [leftBottom, bottom]]);
+    }
+  }
+}

package/src/mvt/appendMvtCoordinates.js

@@ -0,0 +1,11 @@
+export function appendMvtCoordinates(commands, state, count) {
+  let i = 0, dx, dy;
+  for (; i < count; i++) {
+    dx = commands[state.index++];
+    dy = commands[state.index++];
+    if (dx > 0xffffffff || dy > 0xffffffff) throw /* alloc */ new Error('Invalid MVT coordinate');
+    state.x += dx % 2 ? -(dx + 1) / 2 : dx / 2;
+    state.y += dy % 2 ? -(dy + 1) / 2 : dy / 2;
+    state.path.push(/* alloc */ [state.x, state.y]);
+  }
+}

package/src/mvt/appendMvtPolygonTriangles.js

@@ -0,0 +1,19 @@
+import { tessellateVectorRings } from './tessellateVectorRings.js';
+import { triangulate } from '../triangulation/triangulate.js';
+import { isMvtFallbackError } from './isMvtFallbackError.js';
+
+export function appendMvtPolygonTriangles(rings, paths, vertices, triangles) {
+  let indices, index, triangle, points, i = 0;
+  try {
+    indices = triangulate(paths[0], paths.slice(1));
+    for (triangle of indices) {
+      points = /* alloc */ [];
+      for (index of triangle) points.push(/* alloc */ [vertices[index].x, vertices[index].y]);
+      triangles.push(points);
+    }
+  } catch (error) {
+    if (!isMvtFallbackError(error)) throw error;
+    indices = tessellateVectorRings(rings);
+    for (; i < indices.length; i++) triangles.push(indices[i]);
+  }
+}

package/src/mvt/beginMvtPath.js

@@ -0,0 +1,9 @@
+import { finishMvtPath } from './finishMvtPath.js';
+
+export function beginMvtPath(state, paths, type, count) {
+  finishMvtPath(state.path, type, state.closed);
+  if (type !== 1 && count !== 1) throw /* alloc */ new Error('Invalid MVT MoveTo');
+  state.path = /* alloc */ [];
+  paths.push(state.path);
+  state.closed = false;
+}

package/src/mvt/closeMvtPath.js

@@ -0,0 +1,7 @@
+export function closeMvtPath(state, type, count) {
+  if (type !== 3 || count !== 1 || !state.path || state.closed || state.path.length < 3) {
+    throw /* alloc */ new Error('Invalid MVT ClosePath');
+  }
+  state.path.push(/* alloc */ [...state.path[0]]);
+  state.closed = true;
+}

package/src/mvt/collectMvtEdges.js

@@ -0,0 +1,19 @@
+import { finiteMvtCoordinate } from './finiteMvtCoordinate.js';
+
+export function collectMvtEdges(rings, edges, levels) {
+  let ring, i, a, b;
+  for (ring of rings) {
+    if (ring.length < 4 || ring[0][0] !== ring.at(-1)[0] || ring[0][1] !== ring.at(-1)[1]) {
+      throw /* alloc */ new Error('MVT tessellation requires closed rings');
+    }
+    for (i = 1; i < ring.length; i++) {
+      a = ring[i - 1];
+      b = ring[i];
+      if (!finiteMvtCoordinate(a) || !finiteMvtCoordinate(b)) {
+        throw /* alloc */ new Error('Invalid MVT ring coordinate');
+      }
+      levels.add(a[1]);
+      if (a[1] !== b[1]) edges.push(/* alloc */ [a[1] < b[1] ? a : b, a[1] < b[1] ? b : a]);
+    }
+  }
+}

package/src/mvt/createMvtReader.js

@@ -0,0 +1,7 @@
+export function createMvtReader(bytes) {
+  return /* alloc */ {
+    bytes,
+    view: /* alloc */ new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength),
+    pos: 0,
+  };
+}

package/src/mvt/decodeVectorTile.js

@@ -0,0 +1,32 @@
+import { createMvtReader } from './createMvtReader.js';
+import { readMvtField } from './readMvtField.js';
+import { readMvtLayer } from './readMvtLayer.js';
+import { readMvtMessage } from './readMvtMessage.js';
+import { skipMvtField } from './skipMvtField.js';
+
+/**
+ * Decode an uncompressed MVT ArrayBuffer/Uint8Array into tile-local layers.
+ * Feature types: 0 unknown, 1 points, 2 lines, 3 polygon rings (including holes).
+ * Integers outside JavaScript's safe range are returned as decimal strings.
+ */
+export function decodeVectorTile(buffer) {
+  if (!(buffer instanceof ArrayBuffer) && !(buffer instanceof Uint8Array)) {
+    throw /* alloc */ new TypeError('MVT input must be an ArrayBuffer or Uint8Array');
+  }
+  const bytes = buffer instanceof Uint8Array ? buffer : /* alloc */ new Uint8Array(buffer);
+  const reader = createMvtReader(bytes);
+  const layers = /* alloc */ [], names = /* alloc */ new Set();
+  let field, wire, layer;
+  while (reader.pos < reader.bytes.length) {
+    [field, wire] = readMvtField(reader);
+    if (field !== 3) {
+      skipMvtField(reader, wire);
+      continue;
+    }
+    layer = readMvtLayer(readMvtMessage(reader, wire));
+    if (names.has(layer.name)) throw /* alloc */ new Error('Duplicate MVT layer name');
+    names.add(layer.name);
+    layers.push(layer);
+  }
+  return layers;
+}

package/src/mvt/expectMvtWire.js

@@ -0,0 +1,3 @@
+export function expectMvtWire(wire, expected) {
+  if (wire !== expected) throw /* alloc */ new Error('Invalid MVT wire type');
+}

package/src/mvt/finishMvtPath.js

@@ -0,0 +1,5 @@
+export function finishMvtPath(path, type, closed) {
+  if (path && (type === 2 && path.length < 2 || type === 3 && !closed)) {
+    throw /* alloc */ new Error('Incomplete MVT geometry');
+  }
+}

package/src/mvt/finiteMvtCoordinate.js

@@ -0,0 +1,7 @@
+export function finiteMvtCoordinate(point) {
+  let i = 0;
+  for (; i < point.length; i++) {
+    if (!Number.isFinite(point[i])) return false;
+  }
+  return true;
+}

package/src/mvt/groupMvtPolygons.js

@@ -0,0 +1,25 @@
+import { finiteMvtCoordinate } from './finiteMvtCoordinate.js';
+
+export function groupMvtPolygons(rings) {
+  const polygons = /* alloc */ [];
+  let polygon, exteriorSign, ring, area, i;
+  for (ring of rings) {
+    if (ring.length < 4 || ring[0][0] !== ring.at(-1)[0] || ring[0][1] !== ring.at(-1)[1]) {
+      throw /* alloc */ new Error('MVT tessellation requires closed rings');
+    }
+    area = 0;
+    for (i = 1; i < ring.length; i++) {
+      if (!finiteMvtCoordinate(ring[i]) || !finiteMvtCoordinate(ring[i - 1])) {
+        throw /* alloc */ new Error('Invalid MVT ring coordinate');
+      }
+      area += ring[i - 1][0] * ring[i][1] - ring[i][0] * ring[i - 1][1];
+    }
+    if (!polygon || area && Math.sign(area) === exteriorSign) {
+      polygon = /* alloc */ [];
+      polygons.push(polygon);
+      exteriorSign = Math.sign(area);
+    }
+    polygon.push(ring);
+  }
+  return polygons;
+}

package/src/mvt/isMvtFallbackError.js

@@ -0,0 +1,6 @@
+export function isMvtFallbackError(error) {
+  return error.message === 'Polygon triangulation area mismatch' ||
+    error.message === 'Degenerate polygon ring' ||
+    error.message === 'Unable to triangulate polygon: invalid or self-intersecting rings' ||
+    error.message === 'Unable to connect polygon hole';
+}

package/src/mvt/mergeMvtActiveEdges.js

@@ -0,0 +1,9 @@
+export function mergeMvtActiveEdges(active, sorted, left, mid, right) {
+  let i = left, j = mid, k = left;
+  while (i < mid && j < right) {
+    if (active[j].x < active[i].x) sorted[k++] = active[j++];
+    else sorted[k++] = active[i++];
+  }
+  while (i < mid) sorted[k++] = active[i++];
+  while (j < right) sorted[k++] = active[j++];
+}

package/src/mvt/mvtEdgeX.js

@@ -0,0 +1,4 @@
+export function mvtEdgeX(edge, y) {
+  return edge[0][0] + (y - edge[0][1]) *
+    (edge[1][0] - edge[0][0]) / (edge[1][1] - edge[0][1]);
+}