leaflet-city-mapper 0.0.2 → 0.0.3

package/src/utils/scheduledTrips.js

@@ -1,29 +0,0 @@
-/**
- * Trips of a frequency-based timetable (like GTFS frequencies.txt) underway at `date`, in the timetable's local time.
- * @param {{timeZone: string, duration: number, services: Array<{from: string, to: string, every?: number, months?: number[], weekdays?: number[]}>}} timetable
- * `duration` and `every` are minutes; `from`/`to` are 'HH:MM' first/last departures; months are 1-12, weekdays 0 (Sunday)-6.
- * @returns {Array<{id: string, departure: string, progress: number}>} `progress` is 0-1 along the lane.
- */
-
-export function scheduledTrips(date, { timeZone, duration, services }) {
-  const time = new Date(date);
-  if (!Number.isFinite(time.getTime())) throw new Error('Invalid date');
-  const clock = new Intl.DateTimeFormat('en-GB', {
-    timeZone, year: 'numeric', month: '2-digit', day: '2-digit',
-    hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
-  });
-  const parts = Object.fromEntries(clock.formatToParts(time).filter(p => p.type !== 'literal').map(p => [p.type, Number(p.value)]));
-  const minute = parts.hour * 60 + parts.minute + (parts.second + time.getUTCMilliseconds() / 1000) / 60;
-  const weekday = new Date(Date.UTC(parts.year, parts.month - 1, parts.day)).getUTCDay();
-  const minutes = clockTime => clockTime.split(':').reduce((hours, value) => hours * 60 + Number(value));
-  const departures = [];
-  for (const { from, to, every = Infinity, months, weekdays } of services) {
-    if (months?.includes(parts.month) === false || weekdays?.includes(weekday) === false) continue;
-    for (let departure = minutes(from); departure <= minutes(to); departure += every) departures.push(departure);
-  }
-  return departures.sort((a, b) => a - b).filter(departure => minute >= departure && minute < departure + duration).map(departure => ({
-    id: `${parts.year}-${parts.month}-${parts.day}-${departure}`,
-    departure: `${String(Math.floor(departure / 60)).padStart(2, '0')}:${String(departure % 60).padStart(2, '0')}`,
-    progress: (minute - departure) / duration,
-  }));
-}

package/src/utils/setGeoJSONData.js

@@ -1,11 +0,0 @@
-import { releaseArea } from './releaseArea.js';
-import { updateArea } from './updateArea.js';
-
-export function setGeoJSONData(layer, data) {
-  layer.options.data = data;
-  delete layer.options.url;
-  for (const area of layer._areas.values()) releaseArea(layer, area);
-  layer._areas.clear();
-  updateArea(layer);
-  return layer;
-}

package/src/utils/setHighlight.js

@@ -1,13 +0,0 @@
-import { update } from './update.js';
-
-/** Highlight a source vertex range in the shader; vertex colors stay untouched. */
-
-export function setHighlight(backend, feature) {
-  if (feature?.model) feature = null;
-  if (backend.highlightedFeature?.mesh === feature?.mesh &&
-    backend.highlightedFeature?.vertexStart === feature?.vertexStart) return;
-  if (backend.highlightedFeature) backend.highlightedFeature.mesh.highlight = null;
-  backend.highlightedFeature = feature;
-  if (feature) feature.mesh.highlight = [feature.vertexStart, feature.vertexEnd];
-  update(backend);
-}

package/src/utils/setPMTileOpacity.js

@@ -1,7 +0,0 @@
-import { setRasterOpacity } from './rasterTiles.js';
-
-export function setPMTileOpacity(backend, opacity) {
-  backend.options.opacity = opacity;
-  setRasterOpacity(backend, opacity);
-  return backend;
-}

package/src/utils/setPMTileZIndex.js

@@ -1,7 +0,0 @@
-import { setRasterZIndex } from './rasterTiles.js';
-
-export function setPMTileZIndex(backend, zIndex) {
-  backend.options.zIndex = zIndex;
-  setRasterZIndex(backend, zIndex);
-  return backend;
-}

package/src/utils/setVertexColor.js

