@statelyai/graph 0.1.0

package/dist/index.mjs

@@ -0,0 +1,356 @@
+import { o as invalidateIndex, t as getIndex } from "./indexing-BHg1VhqN.mjs";
+import { A as createGraph, B as updateEntities, C as isAcyclic, D as addEdge, E as GraphInstance, F as getEdge, I as getNode, L as hasEdge, M as deleteEdge, N as deleteEntities, O as addEntities, P as deleteNode, R as hasNode, S as hasPath, T as isTree, V as updateNode, _ 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, j as createVisualGraph, k as addNode, 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, z as updateEdge } from "./algorithms-R35X6ro4.mjs";
+import { EdgeSchema, GraphSchema, NodeSchema } from "./schemas.mjs";
+import { getAncestors, getChildren, getDegree, getDepth, getDescendants, getEdgeBetween, getEdgesOf, getInDegree, getInEdges, getLCA, getNeighbors, getOutDegree, getOutEdges, getParent, getPredecessors, getRoots, getSiblings, getSinks, getSources, getSuccessors, isCompound, isLeaf } from "./queries.mjs";
+import { n as toGraphML, t as fromGraphML } from "./graphml-CUTNRXqd.mjs";
+import { t as toDOT } from "./dot-BRtq3e3c.mjs";
+import { n as toAdjacencyList, t as fromAdjacencyList } from "./adjacency-list-CXpOCibq.mjs";
+import { n as toEdgeList, t as fromEdgeList } from "./edge-list-BRujEnnU.mjs";
+
+//#region src/diff.ts
+function nodeToConfig(node) {
+	const config = { id: node.id };
+	if (node.parentId !== null) config.parentId = node.parentId;
+	if (node.initialNodeId !== null) config.initialNodeId = node.initialNodeId;
+	if (node.label !== "") config.label = node.label;
+	if (node.data !== void 0) config.data = node.data;
+	if (node.x !== void 0) config.x = node.x;
+	if (node.y !== void 0) config.y = node.y;
+	if (node.width !== void 0) config.width = node.width;
+	if (node.height !== void 0) config.height = node.height;
+	if (node.shape !== void 0) config.shape = node.shape;
+	if (node.color !== void 0) config.color = node.color;
+	if (node.style !== void 0) config.style = node.style;
+	return config;
+}
+function edgeToConfig(edge) {
+	const config = {
+		id: edge.id,
+		sourceId: edge.sourceId,
+		targetId: edge.targetId
+	};
+	if (edge.label !== "") config.label = edge.label;
+	if (edge.data !== void 0) config.data = edge.data;
+	if (edge.x !== void 0) config.x = edge.x;
+	if (edge.y !== void 0) config.y = edge.y;
+	if (edge.width !== void 0) config.width = edge.width;
+	if (edge.height !== void 0) config.height = edge.height;
+	if (edge.color !== void 0) config.color = edge.color;
+	if (edge.style !== void 0) config.style = edge.style;
+	return config;
+}
+/** Shallow-compare two values, returning true if they differ. */
+function differs(a, b) {
+	if (a === b) return false;
+	if (a == null || b == null) return a !== b;
+	if (typeof a === "object" && typeof b === "object") return JSON.stringify(a) !== JSON.stringify(b);
+	return true;
+}
+const NODE_COMPARE_KEYS = [
+	"parentId",
+	"initialNodeId",
+	"label",
+	"data",
+	"x",
+	"y",
+	"width",
+	"height",
+	"shape",
+	"color",
+	"style"
+];
+const EDGE_COMPARE_KEYS = [
+	"sourceId",
+	"targetId",
+	"label",
+	"data",
+	"x",
+	"y",
+	"width",
+	"height",
+	"color",
+	"style"
+];
+/** Compute a structured diff from graph `a` to graph `b` by matching IDs. */
+function getDiff(a, b) {
+	const aNodeMap = new Map(a.nodes.map((n) => [n.id, n]));
+	const bNodeMap = new Map(b.nodes.map((n) => [n.id, n]));
+	const aEdgeMap = new Map(a.edges.map((e) => [e.id, e]));
+	const bEdgeMap = new Map(b.edges.map((e) => [e.id, e]));
+	const diff = {
+		nodes: {
+			added: [],
+			removed: [],
+			updated: []
+		},
+		edges: {
+			added: [],
+			removed: [],
+			updated: []
+		}
+	};
+	for (const [id, nodeB] of bNodeMap) {
+		const nodeA = aNodeMap.get(id);
+		if (!nodeA) diff.nodes.added.push(nodeToConfig(nodeB));
+		else {
+			const oldPartial = {};
+			const newPartial = {};
+			for (const key of NODE_COMPARE_KEYS) if (differs(nodeA[key], nodeB[key])) {
+				oldPartial[key] = nodeA[key];
+				newPartial[key] = nodeB[key];
+			}
+			if (Object.keys(oldPartial).length > 0) diff.nodes.updated.push({
+				id,
+				old: oldPartial,
+				new: newPartial
+			});
+		}
+	}
+	for (const [id, nodeA] of aNodeMap) if (!bNodeMap.has(id)) diff.nodes.removed.push(nodeToConfig(nodeA));
+	for (const [id, edgeB] of bEdgeMap) {
+		const edgeA = aEdgeMap.get(id);
+		if (!edgeA) diff.edges.added.push(edgeToConfig(edgeB));
+		else {
+			const oldPartial = {};
+			const newPartial = {};
+			for (const key of EDGE_COMPARE_KEYS) if (differs(edgeA[key], edgeB[key])) {
+				oldPartial[key] = edgeA[key];
+				newPartial[key] = edgeB[key];
+			}
+			if (Object.keys(oldPartial).length > 0) diff.edges.updated.push({
+				id,
+				old: oldPartial,
+				new: newPartial
+			});
+		}
+	}
+	for (const [id, edgeA] of aEdgeMap) if (!bEdgeMap.has(id)) diff.edges.removed.push(edgeToConfig(edgeA));
+	return diff;
+}
+/** Check if a diff has zero changes. */
+function isEmptyDiff(diff) {
+	return diff.nodes.added.length === 0 && diff.nodes.removed.length === 0 && diff.nodes.updated.length === 0 && diff.edges.added.length === 0 && diff.edges.removed.length === 0 && diff.edges.updated.length === 0;
+}
+/** Invert a diff: swap added↔removed, swap old↔new in updates. */
+function invertDiff(diff) {
+	return {
+		nodes: {
+			added: diff.nodes.removed,
+			removed: diff.nodes.added,
+			updated: diff.nodes.updated.map((c) => ({
+				id: c.id,
+				old: c.new,
+				new: c.old
+			}))
+		},
+		edges: {
+			added: diff.edges.removed,
+			removed: diff.edges.added,
+			updated: diff.edges.updated.map((c) => ({
+				id: c.id,
+				old: c.new,
+				new: c.old
+			}))
+		}
+	};
+}
+/**
+* Compute an ordered patch list from graph `a` to graph `b`.
+* Order: delete edges → delete nodes → add nodes → add edges → update nodes → update edges.
+*/
+function getPatches(a, b) {
+	return toPatches(getDiff(a, b));
+}
+/**
+* **Mutable.** Apply patches to a graph in order.
+* Delegates to addNode/deleteNode/updateNode/addEdge/deleteEdge/updateEdge.
+*/
+function applyPatches(graph, patches) {
+	for (const patch of patches) switch (patch.op) {
+		case "addNode":
+			addNode(graph, patch.node);
+			break;
+		case "deleteNode":
+			deleteNode(graph, patch.id);
+			break;
+		case "updateNode":
+			updateNode(graph, patch.id, patch.data);
+			break;
+		case "addEdge":
+			addEdge(graph, patch.edge);
+			break;
+		case "deleteEdge":
+			deleteEdge(graph, patch.id);
+			break;
+		case "updateEdge":
+			updateEdge(graph, patch.id, patch.data);
+			break;
+	}
+}
+/**
+* Flatten a structured diff into an ordered patch list.
+* Order: add nodes → update edges → delete edges → delete nodes → add edges → update nodes.
+* This avoids cascading deletes removing edges that are being updated,
+* and ensures new nodes exist before edges reference them.
+*/
+function toPatches(diff) {
+	const patches = [];
+	for (const node of diff.nodes.added) patches.push({
+		op: "addNode",
+		node
+	});
+	for (const change of diff.edges.updated) {
+		const data = {};
+		for (const [key, value] of Object.entries(change.new)) data[key] = value;
+		patches.push({
+			op: "updateEdge",
+			id: change.id,
+			data
+		});
+	}
+	for (const edge of diff.edges.removed) patches.push({
+		op: "deleteEdge",
+		id: edge.id
+	});
+	for (const node of diff.nodes.removed) patches.push({
+		op: "deleteNode",
+		id: node.id
+	});
+	for (const edge of diff.edges.added) patches.push({
+		op: "addEdge",
+		edge
+	});
+	for (const change of diff.nodes.updated) {
+		const data = {};
+		for (const [key, value] of Object.entries(change.new)) data[key] = value;
+		patches.push({
+			op: "updateNode",
+			id: change.id,
+			data
+		});
+	}
+	return patches;
+}
+/** Group a patch list into a structured diff. */
+function toDiff(patches) {
+	const diff = {
+		nodes: {
+			added: [],
+			removed: [],
+			updated: []
+		},
+		edges: {
+			added: [],
+			removed: [],
+			updated: []
+		}
+	};
+	for (const patch of patches) switch (patch.op) {
+		case "addNode":
+			diff.nodes.added.push(patch.node);
+			break;
+		case "deleteNode":
+			diff.nodes.removed.push({ id: patch.id });
+			break;
+		case "updateNode": {
+			const newPartial = {};
+			for (const [key, value] of Object.entries(patch.data)) newPartial[key] = value;
+			diff.nodes.updated.push({
+				id: patch.id,
+				old: {},
+				new: newPartial
+			});
+			break;
+		}
+		case "addEdge":
+			diff.edges.added.push(patch.edge);
+			break;
+		case "deleteEdge":
+			diff.edges.removed.push({ id: patch.id });
+			break;
+		case "updateEdge": {
+			const newPartial = {};
+			for (const [key, value] of Object.entries(patch.data)) newPartial[key] = value;
+			diff.edges.updated.push({
+				id: patch.id,
+				old: {},
+				new: newPartial
+			});
+			break;
+		}
+	}
+	return diff;
+}
+
+//#endregion
+//#region src/transforms.ts
+/**
+* Flattens a hierarchical graph into a flat graph with only leaf nodes.
+*
+* - Edges targeting a compound node resolve to its initial child (recursively).
+* - Edges originating from a compound node expand to all leaf descendants.
+* - Only leaf nodes (nodes with no children) appear in the result.
+* - Duplicate edges (same source + target) are deduplicated.
+*/
+function flatten(graph) {
+	const idx = getIndex(graph);
+	const leaves = /* @__PURE__ */ new Set();
+	for (const node of graph.nodes) if ((idx.childNodes.get(node.id) ?? []).length === 0) leaves.add(node.id);
+	function resolveInitial(nodeId) {
+		if (leaves.has(nodeId)) return nodeId;
+		const ni = idx.nodeById.get(nodeId);
+		if (ni === void 0) return null;
+		const node = graph.nodes[ni];
+		if (node.initialNodeId) return resolveInitial(node.initialNodeId);
+		const childIds = idx.childNodes.get(nodeId) ?? [];
+		if (childIds.length > 0) return resolveInitial(childIds[0]);
+		return nodeId;
+	}
+	function getLeafDescendants(nodeId) {
+		if (leaves.has(nodeId)) return [nodeId];
+		const result = [];
+		const collect = (id) => {
+			const childIds = idx.childNodes.get(id) ?? [];
+			for (const childId of childIds) if (leaves.has(childId)) result.push(childId);
+			else collect(childId);
+		};
+		collect(nodeId);
+		return result;
+	}
+	const edgeSeen = /* @__PURE__ */ new Set();
+	const flatEdges = [];
+	for (const edge of graph.edges) {
+		const sources = leaves.has(edge.sourceId) ? [edge.sourceId] : getLeafDescendants(edge.sourceId);
+		const target = leaves.has(edge.targetId) ? edge.targetId : resolveInitial(edge.targetId);
+		if (target === null) continue;
+		for (const source of sources) {
+			if (source === target) continue;
+			const key = `${source}->${target}`;
+			if (edgeSeen.has(key)) continue;
+			edgeSeen.add(key);
+			flatEdges.push({
+				type: "edge",
+				id: `${edge.id}:${source}->${target}`,
+				sourceId: source,
+				targetId: target,
+				label: edge.label,
+				data: edge.data
+			});
+		}
+	}
+	const leafNodes = graph.nodes.filter((n) => leaves.has(n.id)).map((n) => ({
+		id: n.id,
+		label: n.label,
+		data: n.data
+	}));
+	return createGraph({
+		id: graph.id,
+		type: graph.type,
+		nodes: leafNodes,
+		edges: flatEdges,
+		data: graph.data
+	});
+}
+
+//#endregion
+export { EdgeSchema, GraphInstance, GraphSchema, NodeSchema, addEdge, addEntities, addNode, applyPatches, bfs, createGraph, createVisualGraph, deleteEdge, deleteEntities, deleteNode, dfs, flatten, fromAdjacencyList, fromEdgeList, fromGraphML, genCycles, genPostorders, genPreorders, genShortestPaths, genSimplePaths, getAllPairsShortestPaths, getAncestors, getChildren, getConnectedComponents, getCycles, getDegree, getDepth, getDescendants, getDiff, getEdge, getEdgeBetween, getEdgesOf, getInDegree, getInEdges, getLCA, getMinimumSpanningTree, getNeighbors, getNode, getOutDegree, getOutEdges, getParent, getPatches, getPostorder, getPostorders, getPredecessors, getPreorder, getPreorders, getRoots, getShortestPath, getShortestPaths, getSiblings, getSimplePath, getSimplePaths, getSinks, getSources, getStronglyConnectedComponents, getSuccessors, getTopologicalSort, hasEdge, hasNode, hasPath, invalidateIndex, invertDiff, isAcyclic, isCompound, isConnected, isEmptyDiff, isLeaf, isTree, toAdjacencyList, toDOT, toDiff, toEdgeList, toGraphML, toPatches, updateEdge, updateEntities, updateNode };

