leaflet-city-mapper 0.0.2 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leaflet-city-mapper",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "A small 3D rendering engine for leaflet",
   "type": "module",
   "main": "dist/leaflet-city-mapper.js",
@@ -39,6 +39,7 @@
   },
   "devDependencies": {
     "@cucumber/cucumber": "^10.3.1",
+    "acorn": "^8.15.0",
     "esbuild": "^0.28.2",
     "playwright": "^1.64.1"
   }

package/src/archives/decodeDirectory.js

@@ -0,0 +1,32 @@
+import { varint } from './varint.js';
+/** Decode delta/varint directory columns, rejecting malformed entries. */
+
+export function decodeDirectory(data) {
+  const bytes = new Uint8Array(data);
+  const reader = { bytes, cursor: 0 };
+  const count = varint(reader);
+  if (count > (bytes.length - reader.cursor) / 4) throw new Error('Invalid PMTiles directory count');
+  const entries = [];
+  let tileId = 0;
+  let i, entry, value;
+  for (i = 0; i < count; i++) {
+    tileId += varint(reader);
+    if (!Number.isSafeInteger(tileId) || (i && tileId <= entries[i - 1].tileId)) {
+      throw new Error('Invalid PMTiles directory tile IDs');
+    }
+    entries.push({ tileId });
+  }
+  for (entry of entries) entry.runLength = varint(reader);
+  for (entry of entries) {
+    entry.length = varint(reader);
+    if (!entry.length) throw new Error('Invalid PMTiles directory length');
+  }
+  for (i = 0; i < entries.length; i++) {
+    entry = entries[i];
+    value = varint(reader);
+    if (!value && !i) throw new Error('Invalid PMTiles directory offset');
+    entry.offset = value ? value - 1 : entries[i - 1].offset + entries[i - 1].length;
+  }
+  if (reader.cursor !== bytes.length) throw new Error('Trailing PMTiles directory data');
+  return entries;
+}

package/src/archives/decodeHeader.js

@@ -0,0 +1,19 @@
+/** Decode the PMTiles v3 header. */
+
+export function decodeHeader(data) {
+  if (data.byteLength < 127 || new TextDecoder().decode(new Uint8Array(data, 0, 7)) !== 'PMTiles' ||
+    new Uint8Array(data)[7] !== 3) throw new Error('Expected a PMTiles v3 archive');
+  const view = new DataView(data);
+  const header = {};
+  const offsets = ['rootDirectoryOffset', 'rootDirectoryLength', 'jsonMetadataOffset', 'jsonMetadataLength', 'leafDirectoryOffset', 'leafDirectoryLength', 'tileDataOffset', 'tileDataLength', 'numAddressedTiles', 'numTileEntries', 'numTileContents'];
+  const flags = ['clustered', 'internalCompression', 'tileCompression', 'tileType', 'minZoom', 'maxZoom'];
+  const bounds = ['minLon', 'minLat', 'maxLon', 'maxLat'];
+  let i;
+  for (i = 0; i < offsets.length; i++) header[offsets[i]] = Number(view.getBigUint64(8 + i * 8, true));
+  for (i = 0; i < flags.length; i++) header[flags[i]] = view.getUint8(96 + i);
+  for (i = 0; i < bounds.length; i++) header[bounds[i]] = view.getInt32(102 + i * 4, true) / 1e7;
+  header.centerZoom = view.getUint8(118);
+  header.centerLon = view.getInt32(119, true) / 1e7;
+  header.centerLat = view.getInt32(123, true) / 1e7;
+  return header;
+}

package/src/archives/getZxy.js

