leaflet-city-mapper 0.0.3 → 0.0.5

package/src/controls/moveCameraTouch.js

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

package/src/controls/pitchDragAddHooks.js

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

package/src/controls/refreshRotateControl.js

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

package/src/controls/removeCameraDrag.js

@@ -1,10 +1,13 @@
+import { dragStates } from '../weakmaps/dragStates.js';
+import { cameraDrags } from '../globals/cameraDrags.js';
+
 import { finishCameraDrag } from './finishCameraDrag.js';
 import { cameraDragDown } from './cameraDragDown.js';
 import { cameraDragMove } from './cameraDragMove.js';
 import { cameraDragEnd } from './cameraDragEnd.js';
 import { cameraDragClick } from './cameraDragClick.js';
 import { cameraDragContextMenu } from './cameraDragContextMenu.js';
-import { cameraControlsState } from '../constants/cameraControlsState.js';
+
 import { endAllCameraDrags } from './endAllCameraDrags.js';
 
 export function removeCameraDrag(state) {
@@ -17,7 +20,7 @@ export function removeCameraDrag(state) {
   element.removeEventListener('lostpointercapture', cameraDragEnd);
   element.removeEventListener('click', cameraDragClick, true);
   element.removeEventListener('contextmenu', cameraDragContextMenu);
-  cameraControlsState.dragStates.delete(element);
-  cameraControlsState.cameraDrags.delete(state);
-  if (!cameraControlsState.cameraDrags.size) window.removeEventListener('blur', endAllCameraDrags);
+  dragStates.value.delete(element);
+  cameraDrags.value.delete(state);
+  if (!cameraDrags.value.size) window.removeEventListener('blur', endAllCameraDrags);
 }

package/src/controls/rotateButtonClick.js

@@ -1,7 +1,11 @@
+import { cameraFocusOptions } from '../globals/cameraFocusOptions.js';
+import { mapResetNorthPitch } from '../camera/mapResetNorthPitch.js';
+import { mapResetNorth } from '../camera/mapResetNorth.js';
+
 export function rotateButtonClick(event) {
   const control = this._rotateControl, map = control._map;
   event.preventDefault();
-  if (control.options.visualizePitch) map.resetNorthPitch();
-  else map.resetNorth();
-  if (event.detail) map.getContainer().focus({ preventScroll: true });
-}
+  if (control.options.visualizePitch) mapResetNorthPitch(map);
+  else mapResetNorth(map);
+  if (event.detail) map.getContainer().focus(cameraFocusOptions);
+}

package/src/controls/rotateButtonKeydown.js

@@ -1,9 +1,13 @@
+import { mapSetBearing } from '../camera/mapSetBearing.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+import { mapSetPitch } from '../camera/mapSetPitch.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
 export function rotateButtonKeydown(event) {
   const control = this._rotateControl, map = control._map, step = event.shiftKey ? 15 : 5;
-  if (event.key === 'ArrowLeft') map.setBearing(map.getBearing() - step);
-  else if (event.key === 'ArrowRight') map.setBearing(map.getBearing() + step);
-  else if (event.key === 'ArrowUp' && control.options.visualizePitch) map.setPitch(map.getPitch() + step);
-  else if (event.key === 'ArrowDown' && control.options.visualizePitch) map.setPitch(map.getPitch() - step);
+  if (event.key === 'ArrowLeft') mapSetBearing(map, mapGetBearing(map) - step);
+  else if (event.key === 'ArrowRight') mapSetBearing(map, mapGetBearing(map) + step);
+  else if (event.key === 'ArrowUp' && control.options.visualizePitch) mapSetPitch(map, mapGetPitch(map) + step);
+  else if (event.key === 'ArrowDown' && control.options.visualizePitch) mapSetPitch(map, mapGetPitch(map) - step);
   else if (event.key === 'Home' || event.key === ' ') this.click();
   else return;
   event.preventDefault();

package/src/controls/rotateControl.js

@@ -1,3 +1,4 @@
+import { L } from '../globals/L.js';
 export function rotateControl(options) {
-  return new L.Control.Rotate(options);
-}
+  return /* alloc */ new L.Control.Rotate(options);
+}

