@diagrammo/dgmo 0.92.1 → 0.94.0

package/dist/{chunk-MDVJYRJT.js → chunk-3TWBMU7K.js}

@@ -4,26 +4,27 @@ import {
 } from "./chunk-26EVL454.js";
 import {
   layoutGraph
-} from "./chunk-5SSTVFPX.js";
+} from "./chunk-JT2BG7LM.js";
 import {
   appendArrowheadMarkers
 } from "./chunk-XBJJP2HN.js";
-import {
-  NOTE_BADGE_RADIUS,
-  noteConnectorPoints,
-  renderNoteBadge,
-  renderNoteBox,
-  renderNoteConnector
-} from "./chunk-JRWUHLRP.js";
 import {
   fitDiagramToCanvas
 } from "./chunk-EPDBWATV.js";
+import {
+  serializeSvg
+} from "./chunk-CYRB2JTN.js";
 import {
   ScaleContext
 } from "./chunk-24YPR5EH.js";
 import {
-  renderIntegratedLegend
-} from "./chunk-NMS5XSLX.js";
+  layoutInlineHeader
+} from "./chunk-UIEKW4SG.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y
+} from "./chunk-VLC6WNRD.js";
 import {
   ARROWHEAD_HEIGHT,
   ARROWHEAD_WIDTH,
@@ -32,26 +33,25 @@ import {
   NODE_STROKE_WIDTH
 } from "./chunk-XCKNFFKM.js";
 import {
-  layoutInlineHeader
-} from "./chunk-42UJ23H3.js";
-import {
-  serializeSvg
-} from "./chunk-CYRB2JTN.js";
+  renderIntegratedLegend
+} from "./chunk-NMS5XSLX.js";
 import {
   getLegendExtent,
   getMaxLegendReservedHeight
 } from "./chunk-JILEYZ2V.js";
 import {
-  TITLE_FONT_SIZE,
-  TITLE_FONT_WEIGHT,
-  TITLE_Y
-} from "./chunk-VLC6WNRD.js";
+  parseState
+} from "./chunk-2MS623GW.js";
+import {
+  NOTE_BADGE_RADIUS,
+  noteConnectorPoints,
+  renderNoteBadge,
+  renderNoteBox,
+  renderNoteConnector
+} from "./chunk-VDY2GR6U.js";
 import {
   FONT_FAMILY
 } from "./chunk-ICLB27PZ.js";
-import {
-  parseState
-} from "./chunk-2YAFDND3.js";
 import {
   resolveActiveTagGroup,
   resolveGroupTagColor,

package/dist/{chunk-FTUMRSGT.js → chunk-3ZP3QC47.js}

@@ -1,298 +1,21 @@
 import {
-  noteBoxSize
-} from "./chunk-RJNZHFNG.js";
-import {
-  noteConnectorPoints
-} from "./chunk-JRWUHLRP.js";
-import {
-  NOTE_GAP
-} from "./chunk-5DH3KYFH.js";
+  NODE_HEIGHT,
+  NODE_WIDTH
+} from "./chunk-WTTIODDV.js";
 import {
   LABEL_REACH_WIDE,
-  NODE_HEIGHT,
-  NODE_WIDTH,
   placeEdgeLabels
-} from "./chunk-QT3KDDXK.js";
+} from "./chunk-IN7XI6NO.js";
 import {
+  buildPlacedNotes,
+  noteCanvasShift,
   resolveNotes
-} from "./chunk-O753JUEZ.js";
+} from "./chunk-7SXV7NUS.js";
 import {
   measureText,
   wrapTextToWidth
 } from "./chunk-KAO7JL4I.js";
 
