@statelyai/layout 0.0.0

package/dist/elkjs/index.mjs

@@ -0,0 +1,412 @@
+import { t as getLayeredLayout } from "../layered-ByNCZQgJ.mjs";
+import { a as getRandomLayout, f as getFixedLayout, n as getSporeOverlapRemovalLayout, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "../spore-cihb_Aht.mjs";
+import { createGraph } from "@statelyai/graph";
+
+//#region src/elkjs/index.ts
+var ELK = class {
+	#options;
+	#algorithmIds;
+	constructor(options = {}) {
+		this.#options = options;
+		this.#algorithmIds = new Set([
+			"box",
+			"fixed",
+			"random",
+			"rectpacking",
+			"sporeCompaction",
+			"sporeOverlap",
+			...(options.algorithms ?? ["layered"]).filter((id) => id === "layered")
+		]);
+	}
+	async knownLayoutAlgorithms() {
+		return [...this.#algorithmIds].map((id) => ({
+			id,
+			name: {
+				layered: "Layered",
+				box: "Box",
+				fixed: "Fixed",
+				random: "Random",
+				rectpacking: "Rectangle Packing",
+				sporeCompaction: "SPOrE Compaction",
+				sporeOverlap: "SPOrE Overlap Removal"
+			}[id],
+			category: id === "layered" ? "layered" : "other",
+			knownOptions: id === "layered" ? [
+				"elk.direction",
+				"elk.padding",
+				"elk.spacing.nodeNode",
+				"elk.layered.spacing.nodeNodeBetweenLayers"
+			] : id === "box" ? [
+				"padding",
+				"spacing.nodeNode",
+				"aspectRatio",
+				"box.packingMode"
+			] : id === "random" ? [
+				"padding",
+				"spacing.nodeNode",
+				"aspectRatio",
+				"randomSeed"
+			] : ["position", "bendPoints"]
+		}));
+	}
+	async knownLayoutOptions() {
+		return [
+			{
+				id: "elk.algorithm",
+				name: "Layout Algorithm",
+				type: "STRING"
+			},
+			{
+				id: "elk.direction",
+				name: "Direction",
+				type: "ENUM"
+			},
+			{
+				id: "elk.padding",
+				name: "Padding",
+				type: "OBJECT"
+			},
+			{
+				id: "elk.aspectRatio",
+				name: "Aspect Ratio",
+				type: "DOUBLE"
+			},
+			{
+				id: "elk.randomSeed",
+				name: "Random Seed",
+				type: "INT"
+			},
+			{
+				id: "elk.spacing.nodeNode",
+				name: "Node Spacing",
+				type: "DOUBLE"
+			},
+			{
+				id: "elk.layered.spacing.nodeNodeBetweenLayers",
+				name: "Layer Spacing",
+				type: "DOUBLE"
+			}
+		];
+	}
+	async knownLayoutCategories() {
+		return [{
+			id: "layered",
+			name: "Layered",
+			knownLayouters: this.#algorithmIds.has("layered") ? ["layered"] : []
+		}, {
+			id: "other",
+			name: "Other",
+			knownLayouters: [
+				"box",
+				"fixed",
+				"random"
+			]
+		}];
+	}
+	terminateWorker() {}
+	async layout(graph, arguments_ = {}) {
+		const startedAt = performance.now();
+		if (graph === void 0 || graph === null) throw new TypeError("Missing mandatory parameter: graph");
+		if (typeof graph.id !== "string" && !(typeof graph.id === "number" && Number.isInteger(graph.id))) throw new TypeError("Graph id must be a string or integer");
+		delete graph.logging;
+		const layoutOptions = {
+			...this.#options.defaultLayoutOptions,
+			...arguments_.layoutOptions,
+			...graph.properties,
+			...graph.layoutOptions
+		};
+		const requestedAlgorithm = String(getOption(layoutOptions, "algorithm") ?? "layered");
+		const algorithm = requestedAlgorithm.replace(/^(?:org\.eclipse\.)?elk\./, "");
+		if (algorithm !== "layered" && algorithm !== "box" && algorithm !== "fixed" && algorithm !== "random" && algorithm !== "rectpacking" && algorithm !== "sporeCompaction" && algorithm !== "sporeOverlap") throw new Error(`org.eclipse.elk.core.UnsupportedConfigurationException: Layout algorithm '${requestedAlgorithm}' not found`);
+		const hasHierarchy = (graph.children ?? []).some((child) => (child.children?.length ?? 0) > 0);
+		const hierarchyHandling = getOption(layoutOptions, "hierarchyHandling");
+		if (hasHierarchy && hierarchyHandling !== void 0 && hierarchyHandling !== "INCLUDE_CHILDREN") throw new Error("org.eclipse.elk.core.UnsupportedGraphException: Hierarchical edges require INCLUDE_CHILDREN");
+		if (hasHierarchy) for (const child of graph.children ?? []) {
+			if ((child.children?.length ?? 0) === 0) continue;
+			await this.layout(child, {
+				...arguments_,
+				layoutOptions: {
+					...arguments_.layoutOptions,
+					hierarchyHandling: "INCLUDE_CHILDREN"
+				},
+				logging: false,
+				measureExecutionTime: false
+			});
+		}
+		const graph_ = toGraph(graph);
+		const padding = parsePadding(getOption(layoutOptions, "padding"));
+		const constrainedLayerByNodeId = new Map((graph.children ?? []).flatMap((node) => getOption(node.layoutOptions ?? {}, "layerConstraint") === "FIRST" ? [[String(node.id), 0]] : []));
+		if (algorithm === "layered" && graph_.edges.some((edge) => {
+			const sourceLayer = constrainedLayerByNodeId.get(edge.sourceId);
+			const targetLayer = constrainedLayerByNodeId.get(edge.targetId);
+			return sourceLayer !== void 0 && targetLayer !== void 0 && targetLayer <= sourceLayer;
+		})) throw new Error("org.eclipse.elk.core.UnsupportedConfigurationException: Layer constraints conflict");
+		applyLayout(graph, algorithm === "sporeCompaction" ? getSporeCompactionLayout(graph_, {
+			padding,
+			spacing: getNumberOption(layoutOptions, "spacing.nodeNode")
+		}) : algorithm === "sporeOverlap" ? getSporeOverlapRemovalLayout(graph_, {
+			padding,
+			spacing: getNumberOption(layoutOptions, "spacing.nodeNode")
+		}) : algorithm === "rectpacking" ? getRectanglePackingLayout(graph_, {
+			padding,
+			spacing: getNumberOption(layoutOptions, "spacing.nodeNode")
+		}) : algorithm === "random" ? getRandomLayout(graph_, {
+			padding: getOption(layoutOptions, "padding") === void 0 ? 15 : padding,
+			spacing: getNumberOption(layoutOptions, "spacing.nodeNode"),
+			aspectRatio: getNumberOption(layoutOptions, "aspectRatio"),
+			seed: getNumberOption(layoutOptions, "randomSeed")
+		}) : algorithm === "box" ? getBoxLayout(graph_, {
+			padding: getOption(layoutOptions, "padding") === void 0 ? 15 : padding,
+			spacing: getNumberOption(layoutOptions, "spacing.nodeNode"),
+			aspectRatio: getNumberOption(layoutOptions, "aspectRatio"),
+			interactive: getBooleanOption(layoutOptions, "interactive"),
+			expandNodes: getBooleanOption(layoutOptions, "expandNodes"),
+			priority: (node) => {
+				const child = graph.children?.find((candidate) => String(candidate.id) === node.id);
+				return getNumberOption(child?.layoutOptions ?? {}, "priority");
+			}
+		}) : algorithm === "fixed" ? getFixedLayout(graph_, { direction: getDirection(layoutOptions) }) : getLayeredLayout(graph_, {
+			direction: getDirection(layoutOptions),
+			spacing: {
+				node: getNumberOption(layoutOptions, "spacing.nodeNode"),
+				layer: getNumberOption(layoutOptions, "layered.spacing.nodeNodeBetweenLayers")
+			},
+			padding,
+			constraints: { layer: (node) => constrainedLayerByNodeId.get(node.id) }
+		}), padding, layoutOptions);
+		if (arguments_.logging || arguments_.measureExecutionTime) graph.logging = {
+			name: "Native TypeScript layout",
+			children: [{ name: String(algorithm) }],
+			...arguments_.measureExecutionTime ? { executionTime: (performance.now() - startedAt) / 1e3 } : {}
+		};
+		return graph;
+	}
+};
+function parsePadding(value) {
+	if (typeof value === "number") return {
+		top: value,
+		right: value,
+		bottom: value,
+		left: value
+	};
+	if (typeof value !== "string") return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	};
+	const padding = {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	};
+	for (const match of value.matchAll(/(top|right|bottom|left)\s*=\s*(-?\d+(?:\.\d+)?)/g)) {
+		const side = match[1];
+		padding[side] = Number(match[2]);
+	}
+	return padding;
+}
+function getOption(options, suffix) {
+	const exactKeys = [
+		suffix,
+		`elk.${suffix}`,
+		`org.eclipse.elk.${suffix}`
+	];
+	for (const key of exactKeys) if (options[key] !== void 0) return options[key];
+	return Object.entries(options).find(([key]) => key.endsWith(`.${suffix}`))?.[1];
+}
+function getNumberOption(options, suffix) {
+	const value = getOption(options, suffix);
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+}
+function getBooleanOption(options, suffix) {
+	const value = getOption(options, suffix);
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		if (value.toLowerCase() === "true") return true;
+		if (value.toLowerCase() === "false") return false;
+	}
+}
+function getDirection(options) {
+	const direction = String(getOption(options, "direction") ?? "DOWN").toLowerCase();
+	return direction === "up" || direction === "left" || direction === "right" ? direction : "down";
+}
+function endpoint(value, portOwnerById) {
+	const id = String(value);
+	const ownerId = portOwnerById.get(id);
+	return ownerId === void 0 ? { nodeId: id } : {
+		nodeId: ownerId,
+		port: id
+	};
+}
+function toGraph(root) {
+	const children = root.children ?? [];
+	const nodeIds = new Set(children.map((child) => String(child.id)));
+	const portOwnerById = /* @__PURE__ */ new Map();
+	for (const child of children) for (const port of child.ports ?? []) if (port.id !== void 0) portOwnerById.set(String(port.id), String(child.id));
+	return createGraph({
+		id: String(root.id),
+		nodes: children.map((child) => ({
+			id: String(child.id),
+			x: child.x,
+			y: child.y,
+			...parsePosition(getOption(child.layoutOptions ?? {}, "position")),
+			width: child.width,
+			height: child.height,
+			label: child.labels?.[0]?.text,
+			ports: child.ports?.map((port) => ({
+				name: String(port.id),
+				direction: "inout",
+				x: port.x,
+				y: port.y,
+				width: port.width,
+				height: port.height
+			}))
+		})),
+		edges: (root.edges ?? []).flatMap((edge) => {
+			const source = endpoint(edge.sources?.[0] ?? edge.source, portOwnerById);
+			const target = endpoint(edge.targets?.[0] ?? edge.target, portOwnerById);
+			return nodeIds.has(source.nodeId) && nodeIds.has(target.nodeId) ? [{
+				id: String(edge.id),
+				sourceId: source.nodeId,
+				targetId: target.nodeId,
+				sourcePort: source.port,
+				targetPort: target.port,
+				label: edge.labels?.[0]?.text,
+				width: edge.labels?.[0]?.width,
+				height: edge.labels?.[0]?.height,
+				points: parsePoints(getOption(edge.layoutOptions ?? {}, "bendPoints"))
+			}] : [];
+		})
+	});
+}
+function parsePoints(value) {
+	if (typeof value !== "string") return void 0;
+	const points = [...value.matchAll(/\{\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\}/g)].map((match) => ({
+		x: Number(match[1]),
+		y: Number(match[2])
+	}));
+	return points.length > 0 ? points : void 0;
+}
+function parsePosition(value) {
+	if (typeof value !== "string") return void 0;
+	const match = value.match(/\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)/);
+	return match ? {
+		x: Number(match[1]),
+		y: Number(match[2])
+	} : void 0;
+}
+function toSection(edge, points) {
+	const startPoint = points[0];
+	const endPoint = points.at(-1);
+	if (!startPoint || !endPoint) return void 0;
+	return {
+		id: `${String(edge.id)}_s0`,
+		startPoint: { ...startPoint },
+		endPoint: { ...endPoint },
+		...points.length > 2 ? { bendPoints: points.slice(1, -1).map((point) => ({ ...point })) } : {}
+	};
+}
+function applyLayout(root, graph, padding, layoutOptions) {
+	const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+	const edgeById = new Map(graph.edges.map((edge) => [edge.id, edge]));
+	for (const child of root.children ?? []) {
+		const node = nodeById.get(String(child.id));
+		if (!node) continue;
+		child.x = node.x;
+		child.y = node.y;
+		child.width = node.width;
+		child.height = node.height;
+		placeNodeLabels(child, layoutOptions);
+		for (const port of child.ports ?? []) {
+			const laidOutPort = node.ports?.find((candidate) => candidate.name === String(port.id));
+			if (!laidOutPort) continue;
+			port.x = laidOutPort.x;
+			port.y = laidOutPort.y;
+			port.width = laidOutPort.width;
+			port.height = laidOutPort.height;
+		}
+	}
+	for (const edge of root.edges ?? []) {
+		const laidOutEdge = edgeById.get(String(edge.id));
+		if (!laidOutEdge) {
+			const section$1 = getParentEdgeSection(root, edge);
+			if (section$1) edge.sections = [section$1];
+			continue;
+		}
+		const section = toSection(edge, laidOutEdge.points ?? []);
+		edge.sections = section ? [section] : [];
+		const label = edge.labels?.[0];
+		if (label) {
+			label.x = laidOutEdge.x;
+			label.y = laidOutEdge.y;
+			label.width = laidOutEdge.width;
+			label.height = laidOutEdge.height;
+		}
+	}
+	root.width = Math.max(0, ...graph.nodes.map((node) => node.x + node.width)) + padding.right;
+	root.height = Math.max(0, ...graph.nodes.map((node) => node.y + node.height)) + padding.bottom;
+}
+function getParentEdgeSection(root, edge) {
+	const sourceId = String(edge.sources?.[0] ?? edge.source);
+	const targetId = String(edge.targets?.[0] ?? edge.target);
+	const rootId = String(root.id);
+	const source = root.children?.find((child) => String(child.id) === sourceId);
+	const target = root.children?.find((child) => String(child.id) === targetId);
+	if (source && targetId === rootId) {
+		const startPoint = {
+			x: (source.x ?? 0) + (source.width ?? 0) / 2,
+			y: (source.y ?? 0) + (source.height ?? 0)
+		};
+		return {
+			id: `${String(edge.id)}_s0`,
+			startPoint,
+			endPoint: {
+				x: startPoint.x,
+				y: 0
+			}
+		};
+	}
+	if (sourceId === rootId && target) {
+		const endPoint = {
+			x: (target.x ?? 0) + (target.width ?? 0) / 2,
+			y: target.y ?? 0
+		};
+		return {
+			id: `${String(edge.id)}_s0`,
+			startPoint: {
+				x: endPoint.x,
+				y: 0
+			},
+			endPoint
+		};
+	}
+}
+function placeNodeLabels(node, globalOptions) {
+	for (const label of node.labels ?? []) {
+		const placement = String(getOption({
+			...globalOptions,
+			...node.layoutOptions,
+			...label.layoutOptions
+		}, "nodeLabels.placement") ?? "");
+		if (!placement) continue;
+		const width = label.width ?? 0;
+		const height = label.height ?? 0;
+		const nodeWidth = node.width ?? 0;
+		const nodeHeight = node.height ?? 0;
+		label.x = placement.includes("H_CENTER") ? (nodeWidth - width) / 2 : placement.includes("H_RIGHT") ? nodeWidth - width : 0;
+		if (placement.includes("OUTSIDE") && placement.includes("V_TOP")) label.y = -height - 5;
+		else if (placement.includes("OUTSIDE") && placement.includes("V_BOTTOM")) label.y = nodeHeight + 5;
+		else if (placement.includes("V_CENTER")) label.y = (nodeHeight - height) / 2;
+		else if (placement.includes("V_BOTTOM")) label.y = nodeHeight - height;
+		else label.y = 0;
+	}
+}
+
+//#endregion
+export { ELK as default };