package/src/controls/rotateOnAdd.js

@@ -1,3 +1,6 @@
+import { L } from '../globals/L.js';
+import { cameraDragSensitivity } from '../globals/cameraDragSensitivity.js';
+import { cameraBearingSensitivity } from '../globals/cameraBearingSensitivity.js';
 import { rotateButtonClick } from './rotateButtonClick.js';
 import { rotateButtonKeydown } from './rotateButtonKeydown.js';
 import { refreshRotateControl } from './refreshRotateControl.js';
@@ -5,34 +8,35 @@ import { dragCamera } from './dragCamera.js';
 import { acceptRotateDrag } from './acceptRotateDrag.js';
 import { refreshRotateFocus } from './refreshRotateFocus.js';
 
+
 export function rotateOnAdd(map) {
-  const container = L.DomUtil.create('div', 'leaflet-control-rotate leaflet-bar');
-  const button = L.DomUtil.create('a', 'leaflet-control-rotate-toggle', container);
-  this._map = map;
-  this._container = container;
-  this._button = button;
-  button._rotateControl = this;
-  button.href = '#';
-  button.draggable = false;
-  button.setAttribute('role', 'button');
-  button.title = this.options.visualizePitch ? 'Reset bearing and pitch' : 'Reset bearing to north';
-  button.setAttribute('aria-label', button.title);
-  button.style.cssText = 'cursor:grab;touch-action:none';
-  const arrow = L.DomUtil.create('span', 'leaflet-control-rotate-arrow', button);
-  this._arrow = arrow;
-  arrow.setAttribute('aria-hidden', 'true');
-  arrow.style.cssText = 'display:block;width:100%;height:100%;pointer-events:none;background: no-repeat center / 29px 29px';
-  arrow.style.backgroundImage = 'url("data:image/svg+xml,%3Csvg xmlns=%27http://www.w3.org/2000/svg%27 viewBox=%270 0 29 29%27%3E%3Cpath fill=%27%23333%27 d=%27M10.5 14 14.5 6 18.5 14Z%27/%3E%3Cpath fill=%27%23ccc%27 d=%27M10.5 16 14.5 24 18.5 16Z%27/%3E%3C/svg%3E")';
-  button.onclick = rotateButtonClick;
-  button.onkeydown = rotateButtonKeydown;
-  this._refresh = refreshRotateControl;
-  map.on('rotate pitch', this._refresh, this);
-  this._refresh();
-  this._dragState = dragCamera(map, button, acceptRotateDrag,
-    [0.8, this.options.visualizePitch ? 0.5 : 0]);
-  button.addEventListener('focusout', refreshRotateFocus);
-  L.DomEvent.on(button, 'dblclick contextmenu', L.DomEvent.stop);
-  L.DomEvent.disableClickPropagation(container);
-  L.DomEvent.disableScrollPropagation(container);
+  const container = L.DomUtil.create('div', 'leaflet-control-rotate leaflet-bar');
+  const button = L.DomUtil.create('a', 'leaflet-control-rotate-toggle', container);
+  this._map = map;
+  this._container = container;
+  this._button = button;
+  button._rotateControl = this;
+  button.href = '#';
+  button.draggable = false;
+  button.setAttribute('role', 'button');
+  button.title = this.options.visualizePitch ? 'Reset bearing and pitch' : 'Reset bearing to north';
+  button.setAttribute('aria-label', button.title);
+  button.style.cssText = 'cursor:grab;touch-action:none';
+  const arrow = L.DomUtil.create('span', 'leaflet-control-rotate-arrow', button);
+  this._arrow = arrow;
+  arrow.setAttribute('aria-hidden', 'true');
+  arrow.style.cssText = 'display:block;width:100%;height:100%;pointer-events:none;background: no-repeat center / 29px 29px';
+  arrow.style.backgroundImage = 'url("data:image/svg+xml,%3Csvg xmlns=%27http://www.w3.org/2000/svg%27 viewBox=%270 0 29 29%27%3E%3Cpath fill=%27%23333%27 d=%27M10.5 14 14.5 6 18.5 14Z%27/%3E%3Cpath fill=%27%23ccc%27 d=%27M10.5 16 14.5 24 18.5 16Z%27/%3E%3C/svg%3E")';
+  button.onclick = rotateButtonClick;
+  button.onkeydown = rotateButtonKeydown;
+  this._refresh = refreshRotateControl;
+  map.on('rotate pitch', this._refresh, this);
+  this._refresh();
+  this._dragState = dragCamera(map, button, acceptRotateDrag,
+    this.options.visualizePitch ? cameraDragSensitivity : cameraBearingSensitivity);
+  button.addEventListener('focusout', refreshRotateFocus);
+  L.DomEvent.on(button, 'dblclick contextmenu', L.DomEvent.stop);
+  L.DomEvent.disableClickPropagation(container);
+  L.DomEvent.disableScrollPropagation(container);
   return container;
 }

