leaflet-city-mapper 0.0.1 → 0.0.3

package/src/scene/sources.js

@@ -1,265 +0,0 @@
-import { parseColor, triangulate, isClockWise, treeGeometry, lightGeometry, lampPostGeometry } from '../utils/geometry.js';
-import { emptyNode } from '../utils/scene.js';
-
-/** GeoJSON source areas: loading, building and releasing. */
-export function onTerrainChange(backend) {
-  if (!backend._map) return;
-  for (const area of backend._areas.values()) backend._releaseArea(area);
-  backend._areas.clear();
-  backend._updateArea();
-}
-
-/** Cover the visible ground bounds and one bordering block, clipped to the archive. */
-export function updateArea(backend) {
-  if (!backend._map || !backend.header) return;
-  const z = backend.header.minZoom;
-  const center = backend._map.project(backend._map.getCenter(), z).divideBy(256).floor();
-  const bounds = backend._map.getBounds();
-  const nw = backend._map.project(bounds.getNorthWest(), z).divideBy(256).floor();
-  const se = backend._map.project(bounds.getSouthEast(), z).divideBy(256).floor();
-  const archiveNW = backend._map.project([backend.header.maxLat, backend.header.minLon], z).divideBy(256).floor();
-  const archiveSE = backend._map.project([backend.header.minLat, backend.header.maxLon], z).divideBy(256).floor();
-  const wanted = new Map();
-  for (let x = Math.max(0, nw.x - 1, archiveNW.x); x <= Math.min(2 ** z - 1, se.x + 1, archiveSE.x); x++) {
-    for (let y = Math.max(0, nw.y - 1, archiveNW.y); y <= Math.min(2 ** z - 1, se.y + 1, archiveSE.y); y++) {
-      wanted.set(`${x}/${y}`, { z, x, y });
-    }
-  }
-  for (const [key, area] of backend._areas) {
-    if (!wanted.has(key)) {
-      backend._releaseArea(area);
-      backend._areas.delete(key);
-    }
-  }
-  // Load the nearest new blocks first without rebuilding retained geometry.
-  for (const [key, coords] of [...wanted].sort(([, a], [, b]) =>
-    Math.hypot(a.x - center.x, a.y - center.y) - Math.hypot(b.x - center.x, b.y - center.y))) {
-    if (!backend._areas.has(key)) backend._areas.set(key, { coords, request: new AbortController() });
-  }
-  backend._pump();
-}
-
-export async function loadSource(backend, area) {
-  const { z, x, y } = area.coords;
-  const result = await backend.getZxy(z, x, y, area.request.signal);
-  return result ? JSON.parse(new TextDecoder().decode(result.data))
-    : { type: 'FeatureCollection', features: [] };
-}
-
-/** Start at most two load/build tasks; cancelled tasks still free their slot in finally. */
-export function pump(backend) {
-  // Meshes need the shared renderer; _attach() re-runs _updateArea() once it exists.
-  if (!backend._map || !backend._shared) return;
-  for (const area of backend._areas.values()) {
-    if (backend._inflight >= 2) break;
-    if (area.started) continue;
-    area.started = true;
-    backend._inflight++;
-    (async () => {
-      try {
-        const coords = area.coords;
-        const data = await backend._loadSource(area);
-        if (area.request.signal.aborted) return;
-        if (data?.type !== 'FeatureCollection' || !Array.isArray(data.features)) {
-          throw new Error('Invalid GeoJSON response');
-        }
-        const features = data.features;
-        const positions = [], normals = [], colors = [], uvs = [], featureFaces = [], lights = [];
-        const supports = new Set();
-        let skipped = 0;
-        const map = backend._map;
-        const crs = map.options.crs;
-        const origin = crs.project(backend.location);
-        const metres = Math.cos(backend.location.lat * Math.PI / 180);
-        const groundOffset = point => point.ground || 0;
-        const addTriangle = (a, ah, b, bh, c, ch, nx, ny, nz, color) => {
-          const ux = b.x - a.x, uy = bh - ah, uz = a.y - b.y;
-          const vx = c.x - a.x, vy = ch - ah, vz = a.y - c.y;
-          // Orient the triangle to its intended outward normal after flipping north to -z.
-          if ((uy * vz - uz * vy) * nx + (uz * vx - ux * vz) * ny + (ux * vy - uy * vx) * nz < 0) {
-            const point = b, height = bh;
-            b = c; bh = ch; c = point; ch = height;
-          }
-          positions.push(a.x, ah + groundOffset(a), -a.y,
-            b.x, bh + groundOffset(b), -b.y,
-            c.x, ch + groundOffset(c), -c.y);
-          normals.push(nx, ny, nz, nx, ny, nz, nx, ny, nz);
-          colors.push(color.r, color.g, color.b, color.r, color.g, color.b, color.r, color.g, color.b);
-          if (backend.options.nightLight) uvs.push(...a.uv, ...b.uv, ...c.uv);
-        };
-        let deadline = performance.now() + 8;
-        for (const feature of features) {
-          if (area.request.signal.aborted) return;
-          if (performance.now() >= deadline) {
-            await new Promise(requestAnimationFrame);
-            if (area.request.signal.aborted) return;
-            deadline = performance.now() + 8;
-          }
-          const geometry = feature?.geometry;
-          const isTree = geometry?.type === 'Point';
-          if (backend.options.nightLight && !isTree) throw new Error('Night lights require Point geometry');
-          const polygons = geometry?.type === 'Polygon' ? [geometry.coordinates] : geometry?.type === 'MultiPolygon' ? geometry.coordinates : null;
-          if (!polygons && !isTree) throw new Error('Unsupported GeoJSON geometry');
-          const [lon, lat] = (isTree ? geometry.coordinates : polygons[0]?.[0]?.[0]) ?? [];
-          if (!Number.isFinite(lon) || !Number.isFinite(lat)) throw new Error('Invalid GeoJSON coordinates');
-          if (coords) {
-            const anchor = map.project(new L.LatLng(lat, lon), coords.z);
-            // Overlapping archive blocks may contain the same polygon; its first vertex owns it.
-            if (Math.floor(anchor.x / 256) !== coords.x || Math.floor(anchor.y / 256) !== coords.y) continue;
-          }
-          const style = backend.options.featureStyle(feature);
-          if (style === null) {
-            skipped++;
-            continue;
-          }
-          if (!style || typeof style !== 'object') throw new Error('featureStyle must return an extrusion style or null');
-          const { top, bottom = 0, color = 0xd9b38c } = style;
-          if (!Number.isFinite(top) || !Number.isFinite(bottom) || bottom < 0 || top <= bottom) {
-            throw new Error('Invalid extrusion heights: expected top > bottom >= 0');
-          }
-          const baseColor = parseColor(color);
-          const vertexStart = positions.length / 3;
-          if (isTree) {
-            const point = crs.project(new L.LatLng(lat, lon));
-            const elevation = map._terrain3D?._getElevation([lat, lon]);
-            const projected = {
-              x: (point.x - origin.x) * metres, y: (point.y - origin.y) * metres,
-              ground: Number.isFinite(elevation) && Number.isFinite(backend.root.position[1])
-                ? elevation - backend.root.position[1] : 0,
-            };
-            if (backend.options.nightLight) {
-              if (!Number.isFinite(style.lightFlux) || style.lightFlux <= 0) throw new Error('Invalid light flux');
-              const support = feature.properties?.cod_ouvrag || `${lon},${lat}`;
-              if (style.poleRadius > 0 && !supports.has(support)) {
-                lampPostGeometry(projected, style, addTriangle);
-                supports.add(support);
-              }
-              lightGeometry(projected, style, addTriangle);
-              lights.push({
-                position: [projected.x, projected.ground + top, -projected.y],
-                radius: Math.hypot(top, style.lightRadius), color: [baseColor.r, baseColor.g, baseColor.b],
-                flux: style.lightFlux,
-              });
-            } else treeGeometry(projected, style, addTriangle);
-          }
-          for (const rings of polygons || []) {
-            if (!rings.length) throw new Error('Empty GeoJSON polygon');
-            const paths = rings.map(ring => {
-              if (ring.length < 4) throw new Error('Invalid GeoJSON polygon ring');
-              return ring.slice(0, -1).map(([lng, lat]) => {
-                if (!Number.isFinite(lng) || !Number.isFinite(lat)) throw new Error('Invalid GeoJSON coordinates');
-                const point = crs.project(new L.LatLng(lat, lng));
-                const elevation = backend._map._terrain3D?._getElevation([lat, lng]);
-                return {
-                  x: (point.x - origin.x) * metres,
-                  y: (point.y - origin.y) * metres,
-                  ground: Number.isFinite(elevation) && Number.isFinite(backend.root.position[1])
-                    ? elevation - backend.root.position[1] : 0,
-                };
-              });
-            });
-            const points = paths.flat();
-            for (const [a, b, c] of triangulate(paths[0], paths.slice(1))) {
-              addTriangle(points[a], top, points[b], top, points[c], top, 0, 1, 0, baseColor);
-              if (bottom > 0) addTriangle(points[a], bottom, points[b], bottom, points[c], bottom, 0, -1, 0, baseColor);
-            }
-            paths.forEach((path, index) => {
-              // Interior walls face into the courtyard; exterior walls face away from the building.
-              const sign = isClockWise(path) === (index === 0) ? -1 : 1;
-              for (let i = 0; i < path.length; i++) {
-                const a = path[i], b = path[(i + 1) % path.length];
-                const length = Math.hypot(b.x - a.x, b.y - a.y);
-                if (!length) continue;
-                const nx = sign * (b.y - a.y) / length, nz = sign * (b.x - a.x) / length;
-                addTriangle(a, bottom, b, bottom, b, top, nx, 0, nz, baseColor);
-                addTriangle(a, bottom, b, top, a, top, nx, 0, nz, baseColor);
-              }
-            });
-          }
-          const vertexEnd = positions.length / 3;
-          featureFaces.push({
-            id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
-            properties: feature.properties, baseColor,
-            faceStart: vertexStart / 3, faceEnd: vertexEnd / 3, vertexStart, vertexEnd,
-          });
-        }
-        if (!positions.length) {
-          Object.assign(area, { mesh: null, buildings: 0, skipped, done: true });
-          return;
-        }
-        const device = backend.renderer.device;
-        const attributes = {
-          position: { size: 3, data: new Float32Array(positions) },
-          normal:   { size: 3, data: new Float32Array(normals) },
-          color:    { size: 3, data: new Float32Array(colors) },
-        };
-        if (backend.options.nightLight) attributes.uv = { size: 2, data: new Float32Array(uvs) };
-        for (const [name, attribute] of Object.entries(attributes)) {
-          attribute.count = attribute.data.length / attribute.size;
-          attribute.buffer = device.createBuffer({
-            size: Math.max(4, attribute.data.byteLength),
-            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-          });
-          device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-        }
-        const meshGeometry = {
-          device,
-          attributes,
-          drawRange: { start: 0, count: attributes.position.count },
-        };
-        Object.assign(area, {
-          mesh: {
-            ...emptyNode(),
-            device,
-            geometry:    meshGeometry,
-            program:     backend._createProgram({ vertexColors: true, roofTexture: Boolean(backend.options.roofTexture),
-              ...(backend.options.nightLight ? { nightLight: true, alphaMode: 'BLEND', doubleSided: true } : {}) }),
-            id:          L.Layer.types['3d']._nextId++,
-            renderOrder: 0,
-            extras:      { featureFaces, lights },
-          },
-          buildings: featureFaces.length,
-          skipped,
-          done: true
-        });
-        backend.add(area.mesh);
-      } catch (error) {
-        if (area.request.signal.aborted) return;
-        area.error = error.message;
-        backend.fire('error', { error });
-      }
-    })().finally(() => {
-      backend._inflight--;
-      backend._pump();
-    });
-  }
-  backend._updateStatus();
-}
-
-/** Cancel pending work and dispose this block's GPU data, including any hover highlight. */
-export function releaseArea(backend, area) {
-  area.request.abort();
-  if (area.mesh) {
-    if (backend.highlightedFeature?.mesh === area.mesh) {
-      backend._setHighlight(null);
-      backend.hoveredFeature = null;
-      backend._showFeature(null);
-    }
-    backend.remove(area.mesh);
-    const geometry = area.mesh.geometry;
-    for (const attribute of Object.values(geometry.attributes)) attribute.buffer.destroy();
-    backend._removeProgram(area.mesh.program);
-  }
-}
-
-/** Emit a snapshot for consumers; ready does not wait for all neighborhood tasks. */
-export function updateStatus(backend, enabled = true) {
-  const progress = { enabled, loaded: 0, skipped: 0, pending: 0, errors: [] };
-  for (const area of backend._areas.values()) {
-    if (area.error) progress.errors.push(area.error);
-    else if (!area.done) progress.pending++;
-    progress.loaded += area.buildings ?? 0;
-    progress.skipped += area.skipped ?? 0;
-  }
-  backend.fire('progress', progress);
-}

