@statelyai/graph 1.0.0 → 2.1.0

package/dist/algorithms-fTqmvhzP.d.mts

@@ -1,178 +0,0 @@
-import { A as TraversalOptions, O as SinglePathOptions, S as MSTOptions, T as PathOptions, _ as GraphNode, n as AllPairsShortestPathsOptions, p as GraphEdge, t as AStarOptions, u as Graph, y as GraphPath } from "./types-3-FS9NV2.mjs";
-
-//#region src/algorithms/traversal.d.ts
-declare function bfs<N>(graph: Graph<N>, startId: string): Generator<GraphNode<N>>;
-declare function dfs<N>(graph: Graph<N>, startId: string): Generator<GraphNode<N>>;
-declare function isAcyclic(graph: Graph): boolean;
-declare function getConnectedComponents<N>(graph: Graph<N>): GraphNode<N>[][];
-declare function getTopologicalSort<N>(graph: Graph<N>): GraphNode<N>[] | null;
-declare function hasPath(graph: Graph, sourceId: string, targetId: string): boolean;
-declare function isConnected(graph: Graph): boolean;
-declare function isTree(graph: Graph): boolean;
-//#endregion
-//#region src/algorithms/paths.d.ts
-declare function genShortestPaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E>): Generator<GraphPath<N, E>>;
-declare function getShortestPaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E>): GraphPath<N, E>[];
-declare function getShortestPath<N, E>(graph: Graph<N, E>, opts: SinglePathOptions<E>): GraphPath<N, E> | undefined;
-declare function getSimplePaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E>): GraphPath<N, E>[];
-declare function genSimplePaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E>): Generator<GraphPath<N, E>>;
-declare function getSimplePath<N, E>(graph: Graph<N, E>, opts: SinglePathOptions<E>): GraphPath<N, E> | undefined;
-declare function getStronglyConnectedComponents<N>(graph: Graph<N>): GraphNode<N>[][];
-declare function getCycles<N, E>(graph: Graph<N, E>): GraphPath<N, E>[];
-declare function genCycles<N, E>(graph: Graph<N, E>): Generator<GraphPath<N, E>>;
-declare function getAllPairsShortestPaths<N, E>(graph: Graph<N, E>, opts?: AllPairsShortestPathsOptions<E>): GraphPath<N, E>[];
-declare function getAStarPath<N, E>(graph: Graph<N, E>, opts: AStarOptions<E>): GraphPath<N, E> | undefined;
-declare function joinPaths<N, E>(headPath: GraphPath<N, E>, tailPath: GraphPath<N, E>): GraphPath<N, E>;
-//#endregion
-//#region src/algorithms/ordering.d.ts
-declare function getPreorder<N>(graph: Graph<N>, opts?: TraversalOptions): GraphNode<N>[];
-declare function getPostorder<N>(graph: Graph<N>, opts?: TraversalOptions): GraphNode<N>[];
-declare function getPreorders<N>(graph: Graph<N>, opts?: TraversalOptions): GraphNode<N>[][];
-declare function getPostorders<N>(graph: Graph<N>, opts?: TraversalOptions): GraphNode<N>[][];
-declare function genPreorders<N>(graph: Graph<N>, opts?: TraversalOptions): Generator<GraphNode<N>[]>;
-declare function genPostorders<N>(graph: Graph<N>, opts?: TraversalOptions): Generator<GraphNode<N>[]>;
-//#endregion
-//#region src/algorithms/spanning-tree.d.ts
-declare function getMinimumSpanningTree<N, E>(graph: Graph<N, E>, opts?: MSTOptions<E>): Graph<N, E>;
-//#endregion
-//#region src/algorithms/centrality.d.ts
-interface IterativeCentralityOptions {
-  alpha?: number;
-  maxIterations?: number;
-  tolerance?: number;
-}
-interface HITSResult {
-  hubs: Record<string, number>;
-  authorities: Record<string, number>;
-}
-/**
- * Returns degree centrality scores for all nodes.
- *
- * Degree centrality is the node degree normalized by `n - 1`.
- *
- * @example
- * ```ts
- * const scores = getDegreeCentrality(graph);
- * console.log(scores.a); // 0.5
- * ```
- */
-declare function getDegreeCentrality(graph: Graph): Record<string, number>;
-/**
- * Returns in-degree centrality scores for all nodes.
- *
- * In-degree centrality is the incoming degree normalized by `n - 1`.
- */
-declare function getInDegreeCentrality(graph: Graph): Record<string, number>;
-/**
- * Returns out-degree centrality scores for all nodes.
- *
- * Out-degree centrality is the outgoing degree normalized by `n - 1`.
- */
-declare function getOutDegreeCentrality(graph: Graph): Record<string, number>;
-/**
- * Returns closeness centrality scores for all nodes.
- *
- * Distances are computed over unweighted shortest paths using the graph's
- * existing directed or undirected edge semantics.
- */
-declare function getClosenessCentrality(graph: Graph): Record<string, number>;
-/**
- * Returns betweenness centrality scores for all nodes.
- *
- * Uses Brandes' algorithm over unweighted shortest paths and returns
- * normalized scores.
- */
-declare function getBetweennessCentrality(graph: Graph): Record<string, number>;
-/**
- * Returns PageRank scores for all nodes.
- *
- * Uses power iteration with damping factor `alpha`.
- */
-declare function getPageRank(graph: Graph, options?: IterativeCentralityOptions): Record<string, number>;
-/**
- * Returns HITS hub and authority scores for all nodes.
- *
- * Uses power iteration and L2 normalization per iteration.
- */
-declare function getHITS(graph: Graph, options?: IterativeCentralityOptions): HITSResult;
-/**
- * Returns eigenvector centrality scores for all nodes.
- *
- * Uses power iteration over incoming neighbors for directed graphs and
- * undirected adjacency for undirected graphs.
- */
-declare function getEigenvectorCentrality(graph: Graph, options?: IterativeCentralityOptions): Record<string, number>;
-//#endregion
-//#region src/algorithms/community.d.ts
-interface GirvanNewmanOptions {
-  level?: number;
-  maxLevels?: number;
-}
-interface LabelPropagationOptions {
-  maxIterations?: number;
-}
-type Community<N = any> = GraphNode<N>[];
-/**
- * Returns label-propagation communities for the graph.
- *
- * The implementation is deterministic: ties are broken by lexicographic label
- * order so test results remain stable.
- */
-declare function getLabelPropagationCommunities<N>(graph: Graph<N>, options?: LabelPropagationOptions): Community<N>[];
-/**
- * Lazily yields Girvan-Newman community splits as edge betweenness removes
- * bridge-like edges from the graph.
- */
-declare function genGirvanNewmanCommunities<N>(graph: Graph<N>, options?: GirvanNewmanOptions): Generator<Community<N>[]>;
-/**
- * Returns the requested Girvan-Newman split level eagerly.
- *
- * `level: 1` returns the first split yielded by `genGirvanNewmanCommunities`.
- */
-declare function getGirvanNewmanCommunities<N>(graph: Graph<N>, options?: GirvanNewmanOptions): Community<N>[];
-/**
- * Returns the modularity score for a partition of communities.
- *
- * Community algorithms in this module treat the graph as undirected.
- */
-declare function getModularity<N>(graph: Graph<N>, communities: Community<N>[]): number;
-/**
- * Returns communities found by greedily merging partitions that improve
- * modularity the most at each step.
- */
-declare function getGreedyModularityCommunities<N>(graph: Graph<N>): Community<N>[];
-//#endregion
-//#region src/algorithms/connectivity.d.ts
-/**
- * Returns bridge edges whose removal disconnects the graph.
- *
- * Connectivity algorithms in this module treat the graph as undirected.
- */
-declare function getBridges<N, E>(graph: Graph<N, E>): GraphEdge<E>[];
-/**
- * Returns articulation points (cut vertices) for the graph.
- *
- * Connectivity algorithms in this module treat the graph as undirected.
- */
-declare function getArticulationPoints<N, E>(graph: Graph<N, E>): GraphNode<N>[];
-/**
- * Returns biconnected components as arrays of nodes.
- *
- * Articulation points may appear in multiple returned components.
- */
-declare function getBiconnectedComponents<N, E>(graph: Graph<N, E>): GraphNode<N>[][];
-//#endregion
-//#region src/algorithms/isomorphism.d.ts
-interface IsomorphismOptions<N = any, E = any> {
-  nodeMatch?: (a: GraphNode<N>, b: GraphNode<N>) => boolean;
-  edgeMatch?: (a: GraphEdge<E>, b: GraphEdge<E>) => boolean;
-}
-/**
- * Returns whether two graphs are structurally isomorphic.
- *
- * Optional `nodeMatch` and `edgeMatch` predicates can refine the match using
- * node and edge payloads.
- */
-declare function isIsomorphic<N, E>(graphA: Graph<N, E>, graphB: Graph<N, E>, options?: IsomorphismOptions<N, E>): boolean;
-//#endregion
-export { genCycles as A, getStronglyConnectedComponents as B, getMinimumSpanningTree as C, getPostorders as D, getPostorder as E, getCycles as F, getTopologicalSort as G, bfs as H, getShortestPath as I, isConnected as J, hasPath as K, getShortestPaths as L, genSimplePaths as M, getAStarPath as N, getPreorder as O, getAllPairsShortestPaths as P, getSimplePath as R, getPageRank as S, genPreorders as T, dfs as U, joinPaths as V, getConnectedComponents as W, isTree as Y, getDegreeCentrality as _, getBridges as a, getInDegreeCentrality as b, genGirvanNewmanCommunities as c, getLabelPropagationCommunities as d, getModularity as f, getClosenessCentrality as g, getBetweennessCentrality as h, getBiconnectedComponents as i, genShortestPaths as j, getPreorders as k, getGirvanNewmanCommunities as l, IterativeCentralityOptions as m, isIsomorphic as n, GirvanNewmanOptions as o, HITSResult as p, isAcyclic as q, getArticulationPoints as r, LabelPropagationOptions as s, IsomorphismOptions as t, getGreedyModularityCommunities as u, getEigenvectorCentrality as v, genPostorders as w, getOutDegreeCentrality as x, getHITS as y, getSimplePaths as z };

