@diagrammo/dgmo 0.85.0 → 0.87.0

package/dist/chunk-QT3KDDXK.js

@@ -0,0 +1,436 @@
+import {
+  measureText,
+  truncateText,
+  wrapTextToWidth
+} from "./chunk-KAO7JL4I.js";
+
+// src/boxes-and-lines/node-metrics.ts
+var PHI = 1.618;
+var NODE_HEIGHT = 60;
+var NODE_WIDTH = Math.round(NODE_HEIGHT * PHI);
+
+// src/boxes-and-lines/label-placement.ts
+import { curveBasis } from "d3-shape";
+var EDGE_LABEL_FONT_SIZE = 11;
+var LABEL_MAX_WIDTH = 160;
+var MAX_LABEL_LINES = 3;
+var LABEL_LINE_HEIGHT = 1.3;
+var H_PAD = 6;
+var V_PAD = 3;
+var BOX_CLEAR_PAD = 4;
+var PERP_STEP = 8;
+var LABEL_REACH_NEAR = 40;
+var LABEL_REACH_WIDE = 56;
+var SLIDE_SAMPLES = 9;
+var CURVE_STEP = 4;
+var EDGE_CLEAR_PAD = 2;
+var GROUP_BORDER_BAND = 4;
+var GROUP_TITLE_FONT_SIZE = 14;
+var GROUP_TITLE_DEPTH = 24;
+var GROUP_LABEL_ZONE = 32;
+function measureEdgeLabel(label, fontSize = EDGE_LABEL_FONT_SIZE, maxWidth = LABEL_MAX_WIDTH) {
+  let lines = wrapTextToWidth(label, fontSize, maxWidth, { hardBreak: true });
+  if (lines.length > MAX_LABEL_LINES) {
+    const kept = lines.slice(0, MAX_LABEL_LINES - 1);
+    const rest = lines.slice(MAX_LABEL_LINES - 1).join(" ");
+    kept.push(truncateText(rest, fontSize, maxWidth));
+    lines = kept;
+  }
+  let textW = 0;
+  for (const ln of lines) {
+    const w = measureText(ln, fontSize);
+    if (w > textW) textW = w;
+  }
+  return {
+    lines,
+    width: textW + 2 * H_PAD,
+    height: lines.length * fontSize * LABEL_LINE_HEIGHT + 2 * V_PAD
+  };
+}
+function edgePolylineMidpoint(points) {
+  return pointAtArcFraction(points, 0.5).p;
+}
+function pointAtArcFraction(points, t) {
+  if (points.length === 0) return { p: { x: 0, y: 0 }, nx: 0, ny: 1 };
+  if (points.length === 1)
+    return { p: { x: points[0].x, y: points[0].y }, nx: 0, ny: 1 };
+  const segLen = [];
+  let total = 0;
+  for (let k = 1; k < points.length; k++) {
+    const len = Math.hypot(
+      points[k].x - points[k - 1].x,
+      points[k].y - points[k - 1].y
+    );
+    segLen.push(len);
+    total += len;
+  }
+  let want = total * Math.max(0, Math.min(1, t));
+  for (let k = 1; k < points.length; k++) {
+    const len = segLen[k - 1];
+    if (want <= len || k === points.length - 1) {
+      const f = len === 0 ? 0 : Math.min(1, want / len);
+      const ax = points[k - 1].x;
+      const ay = points[k - 1].y;
+      const bx = points[k].x;
+      const by = points[k].y;
+      const dx = bx - ax;
+      const dy = by - ay;
+      const dlen = Math.hypot(dx, dy) || 1;
+      return {
+        p: { x: ax + dx * f, y: ay + dy * f },
+        nx: -dy / dlen,
+        ny: dx / dlen
+      };
+    }
+    want -= len;
+  }
+  const last = points[points.length - 1];
+  return { p: { x: last.x, y: last.y }, nx: 0, ny: 1 };
+}
+function rectFromCenter(cx, cy, w, h) {
+  return {
+    minX: cx - w / 2,
+    minY: cy - h / 2,
+    maxX: cx + w / 2,
+    maxY: cy + h / 2
+  };
+}
+function overlapsAny(cx, cy, w, h, obstacles, pad) {
+  const minX = cx - w / 2 - pad;
+  const minY = cy - h / 2 - pad;
+  const maxX = cx + w / 2 + pad;
+  const maxY = cy + h / 2 + pad;
+  for (const o of obstacles) {
+    if (minX < o.maxX && maxX > o.minX && minY < o.maxY && maxY > o.minY)
+      return true;
+  }
+  return false;
+}
+function slideFractions() {
+  const out = [0.5];
+  for (let k = 1; k <= SLIDE_SAMPLES; k++) {
+    const off = k * 0.08;
+    if (0.5 - off >= 0.12) out.push(0.5 - off);
+    if (0.5 + off <= 0.88) out.push(0.5 + off);
+  }
+  return out;
+}
+function findClearPosition(points, blocked, perpMax, firstSide = -1) {
+  const ts = slideFractions();
+  for (const t of ts) {
+    const { p } = pointAtArcFraction(points, t);
+    if (!blocked(p.x, p.y)) return p;
+  }
+  for (let mag = PERP_STEP; mag <= perpMax; mag += PERP_STEP) {
+    for (const t of ts) {
+      const { p, nx, ny } = pointAtArcFraction(points, t);
+      for (const sign of [firstSide, -firstSide]) {
+        const x = p.x + nx * mag * sign;
+        const y = p.y + ny * mag * sign;
+        if (!blocked(x, y)) return { x, y };
+      }
+    }
+  }
+  return null;
+}
+function sampleDrawnCurve(points) {
+  const out = [];
+  if (points.length < 2) return out;
+  let cx = 0;
+  let cy = 0;
+  const ctx = {
+    moveTo(x, y) {
+      out.push({ x, y });
+      cx = x;
+      cy = y;
+    },
+    lineTo(x, y) {
+      const n = Math.max(1, Math.ceil(Math.hypot(x - cx, y - cy) / CURVE_STEP));
+      for (let k = 1; k <= n; k++)
+        out.push({ x: cx + (x - cx) * k / n, y: cy + (y - cy) * k / n });
+      cx = x;
+      cy = y;
+    },
+    bezierCurveTo(x1, y1, x2, y2, x, y) {
+      const n = Math.max(
+        1,
+        Math.ceil(
+          (Math.hypot(x1 - cx, y1 - cy) + Math.hypot(x2 - x1, y2 - y1) + Math.hypot(x - x2, y - y2)) / CURVE_STEP
+        )
+      );
+      for (let k = 1; k <= n; k++) {
+        const t = k / n;
+        const u = 1 - t;
+        out.push({
+          x: u * u * u * cx + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * x,
+          y: u * u * u * cy + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * y
+        });
+      }
+      cx = x;
+      cy = y;
+    },
+    closePath() {
+    }
+  };
+  const curve = curveBasis(ctx);
+  curve.lineStart();
+  for (const p of points) curve.point(p.x, p.y);
+  curve.lineEnd();
+  return out;
+}
+function buildGroupContainers(groups) {
+  const byLabel = new Map(groups.map((g) => [g.label, g]));
+  const parent = /* @__PURE__ */ new Map();
+  for (const g of groups)
+    for (const c of g.children) if (byLabel.has(c)) parent.set(c, g.label);
+  for (const g of groups) if (g.parentGroup) parent.set(g.label, g.parentGroup);
+  const chainOf = (label) => {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    let cur = label;
+    while (cur !== void 0 && byLabel.has(cur) && !seen.has(cur)) {
+      seen.add(cur);
+      out.push(cur);
+      cur = parent.get(cur);
+    }
+    return out;
+  };
+  const containers = /* @__PURE__ */ new Map();
+  for (const g of groups) containers.set(g.label, new Set(chainOf(g.label)));
+  for (const g of groups) {
+    const chain = chainOf(g.label);
+    for (const c of g.children) {
+      if (byLabel.has(c)) continue;
+      let set = containers.get(c);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        containers.set(c, set);
+      }
+      for (const a of chain) set.add(a);
+    }
+  }
+  return containers;
+}
+function resolveLabelOverlaps(boxes) {
+  const MAX_PASSES = 8;
+  const PAD = 4;
+  for (let pass = 0; pass < MAX_PASSES; pass++) {
+    let moved = false;
+    for (let i = 0; i < boxes.length; i++) {
+      for (let j = i + 1; j < boxes.length; j++) {
+        const a = boxes[i];
+        const b = boxes[j];
+        const dx = Math.abs(a.cx - b.cx);
+        const dy = Math.abs(a.cy - b.cy);
+        const overlapX = (a.w + b.w) / 2 + PAD - dx;
+        const overlapY = (a.h + b.h) / 2 + PAD - dy;
+        if (overlapX > 0 && overlapY > 0) {
+          const shift = overlapY / 2 + 1;
+          if (a.cy < b.cy) {
+            a.cy -= shift;
+            b.cy += shift;
+          } else {
+            a.cy += shift;
+            b.cy -= shift;
+          }
+          moved = true;
+        }
+      }
+    }
+    if (!moved) break;
+  }
+}
+function placeEdgeLabels(layout, opts) {
+  const fontSize = opts?.fontSize ?? EDGE_LABEL_FONT_SIZE;
+  const maxWidth = opts?.maxWidth ?? LABEL_MAX_WIDTH;
+  const perpMax = opts?.perpMax ?? LABEL_REACH_NEAR;
+  const baseObstacles = [];
+  for (const n of layout.nodes)
+    baseObstacles.push(rectFromCenter(n.x, n.y, n.width, n.height));
+  const expandedGroups = [];
+  for (const g of layout.groups) {
+    const r = rectFromCenter(g.x, g.y, g.width, g.height);
+    if (g.collapsed) baseObstacles.push(r);
+    else expandedGroups.push({ label: g.label, rect: r });
+  }
+  const containers = buildGroupContainers(opts?.groups ?? []);
+  const noContainers = /* @__PURE__ */ new Set();
+  const obstacleCache = /* @__PURE__ */ new Map();
+  const obstaclesFor = (edgeIdx) => {
+    const cached = obstacleCache.get(edgeIdx);
+    if (cached !== void 0) return cached;
+    let out = baseObstacles;
+    if (expandedGroups.length > 0) {
+      const e = layout.edges[edgeIdx];
+      const src = containers.get(e.source) ?? noContainers;
+      const tgt = containers.get(e.target) ?? noContainers;
+      const foreign = expandedGroups.filter((g) => !(src.has(g.label) && tgt.has(g.label))).map((g) => g.rect);
+      if (foreign.length > 0) out = [...baseObstacles, ...foreign];
+    }
+    obstacleCache.set(edgeIdx, out);
+    return out;
+  };
+  const curves = layout.edges.map((e) => {
+    const pts = sampleDrawnCurve(e.points);
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const p of pts) {
+      if (p.x < minX) minX = p.x;
+      if (p.y < minY) minY = p.y;
+      if (p.x > maxX) maxX = p.x;
+      if (p.y > maxY) maxY = p.y;
+    }
+    return { pts, minX, minY, maxX, maxY };
+  });
+  const crossesOtherEdge = (edgeIdx, cx, cy, w, h) => {
+    const minX = cx - w / 2 - EDGE_CLEAR_PAD;
+    const minY = cy - h / 2 - EDGE_CLEAR_PAD;
+    const maxX = cx + w / 2 + EDGE_CLEAR_PAD;
+    const maxY = cy + h / 2 + EDGE_CLEAR_PAD;
+    for (let j = 0; j < curves.length; j++) {
+      if (j === edgeIdx) continue;
+      const c = curves[j];
+      if (c.maxX < minX || c.minX > maxX || c.maxY < minY || c.minY > maxY)
+        continue;
+      for (const p of c.pts)
+        if (p.x > minX && p.x < maxX && p.y > minY && p.y < maxY) return true;
+    }
+    return false;
+  };
+  const hasSubGroup = new Set(
+    (opts?.groups ?? []).flatMap((g) => g.parentGroup ? [g.parentGroup] : [])
+  );
+  const drawnTop = (g) => g.y - g.height / 2 - (hasSubGroup.has(g.label) ? GROUP_LABEL_ZONE : 0);
+  const titleRects = layout.groups.filter((g) => !g.collapsed).map((g) => {
+    const tw = measureText(g.label, GROUP_TITLE_FONT_SIZE, { bold: true });
+    const top = drawnTop(g);
+    return {
+      minX: g.x - tw / 2,
+      minY: top,
+      maxX: g.x + tw / 2,
+      maxY: top + GROUP_TITLE_DEPTH
+    };
+  });
+  const borderBands = (g) => {
+    const B = GROUP_BORDER_BAND;
+    const l = g.x - g.width / 2;
+    const r = g.x + g.width / 2;
+    const t = drawnTop(g);
+    const b = g.y + g.height / 2;
+    return [
+      { minX: l - B, minY: t - B, maxX: r + B, maxY: t + B },
+      { minX: l - B, minY: b - B, maxX: r + B, maxY: b + B },
+      { minX: l - B, minY: t - B, maxX: l + B, maxY: b + B },
+      { minX: r - B, minY: t - B, maxX: r + B, maxY: b + B }
+    ];
+  };
+  const preferredCache = /* @__PURE__ */ new Map();
+  const preferredFor = (edgeIdx) => {
+    const cached = preferredCache.get(edgeIdx);
+    if (cached !== void 0) return cached;
+    const e = layout.edges[edgeIdx];
+    const src = containers.get(e.source) ?? noContainers;
+    const tgt = containers.get(e.target) ?? noContainers;
+    const own = layout.groups.filter(
+      (g) => !g.collapsed && src.has(g.label) && tgt.has(g.label)
+    );
+    const out = [
+      ...obstaclesFor(edgeIdx),
+      ...titleRects,
+      ...own.flatMap(borderBands)
+    ];
+    preferredCache.set(edgeIdx, out);
+    return out;
+  };
+  const clearOfAll = (edgeIdx, cx, cy, w, h) => !overlapsAny(cx, cy, w, h, preferredFor(edgeIdx), BOX_CLEAR_PAD) && !crossesOtherEdge(edgeIdx, cx, cy, w, h);
+  const boxes = [];
+  layout.edges.forEach((e, idx) => {
+    if (!e.label || e.points.length < 2) return;
+    const m = measureEdgeLabel(e.label, fontSize, maxWidth);
+    const mid = edgePolylineMidpoint(e.points);
+    let cy = mid.y;
+    if (e.parallelCount > 1 && e.yOffset !== 0)
+      cy += (e.yOffset < 0 ? -1 : 1) * (m.height / 2);
+    boxes.push({
+      edgeIdx: idx,
+      cx: mid.x,
+      cy,
+      w: m.width,
+      h: m.height,
+      lines: m.lines,
+      resolved: true
+    });
+  });
+  for (const box of boxes) {
+    const obstacles = obstaclesFor(box.edgeIdx);
+    if (clearOfAll(box.edgeIdx, box.cx, box.cy, box.w, box.h)) continue;
+    const e = layout.edges[box.edgeIdx];
+    const { w, h } = box;
+    const mid = pointAtArcFraction(e.points, 0.5);
+    const side = (box.cx - mid.p.x) * mid.nx + (box.cy - mid.p.y) * mid.ny > 0 ? 1 : -1;
+    const ideal = findClearPosition(
+      e.points,
+      (x, y) => !clearOfAll(box.edgeIdx, x, y, w, h),
+      perpMax,
+      side
+    );
+    if (ideal) {
+      box.cx = ideal.x;
+      box.cy = ideal.y;
+      continue;
+    }
+    if (!overlapsAny(box.cx, box.cy, w, h, obstacles, BOX_CLEAR_PAD)) continue;
+    const clear = findClearPosition(
+      e.points,
+      (x, y) => overlapsAny(x, y, w, h, obstacles, BOX_CLEAR_PAD),
+      perpMax
+    ) ?? findClearPosition(
+      e.points,
+      (x, y) => overlapsAny(x, y, w, h, baseObstacles, BOX_CLEAR_PAD),
+      perpMax
+    );
+    if (clear) {
+      box.cx = clear.x;
+      box.cy = clear.y;
+    }
+    if (overlapsAny(box.cx, box.cy, box.w, box.h, obstacles, BOX_CLEAR_PAD))
+      box.resolved = false;
+  }
+  resolveLabelOverlaps(boxes);
+  for (const box of boxes) {
+    const obstacles = obstaclesFor(box.edgeIdx);
+    if (overlapsAny(box.cx, box.cy, box.w, box.h, obstacles, BOX_CLEAR_PAD))
+      box.resolved = false;
+  }
+  const boxByIdx = /* @__PURE__ */ new Map();
+  for (const b of boxes) boxByIdx.set(b.edgeIdx, b);
+  const edges = layout.edges.map((e, idx) => {
+    const b = boxByIdx.get(idx);
+    if (!b) return e;
+    return {
+      ...e,
+      labelX: b.cx,
+      labelY: b.cy,
+      labelWidth: b.w,
+      labelHeight: b.h,
+      labelLines: b.lines,
+      labelResolved: b.resolved
+    };
+  });
+  return {
+    layout: { ...layout, edges },
+    unresolved: boxes.filter((b) => !b.resolved).map((b) => b.edgeIdx)
+  };
+}
+
+export {
+  NODE_HEIGHT,
+  NODE_WIDTH,
+  EDGE_LABEL_FONT_SIZE,
+  BOX_CLEAR_PAD,
+  LABEL_REACH_WIDE,
+  measureEdgeLabel,
+  placeEdgeLabels
+};

