@graphty/layout 1.2.2 → 1.2.4

package/test/random-layout.test.ts

@@ -1,254 +0,0 @@
-import { describe, it, assert } from 'vitest';
-import { 
-  randomLayout,
-  completeGraph,
-  cycleGraph,
-  starGraph,
-  gridGraph
-} from '../src';
-
-describe('Random Layout', () => {
-  describe('Basic functionality', () => {
-    it('should position all nodes', () => {
-      const graph = completeGraph(8);
-      const positions = randomLayout(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 = randomLayout(emptyGraph);
-      
-      assert.equal(Object.keys(positions).length, 0);
-    });
-
-    it('should handle single node', () => {
-      const singleNode = { nodes: () => [0], edges: () => [] };
-      const positions = randomLayout(singleNode);
-      
-      assert.equal(Object.keys(positions).length, 1);
-      assert.isDefined(positions[0]);
-      assert.equal(positions[0].length, 2);
-    });
-
-    it('should handle disconnected components', () => {
-      const disconnected = {
-        nodes: () => [0, 1, 2, 3],
-        edges: () => [[0, 1], [2, 3]]
-      };
-      const positions = randomLayout(disconnected);
-      
-      assert.equal(Object.keys(positions).length, 4);
-      [0, 1, 2, 3].forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.equal(positions[node].length, 2);
-      });
-    });
-  });
-
-  describe('Random distribution properties', () => {
-    it('should position nodes within [0, 1] range by default', () => {
-      const graph = cycleGraph(20);
-      const positions = randomLayout(graph);
-      
-      graph.nodes().forEach(node => {
-        const [x, y] = positions[node];
-        assert.isAtLeast(x, -1);
-        assert.isAtMost(x, 1);
-        assert.isAtLeast(y, -1);
-        assert.isAtMost(y, 1);
-      });
-    });
-
-    it('should distribute nodes across the full range', () => {
-      const graph = gridGraph(10, 10); // 100 nodes
-      const positions = randomLayout(graph);
-      
-      const xValues = graph.nodes().map(node => positions[node][0]);
-      const yValues = graph.nodes().map(node => positions[node][1]);
-      
-      // With 100 nodes, we should have good coverage
-      const minX = Math.min(...xValues);
-      const maxX = Math.max(...xValues);
-      const minY = Math.min(...yValues);
-      const maxY = Math.max(...yValues);
-      
-      // Should use a good portion of the [-1, 1] range
-      // With random distribution, we can't guarantee 80% coverage
-      assert.isAbove(maxX - minX, 0.5);
-      assert.isAbove(maxY - minY, 0.5);
-    });
-
-    it('should handle default range', () => {
-      const graph = starGraph(10);
-      const positions = randomLayout(graph);
-      
-      graph.nodes().forEach(node => {
-        const [x, y] = positions[node];
-        assert.isAtLeast(x, -1);
-        assert.isAtMost(x, 1);
-        assert.isAtLeast(y, -1);
-        assert.isAtMost(y, 1);
-      });
-    });
-  });
-
-  describe('Parameter variations', () => {
-    it('should produce different random layouts', () => {
-      const graph = completeGraph(5);
-      
-      // Get multiple random layouts
-      const positions1 = randomLayout(graph);
-      const positions2 = randomLayout(graph);
-      const positions3 = randomLayout(graph);
-      
-      // At least some positions should differ
-      let different = false;
-      graph.nodes().forEach(node => {
-        if (positions1[node][0] !== positions2[node][0] || 
-            positions1[node][1] !== positions2[node][1] ||
-            positions2[node][0] !== positions3[node][0] ||
-            positions2[node][1] !== positions3[node][1]) {
-          different = true;
-        }
-      });
-      assert.isTrue(different);
-    });
-
-    it('should respect center parameter', () => {
-      const graph = cycleGraph(6);
-      const center = [10, 20];
-      
-      const positions = randomLayout(graph, center);
-      
-      // Positions should be around the center
-      graph.nodes().forEach(node => {
-        const [x, y] = positions[node];
-        assert.isAtLeast(x, center[0] - 1);
-        assert.isAtMost(x, center[0] + 1);
-        assert.isAtLeast(y, center[1] - 1);
-        assert.isAtMost(y, center[1] + 1);
-      });
-    });
-
-    it('should handle different dimensions', () => {
-      const graph = completeGraph(4);
-      
-      // 2D layout (default)
-      const positions2D = randomLayout(graph, [0, 0], 2);
-      graph.nodes().forEach(node => {
-        assert.equal(positions2D[node].length, 2);
-      });
-      
-      // 3D layout
-      const positions3D = randomLayout(graph, [0, 0, 0], 3);
-      graph.nodes().forEach(node => {
-        assert.equal(positions3D[node].length, 3);
-        assert.isNumber(positions3D[node][2]);
-        assert.isAtLeast(positions3D[node][2], -1);
-        assert.isAtMost(positions3D[node][2], 1);
-      });
-    });
-
-    it('should produce different layouts with different seeds', () => {
-      const graph = starGraph(8);
-      
-      const positions1 = randomLayout(graph, [0, 0], 2, 42);
-      const positions2 = randomLayout(graph, [0, 0], 2, 123);
-      
-      // At least some positions should 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 produce same layout with same seed', () => {
-      const graph = completeGraph(10);
-      const seed = 12345;
-      
-      const positions1 = randomLayout(graph, [0, 0], 2, seed);
-      const positions2 = randomLayout(graph, [0, 0], 2, seed);
-      
-      // Should be identical
-      graph.nodes().forEach(node => {
-        assert.deepEqual(positions1[node], positions2[node]);
-      });
-    });
-  });
-
-  describe('Special cases', () => {
-    it('should handle string node IDs', () => {
-      const graph = {
-        nodes: () => ['A', 'B', 'C', 'D'],
-        edges: () => [['A', 'B'], ['B', 'C'], ['C', 'D']]
-      };
-      
-      const positions = randomLayout(graph);
-      
-      assert.equal(Object.keys(positions).length, 4);
-      ['A', 'B', 'C', 'D'].forEach(node => {
-        assert.isDefined(positions[node]);
-        assert.isAtLeast(positions[node][0], -1);
-        assert.isAtMost(positions[node][0], 1);
-      });
-    });
-
-    it('should handle negative center values', () => {
-      const graph = cycleGraph(4);
-      const positions = randomLayout(graph, [-5, -5]);
-      
-      // Should place nodes around negative center
-      graph.nodes().forEach(node => {
-        const [x, y] = positions[node];
-        assert.isAtLeast(x, -6);
-        assert.isAtMost(x, -4);
-        assert.isAtLeast(y, -6);
-        assert.isAtMost(y, -4);
-      });
-    });
-
-    it('should be fast for large graphs', () => {
-      const graph = gridGraph(20, 20); // 400 nodes
-      
-      const startTime = performance.now();
-      const positions = randomLayout(graph);
-      const endTime = performance.now();
-      
-      assert.equal(Object.keys(positions).length, 400);
-      assert.isBelow(endTime - startTime, 50); // Should be very fast
-    });
-
-    it('should avoid node overlap statistically', () => {
-      const graph = completeGraph(20);
-      const positions = randomLayout(graph);
-      
-      // Calculate minimum distance between any two nodes
-      let minDistance = Infinity;
-      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];
-          const distance = Math.sqrt(dx * dx + dy * dy);
-          minDistance = Math.min(minDistance, distance);
-        }
-      }
-      
-      // With 20 nodes in 10x10 space, minimum distance should be > 0
-      assert.isAbove(minDistance, 0);
-    });
-  });
-});

