leaflet-city-mapper 0.0.5 → 0.0.7

package/src/vector-style/parseHexColor.js

@@ -0,0 +1,13 @@
+export function parseHexColor(value) {
+  let i = 0, offset = 0;
+  if (value.length === 4) {
+    value = '#' + value[1] + value[1] + value[2] + value[2] + value[3] + value[3];
+  }
+  const color = /* alloc */ [];
+  for (i = 1; i < 6; i += 2) {
+    offset = parseInt(value.slice(i, i + 2), 16);
+    color.push(offset);
+  }
+  color.push(1);
+  return color;
+}

package/src/vector-style/parseVectorStyle.js

@@ -0,0 +1,13 @@
+import { removeTrailingCommas } from './removeTrailingCommas.js';
+import { stripStyleComments } from './stripStyleComments.js';
+import { validateVectorLayers } from './validateVectorLayers.js';
+
+export function parseVectorStyle(text) {
+  const prefix = /^\s*(?:const|let|var)\s+otm_layers\s*=\s*/.exec(text);
+  if (prefix) text = text.slice(prefix[0].length);
+  const cleaned = removeTrailingCommas(stripStyleComments(text).trim().replace(/;$/, ''));
+  const document = JSON.parse(cleaned);
+  const layers = document.layers ?? document;
+  validateVectorLayers(layers);
+  return layers;
+}

package/src/vector-style/readPaintValue.js

@@ -0,0 +1,6 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function readPaintValue(paint, key, fallback, properties, zoom) {
+  if (paint[key] === undefined) return fallback;
+  return evaluateStyle(paint[key], properties, zoom);
+}

package/src/vector-style/removeTrailingCommas.js

@@ -0,0 +1,12 @@
+export function removeTrailingCommas(json) {
+  let cleaned = '', quoted = false, escaped = false, i = 0, char = '';
+  for (i = 0; i < json.length; i++) {
+    char = json[i];
+    if (!quoted && char === ',' && /^\s*[\]}]/.test(json.slice(i + 1))) continue;
+    cleaned += char;
+    if (escaped) escaped = false;
+    else if (quoted && char === '\\') escaped = true;
+    else if (char === '"') quoted = !quoted;
+  }
+  return cleaned;
+}

package/src/vector-style/scaleDashArray.js

@@ -0,0 +1,13 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function scaleDashArray(dash, weight, properties, zoom) {
+  if (!dash) return undefined;
+  let values = dash, i = 0, result = '';
+  if (typeof dash[0] !== 'number') values = evaluateStyle(dash, properties, zoom);
+  if (!Array.isArray(values)) throw /* alloc */ new TypeError('Style dash array must be an array');
+  for (i = 0; i < values.length; i++) {
+    if (i) result += ' ';
+    result += values[i] * weight;
+  }
+  return result;
+}

package/src/vector-style/skipStyleComment.js

@@ -0,0 +1,9 @@
+export function skipStyleComment(text, index, marker) {
+  if (marker === '/') {
+    while (index < text.length && text[index] !== '\n') index++;
+    return index;
+  }
+  const end = text.indexOf('*/', index + 2);
+  if (end < 0) throw /* alloc */ new Error('Unterminated style comment');
+  return end + 1;
+}

package/src/vector-style/stripStyleComments.js

@@ -0,0 +1,21 @@
+import { appendQuotedStyleCharacter } from './appendQuotedStyleCharacter.js';
+import { skipStyleComment } from './skipStyleComment.js';
+
+export function stripStyleComments(text) {
+  let json = '', i = 0, char = '', next = '', converted = undefined;
+  const state = /* alloc */ { quoted: '', escaped: false };
+  for (i = 0; i < text.length; i++) {
+    char = text[i];
+    next = text[i + 1];
+    converted = appendQuotedStyleCharacter(char, state);
+    if (converted !== undefined) {
+      json += converted;
+      continue;
+    }
+    if (char === '/' && (next === '/' || next === '*')) {
+      i = skipStyleComment(text, i, next);
+      json += next === '/' ? '\n' : ' ';
+    } else json += char;
+  }
+  return json;
+}

package/src/vector-style/styleColor.js