package/dist/indexing-BHg1VhqN.mjs

@@ -0,0 +1,93 @@
+//#region src/indexing.ts
+const indexes = /* @__PURE__ */ new WeakMap();
+/** Get or lazily build the index for a graph. */
+function getIndex(graph) {
+	let idx = indexes.get(graph);
+	if (!idx || idx.nodeCount !== graph.nodes.length || idx.edgeCount !== graph.edges.length) {
+		idx = buildIndex(graph);
+		indexes.set(graph, idx);
+	}
+	return idx;
+}
+/** Clear the cached index. Call this if you mutate graph.nodes/edges directly. */
+function invalidateIndex(graph) {
+	indexes.delete(graph);
+}
+function buildIndex(graph) {
+	const nodeById = /* @__PURE__ */ new Map();
+	const edgeById = /* @__PURE__ */ new Map();
+	const outEdges = /* @__PURE__ */ new Map();
+	const inEdges = /* @__PURE__ */ new Map();
+	const childNodes = /* @__PURE__ */ new Map();
+	for (let i = 0; i < graph.nodes.length; i++) {
+		const n = graph.nodes[i];
+		nodeById.set(n.id, i);
+		outEdges.set(n.id, []);
+		inEdges.set(n.id, []);
+		const parent = n.parentId;
+		if (!childNodes.has(parent)) childNodes.set(parent, []);
+		childNodes.get(parent).push(n.id);
+	}
+	for (let i = 0; i < graph.edges.length; i++) {
+		const e = graph.edges[i];
+		edgeById.set(e.id, i);
+		outEdges.get(e.sourceId)?.push(e.id);
+		inEdges.get(e.targetId)?.push(e.id);
+	}
+	return {
+		nodeById,
+		edgeById,
+		outEdges,
+		inEdges,
+		childNodes,
+		nodeCount: graph.nodes.length,
+		edgeCount: graph.edges.length
+	};
+}
+function indexAddNode(idx, node, arrayIndex) {
+	idx.nodeById.set(node.id, arrayIndex);
+	idx.outEdges.set(node.id, []);
+	idx.inEdges.set(node.id, []);
+	const parent = node.parentId;
+	if (!idx.childNodes.has(parent)) idx.childNodes.set(parent, []);
+	idx.childNodes.get(parent).push(node.id);
+	idx.nodeCount++;
+}
+function indexAddEdge(idx, edge, arrayIndex) {
+	idx.edgeById.set(edge.id, arrayIndex);
+	idx.outEdges.get(edge.sourceId)?.push(edge.id);
+	idx.inEdges.get(edge.targetId)?.push(edge.id);
+	idx.edgeCount++;
+}
+/** Update childNodes index when a node's parentId changes. */
+function indexReparentNode(idx, nodeId, oldParentId, newParentId) {
+	const oldSiblings = idx.childNodes.get(oldParentId);
+	if (oldSiblings) {
+		const pos = oldSiblings.indexOf(nodeId);
+		if (pos !== -1) oldSiblings.splice(pos, 1);
+	}
+	if (!idx.childNodes.has(newParentId)) idx.childNodes.set(newParentId, []);
+	idx.childNodes.get(newParentId).push(nodeId);
+}
+/** Update adjacency lists when an edge's sourceId/targetId changes. */
+function indexUpdateEdgeEndpoints(idx, edgeId, oldSourceId, oldTargetId, newSourceId, newTargetId) {
+	if (oldSourceId !== newSourceId) {
+		const oldOut = idx.outEdges.get(oldSourceId);
+		if (oldOut) {
+			const pos = oldOut.indexOf(edgeId);
+			if (pos !== -1) oldOut.splice(pos, 1);
+		}
+		idx.outEdges.get(newSourceId)?.push(edgeId);
+	}
+	if (oldTargetId !== newTargetId) {
+		const oldIn = idx.inEdges.get(oldTargetId);
+		if (oldIn) {
+			const pos = oldIn.indexOf(edgeId);
+			if (pos !== -1) oldIn.splice(pos, 1);
+		}
+		idx.inEdges.get(newTargetId)?.push(edgeId);
+	}
+}
+
+//#endregion
+export { indexUpdateEdgeEndpoints as a, indexReparentNode as i, indexAddEdge as n, invalidateIndex as o, indexAddNode as r, getIndex as t };

