leaflet-city-mapper 0.0.2 → 0.0.3

package/src/utils/decodeModel.js

@@ -1,43 +0,0 @@
-/** Decode a static glTF JSON document or GLB v2 container. */
-
-export function decodeModel(data) {
-  const view = new DataView(data), decoder = new TextDecoder();
-  let description;
-  if (view.getUint32(0, true) === 0x46546c67) {
-    // Decode GLB v2 chunks; unknown types are skipped.
-    if (view.getUint32(4, true) !== 2 || view.getUint32(8, true) !== data.byteLength) {
-      throw new Error('Invalid GLB header');
-    }
-    let binary;
-    for (let offset = 12; offset < data.byteLength;) {
-      if (offset + 8 > data.byteLength) {
-        throw new Error('Truncated GLB chunk');
-      }
-      const length = view.getUint32(offset, true), type = view.getUint32(offset + 4, true);
-      offset += 8;
-      if (offset + length > data.byteLength) {
-        throw new Error('Truncated GLB data');
-      }
-      const chunk = data.slice(offset, offset + length);
-      if (type === 0x4e4f534a) {
-        description = JSON.parse(decoder.decode(chunk));
-      }
-      if (type === 0x004e4942) {
-        binary = chunk;
-      }
-      offset += length;
-    }
-    if (!description) {
-      throw new Error('Missing GLB JSON');
-    }
-    if (binary) {
-      description.buffers[0].binary = binary;
-    }
-  } else {
-    description = JSON.parse(decoder.decode(data));
-  }
-  if (description.skins?.length || description.animations?.length || description.extensionsRequired?.length || description.meshes?.some(mesh => mesh.primitives.some(primitive => primitive.targets || (primitive.mode !== undefined && primitive.mode !== 4)))) {
-    throw new Error('Layer3D supports static triangle glTF models without required extensions');
-  }
-  return description;
-}

package/src/utils/destroyTexture.js

@@ -1,7 +0,0 @@
-
-export function destroyTexture(layer, texture) {
-  layer.renderer.device.queue.onSubmittedWorkDone().then(() => texture.destroy(), error => {
-    layer.fire('error', { error });
-    texture.destroy();
-  });
-}

package/src/utils/disposeMesh.js

@@ -1,13 +0,0 @@
-import { setParent } from './setParent.js';
-import { update } from './update.js';
-
-export function disposeMesh(backend, mesh) {
-  if (!mesh) {
-    return;
-  }
-  setParent(mesh, null);
-  update(backend);
-  for (const attribute of Object.values(mesh.geometry.attributes)) {
-    attribute.buffer.destroy();
-  }
-}

package/src/utils/drawGeometry.js