@@ -0,0 +1,11 @@
+import { vectorStyleNamedColors } from '../globals/vectorStyleNamedColors.js';
+import { parseFunctionalColor } from './parseFunctionalColor.js';
+import { parseHexColor } from './parseHexColor.js';
+
+export function styleColor(value) {
+  if (Object.hasOwn(vectorStyleNamedColors, value)) return vectorStyleNamedColors[value];
+  if (/^#[0-9a-f]{3}$/i.test(value) || /^#[0-9a-f]{6}$/i.test(value)) {
+    return parseHexColor(value);
+  }
+  return parseFunctionalColor(value);
+}

package/src/vector-style/validateVectorLayers.js

@@ -0,0 +1,10 @@
+export function validateVectorLayers(layers) {
+  let i = 0, layer = null;
+  if (!Array.isArray(layers)) throw /* alloc */ new Error('Invalid vector style layers');
+  for (i = 0; i < layers.length; i++) {
+    layer = layers[i];
+    if (!layer || typeof layer.id !== 'string' || typeof layer.type !== 'string') {
+      throw /* alloc */ new Error('Invalid vector style layers');
+    }
+  }
+}

package/src/vector-style/vectorPaint.js

@@ -0,0 +1,8 @@
+import { fillVectorPaint } from './fillVectorPaint.js';
+import { lineVectorPaint } from './lineVectorPaint.js';
+
+export function vectorPaint(layer, properties, zoom) {
+  const paint = layer.paint || /* alloc */ {};
+  if (layer.type === 'fill') return fillVectorPaint(paint, properties, zoom);
+  return lineVectorPaint(layer, paint, properties, zoom);
+}

package/src/vector-style/visibleStyle.js

@@ -0,0 +1,7 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function visibleStyle(layer, properties, zoom) {
+  return zoom >= (layer.minzoom ?? 0) && zoom < (layer.maxzoom ?? Infinity) &&
+    layer.layout?.visibility !== 'none' &&
+    (!layer.filter || evaluateStyle(layer.filter, properties, zoom, true));
+}

package/src/vector-tiles/appendVectorBatch.js

@@ -0,0 +1,22 @@
+import { vectorFeaturePaths } from './vectorFeaturePaths.js';
+
+export function appendVectorBatch(job, layer, entry, feature, order, batches, dependencies, paint) {
+  const values = /* alloc */ [];
+  let key, batch, path, count;
+  for (key of dependencies) values.push(feature.properties[key]);
+  key = JSON.stringify(/* alloc */ [paint, values]);
+  batch = batches.get(key);
+  if (!batch) {
+    batch = /* alloc */ { kind: entry.type, order, paint, properties: feature.properties, entry,
+      paths: /* alloc */ [], coordinates: 0 };
+    batches.set(key, batch);
+  }
+  for (path of vectorFeaturePaths(job, layer, entry, feature)) {
+    count = entry.type === 'fill' ? 3 : path.length;
+    if (batch.coordinates + count > 6000 && batch.paths.length) {
+      job.output.push(/* alloc */ { ...batch, paths: batch.paths });
+      batch.paths = /* alloc */ []; batch.coordinates = 0;
+    }
+    batch.paths.push(path); batch.coordinates += count;
+  }
+}

package/src/vector-tiles/attachVectorTileBatch.js

@@ -0,0 +1,17 @@
+import { L } from '../globals/L.js';
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+import { vectorStyleZoom } from './vectorStyleZoom.js';
+import { vectorTilePaint } from './vectorTilePaint.js';
+import { forwardVectorTileError } from './forwardVectorTileError.js';
+
+export function attachVectorTileBatch(owner, tile, group, batch) {
+  const { pane } = vectorTileOptionsByLayer.get(owner);
+  const paint = vectorTilePaint(batch, vectorStyleZoom(owner));
+  const options = /* alloc */ { ...paint, pane: `${pane}-${batch.order}`, interactive: false, smoothFactor: 0 };
+  const layer = batch.kind === 'fill'
+    ? /* alloc */ new L.Polygon(batch.paths, /* alloc */ { ...options, stroke: false, triangulated: true })
+    : /* alloc */ new L.Polyline(batch.paths, options);
+  layer.on('error', forwardVectorTileError, owner);
+  tile.rendered.push(/* alloc */ { layer, kind: batch.kind, entry: batch.entry, properties: batch.properties });
+  group.addLayer(layer);
+}

