leaflet-city-mapper 0.0.4 → 0.0.6

package/libs/leaflet-lens.js

@@ -8,6 +8,9 @@
 
     initialize(outerLayer, innerLayer, options) {
       L.Util.setOptions(this, options);
+      if (options?.enabled === undefined) {
+        this.options.enabled = !matchMedia('(hover: none) and (pointer: coarse)').matches;
+      }
       if (!outerLayer?.options || !innerLayer?.options || outerLayer === innerLayer) {
         throw new TypeError('Lens requires two distinct raster layers');
       }
@@ -40,14 +43,15 @@
       this._button = L.DomUtil.create('button', '', container);
       this._button.type = 'button';
       this._button.textContent = '🔍';
-      this._button.title = 'Toggle lens; move the pointer over the map to reveal the layer underneath';
+      this._button.title = 'Toggle lens; touch or move the pointer over the map to reveal the layer underneath';
       this._button.setAttribute('aria-label', 'Toggle lens');
       this._button.style.cssText = 'display:block;border:0;border-radius:2px;padding:0 8px;min-width:30px;height:30px;background:white;color:#222;font:inherit;cursor:pointer';
       L.DomEvent.disableClickPropagation(container);
       L.DomEvent.disableScrollPropagation(container);
       L.DomEvent.on(this._button, 'click', this._toggle, this);
       this._events = {
-        pointermove: this._onPointerMove.bind(this), pointerleave: this._hide.bind(this),
+        pointerdown: this._onPointerDown.bind(this), pointermove: this._onPointerMove.bind(this),
+        pointerleave: this._onPointerLeave.bind(this), pointercancel: this._hide.bind(this),
         focus: this._onFocus.bind(this), blur: this._hide.bind(this), keydown: this._onKeyDown.bind(this),
       };
       for (const [type, handler] of Object.entries(this._events)) {
@@ -111,8 +115,16 @@
       });
     },
 
