@statelyai/graph 0.1.0 → 0.3.1

package/dist/edge-list-CgX6bBIF.mjs

@@ -0,0 +1,71 @@
+//#region src/formats/edge-list/index.ts
+/**
+* Converts a graph to an edge list of `[source, target]` tuples.
+*
+* @example
+* ```ts
+* import { createGraph, toEdgeList } from '@statelyai/graph';
+*
+* const graph = createGraph({
+*   nodes: { a: {}, b: {}, c: {} },
+*   edges: [{ source: 'a', target: 'b' }, { source: 'b', target: 'c' }],
+* });
+*
+* toEdgeList(graph);
+* // [['a', 'b'], ['b', 'c']]
+* ```
+*/
+function toEdgeList(graph) {
+	return graph.edges.map((e) => [e.sourceId, e.targetId]);
+}
+/**
+* Parses an edge list of `[source, target]` tuples into a graph.
+*
+* @example
+* ```ts
+* import { fromEdgeList } from '@statelyai/graph';
+*
+* const graph = fromEdgeList([
+*   ['a', 'b'],
+*   ['b', 'c'],
+* ]);
+*
+* graph.nodes; // [{id: 'a', ...}, {id: 'b', ...}, {id: 'c', ...}]
+* graph.edges; // [{sourceId: 'a', targetId: 'b', ...}, ...]
+* ```
+*/
+function fromEdgeList(edges, options) {
+	const directed = options?.directed ?? true;
+	const nodeIds = /* @__PURE__ */ new Set();
+	for (const [source, target] of edges) {
+		nodeIds.add(source);
+		nodeIds.add(target);
+	}
+	const nodes = [...nodeIds].map((id) => ({
+		type: "node",
+		id,
+		parentId: null,
+		initialNodeId: null,
+		label: "",
+		data: void 0
+	}));
+	const edgeObjects = edges.map(([sourceId, targetId], i) => ({
+		type: "edge",
+		id: `e${i}`,
+		sourceId,
+		targetId,
+		label: "",
+		data: void 0
+	}));
+	return {
+		id: options?.id ?? "",
+		type: directed ? "directed" : "undirected",
+		initialNodeId: null,
+		nodes,
+		edges: edgeObjects,
+		data: void 0
+	};
+}
+
+//#endregion
+export { toEdgeList as n, fromEdgeList as t };

package/dist/formats/adjacency-list/index.d.mts

@@ -0,0 +1,44 @@
+import { c as Graph } from "../../types-BDXC1O5b.mjs";
+
+//#region src/formats/adjacency-list/index.d.ts
+
+/**
+ * Converts a graph to an adjacency list representation.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, toAdjacencyList } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: { a: {}, b: {}, c: {} },
+ *   edges: [{ source: 'a', target: 'b' }, { source: 'a', target: 'c' }],
+ * });
+ *
+ * toAdjacencyList(graph);
+ * // { a: ['b', 'c'], b: [], c: [] }
+ * ```
+ */
+declare function toAdjacencyList(graph: Graph): Record<string, string[]>;
+/**
+ * Parses an adjacency list into a graph.
+ *
+ * @example
+ * ```ts
+ * import { fromAdjacencyList } from '@statelyai/graph';
+ *
+ * const graph = fromAdjacencyList({
+ *   a: ['b', 'c'],
+ *   b: ['c'],
+ *   c: [],
+ * });
+ *
+ * graph.nodes; // [{id: 'a', ...}, {id: 'b', ...}, {id: 'c', ...}]
+ * graph.edges; // [{sourceId: 'a', targetId: 'b', ...}, ...]
+ * ```
+ */
+declare function fromAdjacencyList(adj: Record<string, string[]>, options?: {
+  directed?: boolean;
+  id?: string;
+}): Graph;
+//#endregion
+export { fromAdjacencyList, toAdjacencyList };

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

@@ -0,0 +1,3 @@
+import { n as toAdjacencyList, t as fromAdjacencyList } from "../../adjacency-list-ITO40kmn.mjs";
+
+export { fromAdjacencyList, toAdjacencyList };

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

