leaflet-city-mapper 0.0.2 → 0.0.4

package/src/archives/getTileData.js

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

package/src/archives/getZxy.js

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

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

@@ -0,0 +1,31 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { archiveDecoder } from '../globals/archiveDecoder.js';
+
+import { getZxy } from './getZxy.js';
+
+
+export async function loadSource(layer, area) {
+  if (sceneByLayer.get(layer)._geojson) {
+    const { data, url } = layer.options;
+    if (data !== undefined && url) {
+      throw /* alloc */ new Error('GeoJSON source requires either data or url');
+    }
+    if (data !== undefined) return data;
+    if (!url) {
+      throw /* alloc */ new Error('GeoJSON source requires either data or url');
+    }
+    const sourceUrl = /* alloc */ new URL(url, document.baseURI);
+    const response = await fetch(sourceUrl, /* alloc */ { signal: area.request.signal });
+    if (!response.ok) {
+      throw /* alloc */ new Error(`Unable to load GeoJSON: HTTP ${response.status}`);
+    }
+    return response.json();
+  }
+  const result = await getZxy(layer, area.coords.z, area.coords.x, area.coords.y, area.request.signal);
+  return result
+    ? JSON.parse(archiveDecoder.decode(result.data))
+    : /* alloc */ {
+      type: 'FeatureCollection',
+      features: /* alloc */ [],
+    };
+}

package/src/archives/read.js

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

package/src/archives/tileId.js

@@ -0,0 +1,23 @@
+/** 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 /* alloc */ 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, swap;
+  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; }
+      swap = x;
+      x = y;
+      y = swap;
+    }
+  }
+  return id;
+}

package/src/archives/varint.js

@@ -0,0 +1,19 @@
+
+
+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 /* alloc */ new Error('Truncated PMTiles directory');
+    }
+    byte = bytes[reader.cursor++];
+    value += (byte & 127) * factor;
+    if (!Number.isSafeInteger(value)) {
+      throw /* alloc */ new Error('Invalid PMTiles directory integer');
+    }
+    if (byte < 128) return value;
+  }
+  throw /* alloc */ new Error('Invalid PMTiles directory integer');
+}

package/src/camera/angles.js

@@ -0,0 +1,14 @@
+import { radians } from '../globals/radians.js';
+
+import { mapGetBearing } from './mapGetBearing.js';
+import { mapGetPitch } from './mapGetPitch.js';
+
+export function angles(map, target) {
+  const bearing = mapGetBearing(map) * radians, pitch = mapGetPitch(map) * radians;
+  target ||= /* alloc */ [];
+  target[0] = Math.cos(bearing);
+  target[1] = Math.sin(bearing);
+  target[2] = Math.cos(pitch);
+  target[3] = Math.sin(pitch);
+  return target;
+}

package/src/camera/animationPoint.js

