@graphty/layout 1.1.1 → 1.2.1

package/test/circular-layout.test.ts

@@ -7,7 +7,7 @@ import {
   wheelGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Circular Layout', () => {
   describe('Basic functionality', () => {
@@ -172,8 +172,8 @@ describe('Circular Layout', () => {
       const positions3D = circularLayout(graph, 1, [0, 0, 0], 3);
       graph.nodes().forEach(node => {
         assert.equal(positions3D[node].length, 3);
-        // In 3D circular layout, all z-coordinates should be 0
-        assert.equal(positions3D[node][2], 0);
+        // In 3D spherical layout, z-coordinates should vary
+        assert.isNumber(positions3D[node][2]);
       });
     });
 
@@ -297,4 +297,146 @@ describe('Circular Layout', () => {
       }
     });
   });
+
+  describe('3D spherical layout', () => {
+    it('should create spherical layout for dim=3', () => {
+      const graph = completeGraph(8);
+      const positions = circularLayout(graph, 1, [0, 0, 0], 3);
+      
+      assert.equal(Object.keys(positions).length, 8);
+      graph.nodes().forEach(node => {
+        assert.isDefined(positions[node]);
+        assert.equal(positions[node].length, 3);
+        assert.isNumber(positions[node][0]);
+        assert.isNumber(positions[node][1]);
+        assert.isNumber(positions[node][2]);
+      });
+    });
+
+    it('should place all nodes on unit sphere', () => {
+      const graph = cycleGraph(12);
+      const positions = circularLayout(graph, 1, [0, 0, 0], 3);
+      
+      graph.nodes().forEach(node => {
+        const [x, y, z] = positions[node];
+        const radius = Math.sqrt(x * x + y * y + z * z);
+        assert.approximately(radius, 1, 1e-10, `Node ${node} should be on unit sphere`);
+      });
+    });
+
+    it('should respect scale in 3D', () => {
+      const graph = starGraph(6);
+      const scale = 2.5;
+      const positions = circularLayout(graph, scale, [0, 0, 0], 3);
+      
+      graph.nodes().forEach(node => {
+        const [x, y, z] = positions[node];
+        const radius = Math.sqrt(x * x + y * y + z * z);
+        assert.approximately(radius, scale, 1e-10);
+      });
+    });
+
+    it('should respect center in 3D', () => {
+      const graph = completeGraph(4);
+      const center = [10, -5, 7];
+      const positions = circularLayout(graph, 1, center, 3);
+      
+      graph.nodes().forEach(node => {
+        const [x, y, z] = positions[node];
+        const dx = x - center[0];
+        const dy = y - center[1];
+        const dz = z - center[2];
+        const radius = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        assert.approximately(radius, 1, 1e-10);
+      });
+    });
+
+    it('should distribute nodes evenly on sphere using Fibonacci spiral', () => {
+      const graph = completeGraph(20);
+      const positions = circularLayout(graph, 1, [0, 0, 0], 3);
+      
+      // Check that no two nodes are too close together
+      const nodes = graph.nodes();
+      const minDistance = 0.3; // Reasonable minimum distance for 20 nodes on unit sphere
+      
+      for (let i = 0; i < nodes.length; i++) {
+        for (let j = i + 1; j < nodes.length; j++) {
+          const pos1 = positions[nodes[i]];
+          const pos2 = positions[nodes[j]];
+          const dx = pos1[0] - pos2[0];
+          const dy = pos1[1] - pos2[1];
+          const dz = pos1[2] - pos2[2];
+          const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+          assert.isAbove(distance, minDistance, `Nodes ${i} and ${j} are too close`);
+        }
+      }
+    });
+
+    it('should handle single node in 3D', () => {
+      const singleNode = { nodes: () => ['A'], edges: () => [] };
+      const center = [1, 2, 3];
+      const positions = circularLayout(singleNode, 1, center, 3);
+      
+      assert.equal(Object.keys(positions).length, 1);
+      assert.deepEqual(positions['A'], center);
+    });
+
+    it('should produce deterministic results in 3D', () => {
+      const graph = cycleGraph(10);
+      
+      const positions1 = circularLayout(graph, 1, [0, 0, 0], 3);
+      const positions2 = circularLayout(graph, 1, [0, 0, 0], 3);
+      
+      graph.nodes().forEach(node => {
+        assert.deepEqual(positions1[node], positions2[node]);
+      });
+    });
+
+    it('should handle higher dimensions gracefully', () => {
+      const graph = completeGraph(5);
+      const positions = circularLayout(graph, 1, [0, 0, 0, 0], 4);
+      
+      assert.equal(Object.keys(positions).length, 5);
+      graph.nodes().forEach(node => {
+        assert.equal(positions[node].length, 4);
+        // Should be on unit hypersphere
+        const radius = Math.sqrt(positions[node].reduce((sum, coord) => sum + coord * coord, 0));
+        assert.approximately(radius, 1, 0.1); // Allow some tolerance for random hypersphere
+      });
+    });
+
+    it('should use all three dimensions meaningfully', () => {
+      const graph = completeGraph(30);
+      const positions = circularLayout(graph, 1, [0, 0, 0], 3);
+      
+      // Extract all z-coordinates
+      const zCoords = graph.nodes().map(node => positions[node][2]);
+      
+      // Check that z-coordinates have meaningful variation
+      const minZ = Math.min(...zCoords);
+      const maxZ = Math.max(...zCoords);
+      const zRange = maxZ - minZ;
+      
+      assert.isAbove(zRange, 1.5, 'Z-coordinates should have significant variation');
+      assert.approximately(maxZ, 1, 0.1, 'Max Z should be near 1');
+      assert.approximately(minZ, -1, 0.1, 'Min Z should be near -1');
+    });
+
+    it('should produce valid 3D layout for string node IDs', () => {
+      const graph = {
+        nodes: () => ['alice', 'bob', 'charlie', 'david', 'eve'],
+        edges: () => [['alice', 'bob'], ['bob', 'charlie'], ['charlie', 'david'], 
+                      ['david', 'eve'], ['eve', 'alice']]
+      };
+      
+      const positions = circularLayout(graph, 1, [0, 0, 0], 3);
+      
+      assert.equal(Object.keys(positions).length, 5);
+      graph.nodes().forEach(node => {
+        const [x, y, z] = positions[node];
+        const radius = Math.sqrt(x * x + y * y + z * z);
+        assert.approximately(radius, 1, 1e-10);
+      });
+    });
+  });
 });