package/src/vector-tiles/attachVectorTileBatches.js

@@ -0,0 +1,15 @@
+import { attachVectorTileBatch } from './attachVectorTileBatch.js';
+import { vectorTilesIdle } from './vectorTilesIdle.js';
+import { yieldTask } from '../utils/yieldTask.js';
+
+export async function attachVectorTileBatches(owner, tile, group, batches, session) {
+  let batch, start = performance.now();
+  for (batch of batches) {
+    while (!vectorTilesIdle(owner, session) && owner.session === session &&
+      !tile.controller.signal.aborted) await yieldTask(50);
+    if (tile.controller.signal.aborted || owner.session !== session) return false;
+    attachVectorTileBatch(owner, tile, group, batch);
+    if (performance.now() - start > 8) { await yieldTask(); start = performance.now(); }
+  }
+  return true;
+}

package/src/vector-tiles/compareVectorLabelPriority.js

@@ -0,0 +1,3 @@
+export function compareVectorLabelPriority(a, b) {
+  return a.priority - b.priority;
+}

package/src/vector-tiles/compareVectorTileDistance.js

@@ -0,0 +1,3 @@
+export function compareVectorTileDistance(a, b) {
+  return a.distance - b.distance;
+}

package/src/vector-tiles/configureVectorTileLayer.js

@@ -0,0 +1,28 @@
+import { L } from '../globals/L.js';
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+import { vectorTileSettings } from './vectorTileSettings.js';
+import { loadVectorSprite } from './loadVectorSprite.js';
+import { onVectorTileAdd } from './onVectorTileAdd.js';
+import { onVectorTileRemove } from './onVectorTileRemove.js';
+import { updateVectorTiles } from './updateVectorTiles.js';
+import { updateVectorTilePaint } from './updateVectorTilePaint.js';
+import { updateVectorTileLabels } from './updateVectorTileLabels.js';
+import { pruneVectorTiles } from './pruneVectorTiles.js';
+import { retireVectorTileGroup } from './retireVectorTileGroup.js';
+import { pumpVectorTiles } from './pumpVectorTiles.js';
+import { loadVectorTile } from './loadVectorTile.js';
+
+export async function configureVectorTileLayer(layer, options) {
+  const settings = await vectorTileSettings(options);
+  if (typeof settings.sprite === 'string') settings.spriteSheet = await loadVectorSprite(settings.sprite);
+  const { url, tileJSON, style, sourceId, minNativeZoom, maxNativeZoom, maxZoom, ...core } = settings;
+  L.Util.setOptions(layer, core);
+  settings.pane = `mvt-${L.Util.stamp(layer)}`;
+  vectorTileOptionsByLayer.set(layer, settings);
+  Object.assign(layer, /* alloc */ {
+    onAdd: onVectorTileAdd, onRemove: onVectorTileRemove, update: updateVectorTiles,
+    updatePaint: updateVectorTilePaint, updateLabels: updateVectorTileLabels,
+    prune: pruneVectorTiles, retire: retireVectorTileGroup, pump: pumpVectorTiles, load: loadVectorTile,
+  });
+  return layer;
+}

package/src/vector-tiles/forwardVectorTileError.js

@@ -0,0 +1,5 @@
+import { reportError } from '../scene/reportLayerError.js';
+
+export function forwardVectorTileError({ error }) {
+  reportError(this, error);
+}

package/src/vector-tiles/loadVectorSprite.js

@@ -0,0 +1,5 @@
+export async function loadVectorSprite(url) {
+  const response = await fetch(`${url}.json`);
+  if (!response.ok) throw /* alloc */ new Error(`Sprite ${url}.json: HTTP ${response.status}`);
+  return /* alloc */ { url: `${url}.png`, index: await response.json() };
+}

package/src/vector-tiles/loadVectorTile.js