package/dist/index-v0P1Ake8.d.mts

@@ -0,0 +1,149 @@
+import { LayoutConstraints } from "@statelyai/graph/layout";
+import { EntityRect, Graph, GraphNode, GraphPatch, Point, VisualGraph } from "@statelyai/graph";
+
+//#region src/types.d.ts
+type AnyGraph = Graph<unknown, unknown, unknown, unknown>;
+type LayoutDirection = "up" | "down" | "left" | "right";
+type LayoutScope = {
+  mode: "full";
+} | {
+  mode: "incremental";
+  previous: VisualGraph;
+} | {
+  mode: "partial";
+  previous: VisualGraph;
+  nodeIds: readonly string[];
+} | {
+  mode: "route-only";
+  previous: VisualGraph;
+  edgeIds?: readonly string[];
+};
+interface LayoutDiagnostic {
+  severity: "info" | "warning" | "error";
+  code: string;
+  message: string;
+  entityIds?: readonly string[];
+  phase?: string;
+}
+interface LayoutPhaseMetrics {
+  id: string;
+  durationMs: number;
+}
+interface LayoutMetrics {
+  durationMs: number;
+  nodeCount: number;
+  edgeCount: number;
+  phases: readonly LayoutPhaseMetrics[];
+}
+interface LayoutCapabilities {
+  full: boolean;
+  incremental: boolean;
+  partial: boolean;
+  routeOnly: boolean;
+  hierarchy: boolean;
+  ports: boolean;
+}
+interface LayoutAlgorithm<Options = unknown> {
+  readonly id: string;
+  readonly capabilities: LayoutCapabilities;
+  layout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options: Options, context: LayoutExecutionContext): VisualGraph<N, E, G, P> | Promise<VisualGraph<N, E, G, P>>;
+}
+interface LayoutExecutionContext {
+  readonly scope: LayoutScope;
+  readonly signal?: AbortSignal;
+  readonly diagnostics: LayoutDiagnostic[];
+  measurePhase<T>(id: string, run: () => T): T;
+  throwIfAborted(): void;
+}
+interface LayoutRequest<N = unknown, E = unknown, G = unknown, P = unknown, O = unknown> {
+  graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>;
+  algorithm?: string | LayoutAlgorithm<O>;
+  options?: O;
+  scope?: LayoutScope;
+  signal?: AbortSignal;
+}
+interface LayoutResult<N = unknown, E = unknown, G = unknown, P = unknown> {
+  graph: VisualGraph<N, E, G, P>;
+  patches: readonly GraphPatch<N, E>[];
+  diagnostics: readonly LayoutDiagnostic[];
+  metrics: LayoutMetrics;
+}
+//#endregion
+//#region src/layered/types.d.ts
+interface NodeSize {
+  width: number;
+  height: number;
+}
+interface LayeredSpacing {
+  node: number;
+  layer: number;
+}
+interface LayoutPadding {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+interface LayeredPhaseInput {
+  graph: Graph<unknown, unknown, unknown, unknown>;
+  sizes: ReadonlyMap<string, NodeSize>;
+  direction: LayoutDirection;
+  spacing: LayeredSpacing;
+  padding: LayoutPadding;
+  constrainedLayerByNodeId: ReadonlyMap<string, number>;
+}
+interface AcyclicOrientation {
+  reversedEdgeIds: ReadonlySet<string>;
+}
+interface LayerAssignment {
+  layerByNodeId: ReadonlyMap<string, number>;
+}
+interface LayerOrder {
+  layers: readonly (readonly string[])[];
+}
+interface NodePlacement {
+  rectByNodeId: ReadonlyMap<string, EntityRect>;
+}
+interface EdgeRoutes {
+  pointsByEdgeId: ReadonlyMap<string, readonly Point[]>;
+}
+type CycleBreaker = (input: LayeredPhaseInput) => AcyclicOrientation;
+type LayerAssigner = (input: LayeredPhaseInput, orientation: AcyclicOrientation) => LayerAssignment;
+type CrossingMinimizer = (input: LayeredPhaseInput, orientation: AcyclicOrientation, assignment: LayerAssignment) => LayerOrder;
+type NodePlacer = (input: LayeredPhaseInput, order: LayerOrder) => NodePlacement;
+type EdgeRouter = (input: LayeredPhaseInput, orientation: AcyclicOrientation, placement: NodePlacement) => EdgeRoutes;
+interface LayeredStrategies {
+  breakCycles?: CycleBreaker;
+  assignLayers?: LayerAssigner;
+  minimizeCrossings?: CrossingMinimizer;
+  placeNodes?: NodePlacer;
+  routeEdges?: EdgeRouter;
+}
+interface LayeredLayoutOptions {
+  direction?: LayoutDirection;
+  spacing?: Partial<LayeredSpacing>;
+  padding?: number | Partial<LayoutPadding>;
+  constraints?: LayoutConstraints;
+  measure?: (node: GraphNode) => NodeSize;
+  crossingSweeps?: number;
+  strategies?: LayeredStrategies;
+}
+//#endregion
+//#region src/layered/strategies.d.ts
+declare const breakCyclesWithDepthFirstSearch: CycleBreaker;
+declare const assignLayersByLongestPath: LayerAssigner;
+declare function minimizeCrossingsWithBarycenter(sweeps?: number): CrossingMinimizer;
+declare const placeNodesInLayers: NodePlacer;
+declare const routeEdgesOrthogonally: EdgeRouter;
+//#endregion
+//#region src/layered/index.d.ts
+/**
+ * Deterministic native layered layout for an `@statelyai/graph` graph.
+ *
+ * This initial vertical slice supports flat graphs, cycles, ports, self-loops,
+ * four directions, custom phase strategies, and orthogonal routes.
+ */
+declare function getLayeredLayout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options?: LayeredLayoutOptions): VisualGraph<N, E, G, P>;
+declare const layeredAlgorithm: LayoutAlgorithm<LayeredLayoutOptions>;
+//#endregion
+export { LayoutMetrics as A, NodeSize as C, LayoutDiagnostic as D, LayoutCapabilities as E, LayoutRequest as M, LayoutResult as N, LayoutDirection as O, LayoutScope as P, NodePlacer as S, LayoutAlgorithm as T, LayeredPhaseInput as _, minimizeCrossingsWithBarycenter as a, LayoutPadding as b, AcyclicOrientation as c, EdgeRouter as d, EdgeRoutes as f, LayeredLayoutOptions as g, LayerOrder as h, breakCyclesWithDepthFirstSearch as i, LayoutPhaseMetrics as j, LayoutExecutionContext as k, CrossingMinimizer as l, LayerAssignment as m, layeredAlgorithm as n, placeNodesInLayers as o, LayerAssigner as p, assignLayersByLongestPath as r, routeEdgesOrthogonally as s, getLayeredLayout as t, CycleBreaker as u, LayeredSpacing as v, AnyGraph as w, NodePlacement as x, LayeredStrategies as y };

