leaflet-city-mapper 0.0.9 → 0.1.1

package/src/mvt/readMvtNumbers.js

@@ -1,11 +1,18 @@
-import { readMvtMessage } from './readMvtMessage.js';
-import { readMvtNumber } from './readMvtNumber.js';
-
-export function readMvtNumbers(reader, wire, target) {
-  let packed;
-  if (wire === 0) target.push(readMvtNumber(reader));
-  else {
-    packed = readMvtMessage(reader, wire);
-    while (packed.pos < packed.bytes.length) target.push(readMvtNumber(packed));
-  }
-}
+import { readMvtMessage } from './readMvtMessage.js';
+import { readMvtNumber } from './readMvtNumber.js';
+
+/**
+ * Append packed or unpacked protobuf integers to a destination array.
+ *
+ * @param {Object} reader MVT byte reader.
+ * @param {number} wire Protobuf wire type.
+ * @param {Array<number>} target Destination array.
+ */
+export function readMvtNumbers(reader, wire, target) {
+  let packed;
+  if (wire === 0) target.push(readMvtNumber(reader));
+  else {
+    packed = readMvtMessage(reader, wire);
+    while (packed.pos < packed.bytes.length) target.push(readMvtNumber(packed));
+  }
+}

package/src/mvt/readMvtString.js

@@ -1,6 +1,14 @@
-import { mvtTextDecoder } from '../globals/mvtTextDecoder.js';
-import { readMvtMessage } from './readMvtMessage.js';
-
-export function readMvtString(reader, wire) {
-  return mvtTextDecoder.decode(readMvtMessage(reader, wire).bytes);
-}
+import { mvtTextDecoder } from '../globals/mvtTextDecoder.js';
+import { readMvtMessage } from './readMvtMessage.js';
+
+/**
+ * Decode a length-delimited UTF-8 string.
+ *
+ * @param {Object} reader MVT byte reader.
+ * @param {number} wire Protobuf wire type.
+ *
+ * @returns {string} Decoded string.
+ */
+export function readMvtString(reader, wire) {
+  return mvtTextDecoder.decode(readMvtMessage(reader, wire).bytes);
+}

package/src/mvt/readMvtValue.js

@@ -1,19 +1,29 @@
-import { readMvtField } from './readMvtField.js';
-import { skipMvtField } from './skipMvtField.js';
-import { readMvtKnownValue } from './readMvtKnownValue.js';
-
-export function readMvtValue(reader) {
-  let value, found = false, field, wire;
-  while (reader.pos < reader.bytes.length) {
-    [field, wire] = readMvtField(reader);
-    if (field < 1 || field > 7) {
-      skipMvtField(reader, wire);
-      continue;
-    }
-    if (found) throw /* alloc */ new Error('Multiple MVT value types');
-    found = true;
-    value = readMvtKnownValue(reader, field, wire);
-  }
-  if (!found) throw /* alloc */ new Error('Empty MVT value');
-  return value;
-}
+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) {
+    [field, wire] = readMvtField(reader);
+    if (field < 1 || field > 7) {
+      skipMvtField(reader, wire);
+      continue;
+    }
+    if (found) throw /* alloc */ new Error('Multiple MVT value types');
+    found = true;
+    value = readMvtKnownValue(reader, field, wire);
+  }
+  if (!found) throw /* alloc */ new Error('Empty MVT value');
+  return value;
+}

package/src/mvt/skipMvtField.js

@@ -1,14 +1,22 @@
-import { expectMvtWire } from './expectMvtWire.js';
-import { readMvtInteger } from './readMvtInteger.js';
-import { readMvtNumber } from './readMvtNumber.js';
-import { takeMvtBytes } from './takeMvtBytes.js';
-
-export function skipMvtField(reader, wire) {
-  switch (wire) {
-    case 0: readMvtInteger(reader); break;
-    case 1: takeMvtBytes(reader, 8); break;
-    case 2: takeMvtBytes(reader, readMvtNumber(reader)); break;
-    case 5: takeMvtBytes(reader, 4); break;
-    default: throw /* alloc */ new Error('Unsupported MVT wire type');
-  }
-}
+import { expectMvtWire } from './expectMvtWire.js';
+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;
+    case 1: takeMvtBytes(reader, 8); break;
+    case 2: takeMvtBytes(reader, readMvtNumber(reader)); break;
+    case 5: takeMvtBytes(reader, 4); break;
+    default: throw /* alloc */ new Error('Unsupported MVT wire type');
+  }
+}

package/src/mvt/sortMvtActiveEdges.js