@@ -0,0 +1,36 @@
+import { L } from '../globals/L.js';
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+import { vectorStyleZoom } from './vectorStyleZoom.js';
+import { attachVectorTileBatches } from './attachVectorTileBatches.js';
+
+export async function loadVectorTile(tile) {
+  const { coords, controller } = tile, session = this.session;
+  const { url, style, sourceId, maxZoom, maxNativeZoom } = vectorTileOptionsByLayer.get(this);
+  const count = 2 ** coords.z, x = ((coords.x % count) + count) % count;
+  let group;
+  try {
+    const tileUrl = L.Util.template(url, /* alloc */ { z: coords.z, x, y: coords.y });
+    const response = await fetch(tileUrl, /* alloc */ { signal: controller.signal });
+    if (!response.ok) throw /* alloc */ new Error(`Tile ${tile.key}: HTTP ${response.status}`);
+    const buffer = await response.arrayBuffer();
+    if (controller.signal.aborted) return;
+    const id = ++this.sequence, prepared = Promise.withResolvers();
+    this.waiting.set(id, prepared);
+    this.worker.postMessage(/* alloc */ { type: 'vector', id, buffer, coords, style, source: sourceId, maxZoom,
+      zoom: vectorStyleZoom(this), mapZoom: coords.z >= maxNativeZoom ? maxZoom : this._map.getZoom() }, /* alloc */ [buffer]);
+    const data = await prepared.promise;
+    if (controller.signal.aborted || this.session !== session) return;
+    group = /* alloc */ new L.LayerGroup().addTo(this._map);
+    tile.rendered = /* alloc */ [];
+    if (!await attachVectorTileBatches(this, tile, group, data.batches, session)) { group.remove(); return; }
+    tile.group = group; tile.labelCandidates = data.labels;
+    this.fire('tileload', /* alloc */ { coords, group });
+    this.prune();
+    this.refresh();
+  } catch (error) {
+    group?.remove();
+    if (!controller.signal.aborted && this.session === session) this.fire('error', /* alloc */ { error });
+  } finally {
+    if (this.session === session) { this.inflight--; this.pump(); }
+  }
+}

package/src/vector-tiles/onVectorTileAdd.js

@@ -0,0 +1,39 @@
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+import { geometryWorkerUrl } from '../globals/geometryWorkerUrl.js';
+import { vectorTileEvents } from '../globals/vectorTileEvents.js';
+import { evaluateStyle } from '../vector-style/evaluateStyle.js';
+import { vectorStyleZoom } from './vectorStyleZoom.js';
+import { refreshVectorTiles } from './refreshVectorTiles.js';
+import { rotateVectorLabels } from './rotateVectorLabels.js';
+import { onVectorTileMessage } from './onVectorTileMessage.js';
+import { onVectorTileWorkerError } from './onVectorTileWorkerError.js';
+import { createGeometryWorker } from '../workers/createGeometryWorker.js';
+import { vectorWorkerByLayer } from '../weakmaps/vectorWorkerByLayer.js';
+
+export function onVectorTileAdd(map) {
+  const { style, pane } = vectorTileOptionsByLayer.get(this);
+  let index, entry;
+  for ([index] of style.entries()) {
+    (map.getPane(`${pane}-${index}`) || map.createPane(`${pane}-${index}`)).style.zIndex = 200 + index;
+  }
+  for (entry of style) {
+    if (entry.type !== 'background') continue;
+    map.getContainer().style.background = evaluateStyle(entry.paint['background-color'], /* alloc */ {}, vectorStyleZoom(this));
+    break;
+  }
+  this.session = /* alloc */ {};
+  this.tiles = /* alloc */ new Map(); this.labels = /* alloc */ new Map(); this.waiting = /* alloc */ new Map();
+  this.retiring = /* alloc */ new Set();
+  this.inflight = 0; this.sequence = 0;
+  this.changedAt = 0; this.paintZoom = null;
+  const workerEntry = createGeometryWorker(this.options.workerUrl || geometryWorkerUrl);
+  vectorWorkerByLayer.set(this, workerEntry);
+  this.worker = workerEntry.worker;
+  this.worker.onmessage = onVectorTileMessage.bind(this);
+  this.worker.onerror = onVectorTileWorkerError.bind(this);
+  this.refresh = refreshVectorTiles.bind(this);
+  this.rotateLabels = rotateVectorLabels.bind(this);
+  map.on(vectorTileEvents, this.refresh);
+  map.on('move rotate pitch', this.rotateLabels);
+  this.update();
+}

