leaflet-city-mapper 0.0.2 → 0.0.4

package/src/cog/validateCogContainer.js

@@ -0,0 +1,9 @@
+export function validateCogContainer(container, header) {
+  if (header.tileType !== 0 || header.tileCompression !== 1 ||
+    !Number.isSafeInteger(header.jsonMetadataOffset) || !Number.isSafeInteger(header.jsonMetadataLength) ||
+    header.jsonMetadataLength <= 0 || header.jsonMetadataLength > 1048576 ||
+    !Number.isSafeInteger(header.tileDataOffset) || !Number.isSafeInteger(header.tileDataLength) ||
+    header.tileDataOffset < 127 || header.tileDataOffset + header.tileDataLength > container.size) {
+    throw /* alloc */ new Error('Invalid PMTiles COG asset container');
+  }
+}

package/src/cog/validateCogContentRange.js

@@ -0,0 +1,8 @@
+export function validateCogContentRange(source, range, rangeStart, length) {
+  if (!range || Number(range[1]) !== rangeStart || Number(range[2]) !== rangeStart + length - 1 ||
+    !Number.isSafeInteger(Number(range[3])) || Number(range[3]) < rangeStart + length ||
+    (source.containerSize ?? source.size) !== undefined &&
+      (source.containerSize ?? source.size) !== Number(range[3])) {
+    throw /* alloc */ new Error('Invalid COG range response');
+  }
+}

package/src/cog/validateCogOffsets.js

@@ -0,0 +1,10 @@
+export function validateCogOffsets(source, level) {
+  if (level.offsets?.length !== level.columns * level.rows || level.lengths?.length !== level.offsets.length) {
+    throw /* alloc */ new Error('Invalid COG tile offsets or lengths');
+  }
+  let i;
+  for (i = 0; i < level.offsets.length; i++) {
+    if (!level.offsets[i] || !level.lengths[i] || level.lengths[i] > 1048576 ||
+      level.offsets[i] + level.lengths[i] > source.size) throw /* alloc */ new Error('Invalid COG tile offsets or lengths');
+  }
+}

package/src/cog/validateCogRange.js

@@ -0,0 +1,7 @@
+export function validateCogRange(source, offset, length) {
+  if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 ||
+    length <= 0 || length > 32000000 || !Number.isSafeInteger(offset + length) ||
+    source.size !== undefined && offset + length > source.size) {
+    throw /* alloc */ new Error('Invalid COG byte range');
+  }
+}

package/src/cog/validateCogResponse.js

@@ -0,0 +1,15 @@
+import { validateCogContentRange } from './validateCogContentRange.js';
+import { invalidCogFullResponse } from './invalidCogFullResponse.js';
+
+export function validateCogResponse(source, response, rangeStart, length) {
+  const etag = response.headers.get('ETag');
+  if (source.etag && source.etag !== etag) throw /* alloc */ new Error('COG changed; recreate the layer');
+  if (etag) source.etag = etag;
+  const range = /^bytes (\d+)-(\d+)\/(\d+)$/.exec(response.headers.get('Content-Range') || '');
+  if (response.status === 206) {
+    validateCogContentRange(source, range, rangeStart, length);
+    if (source.baseOffset === undefined) source.size = Number(range[3]);
+  } else if (invalidCogFullResponse(response)) {
+    throw /* alloc */ new Error('COG server must support byte ranges for files over 32 MB');
+  }
+}

package/src/collision/collectMeshes.js

@@ -0,0 +1,5 @@
+export function collectMeshes(node, meshes) {
+  if (node.geometry?.attributes.position) meshes.push(node);
+  let child;
+  for (child of node.children) collectMeshes(child, meshes);
+}

package/src/collision/collider.js