package/dist/queries.d.mts

@@ -0,0 +1,37 @@
+import { c as Graph, d as GraphEdge, f as GraphNode } from "./types-XV3S5Jnh.mjs";
+
+//#region src/queries.d.ts
+declare function getEdgesOf<E>(graph: Graph<any, E>, nodeId: string): GraphEdge<E>[];
+declare function getInEdges<E>(graph: Graph<any, E>, nodeId: string): GraphEdge<E>[];
+declare function getOutEdges<E>(graph: Graph<any, E>, nodeId: string): GraphEdge<E>[];
+declare function getEdgeBetween<E>(graph: Graph<any, E>, sourceId: string, targetId: string): GraphEdge<E> | undefined;
+declare function getSuccessors<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
+declare function getPredecessors<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
+declare function getNeighbors<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
+declare function getDegree(graph: Graph, nodeId: string): number;
+declare function getInDegree(graph: Graph, nodeId: string): number;
+declare function getOutDegree(graph: Graph, nodeId: string): number;
+declare function getChildren<N>(graph: Graph<N>, nodeId: string | null): GraphNode<N>[];
+declare function getParent<N>(graph: Graph<N>, nodeId: string): GraphNode<N> | undefined;
+declare function getAncestors<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
+declare function getDescendants<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
+declare function getRoots<N>(graph: Graph<N>): GraphNode<N>[];
+/** Whether a node has children (is a compound/group node). */
+declare function isCompound(graph: Graph, nodeId: string): boolean;
+/** Whether a node has no children (is a leaf/atomic node). */
+declare function isLeaf(graph: Graph, nodeId: string): boolean;
+/** Depth of a node in the hierarchy (root = 0). */
+declare function getDepth(graph: Graph, nodeId: string): number;
+/** Sibling nodes (same parentId, excluding the node itself). */
+declare function getSiblings<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
+/**
+ * Least Common Ancestor — deepest proper ancestor of all given nodes.
+ * A proper ancestor excludes the input nodes themselves.
+ */
+declare function getLCA<N>(graph: Graph<N>, ...nodeIds: string[]): GraphNode<N> | undefined;
+/** Nodes with no incoming edges (inDegree 0). */
+declare function getSources<N>(graph: Graph<N>): GraphNode<N>[];
+/** Nodes with no outgoing edges (outDegree 0). */
+declare function getSinks<N>(graph: Graph<N>): GraphNode<N>[];
+//#endregion
+export { getAncestors, getChildren, getDegree, getDepth, getDescendants, getEdgeBetween, getEdgesOf, getInDegree, getInEdges, getLCA, getNeighbors, getOutDegree, getOutEdges, getParent, getPredecessors, getRoots, getSiblings, getSinks, getSources, getSuccessors, isCompound, isLeaf };