@weasel-js/diagram 1.14.1 → 1.14.2

package/dist/{chunk-VB6HUKNG.js → chunk-FDCODMFW.js}

@@ -1260,20 +1260,7 @@ function packClusters(graph, rows, preferred2, axes, nodeGap) {
   const width = (n) => extent(n.bounds, axes.cross);
   const pref = (n) => preferred2.get(n.id) ?? 0;
   const insets = new Map(spans.map((s) => [s, canonical(s.group.inset, axes)]));
-  const centerOf = /* @__PURE__ */ new Map();
-  for (const span of spans) {
-    const inside = new Set(span.group.members);
-    let sum = 0;
-    let count = 0;
-    for (const row of rows) {
-      for (const n of row) {
-        if (!inside.has(n.id)) continue;
-        sum += pref(n) + width(n) / 2;
-        count++;
-      }
-    }
-    centerOf.set(span, count === 0 ? 0 : sum / count);
-  }
+  const centerOf = centersOf(spans, rows, (n) => pref(n) + width(n) / 2);
   const itemsByRow = (owner, among) => rows.map((row, r) => {
     const items = [];
     for (const node of row) {
@@ -1317,9 +1304,15 @@ function packClusters(graph, rows, preferred2, axes, nodeGap) {
     const known = blocks.get(span);
     if (known !== void 0) return known;
     const byRow = itemsByRow(span, span.children);
+    const own = rows.flat().filter((n) => spanOf4(n) === span);
     const base = Math.min(...rows.flat().filter((n) => span.group.members.includes(n.id) || spanOf4(n) === span).map(pref));
-    const childAt = new Map(span.children.map((c) => [c, Math.max(0, centerOf.get(c) - outer(c) / 2 - base)]));
-    const { nodeAt, ends: ends2 } = settle2(byRow, childAt, (n) => pref(n) - base, 0);
+    const childLo = new Map(span.children.map((c) => [c, Math.max(0, centerOf.get(c) - outer(c) / 2 - base)]));
+    const squeezed = closeGaps([
+      ...own.map((n) => [pref(n) - base, pref(n) - base + width(n)]),
+      ...span.children.map((c) => [childLo.get(c), childLo.get(c) + outer(c)])
+    ], nodeGap);
+    const childAt = new Map(span.children.map((c) => [c, squeezed(childLo.get(c))]));
+    const { nodeAt, ends: ends2 } = settle2(byRow, childAt, (n) => squeezed(pref(n) - base), 0);
     const block = { width: Math.max(0, ...ends2), nodeAt, childAt };
     const slack = widen(block, span.group, insets.get(span), axes);
     for (const [id, x] of nodeAt) nodeAt.set(id, x + slack);
@@ -1342,6 +1335,33 @@ function packClusters(graph, rows, preferred2, axes, nodeGap) {
   for (const root of roots) place(root, start.get(root));
   return at2;
 }
+function centersOf(spans, rows, center2) {
+  const out = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    const inside = new Set(span.group.members);
+    const centers = rows.flat().filter((n) => inside.has(n.id)).map(center2);
+    out.set(span, centers.length === 0 ? 0 : centers.reduce((a, b) => a + b, 0) / centers.length);
+  }
+  return out;
+}
+function closeGaps(spans, gap) {
+  const sorted = [...spans].sort((a, b) => a[0] - b[0]);
+  const cuts = [];
+  let reach = sorted[0]?.[1] ?? 0;
+  let removed = 0;
+  for (const [lo, hi] of sorted.slice(1)) {
+    if (lo - reach > gap) {
+      removed += lo - reach - gap;
+      cuts.push([lo, removed]);
+    }
+    reach = Math.max(reach, hi);
+  }
+  return (at2) => {
+    let shift = 0;
+    for (const [from, by] of cuts) if (at2 >= from) shift = by;
+    return at2 - shift;
+  };
+}
 function widen(block, group, inset2, axes) {
   const floor = axes.cross === "x" ? (group.minWidth ?? 0) - inset2.crossLo - inset2.crossHi : 0;
   const slack = Math.max(0, floor - block.width) / 2;
@@ -1969,6 +1989,7 @@ function authoredOver(edges, plan) {
 }
 
 // src/layered/rank.ts
+var GROUP_WEIGHT = 4;
 function ranksByLength(graph, back) {
   const index = /* @__PURE__ */ new Map();
   graph.nodes.forEach((node, i) => index.set(node.id, i));
@@ -1977,15 +1998,28 @@ function ranksByLength(graph, back) {
     const from = index.get(edge.from);
     const to = index.get(edge.to);
     if (from === void 0 || to === void 0 || from === to) continue;
-    arcs.push(back.has(edge.id) ? { tail: to, head: from } : { tail: from, head: to });
+    arcs.push(back.has(edge.id) ? { tail: to, head: from, weight: 1, minlen: 1 } : { tail: from, head: to, weight: 1, minlen: 1 });
+  }
+  let count = graph.nodes.length;
+  for (const group of graph.groups ?? []) {
+    const members = [...new Set(group.members.map((id) => index.get(id)).filter((i) => i !== void 0))];
+    if (members.length < 2) continue;
+    const [top, bottom] = [count, count + 1];
+    count += 2;
+    for (const m of members) {
+      arcs.push({ tail: top, head: m, weight: GROUP_WEIGHT, minlen: 0 });
+      arcs.push({ tail: m, head: bottom, weight: GROUP_WEIGHT, minlen: 0 });
+    }
   }
-  const start = longestPath(graph.nodes.length, arcs);
+  const real = graph.nodes.length;
+  const start = longestPath(count, arcs);
   const ranks = /* @__PURE__ */ new Map();
-  for (const part of components(graph.nodes.length, arcs)) {
+  for (const part of components(count, arcs)) {
     const rank = part.nodes.map((g) => start[g]);
     simplex(part.arcs, rank);
-    const min = Math.min(...rank);
-    part.nodes.forEach((g, i) => ranks.set(graph.nodes[g].id, rank[i] - min));
+    const own = part.nodes.flatMap((g, i) => g < real ? [i] : []);
+    const min = Math.min(...own.map((i) => rank[i]));
+    for (const i of own) ranks.set(graph.nodes[part.nodes[i]].id, rank[i] - min);
   }
   return ranks;
 }
@@ -1995,14 +2029,14 @@ function longestPath(count, arcs) {
   const out = Array.from({ length: count }, () => []);
   for (const arc2 of arcs) {
     pending[arc2.head]++;
-    out[arc2.tail].push(arc2.head);
+    out[arc2.tail].push(arc2);
   }
   const ready = [];
   for (let i = 0; i < count; i++) if (pending[i] === 0) ready.push(i);
   for (let k = 0; k < ready.length; k++) {
     const u = ready[k];
-    for (const v of out[u]) {
-      rank[v] = Math.max(rank[v], rank[u] + 1);
+    for (const { head: v, minlen } of out[u]) {
+      rank[v] = Math.max(rank[v], rank[u] + minlen);
       if (--pending[v] === 0) ready.push(v);
     }
   }
@@ -2034,11 +2068,11 @@ function components(count, arcs) {
   const local = new Array(count);
   for (const p of parts) p.nodes.forEach((g, i) => local[g] = i);
   for (const arc2 of arcs) {
-    parts[part[arc2.tail]].arcs.push({ tail: local[arc2.tail], head: local[arc2.head] });
+    parts[part[arc2.tail]].arcs.push({ ...arc2, tail: local[arc2.tail], head: local[arc2.head] });
   }
   return parts;
 }
-var slackOf = (arc2, rank) => rank[arc2.head] - rank[arc2.tail] - 1;
+var slackOf = (arc2, rank) => rank[arc2.head] - rank[arc2.tail] - arc2.minlen;
 function simplex(arcs, rank) {
   if (arcs.length === 0 || arcs.some((arc2) => slackOf(arc2, rank) < 0)) return;
   const inTree = feasibleTree(arcs, rank);
@@ -2152,7 +2186,7 @@ function cutValue(arcs, a, tree2) {
   for (const arc2 of arcs) {
     const from = inside(arc2.tail);
     if (from === inside(arc2.head)) continue;
-    value += from === tailInside ? 1 : -1;
+    value += from === tailInside ? arc2.weight : -arc2.weight;
   }
   return { value, tailInside };
 }
@@ -2168,7 +2202,7 @@ function tighten(rank, arcs, inTree) {
       const w = arc2.tail === v ? arc2.head : arc2.tail;
       if (seen[w]) continue;
       seen[w] = true;
-      rank[w] = arc2.tail === v ? rank[v] + 1 : rank[v] - 1;
+      rank[w] = arc2.tail === v ? rank[v] + arc2.minlen : rank[v] - arc2.minlen;
       queue.push(w);
     }
   }
@@ -2924,6 +2958,112 @@ function holdPins(input) {
   return { crossAt, gaps, depths: los.map((lo, k) => his[k] - lo), rankAt, unheld };
 }
 
+// src/layered/inward.ts
+var SLACK = 1;
+function turnOutward(input) {
+  const { rows, axes } = input;
+  const size = (n) => extent(n.bounds, axes.cross);
+  const lo = (n) => input.crossAt.get(n.id);
+  const hi = (n) => lo(n) + size(n);
+  const hull = drawingSpan(input, size);
+  if (hull === void 0) return void 0;
+  const free = (n) => n.group === void 0 && !input.pinned.has(n.id);
+  const { up, down } = sidesOf(input.hops);
+  const kin = (a, b) => [up, down].some((side) => (side.get(a) ?? []).some((n) => (side.get(b) ?? []).includes(n)));
+  const out = rows.map((row) => [...row]);
+  let changed = false;
+  for (const high of [true, false]) {
+    const reach = (n) => high ? hi(n) : -lo(n);
+    let best;
+    for (const [r, row] of out.entries()) {
+      const order2 = high ? [...row].reverse() : row;
+      let k = 0;
+      while (k < order2.length && isPlaceholder(order2[k].id) && free(order2[k])) k++;
+      const node = order2[k];
+      if (k === 0 || node === void 0 || isPlaceholder(node.id) || !free(node)) continue;
+      const run = order2.slice(0, k);
+      if (!run.every((p) => reach(p) - (high ? hull[1] : -hull[0]) > SLACK)) continue;
+      if (run.some((p) => kin(p.id, node.id))) continue;
+      if (best === void 0 || reach(node) > best.by) best = { r, k, by: reach(node) };
+    }
+    if (best === void 0) continue;
+    const order = high ? [...out[best.r]].reverse() : out[best.r];
+    const turned = [order[best.k], ...order.slice(0, best.k), ...order.slice(best.k + 1)];
+    out[best.r] = high ? turned.reverse() : turned;
+    changed = true;
+  }
+  return changed ? out : void 0;
+}
+function drawingSpan(input, size) {
+  let lo = Infinity;
+  let hi = -Infinity;
+  const take = ([a, b]) => {
+    lo = Math.min(lo, a);
+    hi = Math.max(hi, b);
+  };
+  for (const n of input.rows.flat()) {
+    if (!isPlaceholder(n.id)) take([input.crossAt.get(n.id), input.crossAt.get(n.id) + size(n)]);
+  }
+  for (const box of groupBoxes(input, size).values()) take(box);
+  return lo <= hi ? [lo, hi] : void 0;
+}
+function groupBoxes(input, size) {
+  const groups = input.graph.groups ?? [];
+  const byId = new Map(groups.map((g) => [g.id, g]));
+  const inner = /* @__PURE__ */ new Map();
+  const widen2 = (id, [a, b]) => {
+    const s = inner.get(id);
+    inner.set(id, s === void 0 ? [a, b] : [Math.min(s[0], a), Math.max(s[1], b)]);
+  };
+  for (const n of input.rows.flat()) {
+    if (n.group === void 0 || isPlaceholder(n.id)) continue;
+    const at2 = input.crossAt.get(n.id);
+    for (let g = byId.get(n.group); g !== void 0; g = g.parent === void 0 ? void 0 : byId.get(g.parent)) widen2(g.id, [at2, at2 + size(n)]);
+  }
+  const depth = (id) => {
+    const p = byId.get(id)?.parent;
+    return p === void 0 ? 0 : 1 + depth(p);
+  };
+  const boxes = /* @__PURE__ */ new Map();
+  for (const id of [...inner.keys()].sort((a, b) => depth(b) - depth(a))) {
+    const g = byId.get(id);
+    const [a, b] = inner.get(id);
+    const inset2 = crossInset(g.inset, input.axes);
+    const box = [a - inset2.lo, b + inset2.hi];
+    boxes.set(id, box);
+    if (g.parent !== void 0) widen2(g.parent, box);
+  }
+  return boxes;
+}
+
+// src/layered/reach.ts
+function boxReach(graph, rows, axes) {
+  const lo = rows.map(() => 0);
+  const hi = rows.map(() => 0);
+  const groups = graph.groups ?? [];
+  const byId = new Map(groups.map((g) => [g.id, g]));
+  const rowOf = /* @__PURE__ */ new Map();
+  rows.forEach((row, r) => row.forEach((n) => rowOf.set(n.id, r)));
+  const span = /* @__PURE__ */ new Map();
+  for (const g of groups) {
+    const rs = g.members.map((m) => rowOf.get(m)).filter((r) => r !== void 0);
+    if (rs.length > 0) span.set(g.id, [Math.min(...rs), Math.max(...rs)]);
+  }
+  for (const g of groups) {
+    const own = span.get(g.id);
+    if (own === void 0) continue;
+    for (const [side, out] of [[0, lo], [1, hi]]) {
+      let reach = 0;
+      for (let h = byId.get(g.id); h !== void 0; h = h.parent === void 0 ? void 0 : byId.get(h.parent)) {
+        if (span.get(h.id)?.[side] !== own[side]) break;
+        reach += rankInset(h.inset, axes)[side === 0 ? "lo" : "hi"];
+      }
+      out[own[side]] = Math.max(out[own[side]], reach);
+    }
+  }
+  return { lo, hi };
+}
+
 // src/layered/place.ts
 var pairKey = (upper, lower) => `${upper}\0${lower}`;
 function placeAcross(rows, hops, axis, nodeGap) {
@@ -3157,17 +3297,26 @@ function planOnce(graph, opts = {}) {
   const back = backEdges(graph);
   const ranks = ranksByLength(graph, back);
   const expanded = expand(graph, ranks, back, { axes, nodeGap });
-  const rows = finding ? orderRows(expanded.rows, expanded.hops, { groups: graph.groups ?? [] }) : expanded.rows;
-  const preferred2 = placeAcross(rows, settlePlaces(rows, expanded.hops), axes.cross, nodeGap);
+  let rows = finding ? orderRows(expanded.rows, expanded.hops, { groups: graph.groups ?? [] }) : expanded.rows;
   const grouped = (graph.groups?.length ?? 0) > 0;
-  const packed = grouped ? packClusters(graph, rows, preferred2, axes, nodeGap) : preferred2;
+  const pinned = pinnedSet(graph, opts);
+  const across = () => {
+    const preferred2 = placeAcross(rows, settlePlaces(rows, expanded.hops), axes.cross, nodeGap);
+    return grouped ? packClusters(graph, rows, preferred2, axes, nodeGap) : preferred2;
+  };
+  let packed = across();
+  for (let turn = 0; turn < rows.length; turn++) {
+    const turned = turnOutward({ graph, rows, crossAt: packed, axes, pinned, hops: expanded.hops });
+    if (turned === void 0) break;
+    rows = turned;
+    packed = across();
+  }
   const spaced = grouped ? rankGaps(graph, rows, axes, rankGap) : rows.slice(1).map(() => rankGap);
   const minGaps = spaced.map((gap) => gap - rankGap + rankGap * MIN_GAP);
   for (const r of expanded.labelRows) {
     spaced[r - 1] = spaced[r - 1] - rankGap * (1 - LABEL_GAP);
     spaced[r] = spaced[r] - rankGap * (1 - LABEL_GAP);
   }
-  const pinned = pinnedSet(graph, opts);
   const { crossAt, gaps, depths: depths2, rankAt, unheld } = holdPins({ graph, rows, crossAt: packed, gaps: spaced, pinned, axes, nodeGap, minGaps });
   const slots = /* @__PURE__ */ new Map();
   const bands = [];
@@ -3198,6 +3347,7 @@ function planOnce(graph, opts = {}) {
   const labels = /* @__PURE__ */ new Map();
   const rankOf = /* @__PURE__ */ new Map();
   rows.forEach((row, r) => row.forEach((n) => rankOf.set(n.id, r)));
+  const reach = boxReach(graph, rows, axes);
   const widthOf = new Map(rows.flat().map((n) => [n.id, extent(n.bounds, axes.cross)]));
   for (const [edge, chain2] of expanded.chains) {
     if (chain2.ends.some((id) => displaced.has(id))) continue;
@@ -3205,7 +3355,8 @@ function planOnce(graph, opts = {}) {
     const points = [];
     for (const id of chain2.ids) {
       const cross = crossAt.get(id) + (expanded.wires.get(id) ?? widthOf.get(id) / 2);
-      const [lo, hi] = bands[rankOf.get(id)];
+      const r = rankOf.get(id);
+      const [lo, hi] = [bands[r][0] - reach.lo[r], bands[r][1] + reach.hi[r]];
       for (const rank of chain2.back ? [hi, lo] : [lo, hi]) {
         const at2 = worldOf({ cross, rank }, 0, axes);
         points.push({ x: at2.x + offset.x, y: at2.y + offset.y });
@@ -3716,5 +3867,5 @@ var treeOnce = (graph, opts = {}) => {
 };
 
 export { COMPASS, DEFAULT_GROUP_INSET, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DEVICE_SIZE, DIAGRAM_TRAIT_KEY, DIVIDER_HEIGHT, EVENT_SIZE, GATEWAY_SIZE, PORT_LABEL_GAP, SIDE_TRACK_GAP, anchorOffset, authoredOver, axesFor, backEdges, bodyOutline, bodyTrait, boxForContent, buildBody, canvasMeasure, center, chain, contentBox, createDiagramNodes, dataKeyReader, diagramEdgeOf, diagramNodeOf, expandGroupEdges, extent, footprintNode, force, forceRelaxation, forestOf, graphOrder, grownBy, insetOf, isPinned, isPromise, labelCenter, labelSpotAt, layered, layeredPlan, layeredRoutes, layoutBody, layoutOwnsPort, layoutOwnsRoute, layoutRowPorts, layoutWritesRoute, marginOf, measureBody, outlineDetail, outlineFromD, outlinePath, outlinePolyline, packAcross, packClusters, pinnedSet, planOf, plannerPlan, portLabelBox, portLabelsOf, portOf, portSitesOf, portsOf, portsOnOutline, rankGaps, ranksByLength, ranksOf, rayHit, registerOutline, resolveOutline, routeHolds, rowHeights, samePoints, seededOrder, settle, sizeToBody, subpathOf, subtreeBlocks, translated, tree, untilSettled, widenForMinWidth };
-//# sourceMappingURL=chunk-VB6HUKNG.js.map
-//# sourceMappingURL=chunk-VB6HUKNG.js.map
+//# sourceMappingURL=chunk-FDCODMFW.js.map
+//# sourceMappingURL=chunk-FDCODMFW.js.map