@statelyai/graph 0.5.0 → 0.7.0

package/dist/algorithms.d.mts

@@ -1,10 +1,12 @@
-import { C as TraversalOptions, _ as MSTOptions, b as PathOptions, c as Graph, h as GraphPath, p as GraphNode, t as AllPairsShortestPathsOptions, x as SinglePathOptions } from "./types-FBZCrmnG.mjs";
+import { C as SinglePathOptions, S as PathOptions, T as TraversalOptions, _ as GraphPath, h as GraphNode, n as AllPairsShortestPathsOptions, t as AStarOptions, u as Graph, y as MSTOptions } from "./types-DkKjaQW3.mjs";
 
 //#region src/algorithms.d.ts
 
 /**
  * Breadth-first traversal generator yielding nodes level by level.
  *
+ * **O(V + E)** time, **O(V)** space.
+ *
  * @example
  * ```ts
  * import { createGraph, bfs } from '@statelyai/graph';
@@ -23,6 +25,8 @@ declare function bfs<N>(graph: Graph<N>, startId: string): Generator<GraphNode<N
 /**
  * Depth-first traversal generator yielding nodes as visited.
  *
+ * **O(V + E)** time, **O(V)** space.
+ *
  * @example
  * ```ts
  * import { createGraph, dfs } from '@statelyai/graph';
@@ -41,6 +45,8 @@ declare function dfs<N>(graph: Graph<N>, startId: string): Generator<GraphNode<N
 /**
  * Checks whether the graph contains no cycles.
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, isAcyclic } from '@statelyai/graph';
@@ -58,6 +64,8 @@ declare function isAcyclic(graph: Graph): boolean;
  * Returns connected components as arrays of nodes.
  * Treats all edges as undirected for connectivity.
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, getConnectedComponents } from '@statelyai/graph';
@@ -75,6 +83,8 @@ declare function getConnectedComponents<N>(graph: Graph<N>): GraphNode<N>[][];
 /**
  * Returns a topological ordering of nodes, or `null` if the graph is cyclic.
  *
+ * **O(V + E)** time (Kahn's algorithm).
+ *
  * @example
  * ```ts
  * import { createGraph, getTopologicalSort } from '@statelyai/graph';
@@ -95,6 +105,8 @@ declare function getTopologicalSort<N>(graph: Graph<N>): GraphNode<N>[] | null;
 /**
  * Checks whether a path exists between two nodes.
  *
+ * **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted).
+ *
  * @example
  * ```ts
  * import { createGraph, hasPath } from '@statelyai/graph';
@@ -112,6 +124,8 @@ declare function hasPath(graph: Graph, sourceId: string, targetId: string): bool
 /**
  * Checks whether the graph is connected (all nodes reachable from any node).
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, isConnected } from '@statelyai/graph';
@@ -128,6 +142,8 @@ declare function isConnected(graph: Graph): boolean;
 /**
  * Checks whether the graph is a tree (connected and acyclic).
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, isTree } from '@statelyai/graph';
@@ -148,6 +164,9 @@ declare function isTree(graph: Graph): boolean;
  * Lazily yields all shortest paths from a source node.
  * Use `getShortestPaths` for the full array.
  *
+ * **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted),
+ * plus **O(P)** per path yielded where P is the path length.
+ *
  * @example
  * ```ts
  * import { createGraph, genShortestPaths } from '@statelyai/graph';
@@ -171,6 +190,8 @@ declare function genShortestPaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E
  * Returns all shortest paths from a source node as an array.
  * Delegates to `genShortestPaths` internally.
  *
+ * **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted).
+ *
  * @example
  * ```ts
  * import { createGraph, getShortestPaths } from '@statelyai/graph';
@@ -192,6 +213,8 @@ declare function getShortestPaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E
 /**
  * Returns a single shortest path from source to target, or `undefined` if unreachable.
  *
+ * **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted).
+ *
  * @example
  * ```ts
  * import { createGraph, getShortestPath } from '@statelyai/graph';
@@ -214,6 +237,8 @@ declare function getShortestPath<N, E>(graph: Graph<N, E>, opts: SinglePathOptio
  * Returns all simple (acyclic) paths from a source node as an array.
  * Delegates to `genSimplePaths` internally.
  *
+ * **O(V!)** worst-case (exponential in dense graphs).
+ *
  * @example
  * ```ts
  * import { createGraph, getSimplePaths } from '@statelyai/graph';
@@ -237,6 +262,8 @@ declare function getSimplePaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E>)
  * Lazily yields all simple (acyclic) paths from a source node via DFS backtracking.
  * Use `getSimplePaths` for the full array.
  *
+ * **O(V!)** worst-case (exponential in dense graphs).
+ *
  * @example
  * ```ts
  * import { createGraph, genSimplePaths } from '@statelyai/graph';
@@ -261,6 +288,8 @@ declare function genSimplePaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E>)
 /**
  * Returns a single simple (acyclic) path from source to target, or `undefined` if unreachable.
  *
+ * **O(V + E)** typical, **O(V!)** worst-case.
+ *
  * @example
  * ```ts
  * import { createGraph, getSimplePath } from '@statelyai/graph';
@@ -283,6 +312,8 @@ declare function getSimplePath<N, E>(graph: Graph<N, E>, opts: SinglePathOptions
  * Returns strongly connected components using Tarjan's algorithm.
  * Only meaningful for directed graphs.
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, getStronglyConnectedComponents } from '@statelyai/graph';
@@ -305,6 +336,8 @@ declare function getStronglyConnectedComponents<N>(graph: Graph<N>): GraphNode<N
  * Returns all elementary cycles as an array of paths.
  * Delegates to `genCycles` internally.
  *
+ * **O((V + E) · C)** where C is the number of elementary cycles (can be exponential).
+ *
  * @example
  * ```ts
  * import { createGraph, getCycles } from '@statelyai/graph';
@@ -326,6 +359,8 @@ declare function getCycles<N, E>(graph: Graph<N, E>): GraphPath<N, E>[];
  * Lazily yields elementary cycles one at a time.
  * Use `getCycles` for the full array.
  *
+ * **O((V + E) · C)** where C is the number of elementary cycles (can be exponential).
+ *
  * @example
  * ```ts
  * import { createGraph, genCycles } from '@statelyai/graph';
@@ -348,6 +383,8 @@ declare function genCycles<N, E>(graph: Graph<N, E>): Generator<GraphPath<N, E>>
  * Returns a single canonical preorder (DFS visit-order) sequence.
  * Visits neighbors in the order they appear in the adjacency list.
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, getPreorder } from '@statelyai/graph';
@@ -370,6 +407,8 @@ declare function getPreorder<N>(graph: Graph<N>, opts?: TraversalOptions): Graph
  * Returns a single canonical postorder (DFS finish-order) sequence.
  * Visits neighbors in the order they appear in the adjacency list.
  *
+ * **O(V + E)** time.
+ *
  * @example
  * ```ts
  * import { createGraph, getPostorder } from '@statelyai/graph';
@@ -391,6 +430,8 @@ declare function getPostorder<N>(graph: Graph<N>, opts?: TraversalOptions): Grap
 /**
  * Returns all possible preorder sequences as an array. Can be exponential -- prefer `genPreorders`.
  *
+ * **O(V! · V)** worst-case (exponential).
+ *
  * @example
  * ```ts
  * import { createGraph, getPreorders } from '@statelyai/graph';
@@ -412,6 +453,8 @@ declare function getPreorders<N>(graph: Graph<N>, opts?: TraversalOptions): Grap
 /**
  * Returns all possible postorder sequences as an array. Can be exponential -- prefer `genPostorders`.
  *
+ * **O(V! · V)** worst-case (exponential).
+ *
  * @example
  * ```ts
  * import { createGraph, getPostorders } from '@statelyai/graph';
@@ -435,6 +478,8 @@ declare function getPostorders<N>(graph: Graph<N>, opts?: TraversalOptions): Gra
  * Different neighbor exploration orders yield different sequences.
  * Use `getPreorder()` for a single canonical ordering.
  *
+ * **O(V! · V)** worst-case (exponential).
+ *
  * @example
  * ```ts
  * import { createGraph, genPreorders } from '@statelyai/graph';
@@ -460,6 +505,8 @@ declare function genPreorders<N>(graph: Graph<N>, opts?: TraversalOptions): Gene
  * Different neighbor exploration orders yield different sequences.
  * Use `getPostorder()` for a single canonical ordering.
  *
+ * **O(V! · V)** worst-case (exponential).
+ *
  * @example
  * ```ts
  * import { createGraph, genPostorders } from '@statelyai/graph';
@@ -485,6 +532,8 @@ declare function genPostorders<N>(graph: Graph<N>, opts?: TraversalOptions): Gen
  * Only meaningful for connected undirected graphs (or the component reachable
  * from an arbitrary start node in directed graphs).
  *
+ * **O(E log E)** using either edge sorting (Kruskal) or a min-heap (Prim).
+ *
  * @example
  * ```ts
  * import { createGraph, getMinimumSpanningTree } from '@statelyai/graph';
@@ -509,7 +558,9 @@ declare function getMinimumSpanningTree<N, E>(graph: Graph<N, E>, opts?: MSTOpti
 /**
  * Returns shortest paths between all pairs of nodes.
  * Algorithm 'dijkstra' (default): runs getShortestPaths per source node.
- * Algorithm 'floyd-warshall': classic O(V^3) dynamic programming.
+ * Algorithm 'floyd-warshall': classic dynamic programming.
+ *
+ * **O(V · (V + E) log V)** (Dijkstra) or **O(V³)** (Floyd-Warshall).
  *
  * @example
  * ```ts
@@ -528,6 +579,43 @@ declare function getMinimumSpanningTree<N, E>(graph: Graph<N, E>, opts?: MSTOpti
  * ```
  */
 declare function getAllPairsShortestPaths<N, E>(graph: Graph<N, E>, opts?: AllPairsShortestPathsOptions<E>): GraphPath<N, E>[];
