leaflet-city-mapper 0.1.0 → 0.1.1

package/src/native/createNativeMesh.js

@@ -1,46 +1,46 @@
-import { L } from '../globals/L.js';
-import { disposeMesh } from '../rendering/disposeMesh.js';
-import { createMesh } from '../rendering/createMesh.js';
-import { nativeProgram } from './nativeProgram.js';
-
-/**
- * Replace a native layer mesh and select its rendering program.
- *
- * @param {Object} state Native layer state.
- * @param {string} key Mesh identifier.
- * @param {Array} position Vertex coordinates.
- * @param {number|Array} color Material color.
- * @param {number} opacity Material opacity.
- * @param {Object} texture Optional base texture.
- * @param {Array} uv Optional texture coordinates.
- * @param {boolean} terrain Whether the mesh represents terrain.
- * @param {boolean} nativeStroke Whether the mesh uses native stroke anchors.
- *
- * @returns {Object} The new mesh.
- */
-export function createNativeMesh(state, key, position, color, opacity, texture, uv, terrain, nativeStroke) {
-  const { backend: layer, source, meshes } = state;
-  // Unlit, noninteractive strokes use the normal slot for stationary anchors.
-  const normal = nativeStroke ? state.strokeAnchors : /* alloc */ [];
-  let index, mesh = meshes.get(key);
-  if (!nativeStroke) {
-    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', depthWrite: terrain, nativeStroke,
-  };
-  if (texture) material.baseTexture = texture;
-  if (mesh) disposeMesh(layer, mesh);
-  mesh = createMesh(layer, data, material, 0, source instanceof L.GridLayer
-    ? (terrain ? state.terrainRasterProgram : state.rasterProgram) || nativeProgram(layer, material)
-    : nativeProgram(layer, material));
-  if (source instanceof L.GridLayer) {
-    if (terrain) state.terrainRasterProgram ||= mesh.program;
-    else state.rasterProgram ||= mesh.program;
-    mesh.texture = texture;
-  }
-  meshes.set(key, mesh);
-  return mesh;
-}
+import { L } from '../globals/L.js';
+import { disposeMesh } from '../rendering/disposeMesh.js';
+import { createMesh } from '../rendering/createMesh.js';
+import { nativeProgram } from './nativeProgram.js';
+
+/**
+ * Replace a native layer mesh and select its rendering program.
+ *
+ * @param {Object} state Native layer state.
+ * @param {string} key Mesh identifier.
+ * @param {Array} position Vertex coordinates.
+ * @param {number|Array} color Material color.
+ * @param {number} opacity Material opacity.
+ * @param {Object} texture Optional base texture.
+ * @param {Array} uv Optional texture coordinates.
+ * @param {boolean} terrain Whether the mesh represents terrain.
+ * @param {boolean} nativeStroke Whether the mesh uses native stroke anchors.
+ *
+ * @returns {Object} The new mesh.
+ */
+export function createNativeMesh(state, key, position, color, opacity, texture, uv, terrain, nativeStroke) {
+  const { backend: layer, source, meshes } = state;
+  // Unlit, noninteractive strokes use the normal slot for stationary anchors.
+  const normal = nativeStroke ? state.strokeAnchors : /* alloc */ [];
+  let index, mesh = meshes.get(key);
+  if (!nativeStroke) {
+    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', depthWrite: terrain, nativeStroke,
+  };
+  if (texture) material.baseTexture = texture;
+  if (mesh) disposeMesh(layer, mesh);
+  mesh = createMesh(layer, data, material, 0, source instanceof L.GridLayer
+    ? (terrain ? state.terrainRasterProgram : state.rasterProgram) || nativeProgram(layer, material)
+    : nativeProgram(layer, material));
+  if (source instanceof L.GridLayer) {
+    if (terrain) state.terrainRasterProgram ||= mesh.program;
+    else state.rasterProgram ||= mesh.program;
+    mesh.texture = texture;
+  }
+  meshes.set(key, mesh);
+  return mesh;
+}

package/src/native/forwardNativeError.js

@@ -1,8 +1,8 @@
-/**
- * Forward a native backend error to its source layer.
- *
- * @param {Object} event Error event.
- */
-export function forwardNativeError({ error }) {
-  this.source.fire('error', /* alloc */ { error });
-}
+/**
+ * Forward a native backend error to its source layer.
+ *
+ * @param {Object} event Error event.
+ */
+export function forwardNativeError({ error }) {
+  this.source.fire('error', /* alloc */ { error });
+}

