leaflet-city-mapper 0.0.9 → 0.1.0

package/src/native/pruneNativeResources.js

@@ -1,6 +1,11 @@
 import { disposeMesh } from '../rendering/disposeMesh.js';
 import { destroyTexture } from '../textures/destroyTexture.js';
 
+/**
+ * Dispose meshes and textures not used by the latest native layer update.
+ *
+ * @param {Object} state Native layer state.
+ */
 export function pruneNativeResources(state) {
   const { meshes, textures, backend: layer } = state;
   let mesh, texture, key;

package/src/native/putNativeMesh.js

@@ -3,6 +3,20 @@ import { styleNativeMesh } from './styleNativeMesh.js';
 import { createNativeMesh } from './createNativeMesh.js';
 import { updateNativeStrokeRadius } from './updateNativeStrokeRadius.js';
 
+/**
+ * Create or update a native mesh and apply its style.
+ *
+ * @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.
+ *
+ * @returns {Object|undefined} Updated mesh, if positions were provided.
+ */
 export function putNativeMesh(state, key, position, color, opacity, texture, uv, terrain = false) {
   const { source, meshes } = state;
   if (!position.length) return;

package/src/native/quadNativeMesh.js

@@ -4,7 +4,17 @@ import { coreWhite } from '../globals/coreWhite.js';
 import { textureFor } from '../textures/nativeTextureFor.js';
 import { putNativeMesh } from './putNativeMesh.js';
 
-
+/**
+ * Create or update a textured native mesh from four corners.
+ *
+ * @param {Object} state Native layer state.
+ * @param {string} key Mesh identifier.
+ * @param {HTMLImageElement} image Image to use as a texture.
+ * @param {Array} corners Quad corner coordinates.
+ * @param {number} opacity Mesh opacity.
+ *
+ * @returns {Object|undefined} Mesh, if the texture is available.
+ */
 export function quadNativeMesh(state, key, image, corners, opacity) {
   const texture = textureFor(state, key, image);
   if (!texture) return;

package/src/native/readyNativeGPU.js

@@ -1,9 +1,13 @@
-import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
-
-
-
-import { nativeLayer } from './nativeLayer.js';
-
+import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
+import { nativeLayer } from './nativeLayer.js';
+
+/**
+ * Start native rendering only if the layer state is still current.
+ *
+ * @param {Object} state Native layer state.
+ *
+ * @returns {Object|Promise<Object>} The source layer or its initialization promise.
+ */
 export function readyNativeGPU(state) {
   if (nativeGPUByLayer.get(state.source) !== state) return state.source;
   return nativeLayer(state);

package/src/native/refreshNativeEvent.js

@@ -2,6 +2,11 @@ import { refreshNativeLayer } from './refreshNativeLayer.js';
 import { L } from '../globals/L.js';
 import { update } from '../scene/scheduleSceneUpdate.js';
 
+/**
+ * Refresh native rendering for a source or map event, optimizing stroke-only zooms.
+ *
+ * @param {Object} event Leaflet event.
+ */
 export function refreshNativeEvent(event) {
   if (event?.type === 'zoomend' && this.source instanceof L.Polyline &&
     (!this.source.options.stroke || !(Number(this.source.options.weight) > 0))) return;

package/src/native/refreshNativeLayer.js

@@ -1,7 +1,4 @@
 import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
-
-
-
 import { nativeImageRefresh } from '../textures/nativeImageRefresh.js';
 import { nativeImageError } from '../textures/nativeImageError.js';
 import { removeImageState } from '../textures/removeImageState.js';
@@ -9,6 +6,11 @@ import { addImageState } from '../textures/addImageState.js';
 import { update } from '../scene/scheduleSceneUpdate.js';
 import { hideTargets } from './hideTargets.js';
 
+/**
+ * Mark a native layer dirty, synchronize image listeners and schedule rendering.
+ *
+ * @param {Object} state Native layer state, defaulting to the bound context.
+ */
 export function refreshNativeLayer(state = this) {
   state.zoomOnly = false;
   state.dirty = true;

package/src/native/refreshNativeLayerContract.js

@@ -1,8 +1,11 @@
 import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
-
-
 import { refreshNativeLayer } from './refreshNativeLayer.js';
 
+/**
+ * Refresh a layer's native backend if it is active.
+ *
+ * @param {Object} layer Source layer, defaulting to the bound context.
+ */
 export function refreshNativeLayerContract(layer = this) {
   const native = nativeGPUByLayer.get(layer);
   if (native?.backend && !native.disposed) refreshNativeLayer(native);

package/src/native/rejectNativeReady.js

@@ -1,4 +1,9 @@
 
+/**
+ * Reject the native layer's readiness promise on backend error.
+ *
+ * @param {Object} event Backend error event.
+ */
 export function rejectNativeReady({ error }) {
   this.ready.reject(error);
 }

package/src/native/removeNativeEvents.js

@@ -1,6 +1,10 @@
-import { nativeEventMaps } from '../weakmaps/nativeEventMaps.js';
-
-
+import { nativeEventMaps } from '../weakmaps/nativeEventMaps.js';
+
+/**
+ * Unregister native layer event handling and restore map handling when unused.
+ *
+ * @param {Object} state Native layer state.
+ */
 export function removeNativeEvents(state) {
   const context = state._nativeEventContext;
   if (!context) return;

package/src/native/removeTargets.js

@@ -1,8 +1,11 @@
 import { nativeGPUByLayer } from '../weakmaps/nativeGPUByLayer.js';
-
-
 import { disposeNativeLayer } from './disposeNativeLayer.js';
 
+/**
+ * Dispose a removed native layer and restore its hidden DOM elements.
+ *
+ * @param {Object} state Native layer state.
+ */
 export function removeTargets(state) {
   if (nativeGPUByLayer.get(state.source) === state) nativeGPUByLayer.set(state.source, null);
   if (state.backend) disposeNativeLayer.call(state);

package/src/native/reorderNativeLayer.js

@@ -1,10 +1,12 @@
 import { nativeGPUBackByMap } from '../weakmaps/nativeGPUBackByMap.js';
 import { nativeGPUOrderByMap } from '../weakmaps/nativeGPUOrderByMap.js';
-
-
-
 import { refreshNativeLayer } from './refreshNativeLayer.js';
 
+/**
+ * Move the bound native layer to the front or back and schedule a refresh.
+ *
+ * @param {boolean} front Whether to move the layer to the front.
+ */
 export function reorderNativeLayer(front) {
   if (front) {
     this.order = nativeGPUOrderByMap.get(this.map) + 1;

package/src/native/resolveNativeReady.js

@@ -1,4 +1,7 @@
 
+/**
+ * Resolve the bound native layer's readiness promise.
+ */
 export function resolveNativeReady() {
   this.ready.resolve();
 }

package/src/native/restoreNativeEvents.js

@@ -1,3 +1,6 @@
+/**
+ * Restore the map's original DOM event dispatcher if the native handler is still installed.
+ */
 export function restoreNativeEvents() {
   const { map, descriptor, handle } = this;
   if (map._fireDOMEvent !== handle) return;

package/src/native/retainGridTerrain.js

@@ -1,3 +1,8 @@
+/**
+ * Retain terrain meshes and textures while replacement grid tiles are pending.
+ *
+ * @param {Object} state Native grid layer state.
+ */
 export function retainGridTerrain(state) {
   let key, mesh, retained;
   for ([key, mesh] of state.meshes) {

package/src/native/styleNativeMesh.js

@@ -1,8 +1,14 @@
-import { cameraZIndexOffsetByLayer } from '../weakmaps/cameraZIndexOffsetByLayer.js';
-
-import { L } from '../globals/L.js';
-
-
+import { cameraZIndexOffsetByLayer } from '../weakmaps/cameraZIndexOffsetByLayer.js';
+import { L } from '../globals/L.js';
+
+/**
+ * Apply color, opacity, ordering and source metadata to a native mesh.
+ *
+ * @param {Object} state Native layer state.
+ * @param {Object} mesh Mesh to update.
+ * @param {number|Array} color Material color.
+ * @param {number} opacity Material opacity.
+ */
 export function styleNativeMesh(state, mesh, color, opacity) {
   const { source, marker, paneOrder, order } = state;
   mesh.program.uniforms.baseColor.value = color;

package/src/native/syncGridLayer.js

@@ -3,7 +3,11 @@ import { syncGridTile } from './syncGridTile.js';
 import { syncTerrainGridTile } from './syncTerrainGridTile.js';
 import { retainGridTerrain } from './retainGridTerrain.js';
 
-
+/**
+ * Synchronize loaded grid tiles and retain terrain while replacements are pending.
+ *
+ * @param {Object} state Native grid layer state.
+ */
 export function syncGridLayer(state) {
   const { source } = state;
   const stream = prepareGridTerrainRequests(state);

package/src/native/syncGridTile.js

@@ -4,6 +4,16 @@ import { styleNativeMesh } from './styleNativeMesh.js';
 import { quadNativeMesh } from './quadNativeMesh.js';
 import { boundsQuad } from '../geometry/boundsQuad.js';
 
+/**
+ * Reuse or rebuild the textured mesh for a loaded grid tile.
+ *
+ * @param {Object} state Native grid layer state.
+ * @param {string} key Tile key.
+ * @param {Object} tile Loaded tile.
+ * @param {number} opacity Tile opacity.
+ *
+ * @returns {Object|undefined} Tile mesh, if available.
+ */
 export function syncGridTile(state, key, tile, opacity) {
   const retained = state.textures.get(key), mesh = state.meshes.get(key);
   if (mesh && !mesh._terrainRequest && retained?.image === tile.el &&

package/src/native/syncImageOverlay.js

@@ -1,6 +1,11 @@
-import { quadNativeMesh } from './quadNativeMesh.js';
-import { boundsQuad } from '../geometry/boundsQuad.js';
-
+import { quadNativeMesh } from './quadNativeMesh.js';
+import { boundsQuad } from '../geometry/boundsQuad.js';
+
+/**
+ * Synchronize a loaded image overlay as a textured quad.
+ *
+ * @param {Object} state Native layer state.
+ */
 export function syncImageOverlay(state) {
   const { source } = state;
   if (source._image?.complete && source._image.naturalWidth) {

package/src/native/syncMarker.js

@@ -1,6 +1,11 @@
 import { quadNativeMesh } from './quadNativeMesh.js';
 import { markerQuadCorners } from '../geometry/markerQuadCorners.js';
 
+/**
+ * Synchronize loaded marker icon and shadow images as native meshes.
+ *
+ * @param {Object} state Native marker state.
+ */
 export function syncMarker(state) {
   const { source } = state;
   let i, key, image, mesh;

package/src/native/syncNativeStrokeAnchors.js

@@ -1,3 +1,9 @@
+/**
+ * Retain stroke coordinates and anchors for subsequent zoom scaling.
+ *
+ * @param {Object} state Native layer state.
+ * @param {Array} stroke Stroke coordinates.
+ */
 export function syncNativeStrokeAnchors(state, stroke) {
   const { source } = state;
   if (state.strokeAnchors?.length === stroke.length && stroke.length) {

package/src/native/syncNativeStrokeZoom.js

@@ -1,6 +1,11 @@
 import { styleNativeMesh } from './styleNativeMesh.js';
 import { parseColor } from '../colors/parseColor.js';
 
+/**
+ * Rescale a native stroke for the current zoom and refresh stroke and fill styles.
+ *
+ * @param {Object} state Native vector layer state.
+ */
 export function syncNativeStrokeZoom(state) {
   const { source, meshes, strokeCoordinates, strokeAnchors } = state;
   const mesh = meshes.get('stroke');

package/src/native/syncTerrainGridTile.js

@@ -3,6 +3,16 @@ import { loadGridTerrain } from './loadGridTerrain.js';
 import { styleNativeMesh } from './styleNativeMesh.js';
 import { terrainGridMesh } from './terrainGridMesh.js';
 
+/**
+ * Request terrain for a grid tile and reuse or build its draped mesh.
+ *
+ * @param {Object} state Native grid layer state.
+ * @param {string} key Tile key.
+ * @param {Object} tile Loaded tile.
+ * @param {number} opacity Tile opacity.
+ *
+ * @returns {Object|null|undefined} Mesh when available, otherwise null or undefined.
+ */
 export function syncTerrainGridTile(state, key, tile, opacity) {
   const retained = state.textures.get(key), mesh = state.meshes.get(key);
   let request = state.terrainRequests.get(key);

package/src/native/syncVectorLayer.js

@@ -4,6 +4,11 @@ import { syncNativeStrokeZoom } from './syncNativeStrokeZoom.js';
 import { nativeVectorGeometry } from './nativeVectorGeometry.js';
 import { syncNativeStrokeAnchors } from './syncNativeStrokeAnchors.js';
 
+/**
+ * Synchronize native vector fill and stroke meshes or rescale them after zoom.
+ *
+ * @param {Object} state Native vector layer state.
+ */
 export function syncVectorLayer(state) {
   const { source } = state;
   if (state.zoomOnly) {

package/src/native/synchronizeNativeLayer.js

@@ -1,8 +1,5 @@
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-
 import { L } from '../globals/L.js';
-
-
 import { current } from './isCurrentNativeLayer.js';
 import { syncGridLayer } from './syncGridLayer.js';
 import { syncImageOverlay } from './syncImageOverlay.js';
@@ -10,6 +7,11 @@ import { syncMarker } from './syncMarker.js';
 import { syncVectorLayer } from './syncVectorLayer.js';
 import { pruneNativeResources } from './pruneNativeResources.js';
 
+/**
+ * Synchronize a dirty native layer and dispose resources no longer in use.
+ *
+ * @param {Object} state Native layer state.
+ */
 export function synchronizeNativeLayer(state) {
   const { source, meshes, textures } = state;
   if (!current(state) || !rendererByLayer.get(state.backend) || state.failed) return;

package/src/native/terrainGridMesh.js

@@ -5,6 +5,19 @@ import { terrainElevation } from '../terrain/terrainElevation.js';
 import { localPosition } from '../projections/localPosition.js';
 import { putNativeMesh } from './putNativeMesh.js';
 
+/**
+ * Build a textured grid tile mesh draped over sampled terrain.
+ *
+ * @param {Object} state Native grid layer state.
+ * @param {string} key Tile key.
+ * @param {Object} tile Loaded tile.
+ * @param {Object} request Terrain request containing elevation tiles.
+ * @param {number} opacity Tile opacity.
+ *
+ * @returns {Object|undefined} Terrain mesh, if its texture is available.
+ *
+ * @throws {Error} If an elevation sample is missing.
+ */
 export function terrainGridMesh(state, key, tile, request, opacity) {
   const texture = textureFor(state, key, tile.el);
   if (!texture) return;

package/src/native/updateNativeHover.js

@@ -1,3 +1,11 @@
+/**
+ * Dispatch hover transitions and update the cursor for the current native hit.
+ *
+ * @param {Object} map Leaflet map.
+ * @param {Object} context Native event state.
+ * @param {Event} event Original DOM event.
+ * @param {Object|null} source Hit source layer, if any.
+ */
 export function updateNativeHover(map, context, event, source) {
   if (context.hovered === source) return;
   if (context.hovered) context.fireDOMEvent.call(map, event, context.out, /* alloc */ [context.hovered]);

package/src/native/updateNativeLayerView.js

@@ -1,9 +1,9 @@
 import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
-
-
-
 import { update } from '../scene/scheduleSceneUpdate.js';
 
+/**
+ * Mark the bound native layer's view dirty and schedule a render if attached.
+ */
 export function updateNativeLayerView() {
   this.viewDirty = true;
   if (sharedByLayer.get(this.backend)) update(this.backend);

package/src/native/updateNativeStrokeRadius.js

@@ -1,3 +1,8 @@
+/**
+ * Store the maximum distance between stroke vertices and their anchors.
+ *
+ * @param {Object} mesh Native stroke mesh.
+ */
 export function updateNativeStrokeRadius(mesh) {
   const attributes = mesh.geometry.attributes, positions = attributes.position.data, anchors = attributes.normal.data;
   let i, radius = 0;

package/src/picking/README.md

@@ -0,0 +1,29 @@
+# Picking
+
+[Source guide](../README.md) | [Project README](../../README.md)
+
+Converts pointer events into scene raycasts, feature hits, hover highlighting and
+tooltips. Model hits and batched source features are resolved differently.
+
+## Pointer to feature
+
+```mermaid
+flowchart LR
+  Pointer["Pointer move"] --> Gesture{"Gesture active?"}
+  Gesture -->|yes| Clear["Clear hover"]
+  Gesture -->|no| Ray["Raycast attached scene"]
+  Ray --> Model["Model: walk hit-node parents"]
+  Ray --> Batch["Source: search face ranges"]
+  Model --> Hover["Highlight + tooltip + featurehover"]
+  Batch --> Hover
+```
+
+Face ranges come from [geometry](../geometry/README.md); keep them aligned
+with triangle order. A missing hit may also mean the root or camera is not
+attached.
+
+- [raycast.js](./raycast.js): intersect a pointer ray with scene meshes.
+- [findFeature.js](./findFeature.js): resolve an intersection to a feature.
+- [onPointerMove.js](./onPointerMove.js): update pointer interaction.
+
+Related: [collision](../collision/README.md), [native](../native/README.md), [scene](../scene/README.md).

package/src/picking/collectVisibleMesh.js

@@ -1,3 +1,11 @@
+/**
+ * Collect visible geometry for raycasting and skip invisible subtrees.
+ *
+ * @param {Object} mesh Scene node being visited.
+ * @param {Object[]} meshes Output mesh list.
+ *
+ * @returns {boolean|undefined} True when traversal should skip the node's descendants.
+ */
 export function collectVisibleMesh(mesh, meshes) {
   if (!mesh.visible) return true;
   if (mesh.geometry && mesh._appearance !== 0) meshes.push(mesh);

package/src/picking/findFeature.js

@@ -1,17 +1,17 @@
 import { cameraByLayer } from '../weakmaps/cameraByLayer.js';
 import { modelByLayer } from '../weakmaps/modelByLayer.js';
 import { rootByLayer } from '../weakmaps/rootByLayer.js';
-
-
-
 import { raycast } from './raycast.js';
 
 /**
  * Translate a geometry hit into a configured model or batched source feature.
  * Sorted half-open face ranges permit binary search without a feature per triangle.
+ *
+ * @param {L.Layer} layer Layer containing the features.
+ * @param {MouseEvent} event Pointer location used for raycasting.
+ *
  * @returns {PickedFeature|null}
  */
-
 export function findFeature(layer, event) {
   const model = modelByLayer.get(layer)
   if (!rootByLayer.get(layer) || !cameraByLayer.get(layer)) {

package/src/picking/hit.js

@@ -3,18 +3,25 @@ import { kindByLayer } from '../weakmaps/kindByLayer.js';
 import { rootByLayer } from '../weakmaps/rootByLayer.js';
 import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
 import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
-
-
-
-
 import { traverse } from '../scene/traverse.js';
 import { updateWorldMatrix } from '../transforms/updateWorldMatrix.js';
 import { hitMesh } from './hitMesh.js';
 import { trafficCollision } from '../collision/trafficCollision.js';
 
-// Horizontal normal of the nearest wall faced within `reach` metres of the feet at world (x, y, z), walking along
-// the unit (dx, dz); knee and chest rays, so arches and tree crowns above the head let the walker through.
-
+/**
+ * Find the nearest wall faced by knee and chest rays along a horizontal walking direction.
+ *
+ * @param {L.Layer} layer Walking layer whose shared scene is tested.
+ * @param {number} x World-space feet x coordinate.
+ * @param {number} y World-space feet height.
+ * @param {number} z World-space feet z coordinate.
+ * @param {number} dx Horizontal unit direction along x.
+ * @param {number} dz Horizontal unit direction along z.
+ * @param {number} reach Maximum ray distance in metres.
+ * @param {Object} data Reusable collision scratch and nearest-hit state.
+ *
+ * @returns {number[]|null} Nearest horizontal wall normal, or null when clear.
+ */
 export function hit(layer, x, y, z, dx, dz, reach, data) {
   updateWorldMatrix(sceneByLayer.get(layer));
   data.x = x, data.y = y, data.z = z, data.dx = dx, data.dz = dz, data.reach = reach;

package/src/picking/hitColliderCell.js

@@ -1,5 +1,15 @@
 import { horizontalRay } from '../collision/horizontalRay.js';
 
+/**
+ * Test unseen, front-facing triangles in a collider cell at knee and chest heights.
+ *
+ * @param {number[]} cell Triangle indices in the cell.
+ * @param {Object} c Cached collider geometry and normals.
+ * @param {Object} data Collision scratch and nearest-hit state.
+ * @param {number} ox Collider-local ray origin x coordinate.
+ * @param {number} oy Collider-local ray origin y coordinate.
+ * @param {number} oz Collider-local ray origin z coordinate.
+ */
 export function hitColliderCell(cell, c, data, ox, oy, oz) {
   const { dx, dz, seen } = data;
   let t, height, d;

package/src/picking/hitMesh.js

@@ -1,10 +1,16 @@
 import { CELL } from '../globals/CELL.js';
-
 import { computeBounds } from '../geometry/computeBounds.js';
 import { collider } from '../collision/collider.js';
-
 import { hitColliderCell } from './hitColliderCell.js';
 
+/**
+ * Test a visible mesh's nearby collider cells against the walking ray.
+ *
+ * @param {Object} mesh Scene node being visited.
+ * @param {Object} data Collision scratch and nearest-hit state.
+ *
+ * @returns {boolean|undefined} True when traversal should skip the node's descendants.
+ */
 export function hitMesh(mesh, data) {
   if (!mesh.visible) return true;
   if (!mesh.geometry?.attributes?.position?.data || mesh.program?.depthTest === false) return;

package/src/picking/onClick.js

@@ -1,13 +1,14 @@
 import { hoveredFeatureByLayer } from '../weakmaps/hoveredFeatureByLayer.js';
-
-
-
 import { findFeature } from './findFeature.js';
 import { setHighlight } from './setHighlight.js';
 import { showFeature } from './showFeature.js';
 
-/** Emit click without moving the map or pinning the tooltip. */
-
+/**
+ * Emit click without moving the map or pinning the tooltip.
+ *
+ * @param {L.Layer} layer Layer receiving the click.
+ * @param {MouseEvent} event Pointer event.
+ */
 export function onClick(layer, event) {
   const feature = findFeature(layer, event);
   hoveredFeatureByLayer.set(layer, feature);

package/src/picking/onPointerLeave.js

@@ -1,12 +1,12 @@
 import { hoveredFeatureByLayer } from '../weakmaps/hoveredFeatureByLayer.js';
-
-
-
 import { setHighlight } from './setHighlight.js';
 import { showFeature } from './showFeature.js';
 
-/** Clear hover, highlight and tooltip without retaining a selected feature. */
-
+/**
+ * Clear hover, highlight and tooltip without retaining a selected feature.
+ *
+ * @param {L.Layer} layer Layer whose hover state is cleared.
+ */
 export function onPointerLeave(layer) {
   hoveredFeatureByLayer.set(layer, null);
   setHighlight(layer, null);

package/src/picking/onPointerMove.js

@@ -1,14 +1,15 @@
 import { hoveredFeatureByLayer } from '../weakmaps/hoveredFeatureByLayer.js';
-
-
-
 import { findFeature } from './findFeature.js';
 import { setHighlight } from './setHighlight.js';
 import { showFeature } from './showFeature.js';
 import { onPointerLeave } from './onPointerLeave.js';
 
-/** Gestures clear hover once without raycasting; normal misses report feature:null. */
-
+/**
+ * Clear hover during gestures; otherwise raycast and report the current feature or a miss.
+ *
+ * @param {L.Layer} layer Layer receiving the pointer movement.
+ * @param {PointerEvent} event Pointer movement event.
+ */
 export function onPointerMove(layer, event) {
   if (event.buttons || layer._map.dragging?.moving() || layer._map._animatingZoom) {
     if (hoveredFeatureByLayer.get(layer)) onPointerLeave(layer);

package/src/picking/pointerClick.js

@@ -1,5 +1,10 @@
 import * as onClick from './onClick.js';
 
+/**
+ * Forward a pointer click to the layer's feature handler.
+ *
+ * @param {MouseEvent} event Click event.
+ */
 export function pointerClick(event) {
   onClick.onClick(this, event);
 }

package/src/picking/pointerLeave.js

@@ -1,5 +1,6 @@
 import * as onPointerLeave from './onPointerLeave.js';
 
+/** Clear this layer's feature hover state when the pointer leaves. */
 export function pointerLeave() {
   onPointerLeave.onPointerLeave(this);
 }

package/src/picking/pointerMove.js

@@ -1,5 +1,10 @@
 import * as onPointerMove from './onPointerMove.js';
 
+/**
+ * Forward pointer movement to the layer's feature handler.
+ *
+ * @param {PointerEvent} event Pointer movement event.
+ */
 export function pointerMove(event) {
   onPointerMove.onPointerMove(this, event);
 }