@@ -0,0 +1,56 @@
+import { colliders } from '../globals/colliders.js';
+import { transformTriangle } from './transformTriangle.js';
+import { indexTriangle } from './indexTriangle.js';
+
+
+export function collider(mesh) {
+  let c = colliders.get(mesh.geometry);
+  if (c) return c;
+  const m = mesh.worldMatrix, { position: { data: p }, index, normal, uv } = mesh.geometry.attributes;
+
+  const count = index ? index.count : p.length / 3;
+  const tri = /* alloc */ [];
+  const nrm = /* alloc */ [];
+  const cells = /* alloc */ new Map();
+  const v = /* alloc */ [];
+
+  let i, first, j, ex, ey, ez, fx, fy, fz, nx, nz, ny, length, a, h, t;
+  for (i = 0; i < count; i += 3) {
+    first = index ? index.data[i] : i;
+    // Streetlight halos (uv.x <= 2, see scene/picking.js) are light, not matter.
+    if (mesh.program.nightLight && uv && uv.data[first * 2] <= 2) {
+      continue;
+    }
+    transformTriangle(v, p, index, i, m);
+    ex = v[3] - v[0], ey = v[4] - v[1], ez = v[5] - v[2], fx = v[6] - v[0], fy = v[7] - v[1], fz = v[8] - v[2];
+
+    nx = ey * fz - ez * fy, nz = ex * fy - ey * fx;
+
+    ny = ez * fx - ex * fz, length = Math.hypot(nx, ny, nz);
+
+    if (!length || Math.abs(ny) > 0.9 * length) {
+      continue;
+    }
+
+    if (normal) {
+      // The stored normal tells the outside, whatever the winding.
+      j = first * 3, a = normal.data;
+      if ((m[0] * a[j] + m[4] * a[j + 1] + m[8] * a[j + 2]) * nx + (m[2] * a[j] + m[6] * a[j + 1] + m[10] * a[j + 2]) * nz < 0) { nx = -nx; nz = -nz; }
+    }
+
+    h = Math.hypot(nx, nz), t = nrm.length / 2;
+
+    tri.push(...v);
+    nrm.push(nx / h, nz / h);
+
+    indexTriangle(cells, v, t);
+  }
+  c = /* alloc */ {
+    tri: Float32Array.from(tri),
+    nrm: Float32Array.from(nrm),
+    cells,
+    origin: /* alloc */ [m[12], m[13], m[14]]
+  };
+  colliders.set(mesh.geometry, c);
+  return c;
+}

package/src/collision/hiddenLightHit.js

@@ -0,0 +1,8 @@
+export function hiddenLightHit(mesh, i, u, v, night) {
+  if (!mesh.program.nightLight) return false;
+  const { index, uv: { data: uv } } = mesh.geometry.attributes;
+  const idA = index ? index.data[i] : i, idB = index ? index.data[i + 1] : i + 1, idC = index ? index.data[i + 2] : i + 2;
+  const x = uv[idA * 2] * (1 - u - v) + uv[idB * 2] * u + uv[idC * 2] * v;
+  const y = uv[idA * 2 + 1] * (1 - u - v) + uv[idB * 2 + 1] * u + uv[idC * 2 + 1] * v;
+  return x <= 2 && (!night || x * x + y * y > 0.9);
+}

package/src/collision/indexTriangle.js

@@ -0,0 +1,11 @@
+import { CELL } from '../globals/CELL.js';
+
+export function indexTriangle(cells, v, t) {
+  let ix, iz, key;
+  for (ix = Math.floor(Math.min(v[0], v[3], v[6]) / CELL); ix <= Math.floor(Math.max(v[0], v[3], v[6]) / CELL); ix++)
+    for (iz = Math.floor(Math.min(v[2], v[5], v[8]) / CELL); iz <= Math.floor(Math.max(v[2], v[5], v[8]) / CELL); iz++) {
+      key = ix + ',' + iz;
+      if (!cells.has(key)) cells.set(key, /* alloc */ []);
+      cells.get(key).push(t);
+    }
+}

package/src/collision/intersectMeshes.js

