@statelyai/layout 0.0.3 → 0.0.4

package/README.md

@@ -9,12 +9,15 @@ return `VisualGraph`; positions remain node fields and routes remain
 
 ## Status
 
+<!-- layered compatibility coverage from test/oracle*.test.ts -->
+
 The native layered implementation covers the complete 152-option elkjs 0.11.1
 layered inventory with one simplified typed name per ELK option. Flat and
 compound graphs, cross-hierarchy edges, ports, labels, self-loops, wrapping,
 four directions, constraints, and replaceable phases are differential-tested
-against elkjs. Partial, incremental, and route-only layout remain explicit
-unimplemented capabilities.
+against elkjs, including a curated complex state-machine corpus in both primary
+layout orientations. Partial, incremental, and route-only layout remain
+explicit unimplemented capabilities.
 
 ## Install
 

package/dist/elkjs/index.mjs

@@ -1,8 +1,11 @@
-import { o as elkLayeredOptionDefinitions, t as getLayeredLayout } from "../layered-f_3mmGHr.mjs";
-import { a as getRandomLayout, f as getFixedLayout, n as getSporeOverlapRemovalLayout, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "../spore-BfTduMDc.mjs";
+import { o as elkLayeredOptionDefinitions, t as getLayeredLayout } from "../layered-Bp8MkxWK.mjs";
+import { a as getRandomLayout, f as getFixedLayout, n as getSporeOverlapRemovalLayout, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "../spore-ePWz2LtF.mjs";
 import { createGraph } from "@statelyai/graph";
 
 //#region src/elkjs/index.ts
+function isLayoutEdgeLabel(label) {
+	return getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true && (Boolean(label.text) || label.width !== void 0 || label.height !== void 0);
+}
 var ELK = class {
 	#options;
 	#algorithmIds;
@@ -897,7 +900,7 @@ function toGraph(root, globalOptions = {}) {
 			if (isInsideSelfLoop(root, edge)) return [];
 			const source = endpoint(edge.sources?.[0] ?? edge.source, portOwnerById);
 			const target = endpoint(edge.targets?.[0] ?? edge.target, portOwnerById);
-			const labels = (edge.labels ?? []).filter((label) => Boolean(label.text) && getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true);
+			const labels = (edge.labels ?? []).filter(isLayoutEdgeLabel);
 			const labelLabelSpacing = getNumberOption(globalOptions, "spacing.labelLabel") ?? 0;
 			const labelWidth = Math.max(0, ...labels.map((label) => label.width ?? 0));
 			const labelHeight = labels.reduce((sum, label) => sum + (label.height ?? 0), 0) + Math.max(0, labels.length - 1) * labelLabelSpacing;
@@ -1000,7 +1003,7 @@ function applyLayout(root, graph, padding, layoutOptions) {
 				label.y ??= 0;
 				continue;
 			}
-			if (!label.text) {
+			if (!isLayoutEdgeLabel(label)) {
 				label.x ??= 0;
 				label.y ??= 0;
 				continue;
@@ -1026,7 +1029,7 @@ function normalizeElkGraphBounds(root, padding, layoutOptions = {}) {
 		minimumY = Math.min(minimumY, node.y ?? 0, ...(node.labels ?? []).map((label) => (node.y ?? 0) + (label.y ?? 0)), ...(node.ports ?? []).map((port) => (node.y ?? 0) + (port.y ?? 0)), ...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.y ?? 0) + (port.y ?? 0) + (label.y ?? 0))));
 	}
 	for (const edge of root.edges ?? []) {
-		const laidOutLabels = (edge.labels ?? []).filter((label) => Boolean(label.text) && getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true);
+		const laidOutLabels = (edge.labels ?? []).filter(isLayoutEdgeLabel);
 		minimumX = Math.min(minimumX, ...laidOutLabels.map((label) => label.x ?? 0));
 		minimumY = Math.min(minimumY, ...laidOutLabels.map((label) => label.y ?? 0));
 		if (getBooleanOption(edge.layoutOptions ?? {}, "noLayout") !== true) {
@@ -1055,7 +1058,7 @@ function normalizeElkGraphBounds(root, padding, layoutOptions = {}) {
 				point.x += shiftX;
 				point.y += shiftY;
 			}
-			for (const label of (edge.labels ?? []).filter((candidate) => Boolean(candidate.text))) {
+			for (const label of (edge.labels ?? []).filter(isLayoutEdgeLabel)) {
 				label.x = (label.x ?? 0) + shiftX;
 				label.y = (label.y ?? 0) + shiftY;
 			}
@@ -1091,7 +1094,7 @@ function normalizeElkGraphBounds(root, padding, layoutOptions = {}) {
 		...(node.labels ?? []).map((label) => (node.x ?? 0) + (label.x ?? 0) + (label.width ?? 0)),
 		...(node.ports ?? []).map((port) => (node.x ?? 0) + (port.x ?? 0) + (port.width ?? 0)),
 		...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.x ?? 0) + (port.x ?? 0) + (label.x ?? 0) + (label.width ?? 0)))
-	]), ...(root.edges ?? []).flatMap((edge) => (edge.labels ?? []).filter((label) => Boolean(label.text) && getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true).map((label) => (label.x ?? 0) + (label.width ?? 0))), ...(root.edges ?? []).flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
+	]), ...(root.edges ?? []).flatMap((edge) => (edge.labels ?? []).filter(isLayoutEdgeLabel).map((label) => (label.x ?? 0) + (label.width ?? 0))), ...(root.edges ?? []).flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
 		section.startPoint.x,
 		...(section.bendPoints ?? []).map((point) => point.x),
 		section.endPoint.x
