leaflet-city-mapper 0.0.3 → 0.0.4

package/src/camera/mapCamera.js

@@ -1,18 +1,19 @@
+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 { 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';
@@ -24,8 +25,6 @@ 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';
@@ -38,14 +37,10 @@ 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;
+mapMethods.value = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Map.prototype));
 
 L.Map.mergeOptions({
-  rotate: true, bearing: 0, pitch: 0, pitchMaxDistance: 3,
+  rotate: true, bearing: 0, pitch: 0, maxPitch: 85, pitchMaxDistance: 3,
   rotateControl: true, shiftKeyRotate: true, pitchDrag: true,
   touchRotate: false, touchPitch: false, compassBearing: false,
 });
@@ -53,19 +48,9 @@ L.Map.mergeOptions({
 // 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,
@@ -79,12 +64,10 @@ L.Map.include({
 
 L.Map.addInitHook(initializeCameraMap);
 
-mapCameraState.markerMethods = Object.defineProperties({}, Object.getOwnPropertyDescriptors(L.Marker.prototype));
+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,
-  setRotation: markerSetRotation,
-  _cameraIconPoint: markerCameraIconPoint,
   getEvents: markerGetEvents,
   _setPos: markerSetPos,
   _updateZIndex: markerUpdateZIndex,
@@ -93,30 +76,27 @@ L.Marker.include({
 
 // 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;
+popupEvents.value = L.Popup.prototype.getEvents;
 L.Popup.include({
   getEvents: popupGetEvents,
 });
-mapCameraState.tooltipEvents = L.Tooltip.prototype.getEvents;
+tooltipEvents.value = L.Tooltip.prototype.getEvents;
 L.Tooltip.include({
   getEvents: tooltipGetEvents,
 });
-mapCameraState.popupPosition = L.Popup.prototype._updatePosition;
-mapCameraState.popupPan = L.Popup.prototype._adjustPan;
+popupPosition.value = L.Popup.prototype._updatePosition;
+popupPan.value = L.Popup.prototype._adjustPan;
 L.Popup.include({
   _adjustPan: popupAdjustPan,
   _updatePosition: popupUpdatePosition,
 });
-mapCameraState.tooltipPosition = L.Tooltip.prototype._setPosition;
+tooltipPosition.value = L.Tooltip.prototype._setPosition;
 L.Tooltip.include({
   _setPosition: tooltipSetPosition,
 });
 
-mapCameraState.tiledBounds = L.GridLayer.prototype._getTiledPixelBounds;
-mapCameraState.gridEvents = L.GridLayer.prototype.getEvents;
+tiledBounds.value = L.GridLayer.prototype._getTiledPixelBounds;
+gridEvents.value = L.GridLayer.prototype.getEvents;
 L.GridLayer.include({
   getEvents: gridlayerGetEvents,
   _getTiledPixelBounds: gridlayerGetTiledPixelBounds,

package/src/camera/mapContainerPointToLayerPoint.js

@@ -1,7 +1,9 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { mapMethods } from '../globals/mapMethods.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));
+  return mapMethods.value.containerPointToLayerPoint.call(this, animationPoint(this, project(this, point, true), true));
 }

package/src/camera/mapGetBearing.js

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

package/src/camera/mapGetBounds.js

@@ -1,13 +1,19 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+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 (!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));
+  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

@@ -1,7 +1,10 @@
+import { mapMethods } from '../globals/mapMethods.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
 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);
+  return mapGetPitch(this) || mapGetBearing(this) ? fitCameraBounds(this, bounds, options) :
+    mapMethods.value._getBoundsCenterZoom.call(this, bounds, options);
 }

package/src/camera/mapGetBoundsZoom.js

@@ -1,14 +1,24 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+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 (!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;
+  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

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

package/src/camera/mapGetPitch.js

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

package/src/camera/mapLayerPointToContainerPoint.js

@@ -1,7 +1,8 @@
+import { mapMethods } from '../globals/mapMethods.js';
+
 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)));
+  return project(this, animationPoint(this, mapMethods.value.layerPointToContainerPoint.call(this, point)));
 }

package/src/camera/mapLimitCenter.js

@@ -1,12 +1,17 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+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 || !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);
+  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

