@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-Z5CGSFJB.js

@@ -0,0 +1,647 @@
+import {
+  layoutMap,
+  mapLegendConfig,
+  mapLegendGroups,
+  parsePathRings
+} from "./chunk-IPWPWM6R.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-PWIHZ6NJ.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y
+} from "./chunk-A4GOY3PE.js";
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  measureText
+} from "./chunk-WCT3NYCV.js";
+import {
+  mix
+} from "./chunk-P6T66CCZ.js";
+
+// src/map/renderer.ts
+import * as d3Selection from "d3-selection";
+var LABEL_FONT = 11;
+function pointInRing(px, py, ring) {
+  let inside = false;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const [xi, yi] = ring[i];
+    const [xj, yj] = ring[j];
+    if (yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi)
+      inside = !inside;
+  }
+  return inside;
+}
+function ringToPath(ring) {
+  let d = "";
+  for (let i = 0; i < ring.length; i++)
+    d += (i ? "L" : "M") + ring[i][0] + "," + ring[i][1];
+  return d + "Z";
+}
+function polylineToPath(pts) {
+  let d = "";
+  for (let i = 0; i < pts.length; i++)
+    d += (i ? "L" : "M") + pts[i][0] + "," + pts[i][1];
+  return d;
+}
+function ringToCoastPaths(ring, frame) {
+  if (!frame) return [ringToPath(ring)];
+  const n = ring.length;
+  const eps = 0.75;
+  const onL = (x) => Math.abs(x) <= eps;
+  const onR = (x) => Math.abs(x - frame.w) <= eps;
+  const onT = (y) => Math.abs(y) <= eps;
+  const onB = (y) => Math.abs(y - frame.h) <= eps;
+  const isFrameEdge = (a, b) => onL(a[0]) && onL(b[0]) || onR(a[0]) && onR(b[0]) || onT(a[1]) && onT(b[1]) || onB(a[1]) && onB(b[1]);
+  let firstBreak = -1;
+  for (let i = 0; i < n; i++)
+    if (isFrameEdge(ring[i], ring[(i + 1) % n])) {
+      firstBreak = i;
+      break;
+    }
+  if (firstBreak === -1) return [ringToPath(ring)];
+  const paths = [];
+  let cur = [];
+  const start = (firstBreak + 1) % n;
+  for (let k = 0; k < n; k++) {
+    const i = (start + k) % n;
+    const a = ring[i];
+    const b = ring[(i + 1) % n];
+    if (isFrameEdge(a, b)) {
+      if (cur.length >= 2) paths.push(polylineToPath(cur));
+      cur = [];
+      continue;
+    }
+    if (cur.length === 0) cur.push(a);
+    cur.push(b);
+  }
+  if (cur.length >= 2) paths.push(polylineToPath(cur));
+  return paths;
+}
+function coastlineOuterRings(regions, minExtent, frame) {
+  const paths = [];
+  for (const r of regions) {
+    const rings = r.rings ?? parsePathRings(r.d);
+    for (let i = 0; i < rings.length; i++) {
+      const ring = rings[i];
+      if (ring.length < 3) continue;
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (const [x, y] of ring) {
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+      }
+      if (Math.max(maxX - minX, maxY - minY) < minExtent) continue;
+      const [fx, fy] = ring[0];
+      let depth = 0;
+      for (let j = 0; j < rings.length; j++)
+        if (j !== i && pointInRing(fx, fy, rings[j])) depth++;
+      if (depth % 2 === 1) continue;
+      paths.push(...ringToCoastPaths(ring, frame));
+    }
+  }
+  return paths;
+}
+function appendWaterLines(g, defs, coastId, outerRings, style, flatWater) {
+  const d = outerRings.join(" ");
+  if (!d) return;
+  defs.append("path").attr("id", coastId).attr("d", d).attr("fill", "none");
+  const ref = `#${coastId}`;
+  const linesOuterFirst = [...style.lines].sort((a, b) => b.d - a.d);
+  for (const line of linesOuterFirst) {
+    g.append("use").attr("href", ref).attr("stroke", style.color).attr("stroke-width", 2 * (line.d + line.thickness)).attr("stroke-opacity", line.opacity).attr("stroke-linejoin", "round").attr("stroke-linecap", "round");
+    g.append("use").attr("href", ref).attr("stroke", flatWater).attr("stroke-width", 2 * line.d).attr("stroke-linejoin", "round").attr("stroke-linecap", "round");
+  }
+}
+var mapInstanceCounter = 0;
+function renderMap(container, resolved, data, palette, isDark, onClickItem, exportDims, activeGroupOverride) {
+  d3Selection.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  const width = exportDims?.width ?? container.clientWidth;
+  const height = exportDims?.height ?? container.clientHeight;
+  if (width <= 0 || height <= 0) return;
+  const layout = layoutMap(
+    resolved,
+    data,
+    { width, height },
+    {
+      palette,
+      isDark,
+      // Export-only: forward the contain-fit request from mapExportDimensions so a
+      // clamped/floored (off-aspect) export canvas letterboxes instead of
+      // stretch-distorting. The in-app preview pane passes no exportDims → unset →
+      // keeps the global stretch-fill.
+      preferContain: exportDims?.preferContain ?? false,
+      // Reserve the legend band for the mode actually drawn below (export shows
+      // only the active group; preview keeps the inactive pills).
+      legendMode: exportDims ? "export" : "preview",
+      ...activeGroupOverride !== void 0 && {
+        activeGroup: activeGroupOverride
+      }
+    }
+  );
+  const svg = d3Selection.select(container).append("svg").attr("width", width).attr("height", height).attr("viewBox", `0 0 ${width} ${height}`).attr("preserveAspectRatio", "xMidYMin meet").attr("xmlns", "http://www.w3.org/2000/svg").style("font-family", FONT_FAMILY).style("background", layout.background);
+  svg.append("rect").attr("width", width).attr("height", height).attr("fill", layout.background);
+  const defs = svg.append("defs");
+  const uid = mapInstanceCounter++;
+  const nid = (base) => `${base}__m${uid}`;
+  const arrowSize = (w) => Math.min(15, 7 + w * 0.95);
+  const haloColor = palette.bg;
+  const gRegions = svg.append("g").attr("class", "dgmo-map-regions");
+  const drawRegion = (g, r, strokeWidth) => {
+    const p = g.append("path").attr("d", r.d).attr("fill", r.fill).attr("stroke", r.stroke).attr("stroke-width", strokeWidth);
+    if (r.label) p.attr("data-region-name", r.label);
+    if (r.id && r.id !== "lake") p.attr("data-iso", r.id);
+    if (r.labelX !== void 0 && r.labelY !== void 0) {
+      p.attr("data-label-x", r.labelX).attr("data-label-y", r.labelY);
+    }
+    if (r.layer !== "base") {
+      p.classed("dgmo-map-region", true).attr("data-region", r.id);
+      if (r.value !== void 0) p.attr("data-value", r.value);
+      if (r.tags) {
+        for (const [group, value] of Object.entries(r.tags)) {
+          p.attr(`data-tag-${group.toLowerCase()}`, value.toLowerCase());
+        }
+      }
+    }
+    if (r.lineNumber >= 0) {
+      p.attr("data-line-number", r.lineNumber);
+      if (onClickItem) {
+        p.style("cursor", "pointer").on(
+          "click",
+          () => onClickItem(r.lineNumber)
+        );
+      }
+    }
+  };
+  for (const r of layout.regions) drawRegion(gRegions, r, 0.5);
+  if (layout.relief.length && layout.reliefHatch) {
+    const h = layout.reliefHatch;
+    const rangeClipId = nid("dgmo-relief-clip");
+    const landClipId = nid("dgmo-relief-land");
+    const rangeClip = defs.append("clipPath").attr("id", rangeClipId);
+    for (const s of layout.relief) rangeClip.append("path").attr("d", s.d);
+    const landClip = defs.append("clipPath").attr("id", landClipId);
+    for (const r of layout.regions)
+      if (r.id !== "lake") landClip.append("path").attr("d", r.d);
+    const gRelief = svg.append("g").attr("clip-path", `url(#${landClipId})`).style("pointer-events", "none").append("g").attr("class", "dgmo-map-relief").attr("clip-path", `url(#${rangeClipId})`).attr("stroke", h.color).attr("stroke-width", h.width).attr("vector-effect", "non-scaling-stroke");
+    for (let y = h.spacing; y < height; y += h.spacing) {
+      gRelief.append("line").attr("x1", 0).attr("y1", y).attr("x2", width).attr("y2", y);
+    }
+  }
+  if (layout.coastlineStyle) {
+    const cs = layout.coastlineStyle;
+    const maskId = nid("dgmo-map-water-mask");
+    const mask = defs.append("mask").attr("id", maskId).attr("maskUnits", "userSpaceOnUse").attr("x", 0).attr("y", 0).attr("width", width).attr("height", height);
+    mask.append("rect").attr("x", 0).attr("y", 0).attr("width", width).attr("height", height).attr("fill", "white");
+    const landD = layout.regions.filter((r) => r.id !== "lake").map((r) => r.d).join(" ");
+    const lakeD = layout.regions.filter((r) => r.id === "lake").map((r) => r.d).join(" ");
+    if (landD) mask.append("path").attr("d", landD).attr("fill", "black");
+    if (lakeD) mask.append("path").attr("d", lakeD).attr("fill", "white");
+    if (layout.insets.length) {
+      const reach = Math.max(0, ...cs.lines.map((l) => l.d + l.thickness));
+      for (const box of layout.insets) {
+        const d = box.points.map((p, i) => `${i ? "L" : "M"}${p[0]},${p[1]}`).join("") + "Z";
+        mask.append("path").attr("d", d).attr("fill", "black").attr("stroke", "black").attr("stroke-width", 2 * reach).attr("stroke-linejoin", "round");
+      }
+    }
+    const gWater = svg.append("g").attr("class", "dgmo-map-water-lines").attr("fill", "none").style("pointer-events", "none").attr("mask", `url(#${maskId})`);
+    appendWaterLines(
+      gWater,
+      defs,
+      nid("dgmo-map-coast"),
+      // Pass the canvas frame so edges collinear with it (the antimeridian on a
+      // world map, regional clipExtent cuts) don't get ringed as fake coast —
+      // land runs cleanly to the render-area edge.
+      coastlineOuterRings(layout.regions, cs.minExtent, {
+        w: width,
+        h: height
+      }),
+      cs,
+      layout.background
+    );
+    const byStroke = /* @__PURE__ */ new Map();
+    for (const r of layout.regions) {
+      const arr = byStroke.get(r.stroke);
+      if (arr) arr.push(r.d);
+      else byStroke.set(r.stroke, [r.d]);
+    }
+    for (const [stroke, ds] of byStroke)
+      gWater.append("path").attr("d", ds.join(" ")).attr("stroke", stroke).attr("stroke-width", 0.5).attr("stroke-linejoin", "round");
+  }
+  if (layout.rivers.length) {
+    const gRivers = svg.append("g").attr("class", "dgmo-map-rivers").attr("fill", "none").style("pointer-events", "none");
+    for (const r of layout.rivers) {
+      gRivers.append("path").attr("d", r.d).attr("stroke", r.color).attr("stroke-width", r.width).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+    }
+  }
+  if (layout.cityDots.length) {
+    const gCities = svg.append("g").attr("class", "dgmo-map-cities").attr("fill", palette.textMuted).attr("fill-opacity", 0.28).style("pointer-events", "none");
+    for (const c of layout.cityDots) {
+      gCities.append("circle").attr("cx", c.cx).attr("cy", c.cy).attr("r", c.r);
+    }
+  }
+  const clusterUi = !exportDims && !resolved.directives.noClusterPois;
+  const poiLabels = layout.labels.filter(
+    (l) => l.poiId !== void 0 && !l.hidden
+  );
+  if (poiLabels.length) {
+    const patchBlurId = nid("dgmo-map-label-patch-blur");
+    defs.append("filter").attr("id", patchBlurId).attr("x", "-50%").attr("y", "-50%").attr("width", "200%").attr("height", "200%").append("feGaussianBlur").attr("in", "SourceGraphic").attr("stdDeviation", 2.5);
+    const PAD = 8;
+    const buildPatch = (labels, maskId, decoCluster) => {
+      if (!labels.length) return;
+      const patchMask = defs.append("mask").attr("id", maskId).attr("maskUnits", "userSpaceOnUse").attr("x", 0).attr("y", 0).attr("width", width).attr("height", height);
+      const blobs = patchMask.append("g").attr("filter", `url(#${patchBlurId})`);
+      const blobRects = [];
+      for (const l of labels) {
+        const multi = l.lines && l.lines.length > 1;
+        const tw = multi ? Math.max(...l.lines.map((s) => measureText(s, LABEL_FONT))) : measureText(l.text, LABEL_FONT);
+        const th = multi ? l.lines.length * (LABEL_FONT + 2) : LABEL_FONT;
+        const cx = l.anchor === "start" ? l.x + tw / 2 : l.anchor === "end" ? l.x - tw / 2 : l.x;
+        const cy = l.y - LABEL_FONT * 0.3;
+        const w = tw + 8;
+        const h = th + 6;
+        blobs.append("rect").attr("x", cx - w / 2).attr("y", cy - h / 2).attr("width", w).attr("height", h).attr("rx", h / 2).attr("fill", "white");
+        blobRects.push({
+          x0: cx - w / 2 - PAD,
+          y0: cy - h / 2 - PAD,
+          x1: cx + w / 2 + PAD,
+          y1: cy + h / 2 + PAD
+        });
+      }
+      const gPatch = svg.append("g").attr("class", "dgmo-map-label-patch").attr("mask", `url(#${maskId})`).style("pointer-events", "none");
+      if (decoCluster !== void 0)
+        gPatch.attr("data-cluster-deco", decoCluster);
+      for (const r of layout.regions) {
+        let minX, minY, maxX, maxY;
+        if (r.bbox) {
+          [minX, minY, maxX, maxY] = r.bbox;
+        } else {
+          minX = Infinity;
+          minY = Infinity;
+          maxX = -Infinity;
+          maxY = -Infinity;
+          for (const ring of parsePathRings(r.d))
+            for (const [px, py] of ring) {
+              if (px < minX) minX = px;
+              if (px > maxX) maxX = px;
+              if (py < minY) minY = py;
+              if (py > maxY) maxY = py;
+            }
+        }
+        const hit = blobRects.some(
+          (b) => minX <= b.x1 && maxX >= b.x0 && minY <= b.y1 && maxY >= b.y0
+        );
+        if (hit) gPatch.append("path").attr("d", r.d).attr("fill", r.fill);
+      }
+    };
+    if (clusterUi) {
+      buildPatch(
+        poiLabels.filter((l) => l.clusterMember === void 0),
+        nid("dgmo-map-label-patch")
+      );
+      const byCluster = /* @__PURE__ */ new Map();
+      for (const l of poiLabels) {
+        if (l.clusterMember === void 0) continue;
+        const arr = byCluster.get(l.clusterMember);
+        if (arr) arr.push(l);
+        else byCluster.set(l.clusterMember, [l]);
+      }
+      let ci = 0;
+      for (const [cid, labs] of byCluster)
+        buildPatch(labs, nid(`dgmo-map-label-patch-c${ci++}`), cid);
+    } else {
+      buildPatch(poiLabels, nid("dgmo-map-label-patch"));
+    }
+  }
+  if (layout.insets.length) {
+    const insetG = svg.append("g").attr("class", "dgmo-map-insets");
+    layout.insets.forEach((box, bi) => {
+      const d = box.points.map((p, i) => `${i ? "L" : "M"}${p[0]},${p[1]}`).join("") + "Z";
+      insetG.append("path").attr("d", d).attr("fill", layout.background).attr("stroke", mix(palette.text, palette.bg, 55)).attr("stroke-width", 1).attr("stroke-linejoin", "round");
+      if (box.contextLand) {
+        const clipId = nid(`dgmo-map-inset-clip-${bi}`);
+        defs.append("clipPath").attr("id", clipId).append("path").attr("d", d);
+        insetG.append("path").attr("d", box.contextLand.d).attr("fill", box.contextLand.fill).attr("clip-path", `url(#${clipId})`);
+      }
+    });
+    for (const r of layout.insetRegions) drawRegion(insetG, r, 0.5);
+    if (layout.coastlineStyle) {
+      const cs = layout.coastlineStyle;
+      const maskId = nid("dgmo-map-inset-water-mask");
+      const mask = defs.append("mask").attr("id", maskId).attr("maskUnits", "userSpaceOnUse").attr("x", 0).attr("y", 0).attr("width", width).attr("height", height);
+      const reach = Math.max(0, ...cs.lines.map((l) => l.d + l.thickness));
+      for (const box of layout.insets) {
+        const d = box.points.map((p, i) => `${i ? "L" : "M"}${p[0]},${p[1]}`).join("") + "Z";
+        mask.append("path").attr("d", d).attr("fill", "white").attr("stroke", "black").attr("stroke-width", 2 * reach).attr("stroke-linejoin", "round");
+      }
+      layout.insets.forEach((box, bi) => {
+        if (box.contextLand)
+          mask.append("path").attr("d", box.contextLand.d).attr("fill", "black").attr("clip-path", `url(#${nid(`dgmo-map-inset-clip-${bi}`)})`);
+      });
+      for (const r of layout.insetRegions)
+        if (r.id !== "lake")
+          mask.append("path").attr("d", r.d).attr("fill", "black");
+      for (const r of layout.insetRegions)
+        if (r.id === "lake")
+          mask.append("path").attr("d", r.d).attr("fill", "white");
+      const clipId = nid("dgmo-map-inset-water-clip");
+      const clip = defs.append("clipPath").attr("id", clipId);
+      for (const box of layout.insets) {
+        const d = box.points.map((p, i) => `${i ? "L" : "M"}${p[0]},${p[1]}`).join("") + "Z";
+        clip.append("path").attr("d", d);
+      }
+      const gInsetWater = insetG.append("g").attr("clip-path", `url(#${clipId})`).append("g").attr("class", "dgmo-map-inset-water-lines").attr("fill", "none").style("pointer-events", "none").attr("mask", `url(#${maskId})`);
+      appendWaterLines(
+        gInsetWater,
+        defs,
+        nid("dgmo-map-inset-coast"),
+        coastlineOuterRings(layout.insetRegions, cs.minExtent),
+        cs,
+        layout.background
+      );
+      for (const r of layout.insetRegions)
+        gInsetWater.append("path").attr("d", r.d).attr("stroke", r.stroke).attr("stroke-width", 0.5).attr("stroke-linejoin", "round");
+    }
+    for (const box of layout.insets) {
+      const d = box.points.map((p, i) => `${i ? "L" : "M"}${p[0]},${p[1]}`).join("") + "Z";
+      insetG.append("path").attr("d", d).attr("fill", "none").attr("stroke", mix(palette.text, palette.bg, 55)).attr("stroke-width", 1).attr("stroke-linejoin", "round").style("pointer-events", "none");
+    }
+  }
+  const wireSync = (sel, lineNumber) => {
+    if (lineNumber < 1) return;
+    sel.attr("data-line-number", lineNumber);
+    if (onClickItem)
+      sel.style("cursor", "pointer").on("click", () => onClickItem(lineNumber));
+  };
+  const gLegs = svg.append("g").attr("class", "dgmo-map-legs").attr("fill", "none");
+  const legEnd = (d) => {
+    const m = /^M(-?[\d.]+),(-?[\d.]+)(?:L(-?[\d.]+),(-?[\d.]+)|Q(-?[\d.]+),(-?[\d.]+) (-?[\d.]+),(-?[\d.]+))$/.exec(
+      d
+    );
+    if (!m) return null;
+    const x0 = +m[1];
+    const y0 = +m[2];
+    let ex;
+    let ey;
+    let fromX;
+    let fromY;
+    if (m[3] !== void 0) {
+      ex = +m[3];
+      ey = +m[4];
+      fromX = x0;
+      fromY = y0;
+    } else {
+      ex = +m[7];
+      ey = +m[8];
+      fromX = +m[5];
+      fromY = +m[6];
+    }
+    const dx = ex - fromX;
+    const dy = ey - fromY;
+    const len = Math.hypot(dx, dy);
+    if (!(len > 0)) return null;
+    return { ex, ey, tx: dx / len, ty: dy / len };
+  };
+  layout.legs.forEach((leg) => {
+    const end = leg.arrow ? legEnd(leg.d) : null;
+    let drawD = leg.d;
+    let arrowTri = null;
+    if (end) {
+      const aLen = arrowSize(leg.width);
+      const aHalf = Math.max(aLen * 0.5, leg.width * 0.6 + 1);
+      const bx = end.ex - end.tx * aLen;
+      const by = end.ey - end.ty * aLen;
+      const px = -end.ty;
+      const py = end.tx;
+      arrowTri = `M${bx + px * aHalf},${by + py * aHalf}L${end.ex},${end.ey}L${bx - px * aHalf},${by - py * aHalf}z`;
+      drawD = leg.d.replace(
+        /(-?[\d.]+),(-?[\d.]+)$/,
+        `${bx.toFixed(2)},${by.toFixed(2)}`
+      );
+    }
+    const p = gLegs.append("path").attr("d", drawD).attr("stroke", leg.color).attr("stroke-width", leg.width).attr("stroke-linecap", "round").attr("data-from-id", leg.fromId).attr("data-to-id", leg.toId);
+    if (leg.tags) {
+      for (const [group, value] of Object.entries(leg.tags)) {
+        p.attr(`data-tag-${group.toLowerCase()}`, value.toLowerCase());
+      }
+    }
+    wireSync(p, leg.lineNumber);
+    if (leg.value !== void 0) {
+      p.attr("data-value", leg.value);
+      p.append("title").text(
+        leg.label !== void 0 ? `${leg.label}: ${leg.value}` : `${leg.value}`
+      );
+    }
+    if (arrowTri) {
+      const a = gLegs.append("path").attr("d", arrowTri).attr("fill", leg.color).attr("stroke", leg.color).attr("stroke-width", 1).attr("stroke-linejoin", "round").attr("data-from-id", leg.fromId).attr("data-to-id", leg.toId);
+      if (leg.tags) {
+        for (const [group, value] of Object.entries(leg.tags)) {
+          a.attr(`data-tag-${group.toLowerCase()}`, value.toLowerCase());
+        }
+      }
+    }
+    if (leg.label !== void 0 && leg.labelX !== void 0) {
+      const lt = emitText(
+        gLegs,
+        leg.labelX,
+        leg.labelY ?? 0,
+        leg.label,
+        "middle",
+        leg.labelColor ?? palette.textMuted,
+        leg.labelHaloColor ?? haloColor,
+        leg.labelHalo ?? true,
+        LABEL_FONT - 1
+      );
+      wireSync(lt, leg.lineNumber);
+    }
+  });
+  const gSpider = svg.append("g").attr("class", "dgmo-map-spider");
+  for (const cl of layout.clusters) {
+    if (clusterUi) {
+      gSpider.append("circle").attr("cx", cl.cx).attr("cy", cl.cy).attr("r", cl.hitR).attr("fill", "transparent").attr("data-cluster-hit", cl.id).style("cursor", "pointer");
+    }
+    for (const leg of cl.legs) {
+      gSpider.append("line").attr("x1", cl.cx).attr("y1", cl.cy).attr("x2", leg.x2).attr("y2", leg.y2).attr("stroke", leg.color).attr("stroke-width", 1).attr("data-cluster-deco", cl.id).style("pointer-events", "none");
+    }
+    gSpider.append("circle").attr("cx", cl.cx).attr("cy", cl.cy).attr("r", 2).attr("fill", mix(palette.textMuted, palette.bg, 40)).attr("data-cluster-deco", cl.id).style("pointer-events", "none");
+  }
+  const gPois = svg.append("g").attr("class", "dgmo-map-pois");
+  for (const poi of layout.pois) {
+    if (poi.isOrigin) {
+      gPois.append("circle").attr("cx", poi.cx).attr("cy", poi.cy).attr("r", poi.r + 3).attr("fill", "none").attr("stroke", poi.stroke).attr("stroke-width", 1.5);
+    }
+    const c = gPois.append("circle").attr("cx", poi.cx).attr("cy", poi.cy).attr("r", poi.r).attr("fill", poi.fill).attr("fill-opacity", poi.fillOpacity).attr("stroke", poi.stroke).attr("stroke-width", 1).attr("data-line-number", poi.lineNumber).attr("data-poi", poi.id);
+    if (poi.clusterId !== void 0)
+      c.attr("data-cluster-member", poi.clusterId);
+    if (poi.tags) {
+      for (const [group, value] of Object.entries(poi.tags)) {
+        c.attr(`data-tag-${group.toLowerCase()}`, value.toLowerCase());
+      }
+    }
+    if (onClickItem) {
+      c.style("cursor", "pointer").on(
+        "click",
+        () => onClickItem(poi.lineNumber)
+      );
+    }
+    if (poi.routeNumber !== void 0) {
+      emitText(
+        gPois,
+        poi.cx,
+        poi.cy + 3,
+        String(poi.routeNumber),
+        "middle",
+        palette.bg,
+        poi.fill,
+        false,
+        LABEL_FONT - 2
+      );
+    }
+  }
+  const gLabels = svg.append("g").attr("class", "dgmo-map-labels");
+  for (const lab of layout.labels) {
+    if (lab.hidden) {
+      if (exportDims) continue;
+      emitText(
+        gLabels,
+        lab.x,
+        lab.y,
+        lab.text,
+        lab.anchor,
+        lab.color,
+        lab.haloColor,
+        lab.halo,
+        lab.fontSize ?? LABEL_FONT,
+        lab.italic,
+        lab.letterSpacing
+      ).attr("data-poi", lab.poiId ?? null).attr("data-poi-hidden", "").style("opacity", 0).style("pointer-events", "none");
+      continue;
+    }
+    if (lab.leader) {
+      const line = gLabels.append("line").attr("x1", lab.leader.x1).attr("y1", lab.leader.y1).attr("x2", lab.leader.x2).attr("y2", lab.leader.y2).attr(
+        "stroke",
+        lab.leaderColor ?? mix(palette.textMuted, palette.bg, 60)
+      ).attr("stroke-width", lab.leaderColor ? 1 : 0.75);
+      if (lab.poiId !== void 0) line.attr("data-poi", lab.poiId);
+      if (lab.clusterMember !== void 0)
+        line.attr("data-cluster-member", lab.clusterMember);
+      wireSync(line, lab.lineNumber);
+    }
+    if (lab.calloutDot) {
+      gLabels.append("circle").attr("cx", lab.calloutDot.x).attr("cy", lab.calloutDot.y).attr("r", 2.5).attr("fill", lab.calloutDot.color).attr("stroke", mix(palette.text, palette.bg, 55)).attr("stroke-width", 0.75);
+    }
+    const t = emitText(
+      gLabels,
+      lab.x,
+      lab.y,
+      lab.text,
+      lab.anchor,
+      lab.color,
+      lab.haloColor,
+      lab.halo,
+      lab.fontSize ?? LABEL_FONT,
+      lab.italic,
+      lab.letterSpacing,
+      lab.lines,
+      lab.valueLine
+    );
+    if (lab.poiId !== void 0) {
+      t.attr("data-poi", lab.poiId).style("cursor", "default");
+    }
+    if (lab.clusterMember !== void 0) {
+      t.attr("data-cluster-member", lab.clusterMember);
+    }
+    wireSync(t, lab.lineNumber);
+  }
+  if (clusterUi && layout.clusters.length) {
+    const gBadge = svg.append("g").attr("class", "dgmo-map-cluster-badges");
+    for (const cl of layout.clusters) {
+      const g = gBadge.append("g").attr("data-cluster", cl.id).style("opacity", 0).style("pointer-events", "none");
+      const R = 9;
+      g.append("circle").attr("cx", cl.cx).attr("cy", cl.cy).attr("r", R).attr("fill", mix(palette.textMuted, palette.bg, 35)).attr("stroke", palette.textMuted).attr("stroke-width", 1);
+      g.append("circle").attr("cx", cl.cx).attr("cy", cl.cy).attr("r", R + 2.5).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", 1);
+      const beadR = R + 2.5;
+      for (const leg of cl.legs) {
+        const a = Math.atan2(leg.y2 - cl.cy, leg.x2 - cl.cx);
+        g.append("circle").attr("class", "dgmo-map-cluster-bead").attr("cx", cl.cx + beadR * Math.cos(a)).attr("cy", cl.cy + beadR * Math.sin(a)).attr("r", 1.8).attr("fill", leg.color).attr("stroke", palette.bg).attr("stroke-width", 0.5);
+      }
+      emitText(
+        g,
+        cl.cx,
+        cl.cy + 3,
+        String(cl.count),
+        "middle",
+        palette.text,
+        palette.bg,
+        false,
+        LABEL_FONT
+      );
+    }
+  }
+  if (layout.legend) {
+    const legendY = (layout.title ? TITLE_Y + TITLE_FONT_SIZE : 0) + (layout.subtitle ? TITLE_FONT_SIZE : 0) + 8;
+    const legendG = svg.append("g").attr("class", "dgmo-map-legend").attr("transform", `translate(0, ${legendY})`);
+    const groups = mapLegendGroups(layout.legend);
+    if (groups.length > 0) {
+      const config = mapLegendConfig(
+        groups,
+        exportDims ? "export" : "preview"
+      );
+      renderIntegratedLegend(legendG, {
+        ...config,
+        palette,
+        isDark,
+        width,
+        activeGroup: layout.legend.activeGroup
+      });
+    }
+  }
+  if (layout.title) {
+    svg.append("text").attr("class", "dgmo-map-title").attr("x", width / 2).attr("y", TITLE_Y).attr("text-anchor", "middle").attr("font-size", TITLE_FONT_SIZE).attr("font-weight", TITLE_FONT_WEIGHT).attr("fill", palette.text).attr("paint-order", "stroke fill").attr("stroke", palette.bg).attr("stroke-width", 4).attr("stroke-linejoin", "round").attr("stroke-opacity", 0.7).text(layout.title);
+  }
+  if (layout.subtitle) {
+    svg.append("text").attr("class", "dgmo-map-subtitle").attr("x", width / 2).attr("y", TITLE_Y + TITLE_FONT_SIZE).attr("text-anchor", "middle").attr("font-size", LABEL_FONT + 1).attr("fill", palette.textMuted).attr("paint-order", "stroke fill").attr("stroke", palette.bg).attr("stroke-width", 3).attr("stroke-linejoin", "round").attr("stroke-opacity", 0.7).text(layout.subtitle);
+  }
+  if (layout.caption) {
+    svg.append("text").attr("x", width / 2).attr("y", height - 8).attr("text-anchor", "middle").attr("font-size", LABEL_FONT).attr("fill", palette.textMuted).attr("paint-order", "stroke fill").attr("stroke", palette.bg).attr("stroke-width", 3).attr("stroke-linejoin", "round").attr("stroke-opacity", 0.7).text(layout.caption);
+  }
+}
+function renderMapForExport(container, resolved, data, palette, isDark, exportDims) {
+  renderMap(container, resolved, data, palette, isDark, void 0, exportDims);
+}
+function emitText(g, x, y, text, anchor, color, halo, withHalo, fontSize, italic, letterSpacing, lines, valueLine) {
+  const t = g.append("text").attr("x", x).attr("y", y).attr("text-anchor", anchor).attr("font-size", fontSize).attr("fill", color);
+  if (lines && lines.length > 1) {
+    const lineHeight = fontSize + 2;
+    const startDy = -((lines.length - 1) / 2) * lineHeight;
+    lines.forEach((ln, i) => {
+      t.append("tspan").attr("x", x).attr("dy", i === 0 ? startDy : lineHeight).text(ln);
+    });
+  } else if (valueLine !== void 0) {
+    const valueSize = Math.round(fontSize * 0.82);
+    t.append("tspan").attr("x", x).attr("dy", -fontSize * 0.28).text(text);
+    t.append("tspan").attr("x", x).attr("dy", fontSize * 0.92).attr("font-size", valueSize).attr("fill-opacity", 0.72).text(valueLine);
+  } else {
+    t.text(text);
+  }
+  if (italic) t.attr("font-style", "italic");
+  if (letterSpacing) t.attr("letter-spacing", letterSpacing);
+  if (withHalo) {
+    t.attr("paint-order", "stroke fill").attr("stroke", halo).attr("stroke-width", 2).attr("stroke-linejoin", "round").attr("stroke-linecap", "round").attr("stroke-opacity", 0.55);
+  }
+  return t;
+}
+
+export {
+  renderMap,
+  renderMapForExport
+};
+//# sourceMappingURL=chunk-Z5CGSFJB.js.map