leaflet-city-mapper 0.0.1 → 0.0.3

package/src/constants/onZoomAnimState.js

@@ -0,0 +1 @@
+export const onZoomAnimState = {};

package/src/constants/paints.js

@@ -0,0 +1,10 @@
+// Built-in vehicles for the 'traffic' type. Models are [ring of [x, z], bottom, top, rgb, topRing?] convex prisms in metres;
+// forward is -z, right is +x. `topRing` (same length as `ring`) tapers the prism; rgb components above 1 are self-lit lamps.
+export const paints = [
+  [0.86, 0.86, 0.88],
+  [0.1, 0.1, 0.12],
+  [0.5, 0.53, 0.57],
+  [0.65, 0.1, 0.08],
+  [0.12, 0.25, 0.55],
+  [0.85, 0.7, 0.15]
+];

package/src/constants/parts.js

@@ -0,0 +1,19 @@
+import { box } from "../geometry/box.js";
+import { trousers } from './trousers.js';
+import { shirt } from './shirt.js';
+import { skin } from './skin.js';
+import { dark } from './dark.js';
+
+
+export const parts = {
+  body: [
+    [box(-0.17, 0.17, -0.1, 0.1), 0.82, 0.95, trousers],
+    [box(-0.19, 0.19, -0.11, 0.11), 0.95, 1.44, shirt],
+    [box(-0.05, 0.05, -0.05, 0.05), 1.44, 1.5, skin],
+    [box(-0.1, 0.1, -0.11, 0.1), 1.5, 1.72, skin],
+    [box(-0.105, 0.105, -0.06, 0.115), 1.58, 1.77, dark],
+    [box(-0.105, 0.105, -0.115, -0.06), 1.7, 1.77, dark],
+  ],
+  leg: [[box(-0.07, 0.07, -0.07, 0.07), -0.82, 0, trousers], [box(-0.07, 0.07, -0.17, 0.07), -0.9, -0.82, dark]],
+  arm: [[box(-0.05, 0.05, -0.05, 0.05), -0.55, 0, shirt], [box(-0.045, 0.045, -0.045, 0.045), -0.66, -0.55, skin]],
+};

package/src/constants/pendingUpdates.js

@@ -0,0 +1 @@
+export const pendingUpdates = new Set();

package/src/constants/pumpState.js

@@ -0,0 +1 @@
+export const pumpState = {};

package/src/constants/renderers.js

@@ -0,0 +1,2 @@
+/** Rendering owner per map; entries are removed on the last layer removal. */
+export const renderers = new WeakMap();

package/src/constants/ringDirections.js

