@diagrammo/dgmo 0.86.0 → 0.88.0

package/dist/{chunk-TW6WMZFW.js → chunk-QT3KDDXK.js}

@@ -10,6 +10,7 @@ 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;
@@ -21,6 +22,12 @@ 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) {
@@ -108,24 +115,69 @@ function slideFractions() {
   }
   return out;
 }
-function findClearPosition(w, h, points, obstacles, perpMax) {
+function findClearPosition(points, blocked, perpMax, firstSide = -1) {
   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;
+    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 [-1, 1]) {
+      for (const sign of [firstSide, -firstSide]) {
         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 };
+        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();
@@ -218,6 +270,81 @@ function placeEdgeLabels(layout, opts) {
     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;
@@ -238,10 +365,32 @@ function placeEdgeLabels(layout, opts) {
   });
   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;
+    if (clearOfAll(box.edgeIdx, box.cx, box.cy, box.w, box.h)) 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);
+    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;

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,