@@ -1101,7 +1104,7 @@ function normalizeElkGraphBounds(root, padding, layoutOptions = {}) {
 		...(node.labels ?? []).map((label) => (node.y ?? 0) + (label.y ?? 0) + (label.height ?? 0)),
 		...(node.ports ?? []).map((port) => (node.y ?? 0) + (port.y ?? 0) + (port.height ?? 0)),
 		...(node.ports ?? []).flatMap((port) => (port.labels ?? []).map((label) => (node.y ?? 0) + (port.y ?? 0) + (label.y ?? 0) + (label.height ?? 0)))
-	]), ...(root.edges ?? []).flatMap((edge) => (edge.labels ?? []).filter((label) => Boolean(label.text) && getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true).map((label) => (label.y ?? 0) + (label.height ?? 0) + (String(getOption(label.layoutOptions ?? {}, "edgeLabels.placement") ?? "CENTER") === "CENTER" ? 1 : 0))), ...(root.edges ?? []).flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
+	]), ...(root.edges ?? []).flatMap((edge) => (edge.labels ?? []).filter(isLayoutEdgeLabel).map((label) => (label.y ?? 0) + (label.height ?? 0) + (String(getOption(label.layoutOptions ?? {}, "edgeLabels.placement") ?? "CENTER") === "CENTER" ? 1 : 0))), ...(root.edges ?? []).flatMap((edge) => getBooleanOption(edge.layoutOptions ?? {}, "noLayout") === true ? [] : (edge.sections ?? []).flatMap((section) => [
 		section.startPoint.y,
 		...(section.bendPoints ?? []).map((point) => point.y),
 		section.endPoint.y

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { A as minimizeCrossingsWithBarycenter, B as LayoutError, C as breakCyclesGreedilyByModelOrder, D as breakCyclesWithModelOrderDepthFirstSearch, E as breakCyclesWithModelOrderBreadthFirstSearch, I as routeEdgesOrthogonally, L as routeEdgesWithPolylines, M as minimizeCrossingsWithModelOrder, N as placeNodesInLayers, P as placeNodesInteractively, R as routeEdgesWithSplines, S as breakCyclesGreedily, T as breakCyclesWithDepthFirstSearch, V as UnsupportedLayoutError, _ as assignLayersInteractively, a as elkLayeredEnumValues, b as breakCyclesByStronglyConnectedConnectivity, d as assignLayersWithMinWidth, f as assignLayersWithNetworkSimplex, g as assignLayersByLongestPathToSink, h as assignLayersByLongestPath, i as toElkLayeredOptions, j as minimizeCrossingsWithMedian, k as minimizeCrossingsInteractively, m as assignLayersByDepthFirstModelOrder, n as layeredAlgorithm, o as elkLayeredOptionDefinitions, p as assignLayersByBreadthFirstModelOrder, r as fromElkLayeredOptionId, t as getLayeredLayout, u as assignLayersWithStretchWidth, v as assignLayersWithCoffmanGraham, w as breakCyclesInteractively, x as breakCyclesByStronglyConnectedNodeType, y as breakCyclesByModelOrder } from "./layered-f_3mmGHr.mjs";
-import { a as getRandomLayout, c as rectanglePackingAlgorithm, d as fixedAlgorithm, f as getFixedLayout, i as sporeOverlapRemovalAlgorithm, l as boxAlgorithm, n as getSporeOverlapRemovalLayout, o as randomAlgorithm, r as sporeCompactionAlgorithm, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "./spore-BfTduMDc.mjs";
+import { A as minimizeCrossingsWithBarycenter, B as LayoutError, C as breakCyclesGreedilyByModelOrder, D as breakCyclesWithModelOrderDepthFirstSearch, E as breakCyclesWithModelOrderBreadthFirstSearch, I as routeEdgesOrthogonally, L as routeEdgesWithPolylines, M as minimizeCrossingsWithModelOrder, N as placeNodesInLayers, P as placeNodesInteractively, R as routeEdgesWithSplines, S as breakCyclesGreedily, T as breakCyclesWithDepthFirstSearch, V as UnsupportedLayoutError, _ as assignLayersInteractively, a as elkLayeredEnumValues, b as breakCyclesByStronglyConnectedConnectivity, d as assignLayersWithMinWidth, f as assignLayersWithNetworkSimplex, g as assignLayersByLongestPathToSink, h as assignLayersByLongestPath, i as toElkLayeredOptions, j as minimizeCrossingsWithMedian, k as minimizeCrossingsInteractively, m as assignLayersByDepthFirstModelOrder, n as layeredAlgorithm, o as elkLayeredOptionDefinitions, p as assignLayersByBreadthFirstModelOrder, r as fromElkLayeredOptionId, t as getLayeredLayout, u as assignLayersWithStretchWidth, v as assignLayersWithCoffmanGraham, w as breakCyclesInteractively, x as breakCyclesByStronglyConnectedNodeType, y as breakCyclesByModelOrder } from "./layered-Bp8MkxWK.mjs";
+import { a as getRandomLayout, c as rectanglePackingAlgorithm, d as fixedAlgorithm, f as getFixedLayout, i as sporeOverlapRemovalAlgorithm, l as boxAlgorithm, n as getSporeOverlapRemovalLayout, o as randomAlgorithm, r as sporeCompactionAlgorithm, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "./spore-ePWz2LtF.mjs";
 import { getGraphIssues } from "@statelyai/graph";
 
 //#region src/layout.ts

package/dist/layered/index.mjs

@@ -1,3 +1,3 @@
-import { A as minimizeCrossingsWithBarycenter, C as breakCyclesGreedilyByModelOrder, D as breakCyclesWithModelOrderDepthFirstSearch, E as breakCyclesWithModelOrderBreadthFirstSearch, I as routeEdgesOrthogonally, L as routeEdgesWithPolylines, M as minimizeCrossingsWithModelOrder, N as placeNodesInLayers, P as placeNodesInteractively, R as routeEdgesWithSplines, S as breakCyclesGreedily, T as breakCyclesWithDepthFirstSearch, _ as assignLayersInteractively, a as elkLayeredEnumValues, b as breakCyclesByStronglyConnectedConnectivity, c as placeNodesWithLinearSegments, d as assignLayersWithMinWidth, f as assignLayersWithNetworkSimplex, g as assignLayersByLongestPathToSink, h as assignLayersByLongestPath, i as toElkLayeredOptions, j as minimizeCrossingsWithMedian, k as minimizeCrossingsInteractively, l as placeNodesWithBrandesKoepf, m as assignLayersByDepthFirstModelOrder, n as layeredAlgorithm, o as elkLayeredOptionDefinitions, p as assignLayersByBreadthFirstModelOrder, r as fromElkLayeredOptionId, s as placeNodesWithNetworkSimplex, t as getLayeredLayout, u as assignLayersWithStretchWidth, v as assignLayersWithCoffmanGraham, w as breakCyclesInteractively, x as breakCyclesByStronglyConnectedNodeType, y as breakCyclesByModelOrder } from "../layered-f_3mmGHr.mjs";
+import { A as minimizeCrossingsWithBarycenter, C as breakCyclesGreedilyByModelOrder, D as breakCyclesWithModelOrderDepthFirstSearch, E as breakCyclesWithModelOrderBreadthFirstSearch, I as routeEdgesOrthogonally, L as routeEdgesWithPolylines, M as minimizeCrossingsWithModelOrder, N as placeNodesInLayers, P as placeNodesInteractively, R as routeEdgesWithSplines, S as breakCyclesGreedily, T as breakCyclesWithDepthFirstSearch, _ as assignLayersInteractively, a as elkLayeredEnumValues, b as breakCyclesByStronglyConnectedConnectivity, c as placeNodesWithLinearSegments, d as assignLayersWithMinWidth, f as assignLayersWithNetworkSimplex, g as assignLayersByLongestPathToSink, h as assignLayersByLongestPath, i as toElkLayeredOptions, j as minimizeCrossingsWithMedian, k as minimizeCrossingsInteractively, l as placeNodesWithBrandesKoepf, m as assignLayersByDepthFirstModelOrder, n as layeredAlgorithm, o as elkLayeredOptionDefinitions, p as assignLayersByBreadthFirstModelOrder, r as fromElkLayeredOptionId, s as placeNodesWithNetworkSimplex, t as getLayeredLayout, u as assignLayersWithStretchWidth, v as assignLayersWithCoffmanGraham, w as breakCyclesInteractively, x as breakCyclesByStronglyConnectedNodeType, y as breakCyclesByModelOrder } from "../layered-Bp8MkxWK.mjs";
 
 export { assignLayersByBreadthFirstModelOrder, assignLayersByDepthFirstModelOrder, assignLayersByLongestPath, assignLayersByLongestPathToSink, assignLayersInteractively, assignLayersWithCoffmanGraham, assignLayersWithMinWidth, assignLayersWithNetworkSimplex, assignLayersWithStretchWidth, breakCyclesByModelOrder, breakCyclesByStronglyConnectedConnectivity, breakCyclesByStronglyConnectedNodeType, breakCyclesGreedily, breakCyclesGreedilyByModelOrder, breakCyclesInteractively, breakCyclesWithDepthFirstSearch, breakCyclesWithModelOrderBreadthFirstSearch, breakCyclesWithModelOrderDepthFirstSearch, elkLayeredEnumValues, elkLayeredOptionDefinitions, fromElkLayeredOptionId, getLayeredLayout, layeredAlgorithm, minimizeCrossingsInteractively, minimizeCrossingsWithBarycenter, minimizeCrossingsWithMedian, minimizeCrossingsWithModelOrder, placeNodesInLayers, placeNodesInteractively, placeNodesWithBrandesKoepf, placeNodesWithLinearSegments, placeNodesWithNetworkSimplex, routeEdgesOrthogonally, routeEdgesWithPolylines, routeEdgesWithSplines, toElkLayeredOptions };

package/dist/{layered-f_3mmGHr.mjs → layered-Bp8MkxWK.mjs}

@@ -8745,6 +8745,7 @@ function runLayeredPipeline(graph, options, context) {
 	let expandedRoutes = measure("edge-routing", () => edgeRouter(expanded.input, expanded.orientation, placement));
 	measure("post-compaction", () => applyPostCompaction(expanded.input, placement, expandedRoutes));
 	const antiparallelLabelPositions = /* @__PURE__ */ new Map();
+	const outerAntiparallelLabelIds = /* @__PURE__ */ new Set();
 	const parallelLabelPositions = /* @__PURE__ */ new Map();
 	const postCompactionNodeCrossDeltas = /* @__PURE__ */ new Map();
 	const horizontalAntiparallelFlow = direction === "left" || direction === "right";
@@ -8834,12 +8835,13 @@ function runLayeredPipeline(graph, options, context) {
 			const secondRect = placement.rectByNodeId.get(pair[0].targetId);
 			if (!firstNode || !secondNode || !firstRect || !secondRect) continue;
 			const nonSelfNeighbors = (nodeId) => new Set(graph.edges.flatMap((edge) => edge.sourceId === edge.targetId ? [] : edge.sourceId === nodeId ? [edge.targetId] : edge.targetId === nodeId ? [edge.sourceId] : []));
-			if (nonSelfNeighbors(firstNode.id).size !== 1 || nonSelfNeighbors(secondNode.id).size !== 1) continue;
+			const isolatedAntiparallelPair = nonSelfNeighbors(firstNode.id).size === 1 && nonSelfNeighbors(secondNode.id).size === 1;
 			const hasFlexiblePorts = (node) => {
 				const constraints = options.nodeSettings?.(node)?.portConstraints;
 				return constraints === void 0 || constraints === "UNDEFINED" || constraints === "FREE";
 			};
-			if (!hasFlexiblePorts(firstNode) || !hasFlexiblePorts(secondNode)) continue;
+			const hasFlexiblePairPorts = hasFlexiblePorts(firstNode) && hasFlexiblePorts(secondNode);
+			if (isolatedAntiparallelPair && !hasFlexiblePairPorts) continue;
 			const firstBeforeSecond = horizontal ? firstRect.x + firstRect.width / 2 < secondRect.x + secondRect.width / 2 : firstRect.y + firstRect.height / 2 < secondRect.y + secondRect.height / 2;
 			const beforeRect = firstBeforeSecond ? firstRect : secondRect;
 			const afterRect = firstBeforeSecond ? secondRect : firstRect;
@@ -8850,13 +8852,20 @@ function runLayeredPipeline(graph, options, context) {
 			for (const edge of pair) {
 				const width = edge.width ?? 0;
 				const height = edge.height ?? 0;
-				antiparallelLabelPositions.set(edge.id, horizontal ? {
+				antiparallelLabelPositions.set(edge.id, isolatedAntiparallelPair ? horizontal ? {
 					x: (beforeRect.x + beforeRect.width + afterRect.x - width) / 2,
 					y: cross
 				} : {
 					x: cross,
 					y: (beforeRect.y + beforeRect.height + afterRect.y - height) / 2
+				} : horizontal ? {
+					x: (beforeRect.x + beforeRect.width + afterRect.x - width) / 2,
+					y: edge === forward ? (firstRect.y + firstRect.height / 2 + secondRect.y + secondRect.height / 2) / 2 - height / 2 : Math.max(firstRect.y + firstRect.height, secondRect.y + secondRect.height) + edgeSpacing
+				} : {
+					x: edge === forward ? (firstRect.x + firstRect.width / 2 + secondRect.x + secondRect.width / 2) / 2 - width / 2 : Math.max(firstRect.x + firstRect.width, secondRect.x + secondRect.width) + edgeSpacing,
+					y: (beforeRect.y + beforeRect.height + afterRect.y - height) / 2
 				});
+				if (!isolatedAntiparallelPair && edge !== forward) outerAntiparallelLabelIds.add(edge.id);
 				cross += (horizontal ? height : width) + edgeSpacing;
 			}
 			const forwardLabel = antiparallelLabelPositions.get(forward.id);
@@ -8881,8 +8890,10 @@ function runLayeredPipeline(graph, options, context) {
 					x: nextCross
 				});
 			};
-			alignPort(nodesById.get(forward.sourceId), forward.sourcePort);
-			alignPort(nodesById.get(forward.targetId), forward.targetPort);
+			if (isolatedAntiparallelPair) {
+				alignPort(nodesById.get(forward.sourceId), forward.sourcePort);
+				alignPort(nodesById.get(forward.targetId), forward.targetPort);
+			}
 		}
 	}
 	if (postCompactionNodeCrossDeltas.size > 0) {
@@ -9239,7 +9250,33 @@ function runLayeredPipeline(graph, options, context) {
 		};
 		const flexibleFeedbackLabel = labelPlacement === "CENTER" && inlineLabel && expanded.orientation.reversedEdgeIds.has(edge.id) && hasFlexiblePorts(sourceNode) && hasFlexiblePorts(targetNode) && sourceRect !== void 0 && targetRect !== void 0;
 		const [beforeFlowRect, afterFlowRect] = sourceRect && targetRect ? horizontal ? sourceRect.x <= targetRect.x ? [sourceRect, targetRect] : [targetRect, sourceRect] : sourceRect.y <= targetRect.y ? [sourceRect, targetRect] : [targetRect, sourceRect] : [void 0, void 0];
-		const explicitLabelPosition = antiparallelLabelPositions.get(edge.id) ?? parallelLabelPositions.get(edge.id);
+		const antiparallelLabelPosition = antiparallelLabelPositions.get(edge.id);
+		const explicitLabelPosition = (() => {
+			if (!outerAntiparallelLabelIds.has(edge.id)) return void 0;
+			const edgeNodeSpacing$1 = Number(options.settings?.["spacing.edgeNode"] ?? 10);
+			if (horizontal) {
+				const x$1 = (beforeFlowRect.x + beforeFlowRect.width + afterFlowRect.x - width) / 2;
+				const blockers$1 = [
+					sourceRect,
+					targetRect,
+					...[...placement.rectByNodeId.values()].filter((rect) => rect.x < x$1 + width && rect.x + rect.width > x$1)
+				];
+				return {
+					x: x$1,
+					y: Math.max(...blockers$1.map((rect) => rect.y + rect.height)) + edgeNodeSpacing$1
+				};
+			}
+			const y$1 = (beforeFlowRect.y + beforeFlowRect.height + afterFlowRect.y - height) / 2;
+			const blockers = [
+				sourceRect,
+				targetRect,
+				...[...placement.rectByNodeId.values()].filter((rect) => rect.y < y$1 + height && rect.y + rect.height > y$1)
+			];
+			return {
+				x: Math.max(...blockers.map((rect) => rect.x + rect.width)) + edgeNodeSpacing$1,
+				y: y$1
+			};
+		})() ?? antiparallelLabelPosition ?? parallelLabelPositions.get(edge.id);
 		const x = explicitLabelPosition ? explicitLabelPosition.x : flexibleFeedbackLabel ? horizontal ? (beforeFlowRect.x + beforeFlowRect.width + afterFlowRect.x - width) / 2 : targetRect.x + (targetRect.width - width) / 2 : labelPlacement === "CENTER" && horizontal && labelDummyRect ? labelDummyRect.x : routeX;
 		const y = explicitLabelPosition ? explicitLabelPosition.y : flexibleFeedbackLabel ? horizontal ? targetRect.y + (targetRect.height - height) / 2 : (beforeFlowRect.y + beforeFlowRect.height + afterFlowRect.y - height) / 2 : labelPlacement === "CENTER" && !horizontal && labelDummyRect ? labelDummyRect.y : routeY;
 		return {

package/dist/{spore-BfTduMDc.mjs → spore-ePWz2LtF.mjs}

@@ -1,4 +1,4 @@
-import { F as placePorts, O as getPolylineMidpoint, z as JavaRandom } from "./layered-f_3mmGHr.mjs";
+import { F as placePorts, O as getPolylineMidpoint, z as JavaRandom } from "./layered-Bp8MkxWK.mjs";
 import { getNodeSize } from "@statelyai/graph/layout";
 
 //#region src/fixed.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/layout",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Extensible, graph-native layout algorithms for @statelyai/graph",
   "license": "EPL-2.0 OR GPL-3.0-or-later",
   "repository": {

package/src/elkjs/index.ts

@@ -14,6 +14,7 @@ import type {
   ElkConstructorArguments,
   ElkLayoutAlgorithmDescription,
   ElkEdge,
+  ElkLabel,
   ElkLayoutArguments,
   ElkLayoutCategoryDescription,
   ElkLayoutOptionDescription,
@@ -25,6 +26,13 @@ import type {
   LaidOutElkNode,
 } from "./types";
 
+function isLayoutEdgeLabel(label: ElkLabel): boolean {
+  return (
+    getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true &&
+    (Boolean(label.text) || label.width !== undefined || label.height !== undefined)
+  );
+}
+
 export type {
   ElkConstructorArguments,
   ElkCommonDescription,
@@ -1264,10 +1272,7 @@ function toGraph(root: ElkNode, globalOptions: Readonly<Record<string, unknown>>
       if (isInsideSelfLoop(root, edge)) return [];
       const source = endpoint(edge.sources?.[0] ?? edge.source, portOwnerById);
       const target = endpoint(edge.targets?.[0] ?? edge.target, portOwnerById);
-      const labels = (edge.labels ?? []).filter(
-        (label) =>
-          Boolean(label.text) && getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true,
-      );
+      const labels = (edge.labels ?? []).filter(isLayoutEdgeLabel);
       const labelLabelSpacing = getNumberOption(globalOptions, "spacing.labelLabel") ?? 0;
       const labelWidth = Math.max(0, ...labels.map((label) => label.width ?? 0));
       const labelHeight =
@@ -1387,7 +1392,7 @@ function applyLayout(
         label.y ??= 0;
         continue;
       }
-      if (!label.text) {
+      if (!isLayoutEdgeLabel(label)) {
         label.x ??= 0;
         label.y ??= 0;
         continue;
@@ -1443,10 +1448,7 @@ function normalizeElkGraphBounds(
     );
   }
   for (const edge of root.edges ?? []) {
-    const laidOutLabels = (edge.labels ?? []).filter(
-      (label) =>
-        Boolean(label.text) && getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true,
-    );
+    const laidOutLabels = (edge.labels ?? []).filter(isLayoutEdgeLabel);
     minimumX = Math.min(minimumX, ...laidOutLabels.map((label) => label.x ?? 0));
     minimumY = Math.min(minimumY, ...laidOutLabels.map((label) => label.y ?? 0));
     if (getBooleanOption(edge.layoutOptions ?? {}, "noLayout") !== true) {
@@ -1473,7 +1475,7 @@ function normalizeElkGraphBounds(
           point.y += shiftY;
         }
       }
-      for (const label of (edge.labels ?? []).filter((candidate) => Boolean(candidate.text))) {
+      for (const label of (edge.labels ?? []).filter(isLayoutEdgeLabel)) {
         label.x = (label.x ?? 0) + shiftX;
         label.y = (label.y ?? 0) + shiftY;
       }
@@ -1578,11 +1580,7 @@ function normalizeElkGraphBounds(
       ]),
       ...(root.edges ?? []).flatMap((edge) =>
         (edge.labels ?? [])
-          .filter(
-            (label) =>
-              Boolean(label.text) &&
-              getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true,
-          )
+          .filter(isLayoutEdgeLabel)
           .map((label) => (label.x ?? 0) + (label.width ?? 0)),
       ),
       ...(root.edges ?? []).flatMap((edge) =>
@@ -1617,11 +1615,7 @@ function normalizeElkGraphBounds(
       ]),
       ...(root.edges ?? []).flatMap((edge) =>
         (edge.labels ?? [])
-          .filter(
-            (label) =>
-              Boolean(label.text) &&
-              getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true,
-          )
+          .filter(isLayoutEdgeLabel)
           .map(
             (label) =>
               (label.y ?? 0) +

package/src/layered/index.ts

@@ -1760,6 +1760,7 @@ function runLayeredPipeline<N, E, G, P>(
   );
   measure("post-compaction", () => applyPostCompaction(expanded.input, placement, expandedRoutes));
   const antiparallelLabelPositions = new Map<string, Point>();
+  const outerAntiparallelLabelIds = new Set<string>();
   const parallelLabelPositions = new Map<string, Point>();
   const postCompactionNodeCrossDeltas = new Map<string, number>();
   const horizontalAntiparallelFlow = direction === "left" || direction === "right";
@@ -1898,14 +1899,14 @@ function runLayeredPipeline<N, E, G, P>(
                   : [],
           ),
         );
-      if (nonSelfNeighbors(firstNode.id).size !== 1 || nonSelfNeighbors(secondNode.id).size !== 1) {
-        continue;
-      }
+      const isolatedAntiparallelPair =
+        nonSelfNeighbors(firstNode.id).size === 1 && nonSelfNeighbors(secondNode.id).size === 1;
       const hasFlexiblePorts = (node: GraphNode): boolean => {
         const constraints = options.nodeSettings?.(node)?.portConstraints;
         return constraints === undefined || constraints === "UNDEFINED" || constraints === "FREE";
       };
-      if (!hasFlexiblePorts(firstNode) || !hasFlexiblePorts(secondNode)) continue;
+      const hasFlexiblePairPorts = hasFlexiblePorts(firstNode) && hasFlexiblePorts(secondNode);
+      if (isolatedAntiparallelPair && !hasFlexiblePairPorts) continue;
 
       const firstBeforeSecond = horizontal
         ? firstRect.x + firstRect.width / 2 < secondRect.x + secondRect.width / 2
@@ -1929,16 +1930,44 @@ function runLayeredPipeline<N, E, G, P>(
         const height = edge.height ?? 0;
         antiparallelLabelPositions.set(
           edge.id,
-          horizontal
-            ? {
-                x: (beforeRect.x + beforeRect.width + afterRect.x - width) / 2,
-                y: cross,
-              }
-            : {
-                x: cross,
-                y: (beforeRect.y + beforeRect.height + afterRect.y - height) / 2,
-              },
+          isolatedAntiparallelPair
+            ? horizontal
+              ? {
+                  x: (beforeRect.x + beforeRect.width + afterRect.x - width) / 2,
+                  y: cross,
+                }
+              : {
+                  x: cross,
+                  y: (beforeRect.y + beforeRect.height + afterRect.y - height) / 2,
+                }
+            : horizontal
+              ? {
+                  x: (beforeRect.x + beforeRect.width + afterRect.x - width) / 2,
+                  y:
+                    edge === forward
+                      ? (firstRect.y +
+                          firstRect.height / 2 +
+                          secondRect.y +
+                          secondRect.height / 2) /
+                          2 -
+                        height / 2
+                      : Math.max(firstRect.y + firstRect.height, secondRect.y + secondRect.height) +
+                        edgeSpacing,
+                }
+              : {
+                  x:
+                    edge === forward
+                      ? (firstRect.x + firstRect.width / 2 + secondRect.x + secondRect.width / 2) /
+                          2 -
+                        width / 2
+                      : Math.max(firstRect.x + firstRect.width, secondRect.x + secondRect.width) +
+                        edgeSpacing,
+                  y: (beforeRect.y + beforeRect.height + afterRect.y - height) / 2,
+                },
         );
+        if (!isolatedAntiparallelPair && edge !== forward) {
+          outerAntiparallelLabelIds.add(edge.id);
+        }
         cross += (horizontal ? height : width) + edgeSpacing;
       }
 
@@ -1974,8 +2003,10 @@ function runLayeredPipeline<N, E, G, P>(
           horizontal ? { ...rect, y: nextCross } : { ...rect, x: nextCross },
         );
       };
-      alignPort(nodesById.get(forward.sourceId)!, forward.sourcePort);
-      alignPort(nodesById.get(forward.targetId)!, forward.targetPort);
+      if (isolatedAntiparallelPair) {
+        alignPort(nodesById.get(forward.sourceId)!, forward.sourcePort);
+        alignPort(nodesById.get(forward.targetId)!, forward.targetPort);
+      }
     }
   }
   if (postCompactionNodeCrossDeltas.size > 0) {
@@ -2482,8 +2513,41 @@ function runLayeredPipeline<N, E, G, P>(
             ? [sourceRect, targetRect]
             : [targetRect, sourceRect]
         : [undefined, undefined];
+    const antiparallelLabelPosition = antiparallelLabelPositions.get(edge.id);
+    const outerAntiparallelLabelPosition = (() => {
+      if (!outerAntiparallelLabelIds.has(edge.id)) return undefined;
+      const edgeNodeSpacing = Number(options.settings?.["spacing.edgeNode"] ?? 10);
+      if (horizontal) {
+        const x = (beforeFlowRect!.x + beforeFlowRect!.width + afterFlowRect!.x - width) / 2;
+        const blockers = [
+          sourceRect!,
+          targetRect!,
+          ...[...placement.rectByNodeId.values()].filter(
+            (rect) => rect.x < x + width && rect.x + rect.width > x,
+          ),
+        ];
+        return {
+          x,
+          y: Math.max(...blockers.map((rect) => rect.y + rect.height)) + edgeNodeSpacing,
+        };
+      }
+      const y = (beforeFlowRect!.y + beforeFlowRect!.height + afterFlowRect!.y - height) / 2;
+      const blockers = [
+        sourceRect!,
+        targetRect!,
+        ...[...placement.rectByNodeId.values()].filter(
+          (rect) => rect.y < y + height && rect.y + rect.height > y,
+        ),
+      ];
+      return {
+        x: Math.max(...blockers.map((rect) => rect.x + rect.width)) + edgeNodeSpacing,
+        y,
+      };
+    })();
     const explicitLabelPosition =
-      antiparallelLabelPositions.get(edge.id) ?? parallelLabelPositions.get(edge.id);
+      outerAntiparallelLabelPosition ??
+      antiparallelLabelPosition ??
+      parallelLabelPositions.get(edge.id);
     const x = explicitLabelPosition
       ? explicitLabelPosition.x
       : flexibleFeedbackLabel