leaflet-city-mapper 0.1.0 → 0.1.1

package/src/geometry/bridgePaths.js

@@ -1,19 +1,19 @@
-/**
- * Reconstruct ring paths from flattened projected bridge pixels.
- *
- * @param {Array<Array>} rings Original bridge rings.
- * @param {Array<Array<number>>} pixels Flattened projected coordinates.
- *
- * @returns {Array<Array<Object>>} Projected x/y paths.
- */
-export function bridgePaths(rings, pixels) {
-  const paths = /* alloc */ [];
-  let start = 0, ring, path, i;
-  for (ring of rings) {
-    path = /* alloc */ [];
-    for (i = 0; i < ring.length; i++) path.push(/* alloc */ { x: pixels[start + i][0], y: pixels[start + i][1] });
-    paths.push(path);
-    start += ring.length;
-  }
-  return paths;
-}
+/**
+ * Reconstruct ring paths from flattened projected bridge pixels.
+ *
+ * @param {Array<Array>} rings Original bridge rings.
+ * @param {Array<Array<number>>} pixels Flattened projected coordinates.
+ *
+ * @returns {Array<Array<Object>>} Projected x/y paths.
+ */
+export function bridgePaths(rings, pixels) {
+  const paths = /* alloc */ [];
+  let start = 0, ring, path, i;
+  for (ring of rings) {
+    path = /* alloc */ [];
+    for (i = 0; i < ring.length; i++) path.push(/* alloc */ { x: pixels[start + i][0], y: pixels[start + i][1] });
+    paths.push(path);
+    start += ring.length;
+  }
+  return paths;
+}

package/src/geometry/bridgePolygon.js

@@ -1,37 +1,37 @@
-import { triangulate } from '../triangulation/triangulate.js';
-import { local } from '../projections/projectBridgePoint.js';
-import { bridgePaths } from './bridgePaths.js';
-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 */ [];
-  let ring, path, lng, lat, z, p, coordinate, paths, contour, holes, triangles;
-  for (ring of polygon) {
-    path = ring.slice(0, -1);
-    if (path.length >= 3) rings.push(path);
-  }
-  if (!rings.length) return;
-  const pixels = /* alloc */ [], points = /* alloc */ [];
-  for (ring of rings) for ([lng, lat, z] of ring) {
-    p = map.project(/* alloc */ [lat, lng], zoom);
-    pixels.push(/* alloc */ [p.x, p.y, z]);
-  }
-  for (ring of rings) for (coordinate of ring) points.push(local(coordinate, crs, origin, metres, base));
-  try {
-    paths = bridgePaths(rings, pixels);
-    [contour, ...holes] = paths;
-    triangles = triangulate(contour, holes);
-  } catch { return; }
-  indexBridge(layer, pixels, triangles);
-  bridgeFaces(context, points, triangles);
-  bridgeSides(context, points, rings);
-}
+import { triangulate } from '../triangulation/triangulate.js';
+import { local } from '../projections/projectBridgePoint.js';
+import { bridgePaths } from './bridgePaths.js';
+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 */ [];
+  let ring, path, lng, lat, z, p, coordinate, paths, contour, holes, triangles;
+  for (ring of polygon) {
+    path = ring.slice(0, -1);
+    if (path.length >= 3) rings.push(path);
+  }
+  if (!rings.length) return;
+  const pixels = /* alloc */ [], points = /* alloc */ [];
+  for (ring of rings) for ([lng, lat, z] of ring) {
+    p = map.project(/* alloc */ [lat, lng], zoom);
+    pixels.push(/* alloc */ [p.x, p.y, z]);
+  }
+  for (ring of rings) for (coordinate of ring) points.push(local(coordinate, crs, origin, metres, base));
+  try {
+    paths = bridgePaths(rings, pixels);
+    [contour, ...holes] = paths;
+    triangles = triangulate(contour, holes);
+  } catch { return; }
+  indexBridge(layer, pixels, triangles);
+  bridgeFaces(context, points, triangles);
+  bridgeSides(context, points, rings);
+}

package/src/geometry/bridgeSides.js