@@ -1,15 +1,20 @@
-import { mergeMvtActiveEdges } from './mergeMvtActiveEdges.js';
-
-export function sortMvtActiveEdges(active) {
-  const sorted = /* alloc */ new Array(active.length);
-  let width = 1, left, mid, right, i;
-  while (width < active.length) {
-    for (left = 0; left < active.length; left += width * 2) {
-      mid = Math.min(left + width, active.length);
-      right = Math.min(left + width * 2, active.length);
-      mergeMvtActiveEdges(active, sorted, left, mid, right);
-    }
-    for (i = 0; i < active.length; i++) active[i] = sorted[i];
-    width *= 2;
-  }
-}
+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;
+  while (width < active.length) {
+    for (left = 0; left < active.length; left += width * 2) {
+      mid = Math.min(left + width, active.length);
+      right = Math.min(left + width * 2, active.length);
+      mergeMvtActiveEdges(active, sorted, left, mid, right);
+    }
+    for (i = 0; i < active.length; i++) active[i] = sorted[i];
+    width *= 2;
+  }
+}

package/src/mvt/sortedMvtLevels.js

@@ -1,22 +1,29 @@
-export function sortedMvtLevels(levels) {
-  const sorted = /* alloc */ [];
-  let y, gap = 0, i = 0, j, value, count = 0;
-  for (y of levels) sorted.push(y);
-  gap = Math.floor(sorted.length / 2);
-  for (; gap > 0; gap = Math.floor(gap / 2)) {
-    for (i = gap; i < sorted.length; i++) {
-      value = sorted[i];
-      j = i;
-      while (j >= gap && sorted[j - gap] > value) {
-        sorted[j] = sorted[j - gap];
-        j -= gap;
-      }
-      sorted[j] = value;
-    }
-  }
-  for (i = 0; i < sorted.length; i++) {
-    if (!count || sorted[i] - sorted[count - 1] > 1e-8) sorted[count++] = sorted[i];
-  }
-  sorted.length = count;
-  return sorted;
-}
+/**
+ * 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;
+  for (y of levels) sorted.push(y);
+  gap = Math.floor(sorted.length / 2);
+  for (; gap > 0; gap = Math.floor(gap / 2)) {
+    for (i = gap; i < sorted.length; i++) {
+      value = sorted[i];
+      j = i;
+      while (j >= gap && sorted[j - gap] > value) {
+        sorted[j] = sorted[j - gap];
+        j -= gap;
+      }
+      sorted[j] = value;
+    }
+  }
+  for (i = 0; i < sorted.length; i++) {
+    if (!count || sorted[i] - sorted[count - 1] > 1e-8) sorted[count++] = sorted[i];
+  }
+  sorted.length = count;
+  return sorted;
+}

package/src/mvt/takeMvtBytes.js

@@ -1,8 +1,18 @@
-export function takeMvtBytes(reader, size) {
-  if (!Number.isSafeInteger(size) || size < 0 || size > reader.bytes.length - reader.pos) {
-    throw /* alloc */ new Error('Truncated MVT field');
-  }
-  const start = reader.pos;
-  reader.pos += size;
-  return start;
-}
+/**
+ * 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');
+  }
+  const start = reader.pos;
+  reader.pos += size;
+  return start;
+}

package/src/mvt/tessellateVectorRings.js

@@ -1,19 +1,26 @@
-import { addMvtCrossings } from './addMvtCrossings.js';
-import { appendMvtBandTriangles } from './appendMvtBandTriangles.js';
-import { collectMvtEdges } from './collectMvtEdges.js';
-import { sortedMvtLevels } from './sortedMvtLevels.js';
-
-export function tessellateVectorRings(rings) {
-  const edges = /* alloc */ [], levels = /* alloc */ new Set(), triangles = /* alloc */ [];
-  let sorted, i = 1, top, bottom;
-  collectMvtEdges(rings, edges, levels);
-  addMvtCrossings(edges, levels);
-  sorted = sortedMvtLevels(levels);
-  // ponytail: quadratic edge scan; use a sweep-line index for large datasets.
-  for (; i < sorted.length; i++) {
-    top = sorted[i - 1];
-    bottom = sorted[i];
-    if (bottom > top) appendMvtBandTriangles(edges, top, bottom, triangles);
-  }
-  return triangles;
-}
+import { addMvtCrossings } from './addMvtCrossings.js';
+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;
+  collectMvtEdges(rings, edges, levels);
+  addMvtCrossings(edges, levels);
+  sorted = sortedMvtLevels(levels);
+  // ponytail: quadratic edge scan; use a sweep-line index for large datasets.
+  for (; i < sorted.length; i++) {
+    top = sorted[i - 1];
+    bottom = sorted[i];
+    if (bottom > top) appendMvtBandTriangles(edges, top, bottom, triangles);
+  }
+  return triangles;
+}

package/src/mvt/triangulateVectorRings.js

