@graphty/layout 1.2.8 → 1.3.2

package/src/algorithms/planarity/special-graphs.ts

@@ -2,125 +2,115 @@
  * Special graph detection functions for planarity testing
  */
 
-import { Node, Edge } from '../../types';
+import { Edge,Node } from "../../types";
 
 /**
  * Check if graph is K5 (complete graph with 5 nodes)
- * 
  * @param nodes - List of nodes
  * @param edges - List of edges
  * @returns True if graph is K5
  */
 export function isK5(nodes: Node[], edges: Edge[]): boolean {
-  if (nodes.length !== 5) return false;
-
-  // K5 has exactly 10 edges
-  if (edges.length !== 10) return false;
-
-  // Check if every pair of distinct nodes is connected
-  for (let i = 0; i < nodes.length; i++) {
-    for (let j = i + 1; j < nodes.length; j++) {
-      const hasEdge = edges.some(
-        e => (e[0] === nodes[i] && e[1] === nodes[j]) ||
-          (e[0] === nodes[j] && e[1] === nodes[i])
-      );
-      if (!hasEdge) return false;
+    if (nodes.length !== 5) {return false;}
+
+    // K5 has exactly 10 edges
+    if (edges.length !== 10) {return false;}
+
+    // Check if every pair of distinct nodes is connected
+    for (let i = 0; i < nodes.length; i++) {
+        for (let j = i + 1; j < nodes.length; j++) {
+            const hasEdge = edges.some(
+                (e) => (e[0] === nodes[i] && e[1] === nodes[j]) || (e[0] === nodes[j] && e[1] === nodes[i]),
+            );
+            if (!hasEdge) {return false;}
+        }
     }
-  }
 
-  return true;
+    return true;
 }
 
 /**
  * Check if graph is K3,3 (complete bipartite with 3,3 nodes)
- * 
  * @param nodes - List of nodes
  * @param edges - List of edges
  * @returns True if graph is K3,3
  */
 export function isK33(nodes: Node[], edges: Edge[]): boolean {
-  if (nodes.length !== 6) return false;
+    if (nodes.length !== 6) {return false;}
 
-  // K3,3 has exactly 9 edges
-  if (edges.length !== 9) return false;
+    // K3,3 has exactly 9 edges
+    if (edges.length !== 9) {return false;}
 
-  // Try to find a bipartite partition
-  const nodePartitions = tryFindBipartitePartition(nodes, edges);
-  if (!nodePartitions) return false;
+    // Try to find a bipartite partition
+    const nodePartitions = tryFindBipartitePartition(nodes, edges);
+    if (!nodePartitions) {return false;}
 
-  const [part1, part2] = nodePartitions;
+    const [part1, part2] = nodePartitions;
 
-  // Check if both partitions have size 3
-  if (part1.length !== 3 || part2.length !== 3) return false;
+    // Check if both partitions have size 3
+    if (part1.length !== 3 || part2.length !== 3) {return false;}
 
-  // Check if every node in part1 is connected to every node in part2
-  for (const n1 of part1) {
-    for (const n2 of part2) {
-      const hasEdge = edges.some(
-        e => (e[0] === n1 && e[1] === n2) ||
-          (e[0] === n2 && e[1] === n1)
-      );
-      if (!hasEdge) return false;
+    // Check if every node in part1 is connected to every node in part2
+    for (const n1 of part1) {
+        for (const n2 of part2) {
+            const hasEdge = edges.some((e) => (e[0] === n1 && e[1] === n2) || (e[0] === n2 && e[1] === n1));
+            if (!hasEdge) {return false;}
+        }
     }
-  }
 
-  return true;
+    return true;
 }
 
 /**
  * Try to find a bipartite partition of the nodes
- * 
  * @param nodes - List of nodes
  * @param edges - List of edges
  * @returns Array of two partitions, or null if not bipartite
  */
-export function tryFindBipartitePartition(
-  nodes: Node[],
-  edges: Edge[]
-): [Node[], Node[]] | null {
-  const colorMap: Record<Node, number> = {};
-  const adjList: Record<Node, Node[]> = {};
-
-  // Create adjacency list
-  for (const node of nodes) {
-    adjList[node] = [];
-  }
-
-  for (const [u, v] of edges) {
-    adjList[u].push(v);
-    adjList[v].push(u);
-  }
-
-  // BFS to color nodes
-  const queue: Node[] = [nodes[0]];
-  colorMap[nodes[0]] = 0;
-
-  while (queue.length > 0) {
-    const node = queue.shift()!;
-    const nodeColor = colorMap[node];
-
-    for (const neighbor of adjList[node]) {
-      if (colorMap[neighbor] === undefined) {
-        colorMap[neighbor] = 1 - nodeColor; // Toggle color (0/1)
-        queue.push(neighbor);
-      } else if (colorMap[neighbor] === nodeColor) {
-        // Conflict: not bipartite
-        return null;
-      }
+export function tryFindBipartitePartition(nodes: Node[], edges: Edge[]): [Node[], Node[]] | null {
+    const colorMap: Record<Node, number> = {};
+    const adjList: Record<Node, Node[]> = {};
+
+    // Create adjacency list
+    for (const node of nodes) {
+        adjList[node] = [];
+    }
+
+    for (const [u, v] of edges) {
+        adjList[u].push(v);
+        adjList[v].push(u);
     }
-  }
 
-  // Create partitions
-  const part0: Node[] = [];
-  const part1: Node[] = [];
+    // BFS to color nodes
+    const queue: Node[] = [nodes[0]];
+    colorMap[nodes[0]] = 0;
+
+    while (queue.length > 0) {
+        const node = queue.shift()!;
+        const nodeColor = colorMap[node];
+
+        for (const neighbor of adjList[node]) {
+            if (colorMap[neighbor] === undefined) {
+                colorMap[neighbor] = 1 - nodeColor; // Toggle color (0/1)
+                queue.push(neighbor);
+            } else if (colorMap[neighbor] === nodeColor) {
+                // Conflict: not bipartite
+                return null;
+            }
+        }
+    }
+
+    // Create partitions
+    const part0: Node[] = [];
+    const part1: Node[] = [];
 
-  for (const node of nodes) {
-    if (colorMap[node] === 0) {
-      part0.push(node);
-    } else {
-      part1.push(node);
+    for (const node of nodes) {
+        if (colorMap[node] === 0) {
+            part0.push(node);
+        } else {
+            part1.push(node);
+        }
     }
-  }
 
-  return [part0, part1];
-}
+    return [part0, part1];
+}

package/src/generators/basic.ts

@@ -2,7 +2,7 @@
  * Basic graph generation functions
  */
 
-import { Graph, Node, Edge } from '../types';
+import { Edge,Graph, Node } from "../types";
 
 /**
  * Create a complete graph with n nodes
@@ -10,19 +10,19 @@ import { Graph, Node, Edge } from '../types';
  * @returns Graph object with all nodes connected to all other nodes
  */
 export 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]);
+    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
-  };
+
+    return {
+        nodes: () => nodes,
+        edges: () => edges,
+    };
 }
 
 /**
@@ -31,17 +31,17 @@ export function completeGraph(n: number): Graph {
  * @returns Graph object with nodes connected in a cycle
  */
 export 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