@@ -1,18 +1,18 @@
-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) {
-    for (i = 0; i < ring.length; i++) {
-      bridgeEdge(context, points[start + i], points[start + (i + 1) % ring.length]);
-    }
-    start += ring.length;
-  }
-}
+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) {
+    for (i = 0; i < ring.length; i++) {
+      bridgeEdge(context, points[start + i], points[start + (i + 1) % ring.length]);
+    }
+    start += ring.length;
+  }
+}

package/src/geometry/buildProjectedPoint.js

@@ -1,32 +1,32 @@
-import { generateTreeGeometry } from './generateTreeGeometry.js';
-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) {
-    if (!Number.isFinite(style.lightFlux) || style.lightFlux <= 0) throw /* alloc */ new Error('Invalid light flux');
-    if (style.poleRadius > 0 && !context.supports.has(support)) {
-      generateTreeGeometry(context, lampPostGeometry, projected, style);
-      context.supports.add(support);
-    }
-    generateTreeGeometry(context, lightGeometry, projected, style);
-    context.lights.push(/* alloc */ {
-      position: /* alloc */ [projected.x, projected.ground + top, -projected.y],
-      radius: Math.hypot(top, style.lightRadius), color: /* alloc */ [baseColor.r, baseColor.g, baseColor.b],
-      flux: style.lightFlux,
-    });
-  } else generateTreeGeometry(context, treeGeometry, projected, style);
-}
+import { generateTreeGeometry } from './generateTreeGeometry.js';
+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) {
+    if (!Number.isFinite(style.lightFlux) || style.lightFlux <= 0) throw /* alloc */ new Error('Invalid light flux');
+    if (style.poleRadius > 0 && !context.supports.has(support)) {
+      generateTreeGeometry(context, lampPostGeometry, projected, style);
+      context.supports.add(support);
+    }
+    generateTreeGeometry(context, lightGeometry, projected, style);
+    context.lights.push(/* alloc */ {
+      position: /* alloc */ [projected.x, projected.ground + top, -projected.y],
+      radius: Math.hypot(top, style.lightRadius), color: /* alloc */ [baseColor.r, baseColor.g, baseColor.b],
+      flux: style.lightFlux,
+    });
+  } else generateTreeGeometry(context, treeGeometry, projected, style);
+}

package/src/geometry/buildProjectedPolygon.js

@@ -1,34 +1,34 @@
-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;
-  for (path of paths) for (point of path) points.push(point);
-  for ([a, b, c] of triangulate(paths[0], paths.slice(1))) {
-    addTriangle(context, points[a], top, points[b], top, points[c], top, 0, 1, 0, baseColor);
-    if (bottom > 0) addTriangle(context, points[a], bottom, points[b], bottom, points[c], bottom, 0, -1, 0, baseColor);
-  }
-  for (index = 0; index < paths.length; index++) {
-    path = paths[index];
-    sign = isClockWise(path) === (index === 0) ? -1 : 1;
-    for (i = 0; i < path.length; i++) {
-      a = path[i], b = path[(i + 1) % path.length];
-      length = Math.hypot(b.x - a.x, b.y - a.y);
-      if (!length) continue;
-      nx = sign * (b.y - a.y) / length, nz = sign * (b.x - a.x) / length;
-      addTriangle(context, a, bottom, b, bottom, b, top, nx, 0, nz, baseColor);
-      addTriangle(context, a, bottom, b, top, a, top, nx, 0, nz, baseColor);
-    }
-  }
-}
+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;
+  for (path of paths) for (point of path) points.push(point);
+  for ([a, b, c] of triangulate(paths[0], paths.slice(1))) {
+    addTriangle(context, points[a], top, points[b], top, points[c], top, 0, 1, 0, baseColor);
+    if (bottom > 0) addTriangle(context, points[a], bottom, points[b], bottom, points[c], bottom, 0, -1, 0, baseColor);
+  }
+  for (index = 0; index < paths.length; index++) {
+    path = paths[index];
+    sign = isClockWise(path) === (index === 0) ? -1 : 1;
+    for (i = 0; i < path.length; i++) {
+      a = path[i], b = path[(i + 1) % path.length];
+      length = Math.hypot(b.x - a.x, b.y - a.y);
+      if (!length) continue;
+      nx = sign * (b.y - a.y) / length, nz = sign * (b.x - a.x) / length;
+      addTriangle(context, a, bottom, b, bottom, b, top, nx, 0, nz, baseColor);
+      addTriangle(context, a, bottom, b, top, a, top, nx, 0, nz, baseColor);
+    }
+  }
+}