@@ -0,0 +1,32 @@
+import { sortHits } from './sortHits.js';
+import { localRay } from './localRay.js';
+import { rayBounds } from './rayBounds.js';
+import { readTriangle } from './readTriangle.js';
+import { triangleDistance } from './triangleDistance.js';
+import { worldHit } from './worldHit.js';
+
+/** Nearest triangle hit per mesh, sorted by world-space distance. */
+export function intersectMeshes(ray, meshes, night = 0) {
+  const hits = /* alloc */ [];
+  const a = /* alloc */ [0, 0, 0], b = /* alloc */ [0, 0, 0], c = /* alloc */ [0, 0, 0];
+  const origin = /* alloc */ [0, 0, 0], direction = /* alloc */ [0, 0, 0];
+  let mesh, position, index, instanceOffset, vertices, closest, faceIndex, i, distance;
+  for (mesh of meshes) {
+    // Test locally, then compare distances in shared world space.
+    localRay(ray, mesh, origin, direction);
+    if (!rayBounds(mesh, origin, direction)) continue;
+    ({ position, index, instanceOffset } = mesh.geometry.attributes);
+    vertices = index?.count || position.count;
+    closest = Infinity, faceIndex = void 0;
+    for (i = 0; i < vertices * (instanceOffset?.count ?? 1); i += 3) {
+      readTriangle(mesh, i, a, b, c);
+      distance = triangleDistance(mesh, i, a, b, c, origin, direction, night);
+      if (distance > 0 && distance < closest) {
+        closest = distance; faceIndex = i / 3;
+      }
+    }
+    if (faceIndex === undefined) continue;
+    hits.push(worldHit(ray, mesh, origin, direction, closest, faceIndex));
+  }
+  return sortHits(hits);
+}

package/src/collision/localRay.js

@@ -0,0 +1,21 @@
+export function localRay(ray, mesh, origin, direction) {
+  const inverse = /* alloc */ new DOMMatrix(mesh.worldMatrix).invertSelf();
+  const inverseValues = inverse.toFloat64Array();
+  let value, x, y, z, w;
+  for (value of inverseValues) {
+    if (!Number.isFinite(value)) throw /* alloc */ new Error('Singular 3D transform');
+  }
+  x = ray.origin[0], y = ray.origin[1], z = ray.origin[2];
+  w = inverseValues[3] * x + inverseValues[7] * y + inverseValues[11] * z + inverseValues[15];
+  origin[0] = (inverseValues[0] * x + inverseValues[4] * y + inverseValues[8] * z + inverseValues[12]) / w;
+  origin[1] = (inverseValues[1] * x + inverseValues[5] * y + inverseValues[9] * z + inverseValues[13]) / w;
+  origin[2] = (inverseValues[2] * x + inverseValues[6] * y + inverseValues[10] * z + inverseValues[14]) / w;
+  x = ray.direction[0], y = ray.direction[1], z = ray.direction[2];
+  direction[0] = inverseValues[0] * x + inverseValues[4] * y + inverseValues[8] * z;
+  direction[1] = inverseValues[1] * x + inverseValues[5] * y + inverseValues[9] * z;
+  direction[2] = inverseValues[2] * x + inverseValues[6] * y + inverseValues[10] * z;
+  const directionLength = Math.hypot(...direction) || 1;
+  direction[0] /= directionLength;
+  direction[1] /= directionLength;
+  direction[2] /= directionLength;
+}

package/src/collision/mergeHits.js

@@ -0,0 +1,11 @@
+export function mergeHits(source, target, start, width) {
+  const middle = Math.min(start + width, source.length), end = Math.min(start + width * 2, source.length);
+  let left = start, right = middle, output;
+  for (output = start; output < end; output++) {
+    if (left < middle && (right >= end || !(source[right].distance < source[left].distance))) {
+      target[output] = source[left++];
+    } else {
+      target[output] = source[right++];
+    }
+  }
+}

package/src/collision/rayBounds.js

@@ -0,0 +1,19 @@
+import { computeBounds } from '../geometry/computeBounds.js';
+
+export function rayBounds(mesh, origin, direction) {
+  if (!mesh.geometry.bounds) computeBounds(mesh.geometry);
+  let near = 0, far = Infinity, i, a, b;
+  for (i = 0; i < 3; i++) {
+    if (Math.abs(direction[i]) < 1e-12) {
+      if (origin[i] < mesh.geometry.bounds.min[i] || origin[i] > mesh.geometry.bounds.max[i]) {
+        far = -Infinity;
+        break;
+      }
+    } else {
+      a = (mesh.geometry.bounds.min[i] - origin[i]) / direction[i], b = (mesh.geometry.bounds.max[i] - origin[i]) / direction[i];
+      near = Math.max(near, Math.min(a, b));
+      far = Math.min(far, Math.max(a, b));
+    }
+  }
+  return !(far < near);
+}

package/src/collision/readTriangle.js