+    _onPointerDown(event) {
+      if (event.pointerType === 'touch') this._onPointerMove(event);
+    },
+
+    _onPointerLeave(event) {
+      if (event.pointerType !== 'touch') this._hide();
+    },
+
     _onFocus() {
-      this._show(this._map.getSize().divideBy(2));
+      if (this._lens.hidden) this._show(this._map.getSize().divideBy(2));
     },
 
     _onKeyDown(event) {

package/libs/leaflet.js

@@ -11,7 +11,7 @@ const openlayers = new URLSearchParams(location.search).get('engine') === 'openl
 document.write((openlayers
   ? '<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/ol@10.6.1/ol.css">' +
     '<script src="https://cdn.jsdelivr.net/npm/ol@10.6.1/dist/ol.js"><\/script>' +
-    '<script src="https://unpkg.com/leaflet-city-mapper@0.0.4/libs/openlayers-bindings.min.js"><\/script>'
+    '<script src="https://unpkg.com/leaflet-city-mapper@0.0.6/libs/openlayers-bindings.min.js"><\/script>'
   : '<link rel="stylesheet" href="https://unpkg.com/leaflet@1.9/dist/leaflet.css"><script src="https://unpkg.com/leaflet@1.9/dist/leaflet-src.js"><\/script>'));
 
 const engineStyle = document.createElement('style');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leaflet-city-mapper",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "A small 3D rendering engine for leaflet",
   "type": "module",
   "main": "dist/leaflet-city-mapper.js",
@@ -35,7 +35,8 @@
   },
   "homepage": "https://github.com/Raruto/leaflet-city-mapper#readme",
   "peerDependencies": {
-    "leaflet": "^1.9.3 || ^2.0.0-alpha.1"
+    "leaflet": "^1.9.3 || ^2.0.0-alpha.1",
+    "ol": "^10.6.1"
   },
   "devDependencies": {
     "@cucumber/cucumber": "^10.3.1",

package/src/{camera → animations}/cancelCameraAnimation.js

@@ -1,13 +1,15 @@
+import { cameraAnimationByMap } from '../weakmaps/cameraAnimationByMap.js';
+import { cameraFrameByMap } from '../weakmaps/cameraFrameByMap.js';
+
 import { cameraAnimations } from '../globals/cameraAnimations.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
 import { cameraAnimationFrame } from '../globals/cameraAnimationFrame.js';
 
 
 
 export function cancelCameraAnimation(map) {
   cameraAnimations.delete(map);
-  cameraByMap.get(map)._cameraAnimation = null;
-  cameraByMap.get(map)._cameraFrame = null;
+  cameraAnimationByMap.set(map, null);
+  cameraFrameByMap.set(map, null);
   if (!cameraAnimations.size && cameraAnimationFrame.value !== null) {
     cancelAnimationFrame(cameraAnimationFrame.value);
     cameraAnimationFrame.value = null;

package/src/{core → animations}/cancelGridFade.js

@@ -1,12 +1,13 @@
+import { fadeFrameByLayer } from '../weakmaps/fadeFrameByLayer.js';
+
 import { pendingGridFades } from '../globals/pendingGridFades.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 import { gridFadeFrame } from '../globals/gridFadeFrame.js';
 
 
 
 export function cancelGridFade(layer) {
   pendingGridFades.delete(layer);
-  sceneByLayer.get(layer)._fadeFrame = null;
+  fadeFrameByLayer.set(layer, null);
   if (!pendingGridFades.size && gridFadeFrame.value !== null) {
     cancelAnimationFrame(gridFadeFrame.value);
     gridFadeFrame.value = null;

package/src/animations/endZoom.js

@@ -0,0 +1,27 @@
+import { zoomLevelByLayer } from '../weakmaps/zoomLevelByLayer.js';
+import { zoomTransitionsByLayer } from '../weakmaps/zoomTransitionsByLayer.js';
+import { zoomViewByLayer } from '../weakmaps/zoomViewByLayer.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
+
+
+
+import { mapUpdateCameraOverlays } from '../camera/mapUpdateCameraOverlays.js';
+
+import { update } from '../scene/scheduleSceneUpdate.js';
+
+/** Stop using the outgoing level after zoomend; the next redraw uses current tiles. */
+
+export function endZoom() {
+  const layer = this;
+  let animation;
+  if (zoomTransitionsByLayer.get(layer)) {
+    for (animation of zoomTransitionsByLayer.get(layer).keys()) animation.finish();
+  }
+  zoomTransitionsByLayer.set(layer, null);
+  zoomViewByLayer.set(layer, null);
+  cameraViewByMap.delete(layer._map);
+  layer._map.getContainer().classList.remove('leaflet-camera-zoom');
+  mapUpdateCameraOverlays(layer._map);
+  zoomLevelByLayer.set(layer, null);
+  update(layer);
+}

package/src/{camera → animations}/mapAnimateCamera.js

@@ -1,8 +1,9 @@
+import { cameraAnimationByMap } from '../weakmaps/cameraAnimationByMap.js';
+
 import { cameraEmptyOptions } from '../globals/cameraEmptyOptions.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
-import { mapSetPitchAndBearing } from './mapSetPitchAndBearing.js';
-import { mapGetPitch } from './mapGetPitch.js';
-import { mapGetBearing } from './mapGetBearing.js';
+import { mapSetPitchAndBearing } from '../camera/mapSetPitchAndBearing.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
 
 import { cancelCameraAnimation } from './cancelCameraAnimation.js';
 import { scheduleCameraAnimation } from './scheduleCameraAnimation.js';
@@ -18,7 +19,8 @@ export function mapAnimateCamera(map, pitch, bearing, options = cameraEmptyOptio
   if (!Number.isFinite(duration) || duration < 0) throw /* alloc */ new TypeError('Camera duration must be nonnegative');
   const start = performance.now(), fromPitch = mapGetPitch(map), fromBearing = mapGetBearing(map);
   const delta = ((bearing - fromBearing) % 360 + 540) % 360 - 180;
-  const animation = cameraByMap.get(map)._cameraAnimation = /* alloc */ { duration, start, fromPitch, fromBearing, pitch, delta };
+  const animation = /* alloc */ { duration, start, fromPitch, fromBearing, pitch, delta };
+  cameraAnimationByMap.set(map, animation);
   scheduleCameraAnimation(map, animation);
   return map;
 }

package/src/{scene → animations}/onZoomAnim.js

@@ -1,4 +1,5 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { zoomViewByLayer } from '../weakmaps/zoomViewByLayer.js';
+
 import { pendingZoomAnimations } from '../globals/pendingZoomAnimations.js';
 
 
@@ -8,9 +9,9 @@ import { renderPendingZoomAnimation } from './renderPendingZoomAnimation.js';
 
 export function onZoomAnim(event) {
   const map = this._map;
-  if (event && !sceneByLayer.get(this)._zoomView) {
-    sceneByLayer.get(this)._zoomView = /* alloc */ { from: map.getCenter(), zoom: map.getZoom(), to: event.center,
-      targetZoom: event.zoom, start: performance.now() };
+  if (event && !zoomViewByLayer.get(this)) {
+    zoomViewByLayer.set(this, /* alloc */ { from: map.getCenter(), zoom: map.getZoom(), to: event.center,
+      targetZoom: event.zoom, start: performance.now() });
     map.getContainer().classList.add('leaflet-camera-zoom');
   }
   pendingZoomAnimations.push(this);

package/src/{scene → animations}/renderPendingZoomAnimation.js

@@ -1,5 +1,7 @@
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+
 import { pendingZoomAnimations } from '../globals/pendingZoomAnimations.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
 
@@ -7,5 +9,5 @@ import { render } from '../rendering/render.js';
 
 export function renderPendingZoomAnimation() {
   const layer = pendingZoomAnimations.shift();
-  if (sceneByLayer.get(layer)._shared === layer && sceneByLayer.get(layer).renderer) render(layer);
+  if (sharedByLayer.get(layer) === layer && rendererByLayer.get(layer)) render(layer);
 }

package/src/{camera → animations}/runCameraAnimations.js

@@ -1,8 +1,10 @@
+import { cameraAnimationByMap } from '../weakmaps/cameraAnimationByMap.js';
+import { cameraFrameByMap } from '../weakmaps/cameraFrameByMap.js';
+
 import { cameraAnimationFrame } from '../globals/cameraAnimationFrame.js';
 import { cameraAnimations } from '../globals/cameraAnimations.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
 
-import { mapSetPitchAndBearing } from './mapSetPitchAndBearing.js';
+import { mapSetPitchAndBearing } from '../camera/mapSetPitchAndBearing.js';
 
 
 import { scheduleCameraAnimation } from './scheduleCameraAnimation.js';
@@ -14,15 +16,15 @@ export function runCameraAnimations(now) {
   let failure;
   let map, animation, progress, eased;
   for ([map, animation] of pending) {
-    cameraByMap.get(map)._cameraFrame = null;
-    if (cameraByMap.get(map)._cameraAnimation !== animation) continue;
+    cameraFrameByMap.set(map, null);
+    if (cameraAnimationByMap.get(map) !== animation) continue;
     progress = animation.duration
       ? Math.min(1, (now - animation.start) / (animation.duration * 1000)) : 1;
     eased = 1 - (1 - progress) ** 3;
     try {
       mapSetPitchAndBearing(map, animation.fromPitch + (Math.max(0, Math.min(map.options.maxPitch, animation.pitch)) - animation.fromPitch) * eased, animation.fromBearing + animation.delta * eased);
-      if (progress < 1 && cameraByMap.get(map)._cameraAnimation === animation) scheduleCameraAnimation(map, animation);
-      else if (cameraByMap.get(map)._cameraAnimation === animation) cameraByMap.get(map)._cameraAnimation = null;
+      if (progress < 1 && cameraAnimationByMap.get(map) === animation) scheduleCameraAnimation(map, animation);
+      else if (cameraAnimationByMap.get(map) === animation) cameraAnimationByMap.set(map, null);
     } catch (error) {
       failure ||= error;
     }

package/src/{core → animations}/runGridFades.js

@@ -1,10 +1,11 @@
+import { fadeFrameByLayer } from '../weakmaps/fadeFrameByLayer.js';
+
 import { gridFadeFrame } from '../globals/gridFadeFrame.js';
 import { pendingGridFades } from '../globals/pendingGridFades.js';
-import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
 
-import { updateGridOpacity } from './updateGridOpacity.js';
+import { updateGridOpacity } from '../core/updateGridOpacity.js';
 
 export function runGridFades() {
   gridFadeFrame.value = null;
@@ -13,7 +14,7 @@ export function runGridFades() {
   for ([layer, version] of layers) {
     if (pendingGridFades.get(layer) !== version) continue;
     pendingGridFades.delete(layer);
-    sceneByLayer.get(layer)._fadeFrame = null;
+    fadeFrameByLayer.set(layer, null);
     updateGridOpacity.call(layer);
   }
 }

package/src/{camera → animations}/scheduleCameraAnimation.js

@@ -1,6 +1,7 @@
+import { cameraFrameByMap } from '../weakmaps/cameraFrameByMap.js';
+
 import { cameraAnimations } from '../globals/cameraAnimations.js';
 import { cameraAnimationFrame } from '../globals/cameraAnimationFrame.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
 
 
 
@@ -9,5 +10,5 @@ import { runCameraAnimations } from './runCameraAnimations.js';
 export function scheduleCameraAnimation(map, animation) {
   cameraAnimations.set(map, animation);
   if (cameraAnimationFrame.value === null) cameraAnimationFrame.value = requestAnimationFrame(runCameraAnimations);
-  cameraByMap.get(map)._cameraFrame = cameraAnimationFrame.value;
+  cameraFrameByMap.set(map, cameraAnimationFrame.value);
 }

package/src/animations/scheduleGridFade.js

@@ -0,0 +1,16 @@
+import { fadeFrameByLayer } from '../weakmaps/fadeFrameByLayer.js';
+import { fadeVersionByLayer } from '../weakmaps/fadeVersionByLayer.js';
+
+import { pendingGridFades } from '../globals/pendingGridFades.js';
+import { gridFadeFrame } from '../globals/gridFadeFrame.js';
+
+
+
+import { runGridFades } from './runGridFades.js';
+
+export function scheduleGridFade(layer) {
+  fadeVersionByLayer.set(layer, (fadeVersionByLayer.get(layer) || 0) + 1);
+  pendingGridFades.set(layer, fadeVersionByLayer.get(layer));
+  if (gridFadeFrame.value === null) gridFadeFrame.value = requestAnimationFrame(runGridFades);
+  fadeFrameByLayer.set(layer, gridFadeFrame.value);
+}

package/src/{scene → animations}/startZoom.js

@@ -1,8 +1,9 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { zoomLevelByLayer } from '../weakmaps/zoomLevelByLayer.js';
+
 
 
 /** Preserve the outgoing tile level before Leaflet changes its logical zoom. */
 
 export function startZoom() {
-  sceneByLayer.get(this)._zoomLevel = null;
+  zoomLevelByLayer.set(this, null);
 }

package/src/{rendering → animations}/synchronizeZoomView.js

@@ -1,26 +1,28 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { zoomTransitionsByLayer } from '../weakmaps/zoomTransitionsByLayer.js';
+import { zoomViewByLayer } from '../weakmaps/zoomViewByLayer.js';
+
 import { meshStack } from '../globals/meshStack.js';
 import { updateZoomCamera } from './updateZoomCamera.js';
 
-export function synchronizeZoomView(backend, now) {
-  const map = backend._map;
+export function synchronizeZoomView(layer, now) {
+  const map = layer._map;
   let animation, time, start;
   if (map._animatingZoom) {
-    sceneByLayer.get(backend)._zoomTransitions ||= /* alloc */ new Map();
+    if (!zoomTransitionsByLayer.get(layer)) zoomTransitionsByLayer.set(layer, /* alloc */ new Map());
     for (animation of map.getContainer().getAnimations(meshStack)) {
       if (!(animation instanceof CSSTransition) || animation.transitionProperty !== 'transform' ||
         !animation.effect.target.classList.contains('leaflet-zoom-animated') ||
-        sceneByLayer.get(backend)._zoomTransitions.has(animation)) {
+        zoomTransitionsByLayer.get(layer).has(animation)) {
         continue;
       }
       time = animation.currentTime || 0;
       animation.pause();
-      sceneByLayer.get(backend)._zoomTransitions.set(animation, /* alloc */ { start: now, time });
+      zoomTransitionsByLayer.get(layer).set(animation, /* alloc */ { start: now, time });
     }
     // Freeze CSS between rendered frames: the compositor must not outrun the canvas.
-    for ([animation, { start, time }] of sceneByLayer.get(backend)._zoomTransitions) {
+    for ([animation, { start, time }] of zoomTransitionsByLayer.get(layer)) {
       animation.currentTime = Math.min(animation.effect.getComputedTiming().endTime, time + now - start);
     }
-    if (sceneByLayer.get(backend)._zoomView) updateZoomCamera(backend, now);
+    if (zoomViewByLayer.get(layer)) updateZoomCamera(layer, now);
   }
 }

package/src/{rendering → animations}/updateZoomCamera.js

@@ -1,18 +1,21 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { zoomTransitionsByLayer } from '../weakmaps/zoomTransitionsByLayer.js';
+import { zoomViewByLayer } from '../weakmaps/zoomViewByLayer.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
+
+
 import { mapUpdateCameraOverlays } from '../camera/mapUpdateCameraOverlays.js';
 
-export function updateZoomCamera(backend, now) {
-  const map = backend._map;
-  const view = sceneByLayer.get(backend)._zoomView;
+export function updateZoomCamera(layer, now) {
+  const map = layer._map;
+  const view = zoomViewByLayer.get(layer);
   let proxy, animation;
-  for (animation of sceneByLayer.get(backend)._zoomTransitions.keys()) {
+  for (animation of zoomTransitionsByLayer.get(layer).keys()) {
     if (animation.effect.target === map._proxy) { proxy = animation; break; }
   }
   const progress = proxy?.effect.getComputedTiming().progress ?? Math.min(1, (now - view.start) / 250);
   const targetScale = map.getZoomScale(view.targetZoom, view.zoom), scale = 1 + (targetScale - 1) * progress;
   const from = map.project(view.from, view.zoom), to = map.project(view.to, view.zoom);
-  cameraByMap.get(map)._cameraView = /* alloc */ { zoom: map.getScaleZoom(scale, view.zoom),
-    center: map.unproject(from.add(to.subtract(from).multiplyBy(targetScale * progress / scale)), view.zoom) };
+  cameraViewByMap.set(map, /* alloc */ { zoom: map.getScaleZoom(scale, view.zoom),
+    center: map.unproject(from.add(to.subtract(from).multiplyBy(targetScale * progress / scale)), view.zoom) });
   mapUpdateCameraOverlays(map);
 }

package/src/archives/decodeDirectory.js

@@ -1,5 +1,5 @@
 import { directoryReader } from '../globals/directoryReader.js';
-import { varint } from './varint.js';
+import { varint } from './readVarint.js';
 
 /** Decode delta/varint directory columns, rejecting malformed entries. */
 

package/src/archives/findTile.js

@@ -2,7 +2,7 @@ import { getDirectoryEntries } from './getDirectoryEntries.js';
 import { findDirectoryEntry } from './findDirectoryEntry.js';
 import { getTileData } from './getTileData.js';
 
-export async function findTile(backend, header, id, signal) {
+export async function findTile(layer, header, id, signal) {
   let offset = header.rootDirectoryOffset, length = header.rootDirectoryLength;
   let firstOffset = -1, secondOffset = -1, thirdOffset = -1;
   let depth, entries, entry, tile;
@@ -13,12 +13,12 @@ export async function findTile(backend, header, id, signal) {
     if (depth === 0) firstOffset = offset;
     else if (depth === 1) secondOffset = offset;
     else if (depth === 2) thirdOffset = offset;
-    entries = await getDirectoryEntries(backend, offset, length, header.internalCompression);
+    entries = await getDirectoryEntries(layer, offset, length, header.internalCompression);
     signal?.throwIfAborted();
     entry = findDirectoryEntry(entries, id);
     if (!entry) return;
     if (entry.runLength) {
-      tile = await getTileData(backend, header, entry, id, signal);
+      tile = await getTileData(layer, header, entry, id, signal);
       return tile;
     }
     if (entry.offset + entry.length > header.leafDirectoryLength) {

package/src/archives/getDirectoryEntries.js

@@ -1,12 +1,13 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { directoriesByLayer } from '../weakmaps/directoriesByLayer.js';
+
 import { loadDirectory } from './loadDirectory.js';
 
-export async function getDirectoryEntries(backend, offset, length, compression) {
-  const directories = sceneByLayer.get(backend)._directories;
+export async function getDirectoryEntries(layer, offset, length, compression) {
+  const directories = directoriesByLayer.get(layer);
   const key = `${offset}:${length}`;
   if (!directories.has(key)) {
     if (directories.size >= 32) directories.delete(directories.keys().next().value);
-    directories.set(key, loadDirectory(backend, offset, length, compression));
+    directories.set(key, loadDirectory(layer, offset, length, compression));
   }
   const pending = directories.get(key);
   try {

package/src/archives/getHeader.js

@@ -1,13 +1,17 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
-
-
+import { archiveHeaderByLayer } from '../weakmaps/archiveHeaderByLayer.js';
+import { sceneLayers } from '../weakmaps/sceneLayers.js';
 import { decodeHeader } from './decodeHeader.js';
-import { read } from './read.js';
+import { read } from './readArchiveRange.js';
 
 /** Cache header initialization; failures remain visible to all callers. */
 
 export function getHeader(layer) {
-  if (!sceneByLayer.has(layer)) return layer.getHeader();
+  if (!sceneLayers.has(layer)) return layer.getHeader();
   if (layer.options.archive && layer.options.archive !== layer) return getHeader(layer.options.archive);
-  return sceneByLayer.get(layer)._header ||= read(layer, 0, 127).then(decodeHeader);
+  let header = archiveHeaderByLayer.get(layer);
+  if (!header) {
+    header = read(layer, 0, 127).then(decodeHeader);
+    archiveHeaderByLayer.set(layer, header);
+  }
+  return header;
 }

package/src/archives/getTileData.js

@@ -1,12 +1,12 @@
 import { decompress } from './decompress.js';
-import { read } from './read.js';
+import { read } from './readArchiveRange.js';
 
-export async function getTileData(backend, header, entry, id, signal) {
+export async function getTileData(layer, header, entry, id, signal) {
   if (id - entry.tileId >= entry.runLength) return;
   if (entry.offset + entry.length > header.tileDataLength) {
     throw /* alloc */ new Error('PMTiles tile outside data section');
   }
-  const data = await decompress(await read(backend, header.tileDataOffset + entry.offset, entry.length, signal),
+  const data = await decompress(await read(layer, header.tileDataOffset + entry.offset, entry.length, signal),
     header.tileCompression);
   signal?.throwIfAborted();
   return /* alloc */ { data };

package/src/archives/getZxy.js

@@ -1,19 +1,20 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { sceneLayers } from '../weakmaps/sceneLayers.js';
+
 import { tileId } from './tileId.js';
 import { getHeader } from './getHeader.js';
 import { findTile } from './findTile.js';
 
 /** Nearest directory entry at/before the Hilbert ID, then follow leaf pointers. */
 
-export async function getZxy(backend, z, x, y, signal) {
-  if (!sceneByLayer.has(backend)) return backend.getZxy(z, x, y, signal);
-  if (backend.options.archive && backend.options.archive !== backend) {
-    return getZxy(backend.options.archive, z, x, y, signal);
+export async function getZxy(layer, z, x, y, signal) {
+  if (!sceneLayers.has(layer)) return layer.getZxy(z, x, y, signal);
+  if (layer.options.archive && layer.options.archive !== layer) {
+    return getZxy(layer.options.archive, z, x, y, signal);
   }
   const id = tileId(z, x, y);
   signal?.throwIfAborted();
-  const header = await getHeader(backend);
+  const header = await getHeader(layer);
   signal?.throwIfAborted();
   if (z < header.minZoom || z > header.maxZoom) return;
-  return findTile(backend, header, id, signal);
+  return findTile(layer, header, id, signal);
 }

package/src/archives/loadDirectory.js

@@ -1,7 +1,7 @@
 import { decodeDirectory } from "./decodeDirectory.js";
 import { decompress } from "./decompress.js";
-import { read } from "./read.js";
+import { read } from "./readArchiveRange.js";
 
-export async function loadDirectory(backend, offset, length, compression) {
-  return decodeDirectory(await decompress(await read(backend, offset, length), compression));
+export async function loadDirectory(layer, offset, length, compression) {
+  return decodeDirectory(await decompress(await read(layer, offset, length), compression));
 }

package/src/archives/loadSource.js

@@ -1,11 +1,12 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+
 import { archiveDecoder } from '../globals/archiveDecoder.js';
 
 import { getZxy } from './getZxy.js';
 
 
 export async function loadSource(layer, area) {
-  if (sceneByLayer.get(layer)._geojson) {
+  if (geojsonByLayer.get(layer)) {
     const { data, url } = layer.options;
     if (data !== undefined && url) {
       throw /* alloc */ new Error('GeoJSON source requires either data or url');

package/src/archives/{read.js → readArchiveRange.js}

@@ -1,23 +1,25 @@
-import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { etagByLayer } from '../weakmaps/etagByLayer.js';
+import { urlByLayer } from '../weakmaps/urlByLayer.js';
+
 
 
-export async function read(backend, offset, length, signal) {
+export async function read(layer, offset, length, signal) {
   signal?.throwIfAborted();
   if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) ||
     offset < 0 || length <= 0 || !Number.isSafeInteger(offset + length)) {
     throw /* alloc */ new Error('Invalid PMTiles byte range');
   }
-  const response = await fetch(sceneByLayer.get(backend).url, /* alloc */ {
+  const response = await fetch(urlByLayer.get(layer), /* alloc */ {
     headers: /* alloc */ { Range: `bytes=${offset}-${offset + length - 1}` }, signal,
   });
   if (!response.ok) {
     throw /* alloc */ new Error(`Unable to read PMTiles: HTTP ${response.status}`);
   }
   const etag = response.headers.get('ETag');
-  if (sceneByLayer.get(backend)._etag && etag !== sceneByLayer.get(backend)._etag) {
+  if (etagByLayer.get(layer) && etag !== etagByLayer.get(layer)) {
     throw /* alloc */ new Error('PMTiles archive changed; recreate the layer');
   }
-  if (etag) sceneByLayer.get(backend)._etag = etag;
+  if (etag) etagByLayer.set(layer, etag);
   let data = await response.arrayBuffer();
   if (response.status === 200) {
     data = data.slice(offset, offset + length);

package/src/camera/cameraMapReady.js

@@ -1,4 +1,5 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { cameraDraggableByMap } from '../weakmaps/cameraDraggableByMap.js';
+
 
 
 import { adjustCameraDrag } from '../controls/adjustCameraDrag.js';
@@ -6,6 +7,6 @@ import { adjustCameraDrag } from '../controls/adjustCameraDrag.js';
 export function cameraMapReady() {
   const draggable = this.dragging?._draggable;
   if (!draggable) return;
-  cameraByMap.get(this)._cameraDraggable = draggable;
+  cameraDraggableByMap.set(this, draggable);
   draggable.on('predrag', adjustCameraDrag, this);
 }

package/src/camera/cleanupCameraMap.js

@@ -1,14 +1,16 @@
-import { cameraByMap } from '../globals/cameraByMap.js';
+import { cameraDraggableByMap } from '../weakmaps/cameraDraggableByMap.js';
+import { pitchSkyByMap } from '../weakmaps/pitchSkyByMap.js';
 
 
-import { cancelCameraAnimation } from './cancelCameraAnimation.js';
+
+import { cancelCameraAnimation } from '../animations/cancelCameraAnimation.js';
 import { adjustCameraDrag } from '../controls/adjustCameraDrag.js';
 
 export function cleanupCameraMap() {
   cancelCameraAnimation(this);
-  cameraByMap.get(this)._pitchSky?.remove();
-  if (cameraByMap.get(this)._cameraDraggable) {
-    cameraByMap.get(this)._cameraDraggable.off('predrag', adjustCameraDrag, this);
-    delete cameraByMap.get(this)._cameraDraggable;
+  pitchSkyByMap.get(this)?.remove();
+  if (cameraDraggableByMap.get(this)) {
+    cameraDraggableByMap.get(this).off('predrag', adjustCameraDrag, this);
+    cameraDraggableByMap.delete(this);
   }
 }

package/src/camera/fitCameraBounds.js

@@ -2,9 +2,9 @@ import { L } from '../globals/L.js';
 import { cameraEmptyOptions } from '../globals/cameraEmptyOptions.js';
 import { cameraZeroPadding } from '../globals/cameraZeroPadding.js';
 import { cameraAngles } from '../globals/cameraAngles.js';
-import { pointOf } from './pointOf.js';
-import { angles } from './angles.js';
-import { verticalGroundY } from './verticalGroundY.js';
+import { pointOf } from '../projections/toPoint.js';
+import { angles } from '../projections/cameraAngles.js';
+import { verticalGroundY } from '../projections/verticalGroundY.js';
 
 
 export function fitCameraBounds(map, bounds, options = cameraEmptyOptions) {