@@ -0,0 +1,75 @@
+import { loadDirectory } from './loadDirectory.js';
+import { decompress } from './decompress.js';
+import { tileId } from './tileId.js';
+import { read } from './read.js';
+import { getHeader } from './getHeader.js';
+
+/** Nearest directory entry at/before the Hilbert ID, then follow leaf pointers. */
+
+export async function getZxy(backend, z, x, y, signal) {
+  if (backend.options.archive && backend.options.archive !== backend && backend.options.archive.getZxy) {
+    return backend.options.archive.getZxy(z, x, y, signal);
+  }
+  const id = tileId(z, x, y);
+  signal?.throwIfAborted();
+  const header = await getHeader(backend);
+  signal?.throwIfAborted();
+  if (z < header.minZoom || z > header.maxZoom) {
+    return;
+  }
+  let offset = header.rootDirectoryOffset, length = header.rootDirectoryLength;
+  const visited = new Set();
+  let depth, key, pending, entries, low, high, mid, entry, data;
+  for (depth = 0; depth < 4; depth++) {
+    if (visited.has(offset)) {
+      throw new Error('Cyclic PMTiles directory');
+    }
+    visited.add(offset);
+    key = `${offset}:${length}`;
+    if (!backend._directories.has(key)) {
+      if (backend._directories.size >= 32) {
+        backend._directories.delete(backend._directories.keys().next().value);
+      }
+      backend._directories.set(key, loadDirectory(backend, offset, length, header.internalCompression));
+    }
+    pending = backend._directories.get(key);
+    entries = void 0;
+    try {
+      entries = await pending;
+    } catch (error) {
+      if (backend._directories.get(key) === pending) backend._directories.delete(key);
+      throw error;
+    }
+    signal?.throwIfAborted();
+    low = 0, high = entries.length - 1;
+    while (low <= high) {
+      mid = (low + high) >> 1;
+      if (entries[mid].tileId <= id) {
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    entry = entries[high];
+    if (!entry) {
+      return;
+    }
+    if (entry.runLength) {
+      if (id - entry.tileId >= entry.runLength) {
+        return;
+      }
+      if (entry.offset + entry.length > header.tileDataLength) {
+        throw new Error('PMTiles tile outside data section');
+      }
+      data = await decompress(await read(backend, header.tileDataOffset + entry.offset, entry.length, signal), header.tileCompression);
+      signal?.throwIfAborted();
+      return { data };
+    }
+    if (entry.offset + entry.length > header.leafDirectoryLength) {
+      throw new Error('PMTiles directory outside leaf section');
+    }
+    offset = header.leafDirectoryOffset + entry.offset;
+    length = entry.length;
+  }
+  throw new Error('PMTiles directory depth exceeds four levels');
+}

package/src/archives/loadDirectory.js

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

package/src/archives/tileId.js

@@ -0,0 +1,19 @@
+/** Cumulative Hilbert ID for an archive tile. */
+
+export function tileId(z, x, y) {
+  if (!Number.isInteger(z) || !Number.isInteger(x) || !Number.isInteger(y) || z < 0 || z > 26 ||
+    x < 0 || y < 0 || x >= 2 ** z || y >= 2 ** z) throw new Error('Invalid PMTiles tile coordinates');
+  let id = (4 ** z - 1) / 3;
+  const n = 2 ** z;
+  // Same cumulative Hilbert ordering used by build/pmtiles.js.
+  let s, rx, ry;
+  for (s = n / 2; s >= 1; s /= 2) {
+    rx = (x & s) ? 1 : 0, ry = (y & s) ? 1 : 0;
+    id += s * s * ((3 * rx) ^ ry);
+    if (!ry) {
+      if (rx) { x = n - 1 - x; y = n - 1 - y; }
+      [x, y] = [y, x];
+    }
+  }
+  return id;
+}

package/src/archives/varint.js

@@ -0,0 +1,15 @@
+
+
+export function varint(reader) {
+  const { bytes } = reader;
+  let value = 0;
+  let factor, byte;
+  for (factor = 1; factor <= 2 ** 49; factor *= 128) {
+    if (reader.cursor >= bytes.length) throw new Error('Truncated PMTiles directory');
+    byte = bytes[reader.cursor++];
+    value += (byte & 127) * factor;
+    if (!Number.isSafeInteger(value)) throw new Error('Invalid PMTiles directory integer');
+    if (byte < 128) return value;
+  }
+  throw new Error('Invalid PMTiles directory integer');
+}

package/src/camera/angles.js

@@ -0,0 +1,6 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+
+export function angles(map) {
+  const bearing = map.getBearing() * mapCameraState.radians, pitch = map.getPitch() * mapCameraState.radians;
+  return [Math.cos(bearing), Math.sin(bearing), Math.cos(pitch), Math.sin(pitch)];
+}

package/src/camera/animationPoint.js

@@ -0,0 +1,8 @@
+export function animationPoint(map, point, inverse = false) {
+  const view = map._cameraView;
+  if (!view) return point;
+  const half = map.getSize().divideBy(2), scale = map.getZoomScale(view.zoom);
+  const shift = map.project(map.getCenter(), view.zoom).subtract(map.project(view.center, view.zoom));
+  return inverse ? point.subtract(half).subtract(shift).divideBy(scale).add(half) :
+    point.subtract(half).multiplyBy(scale).add(shift).add(half);
+}

package/src/camera/cameraMapReady.js

@@ -0,0 +1,8 @@
+import { adjustCameraDrag } from '../controls/adjustCameraDrag.js';
+
+export function cameraMapReady() {
+  const draggable = this.dragging?._draggable;
+  if (!draggable) return;
+  this._cameraDraggable = draggable;
+  draggable.on('predrag', adjustCameraDrag, this);
+}

package/src/camera/cancelCameraAnimation.js

@@ -0,0 +1,11 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+
+export function cancelCameraAnimation(map) {
+  mapCameraState.cameraAnimations.delete(map);
+  map._cameraAnimation = null;
+  map._cameraFrame = null;
+  if (!mapCameraState.cameraAnimations.size && mapCameraState.cameraAnimationFrame !== null) {
+    cancelAnimationFrame(mapCameraState.cameraAnimationFrame);
+    mapCameraState.cameraAnimationFrame = null;
+  }
+}

package/src/camera/cleanupCameraMap.js

@@ -0,0 +1,11 @@
+import { cancelCameraAnimation } from './cancelCameraAnimation.js';
+import { adjustCameraDrag } from '../controls/adjustCameraDrag.js';
+
+export function cleanupCameraMap() {
+  cancelCameraAnimation(this);
+  this._pitchSky?.remove();
+  if (this._cameraDraggable) {
+    this._cameraDraggable.off('predrag', adjustCameraDrag, this);
+    delete this._cameraDraggable;
+  }
+}

package/src/camera/constrainCameraToBounds.js

@@ -0,0 +1,3 @@
+export function constrainCameraToBounds() {
+  if (this.options.maxBounds) this._panInsideMaxBounds();
+}

package/src/camera/displayPoint.js

@@ -0,0 +1,3 @@
+export function displayPoint(map, point) {
+  return map.layerPointToContainerPoint(point).subtract(map._getMapPanePos());
+}

package/src/camera/fitCameraBounds.js

@@ -0,0 +1,48 @@
+import { pointOf } from './pointOf.js';
+import { angles } from './angles.js';
+import { verticalGroundY } from './verticalGroundY.js';
+
+export function fitCameraBounds(map, bounds, options = {}) {
+  bounds = bounds.getBounds ? bounds.getBounds() : bounds instanceof L.LatLngBounds ? bounds : new L.LatLngBounds(bounds);
+  const zoom = map.getZoom() ?? 0, half = map.getSize().divideBy(2), distance = map.getSize().y * 1.5;
+  const min = pointOf(options.paddingTopLeft || options.padding || [0, 0]).subtract(half);
+  const max = half.subtract(pointOf(options.paddingBottomRight || options.padding || [0, 0]));
+  const [cos, sin, tilt, rise] = angles(map);
+  const far = map.getSize().y * map.options.pitchMaxDistance;
+  const top = verticalGroundY(min.y, tilt, distance, rise, far);
+  const bottom = verticalGroundY(max.y, tilt, distance, rise, far);
+  const origin = map.project(bounds.getNorthWest(), zoom).add(map.project(bounds.getSouthEast(), zoom)).divideBy(2);
+  const points = [];
+  let latlng, p, point;
+  for (latlng of [bounds.getNorthWest(), bounds.getNorthEast(), bounds.getSouthWest(), bounds.getSouthEast()]) {
+    p = map.project(latlng, zoom).subtract(origin);
+    points.push(new L.Point(cos * p.x - sin * p.y, sin * p.x + cos * p.y));
+  }
+  let low = Infinity, high = -Infinity;
+  for (point of points) {
+    low = Math.min(low, point.y);
+    high = Math.max(high, point.y);
+  }
+  const leftSlope = min.x * rise / distance, rightSlope = max.x * rise / distance;
+  const slope = rightSlope - leftSlope;
+  let left = Infinity, right = -Infinity;
+  for (point of points) {
+    left = Math.min(left, point.x + leftSlope * point.y);
+    right = Math.max(right, point.x + rightSlope * point.y);
+  }
+  // Perspective viewport edges are straight lines on the ground: fit all four corners, not their screen midpoint.
+  const scale = Math.min((bottom - top) / (high - low),
+    (max.x - min.x - slope * top) / (right - left - slope * low));
+  let target = map.getScaleZoom(scale, zoom);
+  const snap = map.options.zoomSnap;
+  if (snap) target = Math.floor(Math.round(target / (snap / 100)) / 100) * snap;
+  target = Math.max(map.getMinZoom(), Math.min(map.getMaxZoom(), options.maxZoom ?? Infinity, target));
+  if (!Number.isFinite(target)) return { center: bounds.getCenter(), zoom: target };
+  const actual = map.getZoomScale(target, zoom);
+  const vMin = high * actual - bottom, vMax = low * actual - top;
+  const v = Math.max(vMin, slope ? (actual * (right - left) - max.x + min.x) / slope : vMin);
+  const centerY = (Math.min(vMax, v) + vMax) / 2;
+  const centerX = (actual * (left + right) - min.x - max.x - (leftSlope + rightSlope) * centerY) / 2;
+  const center = origin.add(new L.Point(cos * centerX + sin * centerY, -sin * centerX + cos * centerY).divideBy(actual));
+  return { center: map.unproject(center, zoom), zoom: target };
+}

package/src/camera/groundBounds.js

@@ -0,0 +1,11 @@
+import { pointOf } from './pointOf.js';
+import { project } from './project.js';
+
+export function groundBounds(map, padding = [0, 0]) {
+  const min = pointOf(padding).divideBy(2), max = map.getSize().subtract(min);
+  const corners = [[min.x, min.y], [max.x, min.y], [min.x, max.y], [max.x, max.y]];
+  const points = [];
+  let point;
+  for (point of corners) points.push(project(map, point, true, true));
+  return new L.Bounds(points);
+}

package/src/camera/initializeCameraMap.js

@@ -0,0 +1,25 @@
+import { updateSky } from './updateSky.js';
+import { constrainCameraToBounds } from './constrainCameraToBounds.js';
+import { cleanupCameraMap } from './cleanupCameraMap.js';
+import { cameraMapReady } from './cameraMapReady.js';
+import { loadCameraControls } from '../controls/loadCameraControls.js';
+import { noOperation } from '../utils/noOperation.js';
+
+export function initializeCameraMap() {
+  if (!document.getElementById('leaflet-camera-zoom-style')) {
+    const style = document.createElement('style');
+    style.id = 'leaflet-camera-zoom-style';
+    style.textContent = '.leaflet-camera-zoom .leaflet-marker-icon,.leaflet-camera-zoom .leaflet-marker-shadow,' +
+      '.leaflet-camera-zoom .leaflet-popup,.leaflet-camera-zoom .leaflet-tooltip{transition:none!important}';
+    document.head.append(style);
+  }
+  this._setPitchAndBearing(this.options.pitch, this.options.bearing);
+  this.on('load resize pitch', updateSky);
+  this.on('rotate pitch', constrainCameraToBounds, this);
+  this.once('unload', cleanupCameraMap, this);
+  this.whenReady(cameraMapReady, this);
+  if (this.options.rotate || this.options.trackContainerMutation) {
+    this.cameraReady = loadCameraControls(this);
+    this.cameraReady.catch(noOperation);
+  }
+}

package/src/camera/mapAnimateCamera.js

@@ -0,0 +1,17 @@
+import { cancelCameraAnimation } from './cancelCameraAnimation.js';
+import { scheduleCameraAnimation } from './scheduleCameraAnimation.js';
+
+export function mapAnimateCamera(pitch, bearing, options = {}) {
+  cancelCameraAnimation(this);
+  if (!Number.isFinite(pitch) || !Number.isFinite(bearing)) throw new TypeError('Camera angles must be finite numbers');
+  if (!options.animate || matchMedia('(prefers-reduced-motion: reduce)').matches) {
+    return this._setPitchAndBearing(pitch, bearing);
+  }
+  const duration = options.duration ?? 0.3;
+  if (!Number.isFinite(duration) || duration < 0) throw new TypeError('Camera duration must be nonnegative');
+  const start = performance.now(), fromPitch = this.getPitch(), fromBearing = this.getBearing();
+  const delta = ((bearing - fromBearing) % 360 + 540) % 360 - 180;
+  const animation = this._cameraAnimation = { duration, start, fromPitch, fromBearing, pitch, delta };
+  scheduleCameraAnimation(this, animation);
+  return this;
+}

package/src/camera/mapCamera.js

@@ -0,0 +1,123 @@
+import { initNativeGPU } from '../core/initNativeGPU.js';
+import { mapCameraState } from '../constants/mapCameraState.js';
+import { mapGetBearing } from './mapGetBearing.js';
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapStopPitchBearingAnimation } from './mapStopPitchBearingAnimation.js';
+import { mapSetPitchAndBearing } from './mapSetPitchAndBearing.js';
+import { mapAnimateCamera } from './mapAnimateCamera.js';
+import { mapSetBearing } from './mapSetBearing.js';
+import { mapSetPitch } from './mapSetPitch.js';
+import { mapResetNorth } from './mapResetNorth.js';
+import { mapResetNorthPitch } from './mapResetNorthPitch.js';
+import { mapLayerPointToContainerPoint } from './mapLayerPointToContainerPoint.js';
+import { mapContainerPointToLayerPoint } from './mapContainerPointToLayerPoint.js';
+import { mapGetCenterLayerPoint } from './mapGetCenterLayerPoint.js';
+import { mapUpdateCameraOverlays } from './mapUpdateCameraOverlays.js';
+import { mapPanBy } from './mapPanBy.js';
+import { mapSetZoomAround } from './mapSetZoomAround.js';
+import { mapPanInside } from './mapPanInside.js';
+import { mapLimitCenter } from './mapLimitCenter.js';
+import { mapLimitOffset } from './mapLimitOffset.js';
+import { mapGetBoundsCenterZoom } from './mapGetBoundsCenterZoom.js';
+import { mapGetBoundsZoom } from './mapGetBoundsZoom.js';
+import { mapTryAnimatedPan } from './mapTryAnimatedPan.js';
+import { mapGetBounds } from './mapGetBounds.js';
+import { initializeCameraMap } from './initializeCameraMap.js';
+import { markerSetIcon } from '../core/markerSetIcon.js';
+import { markerSetRotation } from '../core/markerSetRotation.js';
+import { markerCameraIconPoint } from '../core/markerCameraIconPoint.js';
+import { markerGetEvents } from '../core/markerGetEvents.js';
+import { markerSetPos } from '../core/markerSetPos.js';
+import { markerUpdateZIndex } from '../core/markerUpdateZIndex.js';
+import { markerInitInteraction } from '../core/markerInitInteraction.js';
+import { popupGetEvents } from '../core/popupGetEvents.js';
+import { tooltipGetEvents } from '../core/tooltipGetEvents.js';
+import { popupAdjustPan } from '../core/popupAdjustPan.js';
+import { popupUpdatePosition } from '../core/popupUpdatePosition.js';
+import { tooltipSetPosition } from '../core/tooltipSetPosition.js';
+import { gridlayerGetEvents } from '../core/gridlayerGetEvents.js';
+import { gridlayerGetTiledPixelBounds } from '../core/gridlayerGetTiledPixelBounds.js';
+
+mapCameraState.mapMethods = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Map.prototype));
+mapCameraState.radians = Math.PI / 180;
+
+mapCameraState.cameraAnimations = new Map();
+mapCameraState.cameraAnimationFrame = null;
+
+L.Map.mergeOptions({
+  rotate: true, bearing: 0, pitch: 0, pitchMaxDistance: 3,
+  rotateControl: true, shiftKeyRotate: true, pitchDrag: true,
+  touchRotate: false, touchPitch: false, compassBearing: false,
+});
+
+// Ground coordinates only: the GPU camera handles elevated geometry, never CSS transforms.
+
+L.Map.include({
+  getBearing: mapGetBearing,
+  getPitch: mapGetPitch,
+  _stopPitchBearingAnimation: mapStopPitchBearingAnimation,
+  _setPitchAndBearing: mapSetPitchAndBearing,
+  _animateCamera: mapAnimateCamera,
+  setBearing: mapSetBearing,
+  setPitch: mapSetPitch,
+  resetNorth: mapResetNorth,
+  resetNorthPitch: mapResetNorthPitch,
+  layerPointToContainerPoint: mapLayerPointToContainerPoint,
+  containerPointToLayerPoint: mapContainerPointToLayerPoint,
+  _getCenterLayerPoint: mapGetCenterLayerPoint,
+  _updateCameraOverlays: mapUpdateCameraOverlays,
+  panBy: mapPanBy,
+  setZoomAround: mapSetZoomAround,
+  panInside: mapPanInside,
+  _limitCenter: mapLimitCenter,
+  _limitOffset: mapLimitOffset,
+  _getBoundsCenterZoom: mapGetBoundsCenterZoom,
+  getBoundsZoom: mapGetBoundsZoom,
+  _tryAnimatedPan: mapTryAnimatedPan,
+  getBounds: mapGetBounds,
+});
+
+L.Map.addInitHook(initializeCameraMap);
+
+mapCameraState.markerMethods = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Marker.prototype));
+L.Marker.mergeOptions({ rotation: 0, rotateWithView: false, keepUpright: false, scale: 1 });
+L.Marker.include({
+  setIcon: markerSetIcon,
+  setRotation: markerSetRotation,
+  _cameraIconPoint: markerCameraIconPoint,
+  getEvents: markerGetEvents,
+  _setPos: markerSetPos,
+  _updateZIndex: markerUpdateZIndex,
+  _initInteraction: markerInitInteraction,
+});
+
+// Keep Leaflet's focusable marker and its drag events; only translate its screen position back to ground.
+
+mapCameraState.pendingMarkerPan = new Map();
+mapCameraState.markerPanFrame = null;
+
+mapCameraState.popupEvents = L.Popup.prototype.getEvents;
+L.Popup.include({
+  getEvents: popupGetEvents,
+});
+mapCameraState.tooltipEvents = L.Tooltip.prototype.getEvents;
+L.Tooltip.include({
+  getEvents: tooltipGetEvents,
+});
+mapCameraState.popupPosition = L.Popup.prototype._updatePosition;
+mapCameraState.popupPan = L.Popup.prototype._adjustPan;
+L.Popup.include({
+  _adjustPan: popupAdjustPan,
+  _updatePosition: popupUpdatePosition,
+});
+mapCameraState.tooltipPosition = L.Tooltip.prototype._setPosition;
+L.Tooltip.include({
+  _setPosition: tooltipSetPosition,
+});
+
+mapCameraState.tiledBounds = L.GridLayer.prototype._getTiledPixelBounds;
+mapCameraState.gridEvents = L.GridLayer.prototype.getEvents;
+L.GridLayer.include({
+  getEvents: gridlayerGetEvents,
+  _getTiledPixelBounds: gridlayerGetTiledPixelBounds,
+});

