@graphty/layout 1.2.8 → 1.3.2

package/src/generators/scale-free.ts

@@ -2,7 +2,7 @@
  * Scale-free graph generation function
  */
 
-import { Graph, Node, Edge } from '../types';
+import { Edge,Graph, Node } from "../types";
 
 /**
  * Create a scale-free graph using Barabási-Albert model
@@ -12,61 +12,62 @@ import { Graph, Node, Edge } from '../types';
  * @returns Graph object with scale-free properties
  */
 export 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]++;
+    if (m >= n) {
+        throw new Error("m must be less than n");
     }
-  }
-  
-  // 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;
+
+    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;
+    const 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 edges to targets
-    for (const target of targets) {
-      edges.push([i, target]);
-      degrees[i]++;
-      degrees[target]++;
+
+    // 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) {
+            const 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
-  };
-}
+
+    return {
+        nodes: () => nodes,
+        edges: () => edges,
+    };
+}

package/src/index.ts

@@ -1,18 +1,18 @@
 /**
  * Main entry point for @graphty/layout
- * 
+ *
  * This file exports the complete public API, maintaining
  * compatibility with the original layout.ts file.
  */
 
 // Re-export all types
-export * from './types';
+export * from "./types";
 
 // Re-export utilities that are part of the public API
-export { rescaleLayout, rescaleLayoutDict } from './utils/rescale';
+export { rescaleLayout, rescaleLayoutDict } from "./utils/rescale";
 
 // Re-export all layout algorithms
-export * from './layouts';
+export * from "./layouts";
 
 // Re-export all graph generation functions
-export * from './generators';
+export * from "./generators";

package/src/layouts/basic/index.ts

@@ -2,4 +2,4 @@
  * Basic layout algorithms
  */
 
-export { randomLayout } from './random';
+export { randomLayout } from "./random";

package/src/layouts/basic/random.ts

@@ -2,31 +2,35 @@
  * Random layout algorithm
  */
 
-import { Graph, Node, PositionMap } from '../../types';
-import { _processParams } from '../../utils/params';
-import { getNodesFromGraph } from '../../utils/graph';
-import { RandomNumberGenerator } from '../../utils/random';
+import { Graph, Node, PositionMap } from "../../types";
+import { getNodesFromGraph } from "../../utils/graph";
+import { _processParams } from "../../utils/params";
+import { RandomNumberGenerator } from "../../utils/random";
 
 /**
  * Position nodes uniformly at random in the unit square.
- * 
  * @param G - Graph or list of nodes
  * @param center - Coordinate pair around which to center the layout
  * @param dim - Dimension of layout
  * @param seed - Random seed for reproducible layouts
  * @returns Positions dictionary keyed by node
  */
-export function randomLayout(G: Graph | Node[], center: number[] | null = null, dim: number = 2, seed: number | null = null): PositionMap {
-  const processed = _processParams(G, center, dim);
-  const nodes = getNodesFromGraph(processed.G);
-  center = processed.center;
+export function randomLayout(
+    G: Graph | Node[],
+    center: number[] | null = null,
+    dim: number = 2,
+    seed: number | null = null,
+): PositionMap {
+    const processed = _processParams(G, center, dim);
+    const nodes = getNodesFromGraph(processed.G);
+    center = processed.center;
 
-  const rng = new RandomNumberGenerator(seed ?? undefined);
-  const pos: PositionMap = {};
+    const rng = new RandomNumberGenerator(seed ?? undefined);
+    const pos: PositionMap = {};
 
-  nodes.forEach((node: Node) => {
-    pos[node] = (rng.rand(dim) as number[]).map((val: number, i: number) => val + center[i]);
-  });
+    nodes.forEach((node: Node) => {
+        pos[node] = (rng.rand(dim) as number[]).map((val: number, i: number) => val + center[i]);
+    });
 
-  return pos;
-}
+    return pos;
+}

package/src/layouts/force-directed/arf.ts

