@statelyai/graph 0.13.0 → 2.0.0

package/dist/formats/graphml/index.mjs

@@ -1,4 +1,5 @@
-import { n as createFormatConverter } from "../../converter-Dspillnn.mjs";
+import { t as getEdgeMode } from "../../mode-D8OnHFBk.mjs";
+import { n as createFormatConverter } from "../../converter-DyCJJfTe.mjs";
 import { XMLBuilder, XMLParser } from "fast-xml-parser";
 
 //#region src/formats/graphml/index.ts
@@ -175,7 +176,9 @@ function toGraphML(graph) {
 			...data.length > 0 && { data }
 		};
 	});
+	const graphDirected = graph.mode !== "undirected";
 	const edges = graph.edges.map((edge) => {
+		const edgeDirected = getEdgeMode(graph, edge) !== "undirected";
 		const data = [];
 		if (edge.label) data.push({
 			"@_key": "label",
@@ -225,6 +228,7 @@ function toGraphML(graph) {
 			"@_id": edge.id,
 			"@_source": edge.sourceId,
 			"@_target": edge.targetId,
+			...edgeDirected !== graphDirected && { "@_directed": edgeDirected ? "true" : "false" },
 			...data.length > 0 && { data }
 		};
 	});
@@ -255,7 +259,7 @@ function toGraphML(graph) {
 			key: keys,
 			graph: {
 				"@_id": graph.id,
-				"@_edgedefault": graph.type === "directed" ? "directed" : "undirected",
+				"@_edgedefault": graph.mode === "undirected" ? "undirected" : "directed",
 				...graphData.length > 0 && { data: graphData },
 				node: nodes,
 				edge: edges
@@ -265,7 +269,8 @@ function toGraphML(graph) {
 	return new XMLBuilder({
 		ignoreAttributes: false,
 		format: true,
-		suppressEmptyNode: true
+		suppressEmptyNode: true,
+		suppressBooleanAttributes: false
 	}).build(obj);
 }
 function fromGraphML(xml) {
@@ -276,8 +281,12 @@ function fromGraphML(xml) {
 			"node",
 			"edge",
 			"data",
-			"key"
-		].includes(name)
+			"key",
+			"graph",
+			"port"
+		].includes(name),
+		parseTagValue: false,
+		trimValues: false
 	});
 	let parsed;
 	try {
@@ -287,55 +296,84 @@ function fromGraphML(xml) {
 	}
 	const graphml = parsed?.graphml;
 	if (!graphml) throw new Error("GraphML: missing <graphml> root element");
-	const graphEl = graphml.graph;
+	const graphEl = asArray(graphml.graph)[0];
 	if (!graphEl) throw new Error("GraphML: missing <graph> element");
 	const graphType = graphEl["@_edgedefault"] === "undirected" ? "undirected" : "directed";
 	const graphDataMap = parseDataElements(graphEl.data);
 	const graphData = graphDataMap.graphData !== void 0 ? tryParseJSON(graphDataMap.graphData) : void 0;
-	const nodes = asArray(graphEl.node).map((nodeEl) => {
+	const nodeEntries = [];
+	const edgeEls = [];
+	function collectGraphContents(gEl, parentId) {
+		for (const nodeEl of asArray(gEl.node)) {
+			nodeEntries.push({
+				el: nodeEl,
+				structuralParentId: parentId
+			});
+			for (const subgraphEl of asArray(nodeEl.graph)) collectGraphContents(subgraphEl, String(nodeEl["@_id"]));
+		}
+		edgeEls.push(...asArray(gEl.edge));
+	}
+	collectGraphContents(graphEl, null);
+	const nodes = nodeEntries.map(({ el: nodeEl, structuralParentId }) => {
 		const dataMap = parseDataElements(nodeEl.data);
+		const id = String(nodeEl["@_id"]);
 		const node = {
 			type: "node",
-			id: String(nodeEl["@_id"]),
-			parentId: dataMap.parentId ?? null,
+			id,
+			parentId: dataMap.parentId ?? structuralParentId,
 			initialNodeId: dataMap.initialNodeId ?? null,
 			label: dataMap.label ?? "",
 			data: dataMap.data !== void 0 ? tryParseJSON(dataMap.data) : void 0
 		};
-		if (dataMap.x !== void 0) node.x = parseNumber(dataMap.x);
-		if (dataMap.y !== void 0) node.y = parseNumber(dataMap.y);
-		if (dataMap.width !== void 0) node.width = parseNumber(dataMap.width);
-		if (dataMap.height !== void 0) node.height = parseNumber(dataMap.height);
+		if (dataMap.x !== void 0) node.x = parseNumber(dataMap.x, "x", "node", id);
+		if (dataMap.y !== void 0) node.y = parseNumber(dataMap.y, "y", "node", id);
+		if (dataMap.width !== void 0) node.width = parseNumber(dataMap.width, "width", "node", id);
+		if (dataMap.height !== void 0) node.height = parseNumber(dataMap.height, "height", "node", id);
 		if (dataMap.shape !== void 0) node.shape = dataMap.shape;
 		if (dataMap.color !== void 0) node.color = dataMap.color;
 		if (dataMap.style !== void 0) node.style = tryParseJSON(dataMap.style);
 		if (dataMap.ports !== void 0) node.ports = tryParseJSON(dataMap.ports);
+		else if (nodeEl.port !== void 0) node.ports = collectPorts(nodeEl.port);
 		return node;
 	});
-	const edges = asArray(graphEl.edge).map((edgeEl) => {
+	const usedEdgeIds = new Set(edgeEls.filter((edgeEl) => edgeEl["@_id"] != null).map((edgeEl) => String(edgeEl["@_id"])));
+	const edges = edgeEls.map((edgeEl, i) => {
 		const dataMap = parseDataElements(edgeEl.data);
+		const source = String(edgeEl["@_source"]);
+		const target = String(edgeEl["@_target"]);
+		let id;
+		if (edgeEl["@_id"] != null) id = String(edgeEl["@_id"]);
+		else {
+			id = `${source}-${target}-${i}`;
+			for (let suffix = 0; usedEdgeIds.has(id); suffix++) id = `${source}-${target}-${i}#e${suffix}`;
+			usedEdgeIds.add(id);
+		}
 		const edge = {
 			type: "edge",
-			id: String(edgeEl["@_id"]),
-			sourceId: String(edgeEl["@_source"]),
-			targetId: String(edgeEl["@_target"]),
+			id,
+			sourceId: source,
+			targetId: target,
 			label: dataMap.label ?? "",
 			data: dataMap.data !== void 0 ? tryParseJSON(dataMap.data) : void 0
 		};
-		if (dataMap.weight !== void 0) edge.weight = parseNumber(dataMap.weight);
-		if (dataMap.x !== void 0) edge.x = parseNumber(dataMap.x);
-		if (dataMap.y !== void 0) edge.y = parseNumber(dataMap.y);
-		if (dataMap.width !== void 0) edge.width = parseNumber(dataMap.width);
-		if (dataMap.height !== void 0) edge.height = parseNumber(dataMap.height);
+		if (dataMap.weight !== void 0) edge.weight = parseNumber(dataMap.weight, "weight", "edge", id);
+		if (dataMap.x !== void 0) edge.x = parseNumber(dataMap.x, "x", "edge", id);
+		if (dataMap.y !== void 0) edge.y = parseNumber(dataMap.y, "y", "edge", id);
+		if (dataMap.width !== void 0) edge.width = parseNumber(dataMap.width, "width", "edge", id);
+		if (dataMap.height !== void 0) edge.height = parseNumber(dataMap.height, "height", "edge", id);
 		if (dataMap.color !== void 0) edge.color = dataMap.color;
 		if (dataMap.style !== void 0) edge.style = tryParseJSON(dataMap.style);
 		if (dataMap.sourcePort !== void 0) edge.sourcePort = dataMap.sourcePort;
+		else if (edgeEl["@_sourceport"] != null) edge.sourcePort = String(edgeEl["@_sourceport"]);
 		if (dataMap.targetPort !== void 0) edge.targetPort = dataMap.targetPort;
+		else if (edgeEl["@_targetport"] != null) edge.targetPort = String(edgeEl["@_targetport"]);
+		const directedAttr = edgeEl["@_directed"];
+		if (directedAttr !== void 0) edge.mode = String(directedAttr) === "false" ? "undirected" : "directed";
 		return edge;
 	});
 	const graph = {
 		id: String(graphEl["@_id"] ?? ""),
-		type: graphType,
+		mode: graphType,
 		initialNodeId: graphDataMap.graphInitialNodeId ?? null,
 		nodes,
 		edges,
@@ -361,8 +399,28 @@ function tryParseJSON(str) {
 		return str;
 	}
 }
-function parseNumber(value) {
-	return Number(value);
+/**
+* Flattens native GraphML <port> elements (which may nest) into our port
+* shape. Standard GraphML ports carry only a name; direction is unknowable,
+* so they import as advisory 'inout' with null data.
+*/
+function collectPorts(portEls) {
+	const ports = [];
+	for (const portEl of asArray(portEls)) {
+		if (portEl?.["@_name"] == null) continue;
+		ports.push({
+			name: String(portEl["@_name"]),
+			direction: "inout",
+			data: null
+		});
+		if (portEl.port !== void 0) ports.push(...collectPorts(portEl.port) ?? []);
+	}
+	return ports;
+}
+function parseNumber(value, key, kind, ownerId) {
+	const parsed = Number(value);
+	if (Number.isNaN(parsed)) throw new Error(`GraphML: <data key="${key}"> value "${value}" on ${kind} "${ownerId}" is not a number. Fix the value or remove the attribute.`);
+	return parsed;
 }
 function parseDirection(value) {
 	return [

package/dist/formats/jgf/index.d.mts

@@ -1,4 +1,4 @@
-import { h as GraphFormatConverter, u as Graph } from "../../types-CnZ01raw.mjs";
+import { d as Graph, g as GraphFormatConverter } from "../../types-DNYdIU21.mjs";
 
 //#region src/formats/jgf/index.d.ts
 interface JGFNode {

package/dist/formats/jgf/index.mjs

@@ -1,4 +1,4 @@
-import { n as createFormatConverter } from "../../converter-Dspillnn.mjs";
+import { n as createFormatConverter } from "../../converter-DyCJJfTe.mjs";
 
 //#region src/formats/jgf/index.ts
 /**
@@ -20,13 +20,14 @@ import { n as createFormatConverter } from "../../converter-Dspillnn.mjs";
 */
 function toJGF(graph) {
 	const metadata = {};
+	if (graph.mode === "bidirectional") metadata.mode = graph.mode;
 	if (graph.initialNodeId) metadata.initialNodeId = graph.initialNodeId;
 	if (graph.data !== void 0) metadata.data = graph.data;
 	if (graph.direction) metadata.direction = graph.direction;
 	if (graph.style !== void 0) metadata.style = graph.style;
 	return { graph: {
 		id: graph.id || void 0,
-		directed: graph.type === "directed",
+		directed: graph.mode !== "undirected",
 		...Object.keys(metadata).length > 0 && { metadata },
 		nodes: graph.nodes.map((n) => {
 			const meta = {};
@@ -49,6 +50,7 @@ function toJGF(graph) {
 		}),
 		edges: graph.edges.map((e) => {
 			const meta = {};
+			if (e.mode) meta.mode = e.mode;
 			if (e.data !== void 0) meta.data = e.data;
 			if (e.weight !== void 0) meta.weight = e.weight;
 			if (e.x !== void 0) meta.x = e.x;
@@ -93,7 +95,7 @@ function fromJGF(jgf) {
 	if (!Array.isArray(g.edges)) throw new Error("JGF: \"graph.edges\" must be an array");
 	return {
 		id: g.id ?? "",
-		type: g.directed === false ? "undirected" : "directed",
+		mode: g.metadata?.mode ?? (g.directed === false ? "undirected" : "directed"),
 		initialNodeId: g.metadata?.initialNodeId ?? null,
 		data: g.metadata?.data,
 		...g.metadata?.direction && { direction: g.metadata.direction },
@@ -120,6 +122,7 @@ function fromJGF(jgf) {
 			sourceId: e.source,
 			targetId: e.target,
 			label: e.label ?? "",
+			...e.metadata?.mode && { mode: e.metadata.mode },
 			data: e.metadata?.data,
 			...e.metadata?.weight !== void 0 && { weight: e.metadata.weight },
 			...e.metadata?.x !== void 0 && { x: e.metadata.x },

package/dist/formats/mermaid/index.d.mts

@@ -1,4 +1,4 @@
-import { h as GraphFormatConverter, u as Graph } from "../../types-CnZ01raw.mjs";
+import { d as Graph, g as GraphFormatConverter } from "../../types-DNYdIU21.mjs";
 
 //#region src/formats/mermaid/sequence.d.ts
 interface SequenceNodeData {

package/dist/formats/mermaid/index.mjs

@@ -1,4 +1,4 @@
-import { n as createFormatConverter } from "../../converter-Dspillnn.mjs";
+import { n as createFormatConverter } from "../../converter-DyCJJfTe.mjs";
 
 //#region src/formats/mermaid/shared.ts
 const MERMAID_TO_DIRECTION = {
@@ -16,11 +16,11 @@ const DIRECTION_TO_MERMAID = {
 };
 /** Escape a label for Mermaid output (quotes special chars). */
 function escapeMermaidLabel(s) {
-	return s.replace(/\\/g, "\\\\").replace(/"/g, "#quot;").replace(/;/g, "#59;").replace(/#(?!quot;|59;|35;)/g, "#35;");
+	return s.replace(/\\/g, "\\\\").replace(/"/g, "#quot;").replace(/;/g, "#59;").replace(/\|/g, "#124;").replace(/#(?!quot;|59;|35;|124;)/g, "#35;");
 }
 /** Unescape a Mermaid label back to plain text. */
 function unescapeMermaidLabel(s) {
-	return s.replace(/#quot;/g, "\"").replace(/#59;/g, ";").replace(/#35;/g, "#");
+	return s.replace(/#quot;/g, "\"").replace(/#59;/g, ";").replace(/#124;/g, "|").replace(/#35;/g, "#");
 }
 /** Generate a deterministic edge ID from source, target, and index. */
 function generateEdgeId(sourceId, targetId, index) {
@@ -497,7 +497,7 @@ function fromMermaidSequence(input) {
 	}
 	return {
 		id: "",
-		type: "directed",
+		mode: "directed",
 		initialNodeId: null,
 		nodes: Array.from(nodeMap.values()),
 		edges,
@@ -1292,7 +1292,7 @@ function fromMermaidFlowchart(input) {
 	}
 	return {
 		id: "",
-		type: "directed",
+		mode: "directed",
 		initialNodeId: null,
 		nodes: Array.from(nodeMap.values()),
 		edges,
@@ -1389,6 +1389,19 @@ const mermaidFlowchartConverter = createFormatConverter(toMermaidFlowchart, from
 //#endregion
 //#region src/formats/mermaid/state.ts
 /**
+* Whether a node is a parallel-region marker. Region nodes are generated with
+* the exact id `${parentId}_region_${integer}`, so a node only counts when its
+* id matches that structure for its *actual* parent and that parent is a
+* parallel state. User ids that merely contain `_region_` (e.g.
+* `foo_region_bar`) are ordinary states.
+*/
+function isParallelRegionNode(node, nodesById) {
+	if (!node || !node.parentId) return false;
+	if (nodesById.get(node.parentId)?.data?.stateType !== "parallel") return false;
+	const prefix = `${node.parentId}_region_`;
+	return node.id.startsWith(prefix) && /^\d+$/.test(node.id.slice(prefix.length));
+}
+/**
 * Parses a Mermaid state diagram string into a Graph.
 *
 * @example
@@ -1410,6 +1423,7 @@ function fromMermaidState(input) {
 	let startCounter = 0;
 	let endCounter = 0;
 	let graphDirection;
+	let initialNodeId = null;
 	const classDefs = {};
 	const classAssignments = {};
 	const parentStack = [null];
@@ -1474,6 +1488,7 @@ function fromMermaidState(input) {
 			const stateId = compositeStateAsMatch[2];
 			const node = ensureNode(stateId);
 			node.data.description = description;
+			node.label = description;
 			parentStack.push(stateId);
 			continue;
 		}
@@ -1492,12 +1507,13 @@ function fromMermaidState(input) {
 			const stateId = stateAsMatch[2];
 			const node = ensureNode(stateId);
 			node.data.description = description;
+			node.label = description;
 			continue;
 		}
 		if (line === "}" || line === "end") {
 			if (parentStack.length > 1) {
 				const top = parentStack[parentStack.length - 1];
-				if (top && top.includes("_region_")) parentStack.pop();
+				if (top && isParallelRegionNode(nodeMap.get(top), nodeMap)) parentStack.pop();
 				parentStack.pop();
 			}
 			continue;
@@ -1506,7 +1522,7 @@ function fromMermaidState(input) {
 			const compositeParent = (() => {
 				for (let s = parentStack.length - 1; s >= 0; s--) {
 					const id = parentStack[s];
-					if (id && !id.includes("_region_")) return id;
+					if (id && !isParallelRegionNode(nodeMap.get(id), nodeMap)) return id;
 				}
 				return null;
 			})();
@@ -1540,7 +1556,7 @@ function fromMermaidState(input) {
 					regionCounters.set(compositeParent, 2);
 				} else {
 					const top = parentStack[parentStack.length - 1];
-					if (top && top.includes("_region_")) parentStack.pop();
+					if (top && isParallelRegionNode(nodeMap.get(top), nodeMap)) parentStack.pop();
 					const nextRegionId = `${compositeParent}_region_${regionIndex}`;
 					const nextRegion = {
 						type: "node",
@@ -1588,6 +1604,7 @@ function fromMermaidState(input) {
 			let targetId = transMatch[3];
 			const targetClass = transMatch[4];
 			const label = transMatch[5]?.trim() ?? "";
+			const isTopLevelStart = sourceId === "[*]" && parentStack[parentStack.length - 1] === null;
 			if (sourceId === "[*]") sourceId = resolveStarNode("source");
 			else {
 				ensureNode(sourceId);
@@ -1603,6 +1620,7 @@ function fromMermaidState(input) {
 					if (!classAssignments[targetId]) classAssignments[targetId] = [];
 					classAssignments[targetId].push(targetClass);
 				}
+				if (isTopLevelStart && initialNodeId === null) initialNodeId = targetId;
 			}
 			const edgeId = generateEdgeId(sourceId, targetId, edgeCounter++);
 			edges.push({
@@ -1675,8 +1693,8 @@ function fromMermaidState(input) {
 	}
 	return {
 		id: "",
-		type: "directed",
-		initialNodeId: null,
+		mode: "directed",
+		initialNodeId,
 		nodes: Array.from(nodeMap.values()),
 		edges,
 		data: {
@@ -1699,6 +1717,7 @@ function toMermaidState(graph) {
 		const mDir = DIRECTION_TO_MERMAID[graph.direction];
 		if (mDir) lines.push(`    direction ${mDir}`);
 	}
+	const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
 	const childrenMap = /* @__PURE__ */ new Map();
 	for (const node of graph.nodes) {
 		const pid = node.parentId ?? null;
@@ -1707,28 +1726,44 @@ function toMermaidState(graph) {
 	}
 	const isParent = /* @__PURE__ */ new Set();
 	for (const node of graph.nodes) if (childrenMap.has(node.id)) isParent.add(node.id);
+	const referencedByEdge = /* @__PURE__ */ new Set();
+	for (const edge of graph.edges) {
+		referencedByEdge.add(edge.sourceId);
+		referencedByEdge.add(edge.targetId);
+	}
+	if (graph.initialNodeId) referencedByEdge.add(graph.initialNodeId);
 	function writeNodes(parentId, indent) {
 		const children = childrenMap.get(parentId) ?? [];
 		for (const node of children) {
 			if (node.data?.isStart || node.data?.isEnd) continue;
-			if (node.id.includes("_region_")) continue;
-			if (node.data?.stateType && node.data.stateType !== "parallel") lines.push(`${indent}state ${node.id} <<${node.data.stateType}>>`);
+			if (isParallelRegionNode(node, nodesById)) continue;
+			const description = node.data?.description ?? (node.label && node.label !== node.id ? node.label : void 0);
+			let declared = false;
+			if (node.data?.stateType && node.data.stateType !== "parallel") {
+				lines.push(`${indent}state ${node.id} <<${node.data.stateType}>>`);
+				declared = true;
+			}
 			if (isParent.has(node.id)) {
-				const stateDecl = node.data?.description ? `state "${escapeMermaidLabel(node.data.description)}" as ${node.id} {` : `state ${node.id} {`;
+				const stateDecl = description ? `state "${escapeMermaidLabel(description)}" as ${node.id} {` : `state ${node.id} {`;
 				lines.push(`${indent}${stateDecl}`);
 				if (node.data?.direction) {
 					const mDir = DIRECTION_TO_MERMAID[node.data.direction];
 					if (mDir) lines.push(`${indent}    direction ${mDir}`);
 				}
 				if (node.data?.stateType === "parallel") {
-					const regions = (childrenMap.get(node.id) ?? []).filter((r) => r.id.includes("_region_"));
+					const regions = (childrenMap.get(node.id) ?? []).filter((r) => isParallelRegionNode(r, nodesById));
 					for (let ri = 0; ri < regions.length; ri++) {
 						if (ri > 0) lines.push(`${indent}    --`);
 						writeNodes(regions[ri].id, indent + "    ");
 					}
 				} else writeNodes(node.id, indent + "    ");
 				lines.push(`${indent}}`);
-			} else if (node.data?.description) lines.push(`${indent}state "${escapeMermaidLabel(node.data.description)}" as ${node.id}`);
+				declared = true;
+			} else if (description) {
+				lines.push(`${indent}state "${escapeMermaidLabel(description)}" as ${node.id}`);
+				declared = true;
+			}
+			if (!declared && !referencedByEdge.has(node.id)) lines.push(`${indent}${node.id}`);
 			if (node.data?.notes) for (const note of node.data.notes) if (note.format === "block" || note.text.includes("\n")) {
 				lines.push(`${indent}note ${note.position} of ${node.id}`);
 				for (const noteLine of note.text.split("\n")) lines.push(`${indent}    ${escapeMermaidLabel(noteLine)}`);
@@ -1737,6 +1772,8 @@ function toMermaidState(graph) {
 		}
 	}
 	writeNodes(null, "    ");
+	const hasTopLevelStart = graph.nodes.some((n) => n.data?.isStart && (n.parentId ?? null) === null);
+	if (graph.initialNodeId && !hasTopLevelStart) lines.push(`    [*] --> ${graph.initialNodeId}`);
 	for (const edge of graph.edges) {
 		let sourceId = edge.sourceId;
 		let targetId = edge.targetId;
@@ -2053,7 +2090,7 @@ function fromMermaidClass(input) {
 	}
 	return {
 		id: "",
-		type: "directed",
+		mode: "directed",
 		initialNodeId: null,
 		nodes: Array.from(nodeMap.values()),
 		edges,
@@ -2251,7 +2288,7 @@ function fromMermaidER(input) {
 	}
 	return {
 		id: "",
-		type: "directed",
+		mode: "directed",
 		initialNodeId: null,
 		nodes: Array.from(nodeMap.values()),
 		edges,
@@ -2409,7 +2446,7 @@ function fromMermaidMindmap(input) {
 	}
 	return {
 		id: "",
-		type: "directed",
+		mode: "directed",
 		initialNodeId: null,
 		nodes: Array.from(nodeMap.values()),
 		edges,
@@ -2608,7 +2645,7 @@ function fromMermaidBlock(input) {
 	}
 	return {
 		id: "",
-		type: "directed",
+		mode: "directed",
 		initialNodeId: null,
 		nodes: Array.from(nodeMap.values()),
 		edges,
@@ -2720,7 +2757,7 @@ function fromMermaidIshikawa(input) {
 	}
 	return {
 		id: "",
-		type: "directed",
+		mode: "directed",
 		initialNodeId: null,
 		nodes,
 		edges,

package/dist/formats/tgf/index.d.mts

@@ -1,4 +1,4 @@
-import { h as GraphFormatConverter, u as Graph } from "../../types-CnZ01raw.mjs";
+import { d as Graph, g as GraphFormatConverter } from "../../types-DNYdIU21.mjs";
 
 //#region src/formats/tgf/index.d.ts
 

package/dist/formats/tgf/index.mjs

@@ -1,4 +1,4 @@
-import { n as createFormatConverter } from "../../converter-Dspillnn.mjs";
+import { n as createFormatConverter } from "../../converter-DyCJJfTe.mjs";
 
 //#region src/formats/tgf/index.ts
 /**
@@ -81,7 +81,7 @@ function fromTGF(tgf) {
 	}
 	return {
 		id: "",
-		type: "directed",
+		mode: "directed",
 		initialNodeId: null,
 		nodes,
 		edges,

package/dist/formats/xyflow/index.d.mts

@@ -1,4 +1,4 @@
-import { P as VisualGraphFormatConverter, j as VisualGraph } from "../../types-CnZ01raw.mjs";
+import { L as VisualGraphFormatConverter, P as VisualGraph } from "../../types-DNYdIU21.mjs";
 import { EdgeBase, NodeBase } from "@xyflow/system";
 
 //#region src/formats/xyflow/index.d.ts

package/dist/formats/xyflow/index.mjs

@@ -19,8 +19,33 @@ function readMetadata(value) {
 }
 function readUserData(value) {
 	const metadata = readMetadata(value);
-	if (metadata && "data" in metadata) return metadata.data;
-	return value;
+	if (!metadata) return value;
+	return "data" in metadata ? metadata.data : void 0;
+}
+/**
+* React Flow requires parent nodes to appear before their children in the
+* nodes array. Reorders iteratively, keeping authored order otherwise: each
+* pass emits nodes whose parent is already emitted (or absent). Nodes left
+* over by a parentId cycle are appended in authored order rather than hanging.
+*/
+function orderParentsFirst(nodes) {
+	const nodeIds = new Set(nodes.map((n) => n.id));
+	const emitted = /* @__PURE__ */ new Set();
+	const result = [];
+	let remaining = nodes;
+	while (remaining.length > 0) {
+		const deferred = [];
+		for (const node of remaining) if (!node.parentId || emitted.has(node.parentId) || !nodeIds.has(node.parentId)) {
+			result.push(node);
+			emitted.add(node.id);
+		} else deferred.push(node);
+		if (deferred.length === remaining.length) {
+			result.push(...deferred);
+			break;
+		}
+		remaining = deferred;
+	}
+	return result;
 }
 /**
 * Converts a visual graph to xyflow (React Flow / Svelte Flow) format.
@@ -46,13 +71,13 @@ function toXYFlow(graph) {
 	return {
 		data: { [STATELYAI_METADATA_KEY]: { graph: {
 			id: graph.id,
-			type: graph.type,
+			mode: graph.mode,
 			initialNodeId: graph.initialNodeId,
 			data: graph.data,
 			direction: graph.direction,
 			style: graph.style
 		} } },
-		nodes: graph.nodes.map((n) => {
+		nodes: orderParentsFirst(graph.nodes.map((n) => {
 			const node = {
 				id: n.id,
 				position: {
@@ -72,7 +97,7 @@ function toXYFlow(graph) {
 			if (n.width !== void 0) node.width = n.width;
 			if (n.height !== void 0) node.height = n.height;
 			return node;
-		}),
+		})),
 		edges: graph.edges.map((e) => {
 			const edge = {
 				id: e.id,
@@ -83,6 +108,7 @@ function toXYFlow(graph) {
 			if (e.targetPort) edge.targetHandle = e.targetPort;
 			edge.data = withMetadata(e.data, { edge: {
 				label: e.label,
+				mode: e.mode,
 				weight: e.weight,
 				color: e.color,
 				style: e.style,
@@ -119,7 +145,7 @@ function fromXYFlow(flow) {
 	const graphMetadata = readMetadata(flow.data)?.graph;
 	return {
 		id: graphMetadata?.id?.toString() ?? "",
-		type: graphMetadata?.type === "undirected" ? "undirected" : "directed",
+		mode: graphMetadata?.mode ?? "directed",
 		initialNodeId: graphMetadata && "initialNodeId" in graphMetadata ? graphMetadata.initialNodeId : null,
 		data: graphMetadata && "data" in graphMetadata ? graphMetadata.data : void 0,
 		direction: graphMetadata?.direction ?? "down",
@@ -158,6 +184,7 @@ function fromXYFlow(flow) {
 				y: metadata?.y ?? 0,
 				width: metadata?.width ?? 0,
 				height: metadata?.height ?? 0,
+				...metadata?.mode !== void 0 && { mode: metadata.mode },
 				...metadata?.weight !== void 0 && { weight: metadata.weight },
 				...metadata?.color !== void 0 && { color: metadata.color },
 				...metadata?.style !== void 0 && { style: metadata.style }

package/dist/index-D51lJnt2.d.mts

@@ -0,0 +1,61 @@
+import { d as Graph, g as GraphFormatConverter } from "./types-DNYdIU21.mjs";
+
+//#region src/formats/converter/index.d.ts
+
+/**
+ * Create a `GraphFormatConverter` from a pair of `to`/`from` functions.
+ *
+ * @example
+ * ```ts
+ * import { createFormatConverter } from '@statelyai/graph';
+ *
+ * const yamlConverter = createFormatConverter(
+ *   (graph) => toYAML(graph),
+ *   (yaml) => fromYAML(yaml),
+ * );
+ *
+ * const yaml = yamlConverter.to(graph);
+ * const graph = yamlConverter.from(yaml);
+ * ```
+ */
+declare function createFormatConverter<TSerial, N = any, E = any, G = any>(to: (graph: Graph<N, E, G>) => TSerial, from: (input: TSerial) => Graph<N, E, G>): GraphFormatConverter<TSerial, N, E, G>;
+/**
+ * Bidirectional converter for adjacency-list format (`Record<string, string[]>`).
+ *
+ * @example
+ * ```ts
+ * import { adjacencyListConverter, createGraph } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: { a: {}, b: {} },
+ *   edges: [{ source: 'a', target: 'b' }],
+ * });
+ *
+ * const adj = adjacencyListConverter.to(graph);
+ * // { a: ['b'], b: [] }
+ *
+ * const roundTripped = adjacencyListConverter.from(adj);
+ * ```
+ */
+declare const adjacencyListConverter: GraphFormatConverter<Record<string, string[]>>;
+/**
+ * Bidirectional converter for edge-list format (`[source, target][]`).
+ *
+ * @example
+ * ```ts
+ * import { edgeListConverter, createGraph } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: { a: {}, b: {} },
+ *   edges: [{ source: 'a', target: 'b' }],
+ * });
+ *
+ * const edges = edgeListConverter.to(graph);
+ * // [['a', 'b']]
+ *
+ * const roundTripped = edgeListConverter.from(edges);
+ * ```
+ */
+declare const edgeListConverter: GraphFormatConverter<[string, string][]>;
+//#endregion
+export { createFormatConverter as n, edgeListConverter as r, adjacencyListConverter as t };