@graphty/algorithms 1.3.1 → 1.4.2

package/src/clustering/spectral.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../core/graph.js";
-import type {NodeId} from "../types/index.js";
-import {euclideanDistance} from "../utils/math-utilities.js";
+import type { Graph } from "../core/graph.js";
+import type { NodeId } from "../types/index.js";
+import { euclideanDistance } from "../utils/math-utilities.js";
 
 /**
  * Spectral Clustering implementation
@@ -29,24 +29,19 @@ export interface SpectralClusteringResult {
 /**
  * Perform spectral clustering on a graph
  *
- * @warning This implementation uses simplified power iteration for eigenvector
+ * Note: This implementation uses simplified power iteration for eigenvector
  * computation with approximate eigenvalues. For production use cases requiring
  * precise clustering, consider using a proper linear algebra library like ml-matrix.
  *
  * The approximate eigenvalues (0.1, 0.2 for second and third eigenvectors) work
  * well for most graph structures but may produce suboptimal results for graphs
  * with unusual spectral properties.
+ * @param graph - The input graph to cluster
+ * @param options - Spectral clustering options (k, laplacianType, etc.)
+ * @returns Spectral clustering result with communities and cluster assignments
  */
-export function spectralClustering(
-    graph: Graph,
-    options: SpectralClusteringOptions,
-): SpectralClusteringResult {
-    const {
-        k,
-        laplacianType = "normalized",
-        maxIterations = 100,
-        tolerance = 1e-4,
-    } = options;
+export function spectralClustering(graph: Graph, options: SpectralClusteringOptions): SpectralClusteringResult {
+    const { k, laplacianType = "normalized", maxIterations = 100, tolerance = 1e-4 } = options;
 
     // Input validation
     if (k < 1 || !Number.isInteger(k)) {
@@ -62,7 +57,7 @@ export function spectralClustering(
         const communities: NodeId[][] = nodeIds.map((id) => [id]);
         const clusterAssignments = new Map<NodeId, number>();
         nodeIds.forEach((id, index) => clusterAssignments.set(id, index));
-        return {communities, clusterAssignments};
+        return { communities, clusterAssignments };
     }
 
     // Build adjacency matrix
@@ -97,7 +92,7 @@ export function spectralClustering(
     const kmeans = kMeansClustering(dataPoints, k, maxIterations, tolerance);
 
     // Build communities
-    const communities: NodeId[][] = Array.from({length: k}, () => []);
+    const communities: NodeId[][] = Array.from({ length: k }, () => []);
     const clusterAssignments = new Map<NodeId, number>();
 
     for (let i = 0; i < nodeIds.length; i++) {
@@ -139,10 +134,13 @@ export function spectralClustering(
 
 /**
  * Build adjacency matrix from graph
+ * @param graph - The input graph
+ * @param nodeIds - Array of node IDs defining matrix index order
+ * @returns Square adjacency matrix with edge weights
  */
 function buildAdjacencyMatrix(graph: Graph, nodeIds: NodeId[]): number[][] {
     const n = nodeIds.length;
-    const matrix: number[][] = Array.from({length: n}, () => Array(n).fill(0) as number[]);
+    const matrix: number[][] = Array.from({ length: n }, () => Array(n).fill(0) as number[]);
     const nodeToIndex = new Map<NodeId, number>();
 
     nodeIds.forEach((id, index) => nodeToIndex.set(id, index));
@@ -180,10 +178,13 @@ function buildAdjacencyMatrix(graph: Graph, nodeIds: NodeId[]): number[][] {
 
 /**
  * Build Laplacian matrix from adjacency matrix
+ * @param adjacency - Square adjacency matrix
+ * @param type - Type of Laplacian (unnormalized, normalized, or randomWalk)
+ * @returns The computed Laplacian matrix
  */
 function buildLaplacianMatrix(adjacency: number[][], type: string): number[][] {
     const n = adjacency.length;
-    const laplacian: number[][] = Array.from({length: n}, () => Array(n).fill(0) as number[]);
+    const laplacian: number[][] = Array.from({ length: n }, () => Array(n).fill(0) as number[]);
 
     // Calculate degree matrix
     const degrees = Array(n).fill(0) as number[];
@@ -239,7 +240,14 @@ function buildLaplacianMatrix(adjacency: number[][], type: string): number[][] {
                     const adjacencyVal = adjacencyRow[j];
                     const di = degrees[i];
                     const dj = degrees[j];
-                    if (adjacencyVal !== undefined && adjacencyVal > 0 && di !== undefined && dj !== undefined && di > 0 && dj > 0) {
+                    if (
+                        adjacencyVal !== undefined &&
+                        adjacencyVal > 0 &&
+                        di !== undefined &&
+                        dj !== undefined &&
+                        di > 0 &&
+                        dj > 0
+                    ) {
                         const laplacianRow = laplacian[i];
                         if (laplacianRow) {
                             laplacianRow[j] = -adjacencyVal / Math.sqrt(di * dj);
@@ -283,15 +291,21 @@ function buildLaplacianMatrix(adjacency: number[][], type: string): number[][] {
 /**
  * Find k smallest eigenvectors using simplified eigendecomposition
  * This is a simplified implementation - in practice, you'd use LAPACK or similar
+ * @param matrix - The Laplacian matrix for eigendecomposition
+ * @param k - Number of smallest eigenvectors to find
+ * @returns Object containing eigenvalues and corresponding eigenvectors
  */
-function findSmallestEigenvectors(matrix: number[][], k: number): {
+function findSmallestEigenvectors(
+    matrix: number[][],
+    k: number,
+): {
     eigenvalues: number[];
     eigenvectors: number[][];
 } {
     const n = matrix.length;
 
     if (n === 0 || k === 0) {
-        return {eigenvalues: [], eigenvectors: []};
+        return { eigenvalues: [], eigenvectors: [] };
     }
 
     // For very small matrices, use the full power iteration approach
@@ -314,10 +328,12 @@ function findSmallestEigenvectors(matrix: number[][], k: number): {
 
     for (let eigIdx = 0; eigIdx < k; eigIdx++) {
         // Initialize random vector
-        let vector = Array(n).fill(0).map(() => Math.random() - 0.5);
+        let vector = Array(n)
+            .fill(0)
+            .map(() => Math.random() - 0.5);
 
         // Normalize initial vector
-        const initNorm = Math.sqrt(vector.reduce((sum, val) => sum + (val * val), 0));
+        const initNorm = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
         if (initNorm > 0) {
             vector = vector.map((val) => val / initNorm);
         }
@@ -329,8 +345,8 @@ function findSmallestEigenvectors(matrix: number[][], k: number): {
                 continue;
             }
 
-            const dot = vector.reduce((sum, val, idx) => sum + (val * (ejVector[idx] ?? 0)), 0);
-            vector = vector.map((val, idx) => val - (dot * (ejVector[idx] ?? 0)));
+            const dot = vector.reduce((sum, val, idx) => sum + val * (ejVector[idx] ?? 0), 0);
+            vector = vector.map((val, idx) => val - dot * (ejVector[idx] ?? 0));
         }
 
         // Power iteration
@@ -345,7 +361,7 @@ function findSmallestEigenvectors(matrix: number[][], k: number): {
                     if (matrixVal !== undefined && vecVal !== undefined) {
                         const nvVal = newVector[i];
                         if (nvVal !== undefined) {
-                            newVector[i] = nvVal + (matrixVal * vecVal);
+                            newVector[i] = nvVal + matrixVal * vecVal;
                         }
                     }
                 }
@@ -358,20 +374,20 @@ function findSmallestEigenvectors(matrix: number[][], k: number): {
                     continue;
                 }
 
-                const dot = newVector.reduce((sum, val, idx) => sum + (val * (ejVector[idx] ?? 0)), 0);
+                const dot = newVector.reduce((sum, val, idx) => sum + val * (ejVector[idx] ?? 0), 0);
                 for (let i = 0; i < n; i++) {
                     const ejVal = ejVector[i];
                     if (ejVal !== undefined) {
                         const nvVal = newVector[i];
                         if (nvVal !== undefined) {
-                            newVector[i] = nvVal - (dot * ejVal);
+                            newVector[i] = nvVal - dot * ejVal;
                         }
                     }
                 }
             }
 
             // Normalize
-            const norm = Math.sqrt(newVector.reduce((sum, val) => sum + ((val * val)), 0));
+            const norm = Math.sqrt(newVector.reduce((sum, val) => sum + val * val, 0));
             if (norm > 1e-10) {
                 vector = newVector.map((val) => val / norm);
             } else {
@@ -390,29 +406,30 @@ function findSmallestEigenvectors(matrix: number[][], k: number): {
                 if (matrixVal !== undefined && vecVal !== undefined) {
                     const avVal = Av[i];
                     if (avVal !== undefined) {
-                        Av[i] = avVal + (matrixVal * vecVal);
+                        Av[i] = avVal + matrixVal * vecVal;
                     }
                 }
             }
         }
         eigenvalue = vector.reduce((sum, val, idx) => {
             const avVal = Av[idx];
-            return sum + (val * (avVal ?? 0));
+            return sum + val * (avVal ?? 0);
         }, 0);
 
         eigenvectors.push(vector);
         eigenvalues.push(eigenvalue);
     }
 
-    return {eigenvalues, eigenvectors};
+    return { eigenvalues, eigenvectors };
 }
 
 /**
  * Normalize matrix rows to unit length
+ * @param matrix - Matrix to normalize in place
  */
 function normalizeRows(matrix: number[][]): void {
     for (const row of matrix) {
-        const norm = Math.sqrt(row.reduce((sum, val) => sum + (val * val), 0));
+        const norm = Math.sqrt(row.reduce((sum, val) => sum + val * val, 0));
         if (norm > 0) {
             for (let j = 0; j < row.length; j++) {
                 const val = row[j];
@@ -426,25 +443,30 @@ function normalizeRows(matrix: number[][]): void {
 
 /**
  * K-means clustering algorithm
+ * @param data - Array of data points, each point is an array of coordinates
+ * @param k - Number of clusters to form
+ * @param maxIterations - Maximum number of iterations
+ * @param tolerance - Convergence tolerance for centroid movement
+ * @returns Object containing cluster assignments and final centroids
  */
 function kMeansClustering(
     data: number[][],
     k: number,
     maxIterations: number,
     tolerance = 1e-4,
-): {assignments: number[], centroids: number[][]} {
+): { assignments: number[]; centroids: number[][] } {
     const n = data.length;
     const d = data[0]?.length ?? 0;
 
     // Handle edge cases
     if (n === 0 || k === 0) {
-        return {assignments: [], centroids: []};
+        return { assignments: [], centroids: [] };
     }
 
     if (k >= n) {
         // Each point is its own cluster
         return {
-            assignments: Array.from({length: n}, (_, i) => i),
+            assignments: Array.from({ length: n }, (_, i) => i),
             centroids: data.slice(0, n),
         };
     }
@@ -457,7 +479,7 @@ function kMeansClustering(
         const idx = Math.floor(Math.random() * n);
         if (!selectedIndices.has(idx) && data[idx]) {
             selectedIndices.add(idx);
-            centroids.push([... data[idx]]);
+            centroids.push([...data[idx]]);
         }
     }
 
@@ -509,14 +531,14 @@ function kMeansClustering(
             break;
         }
 
-        oldAssignments = [... assignments];
+        oldAssignments = [...assignments];
 
         // Store old centroids for tolerance-based convergence check
-        const oldCentroids = centroids.map((c) => [... c]);
+        const oldCentroids = centroids.map((c) => [...c]);
 
         // Update centroids
         const counts = Array(k).fill(0) as number[];
-        const sums: number[][] = Array.from({length: k}, () => Array(d).fill(0) as number[]);
+        const sums: number[][] = Array.from({ length: k }, () => Array(d).fill(0) as number[]);
 
         for (let i = 0; i < n; i++) {
             const cluster = assignments[i] ?? 0;
@@ -581,13 +603,21 @@ function kMeansClustering(
         }
     }
 
-    return {assignments, centroids};
+    return { assignments, centroids };
 }
 
 /**
  * Compute smallest eigenvectors for small k (optimized for k=2, k=3)
+ * @param matrix - The Laplacian matrix
+ * @param k - Number of eigenvectors to compute (1-3)
+ * @param n - Size of the matrix
+ * @returns Object containing eigenvalues and eigenvectors
  */
-function computeSmallestEigenvectorsSimple(matrix: number[][], k: number, n: number): {
+function computeSmallestEigenvectorsSimple(
+    matrix: number[][],
+    k: number,
+    n: number,
+): {
     eigenvalues: number[];
     eigenvectors: number[][];
 } {
@@ -603,11 +633,13 @@ function computeSmallestEigenvectorsSimple(matrix: number[][], k: number, n: num
     if (k >= 2) {
         // Use power iteration on I - L/lambda_max to find second smallest
         const maxEig = 2; // For normalized Laplacian, max eigenvalue <= 2
-        let vector = Array(n).fill(0).map(() => Math.random() - 0.5);
+        let vector = Array(n)
+            .fill(0)
+            .map(() => Math.random() - 0.5);
 
         // Make orthogonal to first eigenvector
-        const dot1 = vector.reduce((sum, val) => sum + (val / Math.sqrt(n)), 0);
-        vector = vector.map((val) => val - (dot1 / Math.sqrt(n)));
+        const dot1 = vector.reduce((sum, val) => sum + val / Math.sqrt(n), 0);
+        vector = vector.map((val) => val - dot1 / Math.sqrt(n));
 
         // Power iteration on shifted matrix
         for (let iter = 0; iter < 100; iter++) {
@@ -624,18 +656,18 @@ function computeSmallestEigenvectorsSimple(matrix: number[][], k: number, n: num
                 for (let j = 0; j < n; j++) {
                     const matrixVal = matrix[i]?.[j] ?? 0;
                     const vecVal = vector[j] ?? 0;
-                    newVector[i] = (newVector[i] ?? 0) - ((matrixVal * vecVal) / maxEig);
+                    newVector[i] = (newVector[i] ?? 0) - (matrixVal * vecVal) / maxEig;
                 }
             }
 
             // Orthogonalize against first eigenvector
-            const dot = newVector.reduce((sum, val) => sum + (val / Math.sqrt(n)), 0);
+            const dot = newVector.reduce((sum, val) => sum + val / Math.sqrt(n), 0);
             for (let i = 0; i < n; i++) {
-                newVector[i] = (newVector[i] ?? 0) - (dot / Math.sqrt(n));
+                newVector[i] = (newVector[i] ?? 0) - dot / Math.sqrt(n);
             }
 
             // Normalize
-            const norm = Math.sqrt(newVector.reduce((sum, val) => sum + (val * val), 0));
+            const norm = Math.sqrt(newVector.reduce((sum, val) => sum + val * val, 0));
             if (norm > 1e-10) {
                 vector = newVector.map((val) => val / norm);
             }
@@ -647,12 +679,14 @@ function computeSmallestEigenvectorsSimple(matrix: number[][], k: number, n: num
 
     // For k = 3, add another eigenvector
     if (k >= 3) {
-        let vector = Array(n).fill(0).map(() => Math.random() - 0.5);
+        let vector = Array(n)
+            .fill(0)
+            .map(() => Math.random() - 0.5);
 
         // Orthogonalize against previous eigenvectors
         for (const prev of eigenvectors) {
-            const dot = vector.reduce((sum, val, idx) => sum + (val * (prev[idx] ?? 0)), 0);
-            vector = vector.map((val, idx) => val - (dot * (prev[idx] ?? 0)));
+            const dot = vector.reduce((sum, val, idx) => sum + val * (prev[idx] ?? 0), 0);
+            vector = vector.map((val, idx) => val - dot * (prev[idx] ?? 0));
         }
 
         // Similar power iteration
@@ -669,20 +703,20 @@ function computeSmallestEigenvectorsSimple(matrix: number[][], k: number, n: num
                 for (let j = 0; j < n; j++) {
                     const matrixVal = matrix[i]?.[j] ?? 0;
                     const vecVal = vector[j] ?? 0;
-                    newVector[i] = (newVector[i] ?? 0) - ((matrixVal * vecVal) / 2);
+                    newVector[i] = (newVector[i] ?? 0) - (matrixVal * vecVal) / 2;
                 }
             }
 
             // Orthogonalize
             for (const prev of eigenvectors) {
-                const dot = newVector.reduce((sum, val, idx) => sum + (val * (prev[idx] ?? 0)), 0);
+                const dot = newVector.reduce((sum, val, idx) => sum + val * (prev[idx] ?? 0), 0);
                 for (let i = 0; i < n; i++) {
-                    newVector[i] = (newVector[i] ?? 0) - (dot * (prev[i] ?? 0));
+                    newVector[i] = (newVector[i] ?? 0) - dot * (prev[i] ?? 0);
                 }
             }
 
             // Normalize
-            const norm = Math.sqrt(newVector.reduce((sum, val) => sum + (val * val), 0));
+            const norm = Math.sqrt(newVector.reduce((sum, val) => sum + val * val, 0));
             if (norm > 1e-10) {
                 vector = newVector.map((val) => val / norm);
             }
@@ -692,5 +726,5 @@ function computeSmallestEigenvectorsSimple(matrix: number[][], k: number, n: num
         eigenvalues.push(0.2); // Approximate
     }
 
-    return {eigenvalues: eigenvalues.slice(0, k), eigenvectors: eigenvectors.slice(0, k)};
+    return { eigenvalues: eigenvalues.slice(0, k), eigenvectors: eigenvectors.slice(0, k) };
 }

package/src/core/graph.ts

@@ -1,4 +1,4 @@
-import type {Edge, GraphConfig, Node, NodeId} from "../types/index.js";
+import type { Edge, GraphConfig, Node, NodeId } from "../types/index.js";
 
 /**
  * Core Graph data structure for the Graphty Algorithms library
@@ -13,12 +13,16 @@ export class Graph {
     private config: GraphConfig;
     private edgeCount: number;
 
+    /**
+     * Creates a new Graph instance.
+     * @param config - Configuration options for the graph
+     */
     constructor(config: Partial<GraphConfig> = {}) {
         this.config = {
             directed: false,
             allowSelfLoops: true,
             allowParallelEdges: false,
-            ... config,
+            ...config,
         };
         this.nodeMap = new Map();
         this.adjacencyList = new Map();
@@ -28,10 +32,12 @@ export class Graph {
 
     /**
      * Add a node to the graph
+     * @param id - The unique identifier for the node
+     * @param data - Optional key-value data to attach to the node
      */
     addNode(id: NodeId, data?: Record<string, unknown>): void {
         if (!this.nodeMap.has(id)) {
-            this.nodeMap.set(id, {id, data});
+            this.nodeMap.set(id, { id, data });
             this.adjacencyList.set(id, new Map());
 
             if (this.config.directed) {
@@ -42,6 +48,8 @@ export class Graph {
 
     /**
      * Remove a node from the graph
+     * @param id - The unique identifier of the node to remove
+     * @returns True if the node was removed, false if it did not exist
      */
     removeNode(id: NodeId): boolean {
         if (!this.nodeMap.has(id)) {
@@ -85,6 +93,10 @@ export class Graph {
 
     /**
      * Add an edge to the graph
+     * @param source - The source node identifier
+     * @param target - The target node identifier
+     * @param weight - The weight of the edge (defaults to 1)
+     * @param data - Optional key-value data to attach to the edge
      */
     addEdge(source: NodeId, target: NodeId, weight = 1, data?: Record<string, unknown>): void {
         // Ensure both nodes exist
@@ -101,7 +113,7 @@ export class Graph {
             throw new Error("Parallel edges are not allowed in this graph");
         }
 
-        const edge: Edge = {source, target, weight, data};
+        const edge: Edge = { source, target, weight, data };
 
         // Add to adjacency list
         const sourceAdjacency = this.adjacencyList.get(source);
@@ -120,7 +132,7 @@ export class Graph {
         } else {
             // For undirected graphs, add the reverse edge
             if (source !== target) {
-                const reverseEdge: Edge = {source: target, target: source, weight, data};
+                const reverseEdge: Edge = { source: target, target: source, weight, data };
                 const targetAdjacency = this.adjacencyList.get(target);
 
                 if (targetAdjacency) {
@@ -134,6 +146,9 @@ export class Graph {
 
     /**
      * Remove an edge from the graph
+     * @param source - The source node identifier
+     * @param target - The target node identifier
+     * @returns True if the edge was removed, false if it did not exist
      */
     removeEdge(source: NodeId, target: NodeId): boolean {
         const sourceEdges = this.adjacencyList.get(source);
@@ -162,6 +177,8 @@ export class Graph {
 
     /**
      * Check if a node exists in the graph
+     * @param id - The unique identifier of the node to check
+     * @returns True if the node exists, false otherwise
      */
     hasNode(id: NodeId): boolean {
         return this.nodeMap.has(id);
@@ -169,6 +186,9 @@ export class Graph {
 
     /**
      * Check if an edge exists in the graph
+     * @param source - The source node identifier
+     * @param target - The target node identifier
+     * @returns True if the edge exists, false otherwise
      */
     hasEdge(source: NodeId, target: NodeId): boolean {
         const sourceEdges = this.adjacencyList.get(source);
@@ -177,6 +197,8 @@ export class Graph {
 
     /**
      * Get a node by ID
+     * @param id - The unique identifier of the node to retrieve
+     * @returns The node if found, undefined otherwise
      */
     getNode(id: NodeId): Node | undefined {
         return this.nodeMap.get(id);
@@ -184,6 +206,9 @@ export class Graph {
 
     /**
      * Get an edge by source and target
+     * @param source - The source node identifier
+     * @param target - The target node identifier
+     * @returns The edge if found, undefined otherwise
      */
     getEdge(source: NodeId, target: NodeId): Edge | undefined {
         const sourceEdges = this.adjacencyList.get(source);
@@ -192,6 +217,7 @@ export class Graph {
 
     /**
      * Get the number of nodes in the graph
+     * @returns The total count of nodes
      */
     get nodeCount(): number {
         return this.nodeMap.size;
@@ -199,6 +225,7 @@ export class Graph {
 
     /**
      * Get the number of edges in the graph
+     * @returns The total count of edges
      */
     get totalEdgeCount(): number {
         return this.edgeCount;
@@ -206,6 +233,7 @@ export class Graph {
 
     /**
      * Check if the graph is directed
+     * @returns True if the graph is directed, false otherwise
      */
     get isDirected(): boolean {
         return this.config.directed;
@@ -213,6 +241,7 @@ export class Graph {
 
     /**
      * Get all nodes in the graph
+     * @returns An iterator over all nodes
      */
     nodes(): IterableIterator<Node> {
         return this.nodeMap.values();
@@ -220,6 +249,7 @@ export class Graph {
 
     /**
      * Get all edges in the graph
+     * @yields Each unique edge in the graph
      */
     *edges(): IterableIterator<Edge> {
         for (const [source, edges] of this.adjacencyList) {
@@ -236,6 +266,8 @@ export class Graph {
 
     /**
      * Get neighbors of a node (outgoing edges)
+     * @param nodeId - The node identifier to get neighbors for
+     * @returns An iterator over the neighbor node identifiers
      */
     neighbors(nodeId: NodeId): IterableIterator<NodeId> {
         const edges = this.adjacencyList.get(nodeId);
@@ -244,6 +276,8 @@ export class Graph {
 
     /**
      * Get incoming neighbors of a node (directed graphs only)
+     * @param nodeId - The node identifier to get incoming neighbors for
+     * @returns An iterator over the incoming neighbor node identifiers
      */
     inNeighbors(nodeId: NodeId): IterableIterator<NodeId> {
         if (!this.config.directed) {
@@ -256,6 +290,8 @@ export class Graph {
 
     /**
      * Get outgoing neighbors of a node
+     * @param nodeId - The node identifier to get outgoing neighbors for
+     * @returns An iterator over the outgoing neighbor node identifiers
      */
     outNeighbors(nodeId: NodeId): IterableIterator<NodeId> {
         return this.neighbors(nodeId);
@@ -263,6 +299,8 @@ export class Graph {
 
     /**
      * Get the degree of a node
+     * @param nodeId - The node identifier to get the degree for
+     * @returns The total degree of the node
      */
     degree(nodeId: NodeId): number {
         if (this.config.directed) {
@@ -275,6 +313,8 @@ export class Graph {
 
     /**
      * Get the in-degree of a node
+     * @param nodeId - The node identifier to get the in-degree for
+     * @returns The number of incoming edges to the node
      */
     inDegree(nodeId: NodeId): number {
         if (!this.config.directed) {
@@ -287,6 +327,8 @@ export class Graph {
 
     /**
      * Get the out-degree of a node
+     * @param nodeId - The node identifier to get the out-degree for
+     * @returns The number of outgoing edges from the node
      */
     outDegree(nodeId: NodeId): number {
         const edges = this.adjacencyList.get(nodeId);
@@ -295,23 +337,19 @@ export class Graph {
 
     /**
      * Create a copy of the graph
+     * @returns A new Graph instance with the same nodes and edges
      */
     clone(): Graph {
         const cloned = new Graph(this.config);
 
         // Copy nodes
         for (const node of this.nodeMap.values()) {
-            cloned.addNode(node.id, node.data ? {... node.data} : undefined);
+            cloned.addNode(node.id, node.data ? { ...node.data } : undefined);
         }
 
         // Copy edges
         for (const edge of this.edges()) {
-            cloned.addEdge(
-                edge.source,
-                edge.target,
-                edge.weight,
-                edge.data ? {... edge.data} : undefined,
-            );
+            cloned.addEdge(edge.source, edge.target, edge.weight, edge.data ? { ...edge.data } : undefined);
         }
 
         return cloned;
@@ -319,9 +357,10 @@ export class Graph {
 
     /**
      * Get graph configuration
+     * @returns A copy of the graph configuration object
      */
     getConfig(): GraphConfig {
-        return {... this.config};
+        return { ...this.config };
     }
 
     /**
@@ -337,6 +376,7 @@ export class Graph {
     /**
      * Get the number of unique edges in the graph
      * For undirected graphs, each edge is counted once
+     * @returns The count of unique edges
      */
     get uniqueEdgeCount(): number {
         if (this.config.directed) {
@@ -345,7 +385,7 @@ export class Graph {
 
         // For undirected graphs, we need to count each edge only once
         let count = 0;
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+         
         for (const _edge of this.edges()) {
             count++;
         }

package/src/data-structures/index.ts

@@ -2,5 +2,5 @@
  * Data structures supporting graph algorithms
  */
 
-export {PriorityQueue} from "./priority-queue.js";
-export {UnionFind} from "./union-find.js";
+export { PriorityQueue } from "./priority-queue.js";
+export { UnionFind } from "./union-find.js";