@graphty/layout 1.2.3 → 1.2.4

package/test/spiral-layout.test.ts

@@ -1,338 +0,0 @@
-import { describe, it, assert } from 'vitest';
-import { 
-  spiralLayout,
-  completeGraph,
-  cycleGraph,
-  starGraph,
-  gridGraph,
-  randomGraph
-} from '../src';
-
-describe('Spiral Layout', () => {
-  describe('Basic functionality', () => {
-    it('should position all nodes', () => {
-      const graph = completeGraph(10);
-      const positions = spiralLayout(graph);
-      
-      assert.equal(Object.keys(positions).length, 10);
-      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 = spiralLayout(emptyGraph);
-      
-      assert.equal(Object.keys(positions).length, 0);
-    });
-
-    it('should handle single node', () => {
-      const singleNode = { nodes: () => ['A'], edges: () => [] };
-      const positions = spiralLayout(singleNode);
-      
-      assert.equal(Object.keys(positions).length, 1);
-      assert.isDefined(positions['A']);
-      assert.equal(positions['A'].length, 2);
-      // Single node should be at center
-      assert.isBelow(Math.abs(positions['A'][0]), 0.1);
-      assert.isBelow(Math.abs(positions['A'][1]), 0.1);
-    });
-
-    it('should handle disconnected components', () => {
-      const disconnected = {
-        nodes: () => [1, 2, 3, 4, 5, 6],
-        edges: () => [[1, 2], [2, 3], [4, 5], [5, 6]]
-      };
-      const positions = spiralLayout(disconnected);
-      
-      assert.equal(Object.keys(positions).length, 6);
-      [1, 2, 3, 4, 5, 6].forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.equal(positions[node].length, 2);
-      });
-    });
-  });
-
-  describe('Spiral properties', () => {
-    it('should arrange nodes in spiral pattern with increasing radius', () => {
-      const graph = cycleGraph(20);
-      const positions = spiralLayout(graph);
-      const nodes = graph.nodes();
-      
-      // Calculate distances from center for sequential nodes
-      const distances = nodes.map(node => {
-        const [x, y] = positions[node];
-        return Math.sqrt(x * x + y * y);
-      });
-      
-      // Generally, later nodes should be further from center
-      let increasingTrend = 0;
-      for (let i = 1; i < distances.length; i++) {
-        if (distances[i] >= distances[i - 1]) {
-          increasingTrend++;
-        }
-      }
-      
-      // Most distances should increase (allowing for some spiral curvature)
-      assert.isAbove(increasingTrend / (distances.length - 1), 0.7);
-    });
-
-    it('should create smooth spiral curve', () => {
-      const graph = cycleGraph(30);
-      const positions = spiralLayout(graph);
-      const nodes = graph.nodes();
-      
-      // Calculate angles for sequential nodes
-      const angles: number[] = [];
-      for (let i = 0; i < nodes.length; i++) {
-        const [x, y] = positions[nodes[i]];
-        let angle = Math.atan2(y, x);
-        // Normalize to [0, 2π]
-        if (angle < 0) angle += 2 * Math.PI;
-        angles.push(angle);
-      }
-      
-      // Count angle wraparounds (full rotations)
-      let rotations = 0;
-      for (let i = 1; i < angles.length; i++) {
-        if (angles[i] < angles[i - 1] - Math.PI) {
-          rotations++;
-        }
-      }
-      
-      // Should have at least one full rotation for 30 nodes
-      assert.isAtLeast(rotations, 1);
-    });
-
-    it('should handle equidistant mode', () => {
-      const graph = starGraph(15);
-      const positions = spiralLayout(graph, 1, [0, 0], 2, true);
-      
-      // Calculate distances between consecutive nodes
-      const nodes = graph.nodes();
-      const distances: number[] = [];
-      
-      for (let i = 1; i < nodes.length; i++) {
-        const dx = positions[nodes[i]][0] - positions[nodes[i-1]][0];
-        const dy = positions[nodes[i]][1] - positions[nodes[i-1]][1];
-        distances.push(Math.sqrt(dx * dx + dy * dy));
-      }
-      
-      // In equidistant mode, distances vary but should have some consistency
-      const avgDistance = distances.reduce((a, b) => a + b) / distances.length;
-      
-      // Check that we have reasonable spacing
-      assert.isAbove(avgDistance, 0);
-      assert.isBelow(avgDistance, 1);
-    });
-
-    it('should handle non-equidistant mode', () => {
-      const graph = completeGraph(12);
-      const positions = spiralLayout(graph, 1, [0, 0], 2, 0.35, false);
-      
-      // In non-equidistant mode, nodes spread with equal angle
-      const nodes = graph.nodes();
-      const angles = nodes.map(node => {
-        const [x, y] = positions[node];
-        return Math.atan2(y, x);
-      });
-      
-      // Check angle differences (accounting for spiral growth)
-      assert.equal(angles.length, 12);
-      // Angles should show regular progression
-    });
-  });
-
-  describe('Parameter variations', () => {
-    it('should respect scale parameter', () => {
-      const graph = cycleGraph(8);
-      
-      const positions1 = spiralLayout(graph, 0.5);
-      const positions2 = spiralLayout(graph, 2.0);
-      
-      // Calculate max distances
-      const maxDist1 = Math.max(...graph.nodes().map(node => {
-        const [x, y] = positions1[node];
-        return Math.sqrt(x * x + y * y);
-      }));
-      
-      const maxDist2 = Math.max(...graph.nodes().map(node => {
-        const [x, y] = positions2[node];
-        return Math.sqrt(x * x + y * y);
-      }));
-      
-      // Scale 2 should produce larger spiral
-      assert.approximately(maxDist2 / maxDist1, 4, 0.1); // Scale factor squared
-    });
-
-    it('should respect center parameter', () => {
-      const graph = starGraph(7);
-      const center = [3, -2];
-      
-      const positions = spiralLayout(graph, 1, center);
-      
-      // Check that positions are shifted by center
-      const defaultPositions = spiralLayout(graph, 1, [0, 0]);
-      
-      // Check center of mass is shifted
-      const centerX = graph.nodes().reduce((sum, node) => sum + positions[node][0], 0) / graph.nodes().length;
-      const centerY = graph.nodes().reduce((sum, node) => sum + positions[node][1], 0) / graph.nodes().length;
-      const defaultCenterX = graph.nodes().reduce((sum, node) => sum + defaultPositions[node][0], 0) / graph.nodes().length;
-      const defaultCenterY = graph.nodes().reduce((sum, node) => sum + defaultPositions[node][1], 0) / graph.nodes().length;
-      
-      // Centers should be shifted by approximately the center parameter
-      assert.approximately(centerX - defaultCenterX, center[0], 0.5);
-      assert.approximately(centerY - defaultCenterY, center[1], 0.5);
-    });
-
-    it('should only support 2D layouts', () => {
-      const graph = completeGraph(5);
-      
-      // 2D layout works
-      const positions2D = spiralLayout(graph, 1, [0, 0], 2);
-      graph.nodes().forEach(node => {
-        assert.equal(positions2D[node].length, 2);
-      });
-      
-      // 3D layout should throw error
-      assert.throws(() => {
-        spiralLayout(graph, 1, [0, 0, 0], 3);
-      }, 'can only handle 2 dimensions');
-    });
-
-    it('should respect resolution parameter', () => {
-      const graph = gridGraph(3, 3);
-      
-      const positions1 = spiralLayout(graph, 1, [0, 0], 2, 0.1, true);
-      const positions2 = spiralLayout(graph, 1, [0, 0], 2, 1.0, true);
-      
-      // Different resolutions should produce different spirals
-      let different = false;
-      graph.nodes().forEach(node => {
-        if (Math.abs(positions1[node][0] - positions2[node][0]) > 0.01 ||
-            Math.abs(positions1[node][1] - positions2[node][1]) > 0.01) {
-          different = true;
-        }
-      });
-      assert.isTrue(different);
-    });
-  });
-
-  describe('Special cases and edge cases', () => {
-    it('should handle string node IDs', () => {
-      const graph = {
-        nodes: () => ['first', 'second', 'third', 'fourth', 'fifth'],
-        edges: () => [['first', 'second'], ['second', 'third'], ['third', 'fourth'], ['fourth', 'fifth']]
-      };
-      
-      const positions = spiralLayout(graph);
-      
-      assert.equal(Object.keys(positions).length, 5);
-      ['first', 'second', 'third', 'fourth', 'fifth'].forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.equal(positions[node].length, 2);
-      });
-    });
-
-    it('should produce consistent results', () => {
-      const graph = randomGraph(15, 0.2, 12345);
-      
-      const positions1 = spiralLayout(graph, 1, [0, 0], 2, true, 0.5);
-      const positions2 = spiralLayout(graph, 1, [0, 0], 2, true, 0.5);
-      
-      // Spiral layout is deterministic
-      graph.nodes().forEach(node => {
-        assert.deepEqual(positions1[node], positions2[node]);
-      });
-    });
-
-    it('should handle large graphs efficiently', () => {
-      const graph = gridGraph(20, 20); // 400 nodes
-      
-      const startTime = performance.now();
-      const positions = spiralLayout(graph);
-      const endTime = performance.now();
-      
-      assert.equal(Object.keys(positions).length, 400);
-      assert.isBelow(endTime - startTime, 100);
-    });
-
-    it('should create visually distinct layout from circular', () => {
-      const graph = cycleGraph(20);
-      const spiralPos = spiralLayout(graph);
-      
-      // In spiral, consecutive nodes should have varying distances from center
-      const distances = graph.nodes().map(node => {
-        const [x, y] = spiralPos[node];
-        return Math.sqrt(x * x + y * y);
-      });
-      
-      // Calculate variance in distances
-      const avgDist = distances.reduce((a, b) => a + b) / distances.length;
-      const variance = distances.reduce((sum, d) => sum + Math.pow(d - avgDist, 2), 0) / distances.length;
-      
-      // Spiral should have some variance (unlike perfect circle)
-      assert.isAbove(variance, 0.001);
-    });
-  });
-
-  describe('Layout patterns', () => {
-    it('should create tight spiral for dense graphs', () => {
-      const graph = completeGraph(25);
-      const positions = spiralLayout(graph, 1, [0, 0], 2, 0.35, true);
-      
-      // Check that nodes fill space efficiently
-      const boundingBox = {
-        minX: Math.min(...graph.nodes().map(n => positions[n][0])),
-        maxX: Math.max(...graph.nodes().map(n => positions[n][0])),
-        minY: Math.min(...graph.nodes().map(n => positions[n][1])),
-        maxY: Math.max(...graph.nodes().map(n => positions[n][1]))
-      };
-      
-      const width = boundingBox.maxX - boundingBox.minX;
-      const height = boundingBox.maxY - boundingBox.minY;
-      
-      // Spiral should be roughly square (not too elongated)
-      const aspectRatio = Math.max(width, height) / Math.min(width, height);
-      assert.isBelow(aspectRatio, 2);
-    });
-
-    it('should create logarithmic spiral pattern', () => {
-      const n = 50;
-      const graph = cycleGraph(n);
-      const positions = spiralLayout(graph, 1, [0, 0], 2, 0.35, false);
-      
-      // For non-equidistant spiral, radius should grow exponentially
-      const radii = graph.nodes().map(node => {
-        const [x, y] = positions[node];
-        return Math.sqrt(x * x + y * y);
-      });
-      
-      // Filter out near-zero radii
-      const nonZeroRadii = radii.filter(r => r > 0.01);
-      
-      // Check if growth is approximately exponential
-      // by checking if log(radii) grows linearly
-      if (nonZeroRadii.length > 10) {
-        const logRadii = nonZeroRadii.map(r => Math.log(r));
-        
-        // Simple linear regression
-        const n = logRadii.length;
-        const indices = Array.from({length: n}, (_, i) => i);
-        const sumX = indices.reduce((a, b) => a + b);
-        const sumY = logRadii.reduce((a, b) => a + b);
-        const sumXY = indices.reduce((sum, x, i) => sum + x * logRadii[i], 0);
-        const sumX2 = indices.reduce((sum, x) => sum + x * x, 0);
-        
-        const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
-        
-        // Positive slope indicates exponential growth
-        assert.isAbove(slope, 0);
-      }
-    });
-  });
-});

