bmssp 0.12.0 → 0.14.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.12.0",
+  "version": "0.14.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/js": "^10.0.1",
     "@eslint/markdown": "^7.2.0",
-    "eslint": "^9.34.0",
+    "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.1"
   }
 }

package/src/bmssp.mjs

@@ -1,10 +1,48 @@
+import { dijkstra } from "./dijkstra.mjs";
+
 class BMSSP {
   constructor(inputGraph) {
+    // Main graph represented as an array of edges
     this.graph = [];
+    // Set to store unique node IDs
+    this.nodeIDs = new Set();
+    // Map to store shortest paths
+    this.shortestPaths = new Map();
+
     for (let edge of inputGraph) {
       // Create a deep copy of each edge array
       this.graph.push([...edge]);
+
+      // Add node IDs to the set
+      this.nodeIDs.add(edge[0]);
+      this.nodeIDs.add(edge[1]);
+    }
+
+    // Initialize shortest paths map
+    this.initializeShortestPaths();
+  }
+
+  // Method to initialize the shortest paths map
+  initializeShortestPaths() {
+    for (let nodeId of this.nodeIDs) {
+      this.shortestPaths.set(nodeId, Infinity);
+    }
+  }
+
+  // Method to calculate shortest paths from startNode using Dijkstra
+  calculateShortestPaths(startNode) {
+    // To clean the state before calculation
+    this.initializeShortestPaths();
+
+    // validate startNode
+    if (!this.nodeIDs.has(startNode)) {
+      throw new Error("Start node not found in the graph");
     }
+
+    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 };