@@ -1,11 +1,10 @@
-import type { Graph, Node, PositionMap } from '../../types';
-import { getNodesFromGraph, getEdgesFromGraph } from '../../utils/graph';
-import { RandomNumberGenerator } from '../../utils/random';
-import { randomLayout } from '../basic/random';
+import type { Graph, Node, PositionMap } from "../../types";
+import { getEdgesFromGraph,getNodesFromGraph } from "../../utils/graph";
+import { RandomNumberGenerator } from "../../utils/random";
+import { randomLayout } from "../basic/random";
 
 /**
  * Layout algorithm with attractive and repulsive forces (ARF).
- * 
  * @param G - Graph
  * @param pos - Initial positions for nodes
  * @param scaling - Scale factor for positions
@@ -15,116 +14,119 @@ import { randomLayout } from '../basic/random';
  * @returns Positions dictionary keyed by node
  */
 export function arfLayout(
-  G: Graph,
-  pos: PositionMap | null = null,
-  scaling: number = 1,
-  a: number = 1.1,
-  maxIter: number = 1000,
-  seed: number | null = null
+    G: Graph,
+    pos: PositionMap | null = null,
+    scaling: number = 1,
+    a: number = 1.1,
+    maxIter: number = 1000,
+    seed: number | null = null,
 ): PositionMap {
-  if (a <= 1) {
-    throw new Error("The parameter a should be larger than 1");
-  }
-
-  const nodes = getNodesFromGraph(G);
-  const edges = getEdgesFromGraph(G);
-
-  if (nodes.length === 0) {
-    return {};
-  }
-
-  // Initialize positions if not provided
-  if (!pos) {
-    pos = randomLayout(G, null, 2, seed);
-  } else {
-    // Make sure all nodes have positions
-    const rng = new RandomNumberGenerator(seed ?? undefined);
-    const defaultPos: PositionMap = {};
-    nodes.forEach((node: Node) => {
-      if (!pos![node]) {
-        defaultPos[node] = [(rng.rand() as number), (rng.rand() as number)];
-      }
+    if (a <= 1) {
+        throw new Error("The parameter a should be larger than 1");
+    }
+
+    const nodes = getNodesFromGraph(G);
+    const edges = getEdgesFromGraph(G);
+
+    if (nodes.length === 0) {
+        return {};
+    }
+
+    // Initialize positions if not provided
+    if (!pos) {
+        pos = randomLayout(G, null, 2, seed);
+    } else {
+        // Make sure all nodes have positions
+        const rng = new RandomNumberGenerator(seed ?? undefined);
+        const defaultPos: PositionMap = {};
+        nodes.forEach((node: Node) => {
+            if (!pos![node]) {
+                defaultPos[node] = [rng.rand() as number, rng.rand() as number];
+            }
+        });
+        pos = { ...pos, ...defaultPos };
+    }
+
+    // Create node index mapping
+    const nodeIndex: Record<Node, number> = {};
+    nodes.forEach((node: Node, i: number) => {
+        nodeIndex[node] = i;
     });
-    pos = { ...pos, ...defaultPos };
-  }
-
-  // Create node index mapping
-  const nodeIndex: Record<Node, number> = {};
-  nodes.forEach((node: Node, i: number) => {
-    nodeIndex[node] = i;
-  });
-
-  // Create positions array
-  const positions: number[][] = nodes.map((node: Node) => [...pos![node]]);
-
-  // Initialize spring constant matrix
-  const N = nodes.length;
-  const K = Array(N).fill(0).map(() => Array(N).fill(1));
-
-  // Set diagonal to zero (no self-attraction)
-  for (let i = 0; i < N; i++) {
-    K[i][i] = 0;
-  }
-
-  // Set stronger attraction between connected nodes
-  for (const [source, target] of edges) {
-    if (source === target) continue;
-
-    const i = nodeIndex[source];
-    const j = nodeIndex[target];
-    K[i][j] = a;
-    K[j][i] = a;
-  }
-
-  // Calculate rho (scale factor)
-  const rho = scaling * Math.sqrt(N);
-
-  // Optimization loop
-  const dt = 1e-3;  // Time step
-  const etol = 1e-6;  // Error tolerance
-  let error = etol + 1;
-  let nIter = 0;
-
-  while (error > etol && nIter < maxIter) {
-    // Calculate changes for each node
-    const change = Array(N).fill(0).map(() => [0, 0]);
 
+    // Create positions array
+    const positions: number[][] = nodes.map((node: Node) => [...pos[node]]);
+
+    // Initialize spring constant matrix
+    const N = nodes.length;
+    const K = Array(N)
+        .fill(0)
+        .map(() => Array(N).fill(1));
+
+    // Set diagonal to zero (no self-attraction)
     for (let i = 0; i < N; i++) {
-      for (let j = 0; j < N; j++) {
-        if (i === j) continue;
+        K[i][i] = 0;
+    }
+
+    // Set stronger attraction between connected nodes
+    for (const [source, target] of edges) {
+        if (source === target) {continue;}
 
-        // Calculate difference vector
-        const diff = positions[i].map((coord, dim) => coord - positions[j][dim]);
+        const i = nodeIndex[source];
+        const j = nodeIndex[target];
+        K[i][j] = a;
+        K[j][i] = a;
+    }
 
-        // Calculate distance (with minimum to avoid division by zero)
-        const dist = Math.sqrt(diff.reduce((sum, d) => sum + d * d, 0)) || 0.01;
+    // Calculate rho (scale factor)
+    const rho = scaling * Math.sqrt(N);
 
-        // Calculate attractive and repulsive forces
-        for (let d = 0; d < diff.length; d++) {
-          change[i][d] += K[i][j] * diff[d] - (rho / dist) * diff[d];
+    // Optimization loop
+    const dt = 1e-3; // Time step
+    const etol = 1e-6; // Error tolerance
+    let error = etol + 1;
+    let nIter = 0;
+
+    while (error > etol && nIter < maxIter) {
+        // Calculate changes for each node
+        const change = Array(N)
+            .fill(0)
+            .map(() => [0, 0]);
+
+        for (let i = 0; i < N; i++) {
+            for (let j = 0; j < N; j++) {
+                if (i === j) {continue;}
+
+                // Calculate difference vector
+                const diff = positions[i].map((coord, dim) => coord - positions[j][dim]);
+
+                // Calculate distance (with minimum to avoid division by zero)
+                const dist = Math.sqrt(diff.reduce((sum, d) => sum + d * d, 0)) || 0.01;
+
+                // Calculate attractive and repulsive forces
+                for (let d = 0; d < diff.length; d++) {
+                    change[i][d] += K[i][j] * diff[d] - (rho / dist) * diff[d];
+                }
+            }
         }
-      }
-    }
 
-    // Update positions
-    for (let i = 0; i < N; i++) {
-      for (let d = 0; d < positions[i].length; d++) {
-        positions[i][d] += change[i][d] * dt;
-      }
-    }
+        // Update positions
+        for (let i = 0; i < N; i++) {
+            for (let d = 0; d < positions[i].length; d++) {
+                positions[i][d] += change[i][d] * dt;
+            }
+        }
 
-    // Calculate error (sum of force magnitudes)
-    error = change.reduce((sum, c) =>
-      sum + Math.sqrt(c.reduce((s, v) => s + v * v, 0)), 0);
+        // Calculate error (sum of force magnitudes)
+        error = change.reduce((sum, c) => sum + Math.sqrt(c.reduce((s, v) => s + v * v, 0)), 0);
 
-    nIter++;
-  }
+        nIter++;
+    }
 
-  // Convert positions array back to object
-  const finalPos: PositionMap = {};
-  nodes.forEach((node: Node, i: number) => {
-    finalPos[node] = positions[i];
-  });
+    // Convert positions array back to object
+    const finalPos: PositionMap = {};
+    nodes.forEach((node: Node, i: number) => {
+        finalPos[node] = positions[i];
+    });
 
-  return finalPos;
-}
+    return finalPos;
+}