package/src/camera/mapContainerPointToLayerPoint.js

@@ -0,0 +1,7 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+import { animationPoint } from './animationPoint.js';
+import { project } from './project.js';
+
+export function mapContainerPointToLayerPoint(point) {
+  return mapCameraState.mapMethods.containerPointToLayerPoint.call(this, animationPoint(this, project(this, point, true), true));
+}

package/src/camera/mapGetBearing.js

@@ -0,0 +1 @@
+export function mapGetBearing() { return this._cameraBearing ?? 0; }

package/src/camera/mapGetBounds.js

@@ -0,0 +1,14 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+import { groundBounds } from './groundBounds.js';
+import { animationPoint } from './animationPoint.js';
+
+export function mapGetBounds() {
+  if (!this.getPitch() && !this.getBearing()) return mapCameraState.mapMethods.getBounds.call(this);
+  const footprint = groundBounds(this), bounds = new L.LatLngBounds();
+  let point, raw;
+  for (point of [footprint.min, footprint.max]) {
+    raw = mapCameraState.mapMethods.containerPointToLayerPoint.call(this, animationPoint(this, point, true));
+    bounds.extend(this.layerPointToLatLng(raw));
+  }
+  return bounds;
+}

package/src/camera/mapGetBoundsCenterZoom.js