package/test/rescale-layout.test.ts

@@ -1,373 +0,0 @@
-import { describe, it, assert } from 'vitest';
-import { 
-  rescaleLayout,
-  rescaleLayoutDict,
-  circularLayout,
-  randomLayout,
-  completeGraph,
-  starGraph
-} from '../src';
-
-describe('Rescale Layout', () => {
-  describe('Dictionary format (rescaleLayout)', () => {
-    it('should rescale positions dictionary', () => {
-      const positions = {
-        0: [1, 1],
-        1: [-1, 1],
-        2: [-1, -1],
-        3: [1, -1]
-      };
-      
-      const rescaled = rescaleLayout(positions, 2);
-      
-      // The function scales based on max distance from center
-      // Max distance is sqrt(2), so scale factor is 2/sqrt(2) = sqrt(2)
-      const expectedScale = Math.sqrt(2);
-      assert.approximately(rescaled[0][0], expectedScale, 0.01);
-      assert.approximately(rescaled[0][1], expectedScale, 0.01);
-    });
-
-    it('should center positions around specified point', () => {
-      const positions = {
-        A: [1, 1],
-        B: [-1, 1],
-        C: [-1, -1],
-        D: [1, -1]
-      };
-      
-      const center = [10, 5];
-      const rescaled = rescaleLayout(positions, 1, center);
-      
-      // The max distance is sqrt(2), scale is 1/sqrt(2)
-      const scale = 1 / Math.sqrt(2);
-      assert.approximately(rescaled['A'][0], 10 + scale, 0.01);
-      assert.approximately(rescaled['A'][1], 5 + scale, 0.01);
-    });
-
-    it('should handle empty positions', () => {
-      const positions = {};
-      const rescaled = rescaleLayout(positions, 2, [5, 5]);
-      
-      assert.deepEqual(rescaled, {});
-    });
-
-    it('should handle single node', () => {
-      const positions = { node1: [3, 4] };
-      const rescaled = rescaleLayout(positions, 2, [0, 0]);
-      
-      // Single node should be placed at center
-      assert.deepEqual(rescaled['node1'], [0, 0]);
-    });
-
-    it('should scale and center combined', () => {
-      const positions = {
-        0: [2, 0],
-        1: [0, 2],
-        2: [-2, 0],
-        3: [0, -2]
-      };
-      
-      const rescaled = rescaleLayout(positions, 0.5, [10, 10]);
-      
-      // Max distance is 2, scale factor is 0.5/2 = 0.25
-      assert.approximately(rescaled[0][0], 10.5, 0.01);
-      assert.approximately(rescaled[0][1], 10, 0.01);
-    });
-  });
-
-  describe('Array format (rescaleLayout)', () => {
-    it('should rescale positions array', () => {
-      const positions = [
-        [1, 1],
-        [-1, 1],
-        [-1, -1],
-        [1, -1]
-      ];
-      
-      const rescaled = rescaleLayout(positions, 3);
-      
-      // Max distance is sqrt(2), scale factor is 3/sqrt(2)
-      const expectedScale = 3 / Math.sqrt(2);
-      assert.approximately(rescaled[0][0], expectedScale, 0.01);
-      assert.approximately(rescaled[0][1], expectedScale, 0.01);
-    });
-
-    it('should center array positions', () => {
-      const positions = [
-        [1, 0],
-        [0, 1],
-        [-1, 0],
-        [0, -1]
-      ];
-      
-      const rescaled = rescaleLayout(positions, 1, [5, 5]);
-      
-      assert.deepEqual(rescaled[0], [6, 5]);
-      assert.deepEqual(rescaled[1], [5, 6]);
-      assert.deepEqual(rescaled[2], [4, 5]);
-      assert.deepEqual(rescaled[3], [5, 4]);
-    });
-
-    it('should handle empty array', () => {
-      const positions: number[][] = [];
-      const rescaled = rescaleLayout(positions, 2, [5, 5]);
-      
-      assert.deepEqual(rescaled, []);
-    });
-
-    it('should handle 3D positions', () => {
-      const positions = [
-        [1, 1, 1],
-        [-1, -1, -1]
-      ];
-      
-      const rescaled = rescaleLayout(positions, 2, [0, 0, 0]);
-      
-      // Max distance is sqrt(3), scale factor is 2/sqrt(3)
-      const scale = 2 / Math.sqrt(3);
-      assert.approximately(rescaled[0][0], scale, 0.01);
-      assert.approximately(rescaled[0][1], scale, 0.01);
-      assert.approximately(rescaled[0][2], scale, 0.01);
-    });
-  });
-
-  describe('Integration with layouts', () => {
-    it('should rescale circular layout', () => {
-      const graph = completeGraph(6);
-      const positions = circularLayout(graph, 1); // radius 1
-      
-      const rescaled = rescaleLayout(positions, 5); // scale up to radius 5
-      
-      // Check that all nodes are now at radius ~5
-      Object.values(rescaled).forEach(pos => {
-        const radius = Math.sqrt(pos[0] ** 2 + pos[1] ** 2);
-        assert.approximately(radius, 5, 0.01);
-      });
-    });
-
-    it('should recenter random layout', () => {
-      const graph = starGraph(5);
-      const positions = randomLayout(graph, [0, 0]); // centered at origin
-      
-      const newCenter = [20, 30];
-      const rescaled = rescaleLayout(positions, 1, newCenter);
-      
-      // Calculate new center of mass
-      const com = [0, 0];
-      Object.values(rescaled).forEach(pos => {
-        com[0] += pos[0];
-        com[1] += pos[1];
-      });
-      com[0] /= 5;
-      com[1] /= 5;
-      
-      assert.approximately(com[0], newCenter[0], 1);
-      assert.approximately(com[1], newCenter[1], 1);
-    });
-
-    it('should maintain relative positions', () => {
-      const positions = {
-        A: [1, 0],
-        B: [0, 1],
-        C: [-1, 0],
-        D: [0, -1]
-      };
-      
-      const rescaled = rescaleLayout(positions, 2.5, [10, 10]);
-      
-      // Check that relative positions are maintained
-      // A-C should still be horizontal, B-D vertical
-      assert.approximately(rescaled['A'][1], rescaled['C'][1], 0.001); // Same Y
-      assert.approximately(rescaled['B'][0], rescaled['D'][0], 0.001); // Same X
-      
-      // Check distance is scaled properly
-      const originalMaxDist = 1; // from center to any point
-      const newMaxDist = Math.sqrt((rescaled['A'][0] - 10) ** 2 + (rescaled['A'][1] - 10) ** 2);
-      assert.approximately(newMaxDist, 2.5, 0.01);
-    });
-  });
-
-  describe('rescaleLayoutDict specific', () => {
-    it('should be an alias for rescaleLayout with dictionary', () => {
-      const positions = {
-        node1: [1, 1],
-        node2: [-1, -1]
-      };
-      
-      const result1 = rescaleLayout(positions, 2);
-      const result2 = rescaleLayoutDict(positions, 2);
-      
-      // Compare values with tolerance for floating point
-      Object.keys(result1).forEach(key => {
-        assert.approximately(result1[key][0], result2[key][0], 0.001);
-        assert.approximately(result1[key][1], result2[key][1], 0.001);
-      });
-    });
-
-    it('should handle string node IDs', () => {
-      const positions = {
-        'user:1': [2, 3],
-        'user:2': [4, 5],
-        'item:1': [1, 2]
-      };
-      
-      const rescaled = rescaleLayoutDict(positions, 0.5, [0, 0]);
-      
-      assert.isDefined(rescaled['user:1']);
-      assert.isDefined(rescaled['user:2']);
-      assert.isDefined(rescaled['item:1']);
-    });
-  });
-
-  describe('Edge cases', () => {
-    it('should handle zero scale', () => {
-      const positions = {
-        A: [5, 5],
-        B: [10, 10],
-        C: [-5, -5]
-      };
-      
-      const rescaled = rescaleLayout(positions, 0, [7, 7]);
-      
-      // All nodes should collapse to center
-      assert.deepEqual(rescaled['A'], [7, 7]);
-      assert.deepEqual(rescaled['B'], [7, 7]);
-      assert.deepEqual(rescaled['C'], [7, 7]);
-    });
-
-    it('should handle negative scale', () => {
-      const positions = {
-        0: [1, 0],
-        1: [0, 1]
-      };
-      
-      const rescaled = rescaleLayout(positions, -1);
-      
-      // Center is at (0.5, 0.5)
-      // Centered positions: [0.5, -0.5] and [-0.5, 0.5]
-      // Max distance = sqrt(0.5² + 0.5²) = 0.707...
-      // Scale factor = -1/0.707... = -1.414...
-      // Should flip and scale positions
-      assert.approximately(rescaled[0][0], -0.707, 0.01);
-      assert.approximately(rescaled[0][1], 0.707, 0.01);
-      assert.approximately(rescaled[1][0], 0.707, 0.01);
-      assert.approximately(rescaled[1][1], -0.707, 0.01);
-    });
-
-    it('should preserve original positions object', () => {
-      const positions = {
-        A: [1, 2],
-        B: [3, 4]
-      };
-      
-      const original = JSON.parse(JSON.stringify(positions));
-      const rescaled = rescaleLayout(positions, 2);
-      
-      // Original should be unchanged
-      assert.deepEqual(positions, original);
-      
-      // Rescaled should be different
-      assert.notDeepEqual(rescaled['A'], positions['A']);
-    });
-
-    it('should handle positions with different dimensions', () => {
-      const positions = {
-        A: [1, 2],
-        B: [3, 4, 5], // 3D
-        C: [6] // 1D
-      };
-      
-      const rescaled = rescaleLayout(positions, 2, [0, 0, 0]);
-      
-      // rescaleLayout uses dimension of first position (A has 2D)
-      // But when center has more dimensions, the result extends to match center
-      assert.equal(rescaled['A'].length, 3);
-      assert.equal(rescaled['A'][2], 0); // Third dimension from center
-      assert.equal(rescaled['B'].length, 3);
-      assert.equal(rescaled['C'].length, 3);
-    });
-
-    it('should handle very large scale factors', () => {
-      const positions = {
-        0: [0.001, 0],
-        1: [-0.001, 0]
-      };
-      
-      const rescaled = rescaleLayout(positions, 1000);
-      
-      // Max distance is 0.001, scale factor is 1000/0.001 = 1,000,000
-      assert.approximately(rescaled[0][0], 1000, 0.1);
-      assert.approximately(rescaled[1][0], -1000, 0.1);
-    });
-
-    it('should handle positions at origin', () => {
-      const positions = {
-        A: [0, 0],
-        B: [1, 0],
-        C: [0, 1]
-      };
-      
-      const rescaled = rescaleLayout(positions, 3, [10, 10]);
-      
-      // Center is at (1/3, 1/3)
-      // After centering: A=[-1/3,-1/3], B=[2/3,-1/3], C=[-1/3,2/3]
-      // Max distance = sqrt((2/3)^2 + (2/3)^2) = sqrt(8/9) = 0.9428...
-      // Scale factor = 3 / 0.9428 = 3.182...
-      // B after scaling = [2/3 * 3.182, -1/3 * 3.182] + [10, 10] = [12.12, 8.94]
-      const dist = Math.sqrt((rescaled['B'][0] - 10) ** 2 + (rescaled['B'][1] - 10) ** 2);
-      assert.approximately(dist, 3, 0.1);
-    });
-  });
-
-  describe('Practical usage patterns', () => {
-    it('should normalize layout to unit square', () => {
-      const positions = {
-        0: [10, 20],
-        1: [30, 40],
-        2: [20, 10],
-        3: [40, 30]
-      };
-      
-      // Scale to fit in unit square centered at (0.5, 0.5)
-      const rescaled = rescaleLayout(positions, 0.5, [0.5, 0.5]);
-      
-      // Check that layout fits in reasonable bounds
-      const values = Object.values(rescaled);
-      const xCoords = values.map(p => p[0]);
-      const yCoords = values.map(p => p[1]);
-      
-      assert.isAtLeast(Math.min(...xCoords), 0);
-      assert.isAtMost(Math.max(...xCoords), 1);
-      assert.isAtLeast(Math.min(...yCoords), 0);
-      assert.isAtMost(Math.max(...yCoords), 1);
-    });
-
-    it('should combine multiple layouts with different scales', () => {
-      const layout1 = {
-        A: [1, 1],
-        B: [-1, 1]
-      };
-      
-      const layout2 = {
-        C: [0.5, 0.5],
-        D: [-0.5, 0.5]
-      };
-      
-      // Scale second layout and offset it
-      const rescaled2 = rescaleLayout(layout2, 2, [5, 0]);
-      
-      // Combine layouts
-      const combined = { ...layout1, ...rescaled2 };
-      
-      assert.equal(Object.keys(combined).length, 4);
-      assert.deepEqual(combined['A'], [1, 1]);
-      
-      // Check rescaled layout is positioned correctly
-      const centerX = (rescaled2['C'][0] + rescaled2['D'][0]) / 2;
-      assert.approximately(centerX, 5, 0.1);
-    });
-  });
-});
-
-// Note: rescaleLayoutDict is tested implicitly through rescaleLayout tests
-// since they share the same implementation for dictionary inputs