package/src/vector-tiles/onVectorTileMessage.js

@@ -0,0 +1,10 @@
+import { revokeVectorWorkerUrl } from './revokeVectorWorkerUrl.js';
+
+export function onVectorTileMessage({ data }) {
+  revokeVectorWorkerUrl(this);
+  const pending = this.waiting.get(data.id);
+  if (!pending) return;
+  this.waiting.delete(data.id);
+  if (data.error) pending.reject(/* alloc */ new Error(data.error));
+  else pending.resolve(data);
+}

package/src/vector-tiles/onVectorTileRemove.js

@@ -0,0 +1,20 @@
+import { vectorTileEvents } from '../globals/vectorTileEvents.js';
+import { vectorWorkerByLayer } from '../weakmaps/vectorWorkerByLayer.js';
+import { revokeVectorWorkerUrl } from './revokeVectorWorkerUrl.js';
+
+export function onVectorTileRemove(map) {
+  map.off(vectorTileEvents, this.refresh);
+  map.off('move rotate pitch', this.rotateLabels);
+  clearTimeout(this.timer);
+  this.session = null;
+  this.worker.terminate();
+  revokeVectorWorkerUrl(this);
+  vectorWorkerByLayer.delete(this);
+  let pending, tile, group, marker;
+  for (pending of this.waiting.values()) pending.reject(/* alloc */ new DOMException('Layer removed', 'AbortError'));
+  this.waiting.clear();
+  for (tile of this.tiles.values()) { tile.controller.abort(); tile.group?.remove(); }
+  for (group of this.retiring) group.remove();
+  for (marker of this.labels.values()) marker.remove();
+  this.tiles.clear(); this.labels.clear(); this.retiring.clear();
+}

package/src/vector-tiles/onVectorTileWorkerError.js

@@ -0,0 +1,11 @@
+import { reportError } from '../scene/reportLayerError.js';
+import { revokeVectorWorkerUrl } from './revokeVectorWorkerUrl.js';
+
+export function onVectorTileWorkerError(event) {
+  revokeVectorWorkerUrl(this);
+  const error = /* alloc */ new Error(`Worker MVT: ${event.message}`);
+  let pending;
+  for (pending of this.waiting.values()) pending.reject(error);
+  this.waiting.clear();
+  reportError(this, error);
+}

package/src/vector-tiles/paintVectorTileBatch.js

@@ -0,0 +1,12 @@
+import { vectorTilePaint } from './vectorTilePaint.js';
+
+export function paintVectorTileBatch(batch, zoom) {
+  const paint = vectorTilePaint(batch, zoom), { layer } = batch;
+  if (batch.kind === 'line') {
+    if (paint.dashArray !== layer.options.dashArray) layer.setStyle(paint);
+    else layer.setStyle(/* alloc */ { color: paint.color, opacity: paint.opacity, weight: paint.weight });
+  } else if (JSON.stringify(paint.fillColor) !== JSON.stringify(layer.options.fillColor) ||
+      paint.fillOpacity !== layer.options.fillOpacity) {
+    layer.setStyle(/* alloc */ { fillColor: paint.fillColor, fillOpacity: paint.fillOpacity });
+  }
+}

package/src/vector-tiles/prepareVectorLabel.js

