@statelyai/layout 0.0.4 → 0.0.5

package/dist/elkjs/index.mjs

@@ -1,5 +1,5 @@
-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 { o as elkLayeredOptionDefinitions, t as getLayeredLayout } from "../layered-BYhTymAk.mjs";
+import { a as getRandomLayout, f as getFixedLayout, n as getSporeOverlapRemovalLayout, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "../spore-B504wOFR.mjs";
 import { createGraph } from "@statelyai/graph";
 
 //#region src/elkjs/index.ts

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-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 { 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-BYhTymAk.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-B504wOFR.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-Bp8MkxWK.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-BYhTymAk.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-Bp8MkxWK.mjs → layered-BYhTymAk.mjs}

@@ -3699,6 +3699,77 @@ function getPolylineMidpoint(points) {
 	};
 }
 
+//#endregion
+//#region src/layered/separate-exterior-labels.ts
+/** Separates movable inline labels and their exterior orthogonal route tracks. */
+function separateExteriorLabels({ edges, nodeRects, direction, spacing, settings }) {
+	const horizontalFlow = direction === "left" || direction === "right";
+	const nodeCrossStart = Math.min(...nodeRects.map((rect) => horizontalFlow ? rect.y : rect.x));
+	const nodeCrossEnd = Math.max(...nodeRects.map((rect) => horizontalFlow ? rect.y + rect.height : rect.x + rect.width));
+	const flowStart = (rect) => horizontalFlow ? rect.x : rect.y;
+	const flowEnd = (rect) => horizontalFlow ? rect.x + rect.width : rect.y + rect.height;
+	const crossStart = (rect) => horizontalFlow ? rect.y : rect.x;
+	const crossEnd = (rect) => horizontalFlow ? rect.y + rect.height : rect.x + rect.width;
+	const overlaps = (left, right) => flowStart(left) < flowEnd(right) && flowEnd(left) > flowStart(right) && crossStart(left) < crossEnd(right) && crossEnd(left) > crossStart(right);
+	const labelRectByEdgeId = new Map(edges.filter((edge) => edge.width > 0 && edge.height > 0).map((edge) => [String(edge.id), {
+		x: edge.x,
+		y: edge.y,
+		width: edge.width,
+		height: edge.height
+	}]));
+	const movableLabels = edges.flatMap((edge) => {
+		const labelRect = labelRectByEdgeId.get(String(edge.id));
+		const labelSettings = settings(edge);
+		if (!labelRect || !labelSettings.inline || labelSettings.placement !== "CENTER") return [];
+		const exteriorTrack = edge.points.flatMap((point, index) => {
+			const next = edge.points[index + 1];
+			if (!next) return [];
+			const isFlowSegment = horizontalFlow ? point.y === next.y && point.x !== next.x : point.x === next.x && point.y !== next.y;
+			const trackCross = horizontalFlow ? point.y : point.x;
+			return isFlowSegment && (trackCross < nodeCrossStart || trackCross > nodeCrossEnd) ? [{
+				cross: trackCross,
+				length: horizontalFlow ? Math.abs(next.x - point.x) : Math.abs(next.y - point.y)
+			}] : [];
+		}).sort((left, right) => right.length - left.length)[0];
+		if (!exteriorTrack) return [];
+		return [{
+			edge,
+			exteriorTrack,
+			labelRect,
+			lowSide: exteriorTrack.cross < (nodeCrossStart + nodeCrossEnd) / 2
+		}];
+	});
+	movableLabels.sort((left, right) => {
+		if (left.lowSide !== right.lowSide) return left.lowSide ? -1 : 1;
+		return (left.lowSide ? crossStart(left.labelRect) - crossStart(right.labelRect) : crossStart(right.labelRect) - crossStart(left.labelRect)) || flowStart(left.labelRect) - flowStart(right.labelRect) || (String(left.edge.id) < String(right.edge.id) ? -1 : String(left.edge.id) > String(right.edge.id) ? 1 : 0);
+	});
+	for (const { edge, exteriorTrack, labelRect, lowSide } of movableLabels) {
+		const obstacles = [...nodeRects, ...[...labelRectByEdgeId.entries()].flatMap(([edgeId, rect]) => edgeId === String(edge.id) ? [] : [rect])];
+		let totalDelta = 0;
+		while (true) {
+			const blockers = obstacles.filter((rect) => overlaps(labelRect, rect));
+			if (blockers.length === 0) break;
+			const delta = (lowSide ? Math.min(...blockers.map(crossStart)) - spacing - (horizontalFlow ? edge.height : edge.width) : Math.max(...blockers.map(crossEnd)) + spacing) - crossStart(labelRect);
+			totalDelta += delta;
+			if (horizontalFlow) labelRect.y += delta;
+			else labelRect.x += delta;
+		}
+		if (totalDelta === 0) continue;
+		if (horizontalFlow) edge.y += totalDelta;
+		else edge.x += totalDelta;
+		edge.points = edge.points.map((point) => {
+			if ((horizontalFlow ? point.y : point.x) !== exteriorTrack.cross) return point;
+			return horizontalFlow ? {
+				...point,
+				y: point.y + totalDelta
+			} : {
+				...point,
+				x: point.x + totalDelta
+			};
+		});
+	}
+}
+
 //#endregion
 //#region src/layered/network-simplex.ts
 function connectedEdges(node) {
@@ -9289,6 +9360,19 @@ function runLayeredPipeline(graph, options, context) {
 			routing: edgeRouting === "POLYLINE" ? "polyline" : edgeRouting === "SPLINES" ? "splines" : "orthogonal"
 		};
 	});
