leaflet-city-mapper 0.0.9 → 0.1.0

package/src/geometry/bridgePolygon.js

@@ -5,6 +5,12 @@ import { indexBridge } from './indexBridge.js';
 import { bridgeFaces } from './bridgeFaces.js';
 import { bridgeSides } from './bridgeSides.js';
 
+/**
+ * Project, triangulate and index a bridge polygon, adding its deck geometry.
+ *
+ * @param {Object} context Bridge projection and destination buffers.
+ * @param {Array<Array<Array<number>>>} polygon GeoJSON polygon rings with elevations.
+ */
 export function bridgePolygon(context, polygon) {
   const { backend: layer, map, zoom, crs, origin, metres, base } = context;
   const rings = /* alloc */ [];

package/src/geometry/bridgeSides.js

@@ -1,5 +1,12 @@
 import { bridgeEdge } from './bridgeEdge.js';
 
+/**
+ * Append the side faces of each bridge polygon ring.
+ *
+ * @param {Object} context Destination geometry buffers.
+ * @param {Array<Array<number>>} points Flattened local bridge points.
+ * @param {Array<Array>} rings Bridge rings defining point counts.
+ */
 export function bridgeSides(context, points, rings) {
   let start = 0, ring, i;
   for (ring of rings) {

package/src/geometry/buildGeometryParts.js

@@ -1,5 +1,12 @@
 import { triangle } from './triangle.js';
 
+/**
+ * Build colored extruded parts from bottom and top rings.
+ *
+ * @param {Array<Array>} parts Ring, bottom, top, tint and optional top-ring tuples.
+ *
+ * @returns {Object} Flat position, normal and color arrays.
+ */
 export function build(parts) {
   const position = /* alloc */ [];
   const normal = /* alloc */ [];

package/src/geometry/buildProjectedPoint.js

@@ -3,6 +3,17 @@ import { lampPostGeometry } from './lampPostGeometry.js';
 import { lightGeometry } from './lightGeometry.js';
 import { treeGeometry } from './treeGeometry.js';
 
+/**
+ * Generate tree or night-light geometry for a projected point.
+ *
+ * @param {Object} context Area geometry and light state.
+ * @param {Object} projected Projected point with ground height.
+ * @param {Object} style Point geometry style.
+ * @param {Object} baseColor Parsed RGB color.
+ * @param {string} support Support identifier used to deduplicate lamp posts.
+ *
+ * @throws {Error} If a night-light flux is not finite and positive.
+ */
 export function buildProjectedPoint(context, projected, style, baseColor, support) {
   const { top } = style;
   if (context.backend.options.nightLight) {

package/src/geometry/buildProjectedPolygon.js

@@ -2,6 +2,15 @@ import { triangulate } from '../triangulation/triangulate.js';
 import { addTriangle } from './appendAreaTriangle.js';
 import { isClockWise } from '../triangulation/isClockWise.js';
 
+/**
+ * Append roof, optional bottom and side triangles for a projected polygon.
+ *
+ * @param {Object} context Destination area geometry.
+ * @param {Array<Array<Object>>} paths Projected outer ring and holes.
+ * @param {number} top Extrusion top height.
+ * @param {number} bottom Extrusion bottom height.
+ * @param {Object} baseColor Parsed RGB color.
+ */
 export function buildProjectedPolygon(context, paths, top, bottom, baseColor) {
   const points = /* alloc */ [];
   let path, point, a, b, c, index, sign, i, length, nx, nz;

package/src/geometry/circleAt.js

@@ -1,5 +1,18 @@
-import { tau } from '../globals/tau.js';
-import { L } from '../globals/L.js';
+import { tau } from '../globals/tau.js';
+import { L } from '../globals/L.js';
+
+/**
+ * Compute a point on an elliptical ring with an optional radial offset.
+ *
+ * @param {L.Point} center Ellipse center.
+ * @param {number} radius Horizontal radius.
+ * @param {number} radiusY Vertical radius.
+ * @param {number} count Ring subdivision count.
+ * @param {number} index Ring point index.
+ * @param {number} [offset] Offset applied to both radii.
+ *
+ * @returns {L.Point} Ring point.
+ */
 export function circleAt(center, radius, radiusY, count, index, offset = 0) {
   const angle = index * tau / count;
   return /* alloc */ new L.Point(center.x + Math.max(0, radius + offset) * Math.cos(angle),

package/src/geometry/circleGeometry.js

@@ -5,6 +5,12 @@ import { line } from './line.js';
 import { triangle } from './appendNativeTriangle.js';
 import { projectNativePath } from '../core/projectNativePath.js';
 
+/**
+ * Generate native circle or ellipse fill and stroke triangles.
+ *
+ * @param {L.Circle|L.CircleMarker} source Native circle layer.
+ * @param {Object} context Projection, style and destination buffers.
+ */
 export function circleGeometry(source, context) {
   const { map, point, fill, stroke, options, dash, width } = context;
   const center = map.project(source.getLatLng());

package/src/geometry/clipLine.js

@@ -1,7 +1,14 @@
 import { samePoint } from './samePoint.js';
 import { clipSegment } from './clipSegment.js';
 
-/** Clip a geographic line to [west, south, east, north] without joining disjoint pieces. */
+/**
+ * Clip a geographic line to [west, south, east, north] without joining disjoint pieces.
+ *
+ * @param {Array<Array<number>>} line Geographic coordinates.
+ * @param {Array<number>} bounds West, south, east and north.
+ *
+ * @returns {Array<Array<Array<number>>>} Clipped line pieces.
+ */
 export function clipLine(line, bounds) {
   const pieces = /* alloc */ [];
   let current;

package/src/geometry/clipSegment.js

@@ -1,3 +1,12 @@
+/**
+ * Clip a segment to geographic bounds, discarding zero-length results.
+ *
+ * @param {Array<number>} a Segment start.
+ * @param {Array<number>} b Segment end.
+ * @param {Array<number>} bounds West, south, east and north.
+ *
+ * @returns {Array<Array<number>>|null} Clipped endpoints, or null if outside.
+ */
 export function clipSegment(a, b, bounds) {
   const [west, south, east, north] = bounds;
   const dx = b[0] - a[0], dy = b[1] - a[1];

package/src/geometry/computeBounds.js

@@ -1,5 +1,8 @@
-/** Cache local AABB and center for ray picking and transparent mesh sorting. */
-
+/**
+ * Cache local bounds, center and bounding radius, including any instance offsets.
+ *
+ * @param {Object} geometry Geometry with position and optional instance-offset attributes.
+ */
 export function computeBounds(geometry) {
   const min = /* alloc */ [Infinity, Infinity, Infinity];
   const max = /* alloc */ [-Infinity, -Infinity, -Infinity];

package/src/geometry/conformModelToTerrain.js

@@ -4,12 +4,9 @@ import { sceneOriginByLayer } from '../weakmaps/sceneOriginByLayer.js';
 import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
 import { terrainReadyByLayer } from '../weakmaps/terrainReadyByLayer.js';
 import { terrainZoomByLayer } from '../weakmaps/terrainZoomByLayer.js';
-
 import { radians } from '../globals/radians.js';
 import { L } from '../globals/L.js';
 import { HEIGHT } from '../globals/HEIGHT.js';
-
-
 import { computeBounds } from './computeBounds.js';
 import { getElevation } from '../terrain/getElevation.js';
 import { update } from '../scene/scheduleSceneUpdate.js';
@@ -17,6 +14,12 @@ import { updateWorldMatrix } from '../transforms/updateWorldMatrix.js';
 import { vertexNormals } from './vertexNormals.js';
 import { collectMeshes } from '../collision/collectMeshes.js';
 
+/**
+ * Conform model vertices to terrain or restore their original positions when disabled.
+ *
+ * @param {L.Layer} layer Model layer.
+ * @param {L.Layer} terrain Terrain layer, if available.
+ */
 export function conformModelToTerrain(layer, terrain) {
   if (!modelByLayer.get(layer)) return;
   const meshes = /* alloc */ [];

package/src/geometry/createLampRing.js

@@ -1,5 +1,13 @@
 import { lampDirections } from '../globals/lampDirections.js';
 
+/**
+ * Create a ring of lamp points with ground height and fixed UVs.
+ *
+ * @param {Object} point Ring center and ground height.
+ * @param {number} radius Ring radius.
+ *
+ * @returns {Array<Object>} Lamp ring points.
+ */
 export function ring(point, radius) {
   const points = /* alloc */ new Array(lampDirections.length);
   let i;

package/src/geometry/createModelGeometry.js

@@ -1,7 +1,17 @@
 import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-
 import { createProgram } from '../materials/createProgram.js';
 
+/**
+ * Create GPU buffers and a material program for a model primitive.
+ *
+ * @param {Object} context Model context tracking materials and resources.
+ * @param {Object} primitive glTF primitive specification.
+ * @param {Object} attributes Prepared geometry attributes.
+ *
+ * @returns {Object} Device, geometry and program.
+ *
+ * @throws {Error} If a textured material has no UV attribute.
+ */
 export function createModelGeometry(context, primitive, attributes) {
   const style = context.materials[primitive.material] || /* alloc */ {
     color: /* alloc */ [1, 1, 1], metallic: 1,

package/src/geometry/createRasterQuadGeometry.js

@@ -4,7 +4,13 @@ import { rasterNormals } from '../globals/rasterNormals.js';
 import { rasterUVs } from '../globals/rasterUVs.js';
 import { rasterIndices } from '../globals/rasterIndices.js';
 
-
+/**
+ * Create GPU geometry for a shared indexed raster quad.
+ *
+ * @param {GPUDevice} device Device owning the buffers.
+ *
+ * @returns {Object} Quad geometry and attributes.
+ */
 export function createGeometry(device) {
   const attributes = /* alloc */ {
     position: /* alloc */ { size: 3, data: /* alloc */ new Float32Array(rasterPositions) },

package/src/geometry/createTreeRing.js

@@ -1,6 +1,13 @@
 import { ringDirections } from '../globals/ringDirections.js';
 
-
+/**
+ * Create a ring of projected tree points around a center.
+ *
+ * @param {Object} point Ring center and ground height.
+ * @param {number} radius Ring radius.
+ *
+ * @returns {Array<Object>} Tree ring points.
+ */
 export function ring(point, radius) {
   const result = /* alloc */ new Array(ringDirections.length);
   let i;

package/src/geometry/crossVector.js

@@ -1,3 +1,11 @@
+/**
+ * Compute the cross product of two three-dimensional vectors.
+ *
+ * @param {ArrayLike<number>} a First vector.
+ * @param {ArrayLike<number>} b Second vector.
+ *
+ * @returns {Array<number>} Cross product.
+ */
 export function cross(a, b) {
   return /* alloc */ [
     a[1] * b[2] - a[2] * b[1],

package/src/geometry/dashValues.js

@@ -1,3 +1,12 @@
+/**
+ * Parse a Leaflet dash array into a validated even-length numeric pattern.
+ *
+ * @param {Object} options Leaflet path options.
+ *
+ * @returns {Array<number>} Dash pattern, or an empty array for a solid line.
+ *
+ * @throws {Error} If a dash value is negative or non-finite.
+ */
 export function dashValues(options) {
   const values = Array.isArray(options.dashArray) ? options.dashArray :
     String(options.dashArray || '').trim().split(/[ ,]+/);

package/src/geometry/dashedSegment.js

@@ -1,5 +1,17 @@
 import { segment } from './segment.js';
 
+/**
+ * Append dashed geometry along a segment while preserving the pattern phase.
+ *
+ * @param {Object} context Line geometry context and dash pattern.
+ * @param {L.Point} a Segment start.
+ * @param {L.Point} b Segment end.
+ * @param {number} length Segment length.
+ * @param {number} distance Distance at the start of the segment.
+ * @param {number} period Dash pattern period.
+ *
+ * @throws {Error} If dash lengths cannot advance at these coordinates.
+ */
 export function dashedSegment(context, a, b, length, distance, period) {
   const dash = context.dash;
   let offset = 0, phase = ((distance % period) + period) % period, index = 0, end, delta, skipped = 0;

package/src/geometry/disk.js

@@ -1,6 +1,15 @@
 import { triangle } from './appendNativeTriangle.js';
 import { diskAt } from './diskAt.js';
 
+/**
+ * Append a triangle fan for a filled elliptical disk.
+ *
+ * @param {Function} point Vertex projection function.
+ * @param {L.Point} center Disk center.
+ * @param {number} radius Horizontal radius.
+ * @param {Array<number>} target Destination vertices.
+ * @param {number} [radiusY] Vertical radius.
+ */
 export function disk(point, center, radius, target, radiusY = radius) {
   if (!(radius > 0) || !(radiusY > 0)) return;
   const count = Math.max(12, Math.min(128, Math.ceil(Math.PI * Math.sqrt(radius))));

package/src/geometry/diskAt.js

@@ -1,5 +1,17 @@
-import { tau } from '../globals/tau.js';
-import { L } from '../globals/L.js';
+import { tau } from '../globals/tau.js';
+import { L } from '../globals/L.js';
+
+/**
+ * Compute a point on an elliptical disk perimeter.
+ *
+ * @param {L.Point} center Disk center.
+ * @param {number} radius Horizontal radius.
+ * @param {number} radiusY Vertical radius.
+ * @param {number} count Perimeter subdivision count.
+ * @param {number} index Perimeter point index.
+ *
+ * @returns {L.Point} Perimeter point.
+ */
 export function diskAt(center, radius, radiusY, count, index) {
   return /* alloc */ new L.Point(center.x + radius * Math.cos(index * tau / count),
     center.y + radiusY * Math.sin(index * tau / count));

package/src/geometry/emitter.js

@@ -1,3 +1,13 @@
+/**
+ * Construct a point on one axis-aligned plane of a light emitter.
+ *
+ * @param {Object} point Projected center and ground height.
+ * @param {number} u First local coordinate.
+ * @param {number} v Second local coordinate.
+ * @param {number} axis Plane axis index.
+ *
+ * @returns {Object} Projected point with ground height and UV coordinates.
+ */
 export function emitter(point, u, v, axis) {
   const r = 0.65;
   return /* alloc */ {

package/src/geometry/fillNativePolygon.js

@@ -1,6 +1,14 @@
 import { triangle } from './appendNativeTriangle.js';
 import { triangulate } from '../triangulation/triangulate.js';
 
+/**
+ * Append fill triangles for a native polygon, respecting pre-triangulated input.
+ *
+ * @param {Object} context Projection, style and fill buffer.
+ * @param {Array<Array<L.Point>>} projected Projected polygon rings.
+ *
+ * @throws {Error} If a pre-triangulated polygon does not have exactly three vertices and no holes.
+ */
 export function fillNativePolygon(context, projected) {
   const { options, fill, point } = context;
   if (options.triangulated) {

package/src/geometry/generateTreeGeometry.js

@@ -1,8 +1,14 @@
-import { triangleContexts } from '../globals/triangleContexts.js';
-
-
-import { addGeneratedTriangle } from './addGeneratedTriangle.js';
-
+import { triangleContexts } from '../globals/triangleContexts.js';
+import { addGeneratedTriangle } from './addGeneratedTriangle.js';
+
+/**
+ * Run a point geometry generator with the current triangle destination context.
+ *
+ * @param {Object} context Destination area geometry.
+ * @param {Function} generator Point geometry generator.
+ * @param {Object} point Projected point.
+ * @param {Object} style Geometry style.
+ */
 export function generateTreeGeometry(context, generator, point, style) {
   triangleContexts.push(context);
   try {

package/src/geometry/indexBridge.js

@@ -1,6 +1,12 @@
-import { bridgesByLayer } from '../weakmaps/bridgesByLayer.js';
-
+import { bridgesByLayer } from '../weakmaps/bridgesByLayer.js';
 
+/**
+ * Index bridge triangles in 64-pixel buckets for elevation lookup.
+ *
+ * @param {L.Layer} layer Terrain layer owning the bridge index.
+ * @param {Array<Array<number>>} pixels Projected vertices including elevation.
+ * @param {Array<Array<number>>} triangles Triangle vertex indices.
+ */
 export function indexBridge(layer, pixels, triangles) {
   const bridgeTriangles = /* alloc */ [];
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;

package/src/geometry/instanceAreaGeometry.js

@@ -1,4 +1,10 @@
-/** Compact repeated features only when reconstructed float32 positions compare equal. */
+/**
+ * Compact repeated features only when reconstructed float32 positions compare equal.
+ *
+ * @param {Object} context Area geometry buffers and feature ranges.
+ *
+ * @returns {Object} Instanced buffers, or the original context if compaction is unsuitable.
+ */
 export function instanceAreaGeometry(context) {
   const { positions, normals, colors, featureFaces } = context;
   if (context.backend.options.nightLight || featureFaces.length < 2) return context;

package/src/geometry/interpolateRoute.js

@@ -1,5 +1,13 @@
-/** Point and unit direction at distance `s` along `points` ([x, z, y?]) with cumulative `lengths`. */
-
+/**
+ * Compute point and unit direction at a distance along a route.
+ *
+ * @param {Array<Array<number>>} points Route points as [x, z, y?].
+ * @param {Array<number>} lengths Cumulative route distances.
+ * @param {number} s Distance along the route.
+ * @param {Object} [target] Object to populate.
+ *
+ * @returns {Object} Position and horizontal direction.
+ */
 export function along(points, lengths, s, target) {
   let i = 1, end = lengths.length - 1;
   let middle;

package/src/geometry/lampPostGeometry.js

@@ -2,8 +2,15 @@ import { parseColor } from "../colors/parseColor.js";
 import { ring } from './createLampRing.js';
 import { lampDirections } from '../globals/lampDirections.js';
 
-/** Schematic support and lamp head; wall-mounted fixtures do not get an invented pole. */
-
+/**
+ * Generate a schematic support and lamp head.
+ *
+ * @param {Object} point Projected position and ground height.
+ * @param {Object} style Lamp height and pole radius.
+ * @param {Function} addTriangle Triangle destination callback.
+ *
+ * @throws {Error} If the pole radius is not finite and positive.
+ */
 export function lampPostGeometry(point, style, addTriangle) {
   const color = parseColor(0x50565a), radius = style.poleRadius;
   if (!Number.isFinite(radius) || radius <= 0) {

package/src/geometry/lightGeometry.js

@@ -2,8 +2,15 @@ import { parseColor } from "../colors/parseColor.js";
 import { quad } from './quad.js';
 import { emitter } from './emitter.js';
 
-/** Three crossed emitter discs; illumination itself is evaluated on receiving surfaces. */
-
+/**
+ * Generate three crossed emitter quads; illumination is evaluated on receiving surfaces.
+ *
+ * @param {Object} point Projected position and ground height.
+ * @param {Object} style Light radius, height and color.
+ * @param {Function} addTriangle Triangle destination callback.
+ *
+ * @throws {Error} If the light radius is not finite and positive.
+ */
 export function lightGeometry(point, style, addTriangle) {
   if (!Number.isFinite(style.lightRadius) || style.lightRadius <= 0) throw /* alloc */ new Error('Invalid light radius');
   const color = parseColor(style.color);

package/src/geometry/line.js

@@ -2,6 +2,13 @@ import { segment } from './segment.js';
 import { lineJoin } from './lineJoin.js';
 import { dashedSegment } from './dashedSegment.js';
 
+/**
+ * Generate solid or dashed stroke geometry for a projected line or ring.
+ *
+ * @param {Object} context Line style and geometry buffers.
+ * @param {Array<L.Point>} points Projected line points.
+ * @param {boolean} closed Whether to connect the last point to the first.
+ */
 export function line(context, points, closed) {
   const { options, width, dash } = context;
   if (!options.stroke || width <= 0 || points.length < 2) return;

package/src/geometry/lineJoin.js

@@ -2,6 +2,15 @@ import { L } from '../globals/L.js';
 import { triangle } from './appendNativeTriangle.js';
 import { disk } from './disk.js';
 
+/**
+ * Append a round, bevel or limited miter join between consecutive line segments.
+ *
+ * @param {Object} context Line style and geometry buffers.
+ * @param {Array<L.Point>} points Projected line points.
+ * @param {number} i Index of the join point.
+ * @param {L.Point} b Next point.
+ * @param {number} length Outgoing segment length.
+ */
 export function lineJoin(context, points, i, b, length) {
   const { options, width, point, stroke } = context;
   const a = points[i], radius = width / 2;

package/src/geometry/markerImageBounds.js

@@ -1,3 +1,12 @@
+/**
+ * Resolve and cache a marker icon or shadow's dimensions and anchor.
+ *
+ * @param {Object} state Native marker state.
+ * @param {string} key Image kind, such as shadow.
+ * @param {HTMLImageElement} image Image providing fallback dimensions.
+ *
+ * @returns {Array<number>} Width, height, anchor x and anchor y.
+ */
 export function markerImageBounds(state, key, image) {
   const options = state.source.options.icon.options;
   const dimensions = options[key === 'shadow' ? 'shadowSize' : 'iconSize'];

package/src/geometry/markerQuadCorners.js

@@ -1,16 +1,22 @@
 import { cameraByLayer } from '../weakmaps/cameraByLayer.js';
 import { rootByLayer } from '../weakmaps/rootByLayer.js';
-
 import { coreMatrixKeys } from '../globals/coreMatrixKeys.js';
 import { markerCameraIconPoint } from '../projections/markerCameraIconPoint.js';
-
 import { localPosition } from '../projections/localPosition.js';
-
 import { transformNativePoint } from '../transforms/transformNativePoint.js';
 import { markerImageBounds } from './markerImageBounds.js';
 import { streamTerrainByMap } from '../weakmaps/streamTerrainByMap.js';
 import { mapElevationOf } from '../terrain/mapElevationOf.js';
 
+/**
+ * Compute local scene corners for a camera-oriented marker image quad.
+ *
+ * @param {Object} state Native marker state and projection context.
+ * @param {string} key Image kind, such as shadow.
+ * @param {HTMLImageElement} image Image providing fallback dimensions.
+ *
+ * @returns {Array<Array<number>>} Four local scene corners.
+ */
 export function markerQuadCorners(state, key, image) {
   const { source, map, backend: layer } = state;
 

package/src/geometry/meshShadowBounds.js

@@ -1,3 +1,12 @@
+/**
+ * Transform and cache a mesh's bounding box for shadow calculations.
+ *
+ * @param {Object} mesh Mesh containing the world-matrix version.
+ * @param {Object} bounds Local bounding box.
+ * @param {ArrayLike<number>} matrix World transformation matrix.
+ *
+ * @returns {Object} Cached transformed minimum and maximum bounds.
+ */
 export function meshShadowBounds(mesh, bounds, matrix) {
   let cached = mesh._shadowBounds;
   if (!cached || cached.version !== mesh._worldMatrixVersion || cached.bounds !== bounds) {

package/src/geometry/nativeGeometry.js

@@ -3,7 +3,15 @@ import { visit } from './visitNativeCoordinates.js';
 import { dashValues } from './dashValues.js';
 import { circleGeometry } from './circleGeometry.js';
 
-/** Leaflet paths become flat triangles; solid strokes retain stationary zoom anchors. */
+/**
+ * Convert a Leaflet path into flat fill and stroke triangles.
+ *
+ * @param {L.Path} source Native path.
+ * @param {L.Map} map Map used to project coordinates.
+ * @param {Function} point Vertex projection function.
+ *
+ * @returns {Object} Fill and stroke vertex arrays.
+ */
 export function nativeGeometry(source, map, point) {
   const fill = /* alloc */ [];
   const stroke = /* alloc */ [];

package/src/geometry/offsetBelowGround.js

@@ -1,3 +1,10 @@
+/**
+ * Offset a 3D point downward by the bridge deck thickness.
+ *
+ * @param {Array<number>} p Input point.
+ *
+ * @returns {Array<number>} Offset point.
+ */
 export function below(p) {
   return /* alloc */ [p[0], p[1] - 1.2, p[2]];
 }

package/src/geometry/polygon.js

@@ -1,6 +1,13 @@
 import { line } from './line.js';
 import { fillNativePolygon } from './fillNativePolygon.js';
 
+/**
+ * Project polygon or line rings and append their fill and stroke geometry.
+ *
+ * @param {Object} context Projection, style and geometry buffers.
+ * @param {Array<Array<L.LatLng>>} rings Geographic rings or lines.
+ * @param {boolean} closed Whether to close and optionally fill the rings.
+ */
 export function polygon(context, rings, closed) {
   const { options, map } = context;
   const projected = /* alloc */ [];

package/src/geometry/quad.js

@@ -1,3 +1,17 @@
+/**
+ * Append a quad as two triangles at a common height.
+ *
+ * @param {Function} addTriangle Triangle destination callback.
+ * @param {Object} color Triangle color.
+ * @param {Object} a First corner.
+ * @param {Object} b Second corner.
+ * @param {Object} c Third corner.
+ * @param {Object} d Fourth corner.
+ * @param {number} height Quad height.
+ * @param {number|Array<number>} nx Normal x component or complete normal vector.
+ * @param {number} ny Normal y component when nx is numeric.
+ * @param {number} nz Normal z component when nx is numeric.
+ */
 export function quad(addTriangle, color, a, b, c, d, height, nx, ny, nz) {
   if (typeof nx !== 'number') {
     addTriangle(a, height, b, height, c, height, ...nx, color);

package/src/geometry/restoreGeometry.js

@@ -1,3 +1,9 @@
+/**
+ * Recreate geometry buffers on a device from retained CPU attributes.
+ *
+ * @param {Object} geometry Geometry and attribute data to restore.
+ * @param {GPUDevice} device Device receiving the buffers.
+ */
 export function restoreGeometry(geometry, device) {
   if (geometry.attributes.index?.data instanceof Uint8Array) {
     geometry.attributes.index.data = /* alloc */ new Uint16Array(geometry.attributes.index.data);