@@ -0,0 +1,20 @@
+export function readTriangle(mesh, i, a, b, c) {
+  const { position, index, instanceOffset } = mesh.geometry.attributes;
+  const vertices = index?.count || position.count;
+  const vertex = instanceOffset ? i % vertices : i;
+  const offset = instanceOffset ? Math.floor(i / vertices) * instanceOffset.size : 0;
+  const x = instanceOffset?.data[offset] ?? 0;
+  const y = instanceOffset?.data[offset + 1] ?? 0;
+  const z = instanceOffset?.data[offset + 2] ?? 0;
+  const ai = (index ? index.data[vertex] : vertex) * position.size;
+  const bi = (index ? index.data[vertex + 1] : vertex + 1) * position.size;
+  const ci = (index ? index.data[vertex + 2] : vertex + 2) * position.size;
+  a[0] = position.data[ai]; a[1] = position.data[ai + 1]; a[2] = position.data[ai + 2];
+  b[0] = position.data[bi]; b[1] = position.data[bi + 1]; b[2] = position.data[bi + 2];
+  c[0] = position.data[ci]; c[1] = position.data[ci + 1]; c[2] = position.data[ci + 2];
+  if (instanceOffset) {
+    a[0] = Math.fround(a[0] + x); a[1] = Math.fround(a[1] + y); a[2] = Math.fround(a[2] + z);
+    b[0] = Math.fround(b[0] + x); b[1] = Math.fround(b[1] + y); b[2] = Math.fround(b[2] + z);
+    c[0] = Math.fround(c[0] + x); c[1] = Math.fround(c[1] + y); c[2] = Math.fround(c[2] + z);
+  }
+}

package/src/collision/sortHits.js

@@ -0,0 +1,17 @@
+export function sortHits(hits) {
+  if (hits.length < 2) return hits;
+  const buffer = /* alloc */ new Array(hits.length);
+  let source = hits, target = buffer;
+  let width, start, previous, i;
+  for (width = 1; width < hits.length; width *= 2) {
+    for (start = 0; start < hits.length; start += width * 2) {
+      mergeHits(source, target, start, width);
+    }
+    previous = source;
+    source = target;
+    target = previous;
+  }
+  if (source !== hits) for (i = 0; i < hits.length; i++) hits[i] = source[i];
+  return hits;
+}
+import { mergeHits } from './mergeHits.js';

package/src/collision/transformTriangle.js

@@ -0,0 +1,9 @@
+export function transformTriangle(v, p, index, i, m) {
+  let k, j, x, y, z;
+  for (k = 0; k < 3; k++) {
+    j = (index ? index.data[i + k] : i + k) * 3, x = p[j], y = p[j + 1], z = p[j + 2];
+    v[k * 3] = m[0] * x + m[4] * y + m[8] * z + m[12];
+    v[k * 3 + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+    v[k * 3 + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
+  }
+}

package/src/collision/triangleDistance.js

@@ -0,0 +1,21 @@
+import { hiddenLightHit } from './hiddenLightHit.js';
+
+/** Moller-Trumbore with the renderer's culling and light-halo rules. */
+export function triangleDistance(mesh, i, a, b, c, origin, direction, night) {
+  const ex = b[0] - a[0], ey = b[1] - a[1], ez = b[2] - a[2];
+  const fx = c[0] - a[0], fy = c[1] - a[1], fz = c[2] - a[2];
+  const px = direction[1] * fz - direction[2] * fy;
+  const py = direction[2] * fx - direction[0] * fz;
+  const pz = direction[0] * fy - direction[1] * fx;
+  const det = ex * px + ey * py + ez * pz;
+  if (mesh.program.cullMode === 'none' || mesh.program.cullFace === null
+    ? Math.abs(det) < 1e-9 : det < 1e-9) return Infinity;
+  const tx = origin[0] - a[0], ty = origin[1] - a[1], tz = origin[2] - a[2];
+  const u = (tx * px + ty * py + tz * pz) / det;
+  if (u < 0 || u > 1) return Infinity;
+  const qx = ty * ez - tz * ey, qy = tz * ex - tx * ez, qz = tx * ey - ty * ex;
+  const v = (direction[0] * qx + direction[1] * qy + direction[2] * qz) / det;
+  if (v < 0 || u + v > 1) return Infinity;
+  if (hiddenLightHit(mesh, i, u, v, night)) return Infinity;
+  return (fx * qx + fy * qy + fz * qz) / det;
+}

package/src/collision/worldHit.js

@@ -0,0 +1,18 @@
+export function worldHit(ray, mesh, origin, direction, closest, faceIndex) {
+  const x = direction[0] * closest + origin[0];
+  const y = direction[1] * closest + origin[1];
+  const z = direction[2] * closest + origin[2];
+  const matrix = mesh.worldMatrix;
+  const w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
+  const worldPoint = /* alloc */ [
+    (matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12]) / w,
+    (matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13]) / w,
+    (matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14]) / w,
+  ];
+  return /* alloc */ {
+    faceIndex,
+    object: mesh,
+    point: worldPoint,
+    distance: Math.hypot(worldPoint[0] - ray.origin[0], worldPoint[1] - ray.origin[1], worldPoint[2] - ray.origin[2])
+  };
+}

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/addCameraHandler.js

