@diagrammo/dgmo 0.85.0 → 0.86.0

package/dist/{chunk-7256EOAE.js → chunk-CFBY77QJ.js}

@@ -5,7 +5,7 @@ import {
 import {
   renderCollapseBar,
   renderNodeCard
-} from "./chunk-UNSN56OJ.js";
+} from "./chunk-R2K5L4UA.js";
 import {
   ScaleContext
 } from "./chunk-24YPR5EH.js";
@@ -23,7 +23,7 @@ import {
   LABEL_FONT_SIZE,
   META_FONT_SIZE,
   NODE_STROKE_WIDTH
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   layoutInlineHeader
 } from "./chunk-3DOQOXXI.js";
@@ -940,7 +940,7 @@ function assignEdgeSides(edges, rectById) {
     return { s: facing(dx, dy), t: facing(-dx, -dy) };
   });
 }
-function edgePath(source, target, sSide, tSide, sourcePorts, targetPorts) {
+function edgePath(source, target, sSide, tSide, sourcePorts, targetPorts, ends) {
   const acx = source.x + source.w / 2;
   const acy = source.y + source.h / 2;
   const bcx = target.x + target.w / 2;
@@ -958,8 +958,8 @@ function edgePath(source, target, sSide, tSide, sourcePorts, targetPorts) {
     return { x, y };
   };
   const normal = (side) => side === "L" ? { x: -1, y: 0 } : side === "R" ? { x: 1, y: 0 } : side === "T" ? { x: 0, y: -1 } : { x: 0, y: 1 };
-  const p0 = attach(sSide, source, sourcePorts, { x: bcx, y: bcy });
-  const p1 = attach(tSide, target, targetPorts, { x: acx, y: acy });
+  const p0 = ends?.p0 ?? attach(sSide, source, sourcePorts, { x: bcx, y: bcy });
+  const p1 = ends?.p1 ?? attach(tSide, target, targetPorts, { x: acx, y: acy });
   const n0 = normal(sSide);
   const n1 = normal(tSide);
   const k = Math.max(
@@ -1021,7 +1021,8 @@ function polyCrossings(a, b) {
       if (segmentsCross(a[i], a[i + 1], b[j], b[j + 1])) n++;
   return n;
 }
-function polyIntersection(a, b) {
+function polyIntersections(a, b) {
+  const out = [];
   for (let i = 0; i + 1 < a.length; i++) {
     const p = a[i];
     const p2 = a[i + 1];
@@ -1036,10 +1037,10 @@ function polyIntersection(a, b) {
       const denom = rx * sy - ry * sx;
       if (denom === 0) continue;
       const t = ((q.x - p.x) * sy - (q.y - p.y) * sx) / denom;
-      return { x: p.x + t * rx, y: p.y + t * ry };
+      out.push({ x: p.x + t * rx, y: p.y + t * ry });
     }
   }
-  return null;
+  return out;
 }
 var HOP_R = 7;
 function hoppedPath(g, hops) {
@@ -1308,14 +1309,132 @@ function sketchEdgeGeometry(layout, offsets) {
     }
     if (!changed) break;
   }
+  const FAN_GAP_MAX = 32;
+  const fanSides = /* @__PURE__ */ new Map();
+  for (let i = 0; i < layout.edges.length; i++) {
+    const g = geoms[i];
+    if (!g) continue;
+    const e = layout.edges[i];
+    const ch = chosen[i];
+    const ends = [
+      { id: e.sourceId, side: ch.s, end: "p0", at: g.p0, far: g.p1 },
+      { id: e.targetId, side: ch.t, end: "p1", at: g.p1, far: g.p0 }
+    ];
+    for (const en of ends) {
+      if (isBox(en.id)) continue;
+      const n = normalOf(en.side);
+      const along = en.side === "T" || en.side === "B";
+      const dx = en.far.x - en.at.x;
+      const dy = en.far.y - en.at.y;
+      const proj = along ? dx : dy;
+      const key = Math.atan2(proj, dx * n.x + dy * n.y);
+      const k = `${en.side}:${en.id}`;
+      const list = fanSides.get(k) ?? [];
+      list.push({ edge: i, end: en.end, at: en.at, key, proj });
+      fanSides.set(k, list);
+    }
+  }
+  const fanned = layout.edges.map(() => ({}));
+  let anyFanned = false;
+  for (const [k, list] of fanSides) {
+    const count = list.length;
+    if (count < 2) continue;
+    const along = k[0] === "T" || k[0] === "B";
+    const c = ctx[list[0].edge];
+    const rect = list[0].end === "p0" ? c.source : c.target;
+    const len = along ? rect.w : rect.h;
+    const gap = Math.min(len / (count + 1), FAN_GAP_MAX);
+    const span = (count - 1) / 2 * gap;
+    const reach = len / 2 - gap / 2;
+    list.sort(
+      (a, b) => a.key - b.key || a.edge - b.edge || (a.end < b.end ? -1 : 1)
+    );
+    const runs = [];
+    const place = (r) => Math.max(
+      -reach,
+      Math.min(reach - (r.n - 1) * gap, r.an > 0 ? r.as / r.an : r.ls / r.ln)
+    );
+    for (const f of list) {
+      const aligned = Math.abs(f.proj) <= span;
+      const d = Math.max(-span, Math.min(span, f.proj));
+      const run = aligned ? { n: 1, an: 1, as: d, ln: 0, ls: 0, at: 0 } : { n: 1, an: 0, as: 0, ln: 1, ls: d, at: 0 };
+      run.at = place(run);
+      runs.push(run);
+      while (runs.length > 1) {
+        const cur = runs[runs.length - 1];
+        const prev = runs[runs.length - 2];
+        if (prev.at + prev.n * gap <= cur.at) break;
+        runs.pop();
+        prev.as += cur.as - cur.an * prev.n * gap;
+        prev.ls += cur.ls - cur.ln * prev.n * gap;
+        prev.an += cur.an;
+        prev.ln += cur.ln;
+        prev.n += cur.n;
+        prev.at = place(prev);
+      }
+    }
+    let idx = 0;
+    for (const run of runs) {
+      for (let m = 0; m < run.n; m++, idx++) {
+        const f = list[idx];
+        const off2 = run.at + m * gap;
+        fanned[f.edge][f.end] = along ? { x: f.at.x + off2, y: f.at.y } : { x: f.at.x, y: f.at.y + off2 };
+      }
+    }
+    anyFanned = true;
+  }
+  if (anyFanned) {
+    for (let i = 0; i < ctx.length; i++) {
+      const c = ctx[i];
+      const f = fanned[i];
+      if (!c || !f.p0 && !f.p1) continue;
+      const g = edgePath(
+        c.source,
+        c.target,
+        chosen[i].s,
+        chosen[i].t,
+        c.sPorts,
+        c.tPorts,
+        f
+      );
+      geoms[i] = g;
+      polys[i] = polyline(g);
+    }
+  }
+  const SHARED_END_CLEAR = 2 * HOP_R;
+  const endsAt = (i, id) => {
+    const e = layout.edges[i];
+    const g = geoms[i];
+    const out = [];
+    if (e.sourceId === id) out.push(g.p0);
+    if (e.targetId === id) out.push(g.p1);
+    return out;
+  };
   const hopsFor = layout.edges.map(() => []);
   for (let i = 0; i < polys.length; i++) {
     for (let j = i + 1; j < polys.length; j++) {
-      if (ctx[i]?.adjacent.has(j)) continue;
       const a = polys[i];
       const b = polys[j];
       if (!a || !b) continue;
-      const pt = polyIntersection(a, b);
+      if (!ctx[i]?.adjacent.has(j)) {
+        const pt2 = polyIntersections(a, b)[0];
+        if (pt2) hopsFor[j].push(pt2);
+        continue;
+      }
+      const ei = layout.edges[i];
+      const ej = layout.edges[j];
+      const shared = [ei.sourceId, ei.targetId].filter(
+        (id) => id === ej.sourceId || id === ej.targetId
+      );
+      const nearShared = shared.flatMap((id) => [
+        ...endsAt(i, id),
+        ...endsAt(j, id)
+      ]);
+      const pt = polyIntersections(a, b).find(
+        (p) => nearShared.every(
+          (q) => Math.hypot(p.x - q.x, p.y - q.y) > SHARED_END_CLEAR
+        )
+      );
       if (pt) hopsFor[j].push(pt);
     }
   }

package/dist/{chunk-OZTDXMRQ.js → chunk-D4M25W6R.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-RE27AX7O.js";
 import {
   parseDgmoChartType
-} from "./chunk-JVRDKR5R.js";
+} from "./chunk-AQIBKTPG.js";
 import {
   chartTypes
 } from "./chunk-44GP7PD5.js";

package/dist/{chunk-A4PHPKNR.js → chunk-DAX42XVH.js}

@@ -1,7 +1,7 @@
 import {
   META_FONT_SIZE,
   META_LINE_HEIGHT
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   LEGEND_CAPSULE_PAD,
   LEGEND_DOT_R,

package/dist/{chunk-V3LJIPS4.js → chunk-E6S2K6O2.js}

@@ -21,7 +21,7 @@ import {
   CONTAINER_RADIUS,
   GRID_DASH,
   NODE_STROKE_WIDTH
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   serializeSvg
 } from "./chunk-LD2JSKU3.js";

package/dist/{chunk-BIQYWWJ2.js → chunk-ERYHC4KJ.js}

@@ -22,7 +22,7 @@ import {
   EDGE_LABEL_KNOCKOUT_OPACITY,
   EDGE_STROKE_WIDTH,
   NODE_STROKE_WIDTH
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   layoutInlineHeader
 } from "./chunk-3DOQOXXI.js";

package/dist/{chunk-JLGN6S4B.js → chunk-EWSESGC2.js}

@@ -1,7 +1,10 @@
 import {
+  BOX_CLEAR_PAD,
+  EDGE_LABEL_FONT_SIZE,
   NODE_HEIGHT,
-  NODE_WIDTH
-} from "./chunk-WTTIODDV.js";
+  NODE_WIDTH,
+  measureEdgeLabel
+} from "./chunk-TW6WMZFW.js";
 
 // src/boxes-and-lines/edge-clip.ts
 function rectBorderPoint(rect, toward) {
@@ -297,6 +300,28 @@ function groupedTierCandidates(parsed, sizes, opts) {
     chain.push(e.target);
     chains.push({ edgeIdx: i, chain });
   }
+  const labelGap = Array.from({ length: maxRank + 1 }, () => 0);
+  if (opts?.reserveEdgeLabels) {
+    const leadWall = isTB ? GROUP_LABEL_ZONE : GROUP_PAD;
+    const wallsBetween = (a, b) => {
+      const pa = pathOf(a);
+      const pb = pathOf(b);
+      let shared = 0;
+      while (shared < pa.length && shared < pb.length && pa[shared] === pb[shared])
+        shared++;
+      return (pa.length - shared) * GROUP_PAD + (pb.length - shared) * leadWall;
+    };
+    for (const { e } of edges) {
+      if (!e.label) continue;
+      const rs = globalRank.get(e.source);
+      const rt = globalRank.get(e.target);
+      if (rt <= rs) continue;
+      const m = measureEdgeLabel(e.label, EDGE_LABEL_FONT_SIZE);
+      const need = (isTB ? m.height : m.width) + 2 * BOX_CLEAR_PAD + wallsBetween(e.source, e.target);
+      for (let r = rs + 1; r <= rt; r++)
+        labelGap[r] = Math.max(labelGap[r], need);
+    }
+  }
   const ranks = Array.from({ length: maxRank + 1 }, () => []);
   for (const n of node.values()) ranks[n.rank].push(n.id);
   const up = /* @__PURE__ */ new Map();
@@ -468,7 +493,11 @@ function groupedTierCandidates(parsed, sizes, opts) {
     const bandCenter = [];
     let acc = MARGIN;
     for (let r = 0; r <= maxRank; r++) {
-      if (r > 0) acc += RANKSEP + (tierStartRanks.has(r) ? TIER_GAP : 0);
+      if (r > 0)
+        acc += Math.max(
+          RANKSEP + (tierStartRanks.has(r) ? TIER_GAP : 0),
+          labelGap[r]
+        );
       bandCenter[r] = acc + bandDepth[r] / 2;
       acc += bandDepth[r];
     }

package/dist/{chunk-MIZ46MOF.js → chunk-GYORDNOM.js}

@@ -22,7 +22,7 @@ import {
   LABEL_FONT_SIZE,
   META_FONT_SIZE,
   NODE_STROKE_WIDTH
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   INLINE_HEADER_PAD,
   layoutInlineHeader

package/dist/{chunk-D7D5YK4J.js → chunk-H6AFNCN3.js}

@@ -339,15 +339,27 @@ function renderGauge(svg, parsed, metrics, paint) {
   g.append("line").attr("x1", cx).attr("y1", cy).attr("x2", nx).attr("y2", ny).attr("stroke", paint.text).attr("stroke-width", 5).attr("stroke-linecap", "round");
   g.append("circle").attr("cx", cx).attr("cy", cy).attr("r", 11).attr("fill", paint.text);
   const nowLabel = compactNumber(parsed.now);
-  const nowSize = Math.min(
+  const bandInner = r - stroke / 2;
+  let nowSize = Math.min(
     r * 0.62,
     140,
     r * 0.95 / Math.max(1, nowLabel.length * 0.6)
   );
+  if (parsed.hasTarget) {
+    const shoulderX = (bandInner - 26) * Math.SQRT1_2;
+    const shoulderW = Math.max(
+      measureText(compactNumber(parsed.target * 0.25), 18),
+      measureText(compactNumber(parsed.target * 0.75), 18)
+    );
+    const halfClear = shoulderX - shoulderW - 8;
+    const widthPerPx = measureText(nowLabel, 100, { bold: true }) / 100;
+    if (widthPerPx > 0 && halfClear > 0) {
+      nowSize = Math.min(nowSize, 2 * halfClear / widthPerPx);
+    }
+  }
   const nowY = cy - r * 0.42;
   g.append("text").attr("x", cx).attr("y", nowY + nowSize * 0.35).attr("text-anchor", "middle").attr("fill", paint.muted).attr("font-family", FONT_FAMILY).attr("font-size", nowSize).attr("font-weight", "bold").text(nowLabel);
   if (parsed.hasTarget) {
-    const bandInner = r - stroke / 2;
     for (const f of [0, 0.25, 0.5, 0.75, 1]) {
       const isTarget = f === 1;
       const ang = Math.PI - f * Math.PI;

package/dist/{chunk-PEFPTQ3Z.js → chunk-HUMQIRJK.js}

@@ -15,7 +15,7 @@ import {
   EDGE_LABEL_KNOCKOUT_OPACITY,
   EDGE_STROKE_WIDTH,
   NODE_STROKE_WIDTH
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   layoutInlineHeader
 } from "./chunk-3DOQOXXI.js";

package/dist/{chunk-XXAZ5C4K.js → chunk-IJ27L3R4.js}

@@ -7,7 +7,7 @@ import {
   META_FONT_SIZE,
   META_LINE_HEIGHT,
   SEPARATOR_GAP
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   buildCoupleQuotient,
   rankClasses

package/dist/{chunk-VDMG3MM4.js → chunk-JD4RHBNX.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-24YPR5EH.js";
 import {
   NODE_STROKE_WIDTH
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   TITLE_FONT_SIZE,
   TITLE_FONT_WEIGHT,

package/dist/{chunk-J2ICADUM.js → chunk-LHBMQJC3.js}

@@ -18,7 +18,7 @@ import {
   EDGE_LABEL_KNOCKOUT_OPACITY,
   EDGE_STROKE_WIDTH,
   NODE_STROKE_WIDTH
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   extractExportSvg,
   runInExportContainer