@diagrammo/dgmo 0.91.1 → 0.92.1

package/dist/{chunk-NWPMLX2V.js → chunk-X5BUX2GK.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-EJS3K44P.js";
 import {
   computeNodeSize
-} from "./chunk-Q3N7PI3B.js";
+} from "./chunk-FTUMRSGT.js";
 import {
   EDGE_LABEL_FONT_SIZE,
   NODE_HEIGHT,
@@ -804,7 +804,7 @@ var ESCALATE_REFINE = 10;
 var SEARCH_WORK_CAP = 36e3;
 var MIN_SEARCH_CANDIDATES = 6;
 function searchBudget(nodes, edges) {
-  const seeds = nodes <= 12 ? 20 : nodes <= 22 ? 40 : nodes <= 35 ? 22 : 10;
+  const seeds = nodes <= 22 ? 20 : nodes <= 35 ? 22 : 10;
   const size = Math.max(1, nodes + edges);
   return {
     seeds,
@@ -1278,6 +1278,75 @@ function countGroupOverlaps(layout, opts) {
     }
   return count;
 }
+var FOREIGN_GROUP_MIN_DEPTH = 12;
+var HOLDINGS_CACHE = /* @__PURE__ */ new WeakMap();
+function groupHoldings(groups) {
+  const hit = HOLDINGS_CACHE.get(groups);
+  if (hit) return hit;
+  const byLabel = new Map(groups.map((g) => [g.label, g]));
+  const memo = /* @__PURE__ */ new Map();
+  const walk = (label, seen) => {
+    const done = memo.get(label);
+    if (done) return done;
+    const out = /* @__PURE__ */ new Set(["__group_" + label]);
+    const g = byLabel.get(label);
+    if (!g || seen.has(label)) return out;
+    seen.add(label);
+    for (const c of g.children) {
+      out.add(c);
+      out.add("__group_" + c);
+      if (byLabel.has(c)) for (const k of walk(c, seen)) out.add(k);
+    }
+    memo.set(label, out);
+    return out;
+  };
+  for (const g of groups) walk(g.label, /* @__PURE__ */ new Set());
+  HOLDINGS_CACHE.set(groups, memo);
+  return memo;
+}
+function segmentEntersRect(a, b, l, t, r, bot) {
+  let t0 = 0, t1 = 1;
+  const dx = b.x - a.x, dy = b.y - a.y;
+  const clip = (p, q) => {
+    if (p === 0) return q > 0;
+    const u = q / p;
+    if (p < 0) {
+      if (u >= t1) return false;
+      if (u > t0) t0 = u;
+    } else {
+      if (u <= t0) return false;
+      if (u < t1) t1 = u;
+    }
+    return true;
+  };
+  return clip(-dx, a.x - l) && clip(dx, r - a.x) && clip(-dy, a.y - t) && clip(dy, bot - a.y) && t0 < t1;
+}
+function countForeignGroupCrossings(layout, groups, opts) {
+  const d = opts?.minDepth ?? FOREIGN_GROUP_MIN_DEPTH;
+  const boxes = layout.groups.filter((g) => !g.collapsed);
+  if (boxes.length === 0) return 0;
+  const holdings = groupHoldings(groups);
+  const polys = flatPolys(layout);
+  let count = 0;
+  layout.edges.forEach((e, idx) => {
+    const poly = polys[idx];
+    if (poly.pts.length < 2) return;
+    for (const g of boxes) {
+      const held = holdings.get(g.label);
+      if (!held || held.has(e.source) || held.has(e.target)) continue;
+      const l = g.x - g.width / 2 + d, r = g.x + g.width / 2 - d, t = g.y - g.height / 2 + d, b = g.y + g.height / 2 - d;
+      if (!(l < r) || !(t < b)) continue;
+      if (poly.x1 <= l || poly.x0 >= r || poly.y1 <= t || poly.y0 >= b)
+        continue;
+      for (let i = 0; i + 1 < poly.pts.length; i++)
+        if (segmentEntersRect(poly.pts[i], poly.pts[i + 1], l, t, r, b)) {
+          count++;
+          break;
+        }
+    }
+  });
+  return count;
+}
 function separateGroupBands(layout, parsed) {
   if (layout.groups.some((g) => g.collapsed)) return layout;
   if (countGroupOverlaps(layout) === 0) return layout;
@@ -1643,12 +1712,7 @@ async function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
       dagre.layout(g, {
         customOrder: (lg, order) => {
           order(lg, {});
-          applyOrderPlan(
-            lg,
-            realBoxes,
-            plan.forced,
-            plan.captured
-          );
+          applyOrderPlan(lg, realBoxes, plan.forced, plan.captured);
         }
       });
     else dagre.layout(g);
@@ -1862,13 +1926,17 @@ async function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
   let best = pool[0];
   let bestObj = Infinity;
   let bestBad = Infinity;
+  let bestForeign = Infinity;
   const consider = (lay) => {
     const bad = badness(lay, bestBad);
-    if (bad === Infinity) return;
+    if (bad === Infinity || bad > bestBad) return;
+    const foreign = countForeignGroupCrossings(lay, parsed.groups);
     const sc = objective(lay, bad);
-    if (sc < bestObj) {
+    const wins = bad === bestBad && foreign !== bestForeign ? foreign < bestForeign && !Number.isNaN(sc) : sc < bestObj;
+    if (wins) {
       bestObj = sc;
       bestBad = bad;
+      bestForeign = foreign;
       best = lay;
     }
   };
@@ -2001,6 +2069,7 @@ export {
   countEdgeNearMiss,
   detectGroupOverlaps,
   countGroupOverlaps,
+  countForeignGroupCrossings,
   separateGroupBands,
   layoutBoxesAndLinesSearch
 };

package/dist/{chunk-XQTRGKQ3.js → chunk-XIUGSUE4.js}

@@ -11,7 +11,7 @@ import {
   tagAttrKey,
   validateTagGroupNames,
   validateTagValues
-} from "./chunk-QKJ6MQXW.js";
+} from "./chunk-4SACN2C5.js";
 import {
   MINDMAP_REGISTRY,
   OPTION_NOCOLON_RE,
@@ -23,7 +23,7 @@ import {
   tryParseSharedOption,
   warnUnknownMetaKeys,
   withTagAliases
-} from "./chunk-MPJQMMBZ.js";
+} from "./chunk-TIIZIAGS.js";
 import {
   formatDgmoError,
   makeDgmoError,