@@ -0,0 +1,7 @@
+import { fitCameraBounds } from './fitCameraBounds.js';
+import { mapCameraState } from '../constants/mapCameraState.js';
+
+export function mapGetBoundsCenterZoom(bounds, options) {
+  return this.getPitch() || this.getBearing() ? fitCameraBounds(this, bounds, options) :
+    mapCameraState.mapMethods._getBoundsCenterZoom.call(this, bounds, options);
+}

package/src/camera/mapGetBoundsZoom.js

@@ -0,0 +1,14 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+import { fitCameraBounds } from './fitCameraBounds.js';
+import { pointOf } from './pointOf.js';
+import { groundBounds } from './groundBounds.js';
+
+export function mapGetBoundsZoom(bounds, inside, padding) {
+  if (!this.getPitch() && !this.getBearing()) return mapCameraState.mapMethods.getBoundsZoom.call(this, bounds, inside, padding);
+  if (!inside) return fitCameraBounds(this, bounds, { padding: pointOf(padding || [0, 0]).divideBy(2) }).zoom;
+  bounds = bounds instanceof L.LatLngBounds ? bounds : new L.LatLngBounds(bounds);
+  const footprint = groundBounds(this, padding).getSize(), size = this.project(bounds.getSouthEast()).subtract(this.project(bounds.getNorthWest()));
+  const zoom = this.getScaleZoom(Math.max(footprint.x / size.x, footprint.y / size.y));
+  const snap = this.options.zoomSnap;
+  return Math.max(this.getMinZoom(), Math.min(this.getMaxZoom(), snap ? Math.ceil(zoom / snap) * snap : zoom));
+}

