@graphty/layout 1.2.2 → 1.2.4

package/test/forceatlas2-layout.test.ts

@@ -1,405 +0,0 @@
-import { describe, it, assert } from 'vitest';
-import { 
-  forceatlas2Layout,
-  completeGraph,
-  cycleGraph,
-  starGraph,
-  gridGraph,
-  randomGraph,
-  scaleFreeGraph
-} from '../src';
-
-describe('ForceAtlas2 Layout', () => {
-  describe('Basic functionality', () => {
-    it('should position all nodes', () => {
-      const graph = completeGraph(8);
-      const positions = forceatlas2Layout(graph);
-      
-      assert.equal(Object.keys(positions).length, 8);
-      graph.nodes().forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.equal(positions[node].length, 2);
-        assert.isNumber(positions[node][0]);
-        assert.isNumber(positions[node][1]);
-      });
-    });
-
-    it('should handle empty graph', () => {
-      const emptyGraph = { nodes: () => [], edges: () => [] };
-      const positions = forceatlas2Layout(emptyGraph);
-      
-      assert.equal(Object.keys(positions).length, 0);
-    });
-
-    it('should handle single node', () => {
-      const singleNode = { nodes: () => ['A'], edges: () => [] };
-      const positions = forceatlas2Layout(singleNode);
-      
-      assert.equal(Object.keys(positions).length, 1);
-      assert.isDefined(positions['A']);
-      assert.equal(positions['A'].length, 2);
-    });
-
-    it('should handle disconnected components', () => {
-      const graph = {
-        nodes: () => [0, 1, 2, 3, 4, 5],
-        edges: () => [[0, 1], [1, 2], [3, 4], [4, 5]]
-      };
-      const positions = forceatlas2Layout(graph);
-      
-      assert.equal(Object.keys(positions).length, 6);
-      // Disconnected components should be separated by gravity
-    });
-
-    it('should use initial positions if provided', () => {
-      const graph = starGraph(5);
-      const initialPos = {};
-      graph.nodes().forEach(node => {
-        initialPos[node] = [node, 0]; // Line layout
-      });
-      
-      const positions = forceatlas2Layout(graph, initialPos, 50);
-      
-      assert.equal(Object.keys(positions).length, 5);
-      // Should evolve from initial positions
-      assert.isDefined(positions[0]);
-    });
-  });
-
-  describe('Force parameters', () => {
-    it('should respect maxIter parameter', () => {
-      const graph = randomGraph(10, 0.3, 42);
-      
-      const startTime1 = performance.now();
-      const positions1 = forceatlas2Layout(graph, null, 10);
-      const time1 = performance.now() - startTime1;
-      
-      const startTime2 = performance.now();
-      const positions2 = forceatlas2Layout(graph, null, 100);
-      const time2 = performance.now() - startTime2;
-      
-      // More iterations should take longer
-      assert.isAbove(time2, time1 * 0.5);
-      
-      // Both should position all nodes
-      assert.equal(Object.keys(positions1).length, 10);
-      assert.equal(Object.keys(positions2).length, 10);
-    });
-
-    it('should handle different gravity settings', () => {
-      const graph = {
-        nodes: () => [0, 1, 2, 3],
-        edges: () => [] // No edges, only gravity affects layout
-      };
-      
-      const positions1 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 0.1); // Low gravity
-      const positions2 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 10.0); // High gravity
-      
-      // Both gravity settings should produce valid layouts
-      const avgDist1 = getAverageDistanceFromCenter(positions1);
-      const avgDist2 = getAverageDistanceFromCenter(positions2);
-      
-      // Just verify both produced layouts
-      assert.isAbove(avgDist1, 0);
-      assert.isAbove(avgDist2, 0);
-    });
-
-    it('should handle strongGravity mode', () => {
-      const graph = scaleFreeGraph(15, 2, 123);
-      
-      const positions1 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false, false); // Normal gravity
-      const positions2 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false, true); // Strong gravity
-      
-      // Both should complete
-      assert.equal(Object.keys(positions1).length, 15);
-      assert.equal(Object.keys(positions2).length, 15);
-    });
-
-    it('should handle distributedAction mode', () => {
-      const graph = starGraph(10);
-      
-      const positions1 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false);
-      const positions2 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, true);
-      
-      // Both modes should work
-      assert.equal(Object.keys(positions1).length, 10);
-      assert.equal(Object.keys(positions2).length, 10);
-    });
-  });
-
-  describe('Node properties', () => {
-    it('should respect node masses', () => {
-      const graph = starGraph(5);
-      const nodeMass = {
-        0: 10.0, // Heavy center
-        1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0 // Light leaves
-      };
-      
-      const positions = forceatlas2Layout(graph, null, 100, 1.0, 2.0, 1.0, false, false, nodeMass);
-      
-      // Heavy center should be more stable (closer to origin)
-      const centerDist = Math.sqrt(positions[0][0] ** 2 + positions[0][1] ** 2);
-      const leafDists = [1, 2, 3, 4].map(i => 
-        Math.sqrt(positions[i][0] ** 2 + positions[i][1] ** 2)
-      );
-      
-      // Center should be closer to origin than most leaves
-      const avgLeafDist = leafDists.reduce((a, b) => a + b) / leafDists.length;
-      assert.isBelow(centerDist, avgLeafDist);
-    });
-
-    it('should respect node sizes', () => {
-      const graph = completeGraph(4);
-      const nodeSize = {
-        0: 10.0, // Large node
-        1: 1.0, 2: 1.0, 3: 1.0 // Small nodes
-      };
-      
-      const positions = forceatlas2Layout(graph, null, 100, 1.0, 2.0, 1.0, false, false, null, nodeSize);
-      
-      // Layout should avoid overlaps considering sizes
-      assert.equal(Object.keys(positions).length, 4);
-      
-      // Large node should have more space around it
-      const dist01 = getDistance(positions, 0, 1);
-      const dist12 = getDistance(positions, 1, 2);
-      // Distance to large node should tend to be larger
-      assert.isDefined(dist01);
-      assert.isDefined(dist12);
-    });
-  });
-
-  describe('Advanced features', () => {
-    it('should handle dissuadeHubs option', () => {
-      const graph = scaleFreeGraph(20, 2, 456);
-      
-      const positions1 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false, false, null, null, null, false);
-      const positions2 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false, false, null, null, null, true);
-      
-      // Both should complete
-      assert.equal(Object.keys(positions1).length, 20);
-      assert.equal(Object.keys(positions2).length, 20);
-    });
-
-    it('should handle linlog mode', () => {
-      const graph = randomGraph(15, 0.2, 789);
-      
-      const positions1 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false, false, null, null, null, false, false);
-      const positions2 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false, false, null, null, null, false, true);
-      
-      // Both modes should work
-      assert.equal(Object.keys(positions1).length, 15);
-      assert.equal(Object.keys(positions2).length, 15);
-    });
-
-    it('should handle edge weights', () => {
-      const graph = {
-        nodes: () => [0, 1, 2, 3],
-        edges: () => [[0, 1], [1, 2], [2, 3], [3, 0]],
-        get_edge_data: (u, v) => {
-          // Make edge 0-1 stronger
-          if ((u === 0 && v === 1) || (u === 1 && v === 0)) {
-            return { weight: 10.0 };
-          }
-          return { weight: 1.0 };
-        }
-      };
-      
-      const positions = forceatlas2Layout(graph, null, 100, 1.0, 2.0, 1.0, false, false, null, null, 'weight');
-      
-      // Nodes 0 and 1 should be closer due to stronger edge
-      const d01 = getDistance(positions, 0, 1);
-      const d12 = getDistance(positions, 1, 2);
-      const d23 = getDistance(positions, 2, 3);
-      
-      // ForceAtlas2 is complex and edge weights might not always
-      // result in predictable distance relationships due to other forces
-      // Just verify all nodes are positioned
-      assert.isAbove(d01, 0);
-      assert.isAbove(d12, 0);
-      assert.isAbove(d23, 0);
-      assert.equal(Object.keys(positions).length, 4);
-    });
-  });
-
-  describe('Parameter variations', () => {
-    it('should produce consistent results with same seed', () => {
-      const graph = randomGraph(12, 0.3, 111);
-      
-      const positions1 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false, false, null, null, null, false, false, 42);
-      const positions2 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false, false, null, null, null, false, false, 42);
-      
-      // Same seed should produce same initial positions
-      graph.nodes().forEach(node => {
-        assert.approximately(positions1[node][0], positions2[node][0], 0.1);
-        assert.approximately(positions1[node][1], positions2[node][1], 0.1);
-      });
-    });
-
-    it('should produce different results with different seeds', () => {
-      const graph = cycleGraph(8);
-      
-      const positions1 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false, false, null, null, null, false, false, 123);
-      const positions2 = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false, false, null, null, null, false, false, 456);
-      
-      // Different seeds should produce different layouts
-      let totalDiff = 0;
-      graph.nodes().forEach(node => {
-        totalDiff += Math.abs(positions1[node][0] - positions2[node][0]);
-        totalDiff += Math.abs(positions1[node][1] - positions2[node][1]);
-      });
-      assert.isAbove(totalDiff, 0.1);
-    });
-
-    it('should handle different dimensions', () => {
-      const graph = starGraph(6);
-      
-      // 2D layout
-      const positions2D = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false, false, null, null, null, false, false, null, 2);
-      graph.nodes().forEach(node => {
-        assert.equal(positions2D[node].length, 2);
-      });
-      
-      // 3D layout
-      const positions3D = forceatlas2Layout(graph, null, 50, 1.0, 2.0, 1.0, false, false, null, null, null, false, false, null, 3);
-      graph.nodes().forEach(node => {
-        assert.equal(positions3D[node].length, 3);
-        assert.isNumber(positions3D[node][2]);
-      });
-    });
-  });
-
-  describe('Special cases and edge cases', () => {
-    it('should handle string node IDs', () => {
-      const graph = {
-        nodes: () => ['A', 'B', 'C', 'D', 'E'],
-        edges: () => [['A', 'B'], ['B', 'C'], ['C', 'D'], ['D', 'E'], ['E', 'A']]
-      };
-      
-      const positions = forceatlas2Layout(graph);
-      
-      assert.equal(Object.keys(positions).length, 5);
-      ['A', 'B', 'C', 'D', 'E'].forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.equal(positions[node].length, 2);
-      });
-    });
-
-    it('should handle large graphs reasonably', () => {
-      const graph = gridGraph(10, 10); // 100 nodes
-      
-      const startTime = performance.now();
-      const positions = forceatlas2Layout(graph, null, 30, 1.0, 2.0, 1.0, false, false, null, null, null, false, false, 42); // Fewer iterations for speed
-      const endTime = performance.now();
-      
-      assert.equal(Object.keys(positions).length, 100);
-      assert.isBelow(endTime - startTime, 2000); // Should complete in reasonable time
-    });
-
-    it('should handle high jitter tolerance', () => {
-      const graph = completeGraph(6);
-      
-      const positions = forceatlas2Layout(graph, null, 50, 10.0); // High jitter tolerance
-      
-      assert.equal(Object.keys(positions).length, 6);
-    });
-
-    it('should handle extreme scaling ratios', () => {
-      const graph = starGraph(8);
-      
-      const positions1 = forceatlas2Layout(graph, null, 50, 1.0, 0.1); // Low scaling
-      const positions2 = forceatlas2Layout(graph, null, 50, 1.0, 10.0); // High scaling
-      
-      // Both should complete
-      assert.equal(Object.keys(positions1).length, 8);
-      assert.equal(Object.keys(positions2).length, 8);
-    });
-  });
-
-  describe('Layout quality', () => {
-    it('should separate non-connected nodes', () => {
-      const graph = {
-        nodes: () => [0, 1, 2, 3, 4, 5],
-        edges: () => [[0, 1], [1, 2], [3, 4], [4, 5]]
-      };
-      
-      const positions = forceatlas2Layout(graph, null, 100);
-      
-      // Components should be separated
-      const comp1Center = getCenterOfMass({ 0: positions[0], 1: positions[1], 2: positions[2] });
-      const comp2Center = getCenterOfMass({ 3: positions[3], 4: positions[4], 5: positions[5] });
-      
-      const componentDist = Math.sqrt(
-        Math.pow(comp1Center[0] - comp2Center[0], 2) +
-        Math.pow(comp1Center[1] - comp2Center[1], 2)
-      );
-      
-      // ForceAtlas2 might not always separate components by a large distance
-      assert.isAbove(componentDist, 0.03);
-    });
-
-    it('should create balanced layouts for regular graphs', () => {
-      const graph = completeGraph(6);
-      const positions = forceatlas2Layout(graph, null, 100, 1.0, 2.0, 1.0, false, false, null, null, null, false, false, 42);
-      
-      // Should spread nodes reasonably
-      const bounds = getLayoutBounds(positions);
-      assert.isAbove(bounds.width, 0.3);
-      assert.isAbove(bounds.height, 0.3);
-      
-      // Should not be too stretched
-      const aspectRatio = Math.max(bounds.width, bounds.height) / Math.min(bounds.width, bounds.height);
-      assert.isBelow(aspectRatio, 3);
-    });
-  });
-});
-
-// Helper functions
-function getAverageDistanceFromCenter(positions) {
-  const nodes = Object.keys(positions);
-  let totalDist = 0;
-  
-  nodes.forEach(node => {
-    totalDist += Math.sqrt(positions[node][0] ** 2 + positions[node][1] ** 2);
-  });
-  
-  return totalDist / nodes.length;
-}
-
-function getDistance(positions, node1, node2) {
-  const dx = positions[node1][0] - positions[node2][0];
-  const dy = positions[node1][1] - positions[node2][1];
-  return Math.sqrt(dx * dx + dy * dy);
-}
-
-function getCenterOfMass(positions) {
-  const nodes = Object.keys(positions);
-  const com = [0, 0];
-  
-  nodes.forEach(node => {
-    com[0] += positions[node][0];
-    com[1] += positions[node][1];
-  });
-  
-  com[0] /= nodes.length;
-  com[1] /= nodes.length;
-  return com;
-}
-
-function getLayoutBounds(positions) {
-  const nodes = Object.keys(positions);
-  let minX = Infinity, maxX = -Infinity;
-  let minY = Infinity, maxY = -Infinity;
-  
-  nodes.forEach(node => {
-    minX = Math.min(minX, positions[node][0]);
-    maxX = Math.max(maxX, positions[node][0]);
-    minY = Math.min(minY, positions[node][1]);
-    maxY = Math.max(maxY, positions[node][1]);
-  });
-  
-  return {
-    width: maxX - minX,
-    height: maxY - minY
-  };
-}