+/**
+ * Returns a shortest path using A* search with an admissible heuristic.
+ * More efficient than Dijkstra when a good heuristic is available.
+ *
+ * **O((V + E) log V)** time with a good heuristic; degrades to Dijkstra
+ * with `heuristic: () => 0`.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getAStarPath } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'a', x: 0, y: 0 },
+ *     { id: 'b', x: 1, y: 0 },
+ *     { id: 'c', x: 1, y: 1 },
+ *   ],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b', weight: 1 },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c', weight: 1 },
+ *     { id: 'ac', sourceId: 'a', targetId: 'c', weight: 3 },
+ *   ],
+ * });
+ *
+ * const path = getAStarPath(graph, {
+ *   from: 'a',
+ *   to: 'c',
+ *   heuristic: (nodeId) => {
+ *     const node = graph.nodes.find(n => n.id === nodeId)!;
+ *     const target = graph.nodes.find(n => n.id === 'c')!;
+ *     return Math.abs(node.x! - target.x!) + Math.abs(node.y! - target.y!);
+ *   },
+ * });
+ * // path: a -> b -> c (weight 2, cheaper than direct a -> c)
+ * ```
+ */
+declare function getAStarPath<N, E>(graph: Graph<N, E>, opts: AStarOptions<E>): GraphPath<N, E> | undefined;
 /**
  * Joins two paths end-to-end. The last node of the head path must equal
  * the source of the tail path (the overlap node).
@@ -556,4 +644,4 @@ declare function getAllPairsShortestPaths<N, E>(graph: Graph<N, E>, opts?: AllPa
  */
 declare function joinPaths<N, E>(headPath: GraphPath<N, E>, tailPath: GraphPath<N, E>): GraphPath<N, E>;
 //#endregion
