Changes based on PR comments ... (#2)

* Added custom function document for shortestPath ...

* Exporting WeightParams ...

* Added WeightParams type ...

* Changed weightFunction to use WeightParams ...

* Changed the name of parameter ...

* Added condition to check if the pathWeight is undefined ...

Author: ravann

README.md

@@ -196,6 +196,23 @@ console.log(result.nodes); // Prints the array of nodes in the shortest path
 console.log(result.weight); // Prints the total weight of the path
 ```
 
+<a name="shortest-path" href="#shortest-path">#</a> <b>shortestPath</b>(<i>graph</i>, <i>sourceNode</i>, <i>destinationNode</i>, <i>nextWeightFn</i>)
+
+Calculates the weight based on the custom function.
+
+```javascript
+import type { WeightParams } from '../../types.js';
+function multiplyWeightFunction(wp: WeightParams): number {
+    if (wp.currentPathWeight === undefined) {
+        return wp.edgeWeight;
+    }
+    return wp.edgeWeight * wp.currentPathWeight;
+}
+var result = shortestPath(graph, 'a', 'c', multiplyWeightFunction);
+console.log(result.nodes); // Prints the array of nodes in the shortest path
+console.log(result.weight); // Prints the total weight of the path
+```
+
 <p align="center">
   <a href="https://datavis.tech/">
     <img src="https://cloud.githubusercontent.com/assets/68416/15298394/a7a0a66a-1bbc-11e6-9636-367bed9165fc.png">

src/algorithms/shortestPath/getPath.ts

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

src/algorithms/shortestPath/shortestPath.ts

@@ -3,6 +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';
 
 /**
  * Dijkstra's Shortest Path Algorithm.
@@ -13,10 +14,10 @@ export function shortestPath<Node, LinkProps>(
   graph: Graph<Node, LinkProps>,
   source: NoInfer<Node>,
   destination: NoInfer<Node>,
-  weightFunction: (edgeWeight: number, currentPathWeight: number, hop: number) => number = addWeightFunction
+  nextWeightFn: (params: WeightParams) => number = addWeightFunction
 ): {
   nodes: [Node, Node, ...Node[]];
-  weight: number;
+  weight: number | undefined;
 } {
   const tracks: TraversingTracks<Node> = {
     d: new Map(),
@@ -26,5 +27,5 @@ export function shortestPath<Node, LinkProps>(
 
   dijkstra(graph, tracks, source, destination);
 
-  return getPath(graph, tracks, source, destination, weightFunction);
+  return getPath(graph, tracks, source, destination, nextWeightFn);
 }

src/algorithms/shortestPath/shortestPaths.ts

@@ -41,7 +41,7 @@ export function shortestPaths<Node, LinkProps>(
 
     try {
       path = shortestPath(graph, source, destination);
-      if (!path.weight || pathWeight < path.weight) break;
+      if (!path.weight || !pathWeight || pathWeight < path.weight) break;
       paths.push(path);
     } catch (e) {
       break;

src/index.ts

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

src/types.ts

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