leaflet-city-mapper 0.0.2 → 0.0.4

package/src/core/gridlayerGetTiledPixelBounds.js

@@ -0,0 +1,12 @@
+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 (!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/handleNativeMapEvent.js

@@ -0,0 +1,27 @@
+import { nativeEventMaps } from '../globals/nativeEventMaps.js';
+import { renderers } from '../globals/renderers.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { coreEventTypes } from '../globals/coreEventTypes.js';
+
+
+
+import { nativeEventSource } from './nativeEventSource.js';
+import { updateNativeHover } from './updateNativeHover.js';
+import { bypassNativeEvent } from './bypassNativeEvent.js';
+
+export function handleNativeMapEvent(event, type = event.type, targets) {
+  const map = this, context = nativeEventMaps.get(map), fireDOMEvent = context.fireDOMEvent;
+  const owner = renderers.get(map);
+  if (!sceneByLayer.get(owner)?.renderer || targets || !coreEventTypes.has(type)) {
+    return fireDOMEvent.call(this, event, type, targets);
+  }
+  if (bypassNativeEvent(map, context, event, type)) {
+    return fireDOMEvent.call(this, event, type, targets);
+  }
+  let source = nativeEventSource(context, event, type);
+  if ((type === 'click' || type === 'preclick') && source && map._draggableMoved(source)) source = null;
+  if (type === context.move || type === context.out) {
+    updateNativeHover(map, context, event, source);
+  }
+  return fireDOMEvent.call(this, event, type, source ? /* alloc */ [source] : undefined);
+}

package/src/core/hideTargets.js

@@ -0,0 +1,18 @@
+import { L } from '../globals/L.js';
+export function hideTargets(state) {
+  const { source } = state;
+  const htmlIcon = source instanceof L.Marker && source.options.icon instanceof L.DivIcon;
+  const icon = htmlIcon ? null : source._icon, shadow = htmlIcon ? null : source._shadow;
+  let i, element;
+  for (element of state.hidden) {
+    if (element === icon || element === shadow) continue;
+    element.classList.remove('leaflet-webgpu-target');
+    state.hidden.delete(element);
+  }
+  for (i = 0; i < 2; i++) {
+    element = i ? shadow : icon;
+    if (!element || state.hidden.has(element)) continue;
+    element.classList.add('leaflet-webgpu-target');
+    state.hidden.add(element);
+  }
+}

package/src/core/initNativeGPU.js

@@ -0,0 +1,25 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+import { nativeLayer } from './nativeLayer.js';
+import { hideTargets } from './hideTargets.js';
+import { removeTargets } from './removeTargets.js';
+import { readyNativeGPU } from './readyNativeGPU.js';
+import { reportError } from '../scene/reportError.js';
+
+export function initNativeGPU(source, map) {
+  if (sceneByLayer.get(source)._nativeGPU) return;
+  if (!document.getElementById('leaflet-webgpu-targets')) {
+    const style = document.createElement('style');
+    style.id = 'leaflet-webgpu-targets';
+    style.textContent = '.leaflet-webgpu-target{opacity:0!important}';
+    document.head.append(style);
+  }
+  const state = sceneByLayer.get(source)._nativeGPU = /* alloc */ {
+    source, map, hidden: /* alloc */ new Set(),
+  };
+  hideTargets(state);
+  source.once('remove', removeTargets.bind(null, state));
+  sceneByLayer.get(source).ready = Promise.resolve().then(readyNativeGPU.bind(null, state));
+  sceneByLayer.get(source).ready.catch(reportError.bind(null, source));
+}

package/src/core/initializeGridContainer.js

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

package/src/core/initializeNativeLayer.js

@@ -0,0 +1,40 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { closestMethods } from '../globals/closestMethods.js';
+import { boundsMethods } from '../globals/boundsMethods.js';
+import { gridInitializers } from '../globals/gridInitializers.js';
+
+
+import { noOperation } from '../utils/noOperation.js';
+import { emptyEvents } from '../scene/emptyEvents.js';
+import { refreshNativeLayerContract } from './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 { redrawPath } from './redrawPath.js';
+
+export function initializeNativeLayer() {
+  if (this instanceof L.Polyline || this instanceof L.CircleMarker) {
+    this.beforeAdd = this._updateBounds = noOperation;
+    this.redraw = redrawPath;
+    sceneByLayer.get(this).kind = 'path';
+    if (this instanceof L.Polyline) {
+      closestMethods.set(this, this.closestLayerPoint);
+      this.closestLayerPoint = closestCameraLayerPoint;
+    }
+    if (this instanceof L.Circle) {
+      boundsMethods.set(this, this.getBounds);
+      this.getBounds = cameraCircleBounds;
+    }
+  } else if (this instanceof L.GridLayer) {
+    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)) {
+    sceneByLayer.get(this).kind = 'image';
+    this._reset = refreshNativeLayerContract;
+  }
+}