@@ -1,122 +0,0 @@
-/** Upload retained CPU data and draw one mesh in the active WebGPU render pass. */
-
-export function drawGeometry(backend, mesh, pass, cullMode, frontFace) {
-  const { geometry, program } = mesh;
-  const device = backend.renderer.device;
-  const pipelineKey = `${cullMode}:${frontFace}`;
-  let pipeline = program.pipelineCache.get(pipelineKey);
-  if (!pipeline) {
-    pipeline = device.createRenderPipeline({
-      layout: program.pipelineLayout,
-      vertex: {
-        module: program.vertex,
-        entryPoint: 'vertexMain',
-        buffers: program.vertexBuffers,
-      },
-      fragment: {
-        module: program.fragment,
-        entryPoint: 'fragmentMain',
-        targets: [{
-          format: backend.renderer.format,
-          blend: program.transparent ? {
-            color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-          } : undefined,
-          writeMask: GPUColorWrite.ALL,
-        }],
-      },
-      primitive: { topology: 'triangle-list', cullMode, frontFace },
-      depthStencil: {
-        format: 'depth24plus',
-        depthWriteEnabled: program.depthWrite,
-        depthCompare: program.depthTest === false ? 'always' : 'less-equal',
-      },
-    });
-    program.pipelineCache.set(pipelineKey, pipeline);
-  }
-
-  const uniforms = program.uniforms;
-  const renderer = backend.renderer;
-  const offset = renderer.uniformSlot++ * 256;
-  const data = renderer.uniformData, base = offset / 4;
-  data.set(mesh.worldMatrix, base);
-  data.set(uniforms.baseColor.value, base + 16);
-  data[base + 19] = 1;
-  data[base + 20] = uniforms.metallic.value;
-  data[base + 21] = uniforms.roughness.value;
-  data[base + 22] = uniforms.opacity.value * (mesh.ground ? mesh._appearance ?? 1 : 1);
-  data[base + 23] = uniforms.alphaCutoff.value;
-  data.set(uniforms.emissive.value, base + 24);
-  data[base + 27] = uniforms.occlusionStrength.value;
-  data[base + 28] = mesh.terrain?.[0] ?? 0;
-  data[base + 29] = mesh.terrain?.[1] ?? 0;
-  data[base + 30] = mesh.terrain?.[2] ?? 0;
-  data[base + 31] = mesh.terrain?.[3] ?? 0;
-  data[base + 32] = mesh.highlight?.[0] ?? 0;
-  data[base + 33] = mesh.highlight?.[1] ?? 0;
-  data[base + 34] = program.nightSparkle ? data[55] : 0;
-  data[base + 35] = mesh.ground ? 1 : mesh._appearance ?? 1;
-
-  const textures = mesh._textures ||= [];
-  textures.length = 0;
-  for (const binding of program.bindings) {
-    const texture = uniforms[binding.name]?.value;
-    if (!texture) throw new Error(`Missing Layer3D texture: ${binding.name}`);
-    if (texture.uploaded !== texture.image) {
-      device.queue.copyExternalImageToTexture(
-        { source: texture.image, flipY: Boolean(texture.flipY) },
-        { texture: texture.texture },
-        [texture.image.width, texture.image.height]
-      );
-      texture.uploaded = texture.image;
-    }
-    textures.push(texture);
-  }
-  let bindingsChanged = !mesh.bindGroup || mesh.boundBuffer !== renderer.uniformBuffer ||
-    textures.length !== mesh.boundTextures.length;
-  for (let i = 0; !bindingsChanged && i < textures.length; i++) {
-    if (textures[i].texture !== mesh.boundTextures[i][0] ||
-      textures[i].sampler !== mesh.boundTextures[i][1]) bindingsChanged = true;
-  }
-  if (bindingsChanged) {
-    const entries = [
-      { binding: 0, resource: { buffer: renderer.uniformBuffer, size: 144 } },
-      { binding: 1, resource: { buffer: renderer.uniformBuffer, size: 240 } },
-    ];
-    if (program.terrain) entries.push({ binding: 2, resource: program.terrain.texture.createView() });
-    mesh.boundBuffer = renderer.uniformBuffer;
-    const boundTextures = mesh.boundTextures ||= [];
-    boundTextures.length = textures.length;
-    for (let i = 0; i < textures.length; i++) {
-      const binding = program.bindings[i], texture = textures[i];
-      entries.push({ binding: binding.texture, resource: texture.texture.createView() });
-      entries.push({ binding: binding.sampler, resource: texture.sampler });
-      boundTextures[i] ||= [];
-      boundTextures[i][0] = texture.texture;
-      boundTextures[i][1] = texture.sampler;
-    }
-    mesh.bindGroup = device.createBindGroup({
-      layout: program.bindGroupLayout,
-      entries,
-    });
-  }
-  pass.setPipeline(pipeline);
-  pass.setBindGroup(0, mesh.bindGroup, [offset]);
-  pass.setVertexBuffer(0, geometry.attributes.position.buffer);
-  pass.setVertexBuffer(1, geometry.attributes.normal.buffer);
-  if (geometry.attributes.color) pass.setVertexBuffer(2, geometry.attributes.color.buffer);
-  if (geometry.attributes.uv) pass.setVertexBuffer(3, geometry.attributes.uv.buffer);
-  for (const attribute of Object.values(geometry.attributes)) {
-    if (!attribute.needsUpdate) continue;
-    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-    attribute.needsUpdate = false;
-    geometry.bounds = null;
-  }
-  const index = geometry.attributes.index;
-  if (index) {
-    pass.setIndexBuffer(index.buffer, index.indexFormat);
-    pass.drawIndexed(geometry.drawRange.count, 1, geometry.drawRange.start, 0, 0);
-  } else {
-    pass.draw(geometry.drawRange.count, 1, geometry.drawRange.start, 0);
-  }
-}