@@ -0,0 +1,9 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
+
+export function addCameraHandler(map, name, Type) {
+  const handler = cameraByMap.get(map)[name] = /* alloc */ new Type(map);
+  map._handlers.push(handler);
+  if (map.options[name]) handler.enable();
+}

package/src/controls/adjustCameraDrag.js

@@ -0,0 +1,15 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+import { project } from '../camera/project.js';
+
+export function adjustCameraDrag() {
+  const map = this;
+  const draggable = cameraByMap.get(map)._cameraDraggable;
+  if (!mapGetPitch(map) && !mapGetBearing(map)) 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,91 @@
+import { L } from '../globals/L.js';
+import { Compass } from '../globals/Compass.js';
+import { ContainerResize } from '../globals/ContainerResize.js';
+import { PitchDrag } from '../globals/PitchDrag.js';
+import { ShiftRotate } from '../globals/ShiftRotate.js';
+import { TouchMode } from '../globals/TouchMode.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { touchByContainer } from '../globals/touchByContainer.js';
+import { cameraTouchStates } from '../globals/cameraTouchStates.js';
+import { cameraListenerOptions } from '../globals/cameraListenerOptions.js';
+import { cameraEmptyOptions } from '../globals/cameraEmptyOptions.js';
+import { notifyCameraTouchChange } from './notifyCameraTouchChange.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';
+import { addCameraHandler } from './addCameraHandler.js';
+
+Compass.value = L.Handler.extend({
+  addHooks: compassAddHooks,
+  removeHooks: compassRemoveHooks,
+});
+
+ContainerResize.value = L.Handler.extend({
+  addHooks: containerResizeAddHooks,
+  removeHooks: containerResizeRemoveHooks,
+});
+
+PitchDrag.value = L.Handler.extend({
+  addHooks: pitchDragAddHooks,
+  removeHooks: pitchDragRemoveHooks,
+});
+
+ShiftRotate.value = L.Handler.extend({
+  addHooks: shiftRotateAddHooks,
+  removeHooks: shiftRotateRemoveHooks,
+});
+
+TouchMode.value = L.Handler.extend({
+  addHooks: notifyCameraTouchChange,
+  removeHooks: notifyCameraTouchChange,
+});
+
+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) {
+  addCameraHandler(map, 'trackContainerMutation', ContainerResize.value);
+  if (!map.options.rotate) return;
+  addCameraHandler(map, 'shiftKeyRotate', ShiftRotate.value);
+  addCameraHandler(map, 'pitchDrag', PitchDrag.value);
+  addCameraHandler(map, 'compassBearing', Compass.value);
+  addCameraHandler(map, 'touchRotate', TouchMode.value);
+  addCameraHandler(map, 'touchPitch', TouchMode.value);
+  const container = map.getContainer();
+  const state = cameraByMap.get(map)._cameraTouchState = /* alloc */ { map, container, touch: null, nativeZoom: undefined };
+  touchByContainer.set(container, state);
+  cameraTouchStates.add(state);
+  container.addEventListener('touchstart', startCameraTouch, cameraListenerOptions);
+  container.addEventListener('touchmove', moveCameraTouch, cameraListenerOptions);
+  container.addEventListener('touchend', endCameraTouchEvent, true);
+  container.addEventListener('touchcancel', endCameraTouchEvent, true);
+  window.addEventListener('blur', endAllCameraTouches);
+  map.on('cameratouchchange', changeCameraTouch, map);
+  if (map.options.rotateControl) {
+    cameraByMap.get(map).rotateControl = /* alloc */ new L.Control.Rotate(typeof map.options.rotateControl === 'object' ? map.options.rotateControl : cameraEmptyOptions);
+    cameraByMap.get(map).rotateControl.addTo(map);
+  }
+  map.once('unload', cleanupCameraTouch, map);
+}

