@statelyai/layout 0.1.3 → 0.3.0

package/dist/{spore-BtTSZbb6.mjs → layout-engine-Cs5tatA6.mjs}

@@ -1,4 +1,4 @@
-import { F as placePorts, O as getPolylineMidpoint, z as JavaRandom } from "./layered-CoeH9LRO.mjs";
+import { B as JavaRandom, I as placePorts, k as getPolylineMidpoint, n as layeredAlgorithm } from "./layered-DGFTeQSl.mjs";
 import { getNodeSize } from "@statelyai/graph/layout";
 
 //#region src/fixed.ts
@@ -68,6 +68,14 @@ const fixedAlgorithm = {
 	}
 };
 
+//#endregion
+//#region src/internal/elkjs-compatibility.ts
+const elkjs0111ResultPolicy = Symbol("elkjs0111ResultPolicy");
+function setElkjs0111ResultPolicy(graph, policy) {
+	Object.defineProperty(graph, elkjs0111ResultPolicy, { value: policy });
+	return graph;
+}
+
 //#endregion
 //#region src/box.ts
 function getPadding$3(value) {
@@ -193,6 +201,25 @@ const boxAlgorithm = {
 		return getBoxLayout(graph, options ?? {});
 	}
 };
+/** Pinned behavior used only by the elkjs 0.11.1 compatibility adapter. */
+const elkjs0111BoxAlgorithm = {
+	...boxAlgorithm,
+	layout(graph, options = {}) {
+		const result = getBoxLayout(graph, options);
+		const padding = getPadding$3(options.padding);
+		return setElkjs0111ResultPolicy(result, {
+			providerBounds: result.nodes.length === 0 ? {
+				width: 0,
+				height: 0
+			} : {
+				width: Math.max(...result.nodes.map((node) => node.x + node.width)) + padding.right,
+				height: Math.max(...result.nodes.map((node) => node.y + node.height)) + padding.bottom
+			},
+			preserveEdgeSections: true,
+			skipBoundsNormalization: true
+		});
+	}
+};
 
 //#endregion
 //#region src/packing.ts
@@ -259,9 +286,36 @@ const rectanglePackingAlgorithm = {
 		return getRectanglePackingLayout(graph, options ?? {});
 	}
 };
+/** Pinned output policy used only by the elkjs 0.11.1 compatibility adapter. */
+const elkjs0111RectanglePackingAlgorithm = {
+	...rectanglePackingAlgorithm,
+	layout(graph, options = {}) {
+		const result = getRectanglePackingLayout(graph, options);
+		const padding = getPadding$2(options.padding);
+		return setElkjs0111ResultPolicy(result, {
+			providerBounds: result.nodes.length === 0 ? {
+				width: 0,
+				height: 0
+			} : {
+				width: Math.max(...result.nodes.map((node) => node.x + node.width)) + padding.right,
+				height: Math.max(...result.nodes.map((node) => node.y + node.height)) + padding.bottom
+			},
+			preserveEdgeSections: true,
+			skipBoundsNormalization: true
+		});
+	}
+};
 
 //#endregion
 //#region src/random.ts