package/src/utils/elevationWGSL.js

@@ -1,27 +0,0 @@
-/**
- * WGSL twin of getElevation for the vertex shader: bilinear DEM pixels, or the first valid
- * neighbour near no-data (stored as -1e9), else `base`. Expects `dem: texture_2d<f32>`.
- */
-export const elevationWGSL = `
-  fn demSample(pixel: vec2<i32>) -> f32 {
-    if (any(pixel < vec2<i32>(0)) || any(pixel >= vec2<i32>(textureDimensions(dem)))) { return -1e9; }
-    return textureLoad(dem, pixel, 0).r;
-  }
-  fn elevation(pixel: vec2<f32>, base: f32) -> f32 {
-    let p = pixel - vec2<f32>(0.5);
-    let f = fract(p);
-    let i = vec2<i32>(floor(p));
-    let v00 = demSample(i);
-    let v10 = demSample(i + vec2<i32>(1, 0));
-    let v01 = demSample(i + vec2<i32>(0, 1));
-    let v11 = demSample(i + vec2<i32>(1, 1));
-    if (v00 > -1000.0 && v10 > -1000.0 && v01 > -1000.0 && v11 > -1000.0) {
-      return mix(mix(v00, v10, f.x), mix(v01, v11, f.x), f.y);
-    }
-    if (v00 > -1000.0) { return v00; }
-    if (v10 > -1000.0) { return v10; }
-    if (v01 > -1000.0) { return v01; }
-    if (v11 > -1000.0) { return v11; }
-    return base;
-  }
-`;

package/src/utils/emptyNode.js

@@ -1,9 +0,0 @@
-/** A fresh, empty scene-graph node. */
-export const emptyNode = () => ({
-  position: [0, 0, 0],
-  rotation: [0, 0, 0],
-  scale: [1, 1, 1],
-  worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-  children: [],
-  visible: true,
-});

package/src/utils/endZoom.js

@@ -1,15 +0,0 @@
-import { update } from "./update.js";
-
-/** Stop using the outgoing level after zoomend; the next redraw uses current tiles. */
-
-export function endZoom() {
-  const backend = this;
-  for (const animation of backend._zoomTransitions?.keys() || []) animation.finish();
-  backend._zoomTransitions = null;
-  backend._zoomView = null;
-  delete backend._map._cameraView;
-  backend._map.getContainer().classList.remove('leaflet-camera-zoom');
-  backend._map._updateCameraOverlays();
-  backend._zoomLevel = null;
-  update(backend);
-}

package/src/utils/findFeature.js

@@ -1,49 +0,0 @@
-import { raycast } from './raycast.js';
-
-/**
- * Translate a geometry hit into a configured model or batched source feature.
- * Sorted half-open face ranges permit binary search without a feature per triangle.
- * @returns {PickedFeature|null}
- */
-
-export function findFeature(backend, event) {
-  if (!backend.root || !backend.camera) {
-    return null;
-  }
-  for (const hit of raycast(backend, event, backend.root.children, Boolean(backend.model))) {
-    if (backend.model) {
-      let object = hit.object;
-      while (object && object !== backend.model) {
-        object = object.parent;
-      }
-      if (object === backend.model) {
-        return {
-          id: backend.model.id, properties: backend.model.extras,
-          model: backend.model, mesh: hit.object, point: hit.point
-        };
-      }
-    }
-    const ranges = hit.object.extras?.featureFaces;
-    if (!ranges) {
-      continue;
-    }
-    let low = 0,
-       high = ranges.length - 1;
-    while (low <= high) {
-      const middle = (low + high) >> 1;
-      const range = ranges[middle];
-      if (hit.faceIndex < range.faceStart) {
-        high = middle - 1;
-      } else if (hit.faceIndex >= range.faceEnd) {
-        low = middle + 1;
-      } else {
-        return {
-          ...range,
-          mesh: hit.object,
-          point: hit.point
-        };
-      }
-    }
-  }
-  return null;
-}

