leaflet-city-mapper 0.0.3 → 0.0.4

package/src/core/markerUpdateZIndex.js

@@ -1,8 +1,12 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { markerMethods } from '../globals/markerMethods.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 
 export function markerUpdateZIndex(offset) {
-  mapCameraState.markerMethods._updateZIndex.call(this, offset);
-  const changed = this._cameraZIndexOffset !== offset;
-  this._cameraZIndexOffset = offset;
-  if (changed) this._nativeGPU?.refresh?.();
+  markerMethods.value._updateZIndex.call(this, offset);
+  const changed = sceneByLayer.get(this)._cameraZIndexOffset !== offset;
+  sceneByLayer.get(this)._cameraZIndexOffset = offset;
+  if (changed) refreshNativeLayerContract(this);
 }
+import { refreshNativeLayerContract } from './refreshNativeLayerContract.js';

package/src/core/nativeEventSource.js

@@ -0,0 +1,18 @@
+import { L } from '../globals/L.js';
+import { raycast } from '../picking/raycast.js';
+import { compareNativeHits } from './compareNativeHits.js';
+
+export function nativeEventSource(context, event, type) {
+  const hits = /* alloc */ [];
+  let candidate, source, backend;
+  if (type !== context.out) {
+    for (candidate of context.states) {
+      ({ source, backend } = candidate);
+      if (source instanceof L.Marker || source.options.interactive === false ||
+        !(source instanceof L.Path) && !source.options.interactive) continue;
+      hits.push(...raycast(backend, event, candidate.meshes.values(), false));
+    }
+  }
+  hits.sort(compareNativeHits);
+  return hits[0]?.object._nativeSource || null;
+}

package/src/core/nativeEvents.js

@@ -1,6 +1,9 @@
-import { cityMapper } from '../constants/cityMapper.js';
+import { L } from '../globals/L.js';
+import { nativeEventMaps } from '../globals/nativeEventMaps.js';
+
+
 import { raycast } from '../picking/raycast.js';
-import { nativeEventMaps } from '../constants/nativeEventMaps.js';
+
 import { restoreNativeEvents } from './restoreNativeEvents.js';
 import { handleNativeMapEvent } from './handleNativeMapEvent.js';
 