package/src/geometry/circleAt.js

@@ -1,20 +1,20 @@
-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),
-    center.y + Math.max(0, radiusY + offset) * Math.sin(angle));
-}
+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),
+    center.y + Math.max(0, radiusY + offset) * Math.sin(angle));
+}

package/src/geometry/circleGeometry.js

@@ -1,41 +1,41 @@
-import { L } from '../globals/L.js';
-import { disk } from './disk.js';
-import { circleAt } from './circleAt.js';
-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());
-  let radius = source.getRadius(), radiusY = radius, index, i;
-  if (source instanceof L.Circle) {
-    projectNativePath(source);
-    const projected = source._point.add(map.getPixelOrigin());
-    center.x = projected.x;
-    center.y = projected.y;
-    radius = source._pxRadius ?? source._radius;
-    radiusY = source._pxRadiusY ?? source._radiusY ?? radius;
-  }
-  if (options.fill) disk(point, center, radius, fill, radiusY);
-  const count = Math.max(12, Math.min(128, Math.ceil(Math.PI * Math.sqrt(Math.max(radius, radiusY)))));
-  if (dash.length) {
-    const points = /* alloc */ [];
-    for (index = 0; index < count; index++) points.push(circleAt(center, radius, radiusY, count, index));
-    line(context, points, true);
-  }
-  else if (options.stroke && width > 0) {
-    for (i = 0; i < count; i++) {
-      triangle(point, stroke, circleAt(center, radius, radiusY, count, i, width / 2),
-        circleAt(center, radius, radiusY, count, i, -width / 2), circleAt(center, radius, radiusY, count, i + 1, width / 2));
-      triangle(point, stroke, circleAt(center, radius, radiusY, count, i + 1, width / 2),
-        circleAt(center, radius, radiusY, count, i, -width / 2), circleAt(center, radius, radiusY, count, i + 1, -width / 2));
-    }
-  }
-}
+import { L } from '../globals/L.js';
+import { disk } from './disk.js';
+import { circleAt } from './circleAt.js';
+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());
+  let radius = source.getRadius(), radiusY = radius, index, i;
+  if (source instanceof L.Circle) {
+    projectNativePath(source);
+    const projected = source._point.add(map.getPixelOrigin());
+    center.x = projected.x;
+    center.y = projected.y;
+    radius = source._pxRadius ?? source._radius;
+    radiusY = source._pxRadiusY ?? source._radiusY ?? radius;
+  }
+  if (options.fill) disk(point, center, radius, fill, radiusY);
+  const count = Math.max(12, Math.min(128, Math.ceil(Math.PI * Math.sqrt(Math.max(radius, radiusY)))));
+  if (dash.length) {
+    const points = /* alloc */ [];
+    for (index = 0; index < count; index++) points.push(circleAt(center, radius, radiusY, count, index));
+    line(context, points, true);
+  }
+  else if (options.stroke && width > 0) {
+    for (i = 0; i < count; i++) {
+      triangle(point, stroke, circleAt(center, radius, radiusY, count, i, width / 2),
+        circleAt(center, radius, radiusY, count, i, -width / 2), circleAt(center, radius, radiusY, count, i + 1, width / 2));
+      triangle(point, stroke, circleAt(center, radius, radiusY, count, i + 1, width / 2),
+        circleAt(center, radius, radiusY, count, i, -width / 2), circleAt(center, radius, radiusY, count, i + 1, -width / 2));
+    }
+  }
+}

package/src/geometry/createModelGeometry.js