@@ -0,0 +1,10 @@
+export const ringDirections = [
+  { x: Math.cos(0 * Math.PI / 4), y: Math.sin(0 * Math.PI / 4), nx: Math.cos((0 + 0.5) * Math.PI / 4), nz: -Math.sin((0 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(1 * Math.PI / 4), y: Math.sin(1 * Math.PI / 4), nx: Math.cos((1 + 0.5) * Math.PI / 4), nz: -Math.sin((1 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(2 * Math.PI / 4), y: Math.sin(2 * Math.PI / 4), nx: Math.cos((2 + 0.5) * Math.PI / 4), nz: -Math.sin((2 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(3 * Math.PI / 4), y: Math.sin(3 * Math.PI / 4), nx: Math.cos((3 + 0.5) * Math.PI / 4), nz: -Math.sin((3 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(4 * Math.PI / 4), y: Math.sin(4 * Math.PI / 4), nx: Math.cos((4 + 0.5) * Math.PI / 4), nz: -Math.sin((4 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(5 * Math.PI / 4), y: Math.sin(5 * Math.PI / 4), nx: Math.cos((5 + 0.5) * Math.PI / 4), nz: -Math.sin((5 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(6 * Math.PI / 4), y: Math.sin(6 * Math.PI / 4), nx: Math.cos((6 + 0.5) * Math.PI / 4), nz: -Math.sin((6 + 0.5) * Math.PI / 4) },
+  { x: Math.cos(7 * Math.PI / 4), y: Math.sin(7 * Math.PI / 4), nx: Math.cos((7 + 0.5) * Math.PI / 4), nz: -Math.sin((7 + 0.5) * Math.PI / 4) },
+];

package/src/constants/roundProfile.js

@@ -0,0 +1 @@
+export const roundProfile = [[0, 0], [0.35, 0.8], [0.6, 1], [0.85, 0.7], [1, 0]];

package/src/constants/shirt.js

@@ -0,0 +1 @@
+export const shirt = [0.75, 0.2, 0.15];

package/src/constants/skin.js

@@ -0,0 +1,2 @@
+// Pedestrian, about 1.77 m tall, prisms as in utils/vehicles.js (forward -z). Limbs hang from their pivot at y = 0.
+export const skin = [0.85, 0.64, 0.5];

package/src/constants/speed.js

@@ -0,0 +1,3 @@
+// Pure helpers of the 'traffic' type: lane interpolation and vehicle scheduling.
+/** Default urban speed (m/s) used to turn a lane's hourly `flow` into vehicles on the road. */
+export const speed = 8;

package/src/constants/taillight.js

@@ -0,0 +1 @@
+export const taillight = [1.7, 0.06, 0.05];

package/src/constants/trafficShader.js

@@ -0,0 +1,49 @@
+// One workgroup per vehicle shares its lane lookup and pose across all model vertices.
+export const trafficShader = /* wgsl */ `
+  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>;
+  var<workgroup> center: vec3f;
+  var<workgroup> heading: vec2f;
+  @compute @workgroup_size(64)
+  fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) thread: u32) {
+    let vehicleIndex = group.x;
+    if (thread == 0u) {
+      let vehicle = vehicles[vehicleIndex];
+      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;
+      var end = last;
+      while (i < end) {
+        let middle = i + (end - i) / 2u;
+        if (points[middle].w < s) { i = middle + 1u; }
+        else { end = middle; }
+      }
+      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;
+      heading = (b.xy - a.xy) / d;
+      center = vec3f(a.x + (b.x - a.x) * t - heading.y * params.side,
+        a.z + (b.z - a.z) * t, a.y + (b.y - a.y) * t + heading.x * params.side);
+    }
+    workgroupBarrier();
+    for (var vertex = thread; vertex < params.vertices; vertex += 64u) {
+      let k = vertex * 3u;
+      let n = params.vertices * 3u + k;
+      let o = (vehicleIndex * params.vertices + vertex) * 3u;
+      position[o] = center.x - model[k] * heading.y - model[k + 2u] * heading.x;
+      position[o + 1u] = center.y + model[k + 1u];
+      position[o + 2u] = center.z + model[k] * heading.x - model[k + 2u] * heading.y;
+      normal[o] = -model[n] * heading.y - model[n + 2u] * heading.x;
+      normal[o + 1u] = model[n + 1u];
+      normal[o + 2u] = model[n] * heading.x - model[n + 2u] * heading.y;
+    }
+  }`;

package/src/constants/trousers.js

@@ -0,0 +1 @@
+export const trousers = [0.16, 0.2, 0.32];

package/src/constants/tyre.js

@@ -0,0 +1 @@
+export const tyre = [0.05, 0.05, 0.05];

package/src/constants/underEntryState.js

@@ -0,0 +1 @@
+export const underEntryState = {};

package/src/constants/vehicles.js

@@ -0,0 +1,40 @@
+import { carModel } from '../vehicles/carModel.js';
+import { boatModel } from '../vehicles/boatModel.js';
+import { busModel } from '../vehicles/busModel.js';
+import { tramModel } from '../vehicles/tramModel.js';
+import { metroModel } from '../vehicles/metroModel.js';
+import { bicycleModel } from '../vehicles/bicycleModel.js';
+import { pedestrianModel } from '../vehicles/pedestrianModel.js';
+
+/**
+ * `side`: default offset (metres) to the right of the lane centreline. `model(i)` gives the prisms of the i-th vehicle.
+ * `lights`: night point lights in model space (see the night lighting grid), e.g. the pool cast by the headlights.
+ */
+export const vehicles = {
+  bicycle: { side: 0.4, model: bicycleModel },
+  pedestrian: { side: 0.3, model: pedestrianModel },
+  bus: { side: 1.5, model: busModel },
+  tram: { side: 0, model: tramModel },
+  metro: { side: 0, model: metroModel },
+  car: {
+    side: 1.8,
+    model: carModel,
+    lights: [{
+      position: [0, 1.2, -6],
+      radius: 10,
+      color: [1, 0.94, 0.82],
+      flux: 800
+    }]
+  },
+  // Panoramic river cruiser, about 60 × 11 m: glass saloon, open upper deck with benches, wheelhouse forward.
+  boat: {
+    side: 0,
+    model: boatModel,
+    lights: [{
+      position: [0, 8, 4],
+      radius: 30,
+      color: [1, 0.8, 0.55],
+      flux: 20000
+    }]
+  },
+};

package/src/constants/white.js

@@ -0,0 +1 @@
+export const white = [0.92, 0.93, 0.92];

package/src/controls/acceptPitchDrag.js

@@ -0,0 +1,4 @@
+export function acceptPitchDrag(event) {
+  return !event.target.closest('.leaflet-control,.leaflet-marker-icon,.leaflet-popup') &&
+    (event.button === 2 || event.button === 0 && event.ctrlKey);
+}

package/src/controls/acceptRotateDrag.js

@@ -0,0 +1,3 @@
+export function acceptRotateDrag(event) {
+  return event.button === 0;
+}

package/src/controls/adjustCameraDrag.js

@@ -0,0 +1,10 @@
+import { project } from '../camera/project.js';
+
+export function adjustCameraDrag() {
+  const map = this;
+  const draggable = map._cameraDraggable;
+  if (!map.getPitch() && !map.getBearing()) return;
+  const half = map.getSize().divideBy(2), delta = draggable._newPos.subtract(draggable._startPos);
+  const ground = half.subtract(project(map, half.subtract(delta), true));
+  draggable._newPos = draggable._startPos.add(ground);
+}

package/src/controls/cameraControls.js

@@ -0,0 +1,60 @@
+import { ShiftRotate } from '../constants/ShiftRotate.js';
+import { PitchDrag } from '../constants/PitchDrag.js';
+import { Compass } from '../constants/Compass.js';
+import { ContainerResize } from '../constants/ContainerResize.js';
+import { TouchMode } from '../constants/TouchMode.js';
+import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { rotateOnAdd } from './rotateOnAdd.js';
+import { rotateOnRemove } from './rotateOnRemove.js';
+import { rotateControl } from './rotateControl.js';
+import { shiftRotateAddHooks } from './shiftRotateAddHooks.js';
+import { shiftRotateRemoveHooks } from './shiftRotateRemoveHooks.js';
+import { pitchDragAddHooks } from './pitchDragAddHooks.js';
+import { pitchDragRemoveHooks } from './pitchDragRemoveHooks.js';
+import { compassAddHooks } from './compassAddHooks.js';
+import { compassRemoveHooks } from './compassRemoveHooks.js';
+import { containerResizeAddHooks } from './containerResizeAddHooks.js';
+import { containerResizeRemoveHooks } from './containerResizeRemoveHooks.js';
+import { startCameraTouch } from './startCameraTouch.js';
+import { moveCameraTouch } from './moveCameraTouch.js';
+import { endCameraTouchEvent } from './endCameraTouchEvent.js';
+import { changeCameraTouch } from './changeCameraTouch.js';
+import { cleanupCameraTouch } from './cleanupCameraTouch.js';
+import { endAllCameraTouches } from './endAllCameraTouches.js';
+
+cameraControlsState.cameraDrags = new Set();
+cameraControlsState.dragStates = new WeakMap();
+cameraControlsState.cameraTouchStates = new Set();
+
+L.Control.Rotate = L.Control.extend({
+  options: { position: 'topleft', closeOnZeroBearing: true, visualizePitch: true },
+  onAdd: rotateOnAdd,
+  onRemove: rotateOnRemove,
+});
+
+if (L.control) L.control.rotate = rotateControl;
+
+export function cameraControls(map) {
+  map.addHandler('trackContainerMutation', ContainerResize);
+  if (!map.options.rotate) return;
+  map.addHandler('shiftKeyRotate', ShiftRotate);
+  map.addHandler('pitchDrag', PitchDrag);
+  map.addHandler('compassBearing', Compass);
+  map.addHandler('touchRotate', TouchMode);
+  map.addHandler('touchPitch', TouchMode);
+  const container = map.getContainer();
+  const state = map._cameraTouchState = { map, container, touch: null, nativeZoom: undefined };
+  container._cameraTouchState = state;
+  cameraControlsState.cameraTouchStates.add(state);
+  container.addEventListener('touchstart', startCameraTouch, { capture: true, passive: false });
+  container.addEventListener('touchmove', moveCameraTouch, { capture: true, passive: false });
+  container.addEventListener('touchend', endCameraTouchEvent, true);
+  container.addEventListener('touchcancel', endCameraTouchEvent, true);
+  window.addEventListener('blur', endAllCameraTouches);
+  map.on('cameratouchchange', changeCameraTouch, map);
+  if (map.options.rotateControl) {
+    map.rotateControl = new L.Control.Rotate(typeof map.options.rotateControl === 'object' ? map.options.rotateControl : {});
+    map.rotateControl.addTo(map);
+  }
+  map.once('unload', cleanupCameraTouch, map);
+}

package/src/controls/cameraDragClick.js

@@ -0,0 +1,9 @@
+import { cameraControlsState } from '../constants/cameraControlsState.js';
+
+export function cameraDragClick(event) {
+  const state = cameraControlsState.dragStates.get(this);
+  if (!state.moved) return;
+  event.preventDefault();
+  event.stopPropagation();
+  state.moved = false;
+}

package/src/controls/cameraDragContextMenu.js

@@ -0,0 +1,8 @@
+import { cameraControlsState } from '../constants/cameraControlsState.js';
+
+export function cameraDragContextMenu(event) {
+  const state = cameraControlsState.dragStates.get(this);
+  if (!state.drag && !state.moved) return;
+  event.preventDefault();
+  event.stopPropagation();
+}

package/src/controls/cameraDragDown.js

@@ -0,0 +1,20 @@
+import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { editable } from './editable.js';
+
+export function cameraDragDown(event) {
+  const state = cameraControlsState.dragStates.get(this);
+  if (state.drag || !state.accept(event) || editable(event.target)) return;
+  event.preventDefault();
+  event.stopPropagation();
+  state.moved = false;
+  const rect = state.map.getContainer().getBoundingClientRect();
+  state.drag = {
+    id: event.pointerId, x: event.clientX, y: event.clientY, cursor: state.element.style.cursor,
+    cx: rect.left + rect.width / 2, cy: rect.top + rect.height / 2,
+    dragging: state.map.dragging?.enabled(),
+  };
+  state.map.dragging?.disable();
+  state.element.focus?.({ preventScroll: true });
+  state.element.setPointerCapture(event.pointerId);
+  state.element.style.cursor = 'grabbing';
+}

package/src/controls/cameraDragEnd.js

@@ -0,0 +1,6 @@
+import { finishCameraDrag } from './finishCameraDrag.js';
+import { cameraControlsState } from '../constants/cameraControlsState.js';
+
+export function cameraDragEnd(event) {
+  finishCameraDrag(cameraControlsState.dragStates.get(this), event);
+}

package/src/controls/cameraDragMove.js

@@ -0,0 +1,23 @@
+import { cameraControlsState } from '../constants/cameraControlsState.js';
+
+export function cameraDragMove(event) {
+  const state = cameraControlsState.dragStates.get(this);
+  if (!state.drag || state.drag.id !== event.pointerId) return;
+  const x = event.clientX - state.drag.x, y = event.clientY - state.drag.y;
+  if (Math.hypot(x, y) < 3 && !state.moved) return;
+  state.map._stopPitchBearingAnimation();
+  state.moved = true;
+  event.preventDefault();
+  let bearing = x * state.sensitivity[0];
+  if (state.orbit) {
+    if (Math.abs(state.drag.cy - state.drag.y) > 100) {
+      const angle = Math.atan2(event.clientY - state.drag.cy, event.clientX - state.drag.cx) -
+        Math.atan2(event.clientY - state.drag.cy, state.drag.x - state.drag.cx);
+      bearing = Math.atan2(Math.sin(angle), Math.cos(angle)) * 180 / Math.PI;
+    } else bearing *= event.clientY < state.drag.cy ? 1 : -1;
+  }
+  state.map._setPitchAndBearing(state.map.getPitch() - y * state.sensitivity[1],
+    state.map.getBearing() + bearing);
+  state.drag.x = event.clientX;
+  state.drag.y = event.clientY;
+}

package/src/controls/changeCameraTouch.js

@@ -0,0 +1,14 @@
+import { endCameraTouch } from './endCameraTouch.js';
+
+export function changeCameraTouch() {
+  const state = this._cameraTouchState, { map, container } = state;
+  const active = map.touchRotate.enabled() || map.touchPitch.enabled();
+  if (active && state.nativeZoom === undefined) {
+    state.nativeZoom = map.touchZoom?.enabled();
+    map.touchZoom?.disable();
+  } else if (!active && state.nativeZoom !== undefined) {
+    endCameraTouch(state);
+    if (state.nativeZoom && container._leaflet_id) map.touchZoom.enable();
+    state.nativeZoom = undefined;
+  }
+}

package/src/controls/cleanupCameraTouch.js

@@ -0,0 +1,24 @@
+import { endCameraTouch } from './endCameraTouch.js';
+import { startCameraTouch } from './startCameraTouch.js';
+import { moveCameraTouch } from './moveCameraTouch.js';
+import { endCameraTouchEvent } from './endCameraTouchEvent.js';
+import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { endAllCameraTouches } from './endAllCameraTouches.js';
+import { changeCameraTouch } from './changeCameraTouch.js';
+
+export function cleanupCameraTouch() {
+  const state = this._cameraTouchState;
+  if (!state) return;
+  const { container, map } = state;
+  endCameraTouch(state);
+  container.removeEventListener('touchstart', startCameraTouch, true);
+  container.removeEventListener('touchmove', moveCameraTouch, true);
+  container.removeEventListener('touchend', endCameraTouchEvent, true);
+  container.removeEventListener('touchcancel', endCameraTouchEvent, true);
+  cameraControlsState.cameraTouchStates.delete(state);
+  if (!cameraControlsState.cameraTouchStates.size) window.removeEventListener('blur', endAllCameraTouches);
+  map.off('cameratouchchange', changeCameraTouch, map);
+  map.rotateControl?.remove();
+  delete container._cameraTouchState;
+  delete map._cameraTouchState;
+}

package/src/controls/compassAddHooks.js

@@ -0,0 +1,15 @@
+import { compassOrientation } from './compassOrientation.js';
+import { finishCompassPermission } from './finishCompassPermission.js';
+
+export function compassAddHooks() {
+  this._compassGeneration = (this._generation = (this._generation || 0) + 1);
+  this._orientation = { handler: this, handleEvent: compassOrientation };
+  const permission = window.DeviceOrientationEvent?.requestPermission;
+  let request;
+  try {
+    request = permission ? permission.call(window.DeviceOrientationEvent) : 'granted';
+  } catch (error) {
+    request = Promise.reject(error);
+  }
+  Promise.allSettled([Promise.resolve({ handler: this, generation: this._generation }), request]).then(finishCompassPermission);
+}

package/src/controls/compassOrientation.js

@@ -0,0 +1,6 @@
+export function compassOrientation(event) {
+  const handler = this.handler;
+  const bearing = Number.isFinite(event.webkitCompassHeading) ? -event.webkitCompassHeading : event.alpha;
+  const orientation = event.absolute ? 0 : (screen.orientation?.angle ?? window.orientation ?? 0);
+  if (Number.isFinite(bearing)) handler._map.setBearing(bearing - orientation);
+}

package/src/controls/compassRemoveHooks.js

@@ -0,0 +1,5 @@
+export function compassRemoveHooks() {
+  this._generation++;
+  window.removeEventListener('deviceorientation', this._orientation);
+  window.removeEventListener('deviceorientationabsolute', this._orientation);
+}

package/src/controls/containerResizeAddHooks.js

@@ -0,0 +1,8 @@
+import { resizeMap } from './resizeMap.js';
+
+export function containerResizeAddHooks() {
+  const container = this._map.getContainer();
+  container._containerResizeMap = this._map;
+  this._observer = new ResizeObserver(resizeMap);
+  this._observer.observe(container);
+}

package/src/controls/containerResizeRemoveHooks.js

@@ -0,0 +1,5 @@
+export function containerResizeRemoveHooks() {
+  const container = this._map.getContainer();
+  this._observer.disconnect();
+  delete container._containerResizeMap;
+}

package/src/controls/dragCamera.js

@@ -0,0 +1,22 @@
+import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { cameraDragDown } from './cameraDragDown.js';
+import { cameraDragMove } from './cameraDragMove.js';
+import { cameraDragEnd } from './cameraDragEnd.js';
+import { cameraDragClick } from './cameraDragClick.js';
+import { cameraDragContextMenu } from './cameraDragContextMenu.js';
+import { endAllCameraDrags } from './endAllCameraDrags.js';
+
+export function dragCamera(map, element, accept, sensitivity = [0.8, 0.5], orbit = false) {
+  const state = { map, element, accept, sensitivity, orbit, drag: null, moved: false };
+  cameraControlsState.dragStates.set(element, state);
+  cameraControlsState.cameraDrags.add(state);
+  element.addEventListener('pointerdown', cameraDragDown, true);
+  element.addEventListener('pointermove', cameraDragMove);
+  element.addEventListener('pointerup', cameraDragEnd);
+  element.addEventListener('pointercancel', cameraDragEnd);
+  element.addEventListener('lostpointercapture', cameraDragEnd);
+  element.addEventListener('click', cameraDragClick, true);
+  element.addEventListener('contextmenu', cameraDragContextMenu);
+  window.addEventListener('blur', endAllCameraDrags);
+  return state;
+}

package/src/controls/editable.js

@@ -0,0 +1,3 @@
+export function editable(target) {
+  return target.closest?.('input,textarea,select,[contenteditable="true"]');
+}

package/src/controls/endAllCameraDrags.js

@@ -0,0 +1,7 @@
+import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { finishCameraDrag } from './finishCameraDrag.js';
+
+export function endAllCameraDrags() {
+  let state;
+  for (state of cameraControlsState.cameraDrags) finishCameraDrag(state);
+}

package/src/controls/endAllCameraTouches.js

@@ -0,0 +1,7 @@
+import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { endCameraTouch } from './endCameraTouch.js';
+
+export function endAllCameraTouches() {
+  let state;
+  for (state of cameraControlsState.cameraTouchStates) endCameraTouch(state);
+}

package/src/controls/endCameraTouch.js

@@ -0,0 +1,11 @@
+export function endCameraTouch(state, event) {
+  if (!state.touch) return;
+  if (event?.touches?.length >= 2) return;
+  const { map, container, touch } = state;
+  if (touch.dragging && container._leaflet_id) map.dragging.enable();
+  map.options.zoomSnap = touch.snap;
+  if (touch.zooming && touch.snap && container._leaflet_id) {
+    map.setZoom(Math.round(map.getZoom() / touch.snap) * touch.snap, { animate: false });
+  }
+  state.touch = null;
+}

package/src/controls/endCameraTouchEvent.js

@@ -0,0 +1,5 @@
+import { endCameraTouch } from './endCameraTouch.js';
+
+export function endCameraTouchEvent(event) {
+  endCameraTouch(this._cameraTouchState, event);
+}

package/src/controls/finishCameraDrag.js

@@ -0,0 +1,9 @@
+export function finishCameraDrag(state, event) {
+  if (!state?.drag) return;
+  if (event?.pointerId !== undefined && event.pointerId !== state.drag.id) return;
+  const finished = state.drag;
+  state.drag = null;
+  if (state.element.hasPointerCapture?.(finished.id)) state.element.releasePointerCapture(finished.id);
+  if (finished.dragging && state.map.getContainer()._leaflet_id) state.map.dragging.enable();
+  state.element.style.cursor = finished.cursor;
+}

package/src/controls/finishCompassPermission.js

@@ -0,0 +1,16 @@
+export function finishCompassPermission([handlerResult, permissionResult]) {
+  const { handler, generation } = handlerResult.value;
+  try {
+    if (!handler.enabled() || handler._generation !== generation) return;
+    if (!window.DeviceOrientationEvent || permissionResult.status !== 'fulfilled' ||
+      permissionResult.value !== 'granted') {
+      throw permissionResult.status === 'rejected' ? permissionResult.reason :
+        new Error('Device compass permission unavailable or denied');
+    }
+    window.addEventListener('deviceorientation', handler._orientation);
+    window.addEventListener('deviceorientationabsolute', handler._orientation);
+  } catch (error) {
+    handler.disable();
+    handler._map.fire('error', { error });
+  }
+}

package/src/controls/loadCameraControls.js

@@ -0,0 +1,9 @@
+export async function loadCameraControls(map) {
+  try {
+    const { cameraControls } = await import('./cameraControls.js');
+    if (map._container?._leaflet_id) cameraControls(map);
+  } catch (error) {
+    map.fire('error', { error });
+    throw error;
+  }
+}

package/src/controls/moveCameraTouch.js

@@ -0,0 +1,22 @@
+export function moveCameraTouch(event) {
+  const state = this._cameraTouchState, { map, container, touch } = state;
+  if (!touch || event.touches.length !== 2) return;
+  const [a, b] = event.touches;
+  const angle = Math.atan2(b.clientY - a.clientY, b.clientX - a.clientX);
+  const middle = new L.Point((a.clientX + b.clientX) / 2, (a.clientY + b.clientY) / 2)
+    .subtract(new L.Point(container.getBoundingClientRect().left, container.getBoundingClientRect().top));
+  const delta = Math.atan2(Math.sin(angle - touch.angle), Math.cos(angle - touch.angle)) * 180 / Math.PI;
+  map._setPitchAndBearing(map.touchPitch.enabled() ? touch.pitch - (middle.y - touch.middle.y) * 0.25 : touch.pitch,
+    map.touchRotate.enabled() ? touch.bearing + delta : touch.bearing);
+  const distance = Math.hypot(b.clientX - a.clientX, b.clientY - a.clientY);
+  if (distance < 1) return;
+  const zoom = touch.zooming ? Math.max(map.getMinZoom(), Math.min(map.getMaxZoom(),
+    touch.zoom + Math.log2(distance / touch.distance))) : touch.zoom;
+  map.setView(map.getCenter(), zoom, { animate: false });
+  if (map.options.touchZoom !== 'center') {
+    const projected = map.project(touch.anchor).subtract(map.project(map.containerPointToLatLng(middle)));
+    map.setView(map.unproject(map.project(map.getCenter()).add(projected)), map.getZoom(), { animate: false });
+  }
+  event.preventDefault();
+  event.stopImmediatePropagation();
+}

package/src/controls/notifyCameraTouchChange.js

@@ -0,0 +1 @@
+export function notifyCameraTouchChange() { this._map.fire('cameratouchchange'); }

package/src/controls/pitchDragAddHooks.js

@@ -0,0 +1,6 @@
+import { dragCamera } from './dragCamera.js';
+import { acceptPitchDrag } from './acceptPitchDrag.js';
+
+export function pitchDragAddHooks() {
+  this._dragState = dragCamera(this._map, this._map.getContainer(), acceptPitchDrag, [0.8, 0.5], true);
+}

package/src/controls/pitchDragRemoveHooks.js

@@ -0,0 +1,5 @@
+import { removeCameraDrag } from './removeCameraDrag.js';
+
+export function pitchDragRemoveHooks() {
+  removeCameraDrag(this._dragState);
+}

package/src/controls/refreshRotateControl.js

@@ -0,0 +1,7 @@
+export function refreshRotateControl() {
+  const map = this._map, pitch = this.options.visualizePitch ? map.getPitch() : 0;
+  this._arrow.style.transform = `scale(${1 / Math.sqrt(Math.cos(pitch * Math.PI / 180))}) rotateX(${pitch}deg) rotate(${map.getBearing()}deg)`;
+  this._button.setAttribute('aria-description', `Bearing ${Math.round(map.getBearing())} degrees, pitch ${Math.round(map.getPitch())} degrees. Arrow keys adjust the camera; Home resets it.`);
+  this._container.style.display = this.options.closeOnZeroBearing && !map.getBearing() && !pitch &&
+    !this._container.contains(document.activeElement) ? 'none' : '';
+}

package/src/controls/refreshRotateFocus.js

@@ -0,0 +1,5 @@
+import { refreshRotateControl } from './refreshRotateControl.js';
+
+export function refreshRotateFocus() {
+  refreshRotateControl.call(this._rotateControl);
+}

package/src/controls/removeCameraDrag.js

@@ -0,0 +1,23 @@
+import { finishCameraDrag } from './finishCameraDrag.js';
+import { cameraDragDown } from './cameraDragDown.js';
+import { cameraDragMove } from './cameraDragMove.js';
+import { cameraDragEnd } from './cameraDragEnd.js';
+import { cameraDragClick } from './cameraDragClick.js';
+import { cameraDragContextMenu } from './cameraDragContextMenu.js';
+import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { endAllCameraDrags } from './endAllCameraDrags.js';
+
+export function removeCameraDrag(state) {
+  finishCameraDrag(state);
+  const { element } = state;
+  element.removeEventListener('pointerdown', cameraDragDown, true);
+  element.removeEventListener('pointermove', cameraDragMove);
+  element.removeEventListener('pointerup', cameraDragEnd);
+  element.removeEventListener('pointercancel', cameraDragEnd);
+  element.removeEventListener('lostpointercapture', cameraDragEnd);
+  element.removeEventListener('click', cameraDragClick, true);
+  element.removeEventListener('contextmenu', cameraDragContextMenu);
+  cameraControlsState.dragStates.delete(element);
+  cameraControlsState.cameraDrags.delete(state);
+  if (!cameraControlsState.cameraDrags.size) window.removeEventListener('blur', endAllCameraDrags);
+}

package/src/controls/resizeMap.js

@@ -0,0 +1,3 @@
+export function resizeMap(entries) {
+  entries[0]?.target._containerResizeMap.invalidateSize();
+}

package/src/controls/rotateButtonClick.js

@@ -0,0 +1,7 @@
+export function rotateButtonClick(event) {
+  const control = this._rotateControl, map = control._map;
+  event.preventDefault();
+  if (control.options.visualizePitch) map.resetNorthPitch();
+  else map.resetNorth();
+  if (event.detail) map.getContainer().focus({ preventScroll: true });
+}