package/src/controls/shiftRotateAddHooks.js

@@ -1,8 +1,10 @@
+import { cameraListenerOptions } from '../globals/cameraListenerOptions.js';
 import { shiftRotateWheel } from './shiftRotateWheel.js';
 
+
 export function shiftRotateAddHooks() {
-  const container = this._map.getContainer();
-  container._cameraShiftRotate = this;
-  this._wheel = shiftRotateWheel;
-  container.addEventListener('wheel', this._wheel, { passive: false, capture: true });
+  const container = this._map.getContainer();
+  container._cameraShiftRotate = this;
+  this._wheel = shiftRotateWheel;
+  container.addEventListener('wheel', this._wheel, cameraListenerOptions);
 }

package/src/controls/shiftRotateWheel.js

@@ -1,9 +1,11 @@
-import { editable } from './editable.js';
+import { mapSetBearing } from '../camera/mapSetBearing.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+import { editable } from './isEditableTarget.js';
 
 export function shiftRotateWheel(event) {
   const handler = this._cameraShiftRotate;
   if (!event.shiftKey || editable(event.target) || event.target.closest('.leaflet-control')) return;
   event.preventDefault();
   event.stopImmediatePropagation();
-  handler._map.setBearing(handler._map.getBearing() + Math.sign(event.deltaY) * 5);
+  mapSetBearing(handler._map, mapGetBearing(handler._map) + Math.sign(event.deltaY) * 5);
 }

package/src/controls/startCameraTouch.js