package/src/native/getGridTerrainTile.js

@@ -1,47 +1,47 @@
-/**
- * Load and cache a validated grid terrain tile, wrapping horizontal coordinates.
- *
- * @param {Object} state Native layer state with a terrain cache.
- * @param {number} z Tile zoom.
- * @param {number} x Tile column.
- * @param {number} y Tile row.
- *
- * @returns {Promise<Float32Array>} The elevation samples.
- *
- * @throws {Error} If the tile is not a 256-by-256 Float32Array.
- * @throws {Error} If the tile request or validation fails.
- */
-export async function getGridTerrainTile(state, z, x, y) {
-  const limit = 2 ** z;
-  x = ((x % limit) + limit) % limit;
-  y = Math.max(0, Math.min(limit - 1, y));
-  const key = `${z}/${x}/${y}`;
-  let entry = state.terrainCache.get(key);
-  if (!entry) {
-    entry = /* alloc */ { promise: state.layer.options.getTile(z, x, y, state.terrainController.signal) };
-    state.terrainCache.set(key, entry);
-  } else {
-    state.terrainCache.delete(key);
-    state.terrainCache.set(key, entry);
-  }
-  try {
-    if (!entry.data) entry.data = await entry.promise;
-    if (!(entry.data instanceof Float32Array) || entry.data.length !== 65536) {
-      throw /* alloc */ new Error(`Invalid elevation tile ${key}: expected 256x256 Float32Array`);
-    }
-    if (!entry.range) {
-      let minimum = Infinity, maximum = -Infinity, elevation;
-      for (elevation of entry.data) {
-        if (!Number.isFinite(elevation) || elevation <= -1000) continue;
-        minimum = Math.min(minimum, elevation);
-        maximum = Math.max(maximum, elevation);
-      }
-      entry.range = /* alloc */ [minimum, maximum];
-    }
-  } catch (error) {
-    if (state.terrainCache.get(key) === entry) state.terrainCache.delete(key);
-    throw error;
-  }
-  while (state.terrainCache.size > 256) state.terrainCache.delete(state.terrainCache.keys().next().value);
-  return entry.data;
-}
+/**
+ * Load and cache a validated grid terrain tile, wrapping horizontal coordinates.
+ *
+ * @param {Object} state Native layer state with a terrain cache.
+ * @param {number} z Tile zoom.
+ * @param {number} x Tile column.
+ * @param {number} y Tile row.
+ *
+ * @returns {Promise<Float32Array>} The elevation samples.
+ *
+ * @throws {Error} If the tile is not a 256-by-256 Float32Array.
+ * @throws {Error} If the tile request or validation fails.
+ */
+export async function getGridTerrainTile(state, z, x, y) {
+  const limit = 2 ** z;
+  x = ((x % limit) + limit) % limit;
+  y = Math.max(0, Math.min(limit - 1, y));
+  const key = `${z}/${x}/${y}`;
+  let entry = state.terrainCache.get(key);
+  if (!entry) {
+    entry = /* alloc */ { promise: state.layer.options.getTile(z, x, y, state.terrainController.signal) };
+    state.terrainCache.set(key, entry);
+  } else {
+    state.terrainCache.delete(key);
+    state.terrainCache.set(key, entry);
+  }
+  try {
+    if (!entry.data) entry.data = await entry.promise;
+    if (!(entry.data instanceof Float32Array) || entry.data.length !== 65536) {
+      throw /* alloc */ new Error(`Invalid elevation tile ${key}: expected 256x256 Float32Array`);
+    }
+    if (!entry.range) {
+      let minimum = Infinity, maximum = -Infinity, elevation;
+      for (elevation of entry.data) {
+        if (!Number.isFinite(elevation) || elevation <= -1000) continue;
+        minimum = Math.min(minimum, elevation);
+        maximum = Math.max(maximum, elevation);
+      }
+      entry.range = /* alloc */ [minimum, maximum];
+    }
+  } catch (error) {
+    if (state.terrainCache.get(key) === entry) state.terrainCache.delete(key);
+    throw error;
+  }
+  while (state.terrainCache.size > 256) state.terrainCache.delete(state.terrainCache.keys().next().value);
+  return entry.data;
+}

package/src/native/gridTerrainElevation.js