package/src/camera/mapGetCenterLayerPoint.js

@@ -0,0 +1,5 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+
+export function mapGetCenterLayerPoint() {
+  return mapCameraState.mapMethods.containerPointToLayerPoint.call(this, this.getSize().divideBy(2));
+}

package/src/camera/mapGetPitch.js

@@ -0,0 +1 @@
+export function mapGetPitch() { return this._cameraPitch ?? 0; }

package/src/camera/mapLayerPointToContainerPoint.js

@@ -0,0 +1,7 @@
+import { project } from './project.js';
+import { animationPoint } from './animationPoint.js';
+import { mapCameraState } from '../constants/mapCameraState.js';
+
+export function mapLayerPointToContainerPoint(point) {
+  return project(this, animationPoint(this, mapCameraState.mapMethods.layerPointToContainerPoint.call(this, point)));
+}

package/src/camera/mapLimitCenter.js

@@ -0,0 +1,12 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+import { groundBounds } from './groundBounds.js';
+
+export function mapLimitCenter(center, zoom, bounds) {
+  if (!bounds || !this._loaded || !this.getPitch() && !this.getBearing()) {
+    return mapCameraState.mapMethods._limitCenter.call(this, center, zoom, bounds);
+  }
+  const half = this.getSize().divideBy(2), footprint = groundBounds(this), point = this.project(center, zoom);
+  const view = new L.Bounds(point.add(footprint.min.subtract(half)), point.add(footprint.max.subtract(half)));
+  const offset = this._getBoundsOffset(view, bounds, zoom);
+  return Math.abs(offset.x) <= 1 && Math.abs(offset.y) <= 1 ? center : this.unproject(point.add(offset), zoom);
+}

