leaflet-city-mapper 0.0.6 → 0.0.7

package/src/vector-style/evaluateInterpolate.js

@@ -0,0 +1,27 @@
+import { styleColor } from './styleColor.js';
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateInterpolate(args, properties, zoom) {
+  const result = evaluateStyle(args[1], properties, zoom);
+  const base = args[0][0] === 'exponential' ? args[0][1] : 1;
+  let i = 0, lower = 0, upper = 0, ratio = 0, left = null, right = null, j = 0, color = '';
+  if (result <= args[2]) return evaluateStyle(args[3], properties, zoom);
+  for (i = 4; i < args.length; i += 2) {
+    if (result > args[i]) continue;
+    lower = args[i - 2];
+    upper = args[i];
+    ratio = base === 1 ? (result - lower) / (upper - lower)
+      : (base ** (result - lower) - 1) / (base ** (upper - lower) - 1);
+    left = evaluateStyle(args[i - 1], properties, zoom);
+    right = evaluateStyle(args[i + 1], properties, zoom);
+    if (typeof left === 'number' && typeof right === 'number') return left + (right - left) * ratio;
+    left = styleColor(left);
+    right = styleColor(right);
+    for (j = 0; j < 3; j++) {
+      if (j) color += ',';
+      color += Math.round(left[j] + (right[j] - left[j]) * ratio);
+    }
+    return `rgba(${color},${left[3] + (right[3] - left[3]) * ratio})`;
+  }
+  return evaluateStyle(args.at(-1), properties, zoom);
+}

package/src/vector-style/evaluateMatch.js

@@ -0,0 +1,12 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateMatch(args, properties, zoom) {
+  const result = evaluateStyle(args[0], properties, zoom);
+  let i = 0, matched = false;
+  for (i = 1; i < args.length - 1; i += 2) {
+    if (Array.isArray(args[i])) matched = args[i].includes(result);
+    else matched = args[i] === result;
+    if (matched) return evaluateStyle(args[i + 1], properties, zoom);
+  }
+  return evaluateStyle(args[args.length - 1], properties, zoom);
+}

package/src/vector-style/evaluateMath.js

@@ -0,0 +1,14 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateMath(op, args, properties, zoom) {
+  let i = 0, sum = 0;
+  if (op === '+') {
+    for (i = 0; i < args.length; i++) sum += evaluateStyle(args[i], properties, zoom);
+    return sum;
+  }
+  if (op === '-') {
+    if (args.length === 1) return -evaluateStyle(args[0], properties, zoom);
+    return evaluateStyle(args[0], properties, zoom) - evaluateStyle(args[1], properties, zoom);
+  }
+  throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+}

package/src/vector-style/evaluateMembership.js

@@ -0,0 +1,18 @@
+import { arrayContainsRange } from './arrayContainsRange.js';
+import { evaluateInput } from './evaluateInput.js';
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateMembership(op, args, properties, zoom, legacy) {
+  let target = null;
+  if (op === '!in') {
+    target = evaluateInput(args[0], properties, zoom, legacy);
+    return !arrayContainsRange(args, 1, args.length, target);
+  }
+  if (legacy) {
+    target = evaluateInput(args[0], properties, zoom, true);
+    return arrayContainsRange(args, 1, args.length, target);
+  }
+  const values = evaluateStyle(args[1], properties, zoom);
+  target = evaluateInput(args[0], properties, zoom, false);
+  return values.includes(target);
+}

package/src/vector-style/evaluateNegation.js

@@ -0,0 +1,13 @@
+import { evaluateInput } from './evaluateInput.js';
+import { evaluateMembership } from './evaluateMembership.js';
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateNegation(op, args, properties, zoom, legacy) {
+  if (op === '!') return !evaluateStyle(args[0], properties, zoom, legacy);
+  if (op === '!=') {
+    return evaluateInput(args[0], properties, zoom, legacy) !==
+      evaluateStyle(args[1], properties, zoom);
+  }
+  if (op === '!in') return evaluateMembership(op, args, properties, zoom, legacy);
+  throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+}

package/src/vector-style/evaluatePrimitive.js

@@ -0,0 +1,9 @@
+export function evaluatePrimitive(op, args, properties, zoom) {
+  switch (op) {
+    case 'literal': return args[0];
+    case 'get': return properties[args[0]];
+    case 'has': return Object.hasOwn(properties, args[0]);
+    case 'zoom': return zoom;
+      default: throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+  }
+}

package/src/vector-style/evaluateStep.js

@@ -0,0 +1,11 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateStep(args, properties, zoom) {
+  const result = evaluateStyle(args[0], properties, zoom);
+  let output = args[1], i = 0;
+  for (i = 2; i < args.length; i += 2) {
+    if (result < args[i]) break;
+    output = args[i + 1];
+  }
+  return evaluateStyle(output, properties, zoom);
+}

package/src/vector-style/evaluateStyle.js