package/dist/indexing-DR8M1vBy.mjs

@@ -1,137 +0,0 @@
-//#region src/indexing.ts
-const indexes = /* @__PURE__ */ new WeakMap();
-/**
-* Get or lazily build the index for a graph.
-* Auto-rebuilds when node/edge count changes.
-*
-* @example
-* ```ts
-* import { createGraph, getIndex } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
-* });
-*
-* const idx = getIndex(graph);
-* idx.nodeById.get('a'); // 0
-* idx.outEdges.get('a'); // ['e1']
-* ```
-*/
-function getIndex(graph) {
-	let idx = indexes.get(graph);
-	const sameStructure = idx && idx.nodeCount === graph.nodes.length && idx.edgeCount === graph.edges.length;
-	const signature = idx !== void 0 && sameStructure && idx.nodesRef === graph.nodes && idx.edgesRef === graph.edges ? getIndexSignature(graph) : void 0;
-	if (!idx || idx.nodeCount !== graph.nodes.length || idx.edgeCount !== graph.edges.length || signature !== void 0 && idx.signature !== signature) {
-		idx = buildIndex(graph, signature ?? getIndexSignature(graph));
-		indexes.set(graph, idx);
-	}
-	return idx;
-}
-/**
-* Clear the cached index. Call this if you mutate graph.nodes/edges directly.
-*
-* @example
-* ```ts
-* import { createGraph, invalidateIndex, getIndex } from '@statelyai/graph';
-*
-* const graph = createGraph({ nodes: [{ id: 'a' }], edges: [] });
-* // manually mutate nodes array
-* graph.nodes.push({ type: 'node', id: 'b', parentId: null, initialNodeId: null, label: '', data: undefined });
-* invalidateIndex(graph); // forces rebuild on next getIndex()
-* ```
-*/
-function invalidateIndex(graph) {
-	indexes.delete(graph);
-}
-function getIndexSignature(graph) {
-	const nodeParts = graph.nodes.map((node) => `${node.id}\u0000${node.parentId ?? ""}`);
-	const edgeParts = graph.edges.map((edge) => `${edge.id}\u0000${edge.sourceId}\u0000${edge.targetId}`);
-	return `${nodeParts.join("
")}\u0002${edgeParts.join("
")}`;
-}
-function buildIndex(graph, signature) {
-	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 ?? null;
-		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,
-		signature,
-		nodesRef: graph.nodes,
-		edgesRef: graph.edges
-	};
-}
-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 ?? null;
-	if (!idx.childNodes.has(parent)) idx.childNodes.set(parent, []);
-	idx.childNodes.get(parent).push(node.id);
-	idx.nodeCount++;
-	idx.signature = "";
-}
-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++;
-	idx.signature = "";
-}
-/** Update childNodes index when a node's parentId changes. */
-function indexReparentNode(idx, nodeId, oldParentId, newParentId) {
-	const oldSiblings = idx.childNodes.get(oldParentId ?? null);
-	if (oldSiblings) {
-		const pos = oldSiblings.indexOf(nodeId);
-		if (pos !== -1) oldSiblings.splice(pos, 1);
-	}
-	const np = newParentId ?? null;
-	if (!idx.childNodes.has(np)) idx.childNodes.set(np, []);
-	idx.childNodes.get(np).push(nodeId);
-	idx.signature = "";
-}
-/** 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);
-	}
-	idx.signature = "";
-}
-
-//#endregion
-export { indexUpdateEdgeEndpoints as a, indexReparentNode as i, indexAddEdge as n, invalidateIndex as o, indexAddNode as r, getIndex as t };