@@ -0,0 +1,43 @@
+import { evaluateStyle } from '../vector-style/evaluateStyle.js';
+import { projectVectorPoint } from './projectVectorPoint.js';
+import { vectorLabelProperty } from './vectorLabelProperty.js';
+import { vectorStyleValue } from './vectorStyleValue.js';
+import { vectorLabelAnchors } from './vectorLabelAnchors.js';
+
+export function prepareVectorLabel(job, layer, entry, feature, order) {
+  let text = entry.layout?.['text-field'];
+  const { properties } = feature, { zoom } = job;
+  const icon = entry.layout?.['symbol-placement'] === 'line' ? null
+    : evaluateStyle(entry.layout?.['icon-image'], properties, zoom);
+  if (Array.isArray(text)) text = evaluateStyle(text, properties, zoom);
+  if (typeof text !== 'string') text = '';
+  text = text.replace(/\{([^}]+)\}/g, vectorLabelProperty.bind(null, properties));
+  if (!text.trim() && typeof icon !== 'string') return;
+  if (entry.layout?.['text-transform'] === 'uppercase') text = text.toUpperCase();
+  const size = vectorStyleValue(entry.layout, 'text-size', 12, properties, zoom), line = feature.type === 2 && text.trim();
+  const spacing = layer.extent / 16, anchors = /* alloc */ [];
+  let path, anchor;
+  for (path of line ? feature.geometry : feature.geometry.slice(0, 1)) {
+    if (!path?.length) continue;
+    if (!line) anchors.push(/* alloc */ { point: path[Math.floor(path.length / 2)], a: null });
+    else for (anchor of vectorLabelAnchors(path, spacing)) anchors.push(anchor);
+  }
+  for (anchor of anchors) {
+    if (anchor.point[0] < 0 || anchor.point[0] >= layer.extent || anchor.point[1] < 0 || anchor.point[1] >= layer.extent) continue;
+    job.labels.push(/* alloc */ { text, latlng: projectVectorPoint(anchor.point, job.coords, layer.extent),
+    order, entry, properties, size, pixelBase: anchor.length * 256 / layer.extent / 2 ** job.coords.z,
+    along: anchor.a ? /* alloc */ [
+      projectVectorPoint(anchor.a, job.coords, layer.extent),
+      projectVectorPoint(anchor.b, job.coords, layer.extent),
+    ] : null,
+    icon: text.trim() ? null : icon,
+    iconOffset: evaluateStyle(entry.layout?.['icon-offset'], properties, zoom) || /* alloc */ [0, 0],
+    allowOverlap: entry.layout?.['icon-allow-overlap'] === true,
+    color: vectorStyleValue(entry.paint, 'text-color', '#000', properties, zoom),
+    halo: vectorStyleValue(entry.paint, 'text-halo-color', '#fff', properties, zoom),
+    haloWidth: vectorStyleValue(entry.paint, 'text-halo-width', 0, properties, zoom),
+    priority: /* alloc */ ['place_labels', 'place'].includes(entry['source-layer']) ? 0
+      : /* alloc */ ['street_labels', 'transportation_name'].includes(entry['source-layer']) ? 1 : 2,
+        });
+      }
+    }

package/src/vector-tiles/prepareVectorStyleLayer.js

@@ -0,0 +1,30 @@
+import { vectorStyleDependencies } from './vectorStyleDependencies.js';
+import { vectorFeatureZoom } from './vectorFeatureZoom.js';
+import { prepareVectorLabel } from './prepareVectorLabel.js';
+import { vectorFeaturePaint } from './vectorFeaturePaint.js';
+import { vectorPaint } from '../vector-style/vectorPaint.js';
+import { appendVectorBatch } from './appendVectorBatch.js';
+
+export function prepareVectorStyleLayer(job, layer, entry, order) {
+  const batches = /* alloc */ new Map(), dependencies = vectorStyleDependencies(entry);
+  const outlineColor = entry.type === 'fill' ? entry.paint?.['fill-outline-color'] : null;
+  const outline = outlineColor ? /* alloc */ { ...entry, type: 'line',
+    paint: /* alloc */ { 'line-color': outlineColor, 'line-width': 1 } } : null;
+  let feature, sampleZoom, paint, batch;
+  for (feature of layer.features) {
+    sampleZoom = vectorFeatureZoom(entry, feature.properties, job.zoom, job.maxZoom);
+    if (sampleZoom < 0) continue;
+    if (entry.type === 'symbol') {
+      prepareVectorLabel(job, layer, entry, feature, order);
+      continue;
+    }
+    paint = vectorFeaturePaint(entry, feature, sampleZoom, job.maxZoom);
+    if (!paint) continue;
+    appendVectorBatch(job, layer, entry, feature, order, batches, dependencies, paint);
+    if (outline && feature.type === 3) {
+      appendVectorBatch(job, layer, outline, feature, order, batches, dependencies,
+        vectorPaint(outline, feature.properties, sampleZoom));
+    }
+  }
+  for (batch of batches.values()) if (batch.paths.length) job.output.push(batch);
+}