package/test/forceatlas2-layout.test.ts

@@ -7,7 +7,7 @@ import {
   gridGraph,
   randomGraph,
   scaleFreeGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('ForceAtlas2 Layout', () => {
   describe('Basic functionality', () => {

package/test/fruchterman-reingold-layout.test.ts

@@ -6,7 +6,7 @@ import {
   starGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Fruchterman-Reingold Layout', () => {
   describe('Basic functionality', () => {

package/test/graph-generators.test.ts

@@ -9,7 +9,7 @@ import {
   bipartiteGraph,
   scaleFreeGraph,
   circularLayout
-} from '../layout.ts';
+} from '../src';
 
 describe('Graph Generators', () => {
   describe('completeGraph', () => {

package/test/kamada-kawai-layout.test.ts

@@ -6,7 +6,7 @@ import {
   starGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Kamada-Kawai Layout', () => {
   describe('Basic functionality', () => {
@@ -309,6 +309,249 @@ describe('Kamada-Kawai Layout', () => {
       assert.isBelow(totalDiff / graph.nodes().length, 0.1);
     });
   });
+
+  describe('3D Kamada-Kawai layout', () => {
+    it('should create 3D layout when dim=3', () => {
+      const graph = completeGraph(8);
+      const positions = kamadaKawaiLayout(graph, null, null, 'weight', 1, [0, 0, 0], 3);
+      
+      assert.equal(Object.keys(positions).length, 8);
+      graph.nodes().forEach(node => {
+        assert.isDefined(positions[node]);
+        assert.equal(positions[node].length, 3);
+        assert.isNumber(positions[node][0]);
+        assert.isNumber(positions[node][1]);
+        assert.isNumber(positions[node][2]);
+      });
+    });
+
+    it('should use spherical initialization for 3D', () => {
+      const graph = cycleGraph(6);
+      const positions = kamadaKawaiLayout(graph, null, null, 'weight', 1, [0, 0, 0], 3);
+      
+      // Should produce reasonable edge lengths (not random)
+      const edgeLengths = [];
+      for (const [source, target] of graph.edges()) {
+        const pos1 = positions[source];
+        const pos2 = positions[target];
+        const dist = Math.sqrt(
+          (pos1[0] - pos2[0]) ** 2 + 
+          (pos1[1] - pos2[1]) ** 2 + 
+          (pos1[2] - pos2[2]) ** 2
+        );
+        edgeLengths.push(dist);
+      }
+      
+      // Calculate standard deviation
+      const mean = edgeLengths.reduce((a, b) => a + b) / edgeLengths.length;
+      const variance = edgeLengths.reduce((acc, len) => acc + (len - mean) ** 2, 0) / edgeLengths.length;
+      const stdDev = Math.sqrt(variance);
+      
+      // Should have relatively low variance (not random)
+      assert.isBelow(stdDev / mean, 0.3, 'Edge lengths should be relatively uniform');
+    });
+
+    it('should produce consistent 3D results across runs', () => {
+      const graph = starGraph(7);
+      
+      // Run multiple times
+      const runs = 3;
+      const allPositions = [];
+      
+      for (let i = 0; i < runs; i++) {
+        allPositions.push(kamadaKawaiLayout(graph, null, null, 'weight', 1, [0, 0, 0], 3));
+      }
+      
+      // Check that results are consistent
+      graph.nodes().forEach(node => {
+        for (let i = 1; i < runs; i++) {
+          const pos1 = allPositions[0][node];
+          const pos2 = allPositions[i][node];
+          const diff = Math.sqrt(
+            (pos1[0] - pos2[0]) ** 2 + 
+            (pos1[1] - pos2[1]) ** 2 + 
+            (pos1[2] - pos2[2]) ** 2
+          );
+          assert.isBelow(diff, 1e-6, `Node ${node} should have consistent position across runs`);
+        }
+      });
+    });
+
+    it('should respect scale in 3D', () => {
+      const graph = completeGraph(5);
+      
+      const positions1 = kamadaKawaiLayout(graph, null, null, 'weight', 1, [0, 0, 0], 3);
+      const positions2 = kamadaKawaiLayout(graph, null, null, 'weight', 2, [0, 0, 0], 3);
+      
+      // Calculate bounding box for both
+      const bbox1 = getBoundingBox3D(positions1);
+      const bbox2 = getBoundingBox3D(positions2);
+      
+      // Scale 2 should be approximately twice scale 1
+      assert.approximately(bbox2.width / bbox1.width, 2, 0.1);
+      assert.approximately(bbox2.height / bbox1.height, 2, 0.1);
+      assert.approximately(bbox2.depth / bbox1.depth, 2, 0.1);
+    });
+
+    it('should respect center in 3D', () => {
+      const graph = cycleGraph(5);
+      const center = [10, -5, 7];
+      
+      const positions = kamadaKawaiLayout(graph, null, null, 'weight', 1, center, 3);
+      
+      // Calculate center of mass
+      const com = [0, 0, 0];
+      const nodes = graph.nodes();
+      nodes.forEach(node => {
+        com[0] += positions[node][0];
+        com[1] += positions[node][1];
+        com[2] += positions[node][2];
+      });
+      com[0] /= nodes.length;
+      com[1] /= nodes.length;
+      com[2] /= nodes.length;
+      
+      assert.approximately(com[0], center[0], 1);
+      assert.approximately(com[1], center[1], 1);
+      assert.approximately(com[2], center[2], 1);
+    });
+
+    it('should optimize stress in 3D for regular graphs', () => {
+      const graph = completeGraph(6);
+      const positions = kamadaKawaiLayout(graph, null, null, 'weight', 1, [0, 0, 0], 3);
+      
+      // In a complete graph, all pairwise distances should be similar
+      const distances = [];
+      const nodes = graph.nodes();
+      for (let i = 0; i < nodes.length; i++) {
+        for (let j = i + 1; j < nodes.length; j++) {
+          const pos1 = positions[nodes[i]];
+          const pos2 = positions[nodes[j]];
+          const dist = Math.sqrt(
+            (pos1[0] - pos2[0]) ** 2 + 
+            (pos1[1] - pos2[1]) ** 2 + 
+            (pos1[2] - pos2[2]) ** 2
+          );
+          distances.push(dist);
+        }
+      }
+      
+      const avgDist = distances.reduce((a, b) => a + b) / distances.length;
+      const maxDeviation = Math.max(...distances.map(d => Math.abs(d - avgDist) / avgDist));
+      
+      assert.isBelow(maxDeviation, 0.5, 'All pairwise distances should be relatively similar');
+    });
+
+    it('should handle custom initial 3D positions', () => {
+      const graph = completeGraph(4);
+      
+      // Create custom initial positions (tetrahedron vertices)
+      const initial3D = {
+        0: [1, 1, 1],
+        1: [1, -1, -1],
+        2: [-1, 1, -1],
+        3: [-1, -1, 1]
+      };
+      
+      const positions = kamadaKawaiLayout(graph, null, initial3D, 'weight', 1, [0, 0, 0], 3);
+      
+      assert.equal(Object.keys(positions).length, 4);
+      
+      // Should optimize from initial positions
+      let different = false;
+      graph.nodes().forEach(node => {
+        if (
+          Math.abs(positions[node][0] - initial3D[node][0]) > 0.01 ||
+          Math.abs(positions[node][1] - initial3D[node][1]) > 0.01 ||
+          Math.abs(positions[node][2] - initial3D[node][2]) > 0.01
+        ) {
+          different = true;
+        }
+      });
+      assert.isTrue(different, 'Should modify initial positions during optimization');
+    });
+
+    it('should use all three dimensions effectively', () => {
+      const graph = gridGraph(3, 3);
+      const positions = kamadaKawaiLayout(graph, null, null, 'weight', 1, [0, 0, 0], 3);
+      
+      // Extract coordinate ranges
+      const coords = { x: [], y: [], z: [] };
+      graph.nodes().forEach(node => {
+        coords.x.push(positions[node][0]);
+        coords.y.push(positions[node][1]);
+        coords.z.push(positions[node][2]);
+      });
+      
+      const ranges = {
+        x: Math.max(...coords.x) - Math.min(...coords.x),
+        y: Math.max(...coords.y) - Math.min(...coords.y),
+        z: Math.max(...coords.z) - Math.min(...coords.z)
+      };
+      
+      // All dimensions should be utilized (not flat)
+      assert.isAbove(ranges.x, 0.5, 'X dimension should be utilized');
+      assert.isAbove(ranges.y, 0.5, 'Y dimension should be utilized');
+      assert.isAbove(ranges.z, 0.2, 'Z dimension should be utilized');
+    });
+
+    it('should handle disconnected components in 3D', () => {
+      const graph = {
+        nodes: () => [0, 1, 2, 3, 4, 5],
+        edges: () => [[0, 1], [1, 2], [3, 4], [4, 5]]  // Two triangles
+      };
+      
+      const positions = kamadaKawaiLayout(graph, null, null, 'weight', 1, [0, 0, 0], 3);
+      
+      assert.equal(Object.keys(positions).length, 6);
+      
+      // Each component should be laid out properly
+      const component1 = [0, 1, 2].map(n => positions[n]);
+      const component2 = [3, 4, 5].map(n => positions[n]);
+      
+      // Check internal distances within each component
+      const dist01 = getDistance3D(positions[0], positions[1]);
+      const dist12 = getDistance3D(positions[1], positions[2]);
+      const dist34 = getDistance3D(positions[3], positions[4]);
+      const dist45 = getDistance3D(positions[4], positions[5]);
+      
+      assert.isAbove(dist01, 0);
+      assert.isAbove(dist12, 0);
+      assert.isAbove(dist34, 0);
+      assert.isAbove(dist45, 0);
+    });
+
+    it('should produce better results than random initialization', () => {
+      const graph = cycleGraph(8);
+      
+      // Force random initialization by using very high dimensions (will use random hypersphere)
+      const randomPos = kamadaKawaiLayout(graph, null, null, 'weight', 1, [0, 0, 0, 0, 0], 5);
+      
+      // Normal 3D with spherical initialization
+      const sphericalPos = kamadaKawaiLayout(graph, null, null, 'weight', 1, [0, 0, 0], 3);
+      
+      // Compare edge length uniformity
+      function getEdgeVariance(positions, edges) {
+        const lengths = edges.map(([u, v]) => {
+          const pos1 = positions[u];
+          const pos2 = positions[v];
+          let sum = 0;
+          for (let i = 0; i < Math.min(pos1.length, pos2.length); i++) {
+            sum += (pos1[i] - pos2[i]) ** 2;
+          }
+          return Math.sqrt(sum);
+        });
+        const mean = lengths.reduce((a, b) => a + b) / lengths.length;
+        return lengths.reduce((acc, len) => acc + (len - mean) ** 2, 0) / lengths.length;
+      }
+      
+      const edges = graph.edges();
+      const sphericalVariance = getEdgeVariance(sphericalPos, edges);
+      
+      // Spherical initialization should produce lower variance
+      assert.isBelow(sphericalVariance, 0.5, 'Spherical initialization should produce uniform edge lengths');
+    });
+  });
 });
 
 // Helper functions
@@ -348,4 +591,33 @@ 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 getBoundingBox3D(positions) {
+  const nodes = Object.keys(positions);
+  let minX = Infinity, maxX = -Infinity;
+  let minY = Infinity, maxY = -Infinity;
+  let minZ = Infinity, maxZ = -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]);
+    minZ = Math.min(minZ, positions[node][2]);
+    maxZ = Math.max(maxZ, positions[node][2]);
+  });
+  
+  return {
+    width: maxX - minX,
+    height: maxY - minY,
+    depth: maxZ - minZ
+  };
+}
+
+function getDistance3D(pos1, pos2) {
+  const dx = pos1[0] - pos2[0];
+  const dy = pos1[1] - pos2[1];
+  const dz = pos1[2] - pos2[2];
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
 }

package/test/multipartite-layout.test.ts

@@ -4,7 +4,7 @@ import {
   completeGraph,
   cycleGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Multipartite Layout', () => {
   describe('Basic functionality', () => {

package/test/planar-layout.test.ts

@@ -6,7 +6,7 @@ import {
   starGraph,
   gridGraph,
   wheelGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Planar Layout', () => {
   describe('Basic functionality', () => {

package/test/random-layout.test.ts

@@ -5,7 +5,7 @@ import {
   cycleGraph,
   starGraph,
   gridGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Random Layout', () => {
   describe('Basic functionality', () => {

package/test/rescale-layout.test.ts

@@ -6,7 +6,7 @@ import {
   randomLayout,
   completeGraph,
   starGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Rescale Layout', () => {
   describe('Dictionary format (rescaleLayout)', () => {

package/test/shell-layout.test.ts

@@ -7,7 +7,7 @@ import {
   wheelGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Shell Layout', () => {
   describe('Basic functionality', () => {

package/test/spectral-layout.test.ts

@@ -6,7 +6,7 @@ import {
   starGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Spectral Layout', () => {
   describe('Basic functionality', () => {

package/test/spiral-layout.test.ts

@@ -6,7 +6,7 @@ import {
   starGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Spiral Layout', () => {
   describe('Basic functionality', () => {

package/test/spring-layout.test.ts

@@ -5,7 +5,7 @@ import {
   cycleGraph,
   starGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Spring Layout', () => {
   describe('Basic functionality', () => {

package/vite.config.js

@@ -0,0 +1,36 @@
+import { defineConfig, loadEnv } from 'vite';
+
+export default defineConfig(({ mode }) => {
+  // Load env file based on `mode` in the current working directory.
+  // Set the third parameter to '' to load all env regardless of the `VITE_` prefix.
+  const env = loadEnv(mode, process.cwd(), '');
+  
+  const config = {
+    server: {
+      port: 3000,
+      open: '/examples/',
+      host: true,
+      fs: {
+        // Allow serving files from the dist directory
+        allow: ['..']
+      }
+    },
+    build: {
+      // Ensure the examples can find the built files
+      outDir: 'dist'
+    },
+    publicDir: false // Disable default public directory behavior
+  };
+
+  // Allow HOST configuration from .env
+  if (env.HOST) {
+    config.server.host = env.HOST;
+  }
+
+  // Allow PORT configuration from .env
+  if (env.PORT) {
+    config.server.port = parseInt(env.PORT);
+  }
+
+  return config;
+});

package/vitest.config.ts

@@ -8,8 +8,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: {