package/src/core/layerCallInitHooks.js

@@ -0,0 +1,14 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { layerCallInitHooks as sharedLayerCallInitHooks } from '../globals/layerCallInitHooks.js';
+
+
+import { initializeNativeLayer } from './initializeNativeLayer.js';
+
+export function layerCallInitHooks() {
+  if (!sceneByLayer.has(this)) {
+    sceneByLayer.set(this, /* alloc */ {});
+  }
+  const initialized = this._initHooksCalled;
+  sharedLayerCallInitHooks.value.call(this);
+  if (!initialized) initializeNativeLayer.call(this);
+}

package/src/core/localPixel.js

@@ -0,0 +1,5 @@
+import { localPosition } from './localPosition.js';
+
+export function localPixel(state, point) {
+  return localPosition(state, state.map.unproject(point));
+}

package/src/core/localPixelForGeometry.js

@@ -0,0 +1,7 @@
+import { geometryPixelStates } from '../globals/geometryPixelStates.js';
+
+import { localPixel } from './localPixel.js';
+
+export function localPixelForGeometry(point) {
+  return localPixel(geometryPixelStates[geometryPixelStates.length - 1], point);
+}

package/src/core/localPosition.js

@@ -0,0 +1,10 @@
+import { radians } from '../globals/radians.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+export function localPosition(state, latlng) {
+  const { map, backend } = state, crs = map.options.crs;
+  const origin = crs.project(sceneByLayer.get(backend).location), point = crs.project(latlng);
+  const metres = Math.cos(sceneByLayer.get(backend).location.lat * radians);
+  return /* alloc */ [(point.x - origin.x) * metres, 0, -(point.y - origin.y) * metres];
+}

package/src/core/markerCameraIconPoint.js

@@ -0,0 +1,12 @@
+import { L } from '../globals/L.js';
+import { radians } from '../globals/radians.js';
+
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+export function markerCameraIconPoint(marker, x, y) {
+  let rotation = marker.options.rotation + (marker.options.rotateWithView ? mapGetBearing(marker._map) * radians : 0);
+  if (marker.options.keepUpright && Math.cos(rotation) < 0) rotation += Math.PI;
+  const scale = marker.options.scale;
+  return /* alloc */ new L.Point((x * Math.cos(rotation) - y * Math.sin(rotation)) * scale,
+    (x * Math.sin(rotation) + y * Math.cos(rotation)) * scale);
+}

package/src/core/markerGetEvents.js

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

package/src/core/markerImageBounds.js

@@ -0,0 +1,11 @@
+export function markerImageBounds(state, key, image) {
+  const options = state.source.options.icon.options;
+  const dimensions = options[key === 'shadow' ? 'shadowSize' : 'iconSize'];
+  const bounds = state.markerImageBounds ||= /* alloc */ [0, 0, 0, 0];
+  bounds[0] = dimensions ? dimensions.x ?? dimensions[0] : image.naturalWidth;
+  bounds[1] = dimensions ? dimensions.y ?? dimensions[1] : image.naturalHeight;
+  const anchor = (key === 'shadow' && options.shadowAnchor) || options.iconAnchor;
+  bounds[2] = anchor ? anchor.x ?? anchor[0] : Math.floor(bounds[0] / 2);
+  bounds[3] = anchor ? anchor.y ?? anchor[1] : Math.floor(bounds[1] / 2);
+  return bounds;
+}

