@graphty/algorithms 1.3.1 → 1.5.0

package/src/algorithms/traversal/bfs-unified.ts

@@ -1,9 +1,9 @@
-import type {Graph} from "../../core/graph.js";
-import {CSRGraph} from "../../optimized/csr-graph.js";
-import {DirectionOptimizedBFS} from "../../optimized/direction-optimized-bfs.js";
-import {toCSRGraph} from "../../optimized/graph-adapter.js";
-import type {NodeId, ShortestPathResult, TraversalOptions, TraversalResult} from "../../types/index.js";
-import {reconstructPath} from "../../utils/graph-utilities.js";
+import type { Graph } from "../../core/graph.js";
+import { CSRGraph } from "../../optimized/csr-graph.js";
+import { DirectionOptimizedBFS } from "../../optimized/direction-optimized-bfs.js";
+import { toCSRGraph } from "../../optimized/graph-adapter.js";
+import type { NodeId, ShortestPathResult, TraversalOptions, TraversalResult } from "../../types/index.js";
+import { reconstructPath } from "../../utils/graph-utilities.js";
 
 /**
  * Unified BFS implementation that automatically optimizes for large graphs
@@ -20,6 +20,8 @@ const csrCache = new WeakMap<Graph, CSRGraph>();
 
 /**
  * Get or create CSR representation of a graph
+ * @param graph - The input graph to convert
+ * @returns CSR graph representation (cached for efficiency)
  */
 function getCSRGraph(graph: Graph): CSRGraph {
     let csrGraph = csrCache.get(graph);
@@ -36,12 +38,12 @@ function getCSRGraph(graph: Graph): CSRGraph {
  *
  * Automatically uses the most optimized implementation based on graph size.
  * No configuration needed - just call this function for the best performance.
+ * @param graph - The input graph to traverse
+ * @param startNode - The node to start the BFS from
+ * @param options - Traversal options (callbacks, target node, etc.)
+ * @returns Traversal result with visited nodes, order, and tree structure
  */
-export function breadthFirstSearch(
-    graph: Graph,
-    startNode: NodeId,
-    options: TraversalOptions = {},
-): TraversalResult {
+export function breadthFirstSearch(graph: Graph, startNode: NodeId, options: TraversalOptions = {}): TraversalResult {
     if (!graph.hasNode(startNode)) {
         throw new Error(`Start node ${String(startNode)} not found in graph`);
     }
@@ -57,19 +59,19 @@ export function breadthFirstSearch(
 
 /**
  * Standard BFS implementation for smaller graphs
+ * @param graph - The input graph to traverse
+ * @param startNode - The node to start the BFS from
+ * @param options - Traversal options (callbacks, target node, etc.)
+ * @returns Traversal result with visited nodes, order, and tree structure
  */
-function breadthFirstSearchStandard(
-    graph: Graph,
-    startNode: NodeId,
-    options: TraversalOptions = {},
-): TraversalResult {
+function breadthFirstSearchStandard(graph: Graph, startNode: NodeId, options: TraversalOptions = {}): TraversalResult {
     const visited = new Set<NodeId>();
-    const queue: {node: NodeId, level: number}[] = [];
+    const queue: { node: NodeId; level: number }[] = [];
     const order: NodeId[] = [];
     const tree = new Map<NodeId, NodeId | null>();
 
     // Initialize with start node
-    queue.push({node: startNode, level: 0});
+    queue.push({ node: startNode, level: 0 });
     visited.add(startNode);
     tree.set(startNode, null);
 
@@ -96,22 +98,22 @@ function breadthFirstSearchStandard(
             if (!visited.has(neighbor)) {
                 visited.add(neighbor);
                 tree.set(neighbor, current.node);
-                queue.push({node: neighbor, level: current.level + 1});
+                queue.push({ node: neighbor, level: current.level + 1 });
             }
         }
     }
 
-    return {visited, order, tree};
+    return { visited, order, tree };
 }
 
 /**
  * Optimized BFS implementation using Direction-Optimized BFS
+ * @param graph - The input graph to traverse
+ * @param startNode - The node to start the BFS from
+ * @param options - Traversal options (callbacks, target node, etc.)
+ * @returns Traversal result with visited nodes, order, and tree structure
  */
-function breadthFirstSearchOptimized(
-    graph: Graph,
-    startNode: NodeId,
-    options: TraversalOptions = {},
-): TraversalResult {
+function breadthFirstSearchOptimized(graph: Graph, startNode: NodeId, options: TraversalOptions = {}): TraversalResult {
     const csrGraph = getCSRGraph(graph);
 
     const dobfs = new DirectionOptimizedBFS(csrGraph, {
@@ -146,7 +148,7 @@ function breadthFirstSearchOptimized(
     for (let d = 0; d <= maxDistance; d++) {
         const nodes = nodesByDistance.get(d);
         if (nodes) {
-            order.push(... nodes);
+            order.push(...nodes);
         }
     }
 
@@ -157,19 +159,19 @@ function breadthFirstSearchOptimized(
         }
     }
 
-    return {visited, order, tree};
+    return { visited, order, tree };
 }
 
 /**
  * Find shortest path between two nodes using BFS
  *
  * Automatically optimized for large graphs. Returns null if no path exists.
+ * @param graph - The input graph to search
+ * @param source - The source node ID
+ * @param target - The target node ID
+ * @returns Shortest path result or null if no path exists
  */
-export function shortestPathBFS(
-    graph: Graph,
-    source: NodeId,
-    target: NodeId,
-): ShortestPathResult | null {
+export function shortestPathBFS(graph: Graph, source: NodeId, target: NodeId): ShortestPathResult | null {
     if (!graph.hasNode(source)) {
         throw new Error(`Source node ${String(source)} not found in graph`);
     }
@@ -198,18 +200,18 @@ export function shortestPathBFS(
 
 /**
  * Standard shortest path BFS
+ * @param graph - The input graph to search
+ * @param source - The source node ID
+ * @param target - The target node ID
+ * @returns Shortest path result or null if no path exists
  */
-function shortestPathBFSStandard(
-    graph: Graph,
-    source: NodeId,
-    target: NodeId,
-): ShortestPathResult | null {
+function shortestPathBFSStandard(graph: Graph, source: NodeId, target: NodeId): ShortestPathResult | null {
     const visited = new Set<NodeId>();
-    const queue: {node: NodeId, distance: number}[] = [];
+    const queue: { node: NodeId; distance: number }[] = [];
     const predecessor = new Map<NodeId, NodeId | null>();
 
     // Initialize BFS
-    queue.push({node: source, distance: 0});
+    queue.push({ node: source, distance: 0 });
     visited.add(source);
     predecessor.set(source, null);
 
@@ -234,7 +236,7 @@ function shortestPathBFSStandard(
             if (!visited.has(neighbor)) {
                 visited.add(neighbor);
                 predecessor.set(neighbor, current.node);
-                queue.push({node: neighbor, distance: current.distance + 1});
+                queue.push({ node: neighbor, distance: current.distance + 1 });
             }
         }
     }
@@ -245,12 +247,12 @@ function shortestPathBFSStandard(
 
 /**
  * Optimized shortest path using Direction-Optimized BFS
+ * @param graph - The input graph to search
+ * @param source - The source node ID
+ * @param target - The target node ID
+ * @returns Shortest path result or null if no path exists
  */
-function shortestPathBFSOptimized(
-    graph: Graph,
-    source: NodeId,
-    target: NodeId,
-): ShortestPathResult | null {
+function shortestPathBFSOptimized(graph: Graph, source: NodeId, target: NodeId): ShortestPathResult | null {
     const csrGraph = getCSRGraph(graph);
 
     const dobfs = new DirectionOptimizedBFS(csrGraph, {
@@ -281,11 +283,11 @@ function shortestPathBFSOptimized(
  * Find shortest paths from source to all reachable nodes
  *
  * Automatically optimized for large graphs.
+ * @param graph - The input graph to search
+ * @param source - The source node ID to compute shortest paths from
+ * @returns Map of node IDs to their shortest path results
  */
-export function singleSourceShortestPathBFS(
-    graph: Graph,
-    source: NodeId,
-): Map<NodeId, ShortestPathResult> {
+export function singleSourceShortestPathBFS(graph: Graph, source: NodeId): Map<NodeId, ShortestPathResult> {
     if (!graph.hasNode(source)) {
         throw new Error(`Source node ${String(source)} not found in graph`);
     }
@@ -301,19 +303,19 @@ export function singleSourceShortestPathBFS(
 
 /**
  * Standard single-source shortest paths
+ * @param graph - The input graph to search
+ * @param source - The source node ID to compute shortest paths from
+ * @returns Map of node IDs to their shortest path results
  */
-function singleSourceShortestPathBFSStandard(
-    graph: Graph,
-    source: NodeId,
-): Map<NodeId, ShortestPathResult> {
+function singleSourceShortestPathBFSStandard(graph: Graph, source: NodeId): Map<NodeId, ShortestPathResult> {
     const results = new Map<NodeId, ShortestPathResult>();
     const visited = new Set<NodeId>();
-    const queue: {node: NodeId, distance: number}[] = [];
+    const queue: { node: NodeId; distance: number }[] = [];
     const predecessor = new Map<NodeId, NodeId | null>();
     const distances = new Map<NodeId, number>();
 
     // Initialize BFS
-    queue.push({node: source, distance: 0});
+    queue.push({ node: source, distance: 0 });
     visited.add(source);
     predecessor.set(source, null);
     distances.set(source, 0);
@@ -330,7 +332,7 @@ function singleSourceShortestPathBFSStandard(
                 visited.add(neighbor);
                 predecessor.set(neighbor, current.node);
                 distances.set(neighbor, current.distance + 1);
-                queue.push({node: neighbor, distance: current.distance + 1});
+                queue.push({ node: neighbor, distance: current.distance + 1 });
             }
         }
     }
@@ -351,11 +353,11 @@ function singleSourceShortestPathBFSStandard(
 
 /**
  * Optimized single-source shortest paths
+ * @param graph - The input graph to search
+ * @param source - The source node ID to compute shortest paths from
+ * @returns Map of node IDs to their shortest path results
  */
-function singleSourceShortestPathBFSOptimized(
-    graph: Graph,
-    source: NodeId,
-): Map<NodeId, ShortestPathResult> {
+function singleSourceShortestPathBFSOptimized(graph: Graph, source: NodeId): Map<NodeId, ShortestPathResult> {
     const csrGraph = getCSRGraph(graph);
 
     const dobfs = new DirectionOptimizedBFS(csrGraph, {
@@ -387,6 +389,8 @@ function singleSourceShortestPathBFSOptimized(
  *
  * Note: This function does not use Direction-Optimized BFS as the
  * coloring logic is specific and doesn't benefit from the optimization.
+ * @param graph - The undirected graph to check
+ * @returns True if the graph is bipartite, false otherwise
  */
 export function isBipartite(graph: Graph): boolean {
     if (graph.isDirected) {

package/src/algorithms/traversal/bfs-variants.ts

@@ -1,9 +1,9 @@
-import type {Graph} from "../../core/graph.js";
-import {PriorityQueue} from "../../data-structures/priority-queue.js";
-import {CSRGraph} from "../../optimized/csr-graph.js";
-import {DirectionOptimizedBFS} from "../../optimized/direction-optimized-bfs.js";
-import {toCSRGraph} from "../../optimized/graph-adapter.js";
-import type {NodeId} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import { PriorityQueue } from "../../data-structures/priority-queue.js";
+import { CSRGraph } from "../../optimized/csr-graph.js";
+import { DirectionOptimizedBFS } from "../../optimized/direction-optimized-bfs.js";
+import { toCSRGraph } from "../../optimized/graph-adapter.js";
+import type { NodeId } from "../../types/index.js";
 
 /**
  * Threshold for switching to CSR-optimized implementations.
@@ -20,17 +20,22 @@ const LARGE_GRAPH_THRESHOLD = 10000;
  * - All predecessors on shortest paths
  * - Number of shortest paths (sigma)
  * - Stack of nodes in reverse BFS order
+ * @param graph - The input graph to traverse
+ * @param source - The source node to start BFS from
+ * @param options - Configuration options
+ * @param options.optimized - Whether to use CSR-optimized implementation for large graphs
+ * @returns Object containing distances, predecessors, path counts (sigma), and traversal stack
  */
 export function bfsWithPathCounting(
     graph: Graph,
     source: NodeId,
-    options: {optimized?: boolean} = {},
+    options: { optimized?: boolean } = {},
 ): {
-        distances: Map<NodeId, number>;
-        predecessors: Map<NodeId, NodeId[]>;
-        sigma: Map<NodeId, number>;
-        stack: NodeId[];
-    } {
+    distances: Map<NodeId, number>;
+    predecessors: Map<NodeId, NodeId[]>;
+    sigma: Map<NodeId, number>;
+    stack: NodeId[];
+} {
     const useOptimized = options.optimized ?? false;
 
     // Use CSR format for large graphs
@@ -94,12 +99,18 @@ export function bfsWithPathCounting(
  * BFS that only returns distances (for closeness centrality)
  *
  * Optimized variant that skips predecessor tracking
+ * @param graph - The input graph to traverse
+ * @param source - The source node to start BFS from
+ * @param cutoff - Maximum distance to explore (optional)
+ * @param options - Configuration options
+ * @param options.optimized - Whether to use CSR-optimized implementation for large graphs
+ * @returns Map of node IDs to their shortest distances from the source
  */
 export function bfsDistancesOnly(
     graph: Graph,
     source: NodeId,
     cutoff?: number,
-    options: {optimized?: boolean} = {},
+    options: { optimized?: boolean } = {},
 ): Map<NodeId, number> {
     const useOptimized = options.optimized ?? false;
 
@@ -144,13 +155,13 @@ export function bfsDistancesOnly(
  * BFS for bipartite checking with partition sets
  *
  * Returns whether the graph is bipartite and the two partitions if it is
+ * @param graph - The input graph to check for bipartiteness
+ * @returns Object with bipartite status and optional partition sets
  */
-export function bfsColoringWithPartitions(
-    graph: Graph,
-): {
-        isBipartite: boolean;
-        partitions?: [Set<NodeId>, Set<NodeId>];
-    } {
+export function bfsColoringWithPartitions(graph: Graph): {
+    isBipartite: boolean;
+    partitions?: [Set<NodeId>, Set<NodeId>];
+} {
     const colors = new Map<NodeId, number>();
     const partitionA = new Set<NodeId>();
     const partitionB = new Set<NodeId>();
@@ -183,7 +194,7 @@ export function bfsColoringWithPartitions(
                         }
                     } else if (colors.get(neighbor) === currentColor) {
                         // Same color as current node - not bipartite
-                        return {isBipartite: false};
+                        return { isBipartite: false };
                     }
                 }
             }
@@ -200,6 +211,10 @@ export function bfsColoringWithPartitions(
  * BFS for finding augmenting paths (for flow algorithms)
  *
  * Finds a path from source to sink in a residual graph with positive capacity
+ * @param residualGraph - Map representing the residual graph with capacities
+ * @param source - The source node ID
+ * @param sink - The sink node ID
+ * @returns Object with path and capacity, or null if no path exists
  */
 export function bfsAugmentingPath(
     residualGraph: Map<string, Map<string, number>>,
@@ -239,7 +254,7 @@ export function bfsAugmentingPath(
                 node = parentNode ?? null;
             }
 
-            return {path, pathCapacity};
+            return { path, pathCapacity };
         }
 
         const neighbors = residualGraph.get(current);
@@ -260,12 +275,18 @@ export function bfsAugmentingPath(
  * BFS for weighted graphs using priority queue (simplified Dijkstra)
  *
  * Returns distances from source using edge weights
+ * @param graph - The input weighted graph to traverse
+ * @param source - The source node to start BFS from
+ * @param cutoff - Maximum distance to explore (optional)
+ * @param options - Configuration options
+ * @param options.optimized - Whether to use CSR-optimized implementation for large graphs
+ * @returns Map of node IDs to their shortest weighted distances from the source
  */
 export function bfsWeightedDistances(
     graph: Graph,
     source: NodeId,
     cutoff?: number,
-    options: {optimized?: boolean} = {},
+    options: { optimized?: boolean } = {},
 ): Map<NodeId, number> {
     const useOptimized = options.optimized ?? false;
 
@@ -323,16 +344,19 @@ export function bfsWeightedDistances(
 
 /**
  * CSR-optimized version of bfsWithPathCounting
+ * @param graph - The CSR graph representation
+ * @param source - The source node to start BFS from
+ * @returns Object containing distances, predecessors, path counts (sigma), and traversal stack
  */
 function bfsWithPathCountingCSR(
     graph: CSRGraph,
     source: NodeId,
 ): {
-        distances: Map<NodeId, number>;
-        predecessors: Map<NodeId, NodeId[]>;
-        sigma: Map<NodeId, number>;
-        stack: NodeId[];
-    } {
+    distances: Map<NodeId, number>;
+    predecessors: Map<NodeId, NodeId[]>;
+    sigma: Map<NodeId, number>;
+    stack: NodeId[];
+} {
     const distances = new Map<NodeId, number>();
     const predecessors = new Map<NodeId, NodeId[]>();
     const sigma = new Map<NodeId, number>();
@@ -385,12 +409,12 @@ function bfsWithPathCountingCSR(
 
 /**
  * CSR-optimized version of bfsDistancesOnly
+ * @param graph - The CSR graph representation
+ * @param source - The source node to start BFS from
+ * @param cutoff - Maximum distance to explore (optional)
+ * @returns Map of node IDs to their shortest distances from the source
  */
-function bfsDistancesOnlyCSR(
-    graph: CSRGraph,
-    source: NodeId,
-    cutoff?: number,
-): Map<NodeId, number> {
+function bfsDistancesOnlyCSR(graph: CSRGraph, source: NodeId, cutoff?: number): Map<NodeId, number> {
     // Use Direction-Optimized BFS for best performance
     if (graph.nodeCount() > LARGE_GRAPH_THRESHOLD) {
         const dobfs = new DirectionOptimizedBFS(graph);
@@ -443,12 +467,12 @@ function bfsDistancesOnlyCSR(
 
 /**
  * CSR-optimized version of bfsWeightedDistances
+ * @param graph - The CSR graph representation
+ * @param source - The source node to start BFS from
+ * @param cutoff - Maximum distance to explore (optional)
+ * @returns Map of node IDs to their shortest weighted distances from the source
  */
-function bfsWeightedDistancesCSR(
-    graph: CSRGraph,
-    source: NodeId,
-    cutoff?: number,
-): Map<NodeId, number> {
+function bfsWeightedDistancesCSR(graph: CSRGraph, source: NodeId, cutoff?: number): Map<NodeId, number> {
     const distances = new Map<NodeId, number>();
     const visited = new Set<NodeId>();
 

package/src/algorithms/traversal/bfs.ts

@@ -9,10 +9,4 @@
  */
 
 // Re-export unified implementations that automatically optimize for large graphs
-export {
-    breadthFirstSearch,
-    isBipartite,
-    shortestPathBFS,
-    singleSourceShortestPathBFS,
-} from "./bfs-unified.js";
-
+export { breadthFirstSearch, isBipartite, shortestPathBFS, singleSourceShortestPathBFS } from "./bfs-unified.js";

package/src/algorithms/traversal/dfs.ts

@@ -1,5 +1,5 @@
-import {Graph} from "../../core/graph.js";
-import type {NodeId, TraversalOptions, TraversalResult} from "../../types/index.js";
+import { Graph } from "../../core/graph.js";
+import type { NodeId, TraversalOptions, TraversalResult } from "../../types/index.js";
 
 /**
  * Depth-First Search (DFS) implementation
@@ -18,12 +18,12 @@ export interface DFSOptions extends TraversalOptions {
 
 /**
  * Perform depth-first search starting from a given node
+ * @param graph - The input graph to traverse
+ * @param startNode - The node to start the DFS from
+ * @param options - DFS options (recursive mode, pre/post order, etc.)
+ * @returns Traversal result with visited nodes, order, and tree structure
  */
-export function depthFirstSearch(
-    graph: Graph,
-    startNode: NodeId,
-    options: DFSOptions = {},
-): TraversalResult {
+export function depthFirstSearch(graph: Graph, startNode: NodeId, options: DFSOptions = {}): TraversalResult {
     if (!graph.hasNode(startNode)) {
         throw new Error(`Start node ${String(startNode)} not found in graph`);
     }
@@ -38,11 +38,17 @@ export function depthFirstSearch(
         dfsIterative(graph, startNode, visited, order, tree, options);
     }
 
-    return {visited, order, tree};
+    return { visited, order, tree };
 }
 
 /**
  * Iterative DFS implementation (safer for browsers)
+ * @param graph - The input graph to traverse
+ * @param startNode - The node to start the DFS from
+ * @param visited - Set to track visited nodes
+ * @param order - Array to store traversal order
+ * @param tree - Map to store parent relationships
+ * @param options - DFS options (recursive mode, pre/post order, etc.)
  */
 function dfsIterative(
     graph: Graph,
@@ -58,8 +64,8 @@ function dfsIterative(
         return;
     }
 
-    const stack: {node: NodeId, parent: NodeId | null, depth: number}[] = [];
-    stack.push({node: startNode, parent: null, depth: 0});
+    const stack: { node: NodeId; parent: NodeId | null; depth: number }[] = [];
+    stack.push({ node: startNode, parent: null, depth: 0 });
 
     while (stack.length > 0) {
         const current = stack.pop();
@@ -89,7 +95,7 @@ function dfsIterative(
             for (let i = neighbors.length - 1; i >= 0; i--) {
                 const neighbor = neighbors[i];
                 if (neighbor !== undefined && !visited.has(neighbor)) {
-                    stack.push({node: neighbor, parent: current.node, depth: current.depth + 1});
+                    stack.push({ node: neighbor, parent: current.node, depth: current.depth + 1 });
                 }
             }
         }
@@ -98,6 +104,14 @@ function dfsIterative(
 
 /**
  * Recursive DFS implementation
+ * @param graph - The input graph to traverse
+ * @param node - Current node being visited
+ * @param visited - Set to track visited nodes
+ * @param order - Array to store traversal order
+ * @param tree - Map to store parent relationships
+ * @param options - DFS options (recursive mode, pre/post order, etc.)
+ * @param depth - Current depth in the traversal tree
+ * @param parent - Parent node of the current node
  */
 function dfsRecursive(
     graph: Graph,
@@ -145,6 +159,8 @@ function dfsRecursive(
 
 /**
  * Detect cycles in a graph using DFS
+ * @param graph - The input graph to check for cycles
+ * @returns True if the graph contains a cycle, false otherwise
  */
 export function hasCycleDFS(graph: Graph): boolean {
     const visited = new Set<NodeId>();
@@ -170,13 +186,13 @@ export function hasCycleDFS(graph: Graph): boolean {
 
 /**
  * Utility function for cycle detection in directed graphs
+ * @param graph - The directed graph to check
+ * @param node - Current node being visited
+ * @param visited - Set of all visited nodes
+ * @param recursionStack - Set of nodes in the current recursion path
+ * @returns True if a cycle is found, false otherwise
  */
-function hasCycleUtilDirected(
-    graph: Graph,
-    node: NodeId,
-    visited: Set<NodeId>,
-    recursionStack: Set<NodeId>,
-): boolean {
+function hasCycleUtilDirected(graph: Graph, node: NodeId, visited: Set<NodeId>, recursionStack: Set<NodeId>): boolean {
     visited.add(node);
     recursionStack.add(node);
 
@@ -198,13 +214,13 @@ function hasCycleUtilDirected(
 
 /**
  * Utility function for cycle detection in undirected graphs
+ * @param graph - The undirected graph to check
+ * @param node - Current node being visited
+ * @param visited - Set of all visited nodes
+ * @param parent - Parent node of the current node
+ * @returns True if a cycle is found, false otherwise
  */
-function hasCycleUtilUndirected(
-    graph: Graph,
-    node: NodeId,
-    visited: Set<NodeId>,
-    parent: NodeId | null,
-): boolean {
+function hasCycleUtilUndirected(graph: Graph, node: NodeId, visited: Set<NodeId>, parent: NodeId | null): boolean {
     visited.add(node);
 
     // Check all neighbors
@@ -224,6 +240,8 @@ function hasCycleUtilUndirected(
 
 /**
  * Topological sorting using DFS (for directed acyclic graphs)
+ * @param graph - The directed acyclic graph to sort
+ * @returns Array of node IDs in topological order, or null if graph has cycles
  */
 export function topologicalSort(graph: Graph): NodeId[] | null {
     if (!graph.isDirected) {
@@ -251,13 +269,12 @@ export function topologicalSort(graph: Graph): NodeId[] | null {
 
 /**
  * Utility function for topological sorting
+ * @param graph - The directed graph being sorted
+ * @param node - Current node being visited
+ * @param visited - Set of visited nodes
+ * @param stack - Stack to store nodes in reverse topological order
  */
-function topologicalSortUtil(
-    graph: Graph,
-    node: NodeId,
-    visited: Set<NodeId>,
-    stack: NodeId[],
-): void {
+function topologicalSortUtil(graph: Graph, node: NodeId, visited: Set<NodeId>, stack: NodeId[]): void {
     visited.add(node);
 
     // Visit all neighbors first
@@ -273,6 +290,8 @@ function topologicalSortUtil(
 
 /**
  * Find strongly connected components using DFS (for directed graphs)
+ * @param graph - The directed graph to analyze
+ * @returns Array of strongly connected components (each is an array of node IDs)
  */
 export function findStronglyConnectedComponents(graph: Graph): NodeId[][] {
     if (!graph.isDirected) {
@@ -310,13 +329,12 @@ export function findStronglyConnectedComponents(graph: Graph): NodeId[][] {
 
 /**
  * DFS to record finish order
+ * @param graph - The graph being traversed
+ * @param node - Current node being visited
+ * @param visited - Set of visited nodes
+ * @param finishOrder - Array to store nodes in order of completion
  */
-function dfsFinishOrder(
-    graph: Graph,
-    node: NodeId,
-    visited: Set<NodeId>,
-    finishOrder: NodeId[],
-): void {
+function dfsFinishOrder(graph: Graph, node: NodeId, visited: Set<NodeId>, finishOrder: NodeId[]): void {
     visited.add(node);
 
     for (const neighbor of Array.from(graph.neighbors(node))) {
@@ -330,13 +348,12 @@ function dfsFinishOrder(
 
 /**
  * DFS to collect nodes in a component
+ * @param graph - The graph being traversed
+ * @param node - Current node being visited
+ * @param visited - Set of visited nodes
+ * @param component - Array to collect nodes in the current component
  */
-function dfsCollectComponent(
-    graph: Graph,
-    node: NodeId,
-    visited: Set<NodeId>,
-    component: NodeId[],
-): void {
+function dfsCollectComponent(graph: Graph, node: NodeId, visited: Set<NodeId>, component: NodeId[]): void {
     visited.add(node);
     component.push(node);
 
@@ -349,9 +366,11 @@ function dfsCollectComponent(
 
 /**
  * Create transpose (reverse) of a directed graph
+ * @param graph - The directed graph to transpose
+ * @returns A new graph with all edges reversed
  */
 function createTransposeGraph(graph: Graph): Graph {
-    const transpose = new Graph({directed: true});
+    const transpose = new Graph({ directed: true });
 
     // Add all nodes
     for (const node of Array.from(graph.nodes())) {

package/src/algorithms/traversal/index.ts

@@ -2,6 +2,6 @@
  * Graph traversal algorithms
  */
 
-export {breadthFirstSearch, isBipartite, shortestPathBFS, singleSourceShortestPathBFS} from "./bfs.js";
-export type {DFSOptions} from "./dfs.js";
-export {depthFirstSearch, findStronglyConnectedComponents, hasCycleDFS, topologicalSort} from "./dfs.js";
+export { breadthFirstSearch, isBipartite, shortestPathBFS, singleSourceShortestPathBFS } from "./bfs.js";
+export type { DFSOptions } from "./dfs.js";
+export { depthFirstSearch, findStronglyConnectedComponents, hasCycleDFS, topologicalSort } from "./dfs.js";