bmssp 0.13.0 → 0.15.0

package/index.mjs

@@ -1 +1,2 @@
 export { BMSSP } from "./src/bmssp.mjs";
+export { dijkstra } from "./src/dijkstra.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bmssp",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Javascript package implementation of the bmssp algorithm.",
   "main": "index.mjs",
   "keywords": [
@@ -42,13 +42,13 @@
     "prettier:fix": "prettier --write \"./**/{*.js,*.mjs}\""
   },
   "devDependencies": {
-    "@eslint/js": "^9.34.0",
-    "@eslint/markdown": "^7.2.0",
-    "eslint": "^9.34.0",
+    "@eslint/js": "^10.0.1",
+    "@eslint/markdown": "^8.0.1",
+    "eslint": "^10.0.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
-    "globals": "^16.3.0",
+    "globals": "^17.0.0",
     "jest": "^30.1.1",
-    "prettier": "3.6.2"
+    "prettier": "3.8.3"
   }
 }

package/src/bmssp.mjs

@@ -1,3 +1,5 @@
+import { dijkstra } from "./dijkstra.mjs";
+
 class BMSSP {
   constructor(inputGraph) {
     // Main graph represented as an array of edges
@@ -27,7 +29,7 @@ class BMSSP {
     }
   }
 
-  // Method to calculate shortest paths (placeholder implementation)
+  // Method to calculate shortest paths from startNode using Dijkstra
   calculateShortestPaths(startNode) {
     // To clean the state before calculation
     this.initializeShortestPaths();
@@ -37,9 +39,10 @@ class BMSSP {
       throw new Error("Start node not found in the graph");
     }
 
-    // Placeholder logic for shortest path calculation
-    // This should be replaced with an actual implementation of BMSSP algorithm
-    this.shortestPaths.set(startNode, 0);
+    const result = dijkstra(this.graph, this.nodeIDs, startNode);
+    result.forEach((distance, nodeId) => {
+      this.shortestPaths.set(nodeId, distance);
+    });
   }
 }
 

package/src/dijkstra.mjs

@@ -0,0 +1,80 @@
+/**
+ * Simple Dijkstra single-source shortest path.
+ * Requires all edge weights to be non-negative; with negative weights it may return incorrect paths.
+ * @param {Array<[number, number, number]>} graph - Array of edges [from, to, weight] with non-negative weight
+ * @param {Set<number>} nodeIDs - Set of all node IDs (distances for these will be in the result)
+ * @param {number} source - Source node ID (must be present in nodeIDs)
+ * @throws {Error} If source is not in nodeIDs
+ * @returns {Map<number, number>} Map from node ID to shortest distance from source (Infinity if unreachable)
+ */
+function dijkstra(graph, nodeIDs, source) {
+  if (!nodeIDs.has(source)) {
+    throw new Error("Source node not found in nodeIDs");
+  }
+  const dist = new Map();
+  for (const id of nodeIDs) {
+    dist.set(id, Infinity);
+  }
+  dist.set(source, 0);
+
+  // Build adjacency list: from -> [{ to, weight }, ...]
+  const adj = new Map();
+  for (const [from, to, weight] of graph) {
+    if (!adj.has(from)) adj.set(from, []);
+    adj.get(from).push({ to, weight });
+  }
+
+  // Min-heap of [distance, node]; compare by distance
+  const heap = [[0, source]];
+
+  function heapPush(d, v) {
+    heap.push([d, v]);
+    let i = heap.length - 1;
+    while (i > 0) {
+      const p = (i - 1) >> 1;
+      if (heap[p][0] <= heap[i][0]) break;
+      [heap[p], heap[i]] = [heap[i], heap[p]];
+      i = p;
+    }
+  }
+
+  function heapPop() {
+    if (heap.length === 0) return null;
+    const top = heap[0];
+    const last = heap.pop();
+    if (heap.length === 0) return top;
+    heap[0] = last;
+    let i = 0;
+    const n = heap.length;
+    while (true) {
+      let smallest = i;
+      const left = 2 * i + 1;
+      const right = 2 * i + 2;
+      if (left < n && heap[left][0] < heap[smallest][0]) smallest = left;
+      if (right < n && heap[right][0] < heap[smallest][0]) smallest = right;
+      if (smallest === i) break;
+      [heap[i], heap[smallest]] = [heap[smallest], heap[i]];
+      i = smallest;
+    }
+    return top;
+  }
+
+  while (heap.length > 0) {
+    const [d, u] = heapPop();
+    if (d > dist.get(u)) continue;
+    const neighbors = adj.get(u);
+    if (!neighbors) continue;
+    for (const { to, weight } of neighbors) {
+      if (!dist.has(to)) continue;
+      const alt = d + weight;
+      if (alt < dist.get(to)) {
+        dist.set(to, alt);
+        heapPush(alt, to);
+      }
+    }
+  }
+
+  return dist;
+}
+
+export { dijkstra };