package/src/core/markerInitInteraction.js

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

package/src/core/markerQuadCorners.js

@@ -0,0 +1,48 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { coreMatrixKeys } from '../globals/coreMatrixKeys.js';
+import { markerCameraIconPoint } from './markerCameraIconPoint.js';
+
+import { localPosition } from './localPosition.js';
+
+import { transformNativePoint } from './transformNativePoint.js';
+import { markerImageBounds } from './markerImageBounds.js';
+
+export function markerQuadCorners(state, key, image) {
+  const { source, map, backend } = state;
+  const position = localPosition(state, source.getLatLng());
+  const size = map.getSize();
+  const matrices = state.markerMatrices ||= /* alloc */ {
+    root: /* alloc */ new DOMMatrix(),
+    camera: /* alloc */ new DOMMatrix(),
+    point: /* alloc */ { x: 0, y: 0, z: 0, w: 1 },
+  };
+  const root = matrices.root, camera = matrices.camera, point = matrices.point;
+  const worldMatrix = sceneByLayer.get(backend).root.worldMatrix, projection = sceneByLayer.get(backend).camera.projectionViewMatrix;
+  let i, keyName;
+  for (i = 0; i < 16; i++) {
+    keyName = coreMatrixKeys[i];
+    root[keyName] = worldMatrix[i];
+    camera[keyName] = projection[i];
+  }
+  transformNativePoint(point, root, position[0], position[1], position[2], 1);
+  transformNativePoint(point, camera, point.x, point.y, point.z, point.w);
+  const clipX = point.x, clipY = point.y, clipZ = point.z, clipW = point.w;
+  camera.invertSelf();
+  root.invertSelf();
+  const [width, height, anchorX, anchorY] = markerImageBounds(state, key, image);
+  const centerX = (clipX / clipW + 1) * size.x / 2, centerY = (1 - clipY / clipW) * size.y / 2;
+  const left = centerX - anchorX;
+  const top = centerY - anchorY;
+  const corners = /* alloc */ [];
+  let pointX, pointY, offset, x, y;
+  for (i = 0; i < 4; i++) {
+    pointX = left + (i % 2 ? width : 0);
+    pointY = top + (i < 2 ? 0 : height);
+    offset = markerCameraIconPoint(source, pointX - centerX, pointY - centerY);
+    x = centerX + offset.x, y = centerY + offset.y;
+    transformNativePoint(point, camera, x / size.x * 2 - 1, 1 - y / size.y * 2, clipZ / clipW, 1);
+    transformNativePoint(point, root, point.x / point.w, point.y / point.w, point.z / point.w, 1);
+    corners.push(/* alloc */ [point.x, point.y, point.z]);
+  }
+  return corners;
+}

package/src/core/markerSetIcon.js

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

package/src/core/markerSetPos.js

@@ -0,0 +1,19 @@
+import { markerMethods } from '../globals/markerMethods.js';
+
+import { markerCameraIconPoint } from './markerCameraIconPoint.js';
+
+import { displayPoint } from '../camera/displayPoint.js';
+
+export function markerSetPos(point) {
+  markerMethods.value._setPos.call(this, displayPoint(this._map, point));
+  let i, element, key, direction, options, anchor;
+  for (i = 0; i < 2; i++) {
+    element = i ? this._shadow : this._icon;
+    key = i ? 'shadowAnchor' : 'iconAnchor';
+    if (!element) continue;
+    direction = markerCameraIconPoint(this, 1, 0), options = this.options.icon.options;
+    anchor = options[key] || options.iconAnchor;
+    element.style.transformOrigin = anchor ? `${anchor.x ?? anchor[0]}px ${anchor.y ?? anchor[1]}px` : 'center';
+    element.style.transform += ` rotate(${Math.atan2(direction.y, direction.x)}rad) scale(${this.options.scale})`;
+  }
+}