package/src/vector-tiles/prepareVectorTile.js

@@ -0,0 +1,16 @@
+import { decodeVectorTile } from '../mvt/decodeVectorTile.js';
+import { prepareVectorStyleLayer } from './prepareVectorStyleLayer.js';
+
+export function prepareVectorTile(buffer, coords, style, zoom, source, maxZoom = 19, mapZoom = zoom) {
+  const layers = decodeVectorTile(buffer), byName = /* alloc */ new Map();
+  const job = /* alloc */ { coords, zoom, mapZoom, maxZoom, output: /* alloc */ [], labels: /* alloc */ [],
+    triangles: /* alloc */ new WeakMap(), projected: /* alloc */ new WeakMap() };
+  let layer, order, entry;
+  for (layer of layers) byName.set(layer.name, layer);
+  for ([order, entry] of style.entries()) {
+    layer = byName.get(entry['source-layer']);
+    if (!layer || source !== undefined && entry.source !== source) continue;
+    prepareVectorStyleLayer(job, layer, entry, order);
+  }
+  return /* alloc */ { batches: job.output, labels: job.labels };
+}

package/src/vector-tiles/projectVectorPaths.js

@@ -0,0 +1,15 @@
+import { projectVectorPoint } from './projectVectorPoint.js';
+import { simplifyVectorPath } from './simplifyVectorPath.js';
+
+export function projectVectorPaths(geometry, coords, extent, tolerance) {
+  const paths = /* alloc */ [];
+  let path, simplified, projected, point;
+  for (path of geometry) {
+    simplified = simplifyVectorPath(path, tolerance);
+    if (simplified.length < 3 && Math.hypot(simplified.at(-1)[0] - simplified[0][0], simplified.at(-1)[1] - simplified[0][1]) < tolerance * 2) continue;
+    projected = /* alloc */ [];
+    for (point of simplified) projected.push(projectVectorPoint(point, coords, extent));
+    paths.push(projected);
+  }
+  return paths;
+}

package/src/vector-tiles/projectVectorPoint.js

@@ -0,0 +1,6 @@
+export function projectVectorPoint(point, coords, extent) {
+  const size = 2 ** coords.z;
+  const x = (coords.x + point[0] / extent) / size;
+  const y = (coords.y + point[1] / extent) / size;
+  return /* alloc */ [Math.atan(Math.sinh(Math.PI * (1 - 2 * y))) * 180 / Math.PI, x * 360 - 180];
+}

package/src/vector-tiles/projectVectorTriangles.js

@@ -0,0 +1,18 @@
+import { triangulateVectorRings } from '../mvt/triangulateVectorRings.js';
+import { projectVectorPoint } from './projectVectorPoint.js';
+import { simplifyVectorPath } from './simplifyVectorPath.js';
+
+export function projectVectorTriangles(geometry, coords, extent, tolerance) {
+  const paths = /* alloc */ [], rings = /* alloc */ [];
+  let triangle, projected, point, ring;
+  for (ring of geometry) {
+    ring = simplifyVectorPath(ring, tolerance);
+    if (ring.length >= 4) rings.push(ring);
+  }
+  for (triangle of triangulateVectorRings(rings)) {
+    projected = /* alloc */ [];
+    for (point of triangle) projected.push(projectVectorPoint(point, coords, extent));
+    paths.push(/* alloc */ [projected]);
+  }
+  return paths;
+}

package/src/vector-tiles/pruneVectorTiles.js

@@ -0,0 +1,11 @@
+import { reportError } from '../scene/reportLayerError.js';
+import { vectorTileAwaited } from './vectorTileAwaited.js';
+
+export function pruneVectorTiles() {
+  let tile, key;
+  for ([key, tile] of this.tiles) {
+    if (tile.needed || tile.group && vectorTileAwaited(this, tile)) continue;
+    tile.controller.abort(); this.tiles.delete(key);
+    if (tile.group) this.retire(tile.group).catch(reportError.bind(null, this));
+  }
+}

package/src/vector-tiles/pumpVectorTiles.js

