leaflet-city-mapper 0.1.0 → 0.1.1

package/src/mvt/readMvtNumber.js

@@ -1,18 +1,18 @@
-import { readMvtInteger } from './readMvtInteger.js';
-
-/**
- * Read a protobuf varint as a safe JavaScript number.
- *
- * @param {Object} reader MVT byte reader.
- *
- * @returns {number} Decoded integer.
- *
- * @throws {Error} If the integer exceeds the safe numeric range.
- */
-export function readMvtNumber(reader) {
-  const value = readMvtInteger(reader);
-  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw /* alloc */ new Error('MVT integer exceeds safe range');
-  }
-  return Number(value);
-}
+import { readMvtInteger } from './readMvtInteger.js';
+
+/**
+ * Read a protobuf varint as a safe JavaScript number.
+ *
+ * @param {Object} reader MVT byte reader.
+ *
+ * @returns {number} Decoded integer.
+ *
+ * @throws {Error} If the integer exceeds the safe numeric range.
+ */
+export function readMvtNumber(reader) {
+  const value = readMvtInteger(reader);
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw /* alloc */ new Error('MVT integer exceeds safe range');
+  }
+  return Number(value);
+}

package/src/mvt/readMvtNumbers.js

@@ -1,18 +1,18 @@
-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));
-  }
-}
+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,14 +1,14 @@
-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);
-}
+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,29 +1,29 @@
-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;
-}
+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,22 +1,22 @@
-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');
-  }
-}
+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,20 +1,20 @@
-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;
-  }
-}
+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,29 +1,29 @@
-/**
- * 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;
-}
+/**
+ * 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,18 +1,18 @@
-/**
- * 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;
-}
+/**
+ * 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,26 +1,26 @@
-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;
-}
+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,23 +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.
- *
- * @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;
-}
+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/beforeNativeRender.js

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