@graphty/layout 1.2.8 → 1.3.2

package/src/layouts/geometric/circular.ts

@@ -2,76 +2,82 @@
  * Circular layout algorithm
  */
 
-import { Graph, Node, PositionMap } from '../../types';
-import { _processParams } from '../../utils/params';
-import { getNodesFromGraph } from '../../utils/graph';
-import { RandomNumberGenerator } from '../../utils/random';
-import { np } from '../../utils/numpy';
+import { Graph, Node, PositionMap } from "../../types";
+import { getNodesFromGraph } from "../../utils/graph";
+import { np } from "../../utils/numpy";
+import { _processParams } from "../../utils/params";
+import { RandomNumberGenerator } from "../../utils/random";
 
 /**
  * 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 (supports 2D circle or 3D sphere)
  * @returns Positions dictionary keyed by node
  */
-export function circularLayout(G: Graph, scale: number = 1, center: number[] | null = null, dim: number = 2): PositionMap {
-  if (dim < 2) {
-    throw new Error("cannot handle dimensions < 2");
-  }
+export function circularLayout(
+    G: Graph,
+    scale: number = 1,
+    center: number[] | null = null,
+    dim: number = 2,
+): PositionMap {
+    if (dim < 2) {
+        throw new Error("cannot handle dimensions < 2");
+    }
 
-  const processed = _processParams(G, center, dim);
-  const nodes = getNodesFromGraph(processed.G);
-  center = processed.center;
+    const processed = _processParams(G, center, dim);
+    const nodes = getNodesFromGraph(processed.G);
+    center = processed.center;
 
-  const pos: PositionMap = {};
+    const pos: PositionMap = {};
 
-  if (nodes.length === 0) {
-    return pos;
-  }
+    if (nodes.length === 0) {
+        return pos;
+    }
 
-  if (nodes.length === 1) {
-    pos[nodes[0]] = center;
-    return pos;
-  }
+    if (nodes.length === 1) {
+        pos[nodes[0]] = center;
+        return pos;
+    }
+
+    if (dim === 2) {
+        // 2D circle layout
+        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] = [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) => {
-      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]);
-    });
-  }
+        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);
 
-  return pos;
-}
+            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;
+}

package/src/layouts/geometric/index.ts

@@ -2,6 +2,6 @@
  * Geometric layout algorithms
  */
 
-export { circularLayout } from './circular';
-export { shellLayout } from './shell';
-export { spiralLayout } from './spiral';
+export { circularLayout } from "./circular";
+export { shellLayout } from "./shell";
+export { spiralLayout } from "./spiral";

package/src/layouts/geometric/shell.ts

@@ -2,14 +2,13 @@
  * Shell layout algorithm
  */
 
-import { Graph, Node, PositionMap } from '../../types';
-import { _processParams } from '../../utils/params';
-import { getNodesFromGraph } from '../../utils/graph';
-import { np } from '../../utils/numpy';
+import { Graph, Node, PositionMap } from "../../types";
+import { getNodesFromGraph } from "../../utils/graph";
+import { np } from "../../utils/numpy";
+import { _processParams } from "../../utils/params";
 
 /**
  * Position nodes in concentric circles.
- * 
  * @param G - Graph or list of nodes
  * @param nlist - List of node lists for each shell
  * @param scale - Scale factor for positions
@@ -17,64 +16,70 @@ import { np } from '../../utils/numpy';
  * @param dim - Dimension of layout (currently only supports dim=2)
  * @returns Positions dictionary keyed by node
  */