package/dist/{chunk-UNSN56OJ.js → chunk-R2K5L4UA.js}

@@ -1,6 +1,6 @@
 import {
   EDGE_DASH
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   measureText
 } from "./chunk-KAO7JL4I.js";

package/dist/{chunk-SLMAAJPE.js → chunk-RGI64U3A.js}

@@ -1,6 +1,6 @@
 import {
   EDGE_DASH
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   layoutInlineHeader
 } from "./chunk-3DOQOXXI.js";

package/dist/{chunk-ZGHV4QLK.js → chunk-RJNZHFNG.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-5DH3KYFH.js";
 import {
   wrapDescriptionLines
-} from "./chunk-WMIKC5XO.js";
+} from "./chunk-NPWVOFB3.js";
 import {
   measureText
 } from "./chunk-KAO7JL4I.js";

package/dist/{chunk-FWNJDD4U.js → chunk-S7W75MIM.js}

@@ -1,26 +1,10 @@
+import {
+  safeHref
+} from "./chunk-Z6DXWULM.js";
 import {
   MONO_FAMILY
 } from "./chunk-ICLB27PZ.js";
 
-// src/utils/safe-href.ts
-var ALLOWED_SCHEMES = ["http", "https", "mailto"];
-var SCHEME_RE = /^([a-z][a-z0-9+.-]*):/i;
-var LEADING_TRIM_RE = /^[\x00-\x20]+/;
-function safeHref(url) {
-  if (typeof url !== "string") return null;
-  const trimmed = url.replace(LEADING_TRIM_RE, "");
-  if (trimmed.length === 0) return null;
-  const match = SCHEME_RE.exec(trimmed);
-  if (!match) {
-    return url;
-  }
-  const scheme = match[1].toLowerCase();
-  if (ALLOWED_SCHEMES.includes(scheme)) {
-    return url;
-  }
-  return null;
-}
-
 // src/utils/inline-markdown.ts
 function parseInlineMarkdown(text) {
   const spans = [];
@@ -88,7 +72,6 @@ function renderInlineText(textEl, text, palette, fontSize) {
 }
 
 export {
-  safeHref,
   parseInlineMarkdown,
   truncateBareUrl,
   stripInlineMarkdown,

package/dist/{chunk-ZUUNTOMG.js → chunk-UIUXIDBX.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-24YPR5EH.js";
 import {
   HEADER_HEIGHT
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   measureText,
   truncateText

package/dist/{chunk-XIYVGO24.js → chunk-UMRZPRAN.js}

@@ -1,10 +1,10 @@
 import {
   layoutOrg
-} from "./chunk-LRNIYQ6Y.js";
+} from "./chunk-33FQ6HNV.js";
 import {
   renderCollapseBar,
   renderNodeCard
-} from "./chunk-UNSN56OJ.js";
+} from "./chunk-R2K5L4UA.js";
 import {
   ScaleContext
 } from "./chunk-24YPR5EH.js";
@@ -24,7 +24,7 @@ import {
   META_LINE_HEIGHT,
   NODE_STROKE_WIDTH,
   SEPARATOR_GAP
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   extractExportSvg,
   runInExportContainer

package/dist/{chunk-67USWFFE.js → chunk-UY6TEJJH.js}

@@ -1,7 +1,7 @@
 import {
   EDGE_DASH,
   HAIRLINE_DASH
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   TITLE_FONT_SIZE,
   TITLE_FONT_WEIGHT,

package/dist/{chunk-UGYZ5Q5Y.js → chunk-VJ2KROJ5.js}

@@ -1,6 +1,6 @@
 import {
   buildMapProjection
-} from "./chunk-3MXJMZAN.js";
+} from "./chunk-BV6PKJUS.js";
 import {
   TITLE_FONT_SIZE,
   TITLE_Y

package/dist/{chunk-PSH5DT26.js → chunk-WZ23JJ7U.js}

@@ -4,14 +4,14 @@ import {
   layoutC4Containers,
   layoutC4Context,
   layoutC4Deployment
-} from "./chunk-A4PHPKNR.js";
+} from "./chunk-DAX42XVH.js";
 import {
   appendArrowheadMarkers,
   appendReverseArrowheadMarkers
 } from "./chunk-XBJJP2HN.js";
 import {
   renderInlineText
-} from "./chunk-FWNJDD4U.js";
+} from "./chunk-S7W75MIM.js";
 import {
   ARROWHEAD_HEIGHT,
   ARROWHEAD_WIDTH,
@@ -25,7 +25,7 @@ import {
   META_FONT_SIZE,
   META_LINE_HEIGHT,
   NODE_STROKE_WIDTH
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   serializeSvg
 } from "./chunk-LD2JSKU3.js";

package/dist/{chunk-IIEI7VK5.js → chunk-XCKNFFKM.js}

@@ -5,6 +5,7 @@ var CARD_RADIUS = 6;
 var CONTAINER_RADIUS = 8;
 var COLLAPSE_BAR_INSET = 0;
 var EDGE_LABEL_KNOCKOUT_OPACITY = 0.9;
+var EDGE_LABEL_UNRESOLVED_KNOCKOUT_OPACITY = 1;
 var ARROWHEAD_WIDTH = 10;
 var ARROWHEAD_HEIGHT = 7;
 var EDGE_DASH = "6 3";
@@ -31,6 +32,7 @@ export {
   CONTAINER_RADIUS,
   COLLAPSE_BAR_INSET,
   EDGE_LABEL_KNOCKOUT_OPACITY,
+  EDGE_LABEL_UNRESOLVED_KNOCKOUT_OPACITY,
   ARROWHEAD_WIDTH,
   ARROWHEAD_HEIGHT,
   EDGE_DASH,