leaflet-city-mapper 0.0.9 → 0.1.1

package/src/native/getGridTerrainTile.js

@@ -1,34 +1,47 @@
-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,26 +1,34 @@
-import { terrainElevation } from '../terrain/terrainElevation.js';
-import { nativeTerrainElevation } from './nativeTerrainElevation.js';
-
-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/handleNativeMapEvent.js

@@ -1,15 +1,20 @@
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-
 import { nativeEventMaps } from '../weakmaps/nativeEventMaps.js';
 import { renderers } from '../weakmaps/renderers.js';
 import { coreEventTypes } from '../globals/coreEventTypes.js';
-
-
-
 import { nativeEventSource } from './nativeEventSource.js';
 import { updateNativeHover } from './updateNativeHover.js';
 import { bypassNativeEvent } from './bypassNativeEvent.js';
 
+/**
+ * Dispatch map events to native layer hits while preserving normal Leaflet handling.
+ *
+ * @param {Event} event Original DOM event.
+ * @param {string} type Event type to dispatch.
+ * @param {Array} targets Explicit event targets, when provided.
+ *
+ * @returns {*} Result of Leaflet's DOM event dispatcher.
+ */
 export function handleNativeMapEvent(event, type = event.type, targets) {
   const map = this, context = nativeEventMaps.get(map), fireDOMEvent = context.fireDOMEvent;
   const owner = renderers.get(map);

package/src/native/hideTargets.js

@@ -1,4 +1,10 @@
 import { L } from '../globals/L.js';
+
+/**
+ * Hide rendered marker images while leaving HTML icons available for interaction.
+ *
+ * @param {Object} state Native layer state and its set of hidden elements.
+ */
 export function hideTargets(state) {
   const { source } = state;
   const htmlIcon = source instanceof L.Marker && source.options.icon instanceof L.DivIcon;

package/src/native/initNativeGPU.js

@@ -1,14 +1,17 @@
 import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
 import { readyByLayer } from '../weakmaps/readyByLayer.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/reportLayerError.js';
 
+/**
+ * Initialize GPU rendering for a native Leaflet layer and track its readiness.
+ *
+ * @param {Object} source Leaflet layer to render.
+ * @param {Object} map Map containing the layer.
+ */
 export function initNativeGPU(source, map) {
   if (nativeGPUByLayer.get(source)) return;
   if (!document.getElementById('leaflet-webgpu-targets')) {

package/src/native/isCurrentNativeLayer.js

@@ -1,7 +1,12 @@
 import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
 
-
-
-export function current(state) {
-  return nativeGPUByLayer.get(state.source) === state && state.map.hasLayer(state.source);
+/**
+ * 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,26 +1,36 @@
-import { getGridTerrainTile } from './getGridTerrainTile.js';
-import { refreshNativeLayer } from './refreshNativeLayer.js';
-
-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/nativeAddLatLng.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward addLatLng to the native source and refresh its GPU representation.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeAddLatLng(...args) { return nativeLayerMethod('addLatLng', this, args); }

package/src/native/nativeBringToBack.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward bringToBack and update the native layer's render order.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeBringToBack(...args) { return nativeLayerMethod('bringToBack', this, args); }

package/src/native/nativeBringToFront.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward bringToFront and update the native layer's render order.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeBringToFront(...args) { return nativeLayerMethod('bringToFront', this, args); }

package/src/native/nativeEventSource.js

@@ -1,18 +1,27 @@
-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, 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/nativeEvents.js

@@ -1,13 +1,14 @@
 import { L } from '../globals/L.js';
 import { nativeEventMaps } from '../weakmaps/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. */
+/**
+ * Install one GPU hit test per map event and register the native layer.
+ *
+ * @param {Object} state Native layer state.
+ */
 export function nativeEvents(state) {
   const { map } = state;
   let context = nativeEventMaps.get(map);

package/src/native/nativeLayer.js

@@ -1,16 +1,11 @@
 import { nativeGPUBackByMap } from '../weakmaps/nativeGPUBackByMap.js';
 import { nativeGPUOrderByMap } from '../weakmaps/nativeGPUOrderByMap.js';
-
 import { L } from '../globals/L.js';
 import { nativeMethodHandlers } from '../globals/nativeMethodHandlers.js';
 import { nativeRenderByLayer } from '../weakmaps/nativeRenderByLayer.js';
-
 import { createLayer } from '../scene/createLayer.js';
-
-
 import { nativeEvents } from './nativeEvents.js';
 import { update } from '../scene/scheduleSceneUpdate.js';
-
 import { current } from './isCurrentNativeLayer.js';
 import { refreshNativeLayer } from './refreshNativeLayer.js';
 import { refreshNativeEvent } from './refreshNativeEvent.js';
@@ -21,7 +16,16 @@ import { forwardNativeError } from './forwardNativeError.js';
 import { updateNativeLayerView } from './updateNativeLayerView.js';
 import { synchronizeNativeLayer } from './synchronizeNativeLayer.js';
 
-/** Render from coordinates and detached raster sources; only accessible marker controls remain DOM. */
+/**
+ * Set up native rendering from coordinates and detached raster sources.
+ *
+ * @param {Object} state Native layer state.
+ *
+ * @returns {Promise<Object>} The original source layer.
+ *
+ * @throws {Error} If the backend fails to become ready.
+ * @throws {Error} If initial synchronization fails.
+ */
 export async function nativeLayer(state) {
   const { source, map } = state;
   const layer = state.backend = createLayer(/* alloc */ {

package/src/native/nativeLayerMethod.js

@@ -1,12 +1,19 @@
 import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
 import { nativeGPUBackByMap } from '../weakmaps/nativeGPUBackByMap.js';
 import { nativeGPUOrderByMap } from '../weakmaps/nativeGPUOrderByMap.js';
-
-
 import { refreshNativeLayer } from './refreshNativeLayer.js';
 import { canScaleNativeStyle } from './canScaleNativeStyle.js';
 import { orderNativeGridLayer } from './orderNativeGridLayer.js';
 
+/**
+ * Call the original layer method and update the corresponding GPU rendering.
+ *
+ * @param {string} name Original method name.
+ * @param {Object} source Leaflet source layer.
+ * @param {Array} args Arguments passed to the original method.
+ *
+ * @returns {*} Result of the original method.
+ */
 export function nativeLayerMethod(name, source, args) {
   const state = nativeGPUByLayer.get(source), original = state.methods.get(name).original;
   const scalable = canScaleNativeStyle(name, state, args);

package/src/native/nativeProgram.js

@@ -1,20 +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';
-
-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/nativeRedraw.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward redraw and refresh the GPU representation.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeRedraw(...args) { return nativeLayerMethod('redraw', this, args); }

package/src/native/nativeSetBounds.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward setBounds and refresh the GPU representation.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeSetBounds(...args) { return nativeLayerMethod('setBounds', this, args); }

package/src/native/nativeSetIcon.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward setIcon and refresh the GPU representation.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeSetIcon(...args) { return nativeLayerMethod('setIcon', this, args); }

package/src/native/nativeSetLatLng.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward setLatLng and refresh the GPU representation.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeSetLatLng(...args) { return nativeLayerMethod('setLatLng', this, args); }

package/src/native/nativeSetLatLngs.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward setLatLngs and refresh the GPU representation.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeSetLatLngs(...args) { return nativeLayerMethod('setLatLngs', this, args); }

package/src/native/nativeSetOpacity.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward setOpacity and refresh the GPU representation.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeSetOpacity(...args) { return nativeLayerMethod('setOpacity', this, args); }

package/src/native/nativeSetRadius.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward setRadius and refresh the GPU representation.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeSetRadius(...args) { return nativeLayerMethod('setRadius', this, args); }

package/src/native/nativeSetStyle.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward setStyle and refresh the GPU representation.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeSetStyle(...args) { return nativeLayerMethod('setStyle', this, args); }

package/src/native/nativeSetUrl.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward setUrl and refresh the GPU representation.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeSetUrl(...args) { return nativeLayerMethod('setUrl', this, args); }

package/src/native/nativeSetZIndex.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward setZIndex and refresh the GPU representation.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeSetZIndex(...args) { return nativeLayerMethod('setZIndex', this, args); }

package/src/native/nativeSetZIndexOffset.js

@@ -1,3 +1,10 @@
 import { nativeLayerMethod } from './nativeLayerMethod.js';
 
+/**
+ * Forward setZIndexOffset and refresh the GPU representation.
+ *
+ * @param {...*} args Arguments passed to the source method.
+ *
+ * @returns {*} Result of the source method.
+ */
 export function nativeSetZIndexOffset(...args) { return nativeLayerMethod('setZIndexOffset', this, args); }