@@ -1,34 +1,34 @@
-import { terrainElevation } from '../terrain/terrainElevation.js';
-import { nativeTerrainElevation } from './nativeTerrainElevation.js';
-
-/**
- * Find a terrain elevation from the native grid or cached tiles at available zooms.
- *
- * @param {Object} state Native layer state.
- * @param {Object} location Geographic location to sample.
- *
- * @returns {number|null} Elevation, or null when no sample is available.
- */
-export function gridTerrainElevation(state, location) {
-  let z = Math.max(0, Math.min(24, Math.round(state.map.getZoom())));
-  const tiles = /* alloc */ new Map();
-  let point, limit, x, y, index, dx, dy, tx, ty, entry, elevation;
-  for (; z >= 0; z--) {
-    point = state.map.project(location, z), limit = 2 ** z;
-    x = Math.floor(point.x / 256), y = Math.floor(point.y / 256);
-    elevation = nativeTerrainElevation(state, point, x, y, z);
-    if (Number.isFinite(elevation)) return elevation;
-    tiles.clear();
-    for (index = 0; index < 9; index++) {
-      dx = index % 3 - 1;
-      dy = Math.floor(index / 3) - 1;
-      tx = ((x + dx) % limit + limit) % limit;
-      ty = Math.max(0, Math.min(limit - 1, y + dy));
-      entry = state.terrainCache.get(`${z}/${tx}/${ty}`);
-      if (entry?.data) tiles.set(`${x + dx}/${y + dy}`, entry.data);
-    }
-    elevation = terrainElevation(point, tiles);
-    if (Number.isFinite(elevation)) return elevation;
-  }
-  return null;
-}
+import { terrainElevation } from '../terrain/terrainElevation.js';
+import { nativeTerrainElevation } from './nativeTerrainElevation.js';
+
+/**
+ * Find a terrain elevation from the native grid or cached tiles at available zooms.
+ *
+ * @param {Object} state Native layer state.
+ * @param {Object} location Geographic location to sample.
+ *
+ * @returns {number|null} Elevation, or null when no sample is available.
+ */
+export function gridTerrainElevation(state, location) {
+  let z = Math.max(0, Math.min(24, Math.round(state.map.getZoom())));
+  const tiles = /* alloc */ new Map();
+  let point, limit, x, y, index, dx, dy, tx, ty, entry, elevation;
+  for (; z >= 0; z--) {
+    point = state.map.project(location, z), limit = 2 ** z;
+    x = Math.floor(point.x / 256), y = Math.floor(point.y / 256);
+    elevation = nativeTerrainElevation(state, point, x, y, z);
+    if (Number.isFinite(elevation)) return elevation;
+    tiles.clear();
+    for (index = 0; index < 9; index++) {
+      dx = index % 3 - 1;
+      dy = Math.floor(index / 3) - 1;
+      tx = ((x + dx) % limit + limit) % limit;
+      ty = Math.max(0, Math.min(limit - 1, y + dy));
+      entry = state.terrainCache.get(`${z}/${tx}/${ty}`);
+      if (entry?.data) tiles.set(`${x + dx}/${y + dy}`, entry.data);
+    }
+    elevation = terrainElevation(point, tiles);
+    if (Number.isFinite(elevation)) return elevation;
+  }
+  return null;
+}

package/src/native/isCurrentNativeLayer.js

