@graphty/algorithms 1.5.0 → 1.7.0

package/README.md

@@ -5,6 +5,7 @@
 [![npm version](https://img.shields.io/npm/v/@graphty/algorithms.svg)](https://www.npmjs.com/package/@graphty/algorithms)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Documentation](https://img.shields.io/badge/docs-vitepress-blue)](https://graphty.app/docs/algorithms/)
+[![Storybook](https://img.shields.io/badge/storybook-interactive%20demos-ff4785)](https://graphty.app/storybook/algorithms/)
 [![Examples](https://img.shields.io/badge/demo-github%20pages-blue)](https://graphty.app/algorithms/)
 
 A comprehensive TypeScript graph algorithms library with 98 algorithms optimized for browser environments and visualization applications.
@@ -1028,6 +1029,18 @@ const result = grsbm(graph, {
 
 ## Interactive Examples
 
+### Storybook (Recommended)
+
+Explore algorithms with interactive Storybook demos: **[View Storybook →](https://graphty.app/storybook/algorithms/)**
+
+Storybook provides:
+- **Animated visualizations** showing how each algorithm works step-by-step
+- **Interactive controls** to modify parameters and graph types
+- **Deterministic output** with seeded randomness for reproducibility
+- **Visual testing** with Chromatic for regression detection
+
+### Legacy HTML Examples
+
 Try out all algorithms with interactive visualizations: **[Live Demo →](https://graphty.app/algorithms/)**
 
 The library includes comprehensive examples demonstrating each algorithm. You can:

package/dist/algorithms.js

@@ -6370,7 +6370,7 @@ function girvanNewman(graph, options = {}) {
   });
   while (Array.from(workingGraph.edges()).length > 0 && iterations < maxIterations) {
     iterations++;
-    const edgeBetweenness = calculateEdgeBetweenness(workingGraph);
+    const { betweenness: edgeBetweenness, edgeEndpoints } = calculateEdgeBetweenness(workingGraph);
     if (edgeBetweenness.size === 0) {
       break;
     }
@@ -6378,9 +6378,9 @@ function girvanNewman(graph, options = {}) {
     const edgesToRemove = [];
     for (const [edgeKey, centrality] of edgeBetweenness) {
       if (Math.abs(centrality - maxBetweenness) < 1e-10) {
-        const [source, target] = edgeKey.split("|");
-        if (source && target) {
-          edgesToRemove.push({ source, target });
+        const endpoints = edgeEndpoints.get(edgeKey);
+        if (endpoints) {
+          edgesToRemove.push(endpoints);
         }
       }
     }
@@ -6405,9 +6405,11 @@ function girvanNewman(graph, options = {}) {
 }
 function calculateEdgeBetweenness(graph) {
   const edgeBetweenness = /* @__PURE__ */ new Map();
+  const edgeEndpoints = /* @__PURE__ */ new Map();
   for (const edge of graph.edges()) {
     const edgeKey = getEdgeKey(edge.source, edge.target);
     edgeBetweenness.set(edgeKey, 0);
+    edgeEndpoints.set(edgeKey, { source: edge.source, target: edge.target });
   }
   for (const sourceNode of graph.nodes()) {
     const source = sourceNode.id;
@@ -6458,7 +6460,7 @@ function calculateEdgeBetweenness(graph) {
       edgeBetweenness.set(edgeKey, betweenness / 2);
     }
   }
-  return edgeBetweenness;
+  return { betweenness: edgeBetweenness, edgeEndpoints };
 }
 function findAllShortestPaths(graph, source) {
   const distances = /* @__PURE__ */ new Map();
@@ -9022,7 +9024,7 @@ function buildTransitionMatrix(graph, nodeIds, selfLoops) {
   nodeIds.forEach((id, index) => nodeToIndex.set(id, index));
   for (let i = 0; i < n; i++) {
     const nodeId = nodeIds[i];
-    if (!nodeId) {
+    if (nodeId === void 0) {
       continue;
     }
     const neighbors = graph.neighbors(nodeId);
@@ -9221,37 +9223,45 @@ function extractClusters(matrix, nodeIds) {
       attractors.add(nodeId);
     }
   }
-  let clusterIndex = 0;
+  const attractorToCommunity = /* @__PURE__ */ new Map();
   for (let j = 0; j < n; j++) {
-    const clusterNodes = [];
+    let maxVal = 0;
+    let attractorRow = -1;
     for (let i = 0; i < n; i++) {
       const matrixRow = matrix[i];
       if (!matrixRow) {
         continue;
       }
       const val = matrixRow[j];
-      if (val !== void 0 && val > 0 && !nodeToCluster.has(i)) {
-        clusterNodes.push(i);
-        nodeToCluster.set(i, clusterIndex);
+      if (val !== void 0 && val > maxVal) {
+        maxVal = val;
+        attractorRow = i;
       }
     }
-    if (clusterNodes.length > 0) {
-      communities.push(
-        clusterNodes.map((idx) => {
-          const nodeId = nodeIds[idx];
-          return nodeId;
-        }).filter((node) => node !== void 0)
-      );
-      clusterIndex++;
+    if (attractorRow >= 0) {
+      let community = attractorToCommunity.get(attractorRow);
+      if (!community) {
+        community = [];
+        attractorToCommunity.set(attractorRow, community);
+      }
+      community.push(j);
+      nodeToCluster.set(j, attractorRow);
     }
   }
-  for (let i = 0; i < n; i++) {
-    if (!nodeToCluster.has(i)) {
-      const nodeId = nodeIds[i];
+  for (const [, memberIndices] of attractorToCommunity) {
+    communities.push(
+      memberIndices.map((idx) => {
+        const nodeId = nodeIds[idx];
+        return nodeId;
+      }).filter((node) => node !== void 0)
+    );
+  }
+  for (let j = 0; j < n; j++) {
+    if (!nodeToCluster.has(j)) {
+      const nodeId = nodeIds[j];
       if (nodeId !== void 0) {
         communities.push([nodeId]);
       }
-      nodeToCluster.set(i, clusterIndex++);
     }
   }
   return { communities, attractors };