@@ -1,14 +0,0 @@
-/**
- * Paints the vertices `[start, end)` of a mesh and marks its color buffer dirty.
- * @param {Object} mesh Layer-created mesh with a color attribute.
- * @param {number} start Inclusive vertex index, not an offset into the RGB array.
- * @param {number} end Exclusive vertex index.
- * @param {Object} color sRGB {r,g,b}, typically from parseColor().
- */
-
-export function setVertexColor(mesh, start, end, color) {
-  for (let i = start; i < end; i++) {
-    mesh.geometry.attributes.color.data.set([color.r, color.g, color.b], i * 3);
-  }
-  mesh.geometry.attributes.color.needsUpdate = true;
-}

package/src/utils/showFeature.js

@@ -1,27 +0,0 @@
-/** Update tooltip content/position and arbitrate cursor ownership across shared layers. */
-
-export function showFeature(backend, feature, event) {
-  const tooltip = backend._tooltip;
-  if (!tooltip) return;
-  if (feature) {
-    tooltip.replaceChildren(backend.options.tooltip(feature));
-    tooltip.hidden = false;
-    const rect = backend.container.getBoundingClientRect();
-    const x = event.clientX - rect.left, y = event.clientY - rect.top;
-    tooltip.style.left = `${x + tooltip.offsetWidth + 16 > rect.width ? x - tooltip.offsetWidth - 12 : x + 12}px`;
-    tooltip.style.top = `${y + tooltip.offsetHeight + 16 > rect.height ? y - tooltip.offsetHeight - 12 : y + 12}px`;
-  } else {
-    tooltip.hidden = true;
-  }
-  const shared = backend._shared;
-  if (shared) {
-    const visible = [...shared._layers].some(layer => layer._tooltip && !layer._tooltip.hidden);
-    if (visible) {
-      if (shared._cursor === undefined) shared._cursor = backend.container.style.cursor;
-      backend.container.style.cursor = 'pointer';
-    } else if (shared._cursor !== undefined) {
-      backend.container.style.cursor = shared._cursor;
-      delete shared._cursor;
-    }
-  }
-}

package/src/utils/skin.js

@@ -1,2 +0,0 @@
-// Pedestrian, about 1.77 m tall, prisms as in utils/vehicles.js (forward -z). Limbs hang from their pivot at y = 0.
-export const skin = [0.85, 0.64, 0.5], shirt = [0.75, 0.2, 0.15], trousers = [0.16, 0.2, 0.32], dark = [0.08, 0.07, 0.06];

package/src/utils/sortMeshes.js

@@ -1,12 +0,0 @@
-
-export function sortMeshes(meshes) {
-  return meshes.sort((a, b) => Number(Boolean(b.ground)) - Number(Boolean(a.ground)) ||
-    (a.ground && b.ground ? (a.renderOrder || 0) - (b.renderOrder || 0) ||
-      a.tile.coords.z - b.tile.coords.z : 0) ||
-    Number(a.program.transparent) - Number(b.program.transparent) ||
-    (a.program.transparent
-      ? (a.renderOrder || 0) - (b.renderOrder || 0) ||
-      b._sortDepth - a._sortDepth || a.id - b.id
-      : (a._sortDepth ?? 0) - (b._sortDepth ?? 0) || a.id - b.id)
-  );
-}

package/src/utils/terrainAtlas.js

@@ -1,21 +0,0 @@
-/** Float32 DEM atlas; missing samples retain the shader no-data sentinel. */
-
-export function terrainAtlas(tiles, bounds) {
-  const columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;
-  const elevations = new Float32Array(columns * rows * 65536).fill(-1e9);
-  let low = Infinity, high = -Infinity;
-  for (const [key, values] of tiles) {
-    const [x, y] = key.split('/').map(Number);
-    const start = (y - bounds.min.y) * 256 * columns * 256 + (x - bounds.min.x) * 256;
-    for (let row = 0; row < 256; row++) {
-      for (let column = 0; column < 256; column++) {
-        const value = values[row * 256 + column];
-        if (!Number.isFinite(value) || value <= -1000) continue;
-        elevations[start + row * columns * 256 + column] = value;
-        low = Math.min(low, value);
-        high = Math.max(high, value);
-      }
-    }
-  }
-  return { elevations, low, high };
-}

package/src/utils/terrainElevation.js