-export function shellLayout(G: Graph, nlist: Node[][] | null = null, scale: number = 1, center: number[] | null = null, dim: number = 2): PositionMap {
-  if (dim !== 2) {
-    throw new Error("can only handle 2 dimensions");
-  }
+export function shellLayout(
+    G: Graph,
+    nlist: Node[][] | null = null,
+    scale: number = 1,
+    center: number[] | null = null,
+    dim: number = 2,
+): PositionMap {
+    if (dim !== 2) {
+        throw new Error("can only handle 2 dimensions");
+    }
 
-  const processed = _processParams(G, center, dim);
-  const nodes = getNodesFromGraph(processed.G);
-  center = processed.center;
+    const processed = _processParams(G, center, dim);
+    const nodes = getNodesFromGraph(processed.G);
+    center = processed.center;
 
-  const pos: PositionMap = {};
+    const pos: PositionMap = {};
 
-  if (nodes.length === 0) {
-    return pos;
-  }
+    if (nodes.length === 0) {
+        return pos;
+    }
 
-  if (nodes.length === 1) {
-    pos[nodes[0]] = center;
-    return pos;
-  }
+    if (nodes.length === 1) {
+        pos[nodes[0]] = center;
+        return pos;
+    }
 
-  // If no nlist is specified, put all nodes in a single shell
-  if (!nlist) {
-    nlist = [nodes];
-  }
+    // If no nlist is specified, put all nodes in a single shell
+    if (!nlist) {
+        nlist = [nodes];
+    }
 
-  const radiusBump = scale / nlist.length;
-  let radius: number;
+    const radiusBump = scale / nlist.length;
+    let radius: number;
 
-  if (nlist[0].length === 1) {
-    // Single node at center
-    radius = 0;
-    pos[nlist[0][0]] = [...center];
-    radius += radiusBump;
-  } else {
-    // Start at radius 1
-    radius = radiusBump;
-  }
+    if (nlist[0].length === 1) {
+        // Single node at center
+        radius = 0;
+        pos[nlist[0][0]] = [...center];
+        radius += radiusBump;
+    } else {
+        // Start at radius 1
+        radius = radiusBump;
+    }
 
-  for (let i = 0; i < nlist.length; i++) {
-    const shell = nlist[i];
-    if (shell.length === 0) continue;
+    for (let i = 0; i < nlist.length; i++) {
+        const shell = nlist[i];
+        if (shell.length === 0) {continue;}
 
-    if (shell.length === 1 && i === 0) {
-      // Already handled the case of a single center node
-      continue;
-    }
+        if (shell.length === 1 && i === 0) {
+            // Already handled the case of a single center node
+            continue;
+        }
 
-    // Calculate positions on a circle
-    const theta = np.linspace(0, 2 * Math.PI, shell.length + 1).slice(0, -1);
+        // Calculate positions on a circle
+        const theta = np.linspace(0, 2 * Math.PI, shell.length + 1).slice(0, -1);
 
-    shell.forEach((node: Node, j) => {
-      const x = Math.cos(theta[j]) * radius + center[0];
-      const y = Math.sin(theta[j]) * radius + center[1];
-      pos[node] = [x, y];
-    });
+        shell.forEach((node: Node, j) => {
+            const x = Math.cos(theta[j]) * radius + center[0];
+            const y = Math.sin(theta[j]) * radius + center[1];
+            pos[node] = [x, y];
+        });
 
-    radius += radiusBump;
-  }
+        radius += radiusBump;
+    }
 
-  return pos;
-}
+    return pos;
+}

package/src/layouts/geometric/spiral.ts

@@ -2,14 +2,13 @@
  * Spiral layout algorithm
  */
 
