leaflet-city-mapper 0.0.2 → 0.0.4

package/src/controls/dragCamera.js

@@ -0,0 +1,26 @@
+import { cameraDragSensitivity } from '../globals/cameraDragSensitivity.js';
+import { dragStates } from '../globals/dragStates.js';
+import { cameraDrags } from '../globals/cameraDrags.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 { endAllCameraDrags } from './endAllCameraDrags.js';
+
+export function dragCamera(map, element, accept, sensitivity = cameraDragSensitivity, orbit = false) {
+  const state = /* alloc */ { map, element, accept, sensitivity, orbit, drag: null, moved: false };
+  dragStates.value.set(element, state);
+  cameraDrags.value.add(state);
+  element.addEventListener('pointerdown', cameraDragDown, true);
+  element.addEventListener('pointermove', cameraDragMove);
+  element.addEventListener('pointerup', cameraDragEnd);
+  element.addEventListener('pointercancel', cameraDragEnd);
+  element.addEventListener('lostpointercapture', cameraDragEnd);
+  element.addEventListener('click', cameraDragClick, true);
+  element.addEventListener('contextmenu', cameraDragContextMenu);
+  window.addEventListener('blur', endAllCameraDrags);
+  return state;
+}

package/src/controls/editable.js

@@ -0,0 +1,3 @@
+export function editable(target) {
+  return target.closest?.('input,textarea,select,[contenteditable="true"]');
+}

package/src/controls/endAllCameraDrags.js

@@ -0,0 +1,9 @@
+import { cameraDrags } from '../globals/cameraDrags.js';
+
+
+import { finishCameraDrag } from './finishCameraDrag.js';
+
+export function endAllCameraDrags() {
+  let state;
+  for (state of cameraDrags.value) finishCameraDrag(state);
+}

package/src/controls/endAllCameraTouches.js

@@ -0,0 +1,9 @@
+import { cameraTouchStates } from '../globals/cameraTouchStates.js';
+
+
+import { endCameraTouch } from './endCameraTouch.js';
+
+export function endAllCameraTouches() {
+  let state;
+  for (state of cameraTouchStates) endCameraTouch(state);
+}

package/src/controls/endCameraTouch.js

@@ -0,0 +1,12 @@
+export function endCameraTouch(state, event) {
+  if (!state.touch) return;
+  if (event?.touches?.length >= 2) return;
+  const { map, container, touch } = state;
+  if (touch.dragging && container._leaflet_id) map.dragging.enable();
+  map.options.zoomSnap = touch.snap;
+  if (touch.zooming && touch.snap && container._leaflet_id) {
+    map.setZoom(Math.round(map.getZoom() / touch.snap) * touch.snap,
+      /* alloc */ { animate: false });
+  }
+  state.touch = null;
+}

package/src/controls/endCameraTouchEvent.js

@@ -0,0 +1,8 @@
+import { touchByContainer } from '../globals/touchByContainer.js';
+
+
+import { endCameraTouch } from './endCameraTouch.js';
+
+export function endCameraTouchEvent(event) {
+  endCameraTouch(touchByContainer.get(this), event);
+}

package/src/controls/failCompassPermission.js

@@ -0,0 +1,4 @@
+export function failCompassPermission(handler, error) {
+  handler.disable();
+  handler._map.fire('error', /* alloc */ { error });
+}

package/src/controls/finishCameraDrag.js

@@ -0,0 +1,9 @@
+export function finishCameraDrag(state, event) {
+  if (!state?.drag) return;
+  if (event?.pointerId !== undefined && event.pointerId !== state.drag.id) return;
+  const finished = state.drag;
+  state.drag = null;
+  if (state.element.hasPointerCapture?.(finished.id)) state.element.releasePointerCapture(finished.id);
+  if (finished.dragging && state.map.getContainer()._leaflet_id) state.map.dragging.enable();
+  state.element.style.cursor = finished.cursor;
+}

package/src/controls/finishCompassPermission.js