@@ -0,0 +1,61 @@
+import { c as Graph, f as GraphFormatConverter } from "../../types-BDXC1O5b.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>(to: (graph: Graph) => TSerial, from: (input: TSerial) => Graph): GraphFormatConverter<TSerial>;
+/**
+ * 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 { adjacencyListConverter, createFormatConverter, edgeListConverter };

package/dist/formats/converter/index.mjs

@@ -0,0 +1,3 @@
+import { n as createFormatConverter, r as edgeListConverter, t as adjacencyListConverter } from "../../converter-CchokMDg.mjs";
+
+export { adjacencyListConverter, createFormatConverter, edgeListConverter };

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

@@ -0,0 +1,83 @@
+import { c as Graph, f as GraphFormatConverter } from "../../types-BDXC1O5b.mjs";
+
+//#region src/formats/cytoscape/index.d.ts
+interface CytoscapeNode {
+  data: {
+    id: string;
+    parent?: string;
+    [key: string]: any;
+  };
+  position?: {
+    x: number;
+    y: number;
+  };
+}
+interface CytoscapeEdge {
+  data: {
+    id: string;
+    source: string;
+    target: string;
+    [key: string]: any;
+  };
+}
+interface CytoscapeJSON {
+  data?: Record<string, any>;
+  elements: {
+    nodes: CytoscapeNode[];
+    edges: CytoscapeEdge[];
+  };
+}
+/**
+ * Converts a graph to Cytoscape.js JSON format.
+ *
+ * @example
+ * ```ts
+ * import { createGraph } from '@statelyai/graph';
+ * import { toCytoscapeJSON } from '@statelyai/graph/formats/cytoscape';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const cyto = toCytoscapeJSON(graph);
+ * // { elements: { nodes: [...], edges: [...] } }
+ * ```
+ */
+declare function toCytoscapeJSON(graph: Graph): CytoscapeJSON;
+/**
+ * Parses a Cytoscape.js JSON object into a graph.
+ *
+ * @example
+ * ```ts
+ * import { fromCytoscapeJSON } from '@statelyai/graph/formats/cytoscape';
+ *
+ * const graph = fromCytoscapeJSON({
+ *   elements: {
+ *     nodes: [{ data: { id: 'a' } }, { data: { id: 'b' } }],
+ *     edges: [{ data: { id: 'e0', source: 'a', target: 'b' } }],
+ *   },
+ * });
+ * ```
+ */
+declare function fromCytoscapeJSON(cyto: CytoscapeJSON): Graph;
+/**
+ * Bidirectional converter for Cytoscape.js JSON format.
+ *
+ * @example
+ * ```ts
+ * import { createGraph } from '@statelyai/graph';
+ * import { cytoscapeConverter } from '@statelyai/graph/formats/cytoscape';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const cyto = cytoscapeConverter.to(graph);
+ * const roundTripped = cytoscapeConverter.from(cyto);
+ * ```
+ */
+declare const cytoscapeConverter: GraphFormatConverter<CytoscapeJSON>;
+//#endregion
+export { CytoscapeEdge, CytoscapeJSON, CytoscapeNode, cytoscapeConverter, fromCytoscapeJSON, toCytoscapeJSON };

package/dist/formats/cytoscape/index.mjs