package/src/utils/geometry.js

@@ -1,2 +0,0 @@
-
-

package/src/utils/getElevation.js

@@ -1,10 +0,0 @@
-import { bridgeElevation } from './bridgeElevation.js';
-import { terrainElevation } from './terrainElevation.js';
-
-/** @param {L.LatLng|L.Point} location LatLng, or a pixel point at the terrain zoom. */
-
-export function getElevation(backend, location) {
-  if (!backend._map || !backend._terrainReady) return null;
-  const point = location instanceof L.Point ? location : backend._map.project(location, backend._terrainZoom);
-  return bridgeElevation(point, backend._bridges) ?? terrainElevation(point, backend._terrainTiles);
-}

package/src/utils/getZxy.js

@@ -1,76 +0,0 @@
-import { decodeDirectory } from './decodeDirectory.js';
-import { decompress } from './decompress.js';
-import { tileId } from './tileId.js';
-import { read } from './read.js';
-import { getHeader } from './getHeader.js';
-
-/** Nearest directory entry at/before the Hilbert ID, then follow leaf pointers. */
-
-export async function getZxy(backend, z, x, y, signal) {
-  if (backend.options.archive && backend.options.archive !== backend && backend.options.archive.getZxy) {
-    return backend.options.archive.getZxy(z, x, y, signal);
-  }
-  const id = tileId(z, x, y);
-  signal?.throwIfAborted();
-  const header = await getHeader(backend);
-  signal?.throwIfAborted();
-  if (z < header.minZoom || z > header.maxZoom) {
-    return;
-  }
-  let offset = header.rootDirectoryOffset, length = header.rootDirectoryLength;
-  const visited = new Set();
-  for (let depth = 0; depth < 4; depth++) {
-    if (visited.has(offset)) {
-      throw new Error('Cyclic PMTiles directory');
-    }
-    visited.add(offset);
-    const key = `${offset}:${length}`;
-    if (!backend._directories.has(key)) {
-      if (backend._directories.size >= 32) {
-        backend._directories.delete(backend._directories.keys().next().value);
-      }
-      const pending = read(backend, offset, length)
-        .then(data => decompress(data, header.internalCompression))
-        .then(decodeDirectory)
-        .catch(error => {
-          if (backend._directories.get(key) === pending) {
-            backend._directories.delete(key);
-          }
-          throw error;
-        });
-      backend._directories.set(key, pending);
-    }
-    const entries = await backend._directories.get(key);
-    signal?.throwIfAborted();
-    let low = 0, high = entries.length - 1;
-    while (low <= high) {
-      const mid = (low + high) >> 1;
-      if (entries[mid].tileId <= id) {
-        low = mid + 1;
-      } else {
-        high = mid - 1;
-      }
-    }
-    const entry = entries[high];
-    if (!entry) {
-      return;
-    }
-    if (entry.runLength) {
-      if (id - entry.tileId >= entry.runLength) {
-        return;
-      }
-      if (entry.offset + entry.length > header.tileDataLength) {
-        throw new Error('PMTiles tile outside data section');
-      }
-      const data = await decompress(await read(backend, header.tileDataOffset + entry.offset, entry.length, signal), header.tileCompression);
-      signal?.throwIfAborted();
-      return { data };
-    }
-    if (entry.offset + entry.length > header.leafDirectoryLength) {
-      throw new Error('PMTiles directory outside leaf section');
-    }
-    offset = header.leafDirectoryOffset + entry.offset;
-    length = entry.length;
-  }
-  throw new Error('PMTiles directory depth exceeds four levels');
-}

package/src/utils/glass.js

@@ -1 +0,0 @@
-export const glass = [0.12, 0.15, 0.18], tyre = [0.05, 0.05, 0.05];

package/src/utils/hit.js

