@graphty/layout 1.2.9 → 1.4.0

package/src/layouts/force-directed/fruchterman-reingold.ts

@@ -2,163 +2,162 @@
  * Fruchterman-Reingold force-directed layout algorithm
  */
 
-import { Graph, Node, Edge, PositionMap } from '../../types';
-import { _processParams } from '../../utils/params';
-import { getNodesFromGraph, getEdgesFromGraph } from '../../utils/graph';
-import { RandomNumberGenerator } from '../../utils/random';
-import { rescaleLayout } from '../../utils/rescale';
+import type { Graph, Node, PositionMap } from "../../types";
+import { getEdgesFromGraph,getNodesFromGraph } from "../../utils/graph";
+import { _processParams } from "../../utils/params";
+import { RandomNumberGenerator } from "../../utils/random";
+import { rescaleLayout } from "../../utils/rescale";
 
 /**
  * Position nodes using Fruchterman-Reingold force-directed algorithm.
- *
- * @param {Object} G - Graph or list of nodes
- * @param {number} k - Optimal distance between nodes
- * @param {Object} pos - Initial positions for nodes
- * @param {Array} fixed - Nodes to keep fixed at initial position
- * @param {number} iterations - Maximum number of iterations
- * @param {number} scale - Scale factor for positions
- * @param {Array|null} center - Coordinate pair around which to center the layout
- * @param {number} dim - Dimension of layout
- * @param {number} seed - Random seed for initial positions
- * @returns {Object} Positions dictionary keyed by node
+ * @param G - Graph or list of nodes
+ * @param k - Optimal distance between nodes
+ * @param pos - Initial positions for nodes
+ * @param fixed - Nodes to keep fixed at initial position
+ * @param iterations - Maximum number of iterations
+ * @param scale - Scale factor for positions
+ * @param center - Coordinate pair around which to center the layout
+ * @param dim - Dimension of layout
+ * @param seed - Random seed for initial positions
+ * @returns Positions dictionary keyed by node
  */
 export function fruchtermanReingoldLayout(
-  G: Graph,
-  k: number | null = null,
-  pos: PositionMap | null = null,
-  fixed: Node[] | null = null,
-  iterations: number = 50,
-  scale: number = 1,
-  center: number[] | null = null,
-  dim: number = 2,
-  seed: number | null = null
+    G: Graph,
+    k: number | null = null,
+    pos: PositionMap | null = null,
+    fixed: Node[] | null = null,
+    iterations: number = 50,
+    scale: number = 1,
+    center: number[] | null = null,
+    dim: number = 2,
+    seed: number | null = null,
 ): PositionMap {
-  const processed = _processParams(G, center, dim);
-  let graph = processed.G;
-  center = processed.center;
-
-  const nodes = getNodesFromGraph(graph);
-  const edges = getEdgesFromGraph(graph);
-
-  if (nodes.length === 0) {
-    return {};
-  }
-
-  if (nodes.length === 1) {
-    const singlePos: PositionMap = {};
-    singlePos[nodes[0]] = center;
-    return singlePos;
-  }
-
-  // Set up initial positions
-  let positions: PositionMap = {};
-  if (pos) {
-    // Use provided positions
-    for (const node of nodes) {
-      if (pos[node]) {
-        positions[node] = [...pos[node]];
-      } else {
-        const rng = new RandomNumberGenerator(seed ?? undefined);
-        positions[node] = rng.rand(dim) as number[];
-      }
+    const processed = _processParams(G, center, dim);
+    const graph = processed.G;
+    ({ center } = processed);
+
+    const nodes = getNodesFromGraph(graph);
+    const edges = getEdgesFromGraph(graph);
+
+    if (nodes.length === 0) {
+        return {};
+    }
+
+    if (nodes.length === 1) {
+        const singlePos: PositionMap = {};
+        singlePos[nodes[0]] = center;
+        return singlePos;
     }
-  } else {
-    // Random initial positions
-    const rng = new RandomNumberGenerator(seed ?? undefined);
-    for (const node of nodes) {
-      positions[node] = rng.rand(dim) as number[];
+
+    // Set up initial positions
+    let positions: PositionMap = {};
+    if (pos) {
+        // Use provided positions
+        for (const node of nodes) {
+            if (pos[node]) {
+                positions[node] = [...pos[node]];
+            } else {
+                const rng = new RandomNumberGenerator(seed ?? undefined);
+                positions[node] = rng.rand(dim) as number[];
+            }
+        }
+    } else {
+        // Random initial positions
+        const rng = new RandomNumberGenerator(seed ?? undefined);
+        for (const node of nodes) {
+            positions[node] = rng.rand(dim) as number[];
+        }
     }
-  }
-
-  // Set up fixed nodes
-  const fixedNodes = new Set(fixed || []);
-
-  // Optimal distance between nodes
-  if (!k) {
-    k = 1.0 / Math.sqrt(nodes.length);
-  }
-
-  // Initialize temperature
-  let t = 0.1;
-  // Calculate temperature reduction
-  const dt = t / (iterations + 1);
-
-  // Simple cooling schedule
-  for (let i = 0; i < iterations; i++) {
-    // Calculate repulsive forces
-    const displacement: Record<Node, number[]> = {};
-    for (const node of nodes) {
-      displacement[node] = Array(dim).fill(0);
+
+    // Set up fixed nodes
+    const fixedNodes = new Set(fixed || []);
+
+    // Optimal distance between nodes
+    if (!k) {
+        k = 1.0 / Math.sqrt(nodes.length);
     }
 
-    // Repulsive forces between nodes
-    for (let v1i = 0; v1i < nodes.length; v1i++) {
-      const v1 = nodes[v1i];
-      for (let v2i = v1i + 1; v2i < nodes.length; v2i++) {
-        const v2 = nodes[v2i];
+    // Initialize temperature
+    let t = 0.1;
+    // Calculate temperature reduction
+    const dt = t / (iterations + 1);
+
+    // Simple cooling schedule
+    for (let i = 0; i < iterations; i++) {
+        // Calculate repulsive forces
+        const displacement: Record<Node, number[]> = {};
+        for (const node of nodes) {
+            displacement[node] = Array(dim).fill(0);
+        }
+
+        // Repulsive forces between nodes
+        for (let v1i = 0; v1i < nodes.length; v1i++) {
+            const v1 = nodes[v1i];
+            for (let v2i = v1i + 1; v2i < nodes.length; v2i++) {
+                const v2 = nodes[v2i];
 
-        // Difference vector
-        const delta = positions[v1].map((p, i) => p - positions[v2][i]);
+                // Difference vector
+                const delta = positions[v1].map((p, i) => p - positions[v2][i]);
 
-        // Distance
-        const distance = Math.sqrt(delta.reduce((sum, d) => sum + d * d, 0)) || 0.1;
+                // Distance
+                const distance = Math.sqrt(delta.reduce((sum, d) => sum + d * d, 0)) || 0.1;
 
-        // Force
-        const force = (k * k) / distance;
+                // Force
+                const force = (k * k) / distance;
 
-        // Add force to displacement
-        for (let j = 0; j < dim; j++) {
-          const direction = delta[j] / distance;
-          displacement[v1][j] += direction * force;
-          displacement[v2][j] -= direction * force;
+                // Add force to displacement
+                for (let j = 0; j < dim; j++) {
+                    const direction = delta[j] / distance;
+                    displacement[v1][j] += direction * force;
+                    displacement[v2][j] -= direction * force;
+                }
+            }
         }
-      }
-    }
 
-    // Attractive forces between connected nodes
-    for (const [source, target] of edges) {
-      // Difference vector
-      const delta = positions[source].map((p, i) => p - positions[target][i]);
+        // Attractive forces between connected nodes
+        for (const [source, target] of edges) {
+            // Difference vector
+            const delta = positions[source].map((p, i) => p - positions[target][i]);
 
-      // Distance
-      const distance = Math.sqrt(delta.reduce((sum, d) => sum + d * d, 0)) || 0.1;
+            // Distance
+            const distance = Math.sqrt(delta.reduce((sum, d) => sum + d * d, 0)) || 0.1;
 
-      // Force
-      const force = (distance * distance) / k;
+            // Force
+            const force = (distance * distance) / k;
 
-      // Add force to displacement
-      for (let j = 0; j < dim; j++) {
-        const direction = delta[j] / distance;
-        displacement[source][j] -= direction * force;
-        displacement[target][j] += direction * force;
-      }
-    }
+            // Add force to displacement
+            for (let j = 0; j < dim; j++) {
+                const direction = delta[j] / distance;
+                displacement[source][j] -= direction * force;
+                displacement[target][j] += direction * force;
+            }
+        }
 
-    // Update positions
-    for (const node of nodes) {
-      if (fixedNodes.has(node)) continue;
+        // Update positions
+        for (const node of nodes) {
+            if (fixedNodes.has(node)) {continue;}
 
-      // Calculate displacement magnitude
-      const magnitude = Math.sqrt(displacement[node].reduce((sum, d) => sum + d * d, 0));
+            // Calculate displacement magnitude
+            const magnitude = Math.sqrt(displacement[node].reduce((sum, d) => sum + d * d, 0));
 
-      // Limit maximum displacement by temperature
-      const limitedMagnitude = Math.min(magnitude, t);
+            // Limit maximum displacement by temperature
+            const limitedMagnitude = Math.min(magnitude, t);
 
-      // Update position
-      for (let j = 0; j < dim; j++) {
-        const direction = magnitude === 0 ? 0 : displacement[node][j] / magnitude;
-        positions[node][j] += direction * limitedMagnitude;
-      }
-    }
+            // Update position
+            for (let j = 0; j < dim; j++) {
+                const direction = magnitude === 0 ? 0 : displacement[node][j] / magnitude;
+                positions[node][j] += direction * limitedMagnitude;
+            }
+        }
 
-    // Cool temperature
-    t -= dt;
-  }
+        // Cool temperature
+        t -= dt;
+    }
 
-  // Rescale positions
-  if (!fixed) {
-    positions = rescaleLayout(positions, scale, center) as PositionMap;
-  }
+    // Rescale positions
+    if (!fixed) {
+        positions = rescaleLayout(positions, scale, center) as PositionMap;
+    }
 
-  return positions;
-}
+    return positions;
+}

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

@@ -2,8 +2,8 @@
  * Force-directed layout algorithms
  */
 
-export { springLayout } from './spring';
-export { fruchtermanReingoldLayout } from './fruchterman-reingold';
-export { kamadaKawaiLayout } from './kamada-kawai';
-export { forceatlas2Layout } from './forceatlas2';
-export { arfLayout } from './arf';
+export { arfLayout } from "./arf";
+export { forceatlas2Layout } from "./forceatlas2";
+export { fruchtermanReingoldLayout } from "./fruchterman-reingold";
+export { kamadaKawaiLayout } from "./kamada-kawai";
+export { springLayout } from "./spring";

package/src/layouts/force-directed/kamada-kawai.ts

@@ -1,17 +1,12 @@
-import type { Graph, Node, PositionMap } from '../../types';
-import type { DistanceMap } from '../../algorithms/optimization';
-import { getNodesFromGraph } from '../../utils/graph';
-import { _processParams } from '../../utils/params';
-import { rescaleLayout } from '../../utils/rescale';
-import { circularLayout } from '../geometric/circular';
-import { 
-  _computeShortestPathDistances,
-  _kamadaKawaiSolve
-} from '../../algorithms/optimization';
+import { _computeShortestPathDistances, _kamadaKawaiSolve, type DistanceMap } from "../../algorithms/optimization";
+import type { Graph, Node, PositionMap } from "../../types";
+import { getNodesFromGraph } from "../../utils/graph";
+import { _processParams } from "../../utils/params";
+import { rescaleLayout } from "../../utils/rescale";
+import { circularLayout } from "../geometric/circular";
 
 /**
  * Position nodes using Kamada-Kawai path-length cost-function.
- * 
  * @param G - NetworkX graph or list of nodes
  * @param dist - A two-level dictionary of optimal distances between nodes
  * @param pos - Initial positions for nodes
@@ -22,91 +17,93 @@ import {
  * @returns Positions dictionary keyed by node
  */
 export function kamadaKawaiLayout(
-  G: Graph,
-  dist: DistanceMap | null = null,
-  pos: PositionMap | null = null,
-  weight: string = 'weight',
-  scale: number = 1,
-  center: number[] | null = null,
-  dim: number = 2
+    G: Graph,
+    dist: DistanceMap | null = null,
+    pos: PositionMap | null = null,
+    weight: string = "weight",
+    scale: number = 1,
+    center: number[] | null = null,
+    dim: number = 2,
 ): PositionMap {
-  const processed = _processParams(G, center, dim);
-  const graph = processed.G;
-  center = processed.center;
+    const processed = _processParams(G, center, dim);
+    const graph = processed.G;
+    ({ center } = processed);
 
-  const nodes = getNodesFromGraph(graph);
+    const nodes = getNodesFromGraph(graph);
 
-  if (nodes.length === 0) {
-    return {};
-  }
+    if (nodes.length === 0) {
+        return {};
+    }
 
-  if (nodes.length === 1) {
-    return { [nodes[0]]: center };
-  }
+    if (nodes.length === 1) {
+        return { [nodes[0]]: center };
+    }
 
-  // Initialize distance matrix
-  if (!dist) {
-    // Kamada-Kawai requires a proper Graph, not just a list of nodes
-    if (Array.isArray(graph)) {
-      throw new Error('Kamada-Kawai layout requires a Graph with edges, not just a list of nodes');
+    // Initialize distance matrix
+    if (!dist) {
+        // Kamada-Kawai requires a proper Graph, not just a list of nodes
+        if (Array.isArray(graph)) {
+            throw new Error("Kamada-Kawai layout requires a Graph with edges, not just a list of nodes");
+        }
+        dist = _computeShortestPathDistances(graph, weight);
     }
-    dist = _computeShortestPathDistances(graph, weight);
-  }
 
-  // Convert distances to a matrix
-  const nodesArray: Node[] = Array.from(nodes);
-  const nNodes = nodesArray.length;
-  const distMatrix: number[][] = Array(nNodes).fill(0).map(() => Array(nNodes).fill(1e6));
+    // Convert distances to a matrix
+    const nodesArray: Node[] = Array.from(nodes);
+    const nNodes = nodesArray.length;
+    const distMatrix: number[][] = Array(nNodes)
+        .fill(0)
+        .map(() => Array(nNodes).fill(1e6));
 
-  for (let i = 0; i < nNodes; i++) {
-    const nodeI = nodesArray[i];
-    distMatrix[i][i] = 0;
+    for (let i = 0; i < nNodes; i++) {
+        const nodeI = nodesArray[i];
+        distMatrix[i][i] = 0;
 
-    if (!dist[nodeI]) continue;
+        if (!dist[nodeI]) {continue;}
 
-    for (let j = 0; j < nNodes; j++) {
-      const nodeJ = nodesArray[j];
-      if (dist[nodeI][nodeJ] !== undefined) {
-        distMatrix[i][j] = dist[nodeI][nodeJ];
-      }
+        for (let j = 0; j < nNodes; j++) {
+            const nodeJ = nodesArray[j];
+            if (dist[nodeI][nodeJ] !== undefined) {
+                distMatrix[i][j] = dist[nodeI][nodeJ];
+            }
+        }
     }
-  }
 
-  // Initialize positions if not provided
-  if (!pos) {
-    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 = {};
-      nodesArray.forEach((node, i) => {
-        posArray[node] = [i / (nNodes - 1 || 1)];
-      });
-      pos = posArray;
+    // Initialize positions if not provided
+    if (!pos) {
+        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 = {};
+            nodesArray.forEach((node, i) => {
+                posArray[node] = [i / (nNodes - 1 || 1)];
+            });
+            pos = posArray;
+        }
     }
-  }
 
-  // Convert positions to array for computation
-  const posArray: number[][] = new Array(nNodes);
-  for (let i = 0; i < nNodes; i++) {
-    const node = nodesArray[i];
-    posArray[i] = pos[node] ? [...pos[node]] : Array(dim).fill(0);
+    // Convert positions to array for computation
+    const posArray: number[][] = new Array(nNodes);
+    for (let i = 0; i < nNodes; i++) {
+        const node = nodesArray[i];
+        posArray[i] = pos[node] ? [...pos[node]] : Array(dim).fill(0);
 
-    // Ensure correct dimensionality
-    while (posArray[i].length < dim) {
-      posArray[i].push(0);
+        // Ensure correct dimensionality
+        while (posArray[i].length < dim) {
+            posArray[i].push(0);
+        }
     }
-  }
 
-  // Run the Kamada-Kawai algorithm
-  const newPositions = _kamadaKawaiSolve(distMatrix, posArray, dim);
+    // Run the Kamada-Kawai algorithm
+    const newPositions = _kamadaKawaiSolve(distMatrix, posArray, dim);
 
-  // Convert positions array back to dictionary and rescale
-  const finalPos: PositionMap = {};
-  for (let i = 0; i < nNodes; i++) {
-    finalPos[nodesArray[i]] = newPositions[i];
-  }
+    // Convert positions array back to dictionary and rescale
+    const finalPos: PositionMap = {};
+    for (let i = 0; i < nNodes; i++) {
+        finalPos[nodesArray[i]] = newPositions[i];
+    }
 
-  return rescaleLayout(finalPos, scale, center) as PositionMap;
-}
+    return rescaleLayout(finalPos, scale, center) as PositionMap;
+}

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

@@ -2,34 +2,33 @@
  * Spring layout algorithm (Fruchterman-Reingold variant)
  */
 
-import { Graph, Node, PositionMap } from '../../types';
-import { fruchtermanReingoldLayout } from './fruchterman-reingold';
+import { Graph, Node, PositionMap } from "../../types";
+import { fruchtermanReingoldLayout } from "./fruchterman-reingold";
 
 /**
  * Position nodes using Fruchterman-Reingold force-directed algorithm.
- * 
- * @param {Object} G - Graph or list of nodes
- * @param {number} k - Optimal distance between nodes
- * @param {Object} pos - Initial positions for nodes
- * @param {Array} fixed - Nodes to keep fixed at initial position
- * @param {number} iterations - Maximum number of iterations
- * @param {number} scale - Scale factor for positions
- * @param {Array|null} center - Coordinate pair around which to center the layout
- * @param {number} dim - Dimension of layout
- * @param {number} seed - Random seed for initial positions
- * @returns {Object} Positions dictionary keyed by node
+ * @param G - Graph or list of nodes
+ * @param k - Optimal distance between nodes
+ * @param pos - Initial positions for nodes
+ * @param fixed - Nodes to keep fixed at initial position
+ * @param iterations - Maximum number of iterations
+ * @param scale - Scale factor for positions
+ * @param center - Coordinate pair around which to center the layout
+ * @param dim - Dimension of layout
+ * @param seed - Random seed for initial positions
+ * @returns Positions dictionary keyed by node
  */
 export function springLayout(
-  G: Graph,
-  k: number | null = null,
-  pos: PositionMap | null = null,
-  fixed: Node[] | null = null,
-  iterations: number = 50,
-  scale: number = 1,
-  center: number[] | null = null,
-  dim: number = 2,
-  seed: number | null = null
+    G: Graph,
+    k: number | null = null,
+    pos: PositionMap | null = null,
+    fixed: Node[] | null = null,
+    iterations: number = 50,
+    scale: number = 1,
+    center: number[] | null = null,
+    dim: number = 2,
+    seed: number | null = null,
 ): PositionMap {
-  // Legacy compatibility alias
-  return fruchtermanReingoldLayout(G, k, pos, fixed, iterations, scale, center, dim, seed);
-}
+    // Legacy compatibility alias
+    return fruchtermanReingoldLayout(G, k, pos, fixed, iterations, scale, center, dim, seed);
+}