@statelyai/graph 0.1.0 → 0.3.1

package/dist/formats/gml/index.mjs

@@ -0,0 +1,291 @@
+import { n as createFormatConverter } from "../../converter-CchokMDg.mjs";
+
+//#region src/formats/gml/index.ts
+/**
+* Converts a graph to GML (Graph Modelling Language) string.
+*
+* @example
+* ```ts
+* import { createGraph } from '@statelyai/graph';
+* import { toGML } from '@statelyai/graph/formats/gml';
+*
+* const graph = createGraph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const gml = toGML(graph);
+* // graph [
+* //   directed 1
+* //   node [ id "a" ]
+* //   node [ id "b" ]
+* //   edge [ id "e0" source "a" target "b" ]
+* // ]
+* ```
+*/
+function toGML(graph) {
+	const lines = [];
+	lines.push("graph [");
+	lines.push(`  directed ${graph.type === "directed" ? 1 : 0}`);
+	if (graph.id) lines.push(`  id ${gmlString(graph.id)}`);
+	const childrenMap = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		const pid = node.parentId;
+		if (!childrenMap.has(pid)) childrenMap.set(pid, []);
+		childrenMap.get(pid).push(node);
+	}
+	function writeNode(node, indent) {
+		lines.push(`${indent}node [`);
+		lines.push(`${indent}  id ${gmlString(node.id)}`);
+		if (node.label) lines.push(`${indent}  label ${gmlString(node.label)}`);
+		if (node.initialNodeId !== null) lines.push(`${indent}  initialNodeId ${gmlString(node.initialNodeId)}`);
+		if (node.data !== void 0) lines.push(`${indent}  data ${gmlString(JSON.stringify(node.data))}`);
+		if (node.shape) lines.push(`${indent}  shape ${gmlString(node.shape)}`);
+		if (node.color) lines.push(`${indent}  color ${gmlString(node.color)}`);
+		if (node.x !== void 0 || node.y !== void 0 || node.width !== void 0 || node.height !== void 0) {
+			lines.push(`${indent}  graphics [`);
+			if (node.x !== void 0) lines.push(`${indent}    x ${node.x}`);
+			if (node.y !== void 0) lines.push(`${indent}    y ${node.y}`);
+			if (node.width !== void 0) lines.push(`${indent}    w ${node.width}`);
+			if (node.height !== void 0) lines.push(`${indent}    h ${node.height}`);
+			lines.push(`${indent}  ]`);
+		}
+		const children = childrenMap.get(node.id);
+		if (children) for (const child of children) writeNode(child, indent + "  ");
+		lines.push(`${indent}]`);
+	}
+	const roots = childrenMap.get(null) ?? [];
+	for (const node of roots) writeNode(node, "  ");
+	for (const edge of graph.edges) {
+		lines.push("  edge [");
+		lines.push(`    id ${gmlString(edge.id)}`);
+		lines.push(`    source ${gmlString(edge.sourceId)}`);
+		lines.push(`    target ${gmlString(edge.targetId)}`);
+		if (edge.label) lines.push(`    label ${gmlString(edge.label)}`);
+		if (edge.data !== void 0) lines.push(`    data ${gmlString(JSON.stringify(edge.data))}`);
+		if (edge.color) lines.push(`    color ${gmlString(edge.color)}`);
+		lines.push("  ]");
+	}
+	lines.push("]");
+	return lines.join("\n");
+}
+function gmlString(s) {
+	return `"${s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+/**
+* Parses a GML (Graph Modelling Language) string into a graph.
+*
+* @example
+* ```ts
+* import { fromGML } from '@statelyai/graph/formats/gml';
+*
+* const graph = fromGML(`
+*   graph [
+*     directed 1
+*     node [ id "a" ]
+*     node [ id "b" ]
+*     edge [ source "a" target "b" ]
+*   ]
+* `);
+* ```
+*/
+function fromGML(gml) {
+	if (typeof gml !== "string") throw new Error("GML: expected a string");
+	if (!gml.trim()) throw new Error("GML: input is empty");
+	const tokens = tokenize(gml);
+	if (tokens.length === 0) throw new Error("GML: no tokens found");
+	const graphBlock = parseBlock(tokens, 0).value["graph"];
+	if (!graphBlock) throw new Error("GML: missing top-level \"graph\" block");
+	const directed = graphBlock["directed"] === 1;
+	const graphId = String(graphBlock["id"] ?? "");
+	const nodes = [];
+	const edges = [];
+	function parseNodes(block, parentId) {
+		const nodeEntries = asArray(block["node"]);
+		for (const n of nodeEntries) {
+			const id = String(n["id"] ?? "");
+			const gfx = n["graphics"];
+			nodes.push({
+				type: "node",
+				id,
+				parentId,
+				initialNodeId: n["initialNodeId"] ?? null,
+				label: n["label"] ?? "",
+				data: n["data"] !== void 0 ? tryParseJSON(n["data"]) : void 0,
+				...n["shape"] && { shape: n["shape"] },
+				...n["color"] && { color: n["color"] },
+				...gfx?.x !== void 0 && { x: gfx.x },
+				...gfx?.y !== void 0 && { y: gfx.y },
+				...gfx?.w !== void 0 && { width: gfx.w },
+				...gfx?.h !== void 0 && { height: gfx.h }
+			});
+			if (n["node"] !== void 0) parseNodes(n, id);
+		}
+	}
+	parseNodes(graphBlock, null);
+	const edgeEntries = asArray(graphBlock["edge"]);
+	for (const e of edgeEntries) edges.push({
+		type: "edge",
+		id: String(e["id"] ?? `e${edges.length}`),
+		sourceId: String(e["source"] ?? ""),
+		targetId: String(e["target"] ?? ""),
+		label: e["label"] ?? "",
+		data: e["data"] !== void 0 ? tryParseJSON(e["data"]) : void 0,
+		...e["color"] && { color: e["color"] }
+	});
+	return {
+		id: graphId,
+		type: directed ? "directed" : "undirected",
+		initialNodeId: null,
+		nodes,
+		edges,
+		data: void 0
+	};
+}
+function tokenize(input) {
+	const tokens = [];
+	let i = 0;
+	while (i < input.length) {
+		const ch = input[i];
+		if (/\s/.test(ch)) {
+			i++;
+			continue;
+		}
+		if (ch === "#") {
+			while (i < input.length && input[i] !== "\n") i++;
+			continue;
+		}
+		if (ch === "[") {
+			tokens.push({
+				type: "open",
+				value: "["
+			});
+			i++;
+			continue;
+		}
+		if (ch === "]") {
+			tokens.push({
+				type: "close",
+				value: "]"
+			});
+			i++;
+			continue;
+		}
+		if (ch === "\"") {
+			i++;
+			let s = "";
+			while (i < input.length && input[i] !== "\"") {
+				if (input[i] === "\\" && i + 1 < input.length) {
+					i++;
+					s += input[i];
+				} else s += input[i];
+				i++;
+			}
+			i++;
+			tokens.push({
+				type: "string",
+				value: s
+			});
+			continue;
+		}
+		if (/[-+0-9.]/.test(ch)) {
+			let num = "";
+			while (i < input.length && /[-+0-9.eE]/.test(input[i])) {
+				num += input[i];
+				i++;
+			}
+			const parsed = Number(num);
+			if (!isNaN(parsed)) tokens.push({
+				type: "number",
+				value: parsed
+			});
+			else tokens.push({
+				type: "word",
+				value: num
+			});
+			continue;
+		}
+		if (/[a-zA-Z_]/.test(ch)) {
+			let word = "";
+			while (i < input.length && /[a-zA-Z0-9_]/.test(input[i])) {
+				word += input[i];
+				i++;
+			}
+			tokens.push({
+				type: "word",
+				value: word
+			});
+			continue;
+		}
+		i++;
+	}
+	return tokens;
+}
+function parseBlock(tokens, pos) {
+	const result = {};
+	while (pos < tokens.length) {
+		const tok = tokens[pos];
+		if (tok.type === "close") {
+			pos++;
+			break;
+		}
+		if (tok.type === "word") {
+			const key = tok.value;
+			pos++;
+			if (pos >= tokens.length) break;
+			const next = tokens[pos];
+			if (next.type === "open") {
+				pos++;
+				const nested = parseBlock(tokens, pos);
+				pos = nested.pos;
+				if (result[key] !== void 0) {
+					if (!Array.isArray(result[key])) result[key] = [result[key]];
+					result[key].push(nested.value);
+				} else result[key] = nested.value;
+			} else {
+				if (result[key] !== void 0) {
+					if (!Array.isArray(result[key])) result[key] = [result[key]];
+					result[key].push(next.value);
+				} else result[key] = next.value;
+				pos++;
+			}
+		} else pos++;
+	}
+	return {
+		value: result,
+		pos
+	};
+}
+function asArray(val) {
+	if (val === void 0) return [];
+	return Array.isArray(val) ? val : [val];
+}
+function tryParseJSON(str) {
+	if (typeof str !== "string") return str;
+	try {
+		return JSON.parse(str);
+	} catch {
+		return str;
+	}
+}
+/**
+* Bidirectional converter for GML (Graph Modelling Language) format.
+*
+* @example
+* ```ts
+* import { createGraph } from '@statelyai/graph';
+* import { gmlConverter } from '@statelyai/graph/formats/gml';
+*
+* const graph = createGraph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const gml = gmlConverter.to(graph);
+* const roundTripped = gmlConverter.from(gml);
+* ```
+*/
+const gmlConverter = createFormatConverter(toGML, fromGML);
+
+//#endregion
+export { fromGML, gmlConverter, toGML };

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

@@ -0,0 +1,9 @@
+import { c as Graph, f as GraphFormatConverter } from "../../types-BDXC1O5b.mjs";
+
+//#region src/formats/graphml/index.d.ts
+declare function toGraphML(graph: Graph): string;
+declare function fromGraphML(xml: string): Graph;
+/** Bidirectional converter for GraphML XML format. */
+declare const graphmlConverter: GraphFormatConverter<string>;
+//#endregion
+export { fromGraphML, graphmlConverter, toGraphML };

package/dist/{graphml-CUTNRXqd.mjs → formats/graphml/index.mjs}

@@ -1,6 +1,7 @@
+import { n as createFormatConverter } from "../../converter-CchokMDg.mjs";
 import { XMLBuilder, XMLParser } from "fast-xml-parser";
 
-//#region src/formats/graphml.ts
+//#region src/formats/graphml/index.ts
 const GRAPHML_NS = "http://graphml.graphdrawing.org/xmlns";
 function toGraphML(graph) {
 	const keys = [
@@ -174,7 +175,8 @@ function toGraphML(graph) {
 	}).build(obj);
 }
 function fromGraphML(xml) {
-	const graphEl = new XMLParser({
+	if (typeof xml !== "string") throw new Error("GraphML: expected a string");
+	const parser = new XMLParser({
 		ignoreAttributes: false,
 		isArray: (name) => [
 			"node",
@@ -182,7 +184,17 @@ function fromGraphML(xml) {
 			"data",
 			"key"
 		].includes(name)
-	}).parse(xml).graphml.graph;
+	});
+	let parsed;
+	try {
+		parsed = parser.parse(xml);
+	} catch (e) {
+		throw new Error(`GraphML: invalid XML — ${e.message}`);
+	}
+	const graphml = parsed?.graphml;
+	if (!graphml) throw new Error("GraphML: missing <graphml> root element");
+	const graphEl = graphml.graph;
+	if (!graphEl) throw new Error("GraphML: missing <graph> element");
 	const graphType = graphEl["@_edgedefault"] === "undirected" ? "undirected" : "directed";
 	let graphData = void 0;
 	if (graphEl.data) {
@@ -235,6 +247,8 @@ function tryParseJSON(str) {
 		return str;
 	}
 }
+/** Bidirectional converter for GraphML XML format. */
+const graphmlConverter = createFormatConverter(toGraphML, fromGraphML);
 
 //#endregion
-export { toGraphML as n, fromGraphML as t };
+export { fromGraphML, graphmlConverter, toGraphML };

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

@@ -0,0 +1,79 @@
+import { c as Graph, f as GraphFormatConverter } from "../../types-BDXC1O5b.mjs";
+
+//#region src/formats/jgf/index.d.ts
+interface JGFNode {
+  id: string;
+  label?: string;
+  metadata?: Record<string, any>;
+}
+interface JGFEdge {
+  id?: string;
+  source: string;
+  target: string;
+  label?: string;
+  metadata?: Record<string, any>;
+}
+interface JGFGraph {
+  graph: {
+    id?: string;
+    directed?: boolean;
+    metadata?: Record<string, any>;
+    nodes: JGFNode[];
+    edges: JGFEdge[];
+  };
+}
+/**
+ * Converts a graph to JSON Graph Format (JGF).
+ *
+ * @example
+ * ```ts
+ * import { createGraph } from '@statelyai/graph';
+ * import { toJGF } from '@statelyai/graph/formats/jgf';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const jgf = toJGF(graph);
+ * // { graph: { directed: true, nodes: [...], edges: [...] } }
+ * ```
+ */
+declare function toJGF(graph: Graph): JGFGraph;
+/**
+ * Parses a JSON Graph Format (JGF) object into a graph.
+ *
+ * @example
+ * ```ts
+ * import { fromJGF } from '@statelyai/graph/formats/jgf';
+ *
+ * const graph = fromJGF({
+ *   graph: {
+ *     directed: true,
+ *     nodes: [{ id: 'a' }, { id: 'b' }],
+ *     edges: [{ source: 'a', target: 'b' }],
+ *   },
+ * });
+ * ```
+ */
+declare function fromJGF(jgf: JGFGraph): Graph;
+/**
+ * Bidirectional converter for JSON Graph Format.
+ *
+ * @example
+ * ```ts
+ * import { createGraph } from '@statelyai/graph';
+ * import { jgfConverter } from '@statelyai/graph/formats/jgf';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const jgf = jgfConverter.to(graph);
+ * const roundTripped = jgfConverter.from(jgf);
+ * ```
+ */
+declare const jgfConverter: GraphFormatConverter<JGFGraph>;
+//#endregion
+export { JGFEdge, JGFGraph, JGFNode, fromJGF, jgfConverter, toJGF };

package/dist/formats/jgf/index.mjs

@@ -0,0 +1,134 @@
+import { n as createFormatConverter } from "../../converter-CchokMDg.mjs";
+
+//#region src/formats/jgf/index.ts
+/**
+* Converts a graph to JSON Graph Format (JGF).
+*
+* @example
+* ```ts
+* import { createGraph } from '@statelyai/graph';
+* import { toJGF } from '@statelyai/graph/formats/jgf';
+*
+* const graph = createGraph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const jgf = toJGF(graph);
+* // { graph: { directed: true, nodes: [...], edges: [...] } }
+* ```
+*/
+function toJGF(graph) {
+	const metadata = {};
+	if (graph.initialNodeId !== null) metadata.initialNodeId = graph.initialNodeId;
+	if (graph.data !== void 0) metadata.data = graph.data;
+	if (graph.direction) metadata.direction = graph.direction;
+	return { graph: {
+		id: graph.id || void 0,
+		directed: graph.type === "directed",
+		...Object.keys(metadata).length > 0 && { metadata },
+		nodes: graph.nodes.map((n) => {
+			const meta = {};
+			if (n.parentId !== null) meta.parentId = n.parentId;
+			if (n.initialNodeId !== null) meta.initialNodeId = n.initialNodeId;
+			if (n.data !== void 0) meta.data = n.data;
+			if (n.x !== void 0) meta.x = n.x;
+			if (n.y !== void 0) meta.y = n.y;
+			if (n.width !== void 0) meta.width = n.width;
+			if (n.height !== void 0) meta.height = n.height;
+			if (n.shape) meta.shape = n.shape;
+			if (n.color) meta.color = n.color;
+			return {
+				id: n.id,
+				...n.label && { label: n.label },
+				...Object.keys(meta).length > 0 && { metadata: meta }
+			};
+		}),
+		edges: graph.edges.map((e) => {
+			const meta = {};
+			if (e.data !== void 0) meta.data = e.data;
+			if (e.color) meta.color = e.color;
+			return {
+				id: e.id,
+				source: e.sourceId,
+				target: e.targetId,
+				...e.label && { label: e.label },
+				...Object.keys(meta).length > 0 && { metadata: meta }
+			};
+		})
+	} };
+}
+/**
+* Parses a JSON Graph Format (JGF) object into a graph.
+*
+* @example
+* ```ts
+* import { fromJGF } from '@statelyai/graph/formats/jgf';
+*
+* const graph = fromJGF({
+*   graph: {
+*     directed: true,
+*     nodes: [{ id: 'a' }, { id: 'b' }],
+*     edges: [{ source: 'a', target: 'b' }],
+*   },
+* });
+* ```
+*/
+function fromJGF(jgf) {
+	if (!jgf || typeof jgf !== "object") throw new Error("JGF: expected an object");
+	if (!jgf.graph || typeof jgf.graph !== "object") throw new Error("JGF: missing \"graph\" property");
+	const g = jgf.graph;
+	if (!Array.isArray(g.nodes)) throw new Error("JGF: \"graph.nodes\" must be an array");
+	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",
+		initialNodeId: g.metadata?.initialNodeId ?? null,
+		data: g.metadata?.data,
+		...g.metadata?.direction && { direction: g.metadata.direction },
+		nodes: g.nodes.map((n) => ({
+			type: "node",
+			id: n.id,
+			parentId: n.metadata?.parentId ?? null,
+			initialNodeId: n.metadata?.initialNodeId ?? null,
+			label: n.label ?? "",
+			data: n.metadata?.data,
+			...n.metadata?.x !== void 0 && { x: n.metadata.x },
+			...n.metadata?.y !== void 0 && { y: n.metadata.y },
+			...n.metadata?.width !== void 0 && { width: n.metadata.width },
+			...n.metadata?.height !== void 0 && { height: n.metadata.height },
+			...n.metadata?.shape && { shape: n.metadata.shape },
+			...n.metadata?.color && { color: n.metadata.color }
+		})),
+		edges: g.edges.map((e, i) => ({
+			type: "edge",
+			id: e.id ?? `e${i}`,
+			sourceId: e.source,
+			targetId: e.target,
+			label: e.label ?? "",
+			data: e.metadata?.data,
+			...e.metadata?.color && { color: e.metadata.color }
+		}))
+	};
+}
+/**
+* Bidirectional converter for JSON Graph Format.
+*
+* @example
+* ```ts
+* import { createGraph } from '@statelyai/graph';
+* import { jgfConverter } from '@statelyai/graph/formats/jgf';
+*
+* const graph = createGraph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const jgf = jgfConverter.to(graph);
+* const roundTripped = jgfConverter.from(jgf);
+* ```
+*/
+const jgfConverter = createFormatConverter(toJGF, fromJGF);
+
+//#endregion
+export { fromJGF, jgfConverter, toJGF };