@@ -0,0 +1,135 @@
+import { n as createFormatConverter } from "../../converter-CchokMDg.mjs";
+
+//#region src/formats/cytoscape/index.ts
+/**
+* Converts a graph to Cytoscape.js JSON format.
+*
+* @example
+* ```ts
+* import { createGraph } from '@statelyai/graph';
+* import { toCytoscapeJSON } from '@statelyai/graph/formats/cytoscape';
+*
+* const graph = createGraph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const cyto = toCytoscapeJSON(graph);
+* // { elements: { nodes: [...], edges: [...] } }
+* ```
+*/
+function toCytoscapeJSON(graph) {
+	const graphData = {};
+	if (graph.id) graphData.id = graph.id;
+	graphData.type = graph.type;
+	if (graph.initialNodeId !== null) graphData.initialNodeId = graph.initialNodeId;
+	if (graph.data !== void 0) graphData.graphData = graph.data;
+	if (graph.direction) graphData.direction = graph.direction;
+	return {
+		...Object.keys(graphData).length > 0 && { data: graphData },
+		elements: {
+			nodes: graph.nodes.map((n) => {
+				const data = { id: n.id };
+				if (n.parentId !== null) data.parent = n.parentId;
+				if (n.label) data.label = n.label;
+				if (n.initialNodeId !== null) data.initialNodeId = n.initialNodeId;
+				if (n.data !== void 0) data.nodeData = n.data;
+				if (n.width !== void 0) data.width = n.width;
+				if (n.height !== void 0) data.height = n.height;
+				if (n.shape) data.shape = n.shape;
+				if (n.color) data.color = n.color;
+				const node = { data };
+				if (n.x !== void 0 && n.y !== void 0) node.position = {
+					x: n.x,
+					y: n.y
+				};
+				return node;
+			}),
+			edges: graph.edges.map((e) => {
+				const data = {
+					id: e.id,
+					source: e.sourceId,
+					target: e.targetId
+				};
+				if (e.label) data.label = e.label;
+				if (e.data !== void 0) data.edgeData = e.data;
+				if (e.color) data.color = e.color;
+				return { data };
+			})
+		}
+	};
+}
+/**
+* Parses a Cytoscape.js JSON object into a graph.
+*
+* @example
+* ```ts
+* import { fromCytoscapeJSON } from '@statelyai/graph/formats/cytoscape';
+*
+* const graph = fromCytoscapeJSON({
+*   elements: {
+*     nodes: [{ data: { id: 'a' } }, { data: { id: 'b' } }],
+*     edges: [{ data: { id: 'e0', source: 'a', target: 'b' } }],
+*   },
+* });
+* ```
+*/
+function fromCytoscapeJSON(cyto) {
+	if (!cyto || typeof cyto !== "object") throw new Error("Cytoscape: expected an object");
+	if (!cyto.elements || typeof cyto.elements !== "object") throw new Error("Cytoscape: missing \"elements\" property");
+	if (!Array.isArray(cyto.elements.nodes)) throw new Error("Cytoscape: \"elements.nodes\" must be an array");
+	if (!Array.isArray(cyto.elements.edges)) throw new Error("Cytoscape: \"elements.edges\" must be an array");
+	return {
+		id: cyto.data?.id ?? "",
+		type: cyto.data?.type === "undirected" ? "undirected" : "directed",
+		initialNodeId: cyto.data?.initialNodeId ?? null,
+		data: cyto.data?.graphData,
+		...cyto.data?.direction && { direction: cyto.data.direction },
+		nodes: cyto.elements.nodes.map((n) => ({
+			type: "node",
+			id: n.data.id,
+			parentId: n.data.parent ?? null,
+			initialNodeId: n.data.initialNodeId ?? null,
+			label: n.data.label ?? "",
+			data: n.data.nodeData,
+			...n.position && {
+				x: n.position.x,
+				y: n.position.y
+			},
+			...n.data.width !== void 0 && { width: n.data.width },
+			...n.data.height !== void 0 && { height: n.data.height },
+			...n.data.shape && { shape: n.data.shape },
+			...n.data.color && { color: n.data.color }
+		})),
+		edges: cyto.elements.edges.map((e, i) => ({
+			type: "edge",
+			id: e.data.id ?? `e${i}`,
+			sourceId: e.data.source,
+			targetId: e.data.target,
+			label: e.data.label ?? "",
+			data: e.data.edgeData,
+			...e.data.color && { color: e.data.color }
+		}))
+	};
+}
+/**
+* Bidirectional converter for Cytoscape.js JSON format.
+*
+* @example
+* ```ts
+* import { createGraph } from '@statelyai/graph';
+* import { cytoscapeConverter } from '@statelyai/graph/formats/cytoscape';
+*
+* const graph = createGraph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const cyto = cytoscapeConverter.to(graph);
+* const roundTripped = cytoscapeConverter.from(cyto);
+* ```
+*/
+const cytoscapeConverter = createFormatConverter(toCytoscapeJSON, fromCytoscapeJSON);
+
+//#endregion
+export { cytoscapeConverter, fromCytoscapeJSON, toCytoscapeJSON };

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