package/src/types/3d.js

@@ -1,337 +0,0 @@
-/**
- * The '3d' layer type, loaded on demand by src/index.js.
- *
- * A native WebGPU scene drawn above the map tiles and kept in sync with the map camera
- * (center, zoom, bearing, pitch and zoom animations).
- *
- * No rendering dependencies. Use the `ready` event before using the helpers.
- * All instances on one map share a canvas, scene and camera, with one group per layer.
- *
- * World coordinates are metres relative to `location`: x east, y up, z south.
- * The shared scene instead uses the first attached layer's origin. `root` converts
- * each layer's local metres into that shared space, including latitude scaling.
- *
- * Lifecycle: initialize CPU state -> attach shared GPU device -> load configured
- * data/model -> ready. Removal cancels source work and detaches this layer only;
- * the last removal destroys the context. Model CPU arrays/images survive for re-add.
- *
- * This file holds the Leaflet lifecycle and explicit delegates to scene/ operations.
- * Stateless computations live in utils/; scene/ owns loading, GPU resources and interaction.
- * PMTiles v3 reading is implemented directly by this layer. Models are static triangles, without
- * animation, skinning, morph targets, normal maps or required extensions.
- *
- * Events: ready; error {error}; progress {enabled, loaded, skipped, pending, errors};
- * featurehover/featureclick {feature, originalEvent}. A feature may be null on a miss.
- * Picking tests geometry, not texture alpha: a transparent texel can still be hit.
- *
- * @example
- * new L.Layer({ source: { url: 'tower.glb', center: [48.8582601, 2.29449985] } }).addTo(map);
- * new L.Layer({ source: { type: '3d', url: 'buildings.pmtiles', featureStyle }, attribution }).addTo(map);
- * new L.Layer({ source: { type: 'terrain', url: 'terrain.pmtiles' } }).addTo(map);
- * new L.Layer({ source: { url: 'orthophotos.pmtiles', maxZoom: 24 } }).addTo(map);
- *
- * @typedef {Object} Layer3DOptions The `source` object; `pane`/`attribution` stay standard L.Layer options.
- * @property {string} [type] 'pmtiles' (raster tiles), '3d' (WebGPU scene) or 'terrain'; see L.Layer.types.
- * @property {number[]} [center] Local origin [lat,lng]; defaults to the first map center.
- * @property {number[]} [rotation] Model Euler rotation [x,y,z] in radians, YXZ order.
- * @property {number[]} [scale] Model scale [x,y,z]; independent of geographic scaling.
- * @property {string} [url] GLB/glTF model URL (loaded before ready), or PMTiles URL containing
- * Polygon/MultiPolygon or tree/light Point GeoJSON ('3d'), raster tiles ('pmtiles') or Float32 DEM ('terrain').
- * @property {function(Object): (ExtrusionStyle|null)} [featureStyle] Source styling; null skips.
- * @property {function(PickedFeature): (Node|string)} [tooltipContent] No HTML string evaluation.
- * @property {string} [ariaLabel='3D scene'] Shared canvas accessible name.
- * @property {boolean} [nightLight=false] Point sources: emissive bulbs and local illumination.
- * @property {boolean} [nightSparkle=false] Model: sparse luminous points at night.
- *
- * @typedef {Object} ExtrusionStyle
- * @property {number} top Roof height in metres; must exceed bottom.
- * @property {number} [bottom=0] Nonnegative base height; positive values create an underside.
- * @property {number|string|Object} [color=0xd9b38c] RGB/CSS color, or linear-space {h,s,l}.
- * @property {number} [trunkRadius] Point trees: trunk radius in metres.
- * @property {number} [crownRadius] Point trees: maximum crown radius in metres.
- * @property {number} [crownBottom] Point trees: crown base in metres, between bottom and top.
- * @property {string} [crownShape='round'] Point trees: 'round' or 'cone' schematic crown.
- * @property {number|string|Object} [trunkColor=0x72513a] Point trees: bark color.
- * @property {number} [lightRadius] Point lights: estimated ground reach in metres; top is emitter height.
- * @property {number} [lightFlux] Point lights: luminous flux in lumens.
- *
- * @typedef {Object} PickedFeature
- * @property {string|number} id Source feature id or configured model URL.
- * @property {Object} properties GeoJSON properties or model-level glTF extras.
- * @property {Object} mesh Intersected mesh.
- * @property {number[]} point Intersection [x,y,z] in shared scene metres, not layer-local metres.
- * @property {Object} [model] Configured model root; absent for source polygons.
- * @property {number} [vertexStart] First polygon vertex in the batched mesh.
- * @property {number} [vertexEnd] Exclusive end of the polygon's vertex range.
- *
- * @typedef {Object} SourceArea
- * @property {Object} coords Archive block {z,x,y}; z is header.minZoom, not display zoom.
- * @property {AbortController} request Cancellation also prevents attaching obsolete results.
- * @property {boolean} [started] Enqueued work has consumed a concurrency slot.
- * @property {boolean} [done] Geometry built successfully, including empty blocks.
- * @property {Object|null} [mesh] One batched GPU mesh per non-empty block.
- * @property {number} [buildings] Emitted feature count, not number of triangles.
- * @property {number} [skipped] Features intentionally skipped by featureStyle.
- * @property {string} [error] Failed load/build message; reported through error and progress.
- *
- * @since leaflet-rotate (v0.6.0)
- */
-
-import * as shapes from '../utils/geometry.js';
-import * as gpu from '../scene/gpu.js';
-import * as lighting from '../scene/lighting.js';
-import * as model from '../scene/model.js';
-import * as picking from '../scene/picking.js';
-import * as pmtiles from '../scene/pmtiles.js';
-import * as archive from '../utils/pmtiles.js';
-import * as render from '../scene/render.js';
-import * as graph from '../utils/scene.js';
-import * as sources from '../scene/sources.js';
-
-L.Layer.types['3d'] = L.Layer.extend({
-  color(value) { return shapes.parseColor(value); },
-  _setVertexColor(mesh, start, end, color) { shapes.setVertexColor(mesh, start, end, color); return this.update(); },
-  _triangulate(contour, holes) { return shapes.triangulate(contour, holes); },
-  _isClockWise(points) { return shapes.isClockWise(points); },
-  _treeGeometry(point, style, addTriangle) { return shapes.treeGeometry(point, style, addTriangle); },
-  _lightGeometry(point, style, addTriangle) { return shapes.lightGeometry(point, style, addTriangle); },
-  _lampPostGeometry(point, style, addTriangle) { return shapes.lampPostGeometry(point, style, addTriangle); },
-  _attach(map) { return gpu.attach(this, map); },
-  _destroyTexture(texture) { return gpu.destroyTexture(this, texture); },
-  _createProgram(material) { return gpu.createProgram(this, material); },
-  _removeProgram(program) { return gpu.removeProgram(program); },
-  _createMesh(data, material, usage) { return gpu.createMesh(this, data, material, usage); },
-  _disposeMesh(mesh) { return gpu.disposeMesh(this, mesh); },
-  _computeBounds(geometry) { return shapes.computeBounds(geometry); },
-  _drawGeometry(mesh, pass, cullMode, frontFace) { return gpu.drawGeometry(this, mesh, pass, cullMode, frontFace); },
-  _initSunlight() { return lighting.initSunlight(this); },
-  _resizeSunlight(size) { return lighting.resizeSunlight(this, size); },
-  _bindSunlight() { return lighting.bindSunlight(this); },
-  _updatePointLights() { return lighting.updatePointLights(this); },
-  _renderSunlight(encoder, meshes, sunlight) { return lighting.renderSunlight(this, encoder, meshes, sunlight); },
-  _loadModel() { return model.loadModel(this); },
-  raycast(event, objects, recursive) { return picking.raycast(this, event, objects, recursive); },
-  _findFeature(event) { return picking.findFeature(this, event); },
-  _setHighlight(feature) { return picking.setHighlight(this, feature); },
-  _showFeature(feature, event) { return picking.showFeature(this, feature, event); },
-  _onPointerMove(event) { return picking.onPointerMove(this, event); },
-  _onClick(event) { return picking.onClick(this, event); },
-  _onPointerLeave() { return picking.onPointerLeave(this); },
-  _read(offset, length, signal) { return pmtiles.read(this, offset, length, signal); },
-  _decompress(data, compression) { return archive.decompress(data, compression); },
-  getHeader() { return pmtiles.getHeader(this); },
-  getZxy(z, x, y, signal) { return pmtiles.getZxy(this, z, x, y, signal); },
-  update() { return render.update(this); },
-  _onMapChange() { return render.onMapChange(this); },
-  _getTileLevel() { return render.getTileLevel(this); },
-  _startZoom() { return render.startZoom(this); },
-  _endZoom() { return render.endZoom(this); },
-  _render() { return render.render(this); },
-  setParent(node, parent) { return graph.setParent(node, parent); },
-  traverse(node, callback) { return graph.traverse(node, callback); },
-  _updateWorldMatrix(node) { return graph.updateWorldMatrix(node); },
-  _updateCamera(camera) { return graph.updateCamera(camera); },
-  _onTerrainChange() { return sources.onTerrainChange(this); },
-  _updateArea() { return sources.updateArea(this); },
-  _pump() { return sources.pump(this); },
-  _loadSource(area) { return sources.loadSource(this, area); },
-  _releaseArea(area) { return sources.releaseArea(this, area); },
-  _updateStatus(enabled) { return sources.updateStatus(this, enabled); },
-
-  statics: {
-    /** Rendering owner per map; entries are removed on the last layer removal. */
-    _renderers: new WeakMap(),
-  },
-
-  options: {
-    // Accessible description of the canvas.
-    ariaLabel: '3D scene',
-  },
-
-  /**
-   * @param {Layer3DOptions} [options] World origin comes from center or the first map centre.
-   * Public state: `location` is fixed after first addition; `root` is this layer's
-   * transform; `group` aliases root only for sources; `model` is the configured
-   * model wrapper. `_shared` references the rendering owner (a '3d' layer);
-   * `scene`, `camera` and `renderer` alias its resources while attached.
-   *
-   */
-  initialize(options) {
-    L.Util.setOptions(this, options);
-    // ponytail: models are recognised by extension; extensionless model URLs need a .glb/.gltf suffix or query.
-    const model = !this._geojson && /\.(glb|gltf)(?:[?#]|$)/i.test(this.options.url);
-    this.modelUrl = model ? this.options.url : null;
-    this.url = this.options.url && !model && !this._geojson ? new URL(this.options.url, document.baseURI).href : null;
-    this._directories = new Map();
-    if (this.options.center) {
-      this.location = new L.LatLng(this.options.center[0], this.options.center[1]);
-    }
-    /** @type {Map<string, SourceArea>} Keys are archive x/y, not screen tiles. */
-    this._areas = new Map();
-    // Counts pending archive/build tasks, including ones cancelled after a pan.
-    this._inflight = 0;
-    // Gate GPU work on attachment; replaced on removal to support delayed loads.
-    this._added = Promise.withResolvers();
-    // Defer initialization so callers can subscribe to ready/error after construction.
-    queueMicrotask(async () => {
-      try {
-        this.root = graph.emptyNode();
-        this.raycaster = {
-          origin:    [0, 0, 0],
-          direction: [0, 0, 0]
-        };
-        if (this.url || this._geojson) {
-          this.group = this.root;
-          if (this.url) this.header = await this.getHeader();
-        }
-        if (this._map) {
-          await this._attach(this._map);
-          this._added.resolve();
-        }
-        if (this.modelUrl) await this._loadModel();
-        if (this._shared) this.update();
-        this.fire('ready');
-      } catch (error) {
-        this.fire('error', { error });
-      }
-    });
-  },
-
-  /** Attach interaction immediately; initialization may finish before or after onAdd. */
-  onAdd(map) {
-    if (!this.location) {
-      const center = map.getCenter();
-      this.location = new L.LatLng(center.lat, center.lng);
-    }
-    if (this.url || this._geojson || this.options.tooltipContent || this.modelUrl) {
-      this.container = map.getContainer();
-      if (this.options.tooltipContent) {
-        this._tooltip = L.DomUtil.create('div', 'leaflet-3d-tooltip', this.container);
-        this._tooltip.hidden = true;
-        this._tooltip.setAttribute('role', 'tooltip');
-        this._tooltip.setAttribute('aria-live', 'polite');
-        this._tooltip.style.cssText = 'position:absolute;z-index:600;max-width:220px;padding:10px 12px;border:1px solid #6b5140;border-radius:6px;background:#fffaf0;box-shadow:0 3px 12px #0005;color:#30251d;font:13px/1.45 sans-serif;pointer-events:none';
-      }
-      L.DomEvent.on(this.container, {
-        mousemove: this._onPointerMove,
-        click: this._onClick,
-        mouseleave: this._onPointerLeave,
-      }, this);
-    }
-    if (this.root) {
-      this._attach(map).then(() => this._added.resolve(), error => this.fire('error', { error }));
-    }
-  },
-
-  /** Reconcile source coverage when the visible ground footprint changes. */
-  getEvents() {
-    return this.url ? {
-      moveend:       this._updateArea,
-      zoomend:       this._updateArea,
-      rotate:        this._updateArea,
-      pitch:         this._updateArea,
-      resize:        this._updateArea,
-      terrainchange: this._onTerrainChange,
-    } : {};
-  },
-
-  /** Release source meshes/UI; retain manually added objects and model CPU data. */
-  onRemove(map) {
-    this._added = Promise.withResolvers();
-    if (this.container) {
-      this._onPointerLeave();
-      L.DomEvent.off(this.container, {
-        mousemove:  this._onPointerMove,
-        click:      this._onClick,
-        mouseleave: this._onPointerLeave,
-      }, this);
-      this.container = null;
-    }
-    for (const area of this._areas.values()) this._releaseArea(area);
-    this._areas.clear();
-    this._tooltip?.remove();
-    this._tooltip = null;
-    if (this.url || this._geojson) this._updateStatus(false);
-    const shared = this._shared;
-    if (!shared) return;
-    this.setParent(this.root, null);
-    shared._layers.delete(this);
-    if (shared === this) {
-      map.off('move zoom rotate pitch resize viewreset layeradd layerremove', this._onMapChange, this);
-      map.off('zoomstart', this._startZoom, this);
-      map.off('zoomanim', this.update, this);
-      map.off('zoomend', this._endZoom, this);
-      cancelAnimationFrame(this._frame);
-      this._frame = null;
-      this._queued = false;
-      if (this._layers.size) {
-        // Keep the original scene origin and GPU resources when ownership changes.
-        const next = this._layers.values().next().value;
-        for (const key of ['_layers', '_sceneOrigin', '_size', '_zoomLevel', '_zoomTransitions', '_cursor', '_roofRaster', '_roofTiles']) {
-          next[key] = this[key];
-          delete this[key];
-        }
-        for (const layer of next._layers) layer._shared = next;
-        L.Layer.types['3d']._renderers.set(map, next);
-        map.on('move zoom rotate pitch resize viewreset layeradd layerremove', next._onMapChange, next);
-        map.on('zoomstart', next._startZoom, next);
-        map.on('zoomanim', next.update, next);
-        map.on('zoomend', next._endZoom, next);
-        next.update();
-      } else {
-        if (this._roofRaster) this._destroyTexture(this._roofRaster.texture.texture);
-        this._roofRaster = null;
-        for (const source of this._roofTiles?.values() || []) this._destroyTexture(source.texture);
-        this._roofTiles = null;
-        for (const animation of this._zoomTransitions?.keys() || []) animation.play();
-        this._zoomTransitions = null;
-        this.renderer.canvas.remove();
-        const renderer = this.renderer;
-        const resources = [renderer.depthTexture, renderer.roofFallbackTexture.texture, renderer.uniformBuffer,
-          renderer.sunlight?.texture, renderer.sunlight?.buffer, renderer.sunlight?.lights].filter(Boolean);
-        renderer.device.queue.onSubmittedWorkDone().then(() => {
-          for (const resource of resources) resource.destroy();
-          renderer.device.destroy();
-        }, error => {
-          this.fire('error', { error });
-          renderer.device.destroy();
-        });
-        L.Layer.types['3d']._renderers.delete(map);
-        for (const key of ['_layers', '_sceneOrigin', '_size', '_zoomLevel', '_cursor']) delete this[key];
-      }
-    } else shared.update();
-    this._shared = null;
-    this.renderer = this.scene = this.camera = null;
-  },
-
-  /**
-   * Adds a scene node or mesh in layer-local coordinates and schedules a redraw.
-   * Requires initialization and a compatible scene node.
-   * @param {Object} object
-   * @returns {L.Layer} This layer.
-   */
-  add(object) {
-    this.setParent(object, this.root);
-    return this.update();
-  },
-
-  _setTerrainHeight() {
-    if (!this.root || !this.location) return;
-    this._terrainBaseY ??= this.root.position[1];
-    this.root.position[1] = this._terrainBaseY + (this._map?._terrain3D?._getElevation(this.location) ?? 0);
-  },
-
-  /**
-   * Without an argument, removes this Leaflet layer. With an object, only detaches it:
-   * geometry/program resources are not disposed, so it can be added again.
-   * @param {Object} [object]
-   * @returns {L.Layer}
-   */
-  remove(object) {
-    if (object === undefined) return L.Layer.prototype.remove.call(this);
-    this.setParent(object, null);
-    return this.update();
-  },
-});
-
-L.Layer.types['3d']._nextId = 0;

package/src/types/geojson.js

@@ -1,42 +0,0 @@
-import './3d.js';
-
-/** One GeoJSON batch, independent of the viewport, using the existing extrusion pipeline. */
-L.Layer.types.geojson = L.Layer.types['3d'].extend({
-  _geojson: true,
-
-  async _loadSource(area) {
-    const { data, url } = this.options;
-    if (typeof this.options.featureStyle !== 'function') {
-      throw new Error('featureStyle must be a function');
-    }
-    if ((data !== undefined) === (url !== undefined)) {
-      throw new Error('GeoJSON source requires either data or url');
-    }
-    if (data !== undefined) return data;
-    if (typeof url !== 'string' || !url.trim()) throw new Error('Invalid GeoJSON URL');
-    const response = await fetch(new URL(url, document.baseURI), { signal: area.request.signal });
-    if (!response.ok) throw new Error(`Unable to load GeoJSON: HTTP ${response.status}`);
-    return response.json();
-  },
-
-  _updateArea() {
-    if (!this._map || !this._shared) return;
-    if (!this._areas.has('geojson')) {
-      this._areas.set('geojson', { request: new AbortController() });
-    }
-    this._pump();
-  },
-
-  getEvents() {
-    return { terrainchange: this._onTerrainChange };
-  },
-
-  setData(data) {
-    this.options.data = data;
-    delete this.options.url;
-    for (const area of this._areas.values()) this._releaseArea(area);
-    this._areas.clear();
-    this._updateArea();
-    return this;
-  },
-});