package/src/core/markerSetRotation.js

@@ -0,0 +1,9 @@
+import { refreshNativeLayerContract } from './refreshNativeLayerContract.js';
+
+export function markerSetRotation(marker, rotation) {
+  if (!Number.isFinite(rotation)) throw /* alloc */ new TypeError('Marker rotation must be finite');
+  marker.options.rotation = rotation;
+  marker.update();
+  refreshNativeLayerContract(marker);
+  return marker;
+}

package/src/core/markerUpdateZIndex.js

@@ -0,0 +1,12 @@
+import { markerMethods } from '../globals/markerMethods.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
+
+export function markerUpdateZIndex(offset) {
+  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/nativeAddLatLng.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeAddLatLng(...args) { return nativeLayerMethod('addLatLng', this, args); }

package/src/core/nativeBringToBack.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeBringToBack(...args) { return nativeLayerMethod('bringToBack', this, args); }

package/src/core/nativeBringToFront.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeBringToFront(...args) { return nativeLayerMethod('bringToFront', this, args); }

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

@@ -0,0 +1,31 @@
+import { L } from '../globals/L.js';
+import { nativeEventMaps } from '../globals/nativeEventMaps.js';
+
+
+import { raycast } from '../picking/raycast.js';
+
+import { restoreNativeEvents } from './restoreNativeEvents.js';
+import { handleNativeMapEvent } from './handleNativeMapEvent.js';
+
+/** One GPU hit test per map event, rather than one invisible SVG path per feature. */
+export function nativeEvents(state) {
+  const { map } = state;
+  let context = nativeEventMaps.get(map);
+  if (!context) {
+    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';
+    context.over = pointer ? 'pointerover' : 'mouseover';
+    context.descriptor = Object.getOwnPropertyDescriptor(map, '_fireDOMEvent');
+    context.fireDOMEvent = map._fireDOMEvent;
+    context.handle = handleNativeMapEvent;
+    context.restore = restoreNativeEvents;
+    nativeEventMaps.set(map, context);
+    map._fireDOMEvent = handleNativeMapEvent;
+  }
+  context.states.add(state);
+  state._nativeEventContext = context;
+}

package/src/core/nativeImageError.js

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

package/src/core/nativeImageRefresh.js

@@ -0,0 +1,11 @@
+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 states) refreshNativeLayer(state);
+}

package/src/core/nativeLayer.js