-  };
+    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,
+    };
 }
 
 /**
@@ -50,18 +50,18 @@ export function cycleGraph(n: number): Graph {
  * @returns Graph object with star topology
  */
 export 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
-  };
+    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,
+    };
 }
 
 /**
@@ -70,24 +70,24 @@ export function starGraph(n: number): Graph {
  * @returns Graph object with wheel topology
  */
 export 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
-  };
-}
+    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,
+    };
+}

package/src/generators/bipartite.ts

@@ -2,7 +2,7 @@
  * Bipartite graph generation function
  */
 
-import { Graph, Node, Edge } from '../types';
+import { Edge,Graph, Node } from "../types";
 
 /**
  * Create a bipartite graph with two sets of nodes
@@ -12,34 +12,40 @@ import { Graph, Node, Edge } from '../types';
  * @param seed - Random seed for reproducibility
  * @returns Graph object with bipartite structure and setA/setB properties
  */
-export 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]);
-      }
+export 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;
+    const 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
-  };
-}
+
+    return {
+        nodes: () => nodes,
+        edges: () => edges,
+        setA,
+        setB,
+    };
+}

package/src/generators/grid.ts

@@ -2,7 +2,7 @@
  * Grid graph generation function
  */
 
-import { Graph, Node, Edge } from '../types';
+import { Edge,Graph, Node } from "../types";
 
 /**
  * Create a grid graph with rows x cols nodes
@@ -11,32 +11,32 @@ import { Graph, Node, Edge } from '../types';
  * @returns Graph object with grid topology
  */
 export 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}`);
+    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}`]);
-      }
+
+    // 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
-  };
-}
+
+    return {
+        nodes: () => nodes,
+        edges: () => edges,
+    };
+}

package/src/generators/index.ts

@@ -2,14 +2,8 @@
  * Re-export all graph generation functions
  */
 
-export { 
-  completeGraph, 
-  cycleGraph, 
-  starGraph, 
-  wheelGraph 
-} from './basic';
-
-export { gridGraph } from './grid';
-export { randomGraph } from './random';
-export { bipartiteGraph } from './bipartite';
-export { scaleFreeGraph } from './scale-free';
+export { completeGraph, cycleGraph, starGraph, wheelGraph } from "./basic";
+export { bipartiteGraph } from "./bipartite";
+export { gridGraph } from "./grid";
+export { randomGraph } from "./random";
+export { scaleFreeGraph } from "./scale-free";

package/src/generators/random.ts

@@ -2,7 +2,7 @@
  * Random graph generation function
  */
 
-import { Graph, Node, Edge } from '../types';
+import { Edge,Graph, Node } from "../types";
 
 /**
  * Create a random graph with n nodes and given edge probability
@@ -12,28 +12,29 @@ import { Graph, Node, Edge } from '../types';
  * @returns Graph object with random edges
  */
 export 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]);
-      }
+    const nodes: Node[] = Array.from({ length: n }, (_, i) => i);
+    const edges: Edge[] = [];
+
+    // Simple deterministic pseudo-random if seed provided
+    let currentSeed = seed;
+    const 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
-  };
-}
+
+    return {
+        nodes: () => nodes,
+        edges: () => edges,
+    };
+}