package/dist/index.d.mts

@@ -0,0 +1,77 @@
+import { A as LayoutMetrics, C as NodeSize, D as LayoutDiagnostic, E as LayoutCapabilities, M as LayoutRequest, N as LayoutResult, O as LayoutDirection, P as LayoutScope, S as NodePlacer, T as LayoutAlgorithm, _ as LayeredPhaseInput, a as minimizeCrossingsWithBarycenter, b as LayoutPadding, c as AcyclicOrientation, d as EdgeRouter, f as EdgeRoutes, g as LayeredLayoutOptions, h as LayerOrder, i as breakCyclesWithDepthFirstSearch, j as LayoutPhaseMetrics, k as LayoutExecutionContext, l as CrossingMinimizer, m as LayerAssignment, n as layeredAlgorithm, o as placeNodesInLayers, p as LayerAssigner, r as assignLayersByLongestPath, s as routeEdgesOrthogonally, t as getLayeredLayout, u as CycleBreaker, v as LayeredSpacing, w as AnyGraph, x as NodePlacement, y as LayeredStrategies } from "./index-v0P1Ake8.mjs";
+import { LayoutOptions } from "@statelyai/graph/layout";
+import { Graph, GraphNode, VisualGraph } from "@statelyai/graph";
+
+//#region src/errors.d.ts
+declare class LayoutError extends Error {
+  readonly code: string;
+  constructor(message: string, code: string);
+}
+declare class UnsupportedLayoutError extends LayoutError {
+  constructor(message: string);
+}
+//#endregion
+//#region src/box.d.ts
+
+interface BoxLayoutOptions extends Pick<LayoutOptions, "direction" | "measure"> {
+  spacing?: number;
+  padding?: number | Partial<LayoutPadding>;
+  aspectRatio?: number;
+  interactive?: boolean;
+  expandNodes?: boolean;
+  priority?: (node: GraphNode) => number | undefined;
+}
+/** ELK Box SIMPLE packing translated onto `@statelyai/graph`. */
+declare function getBoxLayout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options?: BoxLayoutOptions): VisualGraph<N, E, G, P>;
+declare const boxAlgorithm: LayoutAlgorithm<BoxLayoutOptions>;
+//#endregion
+//#region src/fixed.d.ts
+interface FixedLayoutOptions extends Pick<LayoutOptions, "direction" | "measure"> {}
+/** Preserve authored positions and routes while completing visual geometry. */
+declare function getFixedLayout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options?: FixedLayoutOptions): VisualGraph<N, E, G, P>;
+declare const fixedAlgorithm: LayoutAlgorithm<FixedLayoutOptions>;
+//#endregion
+//#region src/packing.d.ts
+interface RectanglePackingLayoutOptions extends Pick<LayoutOptions, "direction" | "measure"> {
+  spacing?: number;
+  padding?: number | Partial<LayoutPadding>;
+  targetWidth?: number;
+}
+/** Deterministic shelf-based rectangle packing for `@statelyai/graph`. */
+declare function getRectanglePackingLayout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options?: RectanglePackingLayoutOptions): VisualGraph<N, E, G, P>;
+declare const rectanglePackingAlgorithm: LayoutAlgorithm<RectanglePackingLayoutOptions>;
+//#endregion
+//#region src/random.d.ts
+interface RandomLayoutOptions extends Pick<LayoutOptions, "direction" | "measure"> {
+  spacing?: number;
+  padding?: number | Partial<LayoutPadding>;
+  aspectRatio?: number;
+  seed?: number;
+}
+/** Seeded random distribution using Java's 48-bit `Random` sequence. */
+declare function getRandomLayout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options?: RandomLayoutOptions): VisualGraph<N, E, G, P>;
+declare const randomAlgorithm: LayoutAlgorithm<RandomLayoutOptions>;
+//#endregion
+//#region src/spore.d.ts
+interface SporeLayoutOptions extends Pick<LayoutOptions, "direction" | "measure"> {
+  spacing?: number;
+  padding?: number | Partial<LayoutPadding>;
+}
+/** Compact an existing layout while preserving its relative directions. */
+declare function getSporeCompactionLayout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options?: SporeLayoutOptions): VisualGraph<N, E, G, P>;
+/** Remove overlap while preserving existing distances that already fit. */
+declare function getSporeOverlapRemovalLayout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options?: SporeLayoutOptions): VisualGraph<N, E, G, P>;
+declare const sporeCompactionAlgorithm: LayoutAlgorithm<SporeLayoutOptions>;
+declare const sporeOverlapRemovalAlgorithm: LayoutAlgorithm<SporeLayoutOptions>;
+//#endregion
+//#region src/layout.d.ts
+/** Register or replace a layout algorithm for subsequent `getLayout` calls. */
+declare function registerLayoutAlgorithm<O>(algorithm: LayoutAlgorithm<O>): () => void;
+declare function getLayoutAlgorithm(id: string): LayoutAlgorithm<unknown> | undefined;
+/**
+ * Run a registered or inline algorithm against an `@statelyai/graph` graph.
+ * The input is not mutated.
+ */
+declare function getLayout<N, E, G, P, O = unknown>(request: LayoutRequest<N, E, G, P, O>): Promise<LayoutResult<N, E, G, P>>;
+//#endregion
+export { type AcyclicOrientation, type AnyGraph, type BoxLayoutOptions, type CrossingMinimizer, type CycleBreaker, type EdgeRouter, type EdgeRoutes, type FixedLayoutOptions, type LayerAssigner, type LayerAssignment, type LayerOrder, type LayeredLayoutOptions, type LayeredPhaseInput, type LayeredSpacing, type LayeredStrategies, type LayoutAlgorithm, type LayoutCapabilities, type LayoutDiagnostic, type LayoutDirection, LayoutError, type LayoutExecutionContext, type LayoutMetrics, type LayoutPadding, type LayoutPhaseMetrics, type LayoutRequest, type LayoutResult, type LayoutScope, type NodePlacement, type NodePlacer, type NodeSize, type RandomLayoutOptions, type RectanglePackingLayoutOptions, type SporeLayoutOptions, UnsupportedLayoutError, assignLayersByLongestPath, boxAlgorithm, breakCyclesWithDepthFirstSearch, fixedAlgorithm, getBoxLayout, getFixedLayout, getLayeredLayout, getLayout, getLayoutAlgorithm, getRandomLayout, getRectanglePackingLayout, getSporeCompactionLayout, getSporeOverlapRemovalLayout, layeredAlgorithm, minimizeCrossingsWithBarycenter, placeNodesInLayers, randomAlgorithm, rectanglePackingAlgorithm, registerLayoutAlgorithm, routeEdgesOrthogonally, sporeCompactionAlgorithm, sporeOverlapRemovalAlgorithm };