@diagrammo/dgmo 0.84.0 → 0.86.0

package/dist/chunk-TW6WMZFW.js

@@ -0,0 +1,287 @@
+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
+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;
+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(w, h, points, obstacles, perpMax) {
+  const ts = slideFractions();
+  for (const t of ts) {
+    const { p } = pointAtArcFraction(points, t);
+    if (!overlapsAny(p.x, p.y, w, h, obstacles, BOX_CLEAR_PAD)) 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 [-1, 1]) {
+        const x = p.x + nx * mag * sign;
+        const y = p.y + ny * mag * sign;
+        if (!overlapsAny(x, y, w, h, obstacles, BOX_CLEAR_PAD)) return { x, y };
+      }
+    }
+  }
+  return null;
+}
+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 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 (!overlapsAny(box.cx, box.cy, box.w, box.h, obstacles, BOX_CLEAR_PAD))
+      continue;
+    const e = layout.edges[box.edgeIdx];
+    const clear = findClearPosition(box.w, box.h, e.points, obstacles, perpMax) ?? findClearPosition(box.w, box.h, e.points, baseObstacles, 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-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-YWHGWLY6.js → chunk-VEE777MD.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-WMIKC5XO.js";
 import {
   renderNodeCard
-} from "./chunk-UNSN56OJ.js";
+} from "./chunk-R2K5L4UA.js";
 import {
   renderInlineText
 } from "./chunk-FWNJDD4U.js";
 import {
   formatDateLabel
-} from "./chunk-ULCB4BLF.js";
+} from "./chunk-QPE646M2.js";
 import {
   CARD_RADIUS,
   HAIRLINE_DASH,
@@ -17,7 +17,7 @@ import {
   LABEL_FONT_SIZE,
   NODE_STROKE_WIDTH,
   SEPARATOR_GAP
-} from "./chunk-IIEI7VK5.js";
+} from "./chunk-XCKNFFKM.js";
 import {
   layoutInlineHeader
 } from "./chunk-3DOQOXXI.js";

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-6EV2F6W7.js → chunk-VPASQOR3.js}

@@ -41,6 +41,22 @@ import {
   suggest
 } from "./chunk-BYU54C3S.js";
 
+// src/sequence/diagnostics.ts
+var SEQUENCE_DIAGNOSTIC_CODES = {
+  GROUP_DEPTH: "E_SEQ_GROUP_DEPTH"
+};
+var SEQUENCE_DIAGNOSTICS = [
+  {
+    code: SEQUENCE_DIAGNOSTIC_CODES.GROUP_DEPTH,
+    severity: "error",
+    chartType: "sequence",
+    title: "Group nested too deep",
+    message: (p) => `Group "${String(p.label ?? "?")}" is nested ${String(p.depth ?? "?")} levels deep \u2014 participant groups nest to depth ${String(p.max ?? "?")}; its participants join the group above it`,
+    hint: "Move the inner [Group] up a level \u2014 two levels of bracket is the bound.",
+    example: "sequence\n[Monolith]\n  [Linux]\n    [Container]\n      App"
+  }
+];
+
 // src/sequence/parser.ts
 var KNOWN_SEQ_OPTIONS = /* @__PURE__ */ new Set(["active-tag"]);
 var KNOWN_SEQ_BOOLEANS = /* @__PURE__ */ new Set([
@@ -70,6 +86,7 @@ function isSequenceNote(el) {
 }
 var IS_A_PATTERN = /^([^:]+?)\s+is\s+an?\s+(\w+)(?:\s+(.+))?$/i;
 var COLORED_PARTICIPANT_PATTERN = /^(\S+?)\((red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white)\)\s*$/;
+var MAX_GROUP_DEPTH = 2;
 var GROUP_HEADING_PATTERN = /^\[([^\]|]+?)(?:\(([^)]+)\))?\]\s*(.*)$/;
 var GROUP_HEADING_FALLBACK = /^\[([^\]]+)\]\s*(.*)$/;
 var SECTION_PATTERN = /^==\s+(.+?)(?:\s*==)?\s*$/;
@@ -218,8 +235,8 @@ function parseSequenceDgmo(content, palette) {
     return nameAliasMap.resolve(trimmed) ?? trimmed;
   };
   const fail = makeFail(result);
-  const pushError = (line, message) => {
-    const diag = makeDgmoError(line, message);
+  const pushError = (line, message, code) => {
+    const diag = makeDgmoError(line, message, "error", code);
     result.diagnostics.push(diag);
     if (!result.error) result.error = formatDgmoError(diag);
   };
@@ -249,7 +266,31 @@ function parseSequenceDgmo(content, palette) {
     }
     break;
   }
