@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-I5IGB56C.js

@@ -0,0 +1,255 @@
+// src/map/geo.ts
+import { feature, neighbors } from "topojson-client";
+import { geoBounds, geoArea } from "d3-geo";
+var fold = (s) => s.normalize("NFD").replace(/\p{Diacritic}/gu, "").toLowerCase().trim();
+function geomObject(topo) {
+  const key = Object.keys(topo.objects)[0];
+  return topo.objects[key];
+}
+function featureIndex(topo) {
+  const idx = /* @__PURE__ */ new Map();
+  for (const g of geomObject(topo).geometries) {
+    const f = fold(g.properties.name);
+    if (!idx.has(f)) idx.set(f, { id: g.id, name: g.properties.name });
+  }
+  for (const g of geomObject(topo).geometries) {
+    const idKey = g.id.toLowerCase();
+    if (!idx.has(idKey)) idx.set(idKey, { id: g.id, name: g.properties.name });
+  }
+  return idx;
+}
+var adjacencyCache = /* @__PURE__ */ new WeakMap();
+function buildAdjacency(topo) {
+  const cached = adjacencyCache.get(topo);
+  if (cached) return cached;
+  const geometries = geomObject(topo).geometries;
+  const nb = neighbors(geometries);
+  const sets = /* @__PURE__ */ new Map();
+  geometries.forEach((g, i) => {
+    if (!g.type || g.type === "null") return;
+    let set = sets.get(g.id);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      sets.set(g.id, set);
+    }
+    for (const j of nb[i] ?? []) {
+      const nid = geometries[j]?.id;
+      if (nid && nid !== g.id) set.add(nid);
+    }
+  });
+  const out = /* @__PURE__ */ new Map();
+  for (const [iso, set] of sets) out.set(iso, [...set].sort());
+  adjacencyCache.set(topo, out);
+  return out;
+}
+function decodeFeatures(topo) {
+  return geomObject(topo).geometries.map((g) => {
+    const f = feature(topo, g);
+    return {
+      type: "Feature",
+      id: g.id,
+      properties: g.properties,
+      geometry: f.geometry
+    };
+  });
+}
+function pointInRing(lon, lat, ring) {
+  let inside = false;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const xi = ring[i][0];
+    const yi = ring[i][1];
+    const xj = ring[j][0];
+    const yj = ring[j][1];
+    const intersect = yi > lat !== yj > lat && lon < (xj - xi) * (lat - yi) / (yj - yi) + xi;
+    if (intersect) inside = !inside;
+  }
+  return inside;
+}
+var EDGE_EPS = 1e-9;
+function pointOnRingEdge(lon, lat, ring) {
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const xi = ring[i][0];
+    const yi = ring[i][1];
+    const xj = ring[j][0];
+    const yj = ring[j][1];
+    if (lon < Math.min(xi, xj) - EDGE_EPS || lon > Math.max(xi, xj) + EDGE_EPS)
+      continue;
+    if (lat < Math.min(yi, yj) - EDGE_EPS || lat > Math.max(yi, yj) + EDGE_EPS)
+      continue;
+    const cross = (xj - xi) * (lat - yi) - (yj - yi) * (lon - xi);
+    if (Math.abs(cross) <= EDGE_EPS) return true;
+  }
+  return false;
+}
+function pointInGeometry(geometry, lon, lat) {
+  const g = geometry;
+  if (!g) return false;
+  const polys = g.type === "Polygon" ? [g.coordinates] : g.type === "MultiPolygon" ? g.coordinates : [];
+  for (const rings of polys) {
+    if (!rings.length) continue;
+    if (pointOnRingEdge(lon, lat, rings[0])) return true;
+    if (!pointInRing(lon, lat, rings[0])) continue;
+    let inHole = false;
+    for (let h = 1; h < rings.length; h++) {
+      if (pointInRing(lon, lat, rings[h]) && !pointOnRingEdge(lon, lat, rings[h])) {
+        inHole = true;
+        break;
+      }
+    }
+    if (!inHole) return true;
+  }
+  return false;
+}
+function regionAt(lonLat, countries, states) {
+  const lon = lonLat[0];
+  const lat = lonLat[1];
+  let country = null;
+  for (const f of countries) {
+    if (pointInGeometry(f.geometry, lon, lat)) {
+      country = { iso: f.id, name: f.properties.name };
+      break;
+    }
+  }
+  let state = null;
+  if (country?.iso === "US" && states) {
+    for (const f of states) {
+      if (pointInGeometry(f.geometry, lon, lat)) {
+        state = { iso: f.id, name: f.properties.name };
+        break;
+      }
+    }
+  }
+  return { country, state };
+}
+function featureBbox(topo, geomId) {
+  const geom = geomObject(topo).geometries.find((g) => g.id === geomId);
+  if (!geom) return null;
+  const gj = feature(topo, geom);
+  const b = geoBounds(gj);
+  if (!b || !Number.isFinite(b[0][0])) return null;
+  return [
+    [b[0][0], b[0][1]],
+    [b[1][0], b[1][1]]
+  ];
+}
+var DETACH_GAP_DEG = 10;
+var DETACH_AREA_FRAC = 0.25;
+function explodePolygons(gj) {
+  const g = gj.geometry ?? gj;
+  const t = g.type;
+  const coords = g.coordinates;
+  if (t === "Polygon") {
+    return [
+      { type: "Feature", geometry: { type: "Polygon", coordinates: coords } }
+    ];
+  }
+  if (t === "MultiPolygon") {
+    return coords.map((rings) => ({
+      type: "Feature",
+      geometry: { type: "Polygon", coordinates: rings }
+    }));
+  }
+  return [];
+}
+function bboxGap(a, b) {
+  const lonGap = Math.max(0, a[0][0] - b[1][0], b[0][0] - a[1][0]);
+  const latGap = Math.max(0, a[0][1] - b[1][1], b[0][1] - a[1][1]);
+  return Math.max(lonGap, latGap);
+}
+function featureBboxPrimary(topo, geomId) {
+  const geom = geomObject(topo).geometries.find((g) => g.id === geomId);
+  if (!geom) return null;
+  const gj = feature(topo, geom);
+  const parts = explodePolygons(gj);
+  if (parts.length <= 1) return featureBbox(topo, geomId);
+  const polys = parts.map((p) => {
+    const b = geoBounds(p);
+    if (!b || !Number.isFinite(b[0][0])) return null;
+    const wraps = b[1][0] < b[0][0];
+    const bbox = [
+      [b[0][0], b[0][1]],
+      [b[1][0], b[1][1]]
+    ];
+    return { bbox, area: geoArea(p), wraps };
+  }).filter(
+    (p) => p !== null
+  );
+  if (polys.length <= 1 || polys.some((p) => p.wraps))
+    return featureBbox(topo, geomId);
+  const maxArea = Math.max(...polys.map((p) => p.area));
+  const anchor = polys.find((p) => p.area === maxArea);
+  const cluster = [
+    [anchor.bbox[0][0], anchor.bbox[0][1]],
+    [anchor.bbox[1][0], anchor.bbox[1][1]]
+  ];
+  const remaining = polys.filter((p) => p !== anchor);
+  let added = true;
+  while (added) {
+    added = false;
+    for (let i = remaining.length - 1; i >= 0; i--) {
+      const p = remaining[i];
+      const near = bboxGap(p.bbox, cluster) <= DETACH_GAP_DEG;
+      const large = p.area >= DETACH_AREA_FRAC * maxArea;
+      if (near || large) {
+        cluster[0][0] = Math.min(cluster[0][0], p.bbox[0][0]);
+        cluster[0][1] = Math.min(cluster[0][1], p.bbox[0][1]);
+        cluster[1][0] = Math.max(cluster[1][0], p.bbox[1][0]);
+        cluster[1][1] = Math.max(cluster[1][1], p.bbox[1][1]);
+        remaining.splice(i, 1);
+        added = true;
+      }
+    }
+  }
+  return cluster;
+}
+function unionExtent(boxes, points) {
+  const lats = [];
+  const lons = [];
+  for (const b of boxes) {
+    lats.push(b[0][1], b[1][1]);
+    lons.push(b[0][0], b[1][0]);
+  }
+  for (const [lon, lat] of points) {
+    lons.push(lon);
+    lats.push(lat);
+  }
+  if (!lats.length) return null;
+  const south = Math.min(...lats);
+  const north = Math.max(...lats);
+  const { west, east } = unionLongitudes(lons);
+  return [
+    [west, south],
+    [east, north]
+  ];
+}
+function unionLongitudes(lons) {
+  const pts = [...new Set(lons)].sort((a, b) => a - b);
+  if (pts.length === 1) return { west: pts[0], east: pts[0] };
+  let maxGap = -1;
+  let gapIdx = -1;
+  for (let i = 1; i < pts.length; i++) {
+    const g = pts[i] - pts[i - 1];
+    if (g > maxGap) {
+      maxGap = g;
+      gapIdx = i;
+    }
+  }
+  const wrapGap = pts[0] + 360 - pts[pts.length - 1];
+  if (wrapGap >= maxGap) {
+    return { west: pts[0], east: pts[pts.length - 1] };
+  }
+  return { west: pts[gapIdx], east: pts[gapIdx - 1] + 360 };
+}
+
+export {
+  fold,
+  featureIndex,
+  buildAdjacency,
+  decodeFeatures,
+  pointInGeometry,
+  regionAt,
+  featureBbox,
+  featureBboxPrimary,
+  unionExtent
+};
+//# sourceMappingURL=chunk-I5IGB56C.js.map