+const nativeBehavior = {
+	elkjs0111EdgeTargetBug: false,
+	preserveProviderBounds: false
+};
+const elkjs0111Behavior = {
+	elkjs0111EdgeTargetBug: true,
+	preserveProviderBounds: true
+};
 function getPadding$1(value) {
 	if (typeof value === "number") return {
 		top: value,
@@ -299,6 +353,9 @@ function borderPoint(source, target) {
 }
 /** Seeded random distribution using Java's 48-bit `Random` sequence. */
 function getRandomLayout(graph, options = {}) {
+	return getRandomLayoutWithBehavior(graph, options, nativeBehavior);
+}
+function getRandomLayoutWithBehavior(graph, options, behavior) {
 	if (graph.nodes.length === 0) return getFixedLayout(graph, options);
 	const random = new JavaRandom(options.seed && options.seed !== 0 ? options.seed : Date.now());
 	const aspectRatio = Math.fround(options.aspectRatio ?? 1.6);
@@ -328,10 +385,49 @@ function getRandomLayout(graph, options = {}) {
 	const nodeById = new Map(nodes.map((node) => [node.id, node]));
 	const totalWidth = drawWidth + padding.left + padding.right;
 	const totalHeight = drawHeight + padding.top + padding.bottom;
-	const edges = graph.edges.map((edge) => {
+	const layoutEdge = (edge) => {
 		const source = nodeById.get(edge.sourceId);
 		const target = nodeById.get(edge.targetId);
 		if (!source || !target) return edge;
+		if (behavior.elkjs0111EdgeTargetBug) {
+			const start$1 = {
+				x: source.x + source.width,
+				y: source.y + source.height / 2
+			};
+			const end$1 = {
+				x: source.x + source.width / 2,
+				y: source.y + source.height
+			};
+			const bendCount$1 = random.nextInt(5) + 1;
+			const xDifference = end$1.x - start$1.x;
+			const yDifference = end$1.y - start$1.y;
+			const maximumDeviation$1 = Math.hypot(xDifference, yDifference) * Math.fround(.2);
+			const xIncrement = xDifference / (bendCount$1 + 1);
+			const yIncrement = yDifference / (bendCount$1 + 1);
+			let x = start$1.x;
+			let y = start$1.y;
+			const points$1 = [start$1];
+			for (let index = 0; index < bendCount$1; index++) {
+				x += xIncrement;
+				y += yIncrement;
+				let randomX = x + random.nextFloat() * maximumDeviation$1 - maximumDeviation$1 / 2;
+				if (randomX < 0) randomX = 1;
+				else if (randomX > totalWidth) randomX = totalWidth - 1;
+				let randomY = y + random.nextFloat() * maximumDeviation$1 - maximumDeviation$1 / 2;
+				if (randomY < 0) randomY = 1;
+				else if (randomY > totalHeight) randomY = totalHeight - 1;
+				points$1.push({
+					x: randomX,
+					y: randomY
+				});
+			}
+			points$1.push(end$1);
+			return {
+				...edge,
+				points: points$1,
+				routing: "polyline"
+			};
+		}
 		const start = borderPoint(source, target);
 		const end = borderPoint(target, source);
 		const bendCount = random.nextInt(5) + (source === target ? 1 : 0);
@@ -350,12 +446,18 @@ function getRandomLayout(graph, options = {}) {
 			points,
 			routing: "polyline"
 		};
-	});
-	return getFixedLayout({
+	};
+	const edges = behavior.elkjs0111EdgeTargetBug ? graph.nodes.flatMap((node) => graph.edges.filter((edge) => edge.sourceId === node.id).map(layoutEdge)) : graph.edges.map(layoutEdge);
+	const result = getFixedLayout({
 		...graph,
 		nodes,
 		edges
 	}, { direction: options.direction ?? graph.direction });
+	if (behavior.preserveProviderBounds) setElkjs0111ResultPolicy(result, { providerBounds: {
+		width: drawWidth + 2 * (padding.left + padding.right),
+		height: drawHeight + 2 * (padding.top + padding.bottom)
+	} });
+	return result;
 }
 const randomAlgorithm = {
 	id: "random",
@@ -371,6 +473,13 @@ const randomAlgorithm = {
 		return getRandomLayout(graph, options ?? {});
 	}
 };
+/** Pinned behavior used only by the elkjs 0.11.1 compatibility adapter. */
+const elkjs0111RandomAlgorithm = {
+	...randomAlgorithm,
+	layout(graph, options) {
+		return getRandomLayoutWithBehavior(graph, options ?? {}, elkjs0111Behavior);
+	}
+};
 
 //#endregion
 //#region src/spore.ts
@@ -454,4 +563,49 @@ const sporeCompactionAlgorithm = algorithm("sporeCompaction", true);
 const sporeOverlapRemovalAlgorithm = algorithm("sporeOverlap", false);
 
 //#endregion
-export { getRandomLayout as a, rectanglePackingAlgorithm as c, fixedAlgorithm as d, getFixedLayout as f, sporeOverlapRemovalAlgorithm as i, boxAlgorithm as l, getSporeOverlapRemovalLayout as n, randomAlgorithm as o, sporeCompactionAlgorithm as r, getRectanglePackingLayout as s, getSporeCompactionLayout as t, getBoxLayout as u };
+//#region src/internal/layout-engine.ts
+const builtInLayoutAlgorithms = {
+	box: boxAlgorithm,
+	fixed: fixedAlgorithm,
+	layered: layeredAlgorithm,
+	random: randomAlgorithm,
+	rectpacking: rectanglePackingAlgorithm,
+	sporeCompaction: sporeCompactionAlgorithm,
+	sporeOverlap: sporeOverlapRemovalAlgorithm
+};
+const elkjs0111LayoutAlgorithms = {
+	...builtInLayoutAlgorithms,
+	box: elkjs0111BoxAlgorithm,
+	random: elkjs0111RandomAlgorithm,
+	rectpacking: elkjs0111RectanglePackingAlgorithm
+};
+function getBuiltInLayoutAlgorithm(id) {
+	if (!Object.hasOwn(builtInLayoutAlgorithms, id)) return void 0;
+	return builtInLayoutAlgorithms[id];
+}
+/** Execute one algorithm through the shared engine seam. */
+function executeLayoutAlgorithm({ algorithm: algorithm$1, graph, options, context }) {
+	return algorithm$1.layout(graph, options, context);
+}
+function createDirectExecutionContext() {
+	return {
+		scope: { mode: "full" },
+		diagnostics: [],
+		measurePhase(_id, run) {
+			return run();
+		},
+		throwIfAborted() {}
+	};
+}
+/** Execute through the pinned elkjs 0.11.1 compatibility policy. */
+function executeElkjs0111Layout({ algorithm: algorithm$1, graph, options }) {
+	return executeLayoutAlgorithm({
+		algorithm: elkjs0111LayoutAlgorithms[algorithm$1],
+		graph,
+		options,
+		context: createDirectExecutionContext()
+	});
+}
+
+//#endregion
+export { getFixedLayout as _, getSporeCompactionLayout as a, sporeOverlapRemovalAlgorithm as c, getRectanglePackingLayout as d, rectanglePackingAlgorithm as f, fixedAlgorithm as g, elkjs0111ResultPolicy as h, getBuiltInLayoutAlgorithm as i, getRandomLayout as l, getBoxLayout as m, executeElkjs0111Layout as n, getSporeOverlapRemovalLayout as o, boxAlgorithm as p, executeLayoutAlgorithm as r, sporeCompactionAlgorithm as s, builtInLayoutAlgorithms as t, randomAlgorithm as u };