@@ -1,41 +0,0 @@
-import { CELL } from './CELL.js';
-import { collider } from './collider.js';
-import { computeBounds } from './computeBounds.js';
-import { horizontalRay } from './horizontalRay.js';
-import { traverse } from './traverse.js';
-import { updateWorldMatrix } from './updateWorldMatrix.js';
-
-// Horizontal normal of the nearest wall faced within `reach` metres of the feet at world (x, y, z), walking along
-// the unit (dx, dz); knee and chest rays, so arches and tree crowns above the head let the walker through.
-// ponytail: traffic vehicles and boats move on the GPU and are not obstacles.
-
-export function hit(layer, x, y, z, dx, dz, reach) {
-  const skip = other => other === layer || ['terrain', 'traffic'].includes(other._type);
-  updateWorldMatrix(layer.scene);
-  let best = reach, found = null;
-  for (const other of layer._shared._layers) {
-    if (skip(other)) continue;
-    traverse(other.root, mesh => {
-      if (!mesh.visible) return true;
-      if (!mesh.geometry?.attributes?.position?.data || mesh.program?.depthTest === false) return;
-      if (!mesh.geometry.bounds) computeBounds(mesh.geometry);
-      const m = mesh.worldMatrix, { center: k, radius } = mesh.geometry.bounds;
-      if (Math.hypot(m[0] * k[0] + m[4] * k[1] + m[8] * k[2] + m[12] - x, m[2] * k[0] + m[6] * k[1] + m[10] * k[2] + m[14] - z) >
-        radius * Math.hypot(m[0], m[1], m[2]) + reach) return;
-      const c = collider(mesh), ox = x - m[12] + c.origin[0], oy = y - m[13] + c.origin[1], oz = z - m[14] + c.origin[2];
-      const seen = new Set();
-      for (let ix = Math.floor(Math.min(ox, ox + dx * reach) / CELL); ix <= Math.floor(Math.max(ox, ox + dx * reach) / CELL); ix++)
-        for (let iz = Math.floor(Math.min(oz, oz + dz * reach) / CELL); iz <= Math.floor(Math.max(oz, oz + dz * reach) / CELL); iz++)
-          for (const t of c.cells.get(ix + ',' + iz) || []) {
-            // Walls are one-way: walking out of a building (e.g. starting inside one) is allowed.
-            if (seen.has(t) || dx * c.nrm[t * 2] + dz * c.nrm[t * 2 + 1] >= 0) continue;
-            seen.add(t);
-            for (const height of [0.4, 1.5]) {
-              const d = horizontalRay(c.tri, t, ox, oy + height, oz, dx, dz);
-              if (d >= 0 && d < best) { best = d; found = [c.nrm[t * 2], c.nrm[t * 2 + 1]]; }
-            }
-          }
-    });
-  }
-  return found;
-}

package/src/utils/initSunlight.js

@@ -1,9 +0,0 @@
-import { onAddSun } from './onAddSun.js';
-import { onRemoveSun } from './onRemoveSun.js';
-
-// Sun/moon clock control and sky colours; the control is created on first add (`layer.control`).
-export function initSunlight(layer, options) {
-  L.Util.setOptions(layer, options);
-  layer.onAdd = map => onAddSun(layer, map);
-  layer.onRemove = () => onRemoveSun(layer);
-}

package/src/utils/initTerrain.js

@@ -1,19 +0,0 @@
-import { onTerrainRemove } from './onTerrainRemove.js';
-import { onTerrainAdd } from './onTerrainAdd.js';
-
-/**
- * Renders IGN Float32 DEM tiles and PMTiles raster basemaps in the shared WebGPU scene.
- * Source options: `url` (single-zoom Float32 PMTiles DEM); `bridges` (optional GeoJSON deck polygons with Z, see _addBridges).
- */
-export function initTerrain(layer, options) {
-  const terrainSource = options.url;
-  const layerOptions = { ...options };
-  delete layerOptions.url;
-  layer._init3D(layerOptions);
-  layer.terrainSource = terrainSource;
-  layer._terrainTiles = new Map();
-  layer._rasterTiles = new Map();
-  layer._terrainReady = false;
-  layer.onAdd = map => onTerrainAdd(layer, map);
-  layer.onRemove = map => onTerrainRemove(layer, map);
-}

package/src/utils/initTraffic.js