+	if (edgeRouting === "ORTHOGONAL") separateExteriorLabels({
+		edges,
+		nodeRects: feedbackNodeRects,
+		direction,
+		spacing: Number(options.settings?.["spacing.edgeEdge"] ?? 10),
+		settings: (edge) => {
+			const edgeSettings = options.edgeSettings?.(edge);
+			return {
+				inline: edgeSettings?.["edgeLabels.inline"] === true,
+				placement: edgeSettings?.["edgeLabels.placement"] ?? "CENTER"
+			};
+		}
+	});
 	return {
 		...graph,
 		direction,

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/layout",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Extensible, graph-native layout algorithms for @statelyai/graph",
   "license": "EPL-2.0 OR GPL-3.0-or-later",
   "repository": {
@@ -47,6 +47,7 @@
     "@changesets/cli": "3.0.1",
     "@codemirror/lang-javascript": "^6.2.5",
     "@codemirror/lint": "^6.9.7",
+    "@statelyai/layout-pre-exterior-label-separation": "npm:@statelyai/layout@0.0.4",
     "@types/node": "^25.0.3",
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.4",

package/src/layered/index.ts

@@ -1,6 +1,7 @@
 import type { Graph, GraphEdge, GraphNode, Point, VisualGraph, VisualNode } from "@statelyai/graph";
 import { UnsupportedLayoutError } from "../errors";
 import type { LayoutAlgorithm, LayoutExecutionContext } from "../types";
+import { separateExteriorLabels } from "./separate-exterior-labels";
 import {
   assignLayersByLongestPath,
   assignLayersByLongestPathToSink,
@@ -2582,6 +2583,22 @@ function runLayeredPipeline<N, E, G, P>(
     };
   });
 
+  if (edgeRouting === "ORTHOGONAL") {
+    separateExteriorLabels({
+      edges,
+      nodeRects: feedbackNodeRects,
+      direction,
+      spacing: Number(options.settings?.["spacing.edgeEdge"] ?? 10),
+      settings: (edge) => {
+        const edgeSettings = options.edgeSettings?.(edge);
+        return {
+          inline: edgeSettings?.["edgeLabels.inline"] === true,
+          placement: edgeSettings?.["edgeLabels.placement"] ?? "CENTER",
+        };
+      },
+    });
+  }
+
   return {
     ...graph,
     direction,

package/src/layered/separate-exterior-labels.ts

@@ -0,0 +1,139 @@
+import type { EntityRect, Point } from "@statelyai/graph";
+
+export interface ExteriorLabelEdge {
+  id: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  points: Point[];
+}
+
+interface ExteriorLabelSettings {
+  inline: boolean;
+  placement: string;
+}
+
+interface SeparateExteriorLabelsInput<E extends ExteriorLabelEdge> {
+  edges: E[];
+  nodeRects: readonly EntityRect[];
+  direction: "up" | "down" | "left" | "right";
+  spacing: number;
+  settings: (edge: E) => ExteriorLabelSettings;
+}
+
+/** Separates movable inline labels and their exterior orthogonal route tracks. */
+export function separateExteriorLabels<E extends ExteriorLabelEdge>({
+  edges,
+  nodeRects,
+  direction,
+  spacing,
+  settings,
+}: SeparateExteriorLabelsInput<E>): void {
+  const horizontalFlow = direction === "left" || direction === "right";
+  const nodeCrossStart = Math.min(...nodeRects.map((rect) => (horizontalFlow ? rect.y : rect.x)));
+  const nodeCrossEnd = Math.max(
+    ...nodeRects.map((rect) => (horizontalFlow ? rect.y + rect.height : rect.x + rect.width)),
+  );
+  const flowStart = (rect: EntityRect): number => (horizontalFlow ? rect.x : rect.y);
+  const flowEnd = (rect: EntityRect): number =>
+    horizontalFlow ? rect.x + rect.width : rect.y + rect.height;
+  const crossStart = (rect: EntityRect): number => (horizontalFlow ? rect.y : rect.x);
+  const crossEnd = (rect: EntityRect): number =>
+    horizontalFlow ? rect.y + rect.height : rect.x + rect.width;
+  const overlaps = (left: EntityRect, right: EntityRect): boolean =>
+    flowStart(left) < flowEnd(right) &&
+    flowEnd(left) > flowStart(right) &&
+    crossStart(left) < crossEnd(right) &&
+    crossEnd(left) > crossStart(right);
+  type MutableRect = { x: number; y: number; width: number; height: number };
+  const labelRectByEdgeId = new Map<string, MutableRect>(
+    edges
+      .filter((edge) => edge.width > 0 && edge.height > 0)
+      .map((edge) => [
+        String(edge.id),
+        { x: edge.x, y: edge.y, width: edge.width, height: edge.height },
+      ]),
+  );
+  const movableLabels = edges.flatMap((edge) => {
+    const labelRect = labelRectByEdgeId.get(String(edge.id));
+    const labelSettings = settings(edge);
+    if (!labelRect || !labelSettings.inline || labelSettings.placement !== "CENTER") return [];
+    const exteriorTrack = edge.points
+      .flatMap((point, index) => {
+        const next = edge.points[index + 1];
+        if (!next) return [];
+        const isFlowSegment = horizontalFlow
+          ? point.y === next.y && point.x !== next.x
+          : point.x === next.x && point.y !== next.y;
+        const trackCross = horizontalFlow ? point.y : point.x;
+        return isFlowSegment && (trackCross < nodeCrossStart || trackCross > nodeCrossEnd)
+          ? [
+              {
+                cross: trackCross,
+                length: horizontalFlow ? Math.abs(next.x - point.x) : Math.abs(next.y - point.y),
+              },
+            ]
+          : [];
+      })
+      .sort((left, right) => right.length - left.length)[0];
+    if (!exteriorTrack) return [];
+    return [
+      {
+        edge,
+        exteriorTrack,
+        labelRect,
+        lowSide: exteriorTrack.cross < (nodeCrossStart + nodeCrossEnd) / 2,
+      },
+    ];
+  });
+
+  movableLabels.sort((left, right) => {
+    if (left.lowSide !== right.lowSide) return left.lowSide ? -1 : 1;
+    const crossDifference = left.lowSide
+      ? crossStart(left.labelRect) - crossStart(right.labelRect)
+      : crossStart(right.labelRect) - crossStart(left.labelRect);
+    return (
+      crossDifference ||
+      flowStart(left.labelRect) - flowStart(right.labelRect) ||
+      (String(left.edge.id) < String(right.edge.id)
+        ? -1
+        : String(left.edge.id) > String(right.edge.id)
+          ? 1
+          : 0)
+    );
+  });
+
+  for (const { edge, exteriorTrack, labelRect, lowSide } of movableLabels) {
+    const obstacles = [
+      ...nodeRects,
+      ...[...labelRectByEdgeId.entries()].flatMap(([edgeId, rect]) =>
+        edgeId === String(edge.id) ? [] : [rect],
+      ),
+    ];
+    let totalDelta = 0;
+    while (true) {
+      const blockers = obstacles.filter((rect) => overlaps(labelRect, rect));
+      if (blockers.length === 0) break;
+      const desiredCross = lowSide
+        ? Math.min(...blockers.map(crossStart)) -
+          spacing -
+          (horizontalFlow ? edge.height : edge.width)
+        : Math.max(...blockers.map(crossEnd)) + spacing;
+      const delta = desiredCross - crossStart(labelRect);
+      totalDelta += delta;
+      if (horizontalFlow) labelRect.y += delta;
+      else labelRect.x += delta;
+    }
+    if (totalDelta === 0) continue;
+    if (horizontalFlow) edge.y += totalDelta;
+    else edge.x += totalDelta;
+    edge.points = edge.points.map((point) => {
+      const pointCross = horizontalFlow ? point.y : point.x;
+      if (pointCross !== exteriorTrack.cross) return point;
+      return horizontalFlow
+        ? { ...point, y: point.y + totalDelta }
+        : { ...point, x: point.x + totalDelta };
+    });
+  }
+}