Ravann patch 1 (#3)

Updated weight function name to NextWeightFnParams ...

Added new unit tests to test the weight function related functionality

Author: ravann

src/algorithms/shortestPath/getPath.ts

@@ -1,13 +1,13 @@
 import type { EdgeWeight, NoInfer } from '../../types.js';
 import type { TraversingTracks } from './types.js';
-import type { WeightParams } from '../../types.js';
+import type { NextWeightFnParams } from '../../types.js';
 
 import { Graph } from '../../Graph.js';
 
 /**
  * Computes edge weight as the sum of all the edges in the path.
  */
-export function addWeightFunction( wp: WeightParams): number {
+export function addWeightFunction( wp: NextWeightFnParams): number {
   if (wp.currentPathWeight === undefined) {
       return wp.edgeWeight;
   }
@@ -23,7 +23,7 @@ export function getPath<Node, LinkProps>(
   tracks: TraversingTracks<NoInfer<Node>>,
   source: NoInfer<Node>,
   destination: NoInfer<Node>,
-  nextWeightFn: (params: WeightParams) => number = addWeightFunction
+  nextWeightFn: (params: NextWeightFnParams) => number = addWeightFunction
 ): {
   nodes: [Node, Node, ...Node[]];
   weight: number | undefined;
@@ -39,7 +39,8 @@ export function getPath<Node, LinkProps>(
     const currentNode = p.get(node)!;
 
     nodeList.push(node);
-    totalWeight = nextWeightFn({ edgeWeight: graph.getEdgeWeight(currentNode, node), currentPathWeight: totalWeight, hop });
+    const edgeWeight = graph.getEdgeWeight(currentNode, node)
+    totalWeight = nextWeightFn({edgeWeight, currentPathWeight: totalWeight, hop });
     node = currentNode;
     hop++;
   }

src/algorithms/shortestPath/shortestPath.spec.ts

@@ -1,8 +1,10 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { Graph } from '../../Graph.js';
 import { serializeGraph } from '../../utils/serializeGraph.js';
 import { shortestPath } from './shortestPath.js';
 import { shortestPaths } from './shortestPaths.js';
+import { addWeightFunction } from './getPath.js';
+import { NextWeightFnParams } from '../../types.js';
 
 describe("Dijkstra's Shortest Path Algorithm", function () {
   it('Should compute shortest path on a single edge.', function () {
@@ -104,3 +106,75 @@ describe("Dijkstra's Shortest Path Algorithm", function () {
     expect(postSerializedGraph.links).toContainEqual({ source: 'f', target: 'c' });
   });
 });
+
+describe('addWeightFunction', () => {
+  it('should return edgeWeight if currentPathWeight is undefined', () => {
+    const params = { edgeWeight: 5, currentPathWeight: undefined, hop: 1 };
+    expect(addWeightFunction(params)).toBe(5);
+  });
+
+  it('should return the sum of edgeWeight and currentPathWeight', () => {
+    const params = { edgeWeight: 5, currentPathWeight: 10, hop: 1 };
+    expect(addWeightFunction(params)).toBe(15);
+  });
+});
+
+describe('shortestPath with custom weight functions', () => {
+  it('should compute shortest path with default weight function (sum of weights)', () => {
+    const graph = new Graph().addEdge('a', 'b', 1).addEdge('b', 'c', 2);
+    expect(shortestPath(graph, 'a', 'c')).toEqual({
+      nodes: ['a', 'b', 'c'],
+      weight: 3,
+    });
+  });
+
+  it('should compute shortest path with a custom weight function', () => {
+    const customWeightFn = ({ edgeWeight, currentPathWeight, hop }: NextWeightFnParams) => {
+      if (currentPathWeight === undefined) {
+        return edgeWeight;
+      }
+      return currentPathWeight + edgeWeight ** hop;
+    };
+
+    const graph = new Graph().addEdge('a', 'b', 2).addEdge('b', 'c', 3);
+    expect(shortestPath(graph, 'a', 'c', customWeightFn)).toEqual({
+      nodes: ['a', 'b', 'c'],
+      weight: 7,
+    });
+  });
+
+  it('should pass correct parameters to custom weight function for a path with 3 nodes', () => {
+    const customWeightFn = vi.fn(({ edgeWeight, currentPathWeight, hop }: NextWeightFnParams) => {
+      if (currentPathWeight === undefined) {
+        return edgeWeight;
+      }
+      return currentPathWeight + edgeWeight ** hop;
+    });
+
+    const graph = new Graph().addEdge('a', 'b', 1).addEdge('b', 'c', 2);
+    shortestPath(graph, 'a', 'c', customWeightFn);
+
+    expect(customWeightFn).toHaveBeenCalledWith({ edgeWeight: 2, currentPathWeight: undefined, hop: 1 });
+    expect(customWeightFn).toHaveBeenCalledWith({ edgeWeight: 1, currentPathWeight: 2, hop: 2 });
+  });
+
+  it('should compute shortest path with a custom weight function in a graph with multiple paths', () => {
+    const customWeightFn = ({ edgeWeight, currentPathWeight }: NextWeightFnParams) => {
+      if (currentPathWeight === undefined) {
+        return edgeWeight;
+      }
+      return edgeWeight + currentPathWeight;
+    };
+
+    const graph = new Graph()
+      .addEdge('a', 'b', 1)
+      .addEdge('b', 'c', 2)
+      .addEdge('a', 'd', 1)
+      .addEdge('d', 'c', 1);
+
+    expect(shortestPath(graph, 'a', 'c', customWeightFn)).toEqual({
+      nodes: ['a', 'd', 'c'],
+      weight: 2,
+    });
+  });
+});

src/algorithms/shortestPath/shortestPath.ts

@@ -3,7 +3,7 @@ import { NoInfer } from '../../types.js';
 import { dijkstra } from './dijkstra.js';
 import { getPath, addWeightFunction } from './getPath.js';
 import { TraversingTracks } from './types.js';
-import type { WeightParams } from '../../types.js';
+import type { NextWeightFnParams } from '../../types.js';
 
 /**
  * Dijkstra's Shortest Path Algorithm.
@@ -14,7 +14,7 @@ export function shortestPath<Node, LinkProps>(
   graph: Graph<Node, LinkProps>,
   source: NoInfer<Node>,
   destination: NoInfer<Node>,
-  nextWeightFn: (params: WeightParams) => number = addWeightFunction
+  nextWeightFn: (params: NextWeightFnParams) => number = addWeightFunction
 ): {
   nodes: [Node, Node, ...Node[]];
   weight: number | undefined;

src/index.ts

@@ -1,4 +1,4 @@
-export type { Edge, Serialized, SerializedInput, EdgeWeight, WeightParams } from './types.js';
+export type { Edge, Serialized, SerializedInput, EdgeWeight, NextWeightFnParams } from './types.js';
 
 export { Graph } from './Graph.js';
 export { CycleError } from './CycleError.js';

src/types.ts

@@ -19,7 +19,7 @@ export type SerializedInput<Node = unknown, LinkProps = unknown> = {
 
 export type NoInfer<T> = [T][T extends any ? 0 : never];
 
-export type WeightParams = {
+export type NextWeightFnParams = {
   edgeWeight: EdgeWeight;
   currentPathWeight: EdgeWeight | undefined;
   hop: number;