@graphty/layout 1.1.0 → 1.2.0

package/layout.ts

@@ -245,12 +245,12 @@ function randomLayout(G: Graph, center: number[] | null = null, dim: number = 2,
 }
 
 /**
- * Position nodes on a circle.
+ * Position nodes on a circle (2D) or sphere (3D).
  * 
  * @param G - Graph or list of nodes
  * @param scale - Scale factor for positions
  * @param center - Coordinate pair around which to center the layout
- * @param dim - Dimension of layout (currently only supports dim=2)
+ * @param dim - Dimension of layout (supports 2D circle or 3D sphere)
  * @returns Positions dictionary keyed by node
  */
 function circularLayout(G: Graph, scale: number = 1, center: number[] | null = null, dim: number = 2): PositionMap {
@@ -273,14 +273,41 @@ function circularLayout(G: Graph, scale: number = 1, center: number[] | null = n
     return pos;
   }
 
-  // Calculate positions on a circle
-  const theta = np.linspace(0, 2 * Math.PI, nodes.length + 1).slice(0, -1);
+  if (dim === 2) {
+    // 2D circle layout
+    const theta = np.linspace(0, 2 * Math.PI, nodes.length + 1).slice(0, -1);
 
-  nodes.forEach((node: Node, i: number) => {
-    const x: number = Math.cos(theta[i]) * scale + center[0];
-    const y: number = Math.sin(theta[i]) * scale + center[1];
-    pos[node] = Array(dim).fill(0).map((_, j: number) => j === 0 ? x : j === 1 ? y : 0);
-  });
+    nodes.forEach((node: Node, i: number) => {
+      const x: number = Math.cos(theta[i]) * scale + center[0];
+      const y: number = Math.sin(theta[i]) * scale + center[1];
+      pos[node] = [x, y];
+    });
+  } else if (dim === 3) {
+    // 3D sphere layout using Fibonacci spiral
+    const n = nodes.length;
+    const goldenRatio = (1 + Math.sqrt(5)) / 2;
+    
+    nodes.forEach((node: Node, i: number) => {
+      // Use Fibonacci spiral for even distribution on sphere
+      const theta = 2 * Math.PI * i / goldenRatio;
+      const phi = Math.acos(1 - 2 * (i + 0.5) / n);
+      
+      const x = Math.sin(phi) * Math.cos(theta) * scale + center[0];
+      const y = Math.sin(phi) * Math.sin(theta) * scale + center[1];
+      const z = Math.cos(phi) * scale + center[2];
+      
+      pos[node] = [x, y, z];
+    });
+  } else {
+    // For higher dimensions, fall back to random on hypersphere
+    const rng = new RandomNumberGenerator();
+    nodes.forEach((node: Node) => {
+      // Generate random point on unit hypersphere
+      const coords = Array(dim).fill(0).map(() => rng.rand() as number * 2 - 1);
+      const norm = Math.sqrt(coords.reduce((sum, c) => sum + c * c, 0));
+      pos[node] = coords.map((c, j) => c / norm * scale + center[j]);
+    });
+  }
 
   return pos;
 }