-  let activeGroup = null;
+  const groupStack = [];
+  const activeGroup = () => groupStack.length > 0 ? groupStack[groupStack.length - 1].group : null;
+  const closeGroupsTo = (indent) => {
+    while (groupStack.length > 0 && groupStack[groupStack.length - 1].indent >= indent) {
+      groupStack.pop();
+    }
+  };
+  const joinActiveGroup = (key, id, lineNumber) => {
+    const innermost = activeGroup();
+    if (!innermost || innermost.participantIds.includes(key)) return;
+    const existingGroup = participantGroupMap.get(key);
+    if (existingGroup) {
+      pushError(
+        lineNumber,
+        `Participant '${id}' is already in group '${existingGroup}' \u2014 participants can only belong to one group`
+      );
+      return;
+    }
+    for (const frame of groupStack) {
+      if (!frame.group.participantIds.includes(key)) {
+        frame.group.participantIds.push(key);
+      }
+    }
+    participantGroupMap.set(key, innermost.name);
+  };
   const participantIds = /* @__PURE__ */ new Set();
   const idByKey = /* @__PURE__ */ new Map();
   const addParticipant = (name, lineNumber, extras) => {
@@ -364,7 +405,7 @@ function parseSequenceDgmo(content, palette) {
     const lineNumber = i + 1;
     nameAliasMap.at(lineNumber);
     if (!trimmed) {
-      activeGroup = null;
+      closeGroupsTo(0);
       currentTagGroup = null;
       continue;
     }
@@ -407,14 +448,29 @@ function parseSequenceDgmo(content, palette) {
         );
       }
       contentStarted = true;
-      activeGroup = {
+      const headingIndent = measureIndent(raw);
+      closeGroupsTo(headingIndent);
+      const depth = groupStack.length;
+      if (depth >= MAX_GROUP_DEPTH) {
+        pushError(
+          lineNumber,
+          `Group '${groupName}' is nested ${String(depth + 1)} levels deep \u2014 participant groups nest to depth ${String(MAX_GROUP_DEPTH)}; its participants join the group above it`,
+          SEQUENCE_DIAGNOSTIC_CODES.GROUP_DEPTH
+        );
+        continue;
+      }
+      const parentGroup = activeGroup();
+      const group = {
         name: groupName,
         participantIds: [],
         lineNumber,
+        depth,
+        ...parentGroup ? { parent: parentGroup.name } : {},
         ...groupMeta ? { metadata: groupMeta } : {},
         ...isCollapsed ? { collapsed: true } : {}
       };
-      result.groups.push(activeGroup);
+      result.groups.push(group);
+      groupStack.push({ group, indent: headingIndent });
       continue;
     }
     if (trimmed.startsWith("[")) {
@@ -431,9 +487,7 @@ function parseSequenceDgmo(content, palette) {
         continue;
       }
     }
-    if (activeGroup && measureIndent(raw) === 0) {
-      activeGroup = null;
-    }
+    closeGroupsTo(measureIndent(raw));
     if (trimmed.startsWith("//")) continue;
     if (trimmed.startsWith("#")) {
       pushError(lineNumber, "Use // for comments");
@@ -623,18 +677,7 @@ function parseSequenceDgmo(content, palette) {
         ...position !== void 0 && { position },
         ...isAMeta !== void 0 && { metadata: isAMeta }
       });
-      if (activeGroup && !activeGroup.participantIds.includes(key)) {
-        const existingGroup = participantGroupMap.get(key);
-        if (existingGroup) {
-          pushError(
-            lineNumber,
-            `Participant '${id}' is already in group '${existingGroup}' \u2014 participants can only belong to one group`
-          );
-        } else {
-          activeGroup.participantIds.push(key);
-          participantGroupMap.set(key, activeGroup.name);
-        }
-      }
+      joinActiveGroup(key, id, lineNumber);
       continue;
     }
     const { core: colorCore, meta: colorMeta } = splitPipe(trimmed, lineNumber);
@@ -650,18 +693,7 @@ function parseSequenceDgmo(content, palette) {
       const key = addParticipant(id, lineNumber, {
         ...colorMeta !== void 0 && { metadata: colorMeta }
       });
-      if (activeGroup && !activeGroup.participantIds.includes(key)) {
-        const existingGroup = participantGroupMap.get(key);
-        if (existingGroup) {
-          pushError(
-            lineNumber,
-            `Participant '${id}' is already in group '${existingGroup}' \u2014 participants can only belong to one group`
-          );
-        } else {
-          activeGroup.participantIds.push(key);
-          participantGroupMap.set(key, activeGroup.name);
-        }
-      }
+      joinActiveGroup(key, id, lineNumber);
       continue;
     }
     {
@@ -670,7 +702,7 @@ function parseSequenceDgmo(content, palette) {
         meta: bareMeta,
         alias: bareAlias
       } = splitPipe(trimmed, lineNumber);
-      const inGroup = activeGroup && measureIndent(raw) > 0;
+      const inGroup = activeGroup() !== null && measureIndent(raw) > 0;
       if (/^\S+$/.test(bareCore) && !ARROW_PATTERN.test(bareCore) && (inGroup || !bodyStarted || bareMeta)) {
         contentStarted = true;
         const id = bareCore;
@@ -682,18 +714,7 @@ function parseSequenceDgmo(content, palette) {
           ...position !== void 0 && { position },
           ...bareMeta !== void 0 && { metadata: bareMeta }
         });
-        if (activeGroup && !activeGroup.participantIds.includes(key)) {
-          const existingGroup = participantGroupMap.get(key);
-          if (existingGroup) {
-            pushError(
-              lineNumber,
-              `Participant '${id}' is already in group '${existingGroup}' \u2014 participants can only belong to one group`
-            );
-          } else {
-            activeGroup.participantIds.push(key);
-            participantGroupMap.set(key, activeGroup.name);
-          }
-        }
+        joinActiveGroup(key, id, lineNumber);
         continue;
       }
     }
@@ -1066,6 +1087,7 @@ function looksLikeSequence(content) {
 }
 
 export {
+  SEQUENCE_DIAGNOSTICS,
   isSequenceBlock,
   isSequenceSection,
   isSequenceNote,

package/dist/{chunk-OGKP2XGJ.js → chunk-VPVWG2GH.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-24YPR5EH.js";
 import {
   CARD_RADIUS
-} 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,