@statelyai/graph 0.1.0 → 0.3.0

package/dist/formats/gml/index.mjs

@@ -0,0 +1,236 @@
+import { n as createFormatConverter } from "../../converter-DnbeyE_p.mjs";
+
+//#region src/formats/gml/index.ts
+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, "\\\"")}"`;
+}
+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. */
+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-B6Tpeerk.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-DnbeyE_p.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,30 @@
+import { c as Graph, f as GraphFormatConverter } from "../../types-B6Tpeerk.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[];
+  };
+}
+declare function toJGF(graph: Graph): JGFGraph;
+declare function fromJGF(jgf: JGFGraph): Graph;
+/** Bidirectional converter for JSON Graph Format. */
+declare const jgfConverter: GraphFormatConverter<JGFGraph>;
+//#endregion
+export { JGFEdge, JGFGraph, JGFNode, fromJGF, jgfConverter, toJGF };

package/dist/formats/jgf/index.mjs

@@ -0,0 +1,85 @@
+import { n as createFormatConverter } from "../../converter-DnbeyE_p.mjs";
+
+//#region src/formats/jgf/index.ts
+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 }
+			};
+		})
+	} };
+}
+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. */
+const jgfConverter = createFormatConverter(toJGF, fromJGF);
+
+//#endregion
+export { fromJGF, jgfConverter, toJGF };

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