@@ -1,44 +1,44 @@
-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,
-  };
-  if ((style.baseTexture || style.metalTexture || style.emissiveTexture || style.occlusionTexture) && !attributes.uv) {
-    throw /* alloc */ new Error('Textured model mesh requires UV coordinates');
-  }
-  const program = createProgram(context.backend, style);
-  context.resources.push(program);
-  const device = rendererByLayer.get(context.backend).device;
-  let name, attribute;
-  for ([name, attribute] of Object.entries(attributes)) {
-    attribute.size ||= 1;
-    attribute.count = attribute.data.length / attribute.size;
-    attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
-    attribute.buffer = device.createBuffer(/* alloc */ {
-      size: Math.max(4, attribute.data.byteLength),
-      usage: name === 'index'
-        ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
-        : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-    });
-    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-  }
-  const geometry = /* alloc */ {
-    device, attributes,
-    drawRange: /* alloc */ { start: 0, count: attributes.index?.count || attributes.position.count },
-  };
-  context.resources.push(geometry);
-  return /* alloc */ { device, geometry, program };
-}
+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,
+  };
+  if ((style.baseTexture || style.metalTexture || style.emissiveTexture || style.occlusionTexture) && !attributes.uv) {
+    throw /* alloc */ new Error('Textured model mesh requires UV coordinates');
+  }
+  const program = createProgram(context.backend, style);
+  context.resources.push(program);
+  const device = rendererByLayer.get(context.backend).device;
+  let name, attribute;
+  for ([name, attribute] of Object.entries(attributes)) {
+    attribute.size ||= 1;
+    attribute.count = attribute.data.length / attribute.size;
+    attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
+    attribute.buffer = device.createBuffer(/* alloc */ {
+      size: Math.max(4, attribute.data.byteLength),
+      usage: name === 'index'
+        ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+        : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+  }
+  const geometry = /* alloc */ {
+    device, attributes,
+    drawRange: /* alloc */ { start: 0, count: attributes.index?.count || attributes.position.count },
+  };
+  context.resources.push(geometry);
+  return /* alloc */ { device, geometry, program };
+}

package/src/geometry/crossVector.js

@@ -1,15 +1,15 @@
-/**
- * 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],
-    a[2] * b[0] - a[0] * b[2],
-    a[0] * b[1] - a[1] * b[0]
-  ];
-}
+/**
+ * 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],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}

package/src/geometry/dashValues.js

@@ -1,23 +1,23 @@
-/**
- * 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(/[ ,]+/);
-  const dash = /* alloc */ [];
-  let value, allZero = true;
-  for (value of values) dash.push(Number(value));
-  for (value of dash) {
-    if (!Number.isFinite(value) || value < 0) throw /* alloc */ new Error('Invalid Leaflet dashArray');
-    if (value !== 0) allZero = false;
-  }
-  if (allZero) dash.length = 0;
-  if (dash.length % 2) dash.push(...dash);
-  return dash;
-}
+/**
+ * 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(/[ ,]+/);
+  const dash = /* alloc */ [];
+  let value, allZero = true;
+  for (value of values) dash.push(Number(value));
+  for (value of dash) {
+    if (!Number.isFinite(value) || value < 0) throw /* alloc */ new Error('Invalid Leaflet dashArray');
+    if (value !== 0) allZero = false;
+  }
+  if (allZero) dash.length = 0;
+  if (dash.length % 2) dash.push(...dash);
+  return dash;
+}

package/src/geometry/dashedSegment.js

@@ -1,33 +1,33 @@
-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;
-  while (index < dash.length - 1 && phase >= dash[index]) phase -= dash[index++];
-  let remaining = Math.max(0, dash[index] - phase);
-  while (offset < length) {
-    end = Math.min(length, offset + remaining);
-    if (end > offset && index % 2 === 0) {
-      delta = b.subtract(a).divideBy(length);
-      segment(context, a.add(delta.multiplyBy(offset)), a.add(delta.multiplyBy(end)), true, true);
-    }
-    if (end <= offset) {
-      if (++skipped >= dash.length) throw /* alloc */ new Error('Leaflet dashArray is too small for these coordinates');
-    } else skipped = 0;
-    offset = end;
-    index = (index + 1) % dash.length;
-    remaining = dash[index];
-  }
-}
+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;
+  while (index < dash.length - 1 && phase >= dash[index]) phase -= dash[index++];
+  let remaining = Math.max(0, dash[index] - phase);
+  while (offset < length) {
+    end = Math.min(length, offset + remaining);
+    if (end > offset && index % 2 === 0) {
+      delta = b.subtract(a).divideBy(length);
+      segment(context, a.add(delta.multiplyBy(offset)), a.add(delta.multiplyBy(end)), true, true);
+    }
+    if (end <= offset) {
+      if (++skipped >= dash.length) throw /* alloc */ new Error('Leaflet dashArray is too small for these coordinates');
+    } else skipped = 0;
+    offset = end;
+    index = (index + 1) % dash.length;
+    remaining = dash[index];
+  }
+}