@@ -1,20 +0,0 @@
-/** Bilinear DEM sampling, with the original first-valid-neighbour no-data rule. */
-
-export function terrainElevation(point, tiles) {
-  const x = point.x - 0.5, y = point.y - 0.5;
-  const x0 = Math.floor(x), y0 = Math.floor(y);
-  const fx = x - x0, fy = y - y0;
-  const sample = (px, py) => {
-    const tileX = Math.floor(px / 256), tileY = Math.floor(py / 256);
-    const tile = tiles.get(`${tileX}/${tileY}`);
-    if (!tile) return null;
-    const elevation = tile[(py - tileY * 256) * 256 + px - tileX * 256];
-    return Number.isFinite(elevation) && elevation > -1000 ? elevation : null;
-  };
-  const values = [sample(x0, y0), sample(x0 + 1, y0), sample(x0, y0 + 1), sample(x0 + 1, y0 + 1)];
-  const valid = values.map((value, i) => Number.isFinite(value) ? i : -1).filter(i => i >= 0);
-  if (!valid.length) return null;
-  if (valid.length < 4) return values[valid[0]];
-  return (values[0] * (1 - fx) + values[1] * fx) * (1 - fy) +
-    (values[2] * (1 - fx) + values[3] * fx) * fy;
-}

package/src/utils/terrainGrid.js

@@ -1,23 +0,0 @@
-/** Unit tile grid; the vertex shader supplies the elevation. */
-
-export function terrainGrid(divisions) {
-  const positions = [], normals = [], uvs = [], indices = [];
-  for (let row = 0; row <= divisions; row++) {
-    for (let column = 0; column <= divisions; column++) {
-      positions.push(column / divisions, 0, row / divisions);
-      normals.push(0, 1, 0);
-      uvs.push(column / divisions, row / divisions);
-      if (row < divisions && column < divisions) {
-        const a = row * (divisions + 1) + column;
-        const b = a + 1, c = a + divisions + 1, d = c + 1;
-        indices.push(a, c, b, b, c, d);
-      }
-    }
-  }
-  return {
-    position: { size: 3, data: new Float32Array(positions) },
-    normal: { size: 3, data: new Float32Array(normals) },
-    uv: { size: 2, data: new Float32Array(uvs) },
-    index: { data: new Uint16Array(indices) },
-  };
-}

package/src/utils/tileId.js

@@ -1,18 +0,0 @@
-/** Cumulative Hilbert ID for an archive tile. */
-
-export function tileId(z, x, y) {
-  if (![z, x, y].every(Number.isInteger) || z < 0 || z > 26 ||
-    x < 0 || y < 0 || x >= 2 ** z || y >= 2 ** z) throw new Error('Invalid PMTiles tile coordinates');
-  let id = (4 ** z - 1) / 3;
-  const n = 2 ** z;
-  // Same cumulative Hilbert ordering used by build/pmtiles.js.
-  for (let s = n / 2; s >= 1; s /= 2) {
-    const rx = (x & s) ? 1 : 0, ry = (y & s) ? 1 : 0;
-    id += s * s * ((3 * rx) ^ ry);
-    if (!ry) {
-      if (rx) { x = n - 1 - x; y = n - 1 - y; }
-      [x, y] = [y, x];
-    }
-  }
-  return id;
-}

package/src/utils/toLanes.js

@@ -1,7 +0,0 @@
-// GeoJSON (Multi)LineStrings become lanes ({latlngs, properties, elevation?}); prepare() adds `points` ([x, z, ground]),
-// `lengths` and `length` in layer-local metres.
-
-export const toLanes = ({ features = [] }) => features.flatMap(({ geometry, properties }) => {
-  const lines = geometry?.type === 'LineString' ? [geometry.coordinates] : geometry?.type === 'MultiLineString' ? geometry.coordinates : [];
-  return lines.map(line => ({ latlngs: line.map(([lng, lat]) => [lat, lng]), properties: properties ?? {}, elevation: properties?.elevation }));
-});

package/src/utils/tooltip.js

@@ -1,6 +0,0 @@
-export const tooltip = ({ properties: p }) => {
-  const content = document.createElement('div');
-  content.style.whiteSpace = 'pre-line';
-  content.textContent = [p.name, p.departure && `Departure ${p.departure} ${p.timetable.timeZone}`, p.description].filter(Boolean).join('\n');
-  return content;
-};

package/src/utils/traffic.js