@@ -0,0 +1,188 @@
+import { c as Graph, f as GraphFormatConverter } from "../../types-B6Tpeerk.mjs";
+
+//#region src/formats/mermaid/sequence.d.ts
+interface SequenceNodeData {
+  actorType: 'participant' | 'actor';
+  alias?: string;
+  created?: boolean;
+  destroyed?: boolean;
+}
+interface SequenceEdgeData {
+  kind: 'message' | 'activation' | 'deactivation';
+  stroke?: 'solid' | 'dotted';
+  arrowType?: 'filled' | 'open' | 'cross' | 'async';
+  bidirectional?: boolean;
+  sequenceNumber?: number;
+}
+type SequenceBlock = {
+  type: 'loop';
+  label: string;
+  edgeIds: string[];
+} | {
+  type: 'alt';
+  label: string;
+  branches: {
+    label?: string;
+    edgeIds: string[];
+  }[];
+} | {
+  type: 'opt';
+  label: string;
+  edgeIds: string[];
+} | {
+  type: 'par';
+  branches: {
+    label: string;
+    edgeIds: string[];
+  }[];
+} | {
+  type: 'critical';
+  label: string;
+  edgeIds: string[];
+  options?: {
+    label: string;
+    edgeIds: string[];
+  }[];
+} | {
+  type: 'break';
+  label: string;
+  edgeIds: string[];
+} | {
+  type: 'rect';
+  color: string;
+  edgeIds: string[];
+};
+interface SequenceGraphData {
+  diagramType: 'sequence';
+  autonumber?: boolean;
+  blocks?: SequenceBlock[];
+}
+type SequenceGraph = Graph<SequenceNodeData, SequenceEdgeData, SequenceGraphData>;
+declare function fromMermaidSequence(input: string): SequenceGraph;
+declare function toMermaidSequence(graph: SequenceGraph): string;
+/** Bidirectional converter for Mermaid sequence diagram format. */
+declare const mermaidSequenceConverter: GraphFormatConverter<string>;
+//#endregion
+//#region src/formats/mermaid/flowchart.d.ts
+interface FlowchartNodeData {
+  classes?: string[];
+  link?: string;
+  tooltip?: string;
+}
+interface FlowchartEdgeData {
+  stroke: 'normal' | 'dotted' | 'thick';
+  arrowType: 'arrow' | 'none';
+  endMarker?: 'arrow' | 'circle' | 'cross';
+  startMarker?: 'arrow' | 'circle' | 'cross';
+  bidirectional?: boolean;
+  styleIndex?: number;
+}
+interface FlowchartGraphData {
+  diagramType: 'flowchart';
+  classDefs?: Record<string, Record<string, string>>;
+}
+type FlowchartGraph = Graph<FlowchartNodeData, FlowchartEdgeData, FlowchartGraphData>;
+declare function fromMermaidFlowchart(input: string): FlowchartGraph;
+declare function toMermaidFlowchart(graph: FlowchartGraph): string;
+/** Bidirectional converter for Mermaid flowchart format. */
+declare const mermaidFlowchartConverter: GraphFormatConverter<string>;
+//#endregion
+//#region src/formats/mermaid/state.d.ts
+interface StateNodeData {
+  description?: string;
+  stateType?: 'choice' | 'fork' | 'join';
+  notes?: Array<{
+    position: 'left' | 'right';
+    text: string;
+  }>;
+  isStart?: boolean;
+  isEnd?: boolean;
+}
+interface StateEdgeData {}
+interface StateGraphData {
+  diagramType: 'stateDiagram';
+}
+type StateGraph = Graph<StateNodeData, StateEdgeData, StateGraphData>;
+declare function fromMermaidState(input: string): StateGraph;
+declare function toMermaidState(graph: StateGraph): string;
+/** Bidirectional converter for Mermaid state diagram format. */
+declare const mermaidStateConverter: GraphFormatConverter<string>;
+//#endregion
+//#region src/formats/mermaid/class-diagram.d.ts
+interface ClassNodeData {
+  members?: Array<{
+    visibility: '+' | '-' | '#' | '~';
+    name: string;
+    type?: string;
+    isMethod: boolean;
+  }>;
+  annotation?: string;
+  genericType?: string;
+}
+interface ClassEdgeData {
+  relationType: 'inheritance' | 'composition' | 'aggregation' | 'association' | 'dependency' | 'realization' | 'link' | 'dashed';
+  sourceCardinality?: string;
+  targetCardinality?: string;
+}
+interface ClassGraphData {
+  diagramType: 'classDiagram';
+}
+type ClassGraph = Graph<ClassNodeData, ClassEdgeData, ClassGraphData>;
+declare function fromMermaidClass(input: string): ClassGraph;
+declare function toMermaidClass(graph: ClassGraph): string;
+/** Bidirectional converter for Mermaid class diagram format. */
+declare const mermaidClassConverter: GraphFormatConverter<string>;
+//#endregion
+//#region src/formats/mermaid/er-diagram.d.ts
+interface ERNodeData {
+  attributes?: Array<{
+    type: string;
+    name: string;
+    key?: 'PK' | 'FK' | 'UK';
+    comment?: string;
+  }>;
+}
+interface EREdgeData {
+  sourceCardinality: 'one' | 'zero-or-one' | 'zero-or-more' | 'one-or-more';
+  targetCardinality: 'one' | 'zero-or-one' | 'zero-or-more' | 'one-or-more';
+  identifying: boolean;
+}
+interface ERGraphData {
+  diagramType: 'erDiagram';
+}
+type ERGraph = Graph<ERNodeData, EREdgeData, ERGraphData>;
+declare function fromMermaidER(input: string): ERGraph;
+declare function toMermaidER(graph: ERGraph): string;
+/** Bidirectional converter for Mermaid ER diagram format. */
+declare const mermaidERConverter: GraphFormatConverter<string>;
+//#endregion
+//#region src/formats/mermaid/mindmap.d.ts
+interface MindmapNodeData {
+  icon?: string;
+}
+interface MindmapEdgeData {}
+interface MindmapGraphData {
+  diagramType: 'mindmap';
+}
+type MindmapGraph = Graph<MindmapNodeData, MindmapEdgeData, MindmapGraphData>;
+declare function fromMermaidMindmap(input: string): MindmapGraph;
+declare function toMermaidMindmap(graph: MindmapGraph): string;
+/** Bidirectional converter for Mermaid mindmap format. */
+declare const mermaidMindmapConverter: GraphFormatConverter<string>;
+//#endregion
+//#region src/formats/mermaid/block.d.ts
+interface BlockNodeData {
+  span?: number;
+}
+interface BlockEdgeData {}
+interface BlockGraphData {
+  diagramType: 'block';
+  columns?: number;
+}
+type BlockGraph = Graph<BlockNodeData, BlockEdgeData, BlockGraphData>;
+declare function fromMermaidBlock(input: string): BlockGraph;
+declare function toMermaidBlock(graph: BlockGraph): string;
+/** Bidirectional converter for Mermaid block diagram format. */
+declare const mermaidBlockConverter: GraphFormatConverter<string>;
+//#endregion
+export { type BlockEdgeData, type BlockGraphData, type BlockNodeData, type ClassEdgeData, type ClassGraphData, type ClassNodeData, type EREdgeData, type ERGraphData, type ERNodeData, type FlowchartEdgeData, type FlowchartGraphData, type FlowchartNodeData, type MindmapEdgeData, type MindmapGraphData, type MindmapNodeData, type SequenceBlock, type SequenceEdgeData, type SequenceGraphData, type SequenceNodeData, type StateEdgeData, type StateGraphData, type StateNodeData, fromMermaidBlock, fromMermaidClass, fromMermaidER, fromMermaidFlowchart, fromMermaidMindmap, fromMermaidSequence, fromMermaidState, mermaidBlockConverter, mermaidClassConverter, mermaidERConverter, mermaidFlowchartConverter, mermaidMindmapConverter, mermaidSequenceConverter, mermaidStateConverter, toMermaidBlock, toMermaidClass, toMermaidER, toMermaidFlowchart, toMermaidMindmap, toMermaidSequence, toMermaidState };