@@ -1,8 +1,12 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+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 || !this.getPitch() && !this.getBearing()) return mapCameraState.mapMethods._limitOffset.call(this, 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));

package/src/camera/mapPanBy.js

@@ -1,9 +1,10 @@
+import { mapMethods } from '../globals/mapMethods.js';
+
 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);
+  return mapMethods.value.panBy.call(this, ground, options);
 }

package/src/camera/mapPanInside.js

@@ -1,14 +1,20 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { mapMethods } from '../globals/mapMethods.js';
+import { cameraZeroPadding } from '../globals/cameraZeroPadding.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.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));
+export function mapPanInside(latlng, options = /* alloc */ {}) {
+  if (!mapGetPitch(this) && !mapGetBearing(this)) return mapMethods.value.panInside.call(this, latlng, options);
+  const min = pointOf(options.paddingTopLeft || options.padding || cameraZeroPadding);
+  const max = this.getSize().subtract(pointOf(options.paddingBottomRight || options.padding || cameraZeroPadding));
+  const screen = this.latLngToContainerPoint(latlng);
+  const safe = min;
+  safe.x = Math.max(min.x, Math.min(max.x, screen.x));
+  safe.y = 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

@@ -1 +1,4 @@
-export function mapResetNorth(options = { animate: true }) { return this.setBearing(0, options); }
+import { cameraAnimatedOptions } from '../globals/cameraAnimatedOptions.js';
+import { mapSetBearing } from './mapSetBearing.js';
+
+export function mapResetNorth(map, options = cameraAnimatedOptions) { return mapSetBearing(map, 0, options); }

package/src/camera/mapResetNorthPitch.js

@@ -1 +1,4 @@
-export function mapResetNorthPitch(options = { animate: true }) { return this._animateCamera(0, 0, options); }
+import { cameraAnimatedOptions } from '../globals/cameraAnimatedOptions.js';
+import { mapAnimateCamera } from './mapAnimateCamera.js';
+
+export function mapResetNorthPitch(map, options = cameraAnimatedOptions) { return mapAnimateCamera(map, 0, 0, options); }

package/src/camera/mapSetBearing.js

@@ -1 +1,3 @@
-export function mapSetBearing(bearing, options) { return this._animateCamera(this.getPitch(), bearing, options); }
+import { mapAnimateCamera } from './mapAnimateCamera.js';
+import { mapGetPitch } from './mapGetPitch.js';
+export function mapSetBearing(map, bearing, options) { return mapAnimateCamera(map, mapGetPitch(map), bearing, options); }

package/src/camera/mapSetPitch.js

@@ -1 +1,3 @@
-export function mapSetPitch(pitch, options) { return this._animateCamera(pitch, this.getBearing(), options); }
+import { mapAnimateCamera } from './mapAnimateCamera.js';
+import { mapGetBearing } from './mapGetBearing.js';
+export function mapSetPitch(map, pitch, options) { return mapAnimateCamera(map, pitch, mapGetBearing(map), options); }

package/src/camera/mapSetPitchAndBearing.js

@@ -1,14 +1,22 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
+
 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;
+export function mapSetPitchAndBearing(map, pitch, bearing) {
+  if (!Number.isFinite(pitch) || !Number.isFinite(bearing)) throw /* alloc */ new TypeError('Camera angles must be finite numbers');
+  if (!Number.isFinite(map.options.maxPitch) || map.options.maxPitch < 0 || map.options.maxPitch > 180) {
+    throw /* alloc */ new TypeError('maxPitch must be between 0 and 180 degrees');
+  }
+  const previousPitch = mapGetPitch(map), previousBearing = mapGetBearing(map);
+  cameraByMap.get(map)._cameraPitch = Math.max(0, Math.min(map.options.maxPitch, pitch));
+  cameraByMap.get(map)._cameraBearing = ((bearing % 360) + 360) % 360;
+  if (map._loaded) {
+    updateSky.call(map);
+    if (previousBearing !== mapGetBearing(map)) map.fire('rotate', /* alloc */ { bearing: mapGetBearing(map) });
+    if (previousPitch !== mapGetPitch(map)) map.fire('pitch', /* alloc */ { pitch: mapGetPitch(map) });
+  }
+  return map;
 }

package/src/camera/mapSetZoomAround.js

@@ -1,11 +1,15 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { L } from '../globals/L.js';
+import { mapMethods } from '../globals/mapMethods.js';
+
+import { mapGetPitch } from './mapGetPitch.js';
+import { mapGetBearing } from './mapGetBearing.js';
 
 export function mapSetZoomAround(latlng, zoom, options) {
-  if (!this.getPitch() && !this.getBearing()) return mapCameraState.mapMethods.setZoomAround.call(this, latlng, zoom, options);
-  zoom = this._limitZoom(zoom);
-  const scale = this.getZoomScale(zoom), half = this.getSize().divideBy(2);
-  const screen = latlng instanceof L.Point ? latlng : this.latLngToContainerPoint(latlng);
-  const center = this.containerPointToLayerPoint(half), anchor = this.containerPointToLayerPoint(screen);
-  const next = center.add(anchor.subtract(center).multiplyBy(1 - 1 / scale));
-  return this.setView(this.layerPointToLatLng(next), zoom, { zoom: options });
+  if (!mapGetPitch(this) && !mapGetBearing(this)) return mapMethods.value.setZoomAround.call(this, latlng, zoom, options);
+  zoom = this._limitZoom(zoom);
+  const scale = this.getZoomScale(zoom), half = this.getSize().divideBy(2);
+  const screen = latlng instanceof L.Point ? latlng : this.latLngToContainerPoint(latlng);
+  const center = this.containerPointToLayerPoint(half), anchor = this.containerPointToLayerPoint(screen);
+  const next = center.add(anchor.subtract(center).multiplyBy(1 - 1 / scale));
+  return this.setView(this.layerPointToLatLng(next), zoom, /* alloc */ { zoom: options });
 }

package/src/camera/mapStopPitchBearingAnimation.js

@@ -1,6 +1,6 @@
 import { cancelCameraAnimation } from './cancelCameraAnimation.js';
 
-export function mapStopPitchBearingAnimation() {
-  cancelCameraAnimation(this);
-  return this;
+export function mapStopPitchBearingAnimation(map) {
+  cancelCameraAnimation(map);
+  return map;
 }

package/src/camera/mapTryAnimatedPan.js

@@ -1,9 +1,10 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { mapMethods } from '../globals/mapMethods.js';
+
 
 export function mapTryAnimatedPan(center, options) {
   // Leaflet's geographic recentering already supplies ground pixels, not screen pixels.
   const offset = this._getCenterOffset(center)._trunc();
   if (options?.animate !== true && !this.getSize().contains(offset)) return false;
-  mapCameraState.mapMethods.panBy.call(this, offset, options);
+  mapMethods.value.panBy.call(this, offset, options);
   return true;
 }

package/src/camera/mapUpdateCameraOverlays.js

@@ -1,6 +1,7 @@
-export function mapUpdateCameraOverlays() {
+import { L } from '../globals/L.js';
+export function mapUpdateCameraOverlays(map) {
   let layer;
-  for (layer of Object.values(this._layers)) {
+  for (layer of Object.values(map._layers)) {
     if (layer instanceof L.Marker) layer.update();
     else if (layer instanceof L.Popup || layer instanceof L.Tooltip) layer._updatePosition();
   }

package/src/camera/pointOf.js

@@ -1,3 +1,5 @@
+import { L } from '../globals/L.js';
 export function pointOf(point) {
-  return Array.isArray(point) ? new L.Point(point[0], point[1]) : new L.Point(point.x, point.y);
-}
+  return /* alloc */ new L.Point(
+    Array.isArray(point) ? point[0] : point.x, Array.isArray(point) ? point[1] : point.y);
+}

package/src/camera/project.js

@@ -1,20 +1,27 @@
+import { cameraAngles } from '../globals/cameraAngles.js';
 import { pointOf } from './pointOf.js';
 import { angles } from './angles.js';
 
-export function project(map, point, inverse = false, limit = false) {
-  const half = map.getSize().divideBy(2), distance = map.getSize().y * 1.5;
-  if (!distance) return pointOf(point);
-  const [cos, sin, tilt, rise] = angles(map);
-  const p = pointOf(point).subtract(half);
-  if (inverse) {
-    const far = map.getSize().y * map.options.pitchMaxDistance;
-    const denominator = tilt * distance + rise * p.y;
-    let v = denominator > 0 ? p.y * distance / denominator : -far;
-    if (limit) v = Math.max(-far, Math.min(far, v));
-    const u = p.x * (distance - rise * v) / distance;
-    return new L.Point(cos * u + sin * v, -sin * u + cos * v).add(half);
-  }
-  const u = cos * p.x - sin * p.y, v = sin * p.x + cos * p.y;
-  const scale = distance / (distance - rise * v);
-  return new L.Point(u * scale, tilt * v * scale).add(half);
+
+export function project(map, point, inverse = false, limit = false) {
+  const size = map.getSize(), halfX = size.x / 2, halfY = size.y / 2, distance = size.y * 1.5;
+  const result = pointOf(point);
+  if (!distance) return result;
+  const [cos, sin, tilt, rise] = angles(map, cameraAngles);
+  const x = result.x - halfX, y = result.y - halfY;
+  if (inverse) {
+    const far = size.y * map.options.pitchMaxDistance;
+    const denominator = tilt * distance + rise * y;
+    let v = denominator * tilt > 0 ? y * distance / denominator : -far;
+    if (limit) v = Math.max(-far, Math.min(far, v));
+    const u = x * (distance - rise * v) / distance;
+    result.x = cos * u + sin * v + halfX;
+    result.y = -sin * u + cos * v + halfY;
+    return result;
+  }
+  const u = cos * x - sin * y, v = sin * x + cos * y;
+  const scale = distance / (distance - rise * v);
+  result.x = u * scale + halfX;
+  result.y = tilt * v * scale + halfY;
+  return result;
 }

package/src/camera/runCameraAnimations.js

@@ -1,25 +1,28 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { cameraAnimationFrame } from '../globals/cameraAnimationFrame.js';
+import { cameraAnimations } from '../globals/cameraAnimations.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+import { mapSetPitchAndBearing } from './mapSetPitchAndBearing.js';
+
+
 import { scheduleCameraAnimation } from './scheduleCameraAnimation.js';
 
 export function runCameraAnimations(now) {
-  mapCameraState.cameraAnimationFrame = null;
-  const pending = [...mapCameraState.cameraAnimations];
-  mapCameraState.cameraAnimations.clear();
+  cameraAnimationFrame.value = null;
+  const pending = /* alloc */ [...cameraAnimations];
+  cameraAnimations.clear();
   let failure;
   let map, animation, progress, eased;
   for ([map, animation] of pending) {
-    map._cameraFrame = null;
-    if (map._cameraAnimation !== animation) continue;
+    cameraByMap.get(map)._cameraFrame = null;
+    if (cameraByMap.get(map)._cameraAnimation !== animation) continue;
     progress = animation.duration
       ? Math.min(1, (now - animation.start) / (animation.duration * 1000)) : 1;
     eased = 1 - (1 - progress) ** 3;
     try {
-      map._setPitchAndBearing(
-        animation.fromPitch + (Math.max(0, Math.min(85, animation.pitch)) - animation.fromPitch) * eased,
-        animation.fromBearing + animation.delta * eased,
-      );
-      if (progress < 1 && map._cameraAnimation === animation) scheduleCameraAnimation(map, animation);
-      else if (map._cameraAnimation === animation) map._cameraAnimation = null;
+      mapSetPitchAndBearing(map, animation.fromPitch + (Math.max(0, Math.min(map.options.maxPitch, animation.pitch)) - animation.fromPitch) * eased, animation.fromBearing + animation.delta * eased);
+      if (progress < 1 && cameraByMap.get(map)._cameraAnimation === animation) scheduleCameraAnimation(map, animation);
+      else if (cameraByMap.get(map)._cameraAnimation === animation) cameraByMap.get(map)._cameraAnimation = null;
     } catch (error) {
       failure ||= error;
     }

package/src/camera/scheduleCameraAnimation.js

@@ -1,8 +1,13 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { cameraAnimations } from '../globals/cameraAnimations.js';
+import { cameraAnimationFrame } from '../globals/cameraAnimationFrame.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
+
 import { runCameraAnimations } from './runCameraAnimations.js';
 
 export function scheduleCameraAnimation(map, animation) {
-  mapCameraState.cameraAnimations.set(map, animation);
-  if (mapCameraState.cameraAnimationFrame === null) mapCameraState.cameraAnimationFrame = requestAnimationFrame(runCameraAnimations);
-  map._cameraFrame = mapCameraState.cameraAnimationFrame;
+  cameraAnimations.set(map, animation);
+  if (cameraAnimationFrame.value === null) cameraAnimationFrame.value = requestAnimationFrame(runCameraAnimations);
+  cameraByMap.get(map)._cameraFrame = cameraAnimationFrame.value;
 }

package/src/camera/updateSky.js

@@ -1,16 +1,22 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { L } from '../globals/L.js';
+import { radians } from '../globals/radians.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
 
-export function updateSky() {
-  const height = this.getSize().y, pitch = this.getPitch() * mapCameraState.radians;
-  const far = height * this.options.pitchMaxDistance, distance = height * 1.5;
-  const top = height / 2 - far * Math.cos(pitch) * distance / (distance + Math.sin(pitch) * far);
-  if (top > 0 && !this._pitchSky) {
-    this._pitchSky = L.DomUtil.create('div', 'leaflet-pitch-sky', this.getContainer());
-    this._pitchSky.setAttribute('aria-hidden', 'true');
-    this._pitchSky.style.cssText = 'position:absolute;inset:0 0 auto;height:0;z-index:0;pointer-events:none;background:var(--leaflet-sky-background,linear-gradient(#9ec5e8,#dfe9f0))';
-  }
-  if (this._pitchSky) {
-    this._pitchSky.style.height = `${Math.max(0, Math.ceil(top))}px`;
-    this._pitchSky.style.display = top > 0 ? '' : 'none';
-  }
+import { mapGetPitch } from './mapGetPitch.js';
+
+
+export function updateSky() {
+  const height = this.getSize().y, pitch = mapGetPitch(this) * radians;
+  const far = height * this.options.pitchMaxDistance, distance = height * 1.5;
+  const top = height / 2 - far * Math.abs(Math.cos(pitch)) * distance / (distance + Math.sin(pitch) * far);
+  if (top > 0 && !cameraByMap.get(this)._pitchSky) {
+    cameraByMap.get(this)._pitchSky = L.DomUtil.create('div', 'leaflet-pitch-sky', this.getContainer());
+    cameraByMap.get(this)._pitchSky.setAttribute('aria-hidden', 'true');
+    cameraByMap.get(this)._pitchSky.style.cssText = 'position:absolute;inset:0 0 auto;height:0;z-index:0;pointer-events:none;background:var(--leaflet-sky-background,linear-gradient(#9ec5e8,#dfe9f0))';
+  }
+  if (cameraByMap.get(this)._pitchSky) {
+    cameraByMap.get(this)._pitchSky.style.inset = pitch > Math.PI / 2 ? 'auto 0 0' : '0 0 auto';
+    cameraByMap.get(this)._pitchSky.style.height = `${Math.max(0, Math.ceil(top))}px`;
+    cameraByMap.get(this)._pitchSky.style.display = top > 0 ? '' : 'none';
+  }
 }