@@ -1615,10 +1642,9 @@ function kamadaKawaiLayout(
 
   // Initialize positions if not provided
   if (!pos) {
-    if (dim >= 3) {
-      pos = randomLayout(G, null, dim);
-    } else if (dim === 2) {
-      pos = circularLayout(G, 1, [0, 0], dim);
+    if (dim >= 2) {
+      // Use circular/spherical layout for 2D and 3D
+      pos = circularLayout(G, 1, center, dim);
     } else {
       // For 1D, use a linear layout
       const posArray: PositionMap = {};
@@ -2570,6 +2596,273 @@ function rescaleLayoutDict(
   return scaledPos;
 }
 
+// Graph generation utilities
+/**
+ * Create a complete graph with n nodes
+ * @param n - Number of nodes
+ * @returns Graph object with all nodes connected to all other nodes
+ */
+function completeGraph(n: number): Graph {
+  const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+  const edges: Edge[] = [];
+  
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      edges.push([i, j]);
+    }
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}
+
+/**
+ * Create a cycle graph with n nodes
+ * @param n - Number of nodes
+ * @returns Graph object with nodes connected in a cycle
+ */
+function cycleGraph(n: number): Graph {
+  const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+  const edges: Edge[] = [];
+  
+  for (let i = 0; i < n; i++) {
+    edges.push([i, (i + 1) % n]);
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}
+
+/**
+ * Create a star graph with n nodes (1 center + n-1 leaves)
+ * @param n - Total number of nodes
+ * @returns Graph object with star topology
+ */
+function starGraph(n: number): Graph {
+  const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+  const edges: Edge[] = [];
+  
+  // Connect all nodes to node 0 (center)
+  for (let i = 1; i < n; i++) {
+    edges.push([0, i]);
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}
+
+/**
+ * Create a wheel graph with n nodes (1 center + n-1 rim nodes)
+ * @param n - Total number of nodes
+ * @returns Graph object with wheel topology
+ */
+function wheelGraph(n: number): Graph {
+  const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+  const edges: Edge[] = [];
+  
+  // Connect all rim nodes to center (node 0)
+  for (let i = 1; i < n; i++) {
+    edges.push([0, i]);
+  }
+  
+  // Connect rim nodes in a cycle
+  for (let i = 1; i < n - 1; i++) {
+    edges.push([i, i + 1]);
+  }
+  if (n > 2) {
+    edges.push([n - 1, 1]);
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}
+
+/**
+ * Create a grid graph with rows x cols nodes
+ * @param rows - Number of rows
+ * @param cols - Number of columns
+ * @returns Graph object with grid topology
+ */
+function gridGraph(rows: number, cols: number): Graph {
+  const nodes: Node[] = [];
+  const edges: Edge[] = [];
+  
+  // Create nodes
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      nodes.push(`${i},${j}`);
+    }
+  }
+  
+  // Create edges
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      // Connect to right neighbor
+      if (j < cols - 1) {
+        edges.push([`${i},${j}`, `${i},${j + 1}`]);
+      }
+      // Connect to bottom neighbor
+      if (i < rows - 1) {
+        edges.push([`${i},${j}`, `${i + 1},${j}`]);
+      }
+    }
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}
+
+/**
+ * Create a random graph with n nodes and given edge probability
+ * @param n - Number of nodes
+ * @param p - Probability of edge between any two nodes (0-1)
+ * @param seed - Random seed for reproducibility
+ * @returns Graph object with random edges
+ */
+function randomGraph(n: number, p: number, seed?: number): Graph {
+  const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+  const edges: Edge[] = [];
+  
+  // Simple deterministic pseudo-random if seed provided
+  let currentSeed = seed;
+  let random = seed !== undefined 
+    ? () => {
+        currentSeed = (currentSeed! * 9301 + 49297) % 233280;
+        return currentSeed / 233280;
+      }
+    : Math.random;
+  
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      if (random() < p) {
+        edges.push([i, j]);
+      }
+    }
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}
+
+/**
+ * Create a bipartite graph with two sets of nodes
+ * @param n1 - Number of nodes in first set
+ * @param n2 - Number of nodes in second set
+ * @param p - Probability of edge between nodes in different sets
+ * @param seed - Random seed for reproducibility
+ * @returns Graph object with bipartite structure and setA/setB properties
+ */
+function bipartiteGraph(n1: number, n2: number, p: number, seed?: number): Graph & { setA: Node[], setB: Node[] } {
+  const setA: Node[] = Array.from({ length: n1 }, (_, i) => `A${i}`);
+  const setB: Node[] = Array.from({ length: n2 }, (_, i) => `B${i}`);
+  const nodes = [...setA, ...setB];
+  const edges: Edge[] = [];
+  
+  // Simple deterministic pseudo-random if seed provided
+  let currentSeed = seed;
+  let random = seed !== undefined 
+    ? () => {
+        currentSeed = (currentSeed! * 9301 + 49297) % 233280;
+        return currentSeed / 233280;
+      }
+    : Math.random;
+  
+  // Only connect nodes between sets
+  for (const a of setA) {
+    for (const b of setB) {
+      if (random() < p) {
+        edges.push([a, b]);
+      }
+    }
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges,
+    setA,
+    setB
+  };
+}
+
+/**
+ * Create a scale-free graph using Barabási-Albert model
+ * @param n - Total number of nodes
+ * @param m - Number of edges to attach from new node
+ * @param seed - Random seed for reproducibility
+ * @returns Graph object with scale-free properties
+ */
+function scaleFreeGraph(n: number, m: number, seed?: number): Graph {
+  if (m >= n) {
+    throw new Error('m must be less than n');
+  }
+  
+  const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+  const edges: Edge[] = [];
+  const degrees = new Array(n).fill(0);
+  
+  // Simple deterministic pseudo-random if seed provided
+  let currentSeed = seed;
+  let random = seed !== undefined 
+    ? () => {
+        currentSeed = (currentSeed! * 9301 + 49297) % 233280;
+        return currentSeed / 233280;
+      }
+    : Math.random;
+  
+  // Start with complete graph of m+1 nodes
+  for (let i = 0; i <= m; i++) {
+    for (let j = i + 1; j <= m; j++) {
+      edges.push([i, j]);
+      degrees[i]++;
+      degrees[j]++;
+    }
+  }
+  
+  // Add remaining nodes
+  for (let i = m + 1; i < n; i++) {
+    const targets = new Set<number>();
+    const totalDegree = degrees.reduce((sum, d) => sum + d, 0);
+    
+    // Choose m targets based on preferential attachment
+    while (targets.size < m) {
+      let r = random() * totalDegree;
+      let cumSum = 0;
+      
+      for (let j = 0; j < i; j++) {
+        cumSum += degrees[j];
+        if (r <= cumSum && !targets.has(j)) {
+          targets.add(j);
+          break;
+        }
+      }
+    }
+    
+    // Add edges to targets
+    for (const target of targets) {
+      edges.push([i, target]);
+      degrees[i]++;
+      degrees[target]++;
+    }
+  }
+  
+  return {
+    nodes: () => nodes,
+    edges: () => edges
+  };
+}
+
 // Export the layout functions
 export {
   randomLayout,
@@ -2587,5 +2880,14 @@ export {
   forceatlas2Layout,
   arfLayout,
   rescaleLayout,
-  rescaleLayoutDict
+  rescaleLayoutDict,
+  // Graph generation utilities
+  completeGraph,
+  cycleGraph,
+  starGraph,
+  wheelGraph,
+  gridGraph,
+  randomGraph,
+  bipartiteGraph,
+  scaleFreeGraph
 };

package/package.json

@@ -1,18 +1,25 @@
 {
   "name": "@graphty/layout",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "graph layout algorithms based on networkx",
-  "main": "layout.js",
+  "main": "dist/layout.js",
   "type": "module",
   "directories": {
     "example": "examples"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage",
     "prepare": "husky",
     "build": "tsc",
+    "build:examples": "npm run build && cp dist/layout.js examples/layout.js",
     "watch": "tsc --watch",
-    "dev": "tsc --watch"
+    "dev": "tsc --watch",
+    "commit": "cz",
+    "serve": "npm run build:examples && vite",
+    "examples": "npm run build:examples && vite"
   },
   "repository": {
     "type": "git",
@@ -37,8 +44,15 @@
   "devDependencies": {
     "@commitlint/cli": "^19.8.1",
     "@commitlint/config-conventional": "^19.8.1",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
     "cz-conventional-changelog": "^3.3.0",
+    "happy-dom": "^18.0.1",
     "husky": "^9.1.7",
-    "typescript": "^5.3.3"
+    "semantic-release": "^24.2.7",
+    "typescript": "^5.3.3",
+    "vitest": "^3.2.4"
   }
-}
+}