@@ -0,0 +1,17 @@
+import { failCompassPermission } from './failCompassPermission.js';
+
+export function finishCompassPermission([handlerResult, permissionResult]) {
+  const { handler, generation } = handlerResult.value;
+  if (!handler.enabled() || handler._generation !== generation) return;
+  if (!window.DeviceOrientationEvent || permissionResult.status !== 'fulfilled' ||
+    permissionResult.value !== 'granted') {
+    return failCompassPermission(handler, permissionResult.status === 'rejected' ? permissionResult.reason :
+      /* alloc */ new Error('Device compass permission unavailable or denied'));
+  }
+  try {
+    window.addEventListener('deviceorientation', handler._orientation);
+    window.addEventListener('deviceorientationabsolute', handler._orientation);
+  } catch (error) {
+    failCompassPermission(handler, error);
+  }
+}

package/src/controls/loadCameraControls.js

@@ -0,0 +1,9 @@
+export async function loadCameraControls(map) {
+  try {
+    const { cameraControls } = await import('./cameraControls.js');
+    if (map._container?._leaflet_id) cameraControls(map);
+  } catch (error) {
+    map.fire('error', /* alloc */ { error });
+    throw error;
+  }
+}

package/src/controls/moveCameraTouch.js

@@ -0,0 +1,29 @@
+import { degrees } from '../globals/degrees.js';
+import { touchByContainer } from '../globals/touchByContainer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+import { mapSetPitchAndBearing } from '../camera/mapSetPitchAndBearing.js';
+
+export function moveCameraTouch(event) {
+  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 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, cameraByMap.get(map).touchPitch.enabled() ? touch.pitch - (middle.y - touch.middle.y) * 0.25 : touch.pitch, cameraByMap.get(map).touchRotate.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, /* 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(),
+      /* alloc */ { animate: false });
+  }
+  event.preventDefault();
+  event.stopImmediatePropagation();
+}

package/src/controls/notifyCameraTouchChange.js

@@ -0,0 +1 @@
+export function notifyCameraTouchChange() { this._map.fire('cameratouchchange'); }

package/src/controls/pitchDragAddHooks.js

@@ -0,0 +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, cameraDragSensitivity, true);
+}

package/src/controls/pitchDragRemoveHooks.js

@@ -0,0 +1,5 @@
+import { removeCameraDrag } from './removeCameraDrag.js';
+
+export function pitchDragRemoveHooks() {
+  removeCameraDrag(this._dragState);
+}

package/src/controls/refreshRotateControl.js

@@ -0,0 +1,10 @@
+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/refreshRotateFocus.js

@@ -0,0 +1,5 @@
+import { refreshRotateControl } from './refreshRotateControl.js';
+
+export function refreshRotateFocus() {
+  refreshRotateControl.call(this._rotateControl);
+}

package/src/controls/removeCameraDrag.js

@@ -0,0 +1,26 @@
+import { dragStates } from '../globals/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 { endAllCameraDrags } from './endAllCameraDrags.js';
+
+export function removeCameraDrag(state) {
+  finishCameraDrag(state);
+  const { element } = state;
+  element.removeEventListener('pointerdown', cameraDragDown, true);
+  element.removeEventListener('pointermove', cameraDragMove);
+  element.removeEventListener('pointerup', cameraDragEnd);
+  element.removeEventListener('pointercancel', cameraDragEnd);
+  element.removeEventListener('lostpointercapture', cameraDragEnd);
+  element.removeEventListener('click', cameraDragClick, true);
+  element.removeEventListener('contextmenu', cameraDragContextMenu);
+  dragStates.value.delete(element);
+  cameraDrags.value.delete(state);
+  if (!cameraDrags.value.size) window.removeEventListener('blur', endAllCameraDrags);
+}

package/src/controls/resizeMap.js

@@ -0,0 +1,3 @@
+export function resizeMap(entries) {
+  entries[0]?.target._containerResizeMap.invalidateSize();
+}

package/src/controls/rotateButtonClick.js

@@ -0,0 +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) mapResetNorthPitch(map);
+  else mapResetNorth(map);
+  if (event.detail) map.getContainer().focus(cameraFocusOptions);
+}

package/src/controls/rotateButtonKeydown.js

@@ -0,0 +1,15 @@
+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') 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();
+  event.stopPropagation();
+}

package/src/controls/rotateControl.js

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

package/src/controls/rotateOnAdd.js

@@ -0,0 +1,42 @@
+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';
+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,
+    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/rotateOnRemove.js

