@graphty/layout 1.2.0 → 1.2.1

package/.github/workflows/ci.yml

@@ -38,16 +38,12 @@ jobs:
         run: npm run test:coverage
         if: matrix.node-version == '20.x'
         
-      - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v4
+      - name: Upload coverage reports to Coveralls
+        uses: coverallsapp/github-action@v2
         if: matrix.node-version == '20.x'
         with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
           file: ./coverage/lcov.info
-          flags: unittests
-          name: codecov-umbrella
-          fail_ci_if_error: false
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
   lint:
     name: Lint

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [1.2.1](https://github.com/graphty-org/layout/compare/v1.2.0...v1.2.1) (2025-07-13)
+
+
+### Bug Fixes
+
+* resolve import errors and browser hang in shell layout example ([d65e436](https://github.com/graphty-org/layout/commit/d65e4360d9c42c885731ec952ea52978da61c7d5))
+
 # [1.2.0](https://github.com/graphty-org/layout/compare/v1.1.1...v1.2.0) (2025-07-12)
 
 

package/README.md

@@ -1,7 +1,7 @@
 # Layout
 
 [![CI](https://github.com/graphty-org/layout/actions/workflows/ci.yml/badge.svg)](https://github.com/graphty-org/layout/actions/workflows/ci.yml)
-[![codecov](https://codecov.io/gh/graphty-org/layout/branch/main/graph/badge.svg)](https://codecov.io/gh/graphty-org/layout)
+[![Coverage Status](https://coveralls.io/repos/github/graphty-org/layout/badge.svg?branch=main)](https://coveralls.io/github/graphty-org/layout?branch=main)
 [![npm version](https://badge.fury.io/js/%40graphty%2Flayout.svg)](https://badge.fury.io/js/%40graphty%2Flayout)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 

package/dist/vitest.config.js

@@ -7,8 +7,8 @@ export default defineConfig({
         testTimeout: 30000,
         coverage: {
             provider: 'v8',
-            reporter: ['text', 'json', 'html'],
-            include: ['layout.ts'],
+            reporter: ['text', 'json', 'html', 'lcov'],
+            include: ['src/**/*.ts'],
             exclude: ['**/*.d.ts', '**/*.test.ts'],
             all: true,
             thresholds: {

package/dist/vitest.config.js.map

@@ -1 +1 @@
-{"version":3,"file":"vitest.config.js","sourceRoot":"","sources":["../vitest.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,eAAe,YAAY,CAAC;IAC1B,IAAI,EAAE;QACJ,OAAO,EAAE,IAAI;QACb,WAAW,EAAE,WAAW;QACxB,IAAI,EAAE,OAAO;QACb,WAAW,EAAE,KAAK;QAClB,QAAQ,EAAE;YACR,QAAQ,EAAE,IAAI;YACd,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;YAClC,OAAO,EAAE,CAAC,WAAW,CAAC;YACtB,OAAO,EAAE,CAAC,WAAW,EAAE,cAAc,CAAC;YACtC,GAAG,EAAE,IAAI;YACT,UAAU,EAAE;gBACV,KAAK,EAAE,EAAE;gBACT,SAAS,EAAE,EAAE;gBACb,QAAQ,EAAE,EAAE;gBACZ,UAAU,EAAE,EAAE;aACf;SACF;QACD,OAAO,EAAE,CAAC,mBAAmB,CAAC;QAC9B,SAAS,EAAE,CAAC,SAAS,CAAC;KACvB;IACD,OAAO,EAAE;QACP,KAAK,EAAE;YACL,GAAG,EAAE,MAAM;SACZ;KACF;CACF,CAAC,CAAC"}
+{"version":3,"file":"vitest.config.js","sourceRoot":"","sources":["../vitest.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,eAAe,YAAY,CAAC;IAC1B,IAAI,EAAE;QACJ,OAAO,EAAE,IAAI;QACb,WAAW,EAAE,WAAW;QACxB,IAAI,EAAE,OAAO;QACb,WAAW,EAAE,KAAK;QAClB,QAAQ,EAAE;YACR,QAAQ,EAAE,IAAI;YACd,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;YAC1C,OAAO,EAAE,CAAC,aAAa,CAAC;YACxB,OAAO,EAAE,CAAC,WAAW,EAAE,cAAc,CAAC;YACtC,GAAG,EAAE,IAAI;YACT,UAAU,EAAE;gBACV,KAAK,EAAE,EAAE;gBACT,SAAS,EAAE,EAAE;gBACb,QAAQ,EAAE,EAAE;gBACZ,UAAU,EAAE,EAAE;aACf;SACF;QACD,OAAO,EAAE,CAAC,mBAAmB,CAAC;QAC9B,SAAS,EAAE,CAAC,SAAS,CAAC;KACvB;IACD,OAAO,EAAE;QACP,KAAK,EAAE;YACL,GAAG,EAAE,MAAM;SACZ;KACF;CACF,CAAC,CAAC"}

package/examples/3d-kamada-kawai.html

@@ -95,12 +95,6 @@
     </label>
     <button id="regenerate">Regenerate Graph</button>
     <button id="relayout">Re-run Layout</button>
-    <label>
-      <input type="checkbox" id="showAxes" checked> Show Axes
-    </label>
-    <label>
-      <input type="checkbox" id="animateNodes"> Animate Nodes
-    </label>
   </div>
   <div id="status">
     <div>Nodes: <span id="nodeCount">0</span></div>
@@ -327,7 +321,6 @@
     const scaleLabel = document.getElementById('scaleLabel');
     const regenerateBtn = document.getElementById('regenerate');
     const relayoutBtn = document.getElementById('relayout');
-    const animateNodesCheckbox = document.getElementById('animateNodes');
 
     graphSizeSlider.addEventListener('input', (e) => {
       sizeLabel.textContent = e.target.value;
@@ -364,18 +357,10 @@
       
       time += 0.01;
       
-      // Animate nodes
-      if (animateNodesCheckbox.checked) {
-        nodeAnimations.forEach((mesh, i) => {
-          const offset = Math.sin(time + i * 0.5) * 5;
-          mesh.position.copy(mesh.userData.originalPosition);
-          mesh.position.y += offset;
-        });
-      } else {
-        nodeAnimations.forEach((mesh) => {
-          mesh.position.copy(mesh.userData.originalPosition);
-        });
-      }
+      // Keep nodes at their original positions
+      nodeAnimations.forEach((mesh) => {
+        mesh.position.copy(mesh.userData.originalPosition);
+      });
       
       controls.update();
       renderer.render(scene, camera);

package/examples/bfs-layout.html

@@ -169,61 +169,55 @@
     </div>
 
     <script type="module">
-        import { 
-            bfsLayout,
-            starGraph,
-            gridGraph,
-            randomGraph,
-            scaleFreeGraph,
-            findBestRoot
-        } from "./layout.js";
+        import { bfsLayout, scaleFreeGraph, randomGraph, gridGraph, starGraph } from "./layout.js";
         
         let currentGraph = null;
         let bestRoot = null;
         
         function generateGraph(type, numNodes) {
+            let graph;
             switch(type) {
                 case 'tree':
                     // Generate tree-like structure using scale-free with low m
-                    return scaleFreeGraph(numNodes, 1, Date.now());
+                    graph = scaleFreeGraph(numNodes, 1, Date.now());
+                    break;
                 
                 case 'connected':
                     // Generate connected random graph
-                    return randomGraph(numNodes, 0.15, Date.now());
+                    graph = randomGraph(numNodes, 0.15, Date.now());
+                    break;
                 
                 case 'grid':
                     // Create grid
                     const size = Math.ceil(Math.sqrt(numNodes));
-                    return gridGraph(size, size);
+                    const gridG = gridGraph(size, size);
+                    // Convert string node IDs to numbers for consistency
+                    const nodeMap = new Map();
+                    gridG.nodes().forEach((node, i) => nodeMap.set(node, i));
+                    graph = {
+                        nodes: () => Array.from({length: gridG.nodes().length}, (_, i) => i),
+                        edges: () => gridG.edges().map(([u, v]) => [nodeMap.get(u), nodeMap.get(v)])
+                    };
+                    break;
                 
                 case 'star':
-                    return starGraph(numNodes);
-                
-                default:
-                    return randomGraph(numNodes, 0.2, Date.now());
-                            edges.push([i, i + gridSize]);
-                        }
-                    }
+                    graph = starGraph(numNodes);
                     break;
                 
-                case 'star':
-                    // Star with center at node 0
-                    for (let i = 1; i < numNodes; i++) {
-                        edges.push([0, i]);
-                    }
+                default:
+                    graph = randomGraph(numNodes, 0.2, Date.now());
                     break;
             }
             
-            return { 
-                nodes: () => nodes, 
-                edges: () => edges,
-                // Simplified implementation to get neighbors
-                getNeighbors: function(node) {
-                    return edges
-                        .filter(([s, t]) => s === node || t === node)
-                        .map(([s, t]) => s === node ? t : s);
-                }
+            // Add getNeighbors method to the graph
+            graph.getNeighbors = function(node) {
+                const edges = this.edges();
+                return edges
+                    .filter(([s, t]) => s === node || t === node)
+                    .map(([s, t]) => s === node ? t : s);
             };
+            
+            return graph;
         }
         
         function updateStartNodeOptions() {

package/examples/bipartite-layout.html

@@ -165,9 +165,9 @@
         import { 
             bipartiteLayout,
             bipartiteGraph,
-            detectBipartite,
             randomGraph
         } from "./layout.js";
+        import { detectBipartite } from "./layout-helpers.js";
         
         let currentGraph = null;
         let detectedBipartite = null;
@@ -335,7 +335,7 @@
             document.getElementById('alignment').onchange = null;
         }
         
-        window.generateMixedGraph = function() {
+        window.generateMixedGraph = async function() {
             const totalNodes = parseInt(document.getElementById('set-a-size').value) + 
                                parseInt(document.getElementById('set-b-size').value);
             const edgeDensity = parseFloat(document.getElementById('edge-density').value);
@@ -360,7 +360,7 @@
                 `;
             } else {
                 // Not bipartite - show with spring layout instead
-                const { springLayout } = await import('../dist/layout.js');
+                const { springLayout } = await import('./layout.js');
                 const positions = springLayout(currentGraph);
                 visualizeGraph(currentGraph, positions);
                 

package/examples/forceatlas2-layout.html

@@ -203,16 +203,117 @@
 
     <script type="module">
         import { 
-            forceatlas2Layout,
-            randomGraph,
-            scaleFreeGraph,
-            gridGraph,
-            autoConfigureForce
+            forceatlas2Layout
         } from "./layout.js";
         
+        import {
+            autoConfigureForce
+        } from "./layout-helpers.js";
+        
         let currentGraph = null;
         let currentConfig = null;
         
+        // Graph generation utilities
+        function randomGraph(n, p, seed) {
+            const nodes = Array.from({length: n}, (_, i) => i);
+            const edges = [];
+            
+            // Simple random graph with probability p for each edge
+            for (let i = 0; i < n; i++) {
+                for (let j = i + 1; j < n; j++) {
+                    if (Math.random() < p) {
+                        edges.push([i, j]);
+                    }
+                }
+            }
+            
+            return {
+                nodes: () => nodes,
+                edges: () => edges
+            };
+        }
+        
+        function scaleFreeGraph(n, m, seed) {
+            const nodes = Array.from({length: n}, (_, i) => i);
+            const edges = [];
+            
+            // Start with a complete graph of m+1 nodes
+            for (let i = 0; i <= m; i++) {
+                for (let j = i + 1; j <= m; j++) {
+                    edges.push([i, j]);
+                }
+            }
+            
+            // Add remaining nodes with preferential attachment
+            for (let i = m + 1; i < n; i++) {
+                const degrees = new Map();
+                for (const [u, v] of edges) {
+                    degrees.set(u, (degrees.get(u) || 0) + 1);
+                    degrees.set(v, (degrees.get(v) || 0) + 1);
+                }
+                
+                const totalDegree = Array.from(degrees.values()).reduce((a, b) => a + b, 0);
+                const targets = new Set();
+                
+                while (targets.size < Math.min(m, i)) {
+                    let r = Math.random() * totalDegree;
+                    let node = 0;
+                    
+                    for (const [n, d] of degrees) {
+                        r -= d;
+                        if (r <= 0) {
+                            node = n;
+                            break;
+                        }
+                    }
+                    
+                    if (!targets.has(node)) {
+                        targets.add(node);
+                        edges.push([i, node]);
+                    }
+                }
+            }
+            
+            return {
+                nodes: () => nodes,
+                edges: () => edges
+            };
+        }
+        
+        function gridGraph(rows, cols) {
+            const nodes = [];
+            const edges = [];
+            
+            // Create nodes
+            for (let r = 0; r < rows; r++) {
+                for (let c = 0; c < cols; c++) {
+                    nodes.push(r * cols + c);
+                }
+            }
+            
+            // Create edges
+            for (let r = 0; r < rows; r++) {
+                for (let c = 0; c < cols; c++) {
+                    const node = r * cols + c;
+                    
+                    // Right edge
+                    if (c < cols - 1) {
+                        edges.push([node, node + 1]);
+                    }
+                    
+                    // Down edge
+                    if (r < rows - 1) {
+                        edges.push([node, node + cols]);
+                    }
+                }
+            }
+            
+            return {
+                nodes: () => nodes,
+                edges: () => edges
+            };
+        }
+        
         function generateGraph(type, numNodes) {
             switch(type) {
                 case 'scale-free':
@@ -263,150 +364,7 @@
                 case 'random':
                 default:
                     return randomGraph(numNodes, 0.1, Date.now());
-                    for(let i = 1; i < Math.min(5, numNodes); i++) {
-                        edges.push([0, i]);
-                    }
-                    
-                    // Add nodes with preferential attachment
-                    for(let i = 5; i < numNodes; i++) {
-                        // Number of connections for new node
-                        const newEdges = Math.min(3, i);
-                        
-                        // Track edge count per node for preferential attachment
-                        const nodeDegrees = new Array(i).fill(0);
-                        for(const edge of edges) {
-                            nodeDegrees[edge[0]]++;
-                            nodeDegrees[edge[1]]++;
-                        }
-                        
-                        // Calculate total degree for probability
-                        const totalDegree = nodeDegrees.reduce((sum, deg) => sum + deg, 0);
-                        
-                        // Add edges based on preferential attachment
-                        const added = new Set();
-                        for(let j = 0; j < newEdges; j++) {
-                            let targetNode;
-                            do {
-                                // Choose node with probability proportional to its degree
-                                let rand = Math.random() * totalDegree;
-                                targetNode = 0;
-                                while(targetNode < i && rand > 0) {
-                                    rand -= nodeDegrees[targetNode];
-                                    if(rand > 0) targetNode++;
-                                }
-                                if(targetNode >= i) targetNode = Math.floor(Math.random() * i);
-                            } while(added.has(targetNode));
-                            
-                            edges.push([i, targetNode]);
-                            added.add(targetNode);
-                        }
-                    }
-                    break;
-                    
-                case 'community':
-                    // Create community structure with 3-4 communities
-                    const numCommunities = Math.min(4, Math.ceil(numNodes / 10));
-                    const communitySizes = [];
-                    let remainingNodes = numNodes;
-                    
-                    for(let i = 0; i < numCommunities - 1; i++) {
-                        const size = Math.ceil(numNodes / numCommunities);
-                        communitySizes.push(size);
-                        remainingNodes -= size;
-                    }
-                    communitySizes.push(remainingNodes);
-                    
-                    let nodeIndex = 0;
-                    for(let c = 0; c < numCommunities; c++) {
-                        const communityStart = nodeIndex;
-                        const communityEnd = communityStart + communitySizes[c];
-                        
-                        // Connect nodes within community (dense)
-                        for(let i = communityStart; i < communityEnd; i++) {
-                            for(let j = i + 1; j < communityEnd; j++) {
-                                if(Math.random() < 0.7) { // High probability within community
-                                    edges.push([i, j]);
-                                }
-                            }
-                        }
-                        
-                        // Connect to other communities (sparse)
-                        if(c > 0) {
-                            const prevCommunityStart = nodeIndex - communitySizes[c-1];
-                            const bridgeEdges = Math.max(1, Math.floor(communitySizes[c] * 0.1));
-                            for(let e = 0; e < bridgeEdges; e++) {
-                                const source = communityStart + Math.floor(Math.random() * communitySizes[c]);
-                                const target = prevCommunityStart + Math.floor(Math.random() * communitySizes[c-1]);
-                                edges.push([source, target]);
-                            }
-                        }
-                        
-                        nodeIndex = communityEnd;
-                    }
-                    break;
-                    
-                case 'grid':
-                    // Create a grid-like structure
-                    const gridSize = Math.ceil(Math.sqrt(numNodes));
-                    for(let i = 0; i < numNodes; i++) {
-                        const row = Math.floor(i / gridSize);
-                        const col = i % gridSize;
-                        
-                        // Connect right
-                        if(col < gridSize - 1 && i + 1 < numNodes) {
-                            edges.push([i, i + 1]);
-                        }
-                        
-                        // Connect down
-                        if(row < gridSize - 1 && i + gridSize < numNodes) {
-                            edges.push([i, i + gridSize]);
-                        }
-                    }
-                    break;
-                    
-                case 'random':
-                default:
-                    // Random graph with controlled density
-                    const density = 0.1; // 10% of possible edges
-                    const possibleEdges = (numNodes * (numNodes - 1)) / 2;
-                    const targetEdges = Math.ceil(possibleEdges * density);
-                    
-                    // Ensure connected graph with spanning tree
-                    for(let i = 1; i < numNodes; i++) {
-                        const parent = Math.floor(Math.random() * i);
-                        edges.push([parent, i]);
-                    }
-                    
-                    // Add random edges up to target density
-                    let additionalEdges = targetEdges - (numNodes - 1);
-                    let attempts = 0;
-                    
-                    while(additionalEdges > 0 && attempts < 1000) {
-                        const a = Math.floor(Math.random() * numNodes);
-                        const b = Math.floor(Math.random() * numNodes);
-                        
-                        if(a !== b && !edges.some(e => (e[0] === a && e[1] === b) || (e[0] === b && e[1] === a))) {
-                            edges.push([a, b]);
-                            additionalEdges--;
-                        }
-                        
-                        attempts++;
-                    }
-                    break;
             }
-            
-            // Create node masses based on degree
-            const masses = {};
-            for(const edge of edges) {
-                masses[edge[0]] = (masses[edge[0]] || 1) + 0.1;
-                masses[edge[1]] = (masses[edge[1]] || 1) + 0.1;
-            }
-            
-            return { 
-                nodes: () => nodes, 
-                edges: () => edges,
-                masses: masses
-            };
         }
         
         function visualizeGraph(graph, positions) {
@@ -514,9 +472,6 @@
                 
                 // Apply layout immediately
                 applyLayout();
-                });
-                
-                visualizeGraph(currentGraph, positions);
                 
             } catch (error) {
                 console.error('Error in graph generation:', error);

package/{dist → examples}/layout-helpers.js

@@ -409,50 +409,78 @@ function groupByKCore(nodes, edges) {
         .map(([, nodeList]) => nodeList);
 }
 function groupByCommunity(nodes, edges, targetGroups) {
-    // Simple community detection using modularity
+    // Fast community detection using label propagation
     const communities = new Map();
-    nodes.forEach((node, i) => communities.set(node, i));
-    // Build adjacency
     const adj = new Map();
-    nodes.forEach(node => adj.set(node, new Set()));
+    
+    // Initialize each node in its own community
+    nodes.forEach((node, i) => {
+        communities.set(node, i);
+        adj.set(node, new Set());
+    });
+    
+    // Build adjacency
     edges.forEach(([u, v]) => {
         adj.get(u).add(v);
         adj.get(v).add(u);
     });
-    // Iteratively merge communities
-    let numCommunities = nodes.length;
-    while (numCommunities > targetGroups) {
-        let improved = false;
-        for (const node of nodes) {
-            const currentComm = communities.get(node);
-            const neighborComms = new Set();
-            adj.get(node).forEach(neighbor => {
-                neighborComms.add(communities.get(neighbor));
+    
+    // Label propagation algorithm
+    const maxIterations = 10; // Prevent infinite loops
+    for (let iter = 0; iter < maxIterations; iter++) {
+        let changed = false;
+        
+        // Process nodes in random order
+        const shuffledNodes = nodes.slice().sort(() => Math.random() - 0.5);
+        
+        for (const node of shuffledNodes) {
+            const neighbors = adj.get(node);
+            if (neighbors.size === 0) continue;
+            
+            // Count community frequencies among neighbors
+            const commCounts = new Map();
+            neighbors.forEach(neighbor => {
+                const comm = communities.get(neighbor);
+                commCounts.set(comm, (commCounts.get(comm) || 0) + 1);
             });
-            for (const targetComm of Array.from(neighborComms)) {
-                if (targetComm !== currentComm) {
-                    // Simple decision: join most common neighbor community
-                    communities.set(node, targetComm);
-                    improved = true;
-                    break;
+            
+            // Find most frequent community
+            let maxCount = 0;
+            let bestComm = communities.get(node);
+            commCounts.forEach((count, comm) => {
+                if (count > maxCount || (count === maxCount && comm < bestComm)) {
+                    maxCount = count;
+                    bestComm = comm;
                 }
+            });
+            
+            if (bestComm !== communities.get(node)) {
+                communities.set(node, bestComm);
+                changed = true;
             }
-            if (improved)
-                break;
         }
-        if (!improved)
-            break;
-        // Count communities
-        const currentNumCommunities = new Set(communities.values()).size;
-        numCommunities = currentNumCommunities;
+        
+        if (!changed) break;
     }
-    // Group nodes by community
+    
+    // Consolidate communities
     const groups = new Map();
     communities.forEach((comm, node) => {
-        if (!groups.has(comm))
-            groups.set(comm, []);
+        if (!groups.has(comm)) groups.set(comm, []);
         groups.get(comm).push(node);
     });
-    return Array.from(groups.values());
+    
+    let result = Array.from(groups.values());
+    
+    // If we have too many groups, merge the smallest ones
+    while (result.length > targetGroups && result.length > 1) {
+        // Sort by size
+        result.sort((a, b) => a.length - b.length);
+        // Merge two smallest groups
+        const merged = result[0].concat(result[1]);
+        result = [merged, ...result.slice(2)];
+    }
+    
+    return result;
 }
 //# sourceMappingURL=layout-helpers.js.map