@@ -1,19 +1,23 @@
-import { appendMvtPolygonTriangles } from './appendMvtPolygonTriangles.js';
-import { groupMvtPolygons } from './groupMvtPolygons.js';
-import { mvtPathsVertices } from './mvtPathsVertices.js';
-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.
- */
-export function triangulateVectorRings(rings) {
-  const polygons = groupMvtPolygons(rings), triangles = /* alloc */ [];
-  let polygon, paths, vertices;
-  for (polygon of polygons) {
-    paths = mvtPolygonPaths(polygon);
-    vertices = mvtPathsVertices(paths);
-    appendMvtPolygonTriangles(polygon, paths, vertices, triangles);
-  }
-  return triangles;
-}
+import { appendMvtPolygonTriangles } from './appendMvtPolygonTriangles.js';
+import { groupMvtPolygons } from './groupMvtPolygons.js';
+import { mvtPathsVertices } from './mvtPathsVertices.js';
+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 */ [];
+  let polygon, paths, vertices;
+  for (polygon of polygons) {
+    paths = mvtPolygonPaths(polygon);
+    vertices = mvtPathsVertices(paths);
+    appendMvtPolygonTriangles(polygon, paths, vertices, triangles);
+  }
+  return triangles;
+}

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,16 +1,21 @@
-import { synchronizeNativeLayer } from './synchronizeNativeLayer.js';
-import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
-
-export function beforeNativeRender(state) {
-  try {
-    synchronizeNativeLayer(state);
-    const uniform = state.meshes.get('stroke')?.program.uniforms.strokeScale;
-    if (uniform) {
-      const zoom = cameraViewByMap.get(state.map)?.zoom ?? state.map.getZoom();
-      uniform.value = 2 ** (state.strokeZoom - zoom) * Number(state.source.options.weight) / state.strokeWeight;
-    }
-  } catch (error) {
-    state.failed = true;
-    state.source.fire('error', /* alloc */ { error });
-  }
-}
+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);
+    const uniform = state.meshes.get('stroke')?.program.uniforms.strokeScale;
+    if (uniform) {
+      const zoom = cameraViewByMap.get(state.map)?.zoom ?? state.map.getZoom();
+      uniform.value = 2 ** (state.strokeZoom - zoom) * Number(state.source.options.weight) / state.strokeWeight;
+    }
+  } catch (error) {
+    state.failed = true;
+    state.source.fire('error', /* alloc */ { error });
+  }
+}

package/src/native/bypassNativeEvent.js

@@ -1,11 +1,21 @@
-import { updateNativeHover } from './updateNativeHover.js';
-
-export function bypassNativeEvent(map, context, event, type) {
-  const target = event.target;
-  const dom = target instanceof Element &&
-    target.closest('.leaflet-marker-icon,.leaflet-popup,.leaflet-tooltip,.leaflet-control');
-  if (dom && context.hovered && (type === context.move || type === context.out)) {
-    updateNativeHover(map, context, event, null);
-  }
-  return dom || type === context.move && (map.dragging?.moving() || map._animatingZoom);
-}
+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 &&
+    target.closest('.leaflet-marker-icon,.leaflet-popup,.leaflet-tooltip,.leaflet-control');
+  if (dom && context.hovered && (type === context.move || type === context.out)) {
+    updateNativeHover(map, context, event, null);
+  }
+  return dom || type === context.move && (map.dragging?.moving() || map._animatingZoom);
+}

package/src/native/canScaleNativeStyle.js

@@ -1,17 +1,26 @@
-import { L } from '../globals/L.js';
-import { nativeScalableStyleKeys } from '../globals/nativeScalableStyleKeys.js';
-
-export function canScaleNativeStyle(name, state, args) {
-  const { source } = state;
-  if (name !== 'setStyle' || source.options.interactive !== false || state.dirty && !state.zoomOnly) return false;
-  const stroke = state.strokeCoordinates && state.meshes.get('stroke')?.program.uniforms.strokeScale;
-  const fill = source instanceof L.Polygon && !source.options.stroke && state.meshes.has('fill');
-  if (!stroke && !fill) return false;
-  let key;
-  if (args[0]) {
-    for (key of Object.keys(args[0])) {
-      if (!nativeScalableStyleKeys.has(key)) return false;
-    }
-  }
-  return true;
-}
+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;
+  const stroke = state.strokeCoordinates && state.meshes.get('stroke')?.program.uniforms.strokeScale;
+  const fill = source instanceof L.Polygon && !source.options.stroke && state.meshes.has('fill');
+  if (!stroke && !fill) return false;
+  let key;
+  if (args[0]) {
+    for (key of Object.keys(args[0])) {
+      if (!nativeScalableStyleKeys.has(key)) return false;
+    }
+  }
+  return true;
+}

package/src/native/compareNativeHits.js

@@ -1,3 +1,11 @@
-export function compareNativeHits(a, b) {
-  return b.object.renderOrder - a.object.renderOrder || a.distance - b.distance;
+/**
+ * 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

@@ -1,31 +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';
-
-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/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 @@
-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 });
+}