@@ -0,0 +1,68 @@
+import { c as Graph, f as GraphFormatConverter } from "../../types-BDXC1O5b.mjs";
+
+//#region src/formats/d3/index.d.ts
+interface D3Node {
+  id: string;
+  [key: string]: any;
+}
+interface D3Link {
+  source: string;
+  target: string;
+  [key: string]: any;
+}
+interface D3Graph {
+  nodes: D3Node[];
+  links: D3Link[];
+}
+/**
+ * Converts a graph to D3.js force-directed format.
+ *
+ * @example
+ * ```ts
+ * import { createGraph } from '@statelyai/graph';
+ * import { toD3Graph } from '@statelyai/graph/formats/d3';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const d3 = toD3Graph(graph);
+ * // { nodes: [{ id: 'a' }, { id: 'b' }], links: [{ source: 'a', target: 'b' }] }
+ * ```
+ */
+declare function toD3Graph(graph: Graph): D3Graph;
+/**
+ * Parses a D3.js force-directed JSON object into a graph.
+ *
+ * @example
+ * ```ts
+ * import { fromD3Graph } from '@statelyai/graph/formats/d3';
+ *
+ * const graph = fromD3Graph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   links: [{ source: 'a', target: 'b' }],
+ * });
+ * ```
+ */
+declare function fromD3Graph(d3: D3Graph): Graph;
+/**
+ * Bidirectional converter for D3.js force-directed JSON format.
+ *
+ * @example
+ * ```ts
+ * import { createGraph } from '@statelyai/graph';
+ * import { d3Converter } from '@statelyai/graph/formats/d3';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const d3 = d3Converter.to(graph);
+ * const roundTripped = d3Converter.from(d3);
+ * ```
+ */
+declare const d3Converter: GraphFormatConverter<D3Graph>;
+//#endregion
+export { D3Graph, D3Link, D3Node, d3Converter, fromD3Graph, toD3Graph };

package/dist/formats/d3/index.mjs

