@weasel-js/diagram 1.11.1 → 1.12.0

package/dist/{chunk-IM6DHWZO.js → chunk-R2XB6D32.js}

@@ -1,4 +1,4 @@
-import { AUTO_POSE_DESCRIPTOR, rotatePoint, rectPath, polygonFromPoints, PATH_M, PATH_L, PATH_C, flattenCubic, PATH_Q, PATH_Z, PathBuilder, pointAlongPath } from '@weasel-js/core/math';
+import { AUTO_POSE_DESCRIPTOR, rotatePoint, rectPath, polygonFromPoints, PATH_M, PATH_L, PATH_C, flattenCubic, PATH_Q, PATH_Z, PathBuilder, clipNothing, pointAlongPath } from '@weasel-js/core/math';
 import { transformPath, ellipsePath, PATH_M as PATH_M$1, PATH_CMD_LENGTHS, measurePath, forEachSegment, PATH_L as PATH_L$1, nearestOnLine, PATH_Q as PATH_Q$1, nearestOnQuadratic, PATH_C as PATH_C$1, nearestOnCubic } from '@weasel-js/geom';
 import { cssFamilyName } from '@weasel-js/font/metrics';
 import { createSimulation } from '@weasel-js/simulation';
@@ -502,6 +502,7 @@ function buildBody(spec, at2, opts) {
     layer: opts.layer,
     pose,
     data: opts.body(trait, pose),
+    clipFromPose: clipNothing,
     ...opts.id === void 0 ? {} : { id: opts.id }
   }];
   const leaf = (box, data, rowId) => {
@@ -2855,36 +2856,55 @@ function lineGaps(graph, line, hanging, rankGap, axes, packed) {
   for (const node of graph.nodes) {
     if (!index.has(node.id)) columns[index.get(hanging.owner.get(node.id))].push(node);
   }
-  const gaps = rankGaps(graph, columns, axes, rankGap);
+  return bandGaps(graph, columns, axes, columns.slice(1).map(() => rankGap), (id) => packed.get(id)?.rank);
+}
+function levelGaps(graph, hanging, levelSize, axes, before, base) {
+  const levels = Array.from(levelSize, () => []);
+  for (const node of graph.nodes) (levels[hanging.level.get(node.id)] ??= []).push(node);
+  const outward = { rank: axes.cross, cross: axes.rank, sign: before ? -1 : 1 };
+  const from = [0];
+  for (let k = 1; k < levelSize.length; k++) from[k] = from[k - 1] + (levelSize[k - 1] ?? 0);
+  return bandGaps(graph, levels, outward, base, (id) => {
+    const node = graph.node(id);
+    const at2 = hanging.level.get(id);
+    if (node === void 0 || at2 === void 0) return void 0;
+    return at2 === 0 ? (levelSize[0] - extent(node.bounds, outward.rank)) / 2 : from[at2];
+  });
+}
+function bandGaps(graph, bands, axes, gaps, start) {
+  const insets = rankGaps(graph, bands, axes, 0);
+  const out = gaps.map((gap, i) => gap + (insets[i] ?? 0));
   const groups = graph.groups ?? [];
-  if (axes.rank !== "x" || !groups.some((g) => g.minWidth !== void 0)) return gaps;
-  const columnOf = (id) => index.get(id) ?? index.get(hanging.owner.get(id));
+  if (axes.rank !== "x" || !groups.some((g) => g.minWidth !== void 0)) return out;
+  const bandOf = /* @__PURE__ */ new Map();
+  bands.forEach((band, i) => band.forEach((n) => bandOf.set(n.id, i)));
   const children = /* @__PURE__ */ new Map();
   for (const g of groups) if (g.parent !== void 0) children.set(g.parent, [...children.get(g.parent) ?? [], g.id]);
   const byId = new Map(groups.map((g) => [g.id, g]));
   const span = (id, now) => {
     let [lo, hi] = [Infinity, -Infinity];
     for (const m of byId.get(id).members) {
-      const slot = packed.get(m);
+      const at2 = start(m);
+      const band = bandOf.get(m);
       const node = graph.node(m);
-      if (slot === void 0 || node === void 0) continue;
-      const from = slot.rank + now.slice(0, columnOf(m)).reduce((s, gap) => s + gap, 0);
+      if (at2 === void 0 || band === void 0 || node === void 0) continue;
+      const from = at2 + now.slice(0, band).reduce((s, gap) => s + gap, 0);
       [lo, hi] = [Math.min(lo, from), Math.max(hi, from + extent(node.bounds, axes.rank))];
     }
     return { lo, hi };
   };
   widenForMinWidth(deepestFirst(groups).map((g) => {
-    const cols = g.members.filter((id) => packed.has(id)).map(columnOf);
+    const placed = g.members.flatMap((id) => bandOf.has(id) && start(id) !== void 0 ? [bandOf.get(id)] : []);
     return {
       id: g.id,
       ...g.minWidth !== void 0 ? { minWidth: g.minWidth } : {},
       inset: rankInset(g.inset, axes),
       children: children.get(g.id) ?? [],
-      before: cols.length === 0 ? -1 : Math.min(...cols) - 1,
-      after: cols.length === 0 ? -1 : Math.max(...cols)
+      before: placed.length === 0 ? -1 : Math.min(...placed) - 1,
+      after: placed.length === 0 ? -1 : Math.max(...placed)
     };
-  }), gaps, span);
-  return gaps;
+  }), out, span);
+  return out;
 }
 function widenForMinWidth(groups, gaps, span) {
   const byId = new Map(groups.map((g) => [g.id, g]));
@@ -3078,21 +3098,26 @@ function chainPlan(graph, opts = {}) {
   }
   for (const [id, column] of rows) if (column[1]) column[1] = inPortOrder(graph, id, column[1], axes);
   const before = opts.chainSide === "before";
-  const slots = (rank, side2) => slotsFor(line, rows, levelSize, axes, { node: nodeGap, rank, side: side2 }, before);
-  const gaps = graph.groups?.length ? lineGaps(graph, line, hanging, rankGap, axes, slots(line.map(() => 0), nodeGap)) : line.map(() => rankGap);
-  const place = (side2) => settle(graph, slots(gaps, side2), opts);
+  const grouped = (graph.groups?.length ?? 0) > 0;
+  const across = (side2) => {
+    const base = Array.from(levelSize.slice(1), (_, k) => k === 0 ? side2 : nodeGap);
+    return grouped ? levelGaps(graph, hanging, levelSize, axes, before, base) : base;
+  };
+  const slots = (rank, level2) => slotsFor(line, rows, levelSize, axes, { node: nodeGap, rank, level: level2 }, before);
+  const gaps = grouped ? lineGaps(graph, line, hanging, rankGap, axes, slots(line.map(() => 0), [])) : line.map(() => rankGap);
+  const place = (side2) => settle(graph, slots(gaps, across(side2)), opts);
   let moves = place(nodeGap);
   const side = (tracksNeeded(graph, hanging, moves, axes, before) + 1) * SIDE_TRACK_GAP;
   if (side > nodeGap) moves = place(side);
   return { moves, waypoints: sideRoutes(graph, hanging, moves, axes, before) };
 }
 function slotsFor(line, rows, levelSize, axes, gaps, before) {
-  const { node: nodeGap, rank: rankGap } = gaps;
+  const { node: nodeGap, rank: rankGap, level: levelGap } = gaps;
   const rowSpan = (row) => row.reduce((sum, n) => sum + extent(n.bounds, axes.rank), 0) + nodeGap * Math.max(row.length - 1, 0);
   const bandStart = (at2) => {
     let offset = 0;
-    const first = before ? 1 : 0;
-    for (let k = first; k < (before ? at2 + 1 : at2); k++) offset += (levelSize[k] ?? 0) + (k === first ? gaps.side : nodeGap);
+    if (before) for (let k = 1; k <= at2; k++) offset += (levelSize[k] ?? 0) + (levelGap[k - 1] ?? 0);
+    else for (let k = 0; k < at2; k++) offset += (levelSize[k] ?? 0) + (levelGap[k] ?? 0);
     return before ? -offset : offset;
   };
   const slots = /* @__PURE__ */ new Map();
@@ -3216,5 +3241,5 @@ var treeOnce = (graph, opts = {}) => {
 };
 
 export { COMPASS, DEFAULT_GROUP_INSET, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DIAGRAM_TRAIT_KEY, 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, outlinePath, outlinePolyline, packAcross, packClusters, pinnedSet, planOf, plannerPlan, portLabelBox, portLabelsOf, portOf, portSitesOf, portsOf, portsOnOutline, rankGaps, ranksByLength, ranksOf, rayHit, routeHolds, samePoints, seededOrder, settle, sizeToBody, subpathOf, translated, tree, untilSettled, widenForMinWidth };
-//# sourceMappingURL=chunk-IM6DHWZO.js.map
-//# sourceMappingURL=chunk-IM6DHWZO.js.map
+//# sourceMappingURL=chunk-R2XB6D32.js.map
+//# sourceMappingURL=chunk-R2XB6D32.js.map