-// src/utils/notes/place.ts
-var NOTE_CLEAR = 14;
-var intersects = (a, b, pad) => !(a.right + pad <= b.left || b.right + pad <= a.left || a.bottom + pad <= b.top || b.bottom + pad <= a.top);
-var CONNECTOR_CLEAR = 4;
-var EDGE_CLEAR = 6;
-var SLIDE_STEP = 10;
-var SEARCH_REACH = 480;
-var segmentCrosses = (x1, y1, x2, y2, r) => {
-  const dx = x2 - x1;
-  const dy = y2 - y1;
-  const p = [-dx, dx, -dy, dy];
-  const q = [x1 - r.left, r.right - x1, y1 - r.top, r.bottom - y1];
-  let t0 = 0;
-  let t1 = 1;
-  for (let i = 0; i < 4; i++) {
-    const pi = p[i];
-    const qi = q[i];
-    if (pi === 0) {
-      if (qi <= 0) return false;
-      continue;
-    }
-    const t = qi / pi;
-    if (pi < 0) t0 = Math.max(t0, t);
-    else t1 = Math.min(t1, t);
-  }
-  return t0 < t1;
-};
-function placeNotes(obstacles, requests, direction, edges = []) {
-  const placements = /* @__PURE__ */ new Map();
-  const occupied = obstacles.map((p) => ({
-    left: p.x - p.width / 2,
-    top: p.y - p.height / 2,
-    right: p.x + p.width / 2,
-    bottom: p.y + p.height / 2
-  }));
-  for (const req of requests) {
-    if (req.collapsed) {
-      placements.set(req.key, {
-        collapsed: true,
-        side: "right",
-        x: 0,
-        y: 0
-      });
-      continue;
-    }
-    const p = req.node;
-    const cx = p.x;
-    const cy = p.y;
-    const nodeLeft = cx - p.width / 2;
-    const nodeRight = cx + p.width / 2;
-    const nodeTop = cy - p.height / 2;
-    const nodeBottom = cy + p.height / 2;
-    const { noteW, noteH } = req;
-    const rectFor = (side) => {
-      switch (side) {
-        case "right": {
-          const left = nodeRight + NOTE_GAP;
-          const top = cy - noteH / 2;
-          return { left, top, right: left + noteW, bottom: top + noteH };
-        }
-        case "left": {
-          const right = nodeLeft - NOTE_GAP;
-          const top = cy - noteH / 2;
-          return { left: right - noteW, top, right, bottom: top + noteH };
-        }
-        case "below": {
-          const left = cx - noteW / 2;
-          const top = nodeBottom + NOTE_GAP;
-          return { left, top, right: left + noteW, bottom: top + noteH };
-        }
-        case "above":
-        default: {
-          const left = cx - noteW / 2;
-          const bottom = nodeTop - NOTE_GAP;
-          return { left, top: bottom - noteH, right: left + noteW, bottom };
-        }
-      }
-    };
-    const order = direction === "LR" ? ["below", "above", "right", "left"] : ["right", "left", "below", "above"];
-    const anchor = {
-      left: nodeLeft,
-      top: nodeTop,
-      right: nodeRight,
-      bottom: nodeBottom
-    };
-    const isAnchor = (o) => o.left === anchor.left && o.top === anchor.top && o.right === anchor.right && o.bottom === anchor.bottom;
-    const connector = (rect, side) => {
-      const [x1, y1, x2, y2] = noteConnectorPoints(p, {
-        x: rect.left - cx,
-        y: rect.top - cy,
-        width: noteW,
-        height: noteH,
-        side
-      });
-      return [cx + x1, cy + y1, cx + x2, cy + y2];
-    };
-    const onEdge = (rect) => {
-      const padded = {
-        left: rect.left - EDGE_CLEAR,
-        top: rect.top - EDGE_CLEAR,
-        right: rect.right + EDGE_CLEAR,
-        bottom: rect.bottom + EDGE_CLEAR
-      };
-      return edges.some(
-        (path) => path.some(
-          (pt, i) => i > 0 && segmentCrosses(path[i - 1].x, path[i - 1].y, pt.x, pt.y, padded)
-        )
-      );
-    };
-    const isClear = (rect, side, avoidEdges) => {
-      if (occupied.some((o) => intersects(rect, o, NOTE_CLEAR))) return false;
-      if (avoidEdges && onEdge(rect)) return false;
-      const [x1, y1, x2, y2] = connector(rect, side);
-      return !occupied.some(
-        (o) => !isAnchor(o) && segmentCrosses(x1, y1, x2, y2, {
-          left: o.left - CONNECTOR_CLEAR,
-          top: o.top - CONNECTOR_CLEAR,
-          right: o.right + CONNECTOR_CLEAR,
-          bottom: o.bottom + CONNECTOR_CLEAR
-        })
-      );
-    };
-    const search = (avoidEdges) => {
-      let chosen2 = null;
-      for (const side of order.slice(0, 2)) {
-        const rect = rectFor(side);
-        if (isClear(rect, side, avoidEdges)) {
-          chosen2 = { rect, side };
-          break;
-        }
-      }
-      if (chosen2) return chosen2;
-      let bestLen = Infinity;
-      for (const side of order) {
-        const axisIsY = side === "above" || side === "below";
-        const outward = side === "below" || side === "right" ? 1 : -1;
-        const reach = axisIsY ? noteW / 2 : SEARCH_REACH;
-        const slides = [0];
-        for (let s = SLIDE_STEP; s <= reach; s += SLIDE_STEP) {
-          slides.push(s, -s);
-        }
-        const base = rectFor(side);
-        for (let out = 0; out <= SEARCH_REACH; out += NOTE_CLEAR) {
-          for (const slide of slides) {
-            const dx = axisIsY ? slide : out * outward;
-            const dy = axisIsY ? out * outward : slide;
-            const rect = {
-              left: base.left + dx,
-              top: base.top + dy,
-              right: base.right + dx,
-              bottom: base.bottom + dy
-            };
-            if (!isClear(rect, side, avoidEdges)) continue;
-            const [x1, y1, x2, y2] = connector(rect, side);
-            const len = Math.hypot(x2 - x1, y2 - y1);
-            if (len < bestLen) {
-              bestLen = len;
-              chosen2 = { rect, side };
-            }
-          }
-        }
-      }
-      return chosen2;
-    };
-    let chosen = search(true) ?? search(false);
-    if (!chosen) {
-      const side = order[0];
-      let rect = rectFor(side);
-      const axisIsY = side === "above" || side === "below";
-      const outward = side === "below" || side === "right" ? 1 : -1;
-      for (let guard = 0; guard < 50; guard++) {
-        const blockers = occupied.filter(
-          (o) => intersects(rect, o, NOTE_CLEAR)
-        );
-        if (blockers.length === 0) break;
-        if (axisIsY && outward > 0) {
-          const top = Math.max(...blockers.map((b) => b.bottom)) + NOTE_CLEAR;
-          rect = { ...rect, top, bottom: top + noteH };
-        } else if (axisIsY) {
-          const bottom = Math.min(...blockers.map((b) => b.top)) - NOTE_CLEAR;
-          rect = { ...rect, bottom, top: bottom - noteH };
-        } else if (outward > 0) {
-          const left = Math.max(...blockers.map((b) => b.right)) + NOTE_CLEAR;
-          rect = { ...rect, left, right: left + noteW };
-        } else {
-          const right = Math.min(...blockers.map((b) => b.left)) - NOTE_CLEAR;
-          rect = { ...rect, right, left: right - noteW };
-        }
-      }
-      chosen = { rect, side };
-    }
-    occupied.push(chosen.rect);
-    placements.set(req.key, {
-      collapsed: false,
-      side: chosen.side,
-      x: chosen.rect.left - p.x,
-      y: chosen.rect.top - p.y
-    });
-  }
-  return placements;
-}
-
-// src/utils/notes/build.ts
-function buildPlacedNotes(anchors, noteByNode, direction, collapsedNotes) {
-  const placed = /* @__PURE__ */ new Map();
-  if (noteByNode.size === 0) return placed;
-  const geoms = /* @__PURE__ */ new Map();
-  const requests = [];
-  for (const a of anchors) {
-    const note = noteByNode.get(a.id);
-    if (!note) continue;
-    const size = noteBoxSize(note.body);
-    geoms.set(a.id, {
-      noteW: size.width,
-      noteH: size.height,
-      ...note.color && { color: note.color },
-      lines: size.lines,
-      lineNumber: note.lineNumber,
-      endLineNumber: note.endLineNumber
-    });
-    requests.push({
-      key: a.id,
-      node: { x: a.x, y: a.y, width: a.width, height: a.height },
-      noteW: size.width,
-      noteH: size.height,
-      collapsed: collapsedNotes?.has(note.lineNumber) ?? false
-    });
-  }
-  const placements = placeNotes(
-    anchors.map((a) => ({ x: a.x, y: a.y, width: a.width, height: a.height })),
-    requests,
-    direction
-  );
-  for (const [id, g] of geoms) {
-    const p = placements.get(id);
-    placed.set(
-      id,
-      p.collapsed ? {
-        x: 0,
-        y: 0,
-        width: 0,
-        height: 0,
-        side: "right",
-        ...g.color && { color: g.color },
-        lines: [],
-        lineNumber: g.lineNumber,
-        endLineNumber: g.endLineNumber,
-        collapsed: true
-      } : {
-        x: p.x,
-        y: p.y,
-        width: g.noteW,
-        height: g.noteH,
-        side: p.side,
-        ...g.color && { color: g.color },
-        lines: g.lines,
-        lineNumber: g.lineNumber,
-        endLineNumber: g.endLineNumber
-      }
-    );
-  }
-  return placed;
-}
-
-// src/utils/notes/bounds.ts
-function noteCanvasShift(minX, minY, margin = 20) {
-  return {
-    shiftX: minX < 0 ? margin - minX : 0,
-    shiftY: minY < 0 ? margin - minY : 0
-  };
-}
-
 // src/boxes-and-lines/layout.ts
 var MARGIN = 40;
 var MAX_PARALLEL_EDGES = 5;