@@ -0,0 +1,18 @@
+import { compareVectorTileDistance } from './compareVectorTileDistance.js';
+
+export function pumpVectorTiles() {
+  if (!this.session) return;
+  const center = this._map.getCenter(), pending = /* alloc */ [];
+  let tile, point;
+  for (tile of this.tiles.values()) {
+    if (!tile.needed || tile.started) continue;
+    point = this._map.project(center, tile.coords.z).divideBy(256);
+    tile.distance = (tile.coords.x - point.x) ** 2 + (tile.coords.y - point.y) ** 2;
+    pending.push(tile);
+  }
+  pending.sort(compareVectorTileDistance);
+  for (tile of pending) {
+    if (this.inflight >= 4) break;
+    tile.started = true; this.inflight++; this.load(tile);
+  }
+}

package/src/vector-tiles/readTileJSON.js

@@ -0,0 +1,17 @@
+export async function readTileJSON(options) {
+  const url = /* alloc */ new URL(options.tileJSON, document.baseURI).href;
+  const response = await fetch(url);
+  if (!response.ok) throw /* alloc */ new Error(`TileJSON: HTTP ${response.status}`);
+  const metadata = await response.json();
+  if (!metadata || !Array.isArray(metadata.tiles) || !metadata.tiles.length ||
+      typeof metadata.tiles[0] !== 'string') {
+    throw /* alloc */ new Error('TileJSON requires a tile URL template');
+  }
+  return /* alloc */ {
+    ...options,
+    url: /* alloc */ new URL(metadata.tiles[0], url).href,
+    minNativeZoom: options.minNativeZoom ?? metadata.minzoom,
+    maxNativeZoom: options.maxNativeZoom ?? metadata.maxzoom,
+    attribution: options.attribution ?? metadata.attribution,
+  };
+}

package/src/vector-tiles/readVectorStyle.js

@@ -0,0 +1,17 @@
+import { parseVectorStyle } from '../vector-style/parseVectorStyle.js';
+
+export async function readVectorStyle(style) {
+  if (typeof style === 'string') {
+    const response = await fetch(style);
+    if (!response.ok) throw /* alloc */ new Error(`Vector style: HTTP ${response.status}`);
+    style = parseVectorStyle(await response.text());
+  } else style = style?.layers ?? style;
+  if (!Array.isArray(style)) throw /* alloc */ new Error('Invalid vector style layers');
+  let entry;
+  for (entry of style) {
+    if (!entry || typeof entry.id !== 'string' || typeof entry.type !== 'string') {
+      throw /* alloc */ new Error('Invalid vector style layers');
+    }
+  }
+  return style;
+}

package/src/vector-tiles/refreshVectorTiles.js

@@ -0,0 +1,5 @@
+export function refreshVectorTiles() {
+  clearTimeout(this.timer);
+  this.changedAt = performance.now();
+  this.timer = setTimeout(this.update.bind(this), 180);
+}

package/src/vector-tiles/reserveVectorLabelCells.js

@@ -0,0 +1,6 @@
+export function reserveVectorLabelCells(cells, occupied) {
+  let cell;
+  for (cell of cells) if (occupied.has(cell)) return false;
+  for (cell of cells) occupied.add(cell);
+  return true;
+}

package/src/vector-tiles/retireVectorTileGroup.js

@@ -0,0 +1,13 @@
+import { yieldTask } from '../utils/yieldTask.js';
+
+export async function retireVectorTileGroup(group) {
+  const session = this.session;
+  this.retiring.add(group);
+  let removed = 0, layer;
+  for (layer of group.getLayers()) {
+    if (this.session !== session) return;
+    group.removeLayer(layer);
+    if (++removed % 8 === 0) await yieldTask();
+  }
+  group.remove(); this.retiring.delete(group);
+}

package/src/vector-tiles/revokeVectorWorkerUrl.js

@@ -0,0 +1,9 @@
+import { vectorWorkerByLayer } from '../weakmaps/vectorWorkerByLayer.js';
+
+export function revokeVectorWorkerUrl(layer) {
+  const entry = vectorWorkerByLayer.get(layer);
+  if (entry?.blobUrl) {
+    URL.revokeObjectURL(entry.blobUrl);
+    entry.blobUrl = null;
+  }
+}