@@ -0,0 +1,100 @@
+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';
+import { nativeGeometry } from '../geometry/nativeGeometry.js';
+import { nativeEvents } from './nativeEvents.js';
+import { removeNativeEvents } from './removeNativeEvents.js';
+import { parseColor } from '../utils/parseColor.js';
+import { update } from '../scene/update.js';
+
+import { current } from './current.js';
+import { refreshNativeLayer } from './refreshNativeLayer.js';
+import { refreshNativeEvent } from './refreshNativeEvent.js';
+import { reorderNativeLayer } from './reorderNativeLayer.js';
+import { nativeSetLatLng } from './nativeSetLatLng.js';
+import { nativeSetLatLngs } from './nativeSetLatLngs.js';
+import { nativeAddLatLng } from './nativeAddLatLng.js';
+import { nativeSetRadius } from './nativeSetRadius.js';
+import { nativeSetStyle } from './nativeSetStyle.js';
+import { nativeRedraw } from './nativeRedraw.js';
+import { nativeSetIcon } from './nativeSetIcon.js';
+import { nativeSetUrl } from './nativeSetUrl.js';
+import { nativeSetBounds } from './nativeSetBounds.js';
+import { nativeSetOpacity } from './nativeSetOpacity.js';
+import { nativeSetZIndex } from './nativeSetZIndex.js';
+import { nativeSetZIndexOffset } from './nativeSetZIndexOffset.js';
+import { nativeBringToFront } from './nativeBringToFront.js';
+import { nativeBringToBack } from './nativeBringToBack.js';
+import { disposeNativeLayer } from './disposeNativeLayer.js';
+import { resolveNativeReady } from './resolveNativeReady.js';
+import { rejectNativeReady } from './rejectNativeReady.js';
+import { forwardNativeError } from './forwardNativeError.js';
+import { updateNativeLayerView } from './updateNativeLayerView.js';
+import { synchronizeNativeLayer } from './synchronizeNativeLayer.js';
+import { beforeNativeRender } from './beforeNativeRender.js';
+
+/** 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 = 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 = ++cameraByMap.get(map)._nativeGPUOrder;
+  state.marker = source instanceof L.Marker;
+  state.paneOrder = Number(getComputedStyle(source.getPane()).zIndex) || 0;
+  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 in nativeMethodHandlers) {
+    if (typeof source[name] !== 'function') continue;
+    own = Object.getOwnPropertyDescriptor(source, name), original = source[name];
+    state.methods.set(name, /* alloc */ { own, original });
+    state.originalMethods.set(name, original);
+    source[name] = nativeMethodHandlers[name];
+  }
+  const ready = state.ready = Promise.withResolvers();
+  backend.once('ready', resolveNativeReady, state);
+  backend.once('error', rejectNativeReady, state);
+  backend.on('error', forwardNativeError, state);
+  refreshNativeLayer(state);
+  backend.addTo(map);
+  try {
+    await ready.promise;
+  } catch (error) {
+    disposeNativeLayer.call(state);
+    throw error;
+  }
+  if (!current(state)) return source;
+
+  nativeRenderByLayer.set(backend, state);
+  try {
+    synchronizeNativeLayer(state);
+  } catch (error) {
+    disposeNativeLayer.call(state);
+    throw error;
+  }
+  update(state.backend);
+  return source;
+}

package/src/core/nativeLayerMethod.js

@@ -0,0 +1,26 @@
+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 = 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) {
+    let extreme = name === 'bringToFront' ? -Infinity : Infinity;
+    for (layer of Object.values(state.map._layers)) {
+      if (layer === source || !(layer instanceof L.GridLayer) || layer.getPane() !== source.getPane()) continue;
+      zIndex = layer.options.zIndex || 0;
+      extreme = name === 'bringToFront' ? Math.max(extreme, zIndex) : Math.min(extreme, zIndex);
+    }
+    const edge = name === 'bringToFront' ? extreme + 1 : extreme - 1;
+    if (Number.isFinite(edge)) source.setZIndex(edge);
+  }
+  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/nativeRedraw.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeRedraw(...args) { return nativeLayerMethod('redraw', this, args); }

package/src/core/nativeSetBounds.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeSetBounds(...args) { return nativeLayerMethod('setBounds', this, args); }

package/src/core/nativeSetIcon.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeSetIcon(...args) { return nativeLayerMethod('setIcon', this, args); }

package/src/core/nativeSetLatLng.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeSetLatLng(...args) { return nativeLayerMethod('setLatLng', this, args); }

package/src/core/nativeSetLatLngs.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeSetLatLngs(...args) { return nativeLayerMethod('setLatLngs', this, args); }

package/src/core/nativeSetOpacity.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeSetOpacity(...args) { return nativeLayerMethod('setOpacity', this, args); }

package/src/core/nativeSetRadius.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeSetRadius(...args) { return nativeLayerMethod('setRadius', this, args); }

package/src/core/nativeSetStyle.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeSetStyle(...args) { return nativeLayerMethod('setStyle', this, args); }

package/src/core/nativeSetUrl.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeSetUrl(...args) { return nativeLayerMethod('setUrl', this, args); }

package/src/core/nativeSetZIndex.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeSetZIndex(...args) { return nativeLayerMethod('setZIndex', this, args); }

package/src/core/nativeSetZIndexOffset.js

@@ -0,0 +1,3 @@
+import { nativeLayerMethod } from './nativeLayerMethod.js';
+
+export function nativeSetZIndexOffset(...args) { return nativeLayerMethod('setZIndexOffset', this, args); }