@graphty/layout 1.1.0 → 1.1.1

package/test/random-layout.test.ts

@@ -0,0 +1,254 @@
+import { describe, it, assert } from 'vitest';
+import { 
+  randomLayout,
+  completeGraph,
+  cycleGraph,
+  starGraph,
+  gridGraph
+} from '../layout.ts';
+
+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

@@ -0,0 +1,373 @@
+import { describe, it, assert } from 'vitest';
+import { 
+  rescaleLayout,
+  rescaleLayoutDict,
+  circularLayout,
+  randomLayout,
+  completeGraph,
+  starGraph
+} from '../layout.ts';
+
+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