-export { bfs, dfs, genCycles, genPostorders, genPreorders, genShortestPaths, genSimplePaths, getAllPairsShortestPaths, getConnectedComponents, getCycles, getMinimumSpanningTree, getPostorder, getPostorders, getPreorder, getPreorders, getShortestPath, getShortestPaths, getSimplePath, getSimplePaths, getStronglyConnectedComponents, getTopologicalSort, hasPath, isAcyclic, isConnected, isTree, joinPaths };
+export { bfs, dfs, genCycles, genPostorders, genPreorders, genShortestPaths, genSimplePaths, getAStarPath, getAllPairsShortestPaths, getConnectedComponents, getCycles, getMinimumSpanningTree, getPostorder, getPostorders, getPreorder, getPreorders, getShortestPath, getShortestPaths, getSimplePath, getSimplePaths, getStronglyConnectedComponents, getTopologicalSort, hasPath, isAcyclic, isConnected, isTree, joinPaths };

package/dist/algorithms.mjs

@@ -1,3 +1,3 @@
-import { C as isAcyclic, E as joinPaths, S as hasPath, T as isTree, _ as getShortestPaths, a as genPreorders, b as getStronglyConnectedComponents, c as getAllPairsShortestPaths, d as getMinimumSpanningTree, f as getPostorder, g as getShortestPath, h as getPreorders, i as genPostorders, l as getConnectedComponents, m as getPreorder, n as dfs, o as genShortestPaths, p as getPostorders, r as genCycles, s as genSimplePaths, t as bfs, u as getCycles, v as getSimplePath, w as isConnected, x as getTopologicalSort, y as getSimplePaths } from "./algorithms-DldwenLt.mjs";
+import { C as hasPath, D as joinPaths, E as isTree, S as getTopologicalSort, T as isConnected, _ as getShortestPath, a as genPreorders, b as getSimplePaths, c as getAStarPath, d as getCycles, f as getMinimumSpanningTree, g as getPreorders, h as getPreorder, i as genPostorders, l as getAllPairsShortestPaths, m as getPostorders, n as dfs, o as genShortestPaths, p as getPostorder, r as genCycles, s as genSimplePaths, t as bfs, u as getConnectedComponents, v as getShortestPaths, w as isAcyclic, x as getStronglyConnectedComponents, y as getSimplePath } from "./algorithms-Dw5jEwDK.mjs";
 