package/src/camera/mapLimitOffset.js

@@ -0,0 +1,10 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+import { project } from './project.js';
+
+export function mapLimitOffset(offset, bounds) {
+  if (!bounds || !this.getPitch() && !this.getBearing()) return mapCameraState.mapMethods._limitOffset.call(this, offset, bounds);
+  const half = this.getSize().divideBy(2), ground = half.subtract(project(this, half.subtract(offset), true));
+  const center = this.project(this.getCenter());
+  const limited = this.project(this._limitCenter(this.unproject(center.add(ground)), this.getZoom(), bounds));
+  return half.subtract(project(this, half.subtract(limited.subtract(center))));
+}

package/src/camera/mapPanBy.js

@@ -0,0 +1,9 @@
+import { project } from './project.js';
+import { pointOf } from './pointOf.js';
+import { mapCameraState } from '../constants/mapCameraState.js';
+
+export function mapPanBy(offset, options) {
+  const half = this.getSize().divideBy(2);
+  const ground = half.subtract(project(this, half.subtract(pointOf(offset)), true));
+  return mapCameraState.mapMethods.panBy.call(this, ground, options);
+}

package/src/camera/mapPanInside.js

@@ -0,0 +1,14 @@
+import { mapCameraState } from '../constants/mapCameraState.js';
+import { pointOf } from './pointOf.js';
+
+export function mapPanInside(latlng, options = {}) {
+  if (!this.getPitch() && !this.getBearing()) return mapCameraState.mapMethods.panInside.call(this, latlng, options);
+  const min = pointOf(options.paddingTopLeft || options.padding || [0, 0]);
+  const max = this.getSize().subtract(pointOf(options.paddingBottomRight || options.padding || [0, 0]));
+  const screen = this.latLngToContainerPoint(latlng);
+  const safe = new L.Point(Math.max(min.x, Math.min(max.x, screen.x)),
+    Math.max(min.y, Math.min(max.y, screen.y)));
+  if (safe.equals(screen)) return this;
+  const delta = this.latLngToLayerPoint(latlng).subtract(this.containerPointToLayerPoint(safe));
+  return this.panTo(this.unproject(this.project(this.getCenter()).add(delta)), options);
+}