@@ -1,23 +1,35 @@
-export function startCameraTouch(event) {
-  const state = this._cameraTouchState, { map, container } = state;
-  if (state.touch || event.touches.length !== 2 || event.target.closest('.leaflet-control')) return;
-  if (!map.touchRotate.enabled() && !map.touchPitch.enabled()) return;
-  const [a, b] = event.touches;
-  if (Math.hypot(b.clientX - a.clientX, b.clientY - a.clientY) < 1) return;
-  map._stopPitchBearingAnimation();
-  const middle = new L.Point((a.clientX + b.clientX) / 2, (a.clientY + b.clientY) / 2)
-    .subtract(new L.Point(container.getBoundingClientRect().left, container.getBoundingClientRect().top));
-  state.touch = {
-    angle: Math.atan2(b.clientY - a.clientY, b.clientX - a.clientX),
-    distance: Math.hypot(b.clientX - a.clientX, b.clientY - a.clientY), middle,
-    anchor: map.containerPointToLatLng(middle), zoom: map.getZoom(),
-    bearing: map.getBearing(), pitch: map.getPitch(), zooming: map.touchZoom?.enabled(),
-    dragging: map.dragging?.enabled(),
-  };
-  map.dragging?.disable();
-  event.preventDefault();
-  event.stopImmediatePropagation();
-  if (state.nativeZoom !== undefined) state.touch.zooming = state.nativeZoom;
-  state.touch.snap = map.options.zoomSnap;
-  map.options.zoomSnap = 0;
+import { touchPitchByMap } from '../weakmaps/touchPitchByMap.js';
+import { touchRotateByMap } from '../weakmaps/touchRotateByMap.js';
+
+import { L } from '../globals/L.js';
+import { touchByContainer } from '../weakmaps/touchByContainer.js';
+
+import { mapStopPitchBearingAnimation } from '../animations/mapStopPitchBearingAnimation.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+
+export function startCameraTouch(event) {
+  const state = touchByContainer.get(this), { map, container } = state;
+  if (state.touch || event.touches.length !== 2 || event.target.closest('.leaflet-control')) return;
+  if (!touchRotateByMap.get(map).enabled() && !touchPitchByMap.get(map).enabled()) return;
+  const [a, b] = event.touches;
+  if (Math.hypot(b.clientX - a.clientX, b.clientY - a.clientY) < 1) return;
+  mapStopPitchBearingAnimation(map);
+  const rect = container.getBoundingClientRect();
+  const middle = /* alloc */ new L.Point(
+    (a.clientX + b.clientX) / 2 - rect.left, (a.clientY + b.clientY) / 2 - rect.top);
+  state.touch = /* alloc */ {
+    angle: Math.atan2(b.clientY - a.clientY, b.clientX - a.clientX),
+    distance: Math.hypot(b.clientX - a.clientX, b.clientY - a.clientY), middle,
+    anchor: map.containerPointToLatLng(middle), zoom: map.getZoom(),
+    bearing: mapGetBearing(map), pitch: mapGetPitch(map), zooming: map.touchZoom?.enabled(),
+    dragging: map.dragging?.enabled(),
+    currentMiddle: /* alloc */ new L.Point(middle.x, middle.y),
+  };
+  map.dragging?.disable();
+  event.preventDefault();
+  event.stopImmediatePropagation();
+  if (state.nativeZoom !== undefined) state.touch.zooming = state.nativeZoom;
+  state.touch.snap = map.options.zoomSnap;
+  map.options.zoomSnap = 0;
 }

package/src/core/adjustCameraMarkerPan.js

@@ -1,22 +1,28 @@
-import { pointOf } from '../camera/pointOf.js';
-import { scheduleMarkerPan } from './scheduleMarkerPan.js';
+import { L } from '../globals/L.js';
+import { dragByHandler } from '../weakmaps/dragByHandler.js';
 
-export function adjustCameraMarkerPan(event) {
-  const marker = this._marker, map = marker._map;
-  if (!map.getPitch() && !map.getBearing()) return this._cameraOriginalAdjustPan.call(this, event);
-  const screen = L.DomUtil.getPosition(marker._icon).add(map._getMapPanePos());
-  const size = map.getSize(), padding = pointOf(marker.options.autoPanPadding);
-  const speed = marker.options.autoPanSpeed;
-  const movement = new L.Point(
-    (Math.max(0, screen.x - size.x + padding.x) - Math.max(0, padding.x - screen.x)) / Math.max(1, padding.x) * speed,
-    (Math.max(0, screen.y - size.y + padding.y) - Math.max(0, padding.y - screen.y)) / Math.max(1, padding.y) * speed);
-  if (!movement.x && !movement.y) return;
-  const pane = map._getMapPanePos();
-  map.panBy(movement, { animate: false });
-  const shift = pane.subtract(map._getMapPanePos());
-  this._draggable._newPos._add(shift);
-  this._draggable._startPos._add(shift);
-  L.DomUtil.setPosition(marker._icon, this._draggable._newPos);
-  this._onDrag(event);
-  scheduleMarkerPan(this, event);
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+import { pointOf } from '../projections/toPoint.js';
+import { scheduleMarkerPan } from '../animations/scheduleMarkerPan.js';
+
+export function adjustCameraMarkerPan(event) {
+  const marker = this._marker, map = marker._map;
+  if (!mapGetPitch(map) && !mapGetBearing(map)) return dragByHandler.get(this)._cameraOriginalAdjustPan.call(this, event);
+  const screen = L.DomUtil.getPosition(marker._icon).add(map._getMapPanePos());
+  const size = map.getSize(), padding = pointOf(marker.options.autoPanPadding);
+  const speed = marker.options.autoPanSpeed;
+  const movement = screen;
+  movement.x = (Math.max(0, screen.x - size.x + padding.x) - Math.max(0, padding.x - screen.x)) / Math.max(1, padding.x) * speed;
+  movement.y = (Math.max(0, screen.y - size.y + padding.y) - Math.max(0, padding.y - screen.y)) / Math.max(1, padding.y) * speed;
+  if (!movement.x && !movement.y) return;
+  const pane = map._getMapPanePos();
+  map.panBy(movement, /* alloc */ { animate: false });
+  const shift = pane.subtract(map._getMapPanePos());
+  this._draggable._newPos._add(shift);
+  this._draggable._startPos._add(shift);
+  L.DomUtil.setPosition(marker._icon, this._draggable._newPos);
+  this._onDrag(event);
+  scheduleMarkerPan(this, event);
 }

package/src/core/cameraCircleBounds.js

@@ -1,6 +1,7 @@
-import { indexState } from '../constants/indexState.js';
+import { boundsMethods } from '../weakmaps/boundsMethods.js';
+
 
 export function cameraCircleBounds() {
   this._project();
-  return indexState.boundsMethods.get(this).call(this);
+  return boundsMethods.get(this).call(this);
 }

package/src/core/cameraMarkerDrag.js

@@ -1,18 +1,21 @@
+import { dragByHandler } from '../weakmaps/dragByHandler.js';
+
+
 import { cameraMarkerOnDrag } from './cameraMarkerOnDrag.js';
 import { adjustCameraMarkerPan } from './adjustCameraMarkerPan.js';
 
 export function cameraMarkerDrag() {
-  if (!this.dragging || this.dragging._cameraDrag) return;
-  const drag = this.dragging, original = drag._onDrag, adjustPan = drag._adjustPan;
-  drag._cameraOriginalOnDrag = original;
-  drag._cameraOriginalAdjustPan = adjustPan;
-  drag._onDrag = cameraMarkerOnDrag;
-  drag._adjustPan = adjustCameraMarkerPan;
-  // The handler may already be enabled and listening with its original method.
-  const enabled = drag.enabled();
-  if (enabled) {
-    drag._draggable.off('drag', original, drag);
-    drag._draggable.on('drag', drag._onDrag, drag);
-  }
-  drag._cameraDrag = true;
+  if (!this.dragging || dragByHandler.has(this.dragging)) return;
+  const drag = this.dragging, original = drag._onDrag, adjustPan = drag._adjustPan;
+  dragByHandler.set(drag, /* alloc */ {
+    _cameraOriginalOnDrag: original, _cameraOriginalAdjustPan: adjustPan,
+  });
+  drag._onDrag = cameraMarkerOnDrag;
+  drag._adjustPan = adjustCameraMarkerPan;
+  // The handler may already be enabled and listening with its original method.
+  const enabled = drag.enabled();
+  if (enabled) {
+    drag._draggable.off('drag', original, drag);
+    drag._draggable.on('drag', drag._onDrag, drag);
+  }
 }

package/src/core/cameraMarkerOnDrag.js

@@ -1,8 +1,13 @@
+import { L } from '../globals/L.js';
+import { dragByHandler } from '../weakmaps/dragByHandler.js';
+
+
+
 export function cameraMarkerOnDrag(event) {
   const map = this._marker._map;
   const screen = L.DomUtil.getPosition(this._marker._icon).add(map._getMapPanePos());
   const point = map.containerPointToLayerPoint(screen);
   L.DomUtil.setPosition(this._marker._icon, point);
-  this._cameraOriginalOnDrag.call(this, event);
+  dragByHandler.get(this)._cameraOriginalOnDrag.call(this, event);
   this._marker._setPos(point);
-}
+}

package/src/core/closestCameraLayerPoint.js

@@ -1,7 +1,8 @@
-import { indexState } from '../constants/indexState.js';
+import { closestMethods } from '../weakmaps/closestMethods.js';
+
 
 export function closestCameraLayerPoint(point) {
   this._project();
   this._parts = this._rings;
-  return indexState.closestMethods.get(this).call(this, point);
+  return closestMethods.get(this).call(this, point);
 }

package/src/core/fireRasterLoad.js

@@ -1,5 +1,6 @@
-import { indexState } from '../constants/indexState.js';
+import { pendingRasterLoads } from '../globals/pendingRasterLoads.js';
+
 
 export function fireRasterLoad() {
-  indexState.pendingRasterLoads.shift()?.fire('load');
+  pendingRasterLoads.shift()?.fire('load');
 }

package/src/core/gridlayerGetEvents.js

@@ -1,7 +1,10 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { L } from '../globals/L.js';
+import { gridEvents } from '../globals/gridEvents.js';
+
+
 
 export function gridlayerGetEvents() {
-  const events = mapCameraState.gridEvents.call(this);
-  this._cameraGridUpdate ||= L.Util.throttle(this._onMoveEnd, this.options.updateInterval, this);
-  return { ...events, rotate: this._cameraGridUpdate, pitch: this._cameraGridUpdate };
+  const events = gridEvents.value.call(this);
+  events.rotate = events.pitch = L.Util.throttle(this._onMoveEnd, this.options.updateInterval, this);
+  return events;
 }

package/src/core/gridlayerGetTiledPixelBounds.js

@@ -1,8 +1,12 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { L } from '../globals/L.js';
+import { tiledBounds } from '../globals/tiledBounds.js';
+
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
 
 export function gridlayerGetTiledPixelBounds(center) {
-  if (!this._map.getBearing() && !this._map.getPitch()) return mapCameraState.tiledBounds.call(this, center);
-  const bounds = this._map.getBounds();
-  return new L.Bounds(this._map.project(bounds.getNorthWest(), this._tileZoom),
+  if (!mapGetBearing(this._map) && !mapGetPitch(this._map)) return tiledBounds.value.call(this, center);
+  const bounds = this._map.getBounds();
+  return /* alloc */ new L.Bounds(this._map.project(bounds.getNorthWest(), this._tileZoom),
     this._map.project(bounds.getSouthEast(), this._tileZoom));
 }

package/src/core/initializeGridContainer.js

@@ -1,6 +1,7 @@
-import { indexState } from '../constants/indexState.js';
+import { gridInitializers } from '../weakmaps/gridInitializers.js';
+
 
 export function initializeGridContainer() {
-  indexState.gridInitializers.get(this).call(this);
+  gridInitializers.get(this).call(this);
   this._container.remove();
 }

package/src/core/initializeNativeLayer.js

@@ -1,42 +1,41 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+
+import { L } from '../globals/L.js';
+import { closestMethods } from '../weakmaps/closestMethods.js';
+import { boundsMethods } from '../weakmaps/boundsMethods.js';
+import { gridInitializers } from '../weakmaps/gridInitializers.js';
+
+
 import { noOperation } from '../utils/noOperation.js';
 import { emptyEvents } from '../scene/emptyEvents.js';
-import { refreshNativeLayerContract } from './refreshNativeLayerContract.js';
-import { bringNativeLayerToFront } from './bringNativeLayerToFront.js';
-import { bringNativeLayerToBack } from './bringNativeLayerToBack.js';
-import { indexState } from '../constants/indexState.js';
+import { refreshNativeLayerContract } from '../native/refreshNativeLayerContract.js';
+
 import { closestCameraLayerPoint } from './closestCameraLayerPoint.js';
 import { cameraCircleBounds } from './cameraCircleBounds.js';
 import { initializeGridContainer } from './initializeGridContainer.js';
 import { updateGridOpacity } from './updateGridOpacity.js';
-import { addRasterImage } from './addRasterImage.js';
+import { addRasterImage } from '../textures/attachRasterImage.js';
+import { redrawPath } from './redrawPath.js';
 
 export function initializeNativeLayer() {
   if (this instanceof L.Polyline || this instanceof L.CircleMarker) {
-    this.beforeAdd = this.onAdd = this.onRemove = this._updateBounds = noOperation;
-    this.getEvents = emptyEvents;
-    this._renderer = {
-      options: { tolerance: 0 },
-      _updatePath: refreshNativeLayerContract,
-      _updateStyle: refreshNativeLayerContract,
-      _bringToFront: bringNativeLayerToFront,
-      _bringToBack: bringNativeLayerToBack,
-    };
+    this.beforeAdd = this._updateBounds = noOperation;
+    this.redraw = redrawPath;
+    kindByLayer.set(this, 'path');
     if (this instanceof L.Polyline) {
-      indexState.closestMethods.set(this, this.closestLayerPoint);
+      closestMethods.set(this, this.closestLayerPoint);
       this.closestLayerPoint = closestCameraLayerPoint;
     }
     if (this instanceof L.Circle) {
-      indexState.boundsMethods.set(this, this.getBounds);
+      boundsMethods.set(this, this.getBounds);
       this.getBounds = cameraCircleBounds;
     }
   } else if (this instanceof L.GridLayer) {
-    indexState.gridInitializers.set(this, this._initContainer);
+    gridInitializers.set(this, this._initContainer);
     this._initContainer = initializeGridContainer;
     this._updateOpacity = updateGridOpacity;
   } else if (this instanceof L.ImageOverlay && !(this instanceof L.VideoOverlay) && !(this instanceof L.SVGOverlay)) {
-    this.onAdd = addRasterImage;
-    this.onRemove = noOperation;
-    this.getEvents = emptyEvents;
+    kindByLayer.set(this, 'image');
     this._reset = refreshNativeLayerContract;
   }
 }

package/src/core/layerCallInitHooks.js

@@ -0,0 +1,15 @@
+import { sceneLayers } from '../weakmaps/sceneLayers.js';
+
+import { layerCallInitHooks as sharedLayerCallInitHooks } from '../globals/layerCallInitHooks.js';
+
+
+import { initializeNativeLayer } from './initializeNativeLayer.js';
+
+export function layerCallInitHooks() {
+  if (!sceneLayers.has(this)) {
+    sceneLayers.add(this);
+  }
+  const initialized = this._initHooksCalled;
+  sharedLayerCallInitHooks.value.call(this);
+  if (!initialized) initializeNativeLayer.call(this);
+}

package/src/core/markerGetEvents.js

@@ -1,5 +1,9 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { markerMethods } from '../globals/markerMethods.js';
+
+
 
 export function markerGetEvents() {
-  return { ...mapCameraState.markerMethods.getEvents.call(this), rotate: this.update, pitch: this.update, move: this.update };
+  const events = markerMethods.value.getEvents.call(this);
+  events.rotate = events.pitch = events.move = this.update;
+  return events;
 }

package/src/core/markerInitInteraction.js

@@ -1,8 +1,10 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { markerMethods } from '../globals/markerMethods.js';
+
+
 import { cameraMarkerDrag } from './cameraMarkerDrag.js';
 
 export function markerInitInteraction() {
-  const result = mapCameraState.markerMethods._initInteraction.call(this);
+  const result = markerMethods.value._initInteraction.call(this);
   cameraMarkerDrag.call(this);
   return result;
 }

package/src/core/markerSetIcon.js

@@ -1,9 +1,12 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
-import { initNativeGPU } from './initNativeGPU.js';
+import { L } from '../globals/L.js';
+import { markerMethods } from '../globals/markerMethods.js';
+
+
+import { initNativeGPU } from '../native/initNativeGPU.js';
 
 export function markerSetIcon(icon) {
   if (!(icon instanceof L.DivIcon)) icon.options.crossOrigin ||= true;
-  const result = mapCameraState.markerMethods.setIcon.call(this, icon);
+  const result = markerMethods.value.setIcon.call(this, icon);
   if (this._map && !(icon instanceof L.DivIcon)) initNativeGPU(this, this._map);
   return result;
 }