-export { bfs, dfs, genCycles, genPostorders, genPreorders, genShortestPaths, genSimplePaths, getAllPairsShortestPaths, getConnectedComponents, getCycles, getMinimumSpanningTree, getPostorder, getPostorders, getPreorder, getPreorders, getShortestPath, getShortestPaths, getSimplePath, getSimplePaths, getStronglyConnectedComponents, getTopologicalSort, hasPath, isAcyclic, isConnected, isTree, joinPaths };
+export { bfs, dfs, genCycles, genPostorders, genPreorders, genShortestPaths, genSimplePaths, getAStarPath, getAllPairsShortestPaths, getConnectedComponents, getCycles, getMinimumSpanningTree, getPostorder, getPostorders, getPreorder, getPreorders, getShortestPath, getShortestPaths, getSimplePath, getSimplePaths, getStronglyConnectedComponents, getTopologicalSort, hasPath, isAcyclic, isConnected, isTree, joinPaths };

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

@@ -1,4 +1,4 @@
-import { c as Graph } from "../../types-FBZCrmnG.mjs";
+import { u as Graph } from "../../types-DkKjaQW3.mjs";
 
 //#region src/formats/adjacency-list/index.d.ts
 

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

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-FBZCrmnG.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DkKjaQW3.mjs";
 
 //#region src/formats/converter/index.d.ts
 

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

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-FBZCrmnG.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DkKjaQW3.mjs";
 
 //#region src/formats/cytoscape/index.d.ts
 interface CytoscapeNode {

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

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-FBZCrmnG.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DkKjaQW3.mjs";
 
 //#region src/formats/d3/index.d.ts
 interface D3Node {

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

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-FBZCrmnG.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DkKjaQW3.mjs";
 
 //#region src/formats/dot/index.d.ts
 

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

@@ -1,4 +1,4 @@
-import { c as Graph } from "../../types-FBZCrmnG.mjs";
+import { u as Graph } from "../../types-DkKjaQW3.mjs";
 
 //#region src/formats/edge-list/index.d.ts
 

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

@@ -1,4 +1,4 @@
-import { D as VisualGraphFormatConverter, T as VisualGraph } from "../../types-FBZCrmnG.mjs";
+import { D as VisualGraph, k as VisualGraphFormatConverter } from "../../types-DkKjaQW3.mjs";
 import { ElkEdge, ElkEdgeSection, ElkExtendedEdge, ElkGraphElement, ElkLabel, ElkNode, ElkNode as ElkNode$1, ElkPoint, ElkPort, ElkPrimitiveEdge, ElkShape, LayoutOptions } from "elkjs/lib/elk-api";
 
 //#region src/formats/elk/index.d.ts

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

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-FBZCrmnG.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DkKjaQW3.mjs";
 
 //#region src/formats/gexf/index.d.ts
 declare function toGEXF(graph: Graph): string;

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

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-FBZCrmnG.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DkKjaQW3.mjs";
 
 //#region src/formats/gml/index.d.ts
 

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

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-FBZCrmnG.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DkKjaQW3.mjs";
 
 //#region src/formats/graphml/index.d.ts
 declare function toGraphML(graph: Graph): string;

package/dist/formats/graphml/index.mjs

@@ -17,6 +17,12 @@ function toGraphML(graph) {
 			"@_attr.name": "parentId",
 			"@_attr.type": "string"
 		},
+		{
+			"@_id": "initialNodeId",
+			"@_for": "node",
+			"@_attr.name": "initialNodeId",
+			"@_attr.type": "string"
+		},
 		{
 			"@_id": "data",
 			"@_for": "all",
@@ -29,6 +35,30 @@ function toGraphML(graph) {
 			"@_attr.name": "data",
 			"@_attr.type": "string"
 		},
+		{
+			"@_id": "graphInitialNodeId",
+			"@_for": "graph",
+			"@_attr.name": "initialNodeId",
+			"@_attr.type": "string"
+		},
+		{
+			"@_id": "direction",
+			"@_for": "graph",
+			"@_attr.name": "direction",
+			"@_attr.type": "string"
+		},
+		{
+			"@_id": "style",
+			"@_for": "all",
+			"@_attr.name": "style",
+			"@_attr.type": "string"
+		},
+		{
+			"@_id": "graphStyle",
+			"@_for": "graph",
+			"@_attr.name": "style",
+			"@_attr.type": "string"
+		},
 		{
 			"@_id": "x",
 			"@_for": "all",
@@ -64,85 +94,107 @@ function toGraphML(graph) {
 			"@_for": "all",
 			"@_attr.name": "color",
 			"@_attr.type": "string"
+		},
+		{
+			"@_id": "weight",
+			"@_for": "edge",
+			"@_attr.name": "weight",
+			"@_attr.type": "double"
 		}
 	];
-	const nodes = graph.nodes.map((n) => {
+	const nodes = graph.nodes.map((node) => {
 		const data = [];
-		if (n.label) data.push({
+		if (node.label) data.push({
 			"@_key": "label",
-			"#text": n.label
+			"#text": node.label
 		});
-		if (n.parentId) data.push({
+		if (node.parentId) data.push({
 			"@_key": "parentId",
-			"#text": n.parentId
+			"#text": node.parentId
 		});
-		if (n.data !== void 0) data.push({
+		if (node.initialNodeId) data.push({
+			"@_key": "initialNodeId",
+			"#text": node.initialNodeId
+		});
+		if (node.data !== void 0) data.push({
 			"@_key": "data",
-			"#text": JSON.stringify(n.data)
+			"#text": JSON.stringify(node.data)
+		});
+		if (node.style !== void 0) data.push({
+			"@_key": "style",
+			"#text": JSON.stringify(node.style)
 		});
-		if (n.x !== void 0) data.push({
+		if (node.x !== void 0) data.push({
 			"@_key": "x",
-			"#text": n.x
+			"#text": node.x
 		});
-		if (n.y !== void 0) data.push({
+		if (node.y !== void 0) data.push({
 			"@_key": "y",
-			"#text": n.y
+			"#text": node.y
 		});
-		if (n.width !== void 0) data.push({
+		if (node.width !== void 0) data.push({
 			"@_key": "width",
-			"#text": n.width
+			"#text": node.width
 		});
-		if (n.height !== void 0) data.push({
+		if (node.height !== void 0) data.push({
 			"@_key": "height",
-			"#text": n.height
+			"#text": node.height
 		});
-		if (n.shape) data.push({
+		if (node.shape) data.push({
 			"@_key": "shape",
-			"#text": n.shape
+			"#text": node.shape
 		});
-		if (n.color) data.push({
+		if (node.color) data.push({
 			"@_key": "color",
-			"#text": n.color
+			"#text": node.color
 		});
 		return {
-			"@_id": n.id,
+			"@_id": node.id,
 			...data.length > 0 && { data }
 		};
 	});
-	const edges = graph.edges.map((e) => {
+	const edges = graph.edges.map((edge) => {
 		const data = [];
-		if (e.label) data.push({
+		if (edge.label) data.push({
 			"@_key": "label",
-			"#text": e.label
+			"#text": edge.label
 		});
-		if (e.data !== void 0) data.push({
+		if (edge.data !== void 0) data.push({
 			"@_key": "data",
-			"#text": JSON.stringify(e.data)
+			"#text": JSON.stringify(edge.data)
 		});
-		if (e.x !== void 0) data.push({
+		if (edge.style !== void 0) data.push({
+			"@_key": "style",
+			"#text": JSON.stringify(edge.style)
+		});
+		if (edge.x !== void 0) data.push({
 			"@_key": "x",
-			"#text": e.x
+			"#text": edge.x
 		});
-		if (e.y !== void 0) data.push({
+		if (edge.y !== void 0) data.push({
 			"@_key": "y",
-			"#text": e.y
+			"#text": edge.y
 		});
-		if (e.width !== void 0) data.push({
+		if (edge.width !== void 0) data.push({
 			"@_key": "width",
-			"#text": e.width
+			"#text": edge.width
 		});
-		if (e.height !== void 0) data.push({
+		if (edge.height !== void 0) data.push({
 			"@_key": "height",
-			"#text": e.height
+			"#text": edge.height
 		});
-		if (e.color) data.push({
+		if (edge.color) data.push({
 			"@_key": "color",
-			"#text": e.color
+			"#text": edge.color
+		});
+		if (edge.weight !== void 0) data.push({
+			"@_key": "weight",
+			"#text": edge.weight
 		});
 		return {
-			"@_id": e.id,
-			"@_source": e.sourceId,
-			"@_target": e.targetId,
+			"@_id": edge.id,
+			"@_source": edge.sourceId,
+			"@_target": edge.targetId,
 			...data.length > 0 && { data }
 		};
 	});
@@ -151,6 +203,18 @@ function toGraphML(graph) {
 		"@_key": "graphData",
 		"#text": JSON.stringify(graph.data)
 	});
+	if (graph.initialNodeId) graphData.push({
+		"@_key": "graphInitialNodeId",
+		"#text": graph.initialNodeId
+	});
+	if (graph.direction !== void 0) graphData.push({
+		"@_key": "direction",
+		"#text": graph.direction
+	});
+	if (graph.style !== void 0) graphData.push({
+		"@_key": "graphStyle",
+		"#text": JSON.stringify(graph.style)
+	});
 	const obj = {
 		"?xml": {
 			"@_version": "1.0",
@@ -196,40 +260,57 @@ function fromGraphML(xml) {
 	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) {
-		for (const d of asArray(graphEl.data)) if (d["@_key"] === "graphData") graphData = tryParseJSON(String(d["#text"]));
-	}
-	const nodes = asArray(graphEl.node).map((n) => {
-		const dataMap = parseDataElements(n.data);
-		return {
+	const graphDataMap = parseDataElements(graphEl.data);
+	const graphData = graphDataMap.graphData !== void 0 ? tryParseJSON(graphDataMap.graphData) : void 0;
+	const nodes = asArray(graphEl.node).map((nodeEl) => {
+		const dataMap = parseDataElements(nodeEl.data);
+		const node = {
 			type: "node",
-			id: String(n["@_id"]),
+			id: String(nodeEl["@_id"]),
 			parentId: dataMap.parentId ?? null,
 			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.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);
+		return node;
 	});
-	const edges = asArray(graphEl.edge).map((e) => {
-		const dataMap = parseDataElements(e.data);
-		return {
+	const edges = asArray(graphEl.edge).map((edgeEl) => {
+		const dataMap = parseDataElements(edgeEl.data);
+		const edge = {
 			type: "edge",
-			id: String(e["@_id"]),
-			sourceId: String(e["@_source"]),
-			targetId: String(e["@_target"]),
+			id: String(edgeEl["@_id"]),
+			sourceId: String(edgeEl["@_source"]),
+			targetId: String(edgeEl["@_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.color !== void 0) edge.color = dataMap.color;
+		if (dataMap.style !== void 0) edge.style = tryParseJSON(dataMap.style);
+		return edge;
 	});
-	return {
+	const graph = {
 		id: String(graphEl["@_id"] ?? ""),
 		type: graphType,
-		initialNodeId: null,
+		initialNodeId: graphDataMap.graphInitialNodeId ?? null,
 		nodes,
 		edges,
 		data: graphData
 	};
+	if (graphDataMap.direction !== void 0) graph.direction = parseDirection(graphDataMap.direction);
+	if (graphDataMap.graphStyle !== void 0) graph.style = tryParseJSON(graphDataMap.graphStyle);
+	return graph;
 }
 function asArray(val) {
 	if (val === void 0) return [];
@@ -237,7 +318,7 @@ function asArray(val) {
 }
 function parseDataElements(dataEls) {
 	const map = {};
-	for (const d of asArray(dataEls)) if (d && d["@_key"]) map[d["@_key"]] = String(d["#text"] ?? "");
+	for (const dataEl of asArray(dataEls)) if (dataEl && dataEl["@_key"]) map[dataEl["@_key"]] = String(dataEl["#text"] ?? "");
 	return map;
 }
 function tryParseJSON(str) {
@@ -247,6 +328,17 @@ function tryParseJSON(str) {
 		return str;
 	}
 }
+function parseNumber(value) {
+	return Number(value);
+}
+function parseDirection(value) {
+	return [
+		"up",
+		"down",
+		"left",
+		"right"
+	].includes(value) ? value : void 0;
+}
 /** Bidirectional converter for GraphML XML format. */
 const graphmlConverter = createFormatConverter(toGraphML, fromGraphML);
 

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

@@ -1,4 +1,4 @@
-import { c as Graph, f as GraphFormatConverter } from "../../types-FBZCrmnG.mjs";
+import { m as GraphFormatConverter, u as Graph } from "../../types-DkKjaQW3.mjs";
 
 //#region src/formats/jgf/index.d.ts
 interface JGFNode {