package/src/controls/cameraDragClick.js

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

package/src/controls/cameraDragContextMenu.js

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

package/src/controls/cameraDragDown.js

@@ -0,0 +1,23 @@
+import { dragStates } from '../globals/dragStates.js';
+import { cameraFocusOptions } from '../globals/cameraFocusOptions.js';
+
+
+import { editable } from './editable.js';
+
+export function cameraDragDown(event) {
+  const state = dragStates.value.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 = /* alloc */ {
+    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?.(cameraFocusOptions);
+  state.element.setPointerCapture(event.pointerId);
+  state.element.style.cursor = 'grabbing';
+}

package/src/controls/cameraDragEnd.js

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

package/src/controls/cameraDragMove.js

@@ -0,0 +1,28 @@
+import { degrees } from '../globals/degrees.js';
+import { dragStates } from '../globals/dragStates.js';
+
+import { mapStopPitchBearingAnimation } from '../camera/mapStopPitchBearingAnimation.js';
+import { mapSetPitchAndBearing } from '../camera/mapSetPitchAndBearing.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+export function cameraDragMove(event) {
+  const state = dragStates.value.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;
+  mapStopPitchBearingAnimation(state.map);
+  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)) * degrees;
+    } else bearing *= event.clientY < state.drag.cy ? 1 : -1;
+  }
+  mapSetPitchAndBearing(state.map, mapGetPitch(state.map) - y * state.sensitivity[1], mapGetBearing(state.map) + bearing);
+  state.drag.x = event.clientX;
+  state.drag.y = event.clientY;
+}

package/src/controls/changeCameraTouch.js

@@ -0,0 +1,17 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
+import { endCameraTouch } from './endCameraTouch.js';
+
+export function changeCameraTouch() {
+  const state = cameraByMap.get(this)._cameraTouchState, { map, container } = state;
+  const active = cameraByMap.get(map).touchRotate.enabled() || cameraByMap.get(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,29 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { cameraTouchStates } from '../globals/cameraTouchStates.js';
+import { touchByContainer } from '../globals/touchByContainer.js';
+
+
+import { endCameraTouch } from './endCameraTouch.js';
+import { startCameraTouch } from './startCameraTouch.js';
+import { moveCameraTouch } from './moveCameraTouch.js';
+import { endCameraTouchEvent } from './endCameraTouchEvent.js';
+
+import { endAllCameraTouches } from './endAllCameraTouches.js';
+import { changeCameraTouch } from './changeCameraTouch.js';
+
+export function cleanupCameraTouch() {
+  const state = cameraByMap.get(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);
+  cameraTouchStates.delete(state);
+  if (!cameraTouchStates.size) window.removeEventListener('blur', endAllCameraTouches);
+  map.off('cameratouchchange', changeCameraTouch, map);
+  cameraByMap.get(map).rotateControl?.remove();
+  touchByContainer.delete(container);
+  delete cameraByMap.get(map)._cameraTouchState;
+}

package/src/controls/compassAddHooks.js

@@ -0,0 +1,18 @@
+import { compassOrientation } from './compassOrientation.js';
+import { finishCompassPermission } from './finishCompassPermission.js';
+
+export function compassAddHooks() {
+  this._compassGeneration = (this._generation = (this._generation || 0) + 1);
+  this._orientation = /* alloc */ { 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(/* alloc */ [
+    Promise.resolve(/* alloc */ { handler: this, generation: this._generation }),
+    request,
+  ]).then(finishCompassPermission);
+}

package/src/controls/compassOrientation.js

@@ -0,0 +1,7 @@
+import { mapSetBearing } from '../camera/mapSetBearing.js';
+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)) mapSetBearing(handler._map, 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 = /* alloc */ 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;
+}