@@ -1,12 +1,12 @@
-import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
-
-/**
- * Check whether this state still belongs to a layer present on its map.
- *
- * @param {Object} state Native layer state.
- *
- * @returns {boolean} Whether the state is current.
- */
-export function current(state) {
-  return nativeGPUByLayer.get(state.source) === state && state.map.hasLayer(state.source);
+import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
+
+/**
+ * Check whether this state still belongs to a layer present on its map.
+ *
+ * @param {Object} state Native layer state.
+ *
+ * @returns {boolean} Whether the state is current.
+ */
+export function current(state) {
+  return nativeGPUByLayer.get(state.source) === state && state.map.hasLayer(state.source);
 }

package/src/native/loadGridTerrain.js

@@ -1,36 +1,36 @@
-import { getGridTerrainTile } from './getGridTerrainTile.js';
-import { refreshNativeLayer } from './refreshNativeLayer.js';
-
-/**
- * Load the nine elevation tiles needed by a grid tile and refresh it when current.
- *
- * @param {Object} state Native grid layer state.
- * @param {string} key Grid tile key.
- * @param {Object} tile Grid tile being updated.
- * @param {Object} request Tracked terrain request.
- *
- * @returns {Promise<void>} Completion of the load or error reporting.
- */
-export async function loadGridTerrain(state, key, tile, request) {
-  const { x, y, z } = tile.coords, stream = request.stream;
-  const jobs = /* alloc */ [], tiles = /* alloc */ new Map();
-  let dx, dy, i = 0;
-  try {
-    for (dy = -1; dy <= 1; dy++) for (dx = -1; dx <= 1; dx++) {
-      jobs.push(getGridTerrainTile(stream, z, x + dx, y + dy));
-    }
-    const values = await Promise.all(jobs);
-    if (state.disposed || stream.terrainController.signal.aborted ||
-      state.source._tiles[key] !== tile || state.terrainRequests.get(key) !== request) return;
-    for (dy = -1; dy <= 1; dy++) for (dx = -1; dx <= 1; dx++) tiles.set(`${x + dx}/${y + dy}`, values[i++]);
-    request.tiles = tiles;
-    refreshNativeLayer(state);
-    state.map.fire('terrainchange');
-    state.source._update();
-  } catch (error) {
-    if (!state.disposed && !stream.terrainController.signal.aborted && state.source._tiles[key] === tile) {
-      request.error = error;
-      stream.layer.fire('error', /* alloc */ { error, coords: tile.coords });
-    }
-  }
-}
+import { getGridTerrainTile } from './getGridTerrainTile.js';
+import { refreshNativeLayer } from './refreshNativeLayer.js';
+
+/**
+ * Load the nine elevation tiles needed by a grid tile and refresh it when current.
+ *
+ * @param {Object} state Native grid layer state.
+ * @param {string} key Grid tile key.
+ * @param {Object} tile Grid tile being updated.
+ * @param {Object} request Tracked terrain request.
+ *
+ * @returns {Promise<void>} Completion of the load or error reporting.
+ */
+export async function loadGridTerrain(state, key, tile, request) {
+  const { x, y, z } = tile.coords, stream = request.stream;
+  const jobs = /* alloc */ [], tiles = /* alloc */ new Map();
+  let dx, dy, i = 0;
+  try {
+    for (dy = -1; dy <= 1; dy++) for (dx = -1; dx <= 1; dx++) {
+      jobs.push(getGridTerrainTile(stream, z, x + dx, y + dy));
+    }
+    const values = await Promise.all(jobs);
+    if (state.disposed || stream.terrainController.signal.aborted ||
+      state.source._tiles[key] !== tile || state.terrainRequests.get(key) !== request) return;
+    for (dy = -1; dy <= 1; dy++) for (dx = -1; dx <= 1; dx++) tiles.set(`${x + dx}/${y + dy}`, values[i++]);
+    request.tiles = tiles;
+    refreshNativeLayer(state);
+    state.map.fire('terrainchange');
+    state.source._update();
+  } catch (error) {
+    if (!state.disposed && !stream.terrainController.signal.aborted && state.source._tiles[key] === tile) {
+      request.error = error;
+      stream.layer.fire('error', /* alloc */ { error, coords: tile.coords });
+    }
+  }
+}

package/src/native/nativeEventSource.js

@@ -1,27 +1,27 @@
-import { L } from '../globals/L.js';
-import { raycast } from '../picking/raycast.js';
-import { compareNativeHits } from './compareNativeHits.js';
-
-/**
- * Find the foremost interactive native path hit by a map event.
- *
- * @param {Object} context Native event state for the map.
- * @param {Event} event Original DOM event.
- * @param {string} type Event type being dispatched.
- *
- * @returns {Object|null} Hit source layer, or null.
- */
-export function nativeEventSource(context, event, type) {
-  const hits = /* alloc */ [];
-  let candidate, source, layer;
-  if (type !== context.out) {
-    for (candidate of context.states) {
-      ({ source, backend: layer } = candidate);
-      if (source instanceof L.Marker || source.options.interactive === false ||
-        !(source instanceof L.Path) && !source.options.interactive) continue;
-      hits.push(...raycast(layer, event, candidate.meshes.values(), false));
-    }
-  }
-  hits.sort(compareNativeHits);
-  return hits[0]?.object._nativeSource || null;
-}
+import { L } from '../globals/L.js';
+import { raycast } from '../picking/raycast.js';
+import { compareNativeHits } from './compareNativeHits.js';
+
+/**
+ * Find the foremost interactive native path hit by a map event.
+ *
+ * @param {Object} context Native event state for the map.
+ * @param {Event} event Original DOM event.
+ * @param {string} type Event type being dispatched.
+ *
+ * @returns {Object|null} Hit source layer, or null.
+ */
+export function nativeEventSource(context, event, type) {
+  const hits = /* alloc */ [];
+  let candidate, source, layer;
+  if (type !== context.out) {
+    for (candidate of context.states) {
+      ({ source, backend: layer } = candidate);
+      if (source instanceof L.Marker || source.options.interactive === false ||
+        !(source instanceof L.Path) && !source.options.interactive) continue;
+      hits.push(...raycast(layer, event, candidate.meshes.values(), false));
+    }
+  }
+  hits.sort(compareNativeHits);
+  return hits[0]?.object._nativeSource || null;
+}

package/src/native/nativeProgram.js

@@ -1,28 +1,28 @@
-import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-import { nativeProgramsByRenderer } from '../weakmaps/nativeProgramsByRenderer.js';
-import { createProgram } from '../materials/createProgram.js';
-import { createProgramUniforms } from '../materials/createProgramUniforms.js';
-
-/**
- * Create a native material program from a renderer-local cached template.
- *
- * @param {Object} layer Backend layer.
- * @param {Object} material Material properties.
- *
- * @returns {Object} Program with material-specific uniforms.
- */
-export function nativeProgram(layer, material) {
-  const renderer = rendererByLayer.get(layer);
-  let programs = nativeProgramsByRenderer.get(renderer);
-  if (!programs) {
-    programs = /* alloc */ new Map();
-    nativeProgramsByRenderer.set(renderer, programs);
-  }
-  const key = `${Boolean(material.baseTexture)}:${Boolean(material.nativeStroke)}:${Boolean(material.depthWrite)}`;
-  let template = programs.get(key);
-  if (!template) {
-    template = createProgram(layer, /* alloc */ { doubleSided: true, ...material });
-    programs.set(key, template);
-  }
-  return /* alloc */ { ...template, uniforms: createProgramUniforms(material), _layerMaterial: material };
-}
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { nativeProgramsByRenderer } from '../weakmaps/nativeProgramsByRenderer.js';
+import { createProgram } from '../materials/createProgram.js';
+import { createProgramUniforms } from '../materials/createProgramUniforms.js';
+
+/**
+ * Create a native material program from a renderer-local cached template.
+ *
+ * @param {Object} layer Backend layer.
+ * @param {Object} material Material properties.
+ *
+ * @returns {Object} Program with material-specific uniforms.
+ */
+export function nativeProgram(layer, material) {
+  const renderer = rendererByLayer.get(layer);
+  let programs = nativeProgramsByRenderer.get(renderer);
+  if (!programs) {
+    programs = /* alloc */ new Map();
+    nativeProgramsByRenderer.set(renderer, programs);
+  }
+  const key = `${Boolean(material.baseTexture)}:${Boolean(material.nativeStroke)}:${Boolean(material.depthWrite)}`;
+  let template = programs.get(key);
+  if (!template) {
+    template = createProgram(layer, /* alloc */ { doubleSided: true, ...material });
+    programs.set(key, template);
+  }
+  return /* alloc */ { ...template, uniforms: createProgramUniforms(material), _layerMaterial: material };
+}

package/src/native/nativeTerrainElevation.js

@@ -1,27 +1,27 @@
-import { terrainElevation } from '../terrain/terrainElevation.js';
-import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
-
-/**
- * Sample terrain from a current native grid request at the given tile.
- *
- * @param {Object} state Terrain stream state.
- * @param {Object} point Projected point to sample.
- * @param {number} x Tile column.
- * @param {number} y Tile row.
- * @param {number} z Tile zoom.
- *
- * @returns {number|null} Elevation, or null if no current sample is available.
- */
-export function nativeTerrainElevation(state, point, x, y, z) {
-  let layer, native, request, elevation;
-  const key = `${x}:${y}:${z}`;
-  for (layer of Object.values(state.map._layers)) {
-    native = nativeGPUByLayer.get(layer);
-    if (native?.disposed || native?.terrainStream !== state) continue;
-    request = native.terrainRequests?.get(key);
-    if (!request?.tiles || layer._tiles[key] !== request.tile) continue;
-    elevation = terrainElevation(point, request.tiles);
-    if (Number.isFinite(elevation)) return elevation;
-  }
-  return null;
-}
+import { terrainElevation } from '../terrain/terrainElevation.js';
+import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
+
+/**
+ * Sample terrain from a current native grid request at the given tile.
+ *
+ * @param {Object} state Terrain stream state.
+ * @param {Object} point Projected point to sample.
+ * @param {number} x Tile column.
+ * @param {number} y Tile row.
+ * @param {number} z Tile zoom.
+ *
+ * @returns {number|null} Elevation, or null if no current sample is available.
+ */
+export function nativeTerrainElevation(state, point, x, y, z) {
+  let layer, native, request, elevation;
+  const key = `${x}:${y}:${z}`;
+  for (layer of Object.values(state.map._layers)) {
+    native = nativeGPUByLayer.get(layer);
+    if (native?.disposed || native?.terrainStream !== state) continue;
+    request = native.terrainRequests?.get(key);
+    if (!request?.tiles || layer._tiles[key] !== request.tile) continue;
+    elevation = terrainElevation(point, request.tiles);
+    if (Number.isFinite(elevation)) return elevation;
+  }
+  return null;
+}

package/src/native/nativeVectorGeometry.js

@@ -1,30 +1,30 @@
-import { geometryPixelStates } from '../globals/geometryPixelStates.js';
-import { nativeGeometry } from '../geometry/nativeGeometry.js';
-import { localPixelForGeometry } from '../projections/localPixelForGeometry.js';
-import { locationByLayer } from '../weakmaps/locationByLayer.js';
-import { radians } from '../globals/radians.js';
-import { L } from '../globals/L.js';
-
-/**
- * Build native vector geometry using the layer's local pixel projection.
- *
- * @param {Object} state Native layer state.
- *
- * @returns {*} Geometry produced for the source layer.
- */
-export function nativeVectorGeometry(state) {
-  const { source } = state;
-  state.strokeCoordinates = null;
-  state.strokeAnchors = source instanceof L.Polyline && !source.options.dashArray ? /* alloc */ [] : null;
-  const crs = state.map.options.crs, origin = locationByLayer.get(state.backend);
-  state.pixelProjection = /* alloc */ {
-    transformation: crs.transformation, scale: crs.scale(state.map.getZoom()),
-    origin: crs.project(origin), metres: Math.cos(origin.lat * radians),
-  };
-  geometryPixelStates.push(state);
-  try {
-    return nativeGeometry(source, state.map, localPixelForGeometry);
-  } finally {
-    geometryPixelStates.pop();
-  }
-}
+import { geometryPixelStates } from '../globals/geometryPixelStates.js';
+import { nativeGeometry } from '../geometry/nativeGeometry.js';
+import { localPixelForGeometry } from '../projections/localPixelForGeometry.js';
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { radians } from '../globals/radians.js';
+import { L } from '../globals/L.js';
+
+/**
+ * Build native vector geometry using the layer's local pixel projection.
+ *
+ * @param {Object} state Native layer state.
+ *
+ * @returns {*} Geometry produced for the source layer.
+ */
+export function nativeVectorGeometry(state) {
+  const { source } = state;
+  state.strokeCoordinates = null;
+  state.strokeAnchors = source instanceof L.Polyline && !source.options.dashArray ? /* alloc */ [] : null;
+  const crs = state.map.options.crs, origin = locationByLayer.get(state.backend);
+  state.pixelProjection = /* alloc */ {
+    transformation: crs.transformation, scale: crs.scale(state.map.getZoom()),
+    origin: crs.project(origin), metres: Math.cos(origin.lat * radians),
+  };
+  geometryPixelStates.push(state);
+  try {
+    return nativeGeometry(source, state.map, localPixelForGeometry);
+  } finally {
+    geometryPixelStates.pop();
+  }
+}

package/src/native/orderNativeGridLayer.js

@@ -1,20 +1,20 @@
-import { L } from '../globals/L.js';
-
-/**
- * Move a native grid layer beyond the other grid layers in its pane.
- *
- * @param {Object} state Native layer state.
- * @param {string} name Layer method being called.
- */
-export function orderNativeGridLayer(state, name) {
-  const { source } = state;
-  if (!(source instanceof L.GridLayer) || name !== 'bringToFront' && name !== 'bringToBack') return;
-  let extreme = name === 'bringToFront' ? -Infinity : Infinity, layer, zIndex;
-  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);
-}
+import { L } from '../globals/L.js';
+
+/**
+ * Move a native grid layer beyond the other grid layers in its pane.
+ *
+ * @param {Object} state Native layer state.
+ * @param {string} name Layer method being called.
+ */
+export function orderNativeGridLayer(state, name) {
+  const { source } = state;
+  if (!(source instanceof L.GridLayer) || name !== 'bringToFront' && name !== 'bringToBack') return;
+  let extreme = name === 'bringToFront' ? -Infinity : Infinity, layer, zIndex;
+  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);
+}