@statelyai/graph 0.1.0 → 0.3.0

package/dist/formats/dot/index.mjs

@@ -0,0 +1,235 @@
+import { n as createFormatConverter } from "../../converter-DnbeyE_p.mjs";
+import parse from "dotparser";
+
+//#region src/formats/dot/index.ts
+/** Escape a DOT identifier */
+function escapeId(id) {
+	if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(id)) return id;
+	return `"${id.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+/** Escape a DOT label string */
+function escapeLabel(label) {
+	return label.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+const DIRECTION_TO_RANKDIR = {
+	down: "TB",
+	up: "BT",
+	right: "LR",
+	left: "RL"
+};
+const SHAPE_TO_DOT = {
+	rectangle: "box",
+	ellipse: "ellipse",
+	circle: "circle",
+	diamond: "diamond",
+	hexagon: "hexagon",
+	cylinder: "cylinder",
+	parallelogram: "parallelogram"
+};
+function toDOT(graph) {
+	const isDirected = graph.type === "directed";
+	const keyword = isDirected ? "digraph" : "graph";
+	const edgeOp = isDirected ? "->" : "--";
+	const lines = [];
+	lines.push(`${keyword} ${escapeId(graph.id)} {`);
+	if (graph.direction) {
+		const rankdir = DIRECTION_TO_RANKDIR[graph.direction] ?? "TB";
+		lines.push(`  rankdir=${rankdir};`);
+	}
+	for (const node of graph.nodes) {
+		const attrs = [];
+		if (node.label) attrs.push(`label="${escapeLabel(node.label)}"`);
+		if (node.shape) {
+			const dotShape = SHAPE_TO_DOT[node.shape] ?? node.shape;
+			attrs.push(`shape=${dotShape}`);
+		}
+		if (node.color) attrs.push(`fillcolor="${escapeLabel(node.color)}" style=filled`);
+		if (attrs.length > 0) lines.push(`  ${escapeId(node.id)} [${attrs.join(", ")}];`);
+		else lines.push(`  ${escapeId(node.id)};`);
+	}
+	for (const edge of graph.edges) {
+		const attrs = [];
+		if (edge.label) attrs.push(`label="${escapeLabel(edge.label)}"`);
+		if (edge.color) attrs.push(`color="${escapeLabel(edge.color)}"`);
+		const attrStr = attrs.length > 0 ? ` [${attrs.join(", ")}]` : "";
+		lines.push(`  ${escapeId(edge.sourceId)} ${edgeOp} ${escapeId(edge.targetId)}${attrStr};`);
+	}
+	lines.push("}");
+	return lines.join("\n");
+}
+const RANKDIR_TO_DIRECTION = {
+	TB: "down",
+	BT: "up",
+	LR: "right",
+	RL: "left"
+};
+const DOT_TO_SHAPE = {
+	box: "rectangle",
+	rect: "rectangle",
+	rectangle: "rectangle",
+	ellipse: "ellipse",
+	oval: "ellipse",
+	circle: "circle",
+	diamond: "diamond",
+	hexagon: "hexagon",
+	cylinder: "cylinder",
+	parallelogram: "parallelogram"
+};
+function attrsToMap(attrList) {
+	const map = {};
+	for (const a of attrList) map[a.id] = String(a.eq);
+	return map;
+}
+function nodeFromAttrs(id, attrs, defaults, parentId) {
+	const merged = {
+		...defaults,
+		...attrs
+	};
+	const label = merged["label"] ?? "";
+	const rawShape = merged["shape"];
+	const shape = rawShape ? DOT_TO_SHAPE[rawShape] ?? rawShape : void 0;
+	const color = merged["fillcolor"] ?? merged["color"] ?? void 0;
+	return {
+		type: "node",
+		id,
+		parentId,
+		initialNodeId: null,
+		label,
+		data: void 0,
+		...shape && { shape },
+		...color && { color }
+	};
+}
+function fromDOT(dot) {
+	if (typeof dot !== "string") throw new Error("DOT: expected a string");
+	if (!dot.trim()) throw new Error("DOT: input is empty");
+	let ast;
+	try {
+		ast = parse(dot);
+	} catch (e) {
+		throw new Error(`DOT: parse error — ${e.message}`);
+	}
+	if (!ast || ast.length === 0) throw new Error("DOT: no graph found");
+	const root = ast[0];
+	const isDirected = root.type === "digraph";
+	const nodeMap = /* @__PURE__ */ new Map();
+	const edges = [];
+	let edgeIdx = 0;
+	let direction;
+	function ensureNode(id, parentId, defaults) {
+		if (!nodeMap.has(id)) nodeMap.set(id, nodeFromAttrs(id, {}, defaults, parentId));
+	}
+	function getNodeIdsFromSubgraph(children) {
+		const ids = /* @__PURE__ */ new Set();
+		function collect(statements) {
+			for (const stmt of statements) switch (stmt.type) {
+				case "node_stmt":
+					ids.add(stmt.node_id.id);
+					break;
+				case "edge_stmt":
+					for (const item of stmt.edge_list) if (item.type === "node_id") ids.add(item.id);
+					else if (item.type === "subgraph") collect(item.children);
+					break;
+				case "subgraph":
+					collect(stmt.children);
+					break;
+			}
+		}
+		collect(children);
+		return [...ids];
+	}
+	function walkChildren(children, parentId, nodeDefaults, edgeDefaults) {
+		let nd = { ...nodeDefaults };
+		let ed = { ...edgeDefaults };
+		for (const stmt of children) switch (stmt.type) {
+			case "attr_stmt":
+				if (stmt.target === "node") nd = {
+					...nd,
+					...attrsToMap(stmt.attr_list)
+				};
+				else if (stmt.target === "edge") ed = {
+					...ed,
+					...attrsToMap(stmt.attr_list)
+				};
+				else if (stmt.target === "graph") {
+					const graphAttrs = attrsToMap(stmt.attr_list);
+					if (graphAttrs["rankdir"]) direction = RANKDIR_TO_DIRECTION[graphAttrs["rankdir"].toUpperCase()] ?? void 0;
+				}
+				break;
+			case "node_stmt": {
+				const id = stmt.node_id.id;
+				const node = nodeFromAttrs(id, attrsToMap(stmt.attr_list), nd, parentId);
+				nodeMap.set(id, node);
+				break;
+			}
+			case "edge_stmt": {
+				const edgeAttrs = attrsToMap(stmt.attr_list);
+				const mergedEdgeAttrs = {
+					...ed,
+					...edgeAttrs
+				};
+				const endpointGroups = [];
+				for (const item of stmt.edge_list) if (item.type === "node_id") {
+					ensureNode(item.id, parentId, nd);
+					endpointGroups.push([item.id]);
+				} else if (item.type === "subgraph") {
+					walkChildren(item.children, parentId, nd, ed);
+					const subNodeIds = getNodeIdsFromSubgraph(item.children);
+					for (const subNodeId of subNodeIds) ensureNode(subNodeId, parentId, nd);
+					if (subNodeIds.length > 0) endpointGroups.push(subNodeIds);
+				}
+				for (let i = 0; i < endpointGroups.length - 1; i++) {
+					const left = endpointGroups[i];
+					const right = endpointGroups[i + 1];
+					for (const sourceId of left) for (const targetId of right) {
+						const edge = {
+							type: "edge",
+							id: `e${edgeIdx++}`,
+							sourceId,
+							targetId,
+							label: mergedEdgeAttrs["label"] ?? "",
+							data: void 0,
+							...mergedEdgeAttrs["color"] && { color: mergedEdgeAttrs["color"] }
+						};
+						edges.push(edge);
+					}
+				}
+				break;
+			}
+			case "subgraph": {
+				const subId = stmt.id ?? `subgraph_${nodeMap.size}`;
+				let subLabel = "";
+				for (const child of stmt.children) if (child.type === "attr_stmt" && child.target === "graph") {
+					const ga = attrsToMap(child.attr_list);
+					if (ga["label"]) subLabel = ga["label"];
+				}
+				const subNode = {
+					type: "node",
+					id: subId,
+					parentId,
+					initialNodeId: null,
+					label: subLabel,
+					data: void 0
+				};
+				nodeMap.set(subId, subNode);
+				walkChildren(stmt.children, subId, nd, ed);
+				break;
+			}
+		}
+	}
+	walkChildren(root.children, null, {}, {});
+	return {
+		id: root.id ?? "",
+		type: isDirected ? "directed" : "undirected",
+		initialNodeId: null,
+		nodes: [...nodeMap.values()],
+		edges,
+		data: void 0,
+		...direction && { direction }
+	};
+}
+/** Bidirectional converter for DOT (Graphviz) format. */
+const dotConverter = createFormatConverter(toDOT, fromDOT);
+
+//#endregion
+export { dotConverter, fromDOT, toDOT };

package/dist/{edge-list-CJmfoNu2.d.mts → formats/edge-list/index.d.mts}

@@ -1,10 +1,10 @@
-import { c as Graph } from "./types-XV3S5Jnh.mjs";
+import { c as Graph } from "../../types-B6Tpeerk.mjs";
 
-//#region src/formats/edge-list.d.ts
+//#region src/formats/edge-list/index.d.ts
 declare function toEdgeList(graph: Graph): [string, string][];
 declare function fromEdgeList(edges: [string, string][], options?: {
   directed?: boolean;
   id?: string;
 }): Graph;
 //#endregion
-export { toEdgeList as n, fromEdgeList as t };
+export { fromEdgeList, toEdgeList };

package/dist/formats/edge-list/index.mjs

@@ -0,0 +1,3 @@
+import { n as toEdgeList, t as fromEdgeList } from "../../edge-list-DuHMz8hf.mjs";
+
+export { fromEdgeList, toEdgeList };

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

@@ -0,0 +1,9 @@
+import { c as Graph, f as GraphFormatConverter } from "../../types-B6Tpeerk.mjs";
+
+//#region src/formats/gexf/index.d.ts
+declare function toGEXF(graph: Graph): string;
+declare function fromGEXF(xml: string): Graph;
+/** Bidirectional converter for GEXF (Graph Exchange XML Format). */
+declare const gexfConverter: GraphFormatConverter<string>;
+//#endregion
+export { fromGEXF, gexfConverter, toGEXF };

package/dist/formats/gexf/index.mjs

@@ -0,0 +1,249 @@
+import { n as createFormatConverter } from "../../converter-DnbeyE_p.mjs";
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+
+//#region src/formats/gexf/index.ts
+function toGEXF(graph) {
+	const nodeAttrs = [
+		{
+			"@_id": "a_parentId",
+			"@_title": "parentId",
+			"@_type": "string"
+		},
+		{
+			"@_id": "a_initialNodeId",
+			"@_title": "initialNodeId",
+			"@_type": "string"
+		},
+		{
+			"@_id": "a_data",
+			"@_title": "data",
+			"@_type": "string"
+		},
+		{
+			"@_id": "a_shape",
+			"@_title": "shape",
+			"@_type": "string"
+		}
+	];
+	const edgeAttrs = [{
+		"@_id": "a_edgeData",
+		"@_title": "data",
+		"@_type": "string"
+	}];
+	const nodes = graph.nodes.map((n) => {
+		const attvalues = [];
+		if (n.parentId !== null) attvalues.push({
+			"@_for": "a_parentId",
+			"@_value": n.parentId
+		});
+		if (n.initialNodeId !== null) attvalues.push({
+			"@_for": "a_initialNodeId",
+			"@_value": n.initialNodeId
+		});
+		if (n.data !== void 0) attvalues.push({
+			"@_for": "a_data",
+			"@_value": JSON.stringify(n.data)
+		});
+		if (n.shape) attvalues.push({
+			"@_for": "a_shape",
+			"@_value": n.shape
+		});
+		const node = {
+			"@_id": n.id,
+			"@_label": n.label || n.id
+		};
+		if (n.parentId !== null) node["@_pid"] = n.parentId;
+		if (attvalues.length > 0) node.attvalues = { attvalue: attvalues };
+		if (n.color) {
+			const hex$1 = n.color.replace("#", "");
+			if (hex$1.length === 6) node["viz:color"] = {
+				"@_r": parseInt(hex$1.slice(0, 2), 16),
+				"@_g": parseInt(hex$1.slice(2, 4), 16),
+				"@_b": parseInt(hex$1.slice(4, 6), 16)
+			};
+		}
+		if (n.x !== void 0 || n.y !== void 0) node["viz:position"] = {
+			"@_x": n.x ?? 0,
+			"@_y": n.y ?? 0
+		};
+		if (n.width !== void 0 || n.height !== void 0) node["viz:size"] = { "@_value": n.width ?? n.height ?? 0 };
+		return node;
+	});
+	const edges = graph.edges.map((e) => {
+		const edge = {
+			"@_id": e.id,
+			"@_source": e.sourceId,
+			"@_target": e.targetId
+		};
+		if (e.label) edge["@_label"] = e.label;
+		if (e.data !== void 0) edge.attvalues = { attvalue: [{
+			"@_for": "a_edgeData",
+			"@_value": JSON.stringify(e.data)
+		}] };
+		if (e.color) {
+			const hex$1 = e.color.replace("#", "");
+			if (hex$1.length === 6) edge["viz:color"] = {
+				"@_r": parseInt(hex$1.slice(0, 2), 16),
+				"@_g": parseInt(hex$1.slice(2, 4), 16),
+				"@_b": parseInt(hex$1.slice(4, 6), 16)
+			};
+		}
+		return edge;
+	});
+	const graphData = [];
+	if (graph.initialNodeId !== null) graphData.push({
+		"@_for": "a_initialNodeId",
+		"@_value": graph.initialNodeId
+	});
+	if (graph.data !== void 0) graphData.push({
+		"@_for": "a_data",
+		"@_value": JSON.stringify(graph.data)
+	});
+	const obj = {
+		"?xml": {
+			"@_version": "1.0",
+			"@_encoding": "UTF-8"
+		},
+		gexf: {
+			"@_xmlns": "http://gexf.net/1.3",
+			"@_xmlns:viz": "http://gexf.net/1.3/viz",
+			"@_version": "1.3",
+			graph: {
+				"@_defaultedgetype": graph.type === "directed" ? "directed" : "undirected",
+				...graph.id && { "@_id": graph.id },
+				attributes: [{
+					"@_class": "node",
+					attribute: nodeAttrs
+				}, {
+					"@_class": "edge",
+					attribute: edgeAttrs
+				}],
+				nodes: { node: nodes },
+				edges: { edge: edges }
+			}
+		}
+	};
+	return new XMLBuilder({
+		ignoreAttributes: false,
+		format: true,
+		suppressEmptyNode: true
+	}).build(obj);
+}
+function fromGEXF(xml) {
+	if (typeof xml !== "string") throw new Error("GEXF: expected a string");
+	const parser = new XMLParser({
+		ignoreAttributes: false,
+		isArray: (name) => [
+			"node",
+			"edge",
+			"attribute",
+			"attvalue",
+			"attributes"
+		].includes(name)
+	});
+	let parsed;
+	try {
+		parsed = parser.parse(xml);
+	} catch (e) {
+		throw new Error(`GEXF: invalid XML — ${e.message}`);
+	}
+	const gexf = parsed?.gexf;
+	if (!gexf) throw new Error("GEXF: missing <gexf> root element");
+	const graphEl = gexf.graph;
+	if (!graphEl) throw new Error("GEXF: missing <graph> element");
+	const graphType = graphEl["@_defaultedgetype"] === "undirected" ? "undirected" : "directed";
+	const attrMap = /* @__PURE__ */ new Map();
+	for (const block of asArray(graphEl.attributes)) for (const attr of asArray(block?.attribute)) if (attr?.["@_id"] && attr?.["@_title"]) attrMap.set(attr["@_id"], attr["@_title"]);
+	const nodes = [];
+	function parseNodes(nodeEls, parentId) {
+		for (const n of asArray(nodeEls)) {
+			const attvals = getAttValues(n, attrMap);
+			const id = String(n["@_id"]);
+			const node = {
+				type: "node",
+				id,
+				parentId: (n["@_pid"] != null ? String(n["@_pid"]) : null) ?? attvals["parentId"] ?? parentId,
+				initialNodeId: attvals["initialNodeId"] ?? null,
+				label: n["@_label"] ?? "",
+				data: attvals["data"] !== void 0 ? tryParseJSON(attvals["data"]) : void 0
+			};
+			if (attvals["shape"]) node.shape = attvals["shape"];
+			const pos = n["viz:position"];
+			if (pos) {
+				node.x = Number(pos["@_x"] ?? 0);
+				node.y = Number(pos["@_y"] ?? 0);
+			}
+			const size = n["viz:size"];
+			if (size) {
+				node.width = Number(size["@_value"] ?? 0);
+				node.height = Number(size["@_value"] ?? 0);
+			}
+			const color = n["viz:color"];
+			if (color) {
+				const r = Number(color["@_r"] ?? 0);
+				const g = Number(color["@_g"] ?? 0);
+				const b = Number(color["@_b"] ?? 0);
+				node.color = `#${hex(r)}${hex(g)}${hex(b)}`;
+			}
+			nodes.push(node);
+			const nested = n.nodes?.node ?? n.node;
+			if (nested) parseNodes(nested, id);
+		}
+	}
+	parseNodes(graphEl.nodes?.node ?? graphEl.node, null);
+	const edges = asArray(graphEl.edges?.edge ?? graphEl.edge).map((e, i) => {
+		const attvals = getAttValues(e, attrMap);
+		const edge = {
+			type: "edge",
+			id: String(e["@_id"] ?? `e${i}`),
+			sourceId: String(e["@_source"]),
+			targetId: String(e["@_target"]),
+			label: e["@_label"] ?? "",
+			data: attvals["data"] !== void 0 ? tryParseJSON(attvals["data"]) : void 0
+		};
+		const color = e["viz:color"];
+		if (color) {
+			const r = Number(color["@_r"] ?? 0);
+			const g = Number(color["@_g"] ?? 0);
+			const b = Number(color["@_b"] ?? 0);
+			edge.color = `#${hex(r)}${hex(g)}${hex(b)}`;
+		}
+		return edge;
+	});
+	return {
+		id: String(graphEl["@_id"] ?? ""),
+		type: graphType,
+		initialNodeId: null,
+		nodes,
+		edges,
+		data: void 0
+	};
+}
+function asArray(val) {
+	if (val === void 0) return [];
+	return Array.isArray(val) ? val : [val];
+}
+function getAttValues(el, attrMap) {
+	const result = {};
+	const attvalues = el?.attvalues?.attvalue;
+	for (const av of asArray(attvalues)) if (av?.["@_for"] != null) {
+		const title = attrMap.get(av["@_for"]) ?? av["@_for"];
+		result[title] = String(av["@_value"] ?? "");
+	}
+	return result;
+}
+function tryParseJSON(str) {
+	try {
+		return JSON.parse(str);
+	} catch {
+		return str;
+	}
+}
+function hex(n) {
+	return n.toString(16).padStart(2, "0");
+}
+/** Bidirectional converter for GEXF (Graph Exchange XML Format). */
+const gexfConverter = createFormatConverter(toGEXF, fromGEXF);
+
+//#endregion
+export { fromGEXF, gexfConverter, toGEXF };

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

@@ -0,0 +1,9 @@
+import { c as Graph, f as GraphFormatConverter } from "../../types-B6Tpeerk.mjs";
+
+//#region src/formats/gml/index.d.ts
+declare function toGML(graph: Graph): string;
+declare function fromGML(gml: string): Graph;
+/** Bidirectional converter for GML (Graph Modelling Language) format. */
+declare const gmlConverter: GraphFormatConverter<string>;
+//#endregion
+export { fromGML, gmlConverter, toGML };