-import { Graph, Node, PositionMap } from '../../types';
-import { _processParams } from '../../utils/params';
-import { getNodesFromGraph } from '../../utils/graph';
-import { rescaleLayout } from '../../utils/rescale';
+import { Graph, Node, PositionMap } from "../../types";
+import { getNodesFromGraph } from "../../utils/graph";
+import { _processParams } from "../../utils/params";
+import { rescaleLayout } from "../../utils/rescale";
 
 /**
  * Position nodes in a spiral layout.
- * 
  * @param G - Graph or list of nodes
  * @param scale - Scale factor for positions
  * @param center - Coordinate pair around which to center the layout
@@ -19,75 +18,72 @@ import { rescaleLayout } from '../../utils/rescale';
  * @returns Positions dictionary keyed by node
  */
 export function spiralLayout(
-  G: Graph,
-  scale: number = 1,
-  center: number[] | null = null,
-  dim: number = 2,
-  resolution: number = 0.35,
-  equidistant: boolean = false
+    G: Graph,
+    scale: number = 1,
+    center: number[] | null = null,
+    dim: number = 2,
+    resolution: number = 0.35,
+    equidistant: boolean = false,
 ): PositionMap {
-  if (dim !== 2) {
-    throw new Error("can only handle 2 dimensions");
-  }
+    if (dim !== 2) {
+        throw new Error("can only handle 2 dimensions");
+    }
 
-  const processed = _processParams(G, center || [0, 0], dim);
-  const nodes = getNodesFromGraph(processed.G);
-  center = processed.center;
+    const processed = _processParams(G, center || [0, 0], dim);
+    const nodes = getNodesFromGraph(processed.G);
+    center = processed.center;
 
-  const pos: PositionMap = {};
+    const pos: PositionMap = {};
 
-  if (nodes.length === 0) {
-    return pos;
-  }
+    if (nodes.length === 0) {
+        return pos;
+    }
 
-  if (nodes.length === 1) {
-    pos[nodes[0]] = [...center];
-    return pos;
-  }
+    if (nodes.length === 1) {
+        pos[nodes[0]] = [...center];
+        return pos;
+    }
 
-  let positions: number[][] = [];
+    let positions: number[][] = [];
 
-  if (equidistant) {
-    // Create equidistant points along the spiral
-    // This matches the Python implementation logic
-    const chord = 1;
-    const step = 0.5;
-    let theta = resolution;
-    theta += chord / (step * theta);
+    if (equidistant) {
+        // Create equidistant points along the spiral
+        // This matches the Python implementation logic
+        const chord = 1;
+        const step = 0.5;
+        let theta = resolution;
+        theta += chord / (step * theta);
 
-    for (let i = 0; i < nodes.length; i++) {
-      const r = step * theta;
-      theta += chord / r;
-      positions.push([Math.cos(theta) * r, Math.sin(theta) * r]);
-    }
-  } else {
-    // Create points with equal angle but increasing distance
-    const dist = Array.from({ length: nodes.length }, (_, i) => parseFloat(String(i)));
-    const angle = dist.map(d => resolution * d);
+        for (let i = 0; i < nodes.length; i++) {
+            const r = step * theta;
+            theta += chord / r;
+            positions.push([Math.cos(theta) * r, Math.sin(theta) * r]);
+        }
+    } else {
+        // Create points with equal angle but increasing distance
+        const dist = Array.from({ length: nodes.length }, (_, i) => parseFloat(String(i)));
+        const angle = dist.map((d) => resolution * d);
 
-    positions = dist.map((d, i) => [
-      Math.cos(angle[i]) * d,
-      Math.sin(angle[i]) * d
-    ]);
-  }
+        positions = dist.map((d, i) => [Math.cos(angle[i]) * d, Math.sin(angle[i]) * d]);
+    }
 
-  // Convert position array to position matrix for rescaling
-  const posArray: number[][] = [];
-  for (let i = 0; i < positions.length; i++) {
-    posArray.push(positions[i]);
-  }
+    // Convert position array to position matrix for rescaling
+    const posArray: number[][] = [];
+    for (let i = 0; i < positions.length; i++) {
+        posArray.push(positions[i]);
+    }
 
-  // Rescale positions and add center offset
-  const scaledPositions = rescaleLayout(posArray as any, scale) as any;
-  for (let i = 0; i < scaledPositions.length; i++) {
-    scaledPositions[i][0] += center[0];
-    scaledPositions[i][1] += center[1];
-  }
+    // Rescale positions and add center offset
+    const scaledPositions = rescaleLayout(posArray as any, scale) as any;
+    for (let i = 0; i < scaledPositions.length; i++) {
+        scaledPositions[i][0] += center[0];
+        scaledPositions[i][1] += center[1];
+    }
 
-  // Create position dictionary
-  for (let i = 0; i < nodes.length; i++) {
-    pos[nodes[i]] = scaledPositions[i];
-  }
+    // Create position dictionary
+    for (let i = 0; i < nodes.length; i++) {
+        pos[nodes[i]] = scaledPositions[i];
+    }
 
-  return pos;
-}
+    return pos;
+}

package/src/layouts/hierarchical/bfs.ts

