@statelyai/layout 0.0.0

package/dist/spore-cihb_Aht.mjs

@@ -0,0 +1,487 @@
+import { a as getPolylineMidpoint, c as placePorts } from "./layered-ByNCZQgJ.mjs";
+import { getNodeSize } from "@statelyai/graph/layout";
+
+//#region src/fixed.ts
+function defaultRoute(source, target) {
+	return [{
+		x: source.x + source.width / 2,
+		y: source.y + source.height / 2
+	}, {
+		x: target.x + target.width / 2,
+		y: target.y + target.height / 2
+	}];
+}
+/** Preserve authored positions and routes while completing visual geometry. */
+function getFixedLayout(graph, options = {}) {
+	const direction = options.direction ?? graph.direction ?? "down";
+	const nodes = graph.nodes.map((node) => {
+		const size = getNodeSize(node, options);
+		const rect = {
+			x: node.x ?? 0,
+			y: node.y ?? 0,
+			...size
+		};
+		const ports = placePorts(node.ports, rect, direction);
+		return {
+			...node,
+			...rect,
+			...ports === void 0 ? {} : { ports }
+		};
+	});
+	const nodeById = new Map(nodes.map((node) => [node.id, node]));
+	const edges = graph.edges.map((edge) => {
+		const source = nodeById.get(edge.sourceId);
+		const target = nodeById.get(edge.targetId);
+		const points = edge.points ? [...edge.points] : source && target ? defaultRoute(source, target) : [];
+		const midpoint = getPolylineMidpoint(points);
+		const width = edge.width ?? 0;
+		const height = edge.height ?? 0;
+		return {
+			...edge,
+			x: edge.x ?? midpoint.x - width / 2,
+			y: edge.y ?? midpoint.y - height / 2,
+			width,
+			height,
+			points,
+			routing: edge.routing ?? "polyline"
+		};
+	});
+	return {
+		...graph,
+		direction,
+		nodes,
+		edges
+	};
+}
+const fixedAlgorithm = {
+	id: "fixed",
+	capabilities: {
+		full: true,
+		incremental: false,
+		partial: false,
+		routeOnly: false,
+		hierarchy: true,
+		ports: true
+	},
+	layout(graph, options) {
+		return getFixedLayout(graph, options ?? {});
+	}
+};
+
+//#endregion
+//#region src/box.ts
+function getPadding$3(value) {
+	if (typeof value === "number") return {
+		top: value,
+		right: value,
+		bottom: value,
+		left: value
+	};
+	return {
+		top: value?.top ?? 15,
+		right: value?.right ?? 15,
+		bottom: value?.bottom ?? 15,
+		left: value?.left ?? 15
+	};
+}
+function standardDeviation(values, mean) {
+	if (values.length < 2) return 0;
+	const variance = values.reduce((sum, value) => sum + (value - mean) ** 2, 0);
+	return Math.sqrt(variance / (values.length - 1));
+}
+/** ELK Box SIMPLE packing translated onto `@statelyai/graph`. */
+function getBoxLayout(graph, options = {}) {
+	const spacing = Math.fround(options.spacing ?? 15);
+	const padding = getPadding$3(options.padding);
+	const aspectRatio = (options.aspectRatio ?? 1.3) > 0 ? options.aspectRatio ?? 1.3 : 1.3;
+	const sizes = new Map(graph.nodes.map((node) => [node.id, getNodeSize(node, options)]));
+	const sortedNodes = [...graph.nodes].sort((first, second) => {
+		const priorityDifference = (options.priority?.(second) ?? 0) - (options.priority?.(first) ?? 0);
+		if (priorityDifference !== 0) return priorityDifference;
+		if (options.interactive) {
+			const yDifference = (first.y ?? 0) - (second.y ?? 0);
+			if (yDifference !== 0) return yDifference;
+			const xDifference = (first.x ?? 0) - (second.x ?? 0);
+			if (xDifference !== 0) return xDifference;
+		}
+		const firstSize = sizes.get(first.id) ?? {
+			width: 0,
+			height: 0
+		};
+		const secondSize = sizes.get(second.id) ?? {
+			width: 0,
+			height: 0
+		};
+		return firstSize.width * firstSize.height - secondSize.width * secondSize.height;
+	});
+	const areas = sortedNodes.map((node) => {
+		const size = sizes.get(node.id) ?? {
+			width: 0,
+			height: 0
+		};
+		return size.width * size.height;
+	});
+	let totalArea = areas.reduce((sum, area) => sum + area, 0);
+	const mean = areas.length === 0 ? 0 : totalArea / areas.length;
+	totalArea += areas.length * standardDeviation(areas, mean);
+	totalArea += Math.sqrt(totalArea) * (padding.bottom + padding.top);
+	totalArea += Math.sqrt(totalArea) * padding.right;
+	const widestNode = Math.max(0, ...sortedNodes.map((node) => sizes.get(node.id)?.width ?? 0));
+	const maximumRowWidth = Math.max(widestNode, Math.sqrt(totalArea * aspectRatio)) + padding.left;
+	let x = padding.left;
+	let y = padding.top;
+	let rowHeight = 0;
+	let rowStart = 0;
+	const rows = [];
+	const nodes = [];
+	for (const node of sortedNodes) {
+		const size = sizes.get(node.id) ?? {
+			width: 0,
+			height: 0
+		};
+		if (x + size.width > maximumRowWidth) {
+			rows.push({
+				start: rowStart,
+				end: nodes.length,
+				height: rowHeight
+			});
+			rowStart = nodes.length;
+			x = padding.left;
+			y += rowHeight + spacing;
+			rowHeight = 0;
+		}
+		nodes.push({
+			...node,
+			x,
+			y,
+			...size
+		});
+		x += size.width + spacing;
+		rowHeight = Math.max(rowHeight, size.height);
+	}
+	rows.push({
+		start: rowStart,
+		end: nodes.length,
+		height: rowHeight
+	});
+	if (options.expandNodes) {
+		const broadestRow = Math.max(padding.left + padding.right, ...nodes.map((node) => node.x + node.width + padding.right));
+		for (const row of rows) for (let index = row.start; index < row.end; index++) {
+			const node = nodes[index];
+			if (!node) continue;
+			node.height = row.height;
+			if (index === row.end - 1) node.width = broadestRow - node.x - padding.right;
+		}
+	}
+	const placedById = new Map(nodes.map((node) => [node.id, node]));
+	return getFixedLayout({
+		...graph,
+		nodes: graph.nodes.map((node) => placedById.get(node.id) ?? node)
+	}, { direction: options.direction ?? graph.direction });
+}
+const boxAlgorithm = {
+	id: "box",
+	capabilities: {
+		full: true,
+		incremental: false,
+		partial: false,
+		routeOnly: false,
+		hierarchy: false,
+		ports: true
+	},
+	layout(graph, options) {
+		return getBoxLayout(graph, options ?? {});
+	}
+};
+
+//#endregion
+//#region src/packing.ts
+function getPadding$2(value) {
+	if (typeof value === "number") return {
+		top: value,
+		right: value,
+		bottom: value,
+		left: value
+	};
+	return {
+		top: value?.top ?? 0,
+		right: value?.right ?? 0,
+		bottom: value?.bottom ?? 0,
+		left: value?.left ?? 0
+	};
+}
+/** Deterministic shelf-based rectangle packing for `@statelyai/graph`. */
+function getRectanglePackingLayout(graph, options = {}) {
+	const spacing = options.spacing ?? 20;
+	const padding = getPadding$2(options.padding);
+	const sizes = new Map(graph.nodes.map((node) => [node.id, getNodeSize(node, options)]));
+	const totalArea = [...sizes.values()].reduce((area, size) => area + (size.width + spacing) * (size.height + spacing), 0);
+	const targetWidth = options.targetWidth ?? Math.max(1, Math.sqrt(totalArea) * 1.5);
+	let x = padding.left;
+	let y = padding.top;
+	let rowHeight = 0;
+	const nodes = [];
+	for (const node of graph.nodes) {
+		const size = sizes.get(node.id) ?? {
+			width: 0,
+			height: 0
+		};
+		if (x > padding.left && x + size.width > padding.left + targetWidth) {
+			x = padding.left;
+			y += rowHeight + spacing;
+			rowHeight = 0;
+		}
+		nodes.push({
+			...node,
+			x,
+			y,
+			...size
+		});
+		x += size.width + spacing;
+		rowHeight = Math.max(rowHeight, size.height);
+	}
+	return getFixedLayout({
+		...graph,
+		nodes
+	}, { direction: options.direction ?? graph.direction });
+}
+const rectanglePackingAlgorithm = {
+	id: "rectpacking",
+	capabilities: {
+		full: true,
+		incremental: false,
+		partial: false,
+		routeOnly: false,
+		hierarchy: false,
+		ports: true
+	},
+	layout(graph, options) {
+		return getRectanglePackingLayout(graph, options ?? {});
+	}
+};
+
+//#endregion
+//#region src/random.ts
+var JavaRandom = class JavaRandom {
+	static #multiplier = 25214903917n;
+	static #addend = 11n;
+	static #mask = (1n << 48n) - 1n;
+	#seed;
+	constructor(seed) {
+		this.#seed = (BigInt(seed) ^ JavaRandom.#multiplier) & JavaRandom.#mask;
+	}
+	#next(bits) {
+		this.#seed = this.#seed * JavaRandom.#multiplier + JavaRandom.#addend & JavaRandom.#mask;
+		return Number(this.#seed >> BigInt(48 - bits));
+	}
+	nextDouble() {
+		return (this.#next(26) * 2 ** 27 + this.#next(27)) / 2 ** 53;
+	}
+	nextFloat() {
+		return this.#next(24) / 2 ** 24;
+	}
+	nextInt(bound) {
+		if (bound <= 0) throw new RangeError("bound must be positive");
+		if ((bound & -bound) === bound) return Math.floor(bound * this.#next(31) / 2 ** 31);
+		let bits;
+		let value;
+		do {
+			bits = this.#next(31);
+			value = bits % bound;
+		} while (bits - value + (bound - 1) >= 2 ** 31);
+		return value;
+	}
+};
+function getPadding$1(value) {
+	if (typeof value === "number") return {
+		top: value,
+		right: value,
+		bottom: value,
+		left: value
+	};
+	return {
+		top: value?.top ?? 15,
+		right: value?.right ?? 15,
+		bottom: value?.bottom ?? 15,
+		left: value?.left ?? 15
+	};
+}
+function borderPoint(source, target) {
+	const sourceCenter = {
+		x: source.x + source.width / 2,
+		y: source.y + source.height / 2
+	};
+	const targetCenter = {
+		x: target.x + target.width / 2,
+		y: target.y + target.height / 2
+	};
+	const dx = targetCenter.x - sourceCenter.x;
+	const dy = targetCenter.y - sourceCenter.y;
+	if (dx === 0 && dy === 0) return {
+		x: source.x + source.width,
+		y: sourceCenter.y
+	};
+	const scale = Math.min(dx === 0 ? Infinity : source.width / 2 / Math.abs(dx), dy === 0 ? Infinity : source.height / 2 / Math.abs(dy));
+	return {
+		x: sourceCenter.x + dx * scale,
+		y: sourceCenter.y + dy * scale
+	};
+}
+/** Seeded random distribution using Java's 48-bit `Random` sequence. */
+function getRandomLayout(graph, options = {}) {
+	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);
+	const spacing = Math.fround(options.spacing ?? 15);
+	const padding = getPadding$1(options.padding);
+	const sizes = new Map(graph.nodes.map((node) => [node.id, getNodeSize(node, options)]));
+	const nodeArea = [...sizes.values()].reduce((sum, size) => sum + size.width * size.height, 0);
+	const maximumWidth = Math.max(...[...sizes.values()].map((size) => size.width));
+	const maximumHeight = Math.max(...[...sizes.values()].map((size) => size.height));
+	const edgeFactor = 1 + graph.edges.length;
+	const drawArea = nodeArea + 2 * spacing * spacing * edgeFactor * graph.nodes.length;
+	const areaRoot = Math.sqrt(drawArea);
+	const drawWidth = Math.max(areaRoot * aspectRatio, maximumWidth);
+	const drawHeight = Math.max(areaRoot / aspectRatio, maximumHeight);
+	const nodes = graph.nodes.map((node) => {
+		const size = sizes.get(node.id) ?? {
+			width: 0,
+			height: 0
+		};
+		return {
+			...node,
+			x: padding.left + random.nextDouble() * (drawWidth - size.width),
+			y: padding.left + random.nextDouble() * (drawHeight - size.height),
+			...size
+		};
+	});
+	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 source = nodeById.get(edge.sourceId);
+		const target = nodeById.get(edge.targetId);
+		if (!source || !target) return edge;
+		const start = borderPoint(source, target);
+		const end = borderPoint(target, source);
+		const bendCount = random.nextInt(5) + (source === target ? 1 : 0);
+		const maximumDeviation = Math.hypot(end.x - start.x, end.y - start.y) * .2;
+		const points = [start];
+		for (let index = 1; index <= bendCount; index++) {
+			const progress = index / (bendCount + 1);
+			points.push({
+				x: Math.min(totalWidth - 1, Math.max(1, start.x + (end.x - start.x) * progress + random.nextFloat() * maximumDeviation - maximumDeviation / 2)),
+				y: Math.min(totalHeight - 1, Math.max(1, start.y + (end.y - start.y) * progress + random.nextFloat() * maximumDeviation - maximumDeviation / 2))
+			});
+		}
+		points.push(end);
+		return {
+			...edge,
+			points,
+			routing: "polyline"
+		};
+	});
+	return getFixedLayout({
+		...graph,
+		nodes,
+		edges
+	}, { direction: options.direction ?? graph.direction });
+}
+const randomAlgorithm = {
+	id: "random",
+	capabilities: {
+		full: true,
+		incremental: false,
+		partial: false,
+		routeOnly: false,
+		hierarchy: false,
+		ports: false
+	},
+	layout(graph, options) {
+		return getRandomLayout(graph, options ?? {});
+	}
+};
+
+//#endregion
+//#region src/spore.ts
+function getPadding(value) {
+	if (typeof value === "number") return {
+		top: value,
+		right: value,
+		bottom: value,
+		left: value
+	};
+	return {
+		top: value?.top ?? 0,
+		right: value?.right ?? 0,
+		bottom: value?.bottom ?? 0,
+		left: value?.left ?? 0
+	};
+}
+function getSporeLayout(graph, options, compact) {
+	const spacing = options.spacing ?? 20;
+	const padding = getPadding(options.padding);
+	const nodes = [];
+	graph.nodes.forEach((node, index) => {
+		const size = getNodeSize(node, options);
+		const previous = graph.nodes[index - 1];
+		const placedPrevious = nodes[index - 1];
+		if (!previous || !placedPrevious) {
+			nodes.push({
+				...node,
+				x: padding.left,
+				y: padding.top,
+				...size
+			});
+			return;
+		}
+		const deltaX = (node.x ?? 0) - (previous.x ?? 0);
+		const deltaY = (node.y ?? 0) - (previous.y ?? 0);
+		const requiredX = placedPrevious.width + spacing;
+		const requiredY = placedPrevious.height + spacing;
+		const distance = (delta, required) => {
+			if (delta === 0) return 0;
+			const magnitude = compact ? required : Math.max(Math.abs(delta), required);
+			return Math.sign(delta) * magnitude;
+		};
+		nodes.push({
+			...node,
+			x: placedPrevious.x + distance(deltaX, requiredX),
+			y: placedPrevious.y + distance(deltaY, requiredY),
+			...size
+		});
+	});
+	return getFixedLayout({
+		...graph,
+		nodes
+	}, { direction: options.direction ?? graph.direction });
+}
+/** Compact an existing layout while preserving its relative directions. */
+function getSporeCompactionLayout(graph, options = {}) {
+	return getSporeLayout(graph, options, true);
+}
+/** Remove overlap while preserving existing distances that already fit. */
+function getSporeOverlapRemovalLayout(graph, options = {}) {
+	return getSporeLayout(graph, options, false);
+}
+function algorithm(id, compact) {
+	return {
+		id,
+		capabilities: {
+			full: true,
+			incremental: false,
+			partial: false,
+			routeOnly: false,
+			hierarchy: false,
+			ports: true
+		},
+		layout(graph, options) {
+			return getSporeLayout(graph, options ?? {}, compact);
+		}
+	};
+}
+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 };

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@statelyai/layout",
+  "version": "0.0.0",
+  "description": "Extensible, graph-native layout algorithms for @statelyai/graph",
+  "license": "EPL-2.0 OR GPL-3.0-or-later",
+  "files": [
+    "dist",
+    "LICENSE.md",
+    "NOTICE.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./elkjs": "./dist/elkjs/index.mjs",
+    "./layered": "./dist/layered/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "bench": "vitest bench --run",
+    "demo": "vite --config demo/vite.config.ts",
+    "demo:build": "vite build --config demo/vite.config.ts",
+    "demo:check": "tsx scripts/generate-demo-corpus.ts --check",
+    "demo:generate": "tsx scripts/generate-demo-corpus.ts",
+    "demo:typecheck": "tsc --project demo/tsconfig.json",
+    "dev": "tsdown --watch",
+    "format": "oxfmt .",
+    "format:check": "oxfmt --check .",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "typecheck:repo": "tsc --project tsconfig.repo.json",
+    "verify": "oxfmt --check . && oxlint && tsc --noEmit && tsc --project tsconfig.repo.json && tsc --project demo/tsconfig.json && tsx scripts/generate-demo-corpus.ts --check && vitest --run && tsdown && vite build --config demo/vite.config.ts && publint --pack npm && tsx scripts/smoke-package.ts",
+    "validate:package": "publint --pack npm && tsx scripts/smoke-package.ts"
+  },
+  "dependencies": {
+    "@statelyai/graph": "^2.1.0"
+  },
+  "devDependencies": {
+    "@statelyai/sdk": "^0.20.1",
+    "@types/node": "^25.0.3",
+    "elkjs": "^0.11.1",
+    "oxfmt": "0.62.0",
+    "oxlint": "1.77.0",
+    "publint": "^0.3.15",
+    "tsdown": "^0.18.1",
+    "tsx": "^4.22.4",
+    "typescript": "^5.9.3",
+    "vite": "^8.2.1",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "@statelyai/graph": "^2.1.0"
+  },
+  "packageManager": "pnpm@10.28.2"
+}