@@ -0,0 +1,111 @@
+import { n as createFormatConverter } from "../../converter-CchokMDg.mjs";
+
+//#region src/formats/d3/index.ts
+/**
+* Converts a graph to D3.js force-directed format.
+*
+* @example
+* ```ts
+* import { createGraph } from '@statelyai/graph';
+* import { toD3Graph } from '@statelyai/graph/formats/d3';
+*
+* const graph = createGraph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const d3 = toD3Graph(graph);
+* // { nodes: [{ id: 'a' }, { id: 'b' }], links: [{ source: 'a', target: 'b' }] }
+* ```
+*/
+function toD3Graph(graph) {
+	return {
+		nodes: graph.nodes.map((n) => {
+			const node = { id: n.id };
+			if (n.label) node.label = n.label;
+			if (n.data !== void 0) node.data = n.data;
+			if (n.x !== void 0) node.x = n.x;
+			if (n.y !== void 0) node.y = n.y;
+			if (n.color) node.color = n.color;
+			if (n.shape) node.shape = n.shape;
+			return node;
+		}),
+		links: graph.edges.map((e) => {
+			const link = {
+				source: e.sourceId,
+				target: e.targetId
+			};
+			if (e.id) link.id = e.id;
+			if (e.label) link.label = e.label;
+			if (e.data !== void 0) link.data = e.data;
+			if (e.color) link.color = e.color;
+			return link;
+		})
+	};
+}
+/**
+* Parses a D3.js force-directed JSON object into a graph.
+*
+* @example
+* ```ts
+* import { fromD3Graph } from '@statelyai/graph/formats/d3';
+*
+* const graph = fromD3Graph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   links: [{ source: 'a', target: 'b' }],
+* });
+* ```
+*/
+function fromD3Graph(d3) {
+	if (!d3 || typeof d3 !== "object") throw new Error("D3: expected an object");
+	if (!Array.isArray(d3.nodes)) throw new Error("D3: \"nodes\" must be an array");
+	if (!Array.isArray(d3.links)) throw new Error("D3: \"links\" must be an array");
+	return {
+		id: "",
+		type: "directed",
+		initialNodeId: null,
+		data: void 0,
+		nodes: d3.nodes.map((n) => ({
+			type: "node",
+			id: n.id,
+			parentId: null,
+			initialNodeId: null,
+			label: n.label ?? "",
+			data: n.data,
+			...n.x !== void 0 && { x: n.x },
+			...n.y !== void 0 && { y: n.y },
+			...n.color && { color: n.color },
+			...n.shape && { shape: n.shape }
+		})),
+		edges: d3.links.map((l, i) => ({
+			type: "edge",
+			id: l.id ?? `e${i}`,
+			sourceId: typeof l.source === "string" ? l.source : l.source.id,
+			targetId: typeof l.target === "string" ? l.target : l.target.id,
+			label: l.label ?? "",
+			data: l.data,
+			...l.color && { color: l.color }
+		}))
+	};
+}
+/**
+* Bidirectional converter for D3.js force-directed JSON format.
+*
+* @example
+* ```ts
+* import { createGraph } from '@statelyai/graph';
+* import { d3Converter } from '@statelyai/graph/formats/d3';
+*
+* const graph = createGraph({
+*   nodes: [{ id: 'a' }, { id: 'b' }],
+*   edges: [{ id: 'e0', sourceId: 'a', targetId: 'b' }],
+* });
+*
+* const d3 = d3Converter.to(graph);
+* const roundTripped = d3Converter.from(d3);
+* ```
+*/
+const d3Converter = createFormatConverter(toD3Graph, fromD3Graph);
+
+//#endregion
+export { d3Converter, fromD3Graph, toD3Graph };

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

@@ -0,0 +1,63 @@
+import { c as Graph, f as GraphFormatConverter } from "../../types-BDXC1O5b.mjs";
+
+//#region src/formats/dot/index.d.ts
+
+/**
+ * Converts a graph to a DOT (Graphviz) format string.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, toDOT } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: { a: {}, b: {} },
+ *   edges: [{ source: 'a', target: 'b' }],
+ * });
+ *
+ * const dot = toDOT(graph);
+ * // digraph "" {
+ * //   a;
+ * //   b;
+ * //   a -> b;
+ * // }
+ * ```
+ */
+declare function toDOT(graph: Graph): string;
+/**
+ * Parses a DOT (Graphviz) format string into a graph.
+ *
+ * @example
+ * ```ts
+ * import { fromDOT } from '@statelyai/graph';
+ *
+ * const graph = fromDOT(`
+ *   digraph {
+ *     a -> b;
+ *     b -> c;
+ *   }
+ * `);
+ *
+ * graph.nodes; // [{id: 'a', ...}, {id: 'b', ...}, {id: 'c', ...}]
+ * graph.edges; // [{sourceId: 'a', targetId: 'b', ...}, ...]
+ * ```
+ */
+declare function fromDOT(dot: string): Graph;
+/**
+ * Bidirectional converter for DOT (Graphviz) format.
+ *
+ * @example
+ * ```ts
+ * import { dotConverter, createGraph } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: { a: {}, b: {} },
+ *   edges: [{ source: 'a', target: 'b' }],
+ * });
+ *
+ * const dot = dotConverter.to(graph);
+ * const roundTripped = dotConverter.from(dot);
+ * ```
+ */
+declare const dotConverter: GraphFormatConverter<string>;
+//#endregion
+export { dotConverter, fromDOT, toDOT };