@@ -0,0 +1,33 @@
+import { evaluateBoolean } from './evaluateBoolean.js';
+import { evaluateCoalesceOrCase } from './evaluateCoalesceOrCase.js';
+import { evaluateComparison } from './evaluateComparison.js';
+import { evaluateIExpression } from './evaluateIExpression.js';
+import { evaluateMath } from './evaluateMath.js';
+import { evaluateMatch } from './evaluateMatch.js';
+import { evaluateNegation } from './evaluateNegation.js';
+import { evaluatePrimitive } from './evaluatePrimitive.js';
+import { evaluateStep } from './evaluateStep.js';
+import { evaluateToExpression } from './evaluateToExpression.js';
+
+export function evaluateStyle(value, properties, zoom, legacy = false) {
+  if (!Array.isArray(value)) return value;
+  const op = value[0];
+  const args = value.slice(1);
+  const operation = String(op);
+  if (/^(?:literal|get|has|zoom)$/.test(operation)) {
+    return evaluatePrimitive(op, args, properties, zoom);
+  }
+  switch (operation[0]) {
+    case 'a': return evaluateBoolean(op, args, properties, zoom, legacy);
+    case '!': return evaluateNegation(op, args, properties, zoom, legacy);
+    case '=':
+    case '<':
+    case '>': return evaluateComparison(op, args, properties, zoom, legacy);
+    case 'i': return evaluateIExpression(op, args, properties, zoom, legacy);
+    case 't': return evaluateToExpression(op, args, properties, zoom, legacy);
+    case 'c': return evaluateCoalesceOrCase(op, args, properties, zoom, legacy);
+    case 'm': return evaluateMatch(args, properties, zoom);
+    case 's': return evaluateStep(args, properties, zoom);
+    default: return evaluateMath(op, args, properties, zoom);
+  }
+}

package/src/vector-style/evaluateToExpression.js

@@ -0,0 +1,14 @@
+import { evaluateStyle } from './evaluateStyle.js';
+
+export function evaluateToExpression(op, args, properties, zoom) {
+  if (op === 'to-boolean') return Boolean(evaluateStyle(args[0], properties, zoom));
+  if (op === 'to-number') {
+    let i = 0, number = 0;
+    for (i = 0; i < args.length; i++) {
+      number = Number(evaluateStyle(args[i], properties, zoom));
+      if (Number.isFinite(number)) return number;
+    }
+    throw /* alloc */ new Error('Invalid numeric style expression');
+  }
+  throw /* alloc */ new Error(`Unsupported vector style expression: ${op}`);
+}

package/src/vector-style/fillVectorPaint.js

@@ -0,0 +1,17 @@
+import { readPaintValue } from './readPaintValue.js';
+import { styleColor } from './styleColor.js';
+
+export function fillVectorPaint(paint, properties, zoom) {
+  const fill = styleColor(readPaintValue(paint, 'fill-color', '#000', properties, zoom));
+  const outline = readPaintValue(paint, 'fill-outline-color', null, properties, zoom);
+  const rgb = outline === null ? null : styleColor(outline);
+  const fillOpacity = readPaintValue(paint, 'fill-opacity', 1, properties, zoom) * fill[3];
+  const fillColor = /* alloc */ { r: fill[0] / 255, g: fill[1] / 255, b: fill[2] / 255 };
+  const color = rgb ? /* alloc */ { r: rgb[0] / 255, g: rgb[1] / 255, b: rgb[2] / 255 } : null;
+  return /* alloc */ {
+    fillColor,
+    fillOpacity,
+    color,
+    weight: 0.5
+  };
+}

package/src/vector-style/lineVectorPaint.js

@@ -0,0 +1,21 @@
+import { readPaintValue } from './readPaintValue.js';
+import { scaleDashArray } from './scaleDashArray.js';
+import { styleColor } from './styleColor.js';
+
+export function lineVectorPaint(layer, paint, properties, zoom) {
+  const weight = readPaintValue(paint, 'line-width', 1, properties, zoom);
+  const rgb = styleColor(readPaintValue(paint, 'line-color', '#000', properties, zoom));
+  const opacity = readPaintValue(paint, 'line-opacity', 1, properties, zoom) * rgb[3];
+  const dashArray = scaleDashArray(paint['line-dasharray'], weight, properties, zoom);
+  const lineCap = layer.layout?.['line-cap'] || 'butt';
+  const lineJoin = layer.layout?.['line-join'] || 'miter';
+  const color = /* alloc */ { r: rgb[0] / 255, g: rgb[1] / 255, b: rgb[2] / 255 };
+  return /* alloc */ {
+    color,
+    opacity,
+    weight,
+    dashArray,
+    lineCap,
+    lineJoin
+  };
+}

package/src/vector-style/parseFunctionalColor.js

@@ -0,0 +1,14 @@
+export function parseFunctionalColor(value) {
+  const match = /^rgba?\(([^)]+)\)$/.exec(value);
+  if (match) {
+    const values = match[1].split(',');
+    let i = 0, finite = true;
+    for (i = 0; i < values.length; i++) values[i] = Number(values[i]);
+    if (values.length === 3) values.push(1);
+    for (i = 0; i < values.length; i++) {
+      if (!Number.isFinite(values[i])) finite = false;
+    }
+    if (values.length === 4 && finite) return values;
+  }
+  throw /* alloc */ new Error(`Unsupported interpolated style color: ${value}`);
+}

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 });
+  }
+}