@@ -382,7 +105,7 @@ function computeNodeSize(node, reserveValueRow) {
   return { width: w, height: Math.max(NODE_HEIGHT, totalHeight) };
 }
 async function layoutBoxesAndLines(parsed, collapseInfo, layoutOptions) {
-  const { layoutBoxesAndLinesSearch } = await import("./layout-search-PMYL3VWS.js");
+  const { layoutBoxesAndLinesSearch } = await import("./layout-search-BBX2BMEF.js");
   const searchOpts = {
     ...layoutOptions?.hideDescriptions !== void 0 && {
       hideDescriptions: layoutOptions.hideDescriptions
@@ -698,9 +421,6 @@ function applyParallelEdgeOffsets(layout) {
 }
 
 export {
-  placeNotes,
-  buildPlacedNotes,
-  noteCanvasShift,
   computeNodeSize,
   layoutBoxesAndLines
 };

package/dist/{chunk-J2E7EUER.js → chunk-4EX4OKGZ.js}

@@ -12,14 +12,23 @@ import {
   appendArrowheadMarkers
 } from "./chunk-XBJJP2HN.js";
 import {
-  renderInlineText
-} from "./chunk-S7W75MIM.js";
+  placeEdgeLabels
+} from "./chunk-IN7XI6NO.js";
+import {
+  parseInfra
+} from "./chunk-UXNA2H2V.js";
 import {
   ScaleContext
 } from "./chunk-24YPR5EH.js";
 import {
-  renderIntegratedLegend
-} from "./chunk-NMS5XSLX.js";
+  layoutInlineHeader
+} from "./chunk-UIEKW4SG.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_OFFSET,
+  TITLE_Y
+} from "./chunk-VLC6WNRD.js";
 import {
   ARROWHEAD_HEIGHT,
   ARROWHEAD_WIDTH,
@@ -31,27 +40,21 @@ import {
   NODE_STROKE_WIDTH
 } from "./chunk-XCKNFFKM.js";
 import {
-  layoutInlineHeader
-} from "./chunk-42UJ23H3.js";
+  renderIntegratedLegend
+} from "./chunk-NMS5XSLX.js";
 import {
   getLegendExtent,
   getMaxLegendReservedHeight
 } from "./chunk-JILEYZ2V.js";
 import {
-  TITLE_FONT_SIZE,
-  TITLE_FONT_WEIGHT,
-  TITLE_OFFSET,
-  TITLE_Y
-} from "./chunk-VLC6WNRD.js";
+  preprocessDescriptionLine
+} from "./chunk-IYULMRBE.js";
+import {
+  renderInlineText
+} from "./chunk-QKPOIJBT.js";
 import {
   FONT_FAMILY
 } from "./chunk-ICLB27PZ.js";
