leaflet-city-mapper 0.0.9 → 0.1.1

package/src/walk/moveWalker.js

@@ -1,24 +1,37 @@
 import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { L } from '../globals/L.js';
+import { radians } from '../globals/radians.js';
+import { local } from '../projections/walkerLocalPosition.js';
+import { blocked } from './isWalkBlocked.js';
 
-import { L } from '../globals/L.js';
-import { radians } from '../globals/radians.js';
-import { local } from '../projections/walkerLocalPosition.js';
-import { blocked } from './isWalkBlocked.js';
-
-export function moveWalker(forward, dt) {
-  const metres = forward * this.speed * dt, { lat, lng } = this.state.latlng;
-  const { position, scale } = rootByLayer.get(this.layer);
-  let east = Math.sin(this.state.heading) * metres, north = Math.cos(this.state.heading) * metres;
-  const feet = local.call(this, this.local);
-  let i;
-  for (i = 0; i < feet.length; i++) feet[i] = position[i] + scale[i] * feet[i];
-  // World x is east, z south; keep 0.3 m from walls and slide along them.
-  const wall = blocked.call(this, east, north, feet);
-  if (wall) {
-    const into = east * wall[0] - north * wall[1];
-    east -= into * wall[0]; north += into * wall[1];
-    if (blocked.call(this, east, north, feet)) east = north = 0;
-  }
-  this.state.latlng = /* alloc */ new L.LatLng(lat + north / 111320, lng + east / (111320 * Math.cos(lat * radians)));
-  this.state.phase += Math.hypot(east, north) / 1.6 * Math.PI;
-}
+/**
+ * Move along the walker's heading, maintaining wall clearance and sliding along obstacles.
+ *
+ * @param {number} forward Signed movement direction.
+ * @param {number} dt Frame duration in seconds.
+ */
+export function moveWalker(forward, dt) {
+  const metres = forward * this.speed * dt, { lat, lng } = this.state.latlng;
+  const { position, scale } = rootByLayer.get(this.layer);
+  let east = Math.sin(this.state.heading) * metres, north = Math.cos(this.state.heading) * metres;
+  const feet = local.call(this, this.local);
+  let i;
+  for (i = 0; i < feet.length; i++) feet[i] = position[i] + scale[i] * feet[i];
+  // World x is east, z south; keep 0.3 m from walls and slide along them.
+  const wall = blocked.call(this, east, north, feet);
+  if (wall) {
+    const fraction = Math.max(0, Math.min(1, (this.hitData.best - 0.3) / Math.hypot(east, north)));
+    const movedEast = east * fraction, movedNorth = north * fraction;
+    feet[0] += movedEast; feet[2] -= movedNorth;
+    east -= movedEast; north -= movedNorth;
+    const into = Math.min(0, east * wall[0] - north * wall[1]);
+    east -= into * wall[0]; north += into * wall[1];
+    if (blocked.call(this, east, north, feet)) {
+      const slide = Math.max(0, Math.min(1, (this.hitData.best - 0.3) / Math.hypot(east, north)));
+      east *= slide; north *= slide;
+    }
+    east += movedEast; north += movedNorth;
+  }
+  this.state.latlng = /* alloc */ new L.LatLng(lat + north / 111320, lng + east / (111320 * Math.cos(lat * radians)));
+  this.state.phase += Math.hypot(east, north) / 1.6 * Math.PI;
+}

package/src/walk/onAddWalkControl.js