@@ -0,0 +1,11 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
+export function animationPoint(map, point, inverse = false) {
+  const view = cameraByMap.get(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,11 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
+import { adjustCameraDrag } from '../controls/adjustCameraDrag.js';
+
+export function cameraMapReady() {
+  const draggable = this.dragging?._draggable;
+  if (!draggable) return;
+  cameraByMap.get(this)._cameraDraggable = draggable;
+  draggable.on('predrag', adjustCameraDrag, this);
+}

package/src/camera/cancelCameraAnimation.js

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

package/src/camera/cleanupCameraMap.js

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

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,58 @@
+import { L } from '../globals/L.js';
+import { cameraEmptyOptions } from '../globals/cameraEmptyOptions.js';
+import { cameraZeroPadding } from '../globals/cameraZeroPadding.js';
+import { cameraAngles } from '../globals/cameraAngles.js';
+import { pointOf } from './pointOf.js';
+import { angles } from './angles.js';
+import { verticalGroundY } from './verticalGroundY.js';
+
+
+export function fitCameraBounds(map, bounds, options = cameraEmptyOptions) {
+  bounds = bounds.getBounds ? bounds.getBounds() : bounds instanceof L.LatLngBounds ? bounds
+    : /* alloc */ 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 || cameraZeroPadding).subtract(half);
+  const max = half.subtract(pointOf(options.paddingBottomRight || options.padding || cameraZeroPadding));
+  const [cos, sin, tilt, rise] = angles(map, cameraAngles);
+  if (tilt < 0) {
+    const y = min.y;
+    min.y = -max.y;
+    max.y = -y;
+  }
+  const far = map.getSize().y * map.options.pitchMaxDistance;
+  const top = verticalGroundY(min.y, Math.abs(tilt), distance, rise, far);
+  const bottom = verticalGroundY(max.y, Math.abs(tilt), distance, rise, far);
+  const origin = map.project(bounds.getNorthWest(), zoom).add(map.project(bounds.getSouthEast(), zoom)).divideBy(2);
+  let low = Infinity, high = -Infinity;
+  const leftSlope = min.x * rise / distance, rightSlope = max.x * rise / distance;
+  const slope = rightSlope - leftSlope;
+  let left = Infinity, right = -Infinity;
+  const corners = /* alloc */ [bounds.getNorthWest(), bounds.getNorthEast(), bounds.getSouthWest(), bounds.getSouthEast()];
+  let i, latlng, p, x, y;
+  for (i = 0; i < 4; i++) {
+    latlng = corners[i];
+    p = map.project(latlng, zoom).subtract(origin);
+    x = cos * p.x - sin * p.y;
+    y = sin * p.x + cos * p.y;
+    low = Math.min(low, y);
+    high = Math.max(high, y);
+    left = Math.min(left, x + leftSlope * y);
+    right = Math.max(right, x + rightSlope * 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 /* alloc */ { 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;
+  origin.x += (cos * centerX + sin * centerY) / actual;
+  origin.y += (-sin * centerX + cos * centerY) / actual;
+  return /* alloc */ { center: map.unproject(origin, zoom), zoom: target };
+}

package/src/camera/getBearing.js

@@ -0,0 +1,5 @@
+import { mapGetBearing } from './mapGetBearing.js';
+
+export function getBearing() {
+  return mapGetBearing(this);
+}

package/src/camera/getPitch.js

@@ -0,0 +1,5 @@
+import { mapGetPitch } from './mapGetPitch.js';
+
+export function getPitch() {
+  return mapGetPitch(this);
+}

package/src/camera/groundBounds.js

@@ -0,0 +1,18 @@
+import { L } from '../globals/L.js';
+import { cameraZeroPadding } from '../globals/cameraZeroPadding.js';
+import { pointOf } from './pointOf.js';
+import { project } from './project.js';
+
+
+export function groundBounds(map, padding = cameraZeroPadding) {
+  const min = pointOf(padding).divideBy(2), max = map.getSize().subtract(min);
+  const bounds = /* alloc */ new L.Bounds();
+  const minX = min.x, minY = min.y;
+  let i;
+  for (i = 0; i < 4; i++) {
+    min.x = i % 2 ? max.x : minX;
+    min.y = i < 2 ? minY : max.y;
+    bounds.extend(project(map, min, true, true));
+  }
+  return bounds;
+}

package/src/camera/initializeCameraMap.js

@@ -0,0 +1,30 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+import { mapSetPitchAndBearing } from './mapSetPitchAndBearing.js';
+
+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() {
+  cameraByMap.set(this, /* alloc */ {});
+  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);
+  }
+  mapSetPitchAndBearing(this, 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) {
+    cameraByMap.get(this).cameraReady = loadCameraControls(this);
+    cameraByMap.get(this).cameraReady.catch(noOperation);
+  }
+}

package/src/camera/mapAnimateCamera.js

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

package/src/camera/mapCamera.js

@@ -0,0 +1,103 @@
+import { L } from '../globals/L.js';
+import { mapMethods } from '../globals/mapMethods.js';
+import { markerMethods } from '../globals/markerMethods.js';
+import { popupEvents } from '../globals/popupEvents.js';
+import { tooltipEvents } from '../globals/tooltipEvents.js';
+import { popupPosition } from '../globals/popupPosition.js';
+import { popupPan } from '../globals/popupPan.js';
+import { tooltipPosition } from '../globals/tooltipPosition.js';
+import { tiledBounds } from '../globals/tiledBounds.js';
+import { gridEvents } from '../globals/gridEvents.js';
+
+import { initNativeGPU } from '../core/initNativeGPU.js';
+
+import { mapLayerPointToContainerPoint } from './mapLayerPointToContainerPoint.js';
+import { mapContainerPointToLayerPoint } from './mapContainerPointToLayerPoint.js';
+import { mapGetCenterLayerPoint } from './mapGetCenterLayerPoint.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 { 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';
+
+mapMethods.value = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Map.prototype));
+
+L.Map.mergeOptions({
+  rotate: true, bearing: 0, pitch: 0, maxPitch: 85, 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({
+  layerPointToContainerPoint: mapLayerPointToContainerPoint,
+  containerPointToLayerPoint: mapContainerPointToLayerPoint,
+  _getCenterLayerPoint: mapGetCenterLayerPoint,
+  panBy: mapPanBy,
+  setZoomAround: mapSetZoomAround,
+  panInside: mapPanInside,
+  _limitCenter: mapLimitCenter,
+  _limitOffset: mapLimitOffset,
+  _getBoundsCenterZoom: mapGetBoundsCenterZoom,
+  getBoundsZoom: mapGetBoundsZoom,
+  _tryAnimatedPan: mapTryAnimatedPan,
+  getBounds: mapGetBounds,
+});
+
+L.Map.addInitHook(initializeCameraMap);
+
+markerMethods.value = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Marker.prototype));
+L.Marker.mergeOptions({ rotation: 0, rotateWithView: false, keepUpright: false, scale: 1 });
+L.Marker.include({
+  setIcon: markerSetIcon,
+  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.
+
+popupEvents.value = L.Popup.prototype.getEvents;
+L.Popup.include({
+  getEvents: popupGetEvents,
+});
+tooltipEvents.value = L.Tooltip.prototype.getEvents;
+L.Tooltip.include({
+  getEvents: tooltipGetEvents,
+});
+popupPosition.value = L.Popup.prototype._updatePosition;
+popupPan.value = L.Popup.prototype._adjustPan;
+L.Popup.include({
+  _adjustPan: popupAdjustPan,
+  _updatePosition: popupUpdatePosition,
+});
+tooltipPosition.value = L.Tooltip.prototype._setPosition;
+L.Tooltip.include({
+  _setPosition: tooltipSetPosition,
+});
+
+tiledBounds.value = L.GridLayer.prototype._getTiledPixelBounds;
+gridEvents.value = L.GridLayer.prototype.getEvents;
+L.GridLayer.include({
+  getEvents: gridlayerGetEvents,
+  _getTiledPixelBounds: gridlayerGetTiledPixelBounds,
+});

package/src/camera/mapContainerPointToLayerPoint.js

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

package/src/camera/mapGetBearing.js

@@ -0,0 +1,4 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
+export function mapGetBearing(map) { return cameraByMap.get(map)?._cameraBearing ?? 0; }

package/src/camera/mapGetBounds.js

@@ -0,0 +1,20 @@
+import { L } from '../globals/L.js';
+import { mapMethods } from '../globals/mapMethods.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
+
+import { groundBounds } from './groundBounds.js';
+import { animationPoint } from './animationPoint.js';
+
+export function mapGetBounds() {
+  if (!mapGetPitch(this) && !mapGetBearing(this)) return mapMethods.value.getBounds.call(this);
+  const footprint = groundBounds(this), bounds = /* alloc */ new L.LatLngBounds();
+  let i, point, raw;
+  for (i = 0; i < 2; i++) {
+    point = i ? footprint.max : footprint.min;
+    raw = mapMethods.value.containerPointToLayerPoint.call(this, animationPoint(this, point, true));
+    bounds.extend(this.layerPointToLatLng(raw));
+  }
+  return bounds;
+}

package/src/camera/mapGetBoundsCenterZoom.js

@@ -0,0 +1,10 @@
+import { mapMethods } from '../globals/mapMethods.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
+import { fitCameraBounds } from './fitCameraBounds.js';
+
+export function mapGetBoundsCenterZoom(bounds, options) {
+  return mapGetPitch(this) || mapGetBearing(this) ? fitCameraBounds(this, bounds, options) :
+    mapMethods.value._getBoundsCenterZoom.call(this, bounds, options);
+}

package/src/camera/mapGetBoundsZoom.js

@@ -0,0 +1,24 @@
+import { L } from '../globals/L.js';
+import { mapMethods } from '../globals/mapMethods.js';
+import { cameraZeroPadding } from '../globals/cameraZeroPadding.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
+
+import { fitCameraBounds } from './fitCameraBounds.js';
+import { pointOf } from './pointOf.js';
+import { groundBounds } from './groundBounds.js';
+
+export function mapGetBoundsZoom(bounds, inside, padding) {
+  if (!mapGetPitch(this) && !mapGetBearing(this)) return mapMethods.value.getBoundsZoom.call(this, bounds, inside, padding);
+  if (!inside) return fitCameraBounds(this, bounds,
+    /* alloc */ {
+      padding: pointOf(padding || cameraZeroPadding).divideBy(2),
+    }).zoom;
+  bounds = bounds instanceof L.LatLngBounds ? bounds
+    : /* alloc */ 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,6 @@
+import { mapMethods } from '../globals/mapMethods.js';
+
+
+export function mapGetCenterLayerPoint() {
+  return mapMethods.value.containerPointToLayerPoint.call(this, this.getSize().divideBy(2));
+}

package/src/camera/mapGetPitch.js

@@ -0,0 +1,4 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
+export function mapGetPitch(map) { return cameraByMap.get(map)?._cameraPitch ?? 0; }

package/src/camera/mapLayerPointToContainerPoint.js

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

package/src/camera/mapLimitCenter.js

@@ -0,0 +1,17 @@
+import { L } from '../globals/L.js';
+import { mapMethods } from '../globals/mapMethods.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
+
+import { groundBounds } from './groundBounds.js';
+
+export function mapLimitCenter(center, zoom, bounds) {
+  if (!bounds || !this._loaded || !mapGetPitch(this) && !mapGetBearing(this)) {
+    return mapMethods.value._limitCenter.call(this, center, zoom, bounds);
+  }
+  const half = this.getSize().divideBy(2), footprint = groundBounds(this), point = this.project(center, zoom);
+  const view = /* alloc */ 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,14 @@
+import { mapMethods } from '../globals/mapMethods.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
+
+import { project } from './project.js';
+
+export function mapLimitOffset(offset, bounds) {
+  if (!bounds || !mapGetPitch(this) && !mapGetBearing(this)) return mapMethods.value._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,10 @@
+import { mapMethods } from '../globals/mapMethods.js';
+
+import { project } from './project.js';
+import { pointOf } from './pointOf.js';
+
+export function mapPanBy(offset, options) {
+  const half = this.getSize().divideBy(2);
+  const ground = half.subtract(project(this, half.subtract(pointOf(offset)), true));
+  return mapMethods.value.panBy.call(this, ground, options);
+}