@@ -0,0 +1,6 @@
+import { pitchDragRemoveHooks } from './pitchDragRemoveHooks.js';
+
+export function rotateOnRemove(map) {
+  map.off('rotate pitch', this._refresh, this);
+  pitchDragRemoveHooks.call(this);
+}

package/src/controls/shiftRotateAddHooks.js

@@ -0,0 +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, cameraListenerOptions);
+}

package/src/controls/shiftRotateRemoveHooks.js

@@ -0,0 +1,5 @@
+export function shiftRotateRemoveHooks() {
+  const container = this._map.getContainer();
+  container.removeEventListener('wheel', this._wheel, true);
+  delete container._cameraShiftRotate;
+}

package/src/controls/shiftRotateWheel.js

@@ -0,0 +1,11 @@
+import { mapSetBearing } from '../camera/mapSetBearing.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+import { editable } from './editable.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();
+  mapSetBearing(handler._map, mapGetBearing(handler._map) + Math.sign(event.deltaY) * 5);
+}

package/src/controls/startCameraTouch.js

@@ -0,0 +1,33 @@
+import { L } from '../globals/L.js';
+import { touchByContainer } from '../globals/touchByContainer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+import { mapStopPitchBearingAnimation } from '../camera/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 (!cameraByMap.get(map).touchRotate.enabled() && !cameraByMap.get(map).touchPitch.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/addImageState.js

@@ -0,0 +1,8 @@
+import { imageStates } from '../globals/imageStates.js';
+
+
+export function addImageState(image, state) {
+  let states = imageStates.get(image);
+  if (!states) imageStates.set(image, states = /* alloc */ new Set());
+  states.add(state);
+}

package/src/core/addRasterImage.js

@@ -0,0 +1,12 @@
+import { pendingRasterLoads } from '../globals/pendingRasterLoads.js';
+
+
+import { fireRasterLoad } from './fireRasterLoad.js';
+
+export function addRasterImage() {
+  if (!this._image) this._initImage();
+  if (this._image.complete && this._image.naturalWidth) {
+    pendingRasterLoads.push(this);
+    queueMicrotask(fireRasterLoad);
+  }
+}

package/src/core/adjustCameraMarkerPan.js

@@ -0,0 +1,28 @@
+import { L } from '../globals/L.js';
+import { dragByHandler } from '../globals/dragByHandler.js';
+
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+import { pointOf } from '../camera/pointOf.js';
+import { scheduleMarkerPan } from './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/beforeNativeRender.js

@@ -0,0 +1,10 @@
+import { synchronizeNativeLayer } from './synchronizeNativeLayer.js';
+
+export function beforeNativeRender(state) {
+  try {
+    synchronizeNativeLayer(state);
+  } catch (error) {
+    state.failed = true;
+    state.source.fire('error', /* alloc */ { error });
+  }
+}

package/src/core/boundsQuad.js

@@ -0,0 +1,12 @@
+import { localPosition } from './localPosition.js';
+
+export function boundsQuad(state, bounds) {
+  const positions = /* alloc */ [];
+  let i, corner;
+  for (i = 0; i < 4; i++) {
+    corner = i === 0 ? bounds.getNorthWest() : i === 1 ? bounds.getNorthEast()
+      : i === 2 ? bounds.getSouthWest() : bounds.getSouthEast();
+    positions.push(localPosition(state, corner));
+  }
+  return positions;
+}

package/src/core/bringNativeLayerToBack.js

@@ -0,0 +1,8 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+import { reorderNativeLayer } from './reorderNativeLayer.js';
+
+export function bringNativeLayerToBack(layer = this) {
+  const native = sceneByLayer.get(layer)?._nativeGPU;
+  if (native?.backend && !native.disposed) reorderNativeLayer.call(native, false);
+}

package/src/core/bringNativeLayerToFront.js

@@ -0,0 +1,8 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+import { reorderNativeLayer } from './reorderNativeLayer.js';
+
+export function bringNativeLayerToFront(layer = this) {
+  const native = sceneByLayer.get(layer)?._nativeGPU;
+  if (native?.backend && !native.disposed) reorderNativeLayer.call(native, true);
+}

package/src/core/bypassNativeEvent.js

@@ -0,0 +1,11 @@
+import { updateNativeHover } from './updateNativeHover.js';
+
+export function bypassNativeEvent(map, context, event, type) {
+  const target = event.target;
+  const dom = target instanceof Element &&
+    target.closest('.leaflet-marker-icon,.leaflet-popup,.leaflet-tooltip,.leaflet-control');
+  if (dom && context.hovered && (type === context.move || type === context.out)) {
+    updateNativeHover(map, context, event, null);
+  }
+  return dom || type === context.move && (map.dragging?.moving() || map._animatingZoom);
+}

package/src/core/cameraCircleBounds.js

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

package/src/core/cameraMarkerDrag.js

@@ -0,0 +1,21 @@
+import { dragByHandler } from '../globals/dragByHandler.js';
+
+
+import { cameraMarkerOnDrag } from './cameraMarkerOnDrag.js';
+import { adjustCameraMarkerPan } from './adjustCameraMarkerPan.js';
+
+export function cameraMarkerDrag() {
+  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

@@ -0,0 +1,13 @@
+import { L } from '../globals/L.js';
+import { dragByHandler } from '../globals/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);
+  dragByHandler.get(this)._cameraOriginalOnDrag.call(this, event);
+  this._marker._setPos(point);
+}

package/src/core/cancelGridFade.js

@@ -0,0 +1,14 @@
+import { pendingGridFades } from '../globals/pendingGridFades.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { gridFadeFrame } from '../globals/gridFadeFrame.js';
+
+
+
+export function cancelGridFade(layer) {
+  pendingGridFades.delete(layer);
+  sceneByLayer.get(layer)._fadeFrame = null;
+  if (!pendingGridFades.size && gridFadeFrame.value !== null) {
+    cancelAnimationFrame(gridFadeFrame.value);
+    gridFadeFrame.value = null;
+  }
+}

package/src/core/closestCameraLayerPoint.js

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

package/src/core/compareNativeHits.js

@@ -0,0 +1,3 @@
+export function compareNativeHits(a, b) {
+  return b.object.renderOrder - a.object.renderOrder || a.distance - b.distance;
+}

package/src/core/current.js

@@ -0,0 +1,6 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+export function current(state) {
+  return sceneByLayer.get(state.source)._nativeGPU === state && state.map.hasLayer(state.source);
+}

package/src/core/disposeNativeLayer.js

@@ -0,0 +1,39 @@
+import { nativeRenderByLayer } from '../globals/nativeRenderByLayer.js';
+
+
+import { refreshNativeEvent } from './refreshNativeEvent.js';
+import { updateNativeLayerView } from './updateNativeLayerView.js';
+import { removeNativeEvents } from './removeNativeEvents.js';
+import { disposeMesh } from '../rendering/disposeMesh.js';
+import { destroyTexture } from '../rendering/destroyTexture.js';
+import { nativeImageRefresh } from './nativeImageRefresh.js';
+import { nativeImageError } from './nativeImageError.js';
+import { removeImageState } from './removeImageState.js';
+
+export function disposeNativeLayer() {
+  const state = this;
+  if (state.disposed) return;
+  state.disposed = true;
+  const { source, map, backend, meshes, textures, images } = state;
+  const events = 'load tileload tileunload move drag';
+  source.off(events, refreshNativeEvent, state);
+  map.off('zoomend', refreshNativeEvent, state);
+  if (state.marker) map.off('move zoom rotate pitch resize viewreset', updateNativeLayerView, state);
+  removeNativeEvents(state);
+  let name, methods, mesh, texture, image;
+  for ([name, methods] of state.methods) {
+    if (methods.own) Object.defineProperty(source, name, methods.own);
+    else delete source[name];
+  }
+  for (mesh of meshes.values()) disposeMesh(backend, mesh);
+  meshes.clear();
+  for (texture of textures.values()) destroyTexture(backend, texture.texture);
+  textures.clear();
+  for (image of images) {
+    image.removeEventListener('load', nativeImageRefresh);
+    image.removeEventListener('error', nativeImageError);
+    removeImageState(image, state);
+  }
+  nativeRenderByLayer.delete(backend);
+  backend.remove();
+}

package/src/core/fireRasterLoad.js

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

package/src/core/forwardNativeError.js

@@ -0,0 +1,3 @@
+export function forwardNativeError({ error }) {
+  this.source.fire('error', /* alloc */ { error });
+}

package/src/core/gridlayerGetEvents.js

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