@@ -1,12 +1,11 @@
-import type { Graph, Node, Edge, PositionMap } from '../../types';
-import { getNodesFromGraph, getNeighbors } from '../../utils/graph';
-import { _processParams } from '../../utils/params';
-import { multipartiteLayout } from './multipartite';
+import type { Edge, Graph, Node, PositionMap } from "../../types";
+import { getNeighbors,getNodesFromGraph } from "../../utils/graph";
+import { _processParams } from "../../utils/params";
+import { multipartiteLayout } from "./multipartite";
 
 /**
  * Position nodes according to breadth-first search algorithm.
- * 
- * @param G - Graph 
+ * @param G - Graph
  * @param start - Starting node for bfs
  * @param align - The alignment of layers: 'vertical' or 'horizontal'
  * @param scale - Scale factor for positions
@@ -14,68 +13,68 @@ import { multipartiteLayout } from './multipartite';
  * @returns Positions dictionary keyed by node
  */
 export function bfsLayout(
-  G: Graph,
-  start: Node,
-  align: 'vertical' | 'horizontal' = 'vertical',
-  scale: number = 1,
-  center: number[] | null = null
+    G: Graph,
+    start: Node,
+    align: "vertical" | "horizontal" = "vertical",
+    scale: number = 1,
+    center: number[] | null = null,
 ): PositionMap {
-  const processed = _processParams(G, center || [0, 0], 2);
-  
-  // BFS layout requires a proper Graph, not just a list of nodes
-  if (Array.isArray(processed.G)) {
-    throw new Error('BFS layout requires a Graph with edges, not just a list of nodes');
-  }
-  
-  const graph = processed.G;
-  center = processed.center;
+    const processed = _processParams(G, center || [0, 0], 2);
 
-  const allNodes = getNodesFromGraph(graph);
+    // BFS layout requires a proper Graph, not just a list of nodes
+    if (Array.isArray(processed.G)) {
+        throw new Error("BFS layout requires a Graph with edges, not just a list of nodes");
+    }
+
+    const graph = processed.G;
+    center = processed.center;
+
+    const allNodes = getNodesFromGraph(graph);
+
+    if (allNodes.length === 0) {
+        return {};
+    }
 
-  if (allNodes.length === 0) {
-    return {};
-  }
+    // Compute BFS layers
+    const layers: Record<number, Node[]> = {};
+    const visited = new Set<Node>();
+    let currentLayer = 0;
 
-  // Compute BFS layers
-  const layers: Record<number, Node[]> = {};
-  const visited = new Set<Node>();
-  let currentLayer = 0;
+    // Starting layer
+    layers[currentLayer] = [start];
+    visited.add(start);
 
-  // Starting layer
-  layers[currentLayer] = [start];
-  visited.add(start);
+    // BFS traversal
+    while (Object.values(layers).flat().length < allNodes.length) {
+        const nextLayer: Node[] = [];
+        const currentNodes = layers[currentLayer];
 
-  // BFS traversal
-  while (Object.values(layers).flat().length < allNodes.length) {
-    const nextLayer: Node[] = [];
-    const currentNodes = layers[currentLayer];
+        for (const node of currentNodes) {
+            // Get neighbors - this is a simplified approach
+            // In a real implementation, we would get neighbors from the graph
+            const neighbors = getNeighbors(graph, node);
 
-    for (const node of currentNodes) {
-      // Get neighbors - this is a simplified approach
-      // In a real implementation, we would get neighbors from the graph
-      const neighbors = getNeighbors(graph, node);
+            for (const neighbor of neighbors) {
+                if (!visited.has(neighbor)) {
+                    nextLayer.push(neighbor);
+                    visited.add(neighbor);
+                }
+            }
+        }
 
-      for (const neighbor of neighbors) {
-        if (!visited.has(neighbor)) {
-          nextLayer.push(neighbor);
-          visited.add(neighbor);
+        if (nextLayer.length === 0) {
+            // No more connected nodes
+            const unvisited: Node[] = allNodes.filter((node: Node) => !visited.has(node));
+            if (unvisited.length > 0) {
+                throw new Error("bfs_layout didn't include all nodes. Graph may be disconnected.");
+            }
+            break;
         }
-      }
-    }
 
-    if (nextLayer.length === 0) {
-      // No more connected nodes
-      const unvisited: Node[] = allNodes.filter((node: Node) => !visited.has(node));
-      if (unvisited.length > 0) {
-        throw new Error("bfs_layout didn't include all nodes. Graph may be disconnected.");
-      }
-      break;
+        currentLayer++;
+        layers[currentLayer] = nextLayer;
     }
 
-    currentLayer++;
-    layers[currentLayer] = nextLayer;
-  }
-
-  // Use multipartite_layout to position the layers
-  return multipartiteLayout(graph, layers, align, scale, center);
-}
+    // Use multipartite_layout to position the layers
+    return multipartiteLayout(graph, layers, align, scale, center);
+}