@@ -1,93 +0,0 @@
-/**
- * Vehicles moving along GeoJSON lanes; a compute pass places them on the GPU every frame.
- * Source options:
- * - `url`: GeoJSON (Multi)LineStrings, or a JS module whose default export `(time, layer, signal)` returns them (time-dependent data);
- * - `vehicle`: 'car' (default) or 'boat'; `side`: offset right of the lane centreline in metres (vehicle default);
- * - `speed`: m/s of `flow` lanes; `outline`: draw the lanes.
- * Lane properties: `flow` (vehicles/h) or `timetable` (see scheduledTrips.js), optional fixed `elevation`
- * in metres, `name`/`description` for the default tooltip. The status line (vehicle count, then the FeatureCollection `note`) sits under the layer's entry in the layers control.
- * The 'sunlight' layer on the same map drives the time; without one, vehicles run live.
- */
-import { build } from './build.js';
-import { tooltip } from './tooltip.js';
-import { speed } from './speed.js';
-import { vehicles } from './vehicles.js';
-import {
-  addTraffic,
-  placeTraffic,
-  removeTraffic,
-  readyTraffic,
-  tickTraffic,
-  updateTraffic,
-  updateTrafficTerrain,
-} from './traffic.js';
-
-export function initTraffic(layer, { url, vehicle = 'car', side, outline, speed: velocity = speed, ...options } = {}) {
-  const { model, lights, side: defaultSide } = vehicles[vehicle];
-  side ??= defaultSide;
-  layer._init3D({
-    tooltip,
-    nightLight: Boolean(lights),
-    ...options,
-  });
-  const status = L.DomUtil.create('small', 'traffic-status');
-  status.style.cssText = 'display:block;max-width:200px;margin:0 0 4px 20px;color:#555;';
-  const template = build(model(0)), stride = template.position.length, vertices = stride / 3;
-  const params = new ArrayBuffer(16), paramFloats = new Float32Array(params), paramInts = new Uint32Array(params);
-  const state = {
-    layer, url, model, lights, side, outline, velocity, status, template, stride, vertices,
-    params, paramFloats, paramInts,
-    ready: false, frame: undefined, request: undefined, lanes: [], tripsKey: undefined,
-    mesh: undefined, route: undefined, litAt: -Infinity,
-    trips: [], rebasedAt: 0, nextCheck: -Infinity, elapsed: 0, gpu: null,
-    lanesDirty: true, stale: false, loaded: undefined, file: undefined,
-  };
-  // Lane points are [x, z, ground, cumulative length]. Mirrors along() and place().
-  const shader = `
-    struct Params { seconds: f32, side: f32, vertices: u32, total: u32 }
-    struct Vehicle { start: u32, count: u32, base: f32, speed: f32 }
-    @group(0) @binding(0) var<uniform> params: Params;
-    @group(0) @binding(1) var<storage, read> model: array<f32>;
-    @group(0) @binding(2) var<storage, read> points: array<vec4f>;
-    @group(0) @binding(3) var<storage, read> vehicles: array<Vehicle>;
-    @group(0) @binding(4) var<storage, read_write> position: array<f32>;
-    @group(0) @binding(5) var<storage, read_write> normal: array<f32>;
-    @compute @workgroup_size(64)
-    fn main(@builtin(global_invocation_id) id: vec3u) {
-      let v = id.x;
-      if (v >= params.total) { return; }
-      let vehicle = vehicles[v / params.vertices];
-      let last = vehicle.start + vehicle.count - 1u;
-      let length = points[last].w;
-      var s = vehicle.base + params.seconds * vehicle.speed;
-      s -= length * floor(s / length);
-      var i = vehicle.start + 1u;
-      while (i < last && points[i].w < s) { i++; }
-      let a = points[i - 1u];
-      let b = points[i];
-      let d = select(b.w - a.w, 1.0, b.w == a.w);
-      let t = (s - a.w) / d;
-      let dx = (b.x - a.x) / d;
-      let dz = (b.y - a.y) / d;
-      let cx = a.x + (b.x - a.x) * t - dz * params.side;
-      let cz = a.y + (b.y - a.y) * t + dx * params.side;
-      let y = a.z + (b.z - a.z) * t;
-      let k = (v % params.vertices) * 3u;
-      let n = params.vertices * 3u + k;
-      let o = v * 3u;
-      position[o] = cx - model[k] * dz - model[k + 2u] * dx;
-      position[o + 1u] = y + model[k + 1u];
-      position[o + 2u] = cz + model[k] * dx - model[k + 2u] * dz;
-      normal[o] = -model[n] * dz - model[n + 2u] * dx;
-      normal[o + 1u] = model[n + 1u];
-      normal[o + 2u] = model[n] * dx - model[n + 2u] * dz;
-    }`;
-  state.shader = shader;
-  state.tick = tickTraffic.bind(null, state);
-  state.update = updateTraffic.bind(null, state);
-  state.terrain = updateTrafficTerrain.bind(null, state);
-  layer._beforeRaycast = placeTraffic.bind(null, state);
-  layer.on('ready', readyTraffic.bind(null, state));
-  layer.on('add', addTraffic.bind(null, state));
-  layer.on('remove', removeTraffic.bind(null, state));
-}