package/test/spring-layout.test.ts

@@ -1,241 +0,0 @@
-import { describe, it, assert } from 'vitest';
-import { 
-  springLayout,
-  completeGraph,
-  cycleGraph,
-  starGraph,
-  randomGraph
-} from '../src';
-
-describe('Spring Layout', () => {
-  describe('Basic functionality', () => {
-    it('should position all nodes', () => {
-      const graph = completeGraph(5);
-      const positions = springLayout(graph);
-      
-      assert.equal(Object.keys(positions).length, 5);
-      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 = springLayout(emptyGraph);
-      
-      assert.equal(Object.keys(positions).length, 0);
-    });
-
-    it('should handle single node', () => {
-      const singleNode = { nodes: () => [0], edges: () => [] };
-      const positions = springLayout(singleNode);
-      
-      assert.equal(Object.keys(positions).length, 1);
-      assert.deepEqual(positions[0], [0, 0]);
-    });
-
-    it('should handle disconnected components', () => {
-      const disconnected = {
-        nodes: () => [0, 1, 2, 3],
-        edges: () => [[0, 1], [2, 3]] // Two separate components
-      };
-      const positions = springLayout(disconnected);
-      
-      assert.equal(Object.keys(positions).length, 4);
-      // All nodes should have positions
-      [0, 1, 2, 3].forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.equal(positions[node].length, 2);
-      });
-    });
-  });
-
-  describe('Parameter variations', () => {
-    it('should handle different k values', () => {
-      const graph = completeGraph(6);
-      const positions1 = springLayout(graph, 0.5);
-      const positions2 = springLayout(graph, 2.0);
-      
-      // Different k values should produce different layouts
-      // Check that at least some positions differ
-      let different = false;
-      graph.nodes().forEach(node => {
-        if (positions1[node][0] !== positions2[node][0] || 
-            positions1[node][1] !== positions2[node][1]) {
-          different = true;
-        }
-      });
-      assert.isTrue(different);
-    });
-
-    it('should respect fixed positions', () => {
-      const graph = starGraph(5);
-      const initialPositions = { 
-        0: [0, 0], 
-        1: [1, 0],
-        2: [0.5, 0.5],
-        3: [-0.5, 0.5],
-        4: [0, -1]
-      };
-      const fixedNodes = [0, 1]; // Fix center and one leaf
-      
-      const positions = springLayout(graph, null, initialPositions, fixedNodes);
-      
-      // Fixed nodes should remain at their initial positions
-      assert.deepEqual(positions[0], [0, 0]);
-      assert.deepEqual(positions[1], [1, 0]);
-      
-      // Other nodes should have moved from initial positions
-      [2, 3, 4].forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.equal(positions[node].length, 2);
-        // They should have moved from initial positions
-        assert.notEqual(positions[node][0], initialPositions[node][0]);
-      });
-    });
-
-    it('should converge with more iterations', () => {
-      const graph = randomGraph(10, 0.3, 42);
-      
-      // Run with different iteration counts
-      const positions10 = springLayout(graph, null, null, null, 10);
-      const positions100 = springLayout(graph, null, null, null, 100);
-      
-      // Calculate total movement between iterations
-      const movement10to100 = graph.nodes().reduce((sum, node) => {
-        const dx = positions100[node][0] - positions10[node][0];
-        const dy = positions100[node][1] - positions10[node][1];
-        return sum + Math.sqrt(dx * dx + dy * dy);
-      }, 0);
-      
-      // More iterations should lead to more stable layout
-      // (though initial random positions may vary)
-      assert.isAbove(movement10to100, 0);
-    });
-
-    it('should handle different center positions', () => {
-      const graph = cycleGraph(4);
-      const center1 = [0, 0];
-      const center2 = [10, 10];
-      
-      const positions1 = springLayout(graph, null, null, null, 50, 0.01, center1);
-      const positions2 = springLayout(graph, null, null, null, 50, 0.01, center2);
-      
-      // Calculate center of mass for each layout
-      const com1 = graph.nodes().reduce((acc, node) => {
-        return [acc[0] + positions1[node][0], acc[1] + positions1[node][1]];
-      }, [0, 0]).map(v => v / 4);
-      
-      const com2 = graph.nodes().reduce((acc, node) => {
-        return [acc[0] + positions2[node][0], acc[1] + positions2[node][1]];
-      }, [0, 0]).map(v => v / 4);
-      
-      // Centers of mass should be different
-      assert.isAbove(Math.abs(com2[0] - com1[0]), 5);
-      assert.isAbove(Math.abs(com2[1] - com1[1]), 5);
-    });
-  });
-
-  describe('Graph-specific behaviors', () => {
-    it('should arrange complete graph symmetrically', () => {
-      const graph = completeGraph(4);
-      const positions = springLayout(graph, 1, null, null, 200);
-      
-      // In a complete graph, all nodes should be roughly equidistant
-      const distances: number[] = [];
-      const nodes = graph.nodes();
-      
-      for (let i = 0; i < nodes.length; i++) {
-        for (let j = i + 1; j < nodes.length; j++) {
-          const dx = positions[nodes[i]][0] - positions[nodes[j]][0];
-          const dy = positions[nodes[i]][1] - positions[nodes[j]][1];
-          distances.push(Math.sqrt(dx * dx + dy * dy));
-        }
-      }
-      
-      // Calculate variance in distances
-      const avgDistance = distances.reduce((a, b) => a + b) / distances.length;
-      const variance = distances.reduce((sum, d) => sum + Math.pow(d - avgDistance, 2), 0) / distances.length;
-      
-      // Variance should be small for symmetric layout
-      assert.isBelow(variance / (avgDistance * avgDistance), 0.1);
-    });
-
-    it('should stretch cycle graph into circle-like shape', () => {
-      const n = 8;
-      const graph = cycleGraph(n);
-      const positions = springLayout(graph, 1, null, null, 200);
-      
-      // Calculate center of mass
-      const center = graph.nodes().reduce((acc, node) => {
-        return [acc[0] + positions[node][0], acc[1] + positions[node][1]];
-      }, [0, 0]).map(v => v / n);
-      
-      // Calculate distances from center
-      const distances = graph.nodes().map(node => {
-        const dx = positions[node][0] - center[0];
-        const dy = positions[node][1] - center[1];
-        return Math.sqrt(dx * dx + dy * dy);
-      });
-      
-      // All nodes should be roughly equidistant from center
-      const avgDistance = distances.reduce((a, b) => a + b) / distances.length;
-      distances.forEach(d => {
-        assert.isBelow(Math.abs(d - avgDistance) / avgDistance, 0.6);
-      });
-    });
-
-    it('should position star graph with center near origin', () => {
-      const graph = starGraph(7);
-      const positions = springLayout(graph, 1, null, null, 100);
-      
-      // Center node (0) should be near the center
-      const centerDist = Math.sqrt(positions[0][0] ** 2 + positions[0][1] ** 2);
-      assert.isBelow(centerDist, 0.2);
-      
-      // Leaf nodes should be further from origin
-      for (let i = 1; i < 7; i++) {
-        const leafDist = Math.sqrt(positions[i][0] ** 2 + positions[i][1] ** 2);
-        assert.isAbove(leafDist, 0.5);
-      }
-    });
-  });
-
-  describe('Determinism and reproducibility', () => {
-    it('should produce consistent results with same seed', () => {
-      const graph = randomGraph(8, 0.4, 12345);
-      const seed = 42;
-      
-      // Run layout twice with same parameters and seed
-      const positions1 = springLayout(graph, 1, null, null, 50, 1, [0, 0], 2, seed);
-      const positions2 = springLayout(graph, 1, null, null, 50, 1, [0, 0], 2, seed);
-      
-      // Results should be identical with same seed
-      graph.nodes().forEach(node => {
-        assert.equal(positions1[node][0], positions2[node][0]);
-        assert.equal(positions1[node][1], positions2[node][1]);
-      });
-    });
-
-    it('should produce different results with different seeds', () => {
-      const graph = randomGraph(8, 0.4, 12345);
-      
-      // Run layout with different seeds
-      const positions1 = springLayout(graph, 1, null, null, 50, 1, [0, 0], 2, 42);
-      const positions2 = springLayout(graph, 1, null, null, 50, 1, [0, 0], 2, 123);
-      
-      // Results should be different
-      let different = false;
-      graph.nodes().forEach(node => {
-        if (positions1[node][0] !== positions2[node][0] || 
-            positions1[node][1] !== positions2[node][1]) {
-          different = true;
-        }
-      });
-      assert.isTrue(different);
-    });
-  });
-});

package/test/test-utils.ts

@@ -1,34 +0,0 @@
-/**
- * Test utilities and helper functions
- */
-
-import { Graph, Node, Edge } from '../src/types';
-
-/**
- * Create a simple test graph for testing
- */
-export function createTestGraph(nodes: Node[], edges: Edge[]): Graph {
-  return {
-    nodes: () => nodes,
-    edges: () => edges,
-    adjacency: function() {
-      const adj = new Map<Node, Map<Node, number>>();
-      
-      // Initialize adjacency for all nodes
-      for (const node of nodes) {
-        adj.set(node, new Map());
-      }
-      
-      // Add edges
-      for (const [source, target] of edges) {
-        if (!adj.has(source)) adj.set(source, new Map());
-        if (!adj.has(target)) adj.set(target, new Map());
-        
-        adj.get(source)!.set(target, 1);
-        adj.get(target)!.set(source, 1);
-      }
-      
-      return adj;
-    }
-  };
-}