@@ -1,31 +1,40 @@
-import { walkByMap } from '../weakmaps/walkByMap.js';
-
-export function onAdd(map) {
-  let state = walkByMap.get(map);
-  if (state?.control && state.control !== this) {
-    this._map = null;
-    throw /* alloc */ new Error('Only one Walk control can be active per map');
-  }
-  if (!state) {
-    state = /* alloc */ {
-      control: null,
-      hitData: /* alloc */ {
-        x: 0, y: 0, z: 0, dx: 0, dz: 0, reach: 0, best: 0, found: false,
-        seen: /* alloc */ new Set(),
-        intersections: /* alloc */ [],
-        nodes: /* alloc */ [],
-        normal: /* alloc */ [0, 0],
-      },
-      local: /* alloc */ [0, 0, 0],
-    };
-    walkByMap.set(map, state);
-  }
-  state.control = this;
-  state.local.fill(0);
-  state.hitData.seen.clear();
-  state.hitData.normal.fill(0);
-  this._walk.hitData = state.hitData;
-  this._walk.local = state.local;
-  this._walk.layer.addTo(map);
-  return this._walk.container;
-}
+import { walkByMap } from '../weakmaps/walkByMap.js';
+
+/**
+ * Attach the walk layer and reuse map-owned collision scratch, rejecting duplicate controls.
+ *
+ * @param {L.Map} map Map receiving the control.
+ *
+ * @returns {HTMLElement} Walk control container.
+ *
+ * @throws {Error} If another walk control is already attached to the map.
+ */
+export function onAdd(map) {
+  let state = walkByMap.get(map);
+  if (state?.control && state.control !== this) {
+    this._map = null;
+    throw /* alloc */ new Error('Only one Walk control can be active per map');
+  }
+  if (!state) {
+    state = /* alloc */ {
+      control: null,
+      hitData: /* alloc */ {
+        x: 0, y: 0, z: 0, dx: 0, dz: 0, reach: 0, best: 0, found: false,
+        seen: /* alloc */ new Set(),
+        intersections: /* alloc */ [],
+        nodes: /* alloc */ [],
+        normal: /* alloc */ [0, 0],
+      },
+      local: /* alloc */ [0, 0, 0],
+    };
+    walkByMap.set(map, state);
+  }
+  state.control = this;
+  state.local.fill(0);
+  state.hitData.seen.clear();
+  state.hitData.normal.fill(0);
+  this._walk.hitData = state.hitData;
+  this._walk.local = state.local;
+  this._walk.layer.addTo(map);
+  return this._walk.container;
+}

package/src/walk/onRemoveWalkControl.js

@@ -1,12 +1,17 @@
-import { walkByMap } from '../weakmaps/walkByMap.js';
-
-export function onRemove(map) {
-  const state = walkByMap.get(map);
-  if (state?.control !== this) return;
-  this._walk.stop();
-  this._walk.layer.remove();
-  state.control = null;
-  state.hitData.seen.clear();
-  this._walk.hitData = null;
-  this._walk.local = null;
-}
+import { walkByMap } from '../weakmaps/walkByMap.js';
+
+/**
+ * Stop and detach the current walk control while retaining reusable map-owned scratch.
+ *
+ * @param {L.Map} map Map from which the control is removed.
+ */
+export function onRemove(map) {
+  const state = walkByMap.get(map);
+  if (state?.control !== this) return;
+  this._walk.stop();
+  this._walk.layer.remove();
+  state.control = null;
+  state.hitData.seen.clear();
+  this._walk.hitData = null;
+  this._walk.local = null;
+}

package/src/walk/onWalkBlur.js