package/src/utils/initWalk.js

@@ -1,72 +0,0 @@
-import {
-  controlOnAdd, onBlur, onKey, onLayerAdd, onLayerRemove, onPointer, onReady, onTerrain, start, step, stop, toggle
-} from './walk.js';
-
-/**
- * Third-person walk mode, toggled by a map button (and Esc): a pedestrian at the map centre runs with W/S (or ↑/↓) and
- * turns with A/D (or ←/→); the camera swings back behind it while it moves. Dragging the map only turns the camera
- * (bearing, pitch); the wheel changes the camera distance.
- * The walker follows the terrain, bridges included, and `layer.walker` exposes `{ latlng, heading, phase }`.
- * Source options: `speed` (m/s, default 6), `distance` (camera distance in metres, default 20), `position` (button corner, default 'topleft').
- * Visible meshes of the other 3D layers (buildings, trees, models, streetlights) are solid; terrain and traffic are not.
- */
-export function initWalk(layer, {
-  speed = 70,
-  distance = 20,
-  position = 'bottomright',
-  ...options
-} = {}) {
-  layer._init3D(options);
-  const keys = new Set();
-  const control = new L.Control({ position });
-  const container = L.DomUtil.create('div', 'leaflet-bar leaflet-control');
-  container.style.cssText = 'display:flex;align-items:center;background:#fff;';
-  const button = L.DomUtil.create('button', '', container);
-  button.type = 'button';
-  button.title = 'Walk';
-  button.setAttribute('aria-label', 'Walk');
-  button.setAttribute('aria-pressed', 'false');
-  button.textContent = '🚶';
-  button.style.cssText = 'width:30px;height:30px;padding:0;border:0;border-radius:4px;background:#fff;font-size:18px;line-height:30px;cursor:pointer;';
-  const hint = L.DomUtil.create('small', '', container);
-  hint.style.cssText = 'display:none;padding:0 8px;color:#333;white-space:nowrap;';
-  hint.textContent = 'W/S: run · A/D: turn · drag: look around · Esc: exit';
-  L.DomEvent.disableClickPropagation(container);
-
-  const context = {
-    layer,
-    speed,
-    distance,
-    keys,
-    control,
-    container,
-    button,
-    hint,
-    meshes: null,
-    frame: null,
-    last: undefined,
-    swing: 0,
-    saved: null,
-    drag: null,
-    ready: false,
-    state: layer.walker = { latlng: null, heading: 0, phase: 0 }
-  }
-  context.step = step.bind(context);
-  context.onKey = onKey.bind(context);
-  context.onBlur = onBlur.bind(context);
-  context.onPointer = onPointer.bind(context);
-  context.onTerrain = onTerrain.bind(context);
-  context.start = start.bind(context);
-  context.stop = stop.bind(context);
-  context.toggle = toggle.bind(context);
-  context.controlOnAdd = controlOnAdd.bind(context);
-  context.onReady = onReady.bind(context);
-  context.onLayerAdd = onLayerAdd.bind(context);
-  context.onLayerRemove = onLayerRemove.bind(context);
-
-  control.onAdd = context.controlOnAdd;
-  L.DomEvent.on(button, 'click', context.toggle);
-  layer.on('ready', context.onReady);
-  layer.on('add', context.onLayerAdd);
-  layer.on('remove', context.onLayerRemove);
-};