leaflet-city-mapper 0.0.8 → 0.1.0

package/src/mvt/readMvtValue.js

@@ -2,6 +2,16 @@ import { readMvtField } from './readMvtField.js';
 import { skipMvtField } from './skipMvtField.js';
 import { readMvtKnownValue } from './readMvtKnownValue.js';
 
+/**
+ * Decode an MVT value message containing exactly one known value field.
+ *
+ * @param {Object} reader Value message reader.
+ *
+ * @returns {string|number|boolean} Decoded value.
+ *
+ * @throws {Error} If multiple known value fields are present.
+ * @throws {Error} If no known value field is present.
+ */
 export function readMvtValue(reader) {
   let value, found = false, field, wire;
   while (reader.pos < reader.bytes.length) {

package/src/mvt/skipMvtField.js

@@ -3,6 +3,14 @@ import { readMvtInteger } from './readMvtInteger.js';
 import { readMvtNumber } from './readMvtNumber.js';
 import { takeMvtBytes } from './takeMvtBytes.js';
 
+/**
+ * Skip an unknown protobuf field according to its wire type.
+ *
+ * @param {Object} reader MVT byte reader.
+ * @param {number} wire Protobuf wire type.
+ *
+ * @throws {Error} If the wire type is unsupported.
+ */
 export function skipMvtField(reader, wire) {
   switch (wire) {
     case 0: readMvtInteger(reader); break;

package/src/mvt/sortMvtActiveEdges.js

@@ -1,5 +1,10 @@
 import { mergeMvtActiveEdges } from './mergeMvtActiveEdges.js';
 
+/**
+ * Stably sort active polygon edges in place by their x coordinate.
+ *
+ * @param {Array<Object>} active Active edges with x values.
+ */
 export function sortMvtActiveEdges(active) {
   const sorted = /* alloc */ new Array(active.length);
   let width = 1, left, mid, right, i;

package/src/mvt/sortedMvtLevels.js

@@ -1,3 +1,10 @@
+/**
+ * Sort vertical levels and collapse values within the tessellation tolerance.
+ *
+ * @param {Set<number>} levels Unsorted vertical levels.
+ *
+ * @returns {Array<number>} Sorted distinct levels.
+ */
 export function sortedMvtLevels(levels) {
   const sorted = /* alloc */ [];
   let y, gap = 0, i = 0, j, value, count = 0;

package/src/mvt/takeMvtBytes.js

@@ -1,3 +1,13 @@
+/**
+ * Advance an MVT reader over a bounded number of bytes.
+ *
+ * @param {Object} reader MVT byte reader.
+ * @param {number} size Number of bytes to take.
+ *
+ * @returns {number} Starting byte offset.
+ *
+ * @throws {Error} If the size is invalid or exceeds remaining bytes.
+ */
 export function takeMvtBytes(reader, size) {
   if (!Number.isSafeInteger(size) || size < 0 || size > reader.bytes.length - reader.pos) {
     throw /* alloc */ new Error('Truncated MVT field');

package/src/mvt/tessellateVectorRings.js

@@ -3,6 +3,13 @@ import { appendMvtBandTriangles } from './appendMvtBandTriangles.js';
 import { collectMvtEdges } from './collectMvtEdges.js';
 import { sortedMvtLevels } from './sortedMvtLevels.js';
 
+/**
+ * Tessellate closed polygon rings into even-odd horizontal bands.
+ *
+ * @param {Array} rings Closed tile-coordinate rings.
+ *
+ * @returns {Array} Triangle coordinate arrays.
+ */
 export function tessellateVectorRings(rings) {
   const edges = /* alloc */ [], levels = /* alloc */ new Set(), triangles = /* alloc */ [];
   let sorted, i = 1, top, bottom;

package/src/mvt/triangulateVectorRings.js

@@ -6,6 +6,10 @@ import { mvtPolygonPaths } from './mvtPolygonPaths.js';
 /**
  * Reuse City Mapper's triangulator in tile space, with even-odd tessellation
  * for quantized touching/crossing rings. Output triangles omit their closure.
+ *
+ * @param {Array} rings Closed MVT polygon rings.
+ *
+ * @returns {Array} Triangle coordinate arrays.
  */
 export function triangulateVectorRings(rings) {
   const polygons = groupMvtPolygons(rings), triangles = /* alloc */ [];

package/src/native/README.md

@@ -0,0 +1,27 @@
+# Native Leaflet layers
+
+[Source guide](../README.md) | [Project README](../../README.md)
+
+Synchronizes supported Leaflet layers with GPU meshes and textures, forwards
+events and restores original methods and DOM targets on disposal.
+
+## Leaflet source and GPU representation
+
+```mermaid
+flowchart LR
+  Leaflet["Native Leaflet layer"] --> Init["Initialize GPU state + hide targets"]
+  Init --> Dirty["Data / view changes mark dirty"]
+  Dirty --> Sync["Synchronize meshes + textures"]
+  Sync --> Frame["Shared render frame"]
+  Frame --> Prune["Prune unused resources"]
+  Init --> Remove["Removal: restore methods + release resources"]
+```
+
+Leaflet remains the source of data and events; GPU objects are a representation.
+Pair wrapped methods, listeners and cached resources with their disposal path.
+
+- [initNativeGPU.js](./initNativeGPU.js): start native GPU initialization.
+- [synchronizeNativeLayer.js](./synchronizeNativeLayer.js): synchronize dirty layer state.
+- [disposeNativeLayer.js](./disposeNativeLayer.js): restore methods and release resources.
+
+Related: [core](../core/README.md), [rendering](../rendering/README.md), [picking](../picking/README.md).

package/src/native/beforeNativeRender.js

@@ -1,6 +1,11 @@
 import { synchronizeNativeLayer } from './synchronizeNativeLayer.js';
 import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
 
+/**
+ * Synchronize a native layer and adjust its stroke scale before rendering.
+ *
+ * @param {Object} state Native layer state.
+ */
 export function beforeNativeRender(state) {
   try {
     synchronizeNativeLayer(state);

package/src/native/bypassNativeEvent.js

@@ -1,5 +1,15 @@
 import { updateNativeHover } from './updateNativeHover.js';
 
+/**
+ * Decide whether a DOM event should bypass native layer hit testing.
+ *
+ * @param {Object} map Leaflet map.
+ * @param {Object} context Native event state for the map.
+ * @param {Event} event Original DOM event.
+ * @param {string} type Event type being dispatched.
+ *
+ * @returns {Element|boolean|null} The matching DOM target or whether testing should be bypassed.
+ */
 export function bypassNativeEvent(map, context, event, type) {
   const target = event.target;
   const dom = target instanceof Element &&

package/src/native/canScaleNativeStyle.js

@@ -1,6 +1,15 @@
 import { L } from '../globals/L.js';
 import { nativeScalableStyleKeys } from '../globals/nativeScalableStyleKeys.js';
 
+/**
+ * Check whether a noninteractive native layer can update its style without rebuilding geometry.
+ *
+ * @param {string} name Layer method being called.
+ * @param {Object} state Native layer state.
+ * @param {Array} args Arguments passed to the layer method.
+ *
+ * @returns {boolean} Whether the style change can be applied by scaling.
+ */
 export function canScaleNativeStyle(name, state, args) {
   const { source } = state;
   if (name !== 'setStyle' || source.options.interactive !== false || state.dirty && !state.zoomOnly) return false;

package/src/native/compareNativeHits.js

@@ -1,3 +1,11 @@
+/**
+ * Sort native hits by descending render order and then ascending distance.
+ *
+ * @param {Object} a First hit.
+ * @param {Object} b Second hit.
+ *
+ * @returns {number} Relative order of the hits.
+ */
 export function compareNativeHits(a, b) {
   return b.object.renderOrder - a.object.renderOrder || a.distance - b.distance;
 }

package/src/native/createNativeMesh.js

@@ -3,6 +3,21 @@ 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.

package/src/native/disposeNativeLayer.js

@@ -1,6 +1,4 @@
 import { nativeRenderByLayer } from '../weakmaps/nativeRenderByLayer.js';
-
-
 import { refreshNativeEvent } from './refreshNativeEvent.js';
 import { updateNativeLayerView } from './updateNativeLayerView.js';
 import { removeNativeEvents } from './removeNativeEvents.js';
@@ -10,6 +8,9 @@ import { nativeImageRefresh } from '../textures/nativeImageRefresh.js';
 import { nativeImageError } from '../textures/nativeImageError.js';
 import { removeImageState } from '../textures/removeImageState.js';
 
+/**
+ * Dispose the native layer state, restore source methods and release its resources.
+ */
 export function disposeNativeLayer() {
   const state = this;
   if (state.disposed) return;

package/src/native/forwardNativeError.js

@@ -1,3 +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 });
 }

package/src/native/getGridTerrainTile.js

@@ -1,3 +1,16 @@
+/**
+ * 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;

package/src/native/gridTerrainElevation.js

@@ -1,6 +1,14 @@
 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();

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';
-
-
-
+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,6 +1,16 @@
 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();

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

@@ -2,6 +2,15 @@ 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;

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

@@ -3,6 +3,14 @@ import { nativeProgramsByRenderer } from '../weakmaps/nativeProgramsByRenderer.j
 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);

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); }