@@ -1,3 +1,4 @@
-export function onBlur() {
-  this.keys.clear();
+/** Release held movement keys when the window loses focus. */
+export function onBlur() {
+  this.keys.clear();
 }

package/src/walk/onWalkKey.js

@@ -1,8 +1,11 @@
 import { moves } from '../globals/moves.js';
-
-
 import { stop } from './stopWalking.js';
 
+/**
+ * Track walking keys and Escape without stealing input from text fields or modified shortcuts.
+ *
+ * @param {KeyboardEvent} event Keydown or keyup event.
+ */
 export function onKey(event) {
   if (event.type === 'keyup' && event.code === 'Space') this.keys.delete('Space');
   // Text fields and sliders keep their keys; buttons and checkboxes don't.

package/src/walk/onWalkPointer.js

@@ -1,6 +1,12 @@
 import { mapSetPitchAndBearing } from '../camera/mapSetPitchAndBearing.js';
 import { mapGetPitch } from '../camera/mapGetPitch.js';
 import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+/**
+ * Rotate the walk camera on primary-pointer drags outside map controls.
+ *
+ * @param {PointerEvent} event Pointer event on the map.
+ */
 export function onPointer(event) {
   // Dragging only turns the camera around the walker: horizontal = bearing, vertical = pitch.
   const map = this.layer._map;

package/src/walk/onWalkTerrain.js

@@ -1,5 +1,6 @@
 import { place } from './placeWalker.js';
 
-export function onTerrain() {
-  if (this.meshes) place.call(this);
+/** Reposition existing walker meshes after terrain elevation changes. */
+export function onTerrain() {
+  if (this.meshes) place.call(this);
 }

package/src/walk/placeWalker.js

@@ -1,9 +1,8 @@
 import { limbs } from '../globals/limbs.js';
-
 import { update } from '../scene/scheduleSceneUpdate.js';
-
 import { local } from '../projections/walkerLocalPosition.js';
 
+/** Place and animate the walker meshes at the current position and heading, then request a scene update. */
 export function place() {
   const [x, y, z] = local.call(this, this.local);
   // Model forward is -z; a yaw of -heading turns it to the compass heading (x east, -z north).

package/src/walk/resolveWalkerPosition.js

@@ -1,28 +1,33 @@
-import { L } from '../globals/L.js';
-import { insideWalker } from '../collision/insideWalker.js';
-
-export function resolveWalkerPosition() {
-  if (!this.saved || !insideWalker(this)) return false;
-  const map = this.layer._map;
-  const origin = this.state.latlng;
-  const height = this.state.height;
-  let distance, angle, candidate;
-  for (distance = 0.5; distance <= 20; distance += 0.5) {
-    for (angle = 0; angle < Math.PI * 2; angle += Math.PI / 4) {
-      candidate = /* alloc */ new L.LatLng(
-        origin.lat + Math.cos(angle) * distance / 111320,
-        origin.lng + Math.sin(angle) * distance / (111320 * Math.cos(origin.lat * Math.PI / 180))
-      );
-      this.state.latlng = candidate;
-      this.state.height = 0;
-      if (!insideWalker(this)) {
-        this.verticalSpeed = 0;
-        map.setView(candidate, map.getZoom(), /* alloc */ { animate: false });
-        return true;
-      }
-    }
-  }
-  this.state.latlng = origin;
-  this.state.height = height;
-  return false;
-}
+import { L } from '../globals/L.js';
+import { insideWalker } from '../collision/insideWalker.js';
+
+/**
+ * Search nearby positions when the active walker is enclosed, restoring the original position if none is clear.
+ *
+ * @returns {boolean} Whether the walker was moved to a clear position.
+ */
+export function resolveWalkerPosition() {
+  if (!this.saved || !insideWalker(this)) return false;
+  const map = this.layer._map;
+  const origin = this.state.latlng;
+  const height = this.state.height;
+  let distance, angle, candidate;
+  for (distance = 0.5; distance <= 20; distance += 0.5) {
+    for (angle = 0; angle < Math.PI * 2; angle += Math.PI / 4) {
+      candidate = /* alloc */ new L.LatLng(
+        origin.lat + Math.cos(angle) * distance / 111320,
+        origin.lng + Math.sin(angle) * distance / (111320 * Math.cos(origin.lat * Math.PI / 180))
+      );
+      this.state.latlng = candidate;
+      this.state.height = 0;
+      if (!insideWalker(this)) {
+        this.verticalSpeed = 0;
+        map.setView(candidate, map.getZoom(), /* alloc */ { animate: false });
+        return true;
+      }
+    }
+  }
+  this.state.latlng = origin;
+  this.state.height = height;
+  return false;
+}

package/src/walk/startWalking.js

@@ -12,7 +12,7 @@ import { onPointer } from './onWalkPointer.js';
 import { onTerrain } from './onWalkTerrain.js';
 import { resolveWalkerPosition } from './resolveWalkerPosition.js';
 
-
+/** Enter walk mode, saving map settings and installing input and terrain listeners. */
 export function start() {
   const map = this.layer._map;
   if (this.saved || !map) return;

package/src/walk/stepWalkerHeight.js

@@ -1,11 +1,18 @@
-export function stepWalkerHeight(dt) {
-  if (this.keys.has('Space')) {
-    this.verticalSpeed = 6;
-    this.state.height += this.verticalSpeed * dt;
-    return true;
-  }
-  if (!this.verticalSpeed && !this.state.height) return false;
-  this.state.height = Math.max(0, this.state.height + this.verticalSpeed * dt - 9.81 * dt * dt / 2);
-  this.verticalSpeed = this.state.height > 0 ? this.verticalSpeed - 9.81 * dt : 0;
-  return true;
-}
+/**
+ * Advance ascent or gravity-driven descent and report whether the walker's height changed.
+ *
+ * @param {number} dt Frame duration in seconds.
+ *
+ * @returns {boolean} Whether a vertical update was applied.
+ */
+export function stepWalkerHeight(dt) {
+  if (this.keys.has('Space')) {
+    this.verticalSpeed = 6;
+    this.state.height += this.verticalSpeed * dt;
+    return true;
+  }
+  if (!this.verticalSpeed && !this.state.height) return false;
+  this.state.height = Math.max(0, this.state.height + this.verticalSpeed * dt - 9.81 * dt * dt / 2);
+  this.verticalSpeed = this.state.height > 0 ? this.verticalSpeed - 9.81 * dt : 0;
+  return true;
+}

package/src/walk/stopWalking.js

@@ -6,6 +6,7 @@ import { onBlur } from './onWalkBlur.js';
 import { onPointer } from './onWalkPointer.js';
 import { onTerrain } from './onWalkTerrain.js';
 
+/** Leave walk mode, release walker meshes and listeners, and restore the saved map settings. */
 export function stop() {
   const map = this.layer._map;
   cancelAnimationFrame(this.frame);

package/src/walk/toggleWalking.js

@@ -1,6 +1,7 @@
 import { start } from './startWalking.js';
 import { stop } from './stopWalking.js';
 
-export function toggle() {
-  if (this.saved) stop.call(this); else start.call(this);
+/** Toggle the control between walk mode and the normal map view. */
+export function toggle() {
+  if (this.saved) stop.call(this); else start.call(this);
 }

package/src/walk/updateWalkerFrame.js

@@ -1,19 +1,29 @@
-import { wrap } from '../utils/wrap.js';
-import { place } from './placeWalker.js';
-import { land } from './landWalker.js';
-import { moveWalker } from './moveWalker.js';
-import { updateWalkerView } from './updateWalkerView.js';
-
-export function updateWalkerFrame(walker, previousY, forward, turn, dt, changed) {
-  if (turn) {
-    walker.state.heading = wrap(walker.state.heading + turn * 2.5 * dt);
-    changed = true;
-  }
-  if (forward) {
-    moveWalker.call(walker, forward, dt);
-    changed = true;
-  }
-  if (changed) land.call(walker, previousY);
-  if (updateWalkerView.call(walker, forward, turn, dt)) changed = true;
-  if (changed) place.call(walker);
-}
+import { wrap } from '../utils/wrap.js';
+import { place } from './placeWalker.js';
+import { land } from './landWalker.js';
+import { moveWalker } from './moveWalker.js';
+import { updateWalkerView } from './updateWalkerView.js';
+
+/**
+ * Apply heading, motion, landing and camera changes, repositioning meshes when the frame changes.
+ *
+ * @param {Object} walker Walk context.
+ * @param {number} previousY Previous world-space feet height.
+ * @param {number} forward Signed movement direction.
+ * @param {number} turn Signed turning direction.
+ * @param {number} dt Frame duration in seconds.
+ * @param {boolean} changed Whether the walker already changed this frame.
+ */
+export function updateWalkerFrame(walker, previousY, forward, turn, dt, changed) {
+  if (turn) {
+    walker.state.heading = wrap(walker.state.heading + turn * 2.5 * dt);
+    changed = true;
+  }
+  if (forward) {
+    moveWalker.call(walker, forward, dt);
+    changed = true;
+  }
+  if (changed) land.call(walker, previousY);
+  if (updateWalkerView.call(walker, forward, turn, dt)) changed = true;
+  if (changed) place.call(walker);
+}

package/src/walk/updateWalkerView.js

@@ -1,22 +1,31 @@
-import { degrees } from '../globals/degrees.js';
-import { radians } from '../globals/radians.js';
-import { mapGetBearing } from '../camera/mapGetBearing.js';
-import { mapSetPitchAndBearing } from '../camera/mapSetPitchAndBearing.js';
-import { mapGetPitch } from '../camera/mapGetPitch.js';
-import { wrap } from '../utils/wrap.js';
-
-export function updateWalkerView(forward, turn, dt) {
-  const map = this.layer._map;
-  if (forward || turn) {
-    // Swing the camera behind the walker.
-    const bearing = mapGetBearing(map) * radians, behind = wrap(-this.state.heading - bearing);
-    if (Math.abs(behind) > 1e-3) mapSetPitchAndBearing(map, mapGetPitch(map), (bearing + behind * Math.min(1, dt * 4)) * degrees);
-    map.setView(this.state.latlng, map.getZoom(), /* alloc */ { animate: false });
-  }
-  const target = forward ? 0.9 : 0;
-  if (Math.abs(this.swing - target) > 1e-3) {
-    this.swing += (target - this.swing) * Math.min(1, dt * 10);
-    return true;
-  }
-  return false;
-}
+import { degrees } from '../globals/degrees.js';
+import { radians } from '../globals/radians.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+import { mapSetPitchAndBearing } from '../camera/mapSetPitchAndBearing.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { wrap } from '../utils/wrap.js';
+
+/**
+ * Follow movement with the map camera and ease the limb swing toward its active or idle amplitude.
+ *
+ * @param {number} forward Signed movement direction.
+ * @param {number} turn Signed turning direction.
+ * @param {number} dt Frame duration in seconds.
+ *
+ * @returns {boolean} Whether the limb swing was updated.
+ */
+export function updateWalkerView(forward, turn, dt) {
+  const map = this.layer._map;
+  if (forward || turn) {
+    // Swing the camera behind the walker.
+    const bearing = mapGetBearing(map) * radians, behind = wrap(-this.state.heading - bearing);
+    if (Math.abs(behind) > 1e-3) mapSetPitchAndBearing(map, mapGetPitch(map), (bearing + behind * Math.min(1, dt * 4)) * degrees);
+    map.setView(this.state.latlng, map.getZoom(), /* alloc */ { animate: false });
+  }
+  const target = forward ? 0.9 : 0;
+  if (Math.abs(this.swing - target) > 1e-3) {
+    this.swing += (target - this.swing) * Math.min(1, dt * 10);
+    return true;
+  }
+  return false;
+}

package/src/weakmaps/README.md

@@ -0,0 +1,33 @@
+# Private state
+
+[Source guide](../README.md) | [Project README](../../README.md)
+
+Stores state associated with layers, maps and other objects in dedicated
+WeakMap modules. Field indexes group maps for lifecycle and compatibility.
+
+## Ownership
+
+```mermaid
+flowchart LR
+  Map["Map"] -->|"renderers"| Owner["Shared owner layer"]
+  Member["Member layer"] -->|"sharedByLayer"| Owner
+  Member -->|"rendererByLayer"| Renderer["Shared renderer"]
+  Owner -->|"rendererByLayer"| Renderer
+  Layer["Source layer"] -->|"directoriesByLayer"| Cache["Directory cache"]
+  Map -->|"cameraPitchByMap"| Pitch["Pitch"]
+```
+
+Each label names a dedicated `WeakMap` imported directly by its consumers.
+Keys can also be meshes or devices. `get` returning `undefined` differs from a
+stored `null`.
+
+On owner removal, [onRemove3DLayer.js](../scene/onRemove3DLayer.js) transfers
+selected fields or releases the last shared scene. Weak keys do **not** abort
+requests, remove listeners or destroy GPU resources.
+
+[sceneFields.js](./sceneFields.js) indexes selected maps for lifecycle and test
+compatibility; [cameraFields.js](./cameraFields.js) is a test compatibility
+index. They reference the original maps, not copies. When adding state, use a
+dedicated module and update indexes and lifecycle lists only where applicable.
+
+Related: [scene](../scene/README.md), [camera](../camera/README.md), [globals](../globals/README.md).

package/src/weakmaps/addedByLayer.js

@@ -1 +1,6 @@
+/**
+ * Deferred layer-attachment promises and resolvers, keyed by layer.
+ *
+ * @type {WeakMap<Object, Object>}
+ */
 export const addedByLayer = new WeakMap();

package/src/weakmaps/archiveHeaderByLayer.js

@@ -1 +1,6 @@
+/**
+ * Cached archive headers keyed by source layer.
+ *
+ * @type {WeakMap<Object, Object>}
+ */
 export const archiveHeaderByLayer = new WeakMap();

package/src/weakmaps/areasByLayer.js

@@ -1 +1,6 @@
+/**
+ * Source area maps and their request state, keyed by layer.
+ *
+ * @type {WeakMap<Object, Map>}
+ */
 export const areasByLayer = new WeakMap();

package/src/weakmaps/boundsMethods.js

@@ -1 +1,6 @@
+/**
+ * Original Leaflet bounds methods saved for native layers.
+ *
+ * @type {WeakMap<Object, Function>}
+ */
 export const boundsMethods = new WeakMap();

package/src/weakmaps/bridgeMeshByLayer.js

@@ -1 +1,6 @@
+/**
+ * Terrain bridge meshes keyed by layer.
+ *
+ * @type {WeakMap<Object, Object|null>}
+ */
 export const bridgeMeshByLayer = new WeakMap();

package/src/weakmaps/bridgesByLayer.js

@@ -1 +1,6 @@
+/**
+ * Spatial bridge indexes used for elevation lookup, keyed by layer.
+ *
+ * @type {WeakMap<Object, Map|null>}
+ */
 export const bridgesByLayer = new WeakMap();

package/src/weakmaps/cameraAnimationByMap.js

@@ -1 +1,6 @@
+/**
+ * Active camera animations keyed by map.
+ *
+ * @type {WeakMap<Object, Object|null>}
+ */
 export const cameraAnimationByMap = new WeakMap();

package/src/weakmaps/cameraBearingByMap.js

@@ -1 +1,6 @@
+/**
+ * Camera bearings in degrees keyed by map.
+ *
+ * @type {WeakMap<Object, number>}
+ */
 export const cameraBearingByMap = new WeakMap();

package/src/weakmaps/cameraByLayer.js

@@ -1 +1,6 @@
+/**
+ * Scene cameras used for rendering and picking, keyed by layer.
+ *
+ * @type {WeakMap<Object, Object|null>}
+ */
 export const cameraByLayer = new WeakMap();

package/src/weakmaps/cameraDraggableByMap.js

@@ -1 +1,6 @@
+/**
+ * Leaflet draggable instances used by camera controls, keyed by map.
+ *
+ * @type {WeakMap<Object, Object>}
+ */
 export const cameraDraggableByMap = new WeakMap();

package/src/weakmaps/cameraFields.js

@@ -16,6 +16,11 @@ import { timeControlByMap } from './timeControlByMap.js';
 import { touchPitchByMap } from './touchPitchByMap.js';
 import { touchRotateByMap } from './touchRotateByMap.js';
 
+/**
+ * Index camera and control state maps by their compatibility field names.
+ *
+ * @type {Object<string, WeakMap>}
+ */
 export const cameraFields = {
   "_cameraAnimation": cameraAnimationByMap,
   "_cameraBearing": cameraBearingByMap,

package/src/weakmaps/cameraFrameByMap.js

@@ -1 +1,6 @@
+/**
+ * Scheduled camera animation frame identifiers keyed by map.
+ *
+ * @type {WeakMap<Object, number|null>}
+ */
 export const cameraFrameByMap = new WeakMap();

package/src/weakmaps/cameraHandlersByMap.js

@@ -1 +1,6 @@
-export const cameraHandlersByMap = new WeakMap();
+/**
+ * Camera interaction handlers indexed by name for each map.
+ *
+ * @type {WeakMap<Object, Map>}
+ */
+export const cameraHandlersByMap = new WeakMap();

package/src/weakmaps/cameraMaps.js

@@ -1 +1,6 @@
+/**
+ * Maps initialized with camera support.
+ *
+ * @type {WeakSet<Object>}
+ */
 export const cameraMaps = new WeakSet();

package/src/weakmaps/cameraPitchByMap.js

@@ -1 +1,6 @@
+/**
+ * Camera pitch values in degrees keyed by map.
+ *
+ * @type {WeakMap<Object, number>}
+ */
 export const cameraPitchByMap = new WeakMap();

package/src/weakmaps/cameraReadyByMap.js

@@ -1 +1,6 @@
+/**
+ * Camera control initialization promises keyed by map.
+ *
+ * @type {WeakMap<Object, Promise>}
+ */
 export const cameraReadyByMap = new WeakMap();

package/src/weakmaps/cameraTouchStateByMap.js

@@ -1 +1,6 @@
+/**
+ * Camera touch interaction state keyed by map.
+ *
+ * @type {WeakMap<Object, Object>}
+ */
 export const cameraTouchStateByMap = new WeakMap();