package/src/camera/mapResetNorth.js

@@ -0,0 +1 @@
+export function mapResetNorth(options = { animate: true }) { return this.setBearing(0, options); }

package/src/camera/mapResetNorthPitch.js

@@ -0,0 +1 @@
+export function mapResetNorthPitch(options = { animate: true }) { return this._animateCamera(0, 0, options); }

package/src/camera/mapSetBearing.js

@@ -0,0 +1 @@
+export function mapSetBearing(bearing, options) { return this._animateCamera(this.getPitch(), bearing, options); }

package/src/camera/mapSetPitch.js

@@ -0,0 +1 @@
+export function mapSetPitch(pitch, options) { return this._animateCamera(pitch, this.getBearing(), options); }

package/src/camera/mapSetPitchAndBearing.js

@@ -0,0 +1,14 @@
+import { updateSky } from './updateSky.js';
+
+export function mapSetPitchAndBearing(pitch, bearing) {
+  if (!Number.isFinite(pitch) || !Number.isFinite(bearing)) throw new TypeError('Camera angles must be finite numbers');
+  const previousPitch = this.getPitch(), previousBearing = this.getBearing();
+  this._cameraPitch = Math.max(0, Math.min(85, pitch));
+  this._cameraBearing = ((bearing % 360) + 360) % 360;
+  if (this._loaded) {
+    updateSky.call(this);
+    if (previousBearing !== this.getBearing()) this.fire('rotate', { bearing: this.getBearing() });
+    if (previousPitch !== this.getPitch()) this.fire('pitch', { pitch: this.getPitch() });
+  }
+  return this;
+}