@@ -9,7 +12,9 @@ export function nativeEvents(state) {
   const { map } = state;
   let context = nativeEventMaps.get(map);
   if (!context) {
-    context = { map, states: new Set(), hovered: null };
+    context = /* alloc */ {
+      map, states: /* alloc */ new Set(), hovered: null,
+    };
     const pointer = L.version.startsWith('2');
     context.move = pointer ? 'pointermove' : 'mousemove';
     context.out = pointer ? 'pointerout' : 'mouseout';

package/src/core/nativeImageError.js

@@ -1,8 +1,13 @@
-import { nativeLayerState } from '../constants/nativeLayerState.js';
+import { imageStates } from '../globals/imageStates.js';
+
 
 export function nativeImageError(event) {
+  const states = imageStates.get(event.currentTarget);
+  if (!states) return;
   let state;
-  for (state of nativeLayerState.imageStates.get(event.currentTarget) || []) {
-    state.source.fire('error', { error: new Error('Unable to load native layer image') });
+  for (state of states) {
+    state.source.fire('error', /* alloc */ {
+      error: /* alloc */ new Error('Unable to load native layer image'),
+    });
   }
 }

package/src/core/nativeImageRefresh.js

@@ -1,7 +1,11 @@
-import { nativeLayerState } from '../constants/nativeLayerState.js';
+import { imageStates } from '../globals/imageStates.js';
+
+
 import { refreshNativeLayer } from './refreshNativeLayer.js';
 
 export function nativeImageRefresh(event) {
+  const states = imageStates.get(event.currentTarget);
+  if (!states) return;
   let state;
-  for (state of nativeLayerState.imageStates.get(event.currentTarget) || []) refreshNativeLayer(state);
+  for (state of states) refreshNativeLayer(state);
 }

package/src/core/nativeLayer.js

@@ -1,4 +1,11 @@
-import { nativeMethodHandlers } from '../constants/nativeMethodHandlers.js';
+import { L } from '../globals/L.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { nativeMethodHandlers } from '../globals/nativeMethodHandlers.js';
+import { nativeRenderByLayer } from '../globals/nativeRenderByLayer.js';
+
+import { createLayer } from '../scene/createLayer.js';
+
+
 import { createMesh } from '../rendering/createMesh.js';
 import { destroyTexture } from '../rendering/destroyTexture.js';
 import { disposeMesh } from '../rendering/disposeMesh.js';
@@ -7,7 +14,7 @@ import { nativeEvents } from './nativeEvents.js';
 import { removeNativeEvents } from './removeNativeEvents.js';
 import { parseColor } from '../utils/parseColor.js';
 import { update } from '../scene/update.js';
-import { nativeLayerState } from '../constants/nativeLayerState.js';
+
 import { current } from './current.js';
 import { refreshNativeLayer } from './refreshNativeLayer.js';
 import { refreshNativeEvent } from './refreshNativeEvent.js';
@@ -34,40 +41,36 @@ import { updateNativeLayerView } from './updateNativeLayerView.js';
 import { synchronizeNativeLayer } from './synchronizeNativeLayer.js';
 import { beforeNativeRender } from './beforeNativeRender.js';
 
-nativeLayerState.imageStates = new WeakMap();
-nativeLayerState.geometryPixelStates = [];
-
 /** Render from coordinates and detached raster sources; only accessible marker controls remain DOM. */
 export async function nativeLayer(state) {
   const { source, map } = state;
-  const backend = state.backend = new L.Layer({ source: { type: '3d' } });
-  state.meshes = new Map();
-  state.textures = new Map();
-  state.methods = new Map();
-  state.originalMethods = new Map();
-  state.images = new Set();
-  map._nativeGPUOrder ||= 0;
-  map._nativeGPUBack ||= 0;
+  const backend = state.backend = createLayer(/* alloc */ {
+    source: /* alloc */ { type: '3d' },
+  });
+  state.meshes = /* alloc */ new Map();
+  state.textures = /* alloc */ new Map();
+  state.methods = /* alloc */ new Map();
+  state.originalMethods = /* alloc */ new Map();
+  state.images = /* alloc */ new Set();
+  cameraByMap.get(map)._nativeGPUOrder ||= 0;
+  cameraByMap.get(map)._nativeGPUBack ||= 0;
   state.dirty = true;
   state.viewDirty = true;
   state.failed = false;
-  state.order = ++map._nativeGPUOrder;
+  state.order = ++cameraByMap.get(map)._nativeGPUOrder;
   state.marker = source instanceof L.Marker;
   state.paneOrder = Number(getComputedStyle(source.getPane()).zIndex) || 0;
-  state.refresh = refreshNativeLayer;
-  state.reorder = reorderNativeLayer;
-  state.dispose = disposeNativeLayer;
+  state.disposed = false;
   const currentEvents = 'load tileload tileunload move drag';
   source.on(currentEvents, refreshNativeEvent, state);
   map.on('zoomend', refreshNativeEvent, state);
   if (state.marker) map.on('move zoom rotate pitch resize viewreset', updateNativeLayerView, state);
   nativeEvents(state);
   let name, own, original;
-  for (name of ['setLatLng', 'setLatLngs', 'addLatLng', 'setRadius', 'setStyle', 'redraw',
-    'setIcon', 'setUrl', 'setBounds', 'setOpacity', 'setZIndex', 'setZIndexOffset', 'bringToFront', 'bringToBack']) {
+  for (name in nativeMethodHandlers) {
     if (typeof source[name] !== 'function') continue;
     own = Object.getOwnPropertyDescriptor(source, name), original = source[name];
-    state.methods.set(name, { own, original });
+    state.methods.set(name, /* alloc */ { own, original });
     state.originalMethods.set(name, original);
     source[name] = nativeMethodHandlers[name];
   }
@@ -85,7 +88,7 @@ export async function nativeLayer(state) {
   }
   if (!current(state)) return source;
 
-  backend._beforeRender = beforeNativeRender.bind(null, state);
+  nativeRenderByLayer.set(backend, state);
   try {
     synchronizeNativeLayer(state);
   } catch (error) {

package/src/core/nativeLayerMethod.js

@@ -1,7 +1,12 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
 import { refreshNativeLayer } from './refreshNativeLayer.js';
 
 export function nativeLayerMethod(name, source, args) {
-  const state = source._nativeGPU, original = state.originalMethods.get(name);
+  const state = sceneByLayer.get(source)._nativeGPU, original = state.originalMethods.get(name);
   const result = original.apply(source, args);
   let layer, zIndex;
   if ((name === 'bringToFront' || name === 'bringToBack') && source instanceof L.GridLayer) {
@@ -14,8 +19,8 @@ export function nativeLayerMethod(name, source, args) {
     const edge = name === 'bringToFront' ? extreme + 1 : extreme - 1;
     if (Number.isFinite(edge)) source.setZIndex(edge);
   }
-  if (name === 'bringToFront') state.order = ++state.map._nativeGPUOrder;
-  if (name === 'bringToBack') state.order = --state.map._nativeGPUBack;
+  if (name === 'bringToFront') state.order = ++cameraByMap.get(state.map)._nativeGPUOrder;
+  if (name === 'bringToBack') state.order = --cameraByMap.get(state.map)._nativeGPUBack;
   refreshNativeLayer(state);
   return result;
 }

package/src/core/popupAdjustPan.js

@@ -1,23 +1,29 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { popupPan } from '../globals/popupPan.js';
+
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
 import { pointOf } from '../camera/pointOf.js';
 
 export function popupAdjustPan() {
-  const map = this._map;
-  if (!map.getPitch() && !map.getBearing()) return mapCameraState.popupPan.call(this);
-  if (!this.options.autoPan) return;
-  if (map._panAnim) map._panAnim.stop();
-  if (this._autopanning) { this._autopanning = false; return; }
-  const rect = this._container.getBoundingClientRect(), container = map.getContainer().getBoundingClientRect();
-  const min = pointOf(this.options.autoPanPaddingTopLeft || this.options.autoPanPadding);
-  const max = map.getSize().subtract(pointOf(this.options.autoPanPaddingBottomRight || this.options.autoPanPadding));
-  const left = rect.left - container.left, top = rect.top - container.top;
-  const right = rect.right - container.left, bottom = rect.bottom - container.top;
-  const dx = Math.min(0, left - min.x) || Math.max(0, right - max.x);
-  const dy = Math.min(0, top - min.y) || Math.max(0, bottom - max.y);
-  if (!dx && !dy) return;
-  if (this.options.keepInView) this._autopanning = true;
-  const screen = map.latLngToContainerPoint(this._latlng).subtract(new L.Point(dx, dy));
-  const delta = map.latLngToLayerPoint(this._latlng).subtract(map.containerPointToLayerPoint(screen));
-  map.fire('autopanstart');
+  const map = this._map;
+  if (!mapGetPitch(map) && !mapGetBearing(map)) return popupPan.value.call(this);
+  if (!this.options.autoPan) return;
+  if (map._panAnim) map._panAnim.stop();
+  if (this._autopanning) { this._autopanning = false; return; }
+  const rect = this._container.getBoundingClientRect(), container = map.getContainer().getBoundingClientRect();
+  const min = pointOf(this.options.autoPanPaddingTopLeft || this.options.autoPanPadding);
+  const max = map.getSize().subtract(pointOf(this.options.autoPanPaddingBottomRight || this.options.autoPanPadding));
+  const left = rect.left - container.left, top = rect.top - container.top;
+  const right = rect.right - container.left, bottom = rect.bottom - container.top;
+  const dx = Math.min(0, left - min.x) || Math.max(0, right - max.x);
+  const dy = Math.min(0, top - min.y) || Math.max(0, bottom - max.y);
+  if (!dx && !dy) return;
+  if (this.options.keepInView) this._autopanning = true;
+  const screen = map.latLngToContainerPoint(this._latlng);
+  screen.x -= dx;
+  screen.y -= dy;
+  const delta = map.latLngToLayerPoint(this._latlng).subtract(map.containerPointToLayerPoint(screen));
+  map.fire('autopanstart');
   map.panTo(map.unproject(map.project(map.getCenter()).add(delta)));
 }

package/src/core/popupGetEvents.js

@@ -1,5 +1,8 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { popupEvents } from '../globals/popupEvents.js';
+
 
 export function popupGetEvents() {
-  return { ...mapCameraState.popupEvents.call(this), rotate: this._updatePosition, pitch: this._updatePosition, move: this._updatePosition };
+  const events = popupEvents.value.call(this);
+  events.rotate = events.pitch = events.move = this._updatePosition;
+  return events;
 }

package/src/core/popupUpdatePosition.js

@@ -1,8 +1,11 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { L } from '../globals/L.js';
+import { popupPosition } from '../globals/popupPosition.js';
+
+
 import { displayPoint } from '../camera/displayPoint.js';
 
 export function popupUpdatePosition() {
-  mapCameraState.popupPosition.call(this);
+  popupPosition.value.call(this);
   if (!this._map) return;
   const point = this._map.latLngToLayerPoint(this._latlng), delta = displayPoint(this._map, point).subtract(point);
   if (this._zoomAnimated) {

package/src/core/pruneNativeResources.js

@@ -0,0 +1,20 @@
+import { disposeMesh } from '../rendering/disposeMesh.js';
+import { destroyTexture } from '../rendering/destroyTexture.js';
+
+export function pruneNativeResources(state) {
+  const { meshes, textures, backend } = state;
+  let mesh, texture, key;
+  for ([key, mesh] of meshes) {
+    if (mesh._nativeUsed) continue;
+    disposeMesh(backend, mesh);
+    meshes.delete(key);
+    texture = textures.get(key);
+    if (texture) destroyTexture(backend, texture.texture);
+    textures.delete(key);
+  }
+  for ([key, texture] of textures) {
+    if (texture.used) continue;
+    destroyTexture(backend, texture.texture);
+    textures.delete(key);
+  }
+}

package/src/core/putNativeMesh.js

@@ -1,3 +1,4 @@
+import { L } from '../globals/L.js';
 import { disposeMesh } from '../rendering/disposeMesh.js';
 import { createMesh } from '../rendering/createMesh.js';
 import { styleNativeMesh } from './styleNativeMesh.js';
@@ -6,17 +7,19 @@ export function putNativeMesh(state, key, position, color, opacity, texture, uv)
   const { backend, source, meshes } = state;
   if (!position.length) return;
   let mesh = meshes.get(key);
-  const normal = [];
-  let index;
-  for (index = 0; index < position.length; index++) normal.push(index % 3 === 1 ? 1 : 0);
-  const data = { position, normal, ...(uv ? { uv } : {}) };
   if (!mesh || mesh.geometry.attributes.position.data.length !== position.length ||
     mesh.program.uniforms.baseTexture?.value !== texture) {
-    if (mesh) disposeMesh(backend, mesh);
-    mesh = createMesh(backend, data, {
+    const normal = /* alloc */ [];
+    let index;
+    for (index = 0; index < position.length; index++) normal.push(index % 3 === 1 ? 1 : 0);
+    const data = /* alloc */ { position, normal };
+    if (uv) data.uv = uv;
+    const material = /* alloc */ {
       vertexColors: false, color, opacity, unlit: true, alphaMode: 'BLEND',
-      ...(texture ? { baseTexture: texture } : {}),
-    }, 0, source instanceof L.GridLayer ? state.rasterProgram : undefined);
+    };
+    if (texture) material.baseTexture = texture;
+    if (mesh) disposeMesh(backend, mesh);
+    mesh = createMesh(backend, data, material, 0, source instanceof L.GridLayer ? state.rasterProgram : undefined);
     if (source instanceof L.GridLayer) {
       state.rasterProgram ||= mesh.program;
       mesh.texture = texture;

package/src/core/quadNativeMesh.js

@@ -1,15 +1,20 @@
+import { coreQuadIndices } from '../globals/coreQuadIndices.js';
+import { coreQuadUV } from '../globals/coreQuadUV.js';
+import { coreWhite } from '../globals/coreWhite.js';
 import { textureFor } from './textureFor.js';
 import { putNativeMesh } from './putNativeMesh.js';
 
+
 export function quadNativeMesh(state, key, image, corners, opacity) {
   const texture = textureFor(state, key, image);
   if (!texture) return;
-  const indices = [0, 2, 1, 1, 2, 3];
-  const position = [], uv = [], textureCoords = [[0, 0], [1, 0], [0, 1], [1, 1]];
+  const indices = coreQuadIndices;
+  const position = /* alloc */ [];
+  const uv = /* alloc */ [];
   let index;
   for (index of indices) {
     position.push(...corners[index]);
-    uv.push(...textureCoords[index]);
+    uv.push(coreQuadUV[index * 2], coreQuadUV[index * 2 + 1]);
   }
-  return putNativeMesh(state, key, position, [1, 1, 1], opacity, texture, uv);
+  return putNativeMesh(state, key, position, coreWhite, opacity, texture, uv);
 }

package/src/core/readyNativeGPU.js

@@ -1,6 +1,9 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { nativeLayer } from './nativeLayer.js';
 
 export function readyNativeGPU(state) {
-  if (state.source._nativeGPU !== state) return state.source;
+  if (sceneByLayer.get(state.source)._nativeGPU !== state) return state.source;
   return nativeLayer(state);
 }

package/src/core/redrawPath.js

@@ -0,0 +1,6 @@
+import { refreshNativeLayerContract } from './refreshNativeLayerContract.js';
+
+export function redrawPath() {
+  refreshNativeLayerContract(this);
+  return this;
+}

package/src/core/refreshNativeLayer.js

@@ -1,29 +1,34 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { nativeImageRefresh } from './nativeImageRefresh.js';
 import { nativeImageError } from './nativeImageError.js';
 import { removeImageState } from './removeImageState.js';
 import { addImageState } from './addImageState.js';
 import { update } from '../scene/update.js';
+import { hideTargets } from './hideTargets.js';
 
 export function refreshNativeLayer(state = this) {
   state.dirty = true;
   state.viewDirty = true;
   state.failed = false;
-  state.hide();
-  const activeImages = [state.source._icon, state.source._shadow, state.source._image];
-  let image;
+  hideTargets(state);
+  const source = state.source;
+  let i, image;
   for (image of state.images) {
-    if (activeImages.includes(image)) continue;
+    if (image === source._icon || image === source._shadow || image === source._image) continue;
     image.removeEventListener('load', nativeImageRefresh);
     image.removeEventListener('error', nativeImageError);
     removeImageState(image, state);
     state.images.delete(image);
   }
-  for (image of activeImages) {
+  for (i = 0; i < 3; i++) {
+    image = i === 0 ? source._icon : i === 1 ? source._shadow : source._image;
     if (!(image instanceof HTMLImageElement) || state.images.has(image)) continue;
     state.images.add(image);
     addImageState(image, state);
     image.addEventListener('load', nativeImageRefresh);
     image.addEventListener('error', nativeImageError);
   }
-  if (state.backend._shared) update(state.backend);
+  if (sceneByLayer.get(state.backend)._shared) update(state.backend);
 }

package/src/core/refreshNativeLayerContract.js

@@ -1,3 +1,8 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+import { refreshNativeLayer } from './refreshNativeLayer.js';
+
 export function refreshNativeLayerContract(layer = this) {
-  layer?._nativeGPU?.refresh?.();
+  const native = sceneByLayer.get(layer)?._nativeGPU;
+  if (native?.backend && !native.disposed) refreshNativeLayer(native);
 }

package/src/core/rejectNativeReady.js

@@ -1,3 +1,4 @@
+
 export function rejectNativeReady({ error }) {
   this.ready.reject(error);
 }

package/src/core/removeImageState.js

@@ -1,8 +1,9 @@
-import { nativeLayerState } from '../constants/nativeLayerState.js';
+import { imageStates } from '../globals/imageStates.js';
+
 
 export function removeImageState(image, state) {
-  const states = nativeLayerState.imageStates.get(image);
+  const states = imageStates.get(image);
   if (!states) return;
   states.delete(state);
-  if (!states.size) nativeLayerState.imageStates.delete(image);
+  if (!states.size) imageStates.delete(image);
 }

package/src/core/removeLayer.js

@@ -0,0 +1,22 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { removeLayer as sharedRemoveLayer } from '../globals/removeLayer.js';
+
+import { removeSceneLayer } from '../scene/removeSceneLayer.js';
+
+
+
+export function removeLayer(layer) {
+  const id = L.Util.stamp(layer);
+  if (!this._layers[id]) return this;
+  const state = sceneByLayer.get(layer);
+  if (!state.kind) return sharedRemoveLayer.value.call(this, layer);
+  if (this._loaded) removeSceneLayer(layer, this);
+  delete this._layers[id];
+  if (this._loaded) {
+    this.fire('layerremove', /* alloc */ { layer });
+    layer.fire('remove');
+  }
+  layer._map = layer._mapToAdd = null;
+  return this;
+}

package/src/core/removeNativeEvents.js

@@ -1,4 +1,5 @@
-import { nativeEventMaps } from '../constants/nativeEventMaps.js';
+import { nativeEventMaps } from '../globals/nativeEventMaps.js';
+
 
 export function removeNativeEvents(state) {
   const context = state._nativeEventContext;

package/src/core/removeTargets.js

@@ -1,6 +1,10 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+import { disposeNativeLayer } from './disposeNativeLayer.js';
+
 export function removeTargets(state) {
-  if (state.source._nativeGPU === state) state.source._nativeGPU = null;
-  state.dispose?.();
+  if (sceneByLayer.get(state.source)._nativeGPU === state) sceneByLayer.get(state.source)._nativeGPU = null;
+  if (state.backend) disposeNativeLayer.call(state);
   let element;
   for (element of state.hidden) {
     element.classList.remove('leaflet-webgpu-target');

package/src/core/reorderNativeLayer.js

@@ -1,6 +1,9 @@
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
 import { refreshNativeLayer } from './refreshNativeLayer.js';
 
 export function reorderNativeLayer(front) {
-  this.order = front ? ++this.map._nativeGPUOrder : --this.map._nativeGPUBack;
+  this.order = front ? ++cameraByMap.get(this.map)._nativeGPUOrder : --cameraByMap.get(this.map)._nativeGPUBack;
   refreshNativeLayer(this);
 }

package/src/core/resolveNativeReady.js

@@ -1,3 +1,4 @@
+
 export function resolveNativeReady() {
   this.ready.resolve();
 }

package/src/core/runGridFades.js

@@ -1,14 +1,19 @@
-import { indexState } from '../constants/indexState.js';
+import { gridFadeFrame } from '../globals/gridFadeFrame.js';
+import { pendingGridFades } from '../globals/pendingGridFades.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+
 import { updateGridOpacity } from './updateGridOpacity.js';
 
 export function runGridFades() {
-  indexState.gridFadeFrame = null;
-  const layers = [...indexState.pendingGridFades];
+  gridFadeFrame.value = null;
+  const layers = /* alloc */ [...pendingGridFades];
   let layer, version;
   for ([layer, version] of layers) {
-    if (indexState.pendingGridFades.get(layer) !== version) continue;
-    indexState.pendingGridFades.delete(layer);
-    layer._fadeFrame = null;
+    if (pendingGridFades.get(layer) !== version) continue;
+    pendingGridFades.delete(layer);
+    sceneByLayer.get(layer)._fadeFrame = null;
     updateGridOpacity.call(layer);
   }
 }

package/src/core/runMarkerPanFrame.js

@@ -1,9 +1,11 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { markerPanFrame } from '../globals/markerPanFrame.js';
+import { pendingMarkerPan } from '../globals/pendingMarkerPan.js';
+
 
 export function runMarkerPanFrame() {
-  mapCameraState.markerPanFrame = null;
-  const pending = [...mapCameraState.pendingMarkerPan];
-  mapCameraState.pendingMarkerPan.clear();
+  markerPanFrame.value = null;
+  const pending = /* alloc */ [...pendingMarkerPan];
+  pendingMarkerPan.clear();
   let drag, event;
   for ([drag, event] of pending) {
     drag._panRequest = null;

package/src/core/scheduleGridFade.js

@@ -1,9 +1,14 @@
-import { indexState } from '../constants/indexState.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { pendingGridFades } from '../globals/pendingGridFades.js';
+import { gridFadeFrame } from '../globals/gridFadeFrame.js';
+
+
+
 import { runGridFades } from './runGridFades.js';
 
 export function scheduleGridFade(layer) {
-  layer._fadeVersion = (layer._fadeVersion || 0) + 1;
-  indexState.pendingGridFades.set(layer, layer._fadeVersion);
-  if (indexState.gridFadeFrame === null) indexState.gridFadeFrame = requestAnimationFrame(runGridFades);
-  layer._fadeFrame = indexState.gridFadeFrame;
+  sceneByLayer.get(layer)._fadeVersion = (sceneByLayer.get(layer)._fadeVersion || 0) + 1;
+  pendingGridFades.set(layer, sceneByLayer.get(layer)._fadeVersion);
+  if (gridFadeFrame.value === null) gridFadeFrame.value = requestAnimationFrame(runGridFades);
+  sceneByLayer.get(layer)._fadeFrame = gridFadeFrame.value;
 }

package/src/core/scheduleMarkerPan.js

@@ -1,8 +1,11 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { pendingMarkerPan } from '../globals/pendingMarkerPan.js';
+import { markerPanFrame } from '../globals/markerPanFrame.js';
+
+
 import { runMarkerPanFrame } from './runMarkerPanFrame.js';
 
 export function scheduleMarkerPan(drag, event) {
-  mapCameraState.pendingMarkerPan.set(drag, event);
-  if (mapCameraState.markerPanFrame === null) mapCameraState.markerPanFrame = requestAnimationFrame(runMarkerPanFrame);
-  drag._panRequest = mapCameraState.markerPanFrame;
+  pendingMarkerPan.set(drag, event);
+  if (markerPanFrame.value === null) markerPanFrame.value = requestAnimationFrame(runMarkerPanFrame);
+  drag._panRequest = markerPanFrame.value;
 }

package/src/core/setRotation.js

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

package/src/core/styleNativeMesh.js

@@ -1,9 +1,13 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 export function styleNativeMesh(state, mesh, color, opacity) {
   const { source, marker, paneOrder, order } = state;
   mesh.program.uniforms.baseColor.value = color;
   mesh.program.uniforms.opacity.value = opacity;
   if (source instanceof L.GridLayer) mesh.opacity = opacity;
-  const zIndex = marker ? source._zIndex + (source._cameraZIndexOffset || 0) : source.options.zIndex;
+  const zIndex = marker ? source._zIndex + (sceneByLayer.get(source)._cameraZIndexOffset || 0) : source.options.zIndex;
   mesh.renderOrder = paneOrder * 1e6 + (zIndex || 0) * 1000 + order;
   mesh._nativeSource = source;
   mesh._nativeUsed = true;