-import {
-  parseInfra
-} from "./chunk-SOHZDW6N.js";
-import {
-  preprocessDescriptionLine
-} from "./chunk-IYULMRBE.js";
 import {
   tagAttrKey
 } from "./chunk-4SACN2C5.js";
@@ -968,17 +971,66 @@ function renderEdgePaths(svg, edges, nodes, groups, palette, _isDark, animate, d
     }
   }
 }
+function placeInfraEdgeLabels(routes, edges, nodes, groups, fontSize) {
+  const adapted = {
+    nodes: nodes.map((n) => ({
+      label: n.id,
+      x: n.x,
+      y: n.y,
+      width: n.width,
+      height: n.height
+    })),
+    groups: groups.map((g) => ({
+      label: g.id,
+      lineNumber: g.lineNumber,
+      x: g.x + g.width / 2,
+      y: g.y + g.height / 2,
+      width: g.width,
+      height: g.height,
+      collapsed: false
+    })),
+    width: 0,
+    height: 0,
+    edges: edges.map((e, idx) => ({
+      source: e.sourceId,
+      target: e.targetId,
+      ...e.label && { label: e.label },
+      bidirectional: false,
+      lineNumber: e.lineNumber,
+      points: routes[idx] ?? [],
+      yOffset: 0,
+      parallelCount: 1,
+      metadata: {}
+    }))
+  };
+  const blGroups = groups.map((g) => ({
+    label: g.id,
+    children: nodes.filter((n) => n.groupId === g.id).map((n) => n.id),
+    lineNumber: g.lineNumber,
+    metadata: {}
+  }));
+  const placed = placeEdgeLabels(adapted, {
+    fontSize,
+    maxWidth: Number.POSITIVE_INFINITY,
+    groups: blGroups
+  });
+  const out = /* @__PURE__ */ new Map();
+  placed.layout.edges.forEach((e, idx) => {
+    if (e.labelX !== void 0 && e.labelY !== void 0)
+      out.set(idx, { x: e.labelX, y: e.labelY });
+  });
+  return out;
+}
 function renderEdgeLabels(svg, edges, nodes, groups, palette, _isDark, animate, direction, sc = buildScaledConstants(ScaleContext.identity())) {
   const nodeMap = nodeMapWithGroups(nodes, groups);
   const { srcPts, tgtPts } = computePortPts(edges, nodeMap, direction);
-  for (const edge of edges) {
-    if (edge.points.length === 0) continue;
-    if (!edge.label) continue;
+  const routes = edges.map((edge) => {
+    if (edge.points.length === 0) return [];
     const sourceNode = nodeMap.get(edge.sourceId);
     const targetNode = nodeMap.get(edge.targetId);
-    if (!sourceNode || !targetNode) continue;
+    if (!sourceNode || !targetNode) return [];
     const key = `${edge.sourceId}:${edge.targetId}`;
-    const wps = edgeWaypoints(
+    return edgeWaypoints(
       sourceNode,
       targetNode,
       groups,
@@ -988,7 +1040,18 @@ function renderEdgeLabels(svg, edges, nodes, groups, palette, _isDark, animate,
       srcPts.get(key),
       tgtPts.get(key)
     );
-    const midPt = wps[Math.floor(wps.length / 2)];
+  });
+  const labelPts = placeInfraEdgeLabels(
+    routes,
+    edges,
+    nodes,
+    groups,
+    EDGE_LABEL_FONT_SIZE
+  );
+  for (const [idx, edge] of edges.entries()) {
+    if (!edge.label) continue;
+    const wps = routes[idx];
+    const midPt = labelPts.get(idx);
     if (!midPt) continue;
     const labelText = edge.label;
     const g = svg.append("g").attr("class", animate ? "infra-edge-label" : "");