@@ -1,315 +0,0 @@
-import * as createMeshApi from './createMesh.js';
-import * as disposeMesh from './disposeMesh.js';
-import * as setHighlight from './setHighlight.js';
-import * as showFeature from './showFeature.js';
-import { update as updateScene } from './update.js';
-import { along } from './along.js';
-import { build } from './build.js';
-import { computeBounds } from './computeBounds.js';
-import { routeGeometry } from './routeGeometry.js';
-import { toLanes } from './toLanes.js';
-import { tripsAt } from './tripsAt.js';
-import { underEntry } from './underEntry.js';
-import { getElevation } from './getElevation.js';
-
-export function trafficNow(state) {
-  let control = { live: true };
-  state.layer._map?.eachLayer(other => { if (other.control?.time) control = other.control; });
-  return { live: control.live, time: control.live ? new Date() : control.time };
-}
-
-export function createTrafficMesh(state, data, featureFaces, material, usage = 0) {
-  const result = createMeshApi.createMesh(state.layer, data, material, usage);
-  result.extras.featureFaces = featureFaces;
-  return result;
-}
-
-export function disposeTrafficObject(state, object) {
-  if (!object) return;
-  if (state.layer.highlightedFeature?.mesh === object) {
-    setHighlight.setHighlight(state.layer, null);
-    state.layer.hoveredFeature = null;
-    showFeature.showFeature(state.layer, null);
-  };
-  disposeMesh.disposeMesh(state.layer, object);
-}
-
-export function failTraffic(state, error) {
-  state.status.textContent = `Error: ${error.message}`;
-  state.status.setAttribute('role', 'alert');
-  console.error('Traffic layer', error);
-}
-
-export function groundTraffic(state) {
-  const { layer, lanes } = state;
-  const terrain = layer._map._terrain3D?._terrainReady && layer._map._terrain3D, base = layer.root.position[1];
-  for (const lane of lanes) lane.points.forEach((point, i) => {
-    const elevation = terrain && (lane.elevation ?? getElevation(terrain, lane.latlngs[i]));
-    point[2] = Number.isFinite(elevation) && Number.isFinite(base) ? elevation - base : 0;
-  });
-  state.lanesDirty = true;
-  state.nextCheck = -Infinity;
-}
-
-export function prepareTraffic(state) {
-  const { layer, lanes } = state;
-  const crs = layer._map.options.crs, origin = crs.project(layer.location);
-  const metres = Math.cos(layer.location.lat * Math.PI / 180);
-  for (const lane of lanes) {
-    lane.points = lane.latlngs.map(([lat, lng]) => {
-      const point = crs.project(new L.LatLng(lat, lng));
-      return [(point.x - origin.x) * metres, -(point.y - origin.y) * metres, 0];
-    });
-    lane.lengths = [0];
-    for (let i = 1; i < lane.points.length; i++) {
-      lane.lengths.push(lane.lengths[i - 1] + Math.hypot(lane.points[i][0] - lane.points[i - 1][0], lane.points[i][1] - lane.points[i - 1][1]));
-    }
-    lane.length = lane.lengths.at(-1);
-  }
-  groundTraffic(state);
-  disposeTrafficObject(state, state.route);
-  state.route = null;
-  state.tripsKey = null;
-}
-
-export function drawTrafficRoute(state) {
-  state.route = createTrafficMesh(state, routeGeometry(state.lanes), [], { emissive: [0.03, 0.25, 0.3] });
-}
-
-export function rebuildTrafficMesh(state) {
-  const { trips, model, vertices } = state;
-  disposeTrafficObject(state, state.mesh);
-  state.mesh = null;
-  if (!trips.length) return;
-  const color = trips.flatMap((trip, i) => build(model(i)).color), count = color.length / 3;
-  state.mesh = createTrafficMesh(state, { position: color.map(() => 0), normal: color.map(() => 0), color },
-    trips.map((trip, i) => ({
-      id: trip.id, properties: trip.properties, faceStart: i * vertices / 3, faceEnd: (i + 1) * vertices / 3,
-      vertexStart: i * vertices, vertexEnd: (i + 1) * vertices
-    })), {}, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC);
-  state.mesh.geometry.drawRange.count = count;
-  trafficBounds(state);
-}
-
-export function trafficBounds(state) {
-  const extent = { attributes: { position: { data: state.lanes.flatMap(lane => lane.points.flatMap(([x, z, y]) => [x - 20, y, z - 20, x + 20, y + 5, z + 20])) } } };
-  computeBounds(extent);
-  state.mesh.geometry.bounds = extent.bounds;
-}
-
-export function destroyTrafficGpu(state) {
-  for (const buffer of [state.gpu?.params, state.gpu?.template, state.gpu?.points, state.gpu?.vehicles]) buffer?.destroy();
-  state.gpu = null;
-}
-
-export function trafficStorage(device, data) {
-  const buffer = device.createBuffer({ size: Math.max(16, data.byteLength), usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
-  device.queue.writeBuffer(buffer, 0, data);
-  return buffer;
-}
-
-export function rebaseTraffic(state) {
-  const { device } = state.layer.renderer;
-  if (state.gpu?.device !== device) {
-    destroyTrafficGpu(state);
-    state.gpu = {
-      device,
-      pipeline: device.createComputePipeline({ layout: 'auto', compute: { module: device.createShaderModule({ code: state.shader }), entryPoint: 'main' } }),
-      params: device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST }),
-      template: trafficStorage(device, new Float32Array([...state.template.position, ...state.template.normal])),
-    };
-    state.lanesDirty = true;
-  }
-  if (state.lanesDirty) {
-    const data = new Float32Array(state.lanes.reduce((count, lane) => count + lane.points.length, 0) * 4);
-    let offset = 0;
-    for (const lane of state.lanes) {
-      lane.start = offset / 4;
-      lane.points.forEach((point, i) => { data.set([point[0], point[1], point[2], lane.lengths[i]], offset); offset += 4; });
-    }
-    state.gpu.points?.destroy();
-    state.gpu.points = trafficStorage(device, data);
-    state.lanesDirty = false;
-  }
-  const data = new Float32Array(state.trips.length * 4), index = new Uint32Array(data.buffer);
-  state.trips.forEach((trip, i) => {
-    index[i * 4] = trip.lane.start;
-    index[i * 4 + 1] = trip.lane.points.length;
-    data[i * 4 + 2] = trip.distance;
-    data[i * 4 + 3] = trip.speed;
-    state.mesh.extras.featureFaces[i].properties = trip.properties;
-  });
-  if (state.gpu.vehicles?.size >= data.byteLength) device.queue.writeBuffer(state.gpu.vehicles, 0, data);
-  else {
-    state.gpu.vehicles?.destroy();
-    state.gpu.vehicles = trafficStorage(device, data);
-  }
-  const { position, normal } = state.mesh.geometry.attributes;
-  state.gpu.bindGroup = device.createBindGroup({
-    layout: state.gpu.pipeline.getBindGroupLayout(0),
-    entries: [state.gpu.params, state.gpu.template, state.gpu.points, state.gpu.vehicles, position.buffer, normal.buffer]
-      .map((buffer, binding) => ({ binding, resource: { buffer } })),
-  });
-}
-
-export function moveTraffic(state, seconds) {
-  const { device } = state.gpu;
-  state.paramFloats[0] = state.elapsed = seconds;
-  state.paramFloats[1] = state.side;
-  state.paramInts[2] = state.vertices;
-  state.paramInts[3] = state.trips.length * state.vertices;
-  device.queue.writeBuffer(state.gpu.params, 0, state.params);
-  const encoder = device.createCommandEncoder(), pass = encoder.beginComputePass();
-  pass.setPipeline(state.gpu.pipeline);
-  pass.setBindGroup(0, state.gpu.bindGroup);
-  pass.dispatchWorkgroups(Math.ceil(state.paramInts[3] / 64));
-  pass.end();
-  device.queue.submit([encoder.finish()]);
-  state.stale = true;
-}
-
-export function locateTraffic(state, trip) {
-  const { points, lengths, length } = trip.lane;
-  let distance = trip.distance + state.elapsed * trip.speed;
-  distance -= length * Math.floor(distance / length);
-  const { x, y, z, dx, dz } = along(points, lengths, distance);
-  return { x: x - dz * state.side, y, z: z + dx * state.side, dx, dz };
-}
-
-export function placeTraffic(state) {
-  if (!state.mesh || !state.stale) return;
-  state.stale = false;
-  const { position, normal } = state.mesh.geometry.attributes;
-  state.trips.forEach((trip, i) => {
-    const { x: cx, y, z: cz, dx, dz } = locateTraffic(state, trip);
-    for (let k = 0, o = i * state.stride; k < state.stride; k += 3, o += 3) {
-      const lx = state.template.position[k], lz = state.template.position[k + 2], nx = state.template.normal[k], nz = state.template.normal[k + 2];
-      position.data[o] = cx - lx * dz - lz * dx;
-      position.data[o + 1] = y + state.template.position[k + 1];
-      position.data[o + 2] = cz + lx * dx - lz * dz;
-      normal.data[o] = -nx * dz - nz * dx;
-      normal.data[o + 1] = state.template.normal[k + 1];
-      normal.data[o + 2] = nx * dx - nz * dz;
-    }
-  });
-}
-
-export function tickTraffic(state) {
-  state.frame = undefined;
-  if (!state.ready || !state.layer._map) return;
-  if (!state.layer.renderer) { state.frame = requestAnimationFrame(state.tick); return; }
-  if (state.mesh && !(state.mesh.geometry.attributes.position.buffer.usage & GPUBufferUsage.STORAGE)) {
-    state.tripsKey = null;
-    state.nextCheck = -Infinity;
-  }
-  const { live, time } = trafficNow(state), ms = time?.getTime(), valid = Number.isFinite(ms);
-  let changed = false;
-  if (!live || !valid || !(ms >= state.rebasedAt && ms < state.nextCheck)) {
-    let text;
-    try {
-      state.trips = valid ? tripsAt(time, state.lanes, state.velocity) : [];
-      text = !valid ? 'Select a valid simulation date' : !state.loaded ? 'Loading…' :
-        `${state.trips.length} vehicle${state.trips.length === 1 ? '' : 's'}${state.loaded.note ? ` · ${state.loaded.note}` : ''}`;
-    } catch (error) { return failTraffic(state, error); }
-    state.rebasedAt = ms;
-    state.nextCheck = ms + 1000;
-    const key = state.trips.map(trip => trip.id).join();
-    changed = key !== state.tripsKey || (state.outline && !state.route && state.lanes.length);
-    if (state.outline && !state.route && state.lanes.length) drawTrafficRoute(state);
-    if (key !== state.tripsKey) { rebuildTrafficMesh(state); state.tripsKey = key; }
-    if (state.mesh) rebaseTraffic(state);
-    if (state.status.textContent !== text) state.status.textContent = text;
-    state.status.removeAttribute('role');
-  }
-  if (state.mesh) moveTraffic(state, (ms - state.rebasedAt) / 1000);
-  if (state.mesh && state.lights && (!live || !(performance.now() - state.litAt < 100))) {
-    state.litAt = performance.now();
-    state.mesh.extras.lights = state.trips.flatMap(trip => {
-      const { x, y, z, dx, dz } = locateTraffic(state, trip);
-      return state.lights.map(({ position: [lx, ly, lz], ...light }) => ({ ...light, position: [x - lx * dz - lz * dx, y + ly, z + lx * dx - lz * dz] }));
-    });
-  }
-  if (state.mesh || changed) updateScene(state.layer);
-  if (live && valid) state.frame = requestAnimationFrame(state.tick);
-}
-
-export async function fetchTrafficLanes(state, time, signal) {
-  const href = new URL(state.url, document.baseURI).href;
-  if (/\.m?js(?:[?#]|$)/i.test(state.url)) return (await import(href)).default(time, state.layer, signal);
-  if (!state.file) {
-    const response = await fetch(href, { signal });
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-    state.file = await response.json();
-  }
-  return state.file;
-}
-
-export function loadedTrafficLanes(state, signal, data) {
-  if (signal.aborted || !state.layer._map || data === state.loaded) return;
-  state.loaded = data;
-  state.lanes = toLanes(data);
-  prepareTraffic(state);
-  if (!state.frame) state.tick();
-}
-
-export function failedTrafficLoad(state, error) {
-  if (error.name !== 'AbortError') failTraffic(state, error);
-}
-
-export function loadTraffic(state) {
-  const { time } = trafficNow(state);
-  if (!Number.isFinite(time?.getTime())) return;
-  state.request?.abort();
-  const { signal } = state.request = new AbortController();
-  fetchTrafficLanes(state, time, signal).then(
-    loadedTrafficLanes.bind(null, state, signal),
-    failedTrafficLoad.bind(null, state),
-  );
-}
-
-export function updateTraffic(state, event) {
-  if (event?.layer === state.layer) return;
-  cancelAnimationFrame(state.frame);
-  loadTraffic(state);
-  state.tick();
-}
-
-export function updateTrafficTerrain(state) {
-  if (!state.lanes.length) return;
-  groundTraffic(state);
-  disposeTrafficObject(state, state.route);
-  state.route = null;
-  if (state.mesh) trafficBounds(state);
-  if (!state.frame) state.tick();
-}
-
-export function startTraffic(state) {
-  state.layer._map.off('simulationtimechange layerremove', state.update).on('simulationtimechange layerremove', state.update);
-  state.layer._map.off('terrainchange', state.terrain).on('terrainchange', state.terrain);
-  underEntry(state.layer, state.status);
-  state.update();
-}
-
-export function readyTraffic(state) {
-  state.ready = true;
-  if (state.layer._map) startTraffic(state);
-}
-
-export function addTraffic(state) {
-  if (state.ready) startTraffic(state);
-}
-
-export function removeTraffic(state) {
-  state.request?.abort();
-  cancelAnimationFrame(state.frame);
-  state.frame = undefined;
-  state.layer._map.off('simulationtimechange layerremove', state.update).off('terrainchange', state.terrain);
-  disposeTrafficObject(state, state.mesh);
-  disposeTrafficObject(state, state.route);
-  state.mesh = state.route = null;
-  delete state.layer._beforeRaycast;
-  destroyTrafficGpu(state);
-  state.lanes = [];
-  state.trips = [];
-  state.tripsKey = state.loaded = null;
-}

package/src/utils/traverse.js

@@ -1,6 +0,0 @@
-/** Depth-first walk; a truthy callback result skips that node's descendants. */
-
-export function traverse(node, callback) {
-  if (callback(node)) return;
-  for (const child of node.children) traverse(child, callback);
-}

package/src/utils/treeGeometry.js

@@ -1,45 +0,0 @@
-import { parseColor } from "./parseColor.js";
-
-/** Low-poly tree, sharing the source block's buffers, picking and terrain offset. */
-
-export function treeGeometry(point, style, addTriangle) {
-  const { top, bottom = 0, trunkRadius, crownRadius, crownBottom, crownShape = 'round' } = style;
-  if (![trunkRadius, crownRadius, crownBottom].every(Number.isFinite) ||
-    trunkRadius <= 0 || crownRadius < trunkRadius || crownBottom <= bottom || crownBottom >= top ||
-    !['round', 'cone'].includes(crownShape)) {
-    throw new Error('Invalid tree dimensions or crown shape');
-  }
-  const trunk = parseColor(style.trunkColor ?? 0x72513a);
-  const crown = parseColor(style.color ?? 0x4f823b);
-  const ring = radius => Array.from({ length: 8 }, (_, i) => ({
-    x: point.x + Math.cos(i * Math.PI / 4) * radius,
-    y: point.y + Math.sin(i * Math.PI / 4) * radius,
-    ground: point.ground,
-  }));
-  const surface = (lowRadius, low, highRadius, high, color) => {
-    const lower = ring(lowRadius), upper = ring(highRadius);
-    for (let i = 0; i < 8; i++) {
-      const next = (i + 1) % 8;
-      const angle = (i + 0.5) * Math.PI / 4;
-      const slope = (lowRadius - highRadius) / (high - low);
-      const length = Math.hypot(1, slope);
-      const nx = Math.cos(angle) / length, ny = slope / length, nz = -Math.sin(angle) / length;
-      if (lowRadius) addTriangle(lower[i], low, lower[next], low, upper[next], high, nx, ny, nz, color);
-      if (highRadius) addTriangle(lower[i], low, upper[next], high, upper[i], high, nx, ny, nz, color);
-    }
-  };
-  surface(trunkRadius, bottom, trunkRadius, crownBottom + (top - crownBottom) * 0.25, trunk);
-  if (crownShape === 'cone') {
-    const base = ring(crownRadius);
-    for (let i = 0; i < 8; i++) addTriangle(point, crownBottom, base[i], crownBottom,
-      base[(i + 1) % 8], crownBottom, 0, -1, 0, crown);
-    surface(crownRadius, crownBottom, 0, top, crown);
-  } else {
-    const profile = [[0, 0], [0.35, 0.8], [0.6, 1], [0.85, 0.7], [1, 0]];
-    for (let i = 1; i < profile.length; i++) {
-      const [low, lr] = profile[i - 1], [high, hr] = profile[i];
-      surface(lr * crownRadius, crownBottom + low * (top - crownBottom),
-        hr * crownRadius, crownBottom + high * (top - crownBottom), crown);
-    }
-  }
-}