@graphty/layout 1.2.8 → 1.3.2

package/src/layouts/hierarchical/bipartite.ts

@@ -2,14 +2,13 @@
  * Bipartite 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 two straight lines (bipartite layout).
- * 
  * @param G - Graph or list of nodes
  * @param nodes - Nodes in one node set of the graph
  * @param align - The alignment of nodes: 'vertical' or 'horizontal'
@@ -19,76 +18,76 @@ import { rescaleLayout } from '../../utils/rescale';
  * @returns Positions dictionary keyed by node
  */
 export function bipartiteLayout(
-  G: Graph,
-  nodes: Node[] | null = null,
-  align: 'vertical' | 'horizontal' = 'vertical',
-  scale: number = 1,
-  center: number[] | null = null,
-  aspectRatio: number = 4 / 3
+    G: Graph,
+    nodes: Node[] | null = null,
+    align: "vertical" | "horizontal" = "vertical",
+    scale: number = 1,
+    center: number[] | null = null,
+    aspectRatio: number = 4 / 3,
 ): PositionMap {
-  if (align !== 'vertical' && align !== 'horizontal') {
-    throw new Error("align must be either vertical or horizontal");
-  }
+    if (align !== "vertical" && align !== "horizontal") {
+        throw new Error("align must be either vertical or horizontal");
+    }
 
-  const processed = _processParams(G, center || [0, 0], 2);
-  const graph = processed.G;
-  center = processed.center;
+    const processed = _processParams(G, center || [0, 0], 2);
+    const graph = processed.G;
+    center = processed.center;
 
-  const allNodes = getNodesFromGraph(graph);
+    const allNodes = getNodesFromGraph(graph);
 
-  if (allNodes.length === 0) {
-    return {};
-  }
+    if (allNodes.length === 0) {
+        return {};
+    }
 
-  // If nodes not provided, try to determine bipartite sets
-  if (!nodes) {
-    // A simple heuristic for bipartite detection: use nodes with even/odd indices
-    // This is a simplification, in Python NetworkX has bipartite.sets()
-    nodes = allNodes.filter((_: Node, i: number): boolean => i % 2 === 0);
-  }
+    // If nodes not provided, try to determine bipartite sets
+    if (!nodes) {
+        // A simple heuristic for bipartite detection: use nodes with even/odd indices
+        // This is a simplification, in Python NetworkX has bipartite.sets()
+        nodes = allNodes.filter((_: Node, i: number): boolean => i % 2 === 0);
+    }
 
-  const left = new Set(nodes);
-  const right: Set<Node> = new Set(allNodes.filter((n: Node) => !left.has(n)));
+    const left = new Set(nodes);
+    const right: Set<Node> = new Set(allNodes.filter((n: Node) => !left.has(n)));
 
-  const height = 1;
-  const width = aspectRatio * height;
-  const offset = [width / 2, height / 2];
+    const height = 1;
+    const width = aspectRatio * height;
+    const offset = [width / 2, height / 2];
 
-  const pos: PositionMap = {};
+    const pos: PositionMap = {};
 
-  // Position nodes in the left set
-  const leftNodes = [...left];
-  leftNodes.forEach((node, i) => {
-    const x = 0;
-    const y = i * height / (leftNodes.length || 1);
-    pos[node] = [x, y];
-  });
+    // Position nodes in the left set
+    const leftNodes = [...left];
+    leftNodes.forEach((node, i) => {
+        const x = 0;
+        const y = (i * height) / (leftNodes.length || 1);
+        pos[node] = [x, y];
+    });
 
-  // Position nodes in the right set
-  const rightNodes = [...right];
-  rightNodes.forEach((node, i) => {
-    const x = width;
-    const y = i * height / (rightNodes.length || 1);
-    pos[node] = [x, y];
-  });
+    // Position nodes in the right set
+    const rightNodes = [...right];
+    rightNodes.forEach((node, i) => {
+        const x = width;
+        const y = (i * height) / (rightNodes.length || 1);
+        pos[node] = [x, y];
+    });
 
-  // Center positions around the origin and apply offset
-  for (const node in pos) {
-    pos[node][0] -= offset[0];
-    pos[node][1] -= offset[1];
-  }
+    // Center positions around the origin and apply offset
+    for (const node in pos) {
+        pos[node][0] -= offset[0];
+        pos[node][1] -= offset[1];
+    }
 
-  // Rescale positions
-  const scaledPos = rescaleLayout(pos, scale, center) as PositionMap;
+    // Rescale positions
+    const scaledPos = rescaleLayout(pos, scale, center) as PositionMap;
 
-  // Handle horizontal alignment
-  if (align === 'horizontal') {
-    for (const node in scaledPos) {
-      const temp = scaledPos[node][0];
-      scaledPos[node][0] = scaledPos[node][1];
-      scaledPos[node][1] = temp;
+    // Handle horizontal alignment
+    if (align === "horizontal") {
+        for (const node in scaledPos) {
+            const temp = scaledPos[node][0];
+            scaledPos[node][0] = scaledPos[node][1];
+            scaledPos[node][1] = temp;
+        }
     }
-  }
 
-  return scaledPos;
-}
+    return scaledPos;
+}

package/src/layouts/hierarchical/index.ts

@@ -2,6 +2,6 @@
  * Hierarchical layout algorithms
  */
 
-export { bipartiteLayout } from './bipartite';
-export { multipartiteLayout } from './multipartite';
-export { bfsLayout } from './bfs';
+export { bfsLayout } from "./bfs";
+export { bipartiteLayout } from "./bipartite";
+export { multipartiteLayout } from "./multipartite";

package/src/layouts/hierarchical/multipartite.ts

@@ -1,11 +1,10 @@
-import type { Graph, Node, PositionMap } from '../../types';
-import { getNodesFromGraph, getNeighbors } from '../../utils/graph';
-import { _processParams } from '../../utils/params';
-import { rescaleLayout } from '../../utils/rescale';
+import type { Graph, Node, PositionMap } from "../../types";
+import { getNeighbors,getNodesFromGraph } from "../../utils/graph";
+import { _processParams } from "../../utils/params";
+import { rescaleLayout } from "../../utils/rescale";
 
 /**
  * Position nodes in layers of straight lines (multipartite layout).
- * 
  * @param G - Graph or list of nodes
  * @param subsetKey - Object mapping layers to node sets, or node attribute name
  * @param align - The alignment of nodes: 'vertical' or 'horizontal'
@@ -14,75 +13,75 @@ import { rescaleLayout } from '../../utils/rescale';
  * @returns Positions dictionary keyed by node
  */
 export function multipartiteLayout(
-  G: Graph,
-  subsetKey: Record<number | string, Node | Node[]> | string = 'subset',
-  align: 'vertical' | 'horizontal' = 'vertical',
-  scale: number = 1,
-  center: number[] | null = null
+    G: Graph,
+    subsetKey: Record<number | string, Node | Node[]> | string = "subset",
+    align: "vertical" | "horizontal" = "vertical",
+    scale: number = 1,
+    center: number[] | null = null,
 ): PositionMap {
-  if (align !== 'vertical' && align !== 'horizontal') {
-    throw new Error("align must be either vertical or horizontal");
-  }
+    if (align !== "vertical" && align !== "horizontal") {
+        throw new Error("align must be either vertical or horizontal");
+    }
 
-  const processed = _processParams(G, center || [0, 0], 2);
-  const graph = processed.G;
-  center = processed.center;
+    const processed = _processParams(G, center || [0, 0], 2);
+    const graph = processed.G;
+    center = processed.center;
 
-  const allNodes = getNodesFromGraph(graph);
+    const allNodes = getNodesFromGraph(graph);
 
-  if (allNodes.length === 0) {
-    return {};
-  }
+    if (allNodes.length === 0) {
+        return {};
+    }
 
-  // Convert subsetKey to a layer mapping if it's a string
-  let layers: Record<number | string, Node[]> = {};
-  if (typeof subsetKey === 'string') {
-    // In JS we don't have access to node attributes directly
-    // This is a simplification - in a real implementation we would need
-    // to access node attributes from the graph
-    console.warn("Using string subsetKey requires node attributes, using default partitioning");
-    // Create a simple partitioning as fallback
-    layers = { 0: allNodes };
-  } else {
-    // subsetKey is already a mapping of layers to nodes
-    // Convert single nodes to arrays
-    for (const [key, value] of Object.entries(subsetKey)) {
-      if (Array.isArray(value)) {
-        layers[key] = value;
-      } else {
-        layers[key] = [value];
-      }
+    // Convert subsetKey to a layer mapping if it's a string
+    let layers: Record<number | string, Node[]> = {};
+    if (typeof subsetKey === "string") {
+        // In JS we don't have access to node attributes directly
+        // This is a simplification - in a real implementation we would need
+        // to access node attributes from the graph
+        console.warn("Using string subsetKey requires node attributes, using default partitioning");
+        // Create a simple partitioning as fallback
+        layers = { 0: allNodes };
+    } else {
+        // subsetKey is already a mapping of layers to nodes
+        // Convert single nodes to arrays
+        for (const [key, value] of Object.entries(subsetKey)) {
+            if (Array.isArray(value)) {
+                layers[key] = value;
+            } else {
+                layers[key] = [value];
+            }
+        }
     }
-  }
 
-  const layerCount = Object.keys(layers).length;
-  let pos: PositionMap = {};
+    const layerCount = Object.keys(layers).length;
+    let pos: PositionMap = {};
 
-  // Process each layer
-  Object.entries(layers).forEach(([layer, nodes], layerIdx) => {
-    const layerNodes = Array.isArray(nodes) ? nodes : [nodes];
-    const layerSize = layerNodes.length;
+    // Process each layer
+    Object.entries(layers).forEach(([layer, nodes], layerIdx) => {
+        const layerNodes = Array.isArray(nodes) ? nodes : [nodes];
+        const layerSize = layerNodes.length;
 
-    layerNodes.forEach((node, nodeIdx) => {
-      // Place nodes in a grid: layerIdx determines x-coordinate (column)
-      // nodeIdx determines y-coordinate (row position within column)
-      const x = layerIdx - (layerCount - 1) / 2;
-      const y = nodeIdx - (layerSize - 1) / 2;
-      pos[node] = [x, y];
+        layerNodes.forEach((node, nodeIdx) => {
+            // Place nodes in a grid: layerIdx determines x-coordinate (column)
+            // nodeIdx determines y-coordinate (row position within column)
+            const x = layerIdx - (layerCount - 1) / 2;
+            const y = nodeIdx - (layerSize - 1) / 2;
+            pos[node] = [x, y];
+        });
     });
-  });
 
-  // Rescale positions
-  pos = rescaleLayout(pos, scale, center) as PositionMap;
+    // Rescale positions
+    pos = rescaleLayout(pos, scale, center) as PositionMap;
 
-  // Handle horizontal alignment
-  if (align === 'horizontal') {
-    for (const node in pos) {
-      const temp = pos[node][0];
-      pos[node][0] = pos[node][1];
-      pos[node][1] = temp;
+    // Handle horizontal alignment
+    if (align === "horizontal") {
+        for (const node in pos) {
+            const temp = pos[node][0];
+            pos[node][0] = pos[node][1];
+            pos[node][1] = temp;
+        }
     }
-  }
 
-  return pos;
-}
+    return pos;
+}

package/src/layouts/index.ts

@@ -2,8 +2,8 @@
  * Re-export all layout algorithms
  */
 
-export * from './basic';
-export * from './geometric';
-export * from './force-directed';
-export * from './hierarchical';
-export * from './specialized';
+export * from "./basic";
+export * from "./force-directed";
+export * from "./geometric";
+export * from "./hierarchical";
+export * from "./specialized";

package/src/layouts/specialized/index.ts

@@ -2,5 +2,5 @@
  * Specialized layout algorithms
  */
 
-export { spectralLayout } from './spectral';
-export { planarLayout } from './planar';
+export { planarLayout } from "./planar";
+export { spectralLayout } from "./spectral";

package/src/layouts/specialized/planar.ts

@@ -2,64 +2,65 @@
  * Planar layout algorithm
  */
 
-import { Graph, Node, Edge, PositionMap } from '../../types';
-import { _processParams } from '../../utils/params';
-import { getNodesFromGraph, getEdgesFromGraph } from '../../utils/graph';
-import { rescaleLayout } from '../../utils/rescale';
-import { checkPlanarity, combinatorialEmbeddingToPos } from '../../algorithms/planarity';
+import { checkPlanarity, combinatorialEmbeddingToPos } from "../../algorithms/planarity";
+import { Edge, Graph, Node, PositionMap } from "../../types";
+import { getEdgesFromGraph,getNodesFromGraph } from "../../utils/graph";
+import { _processParams } from "../../utils/params";
+import { rescaleLayout } from "../../utils/rescale";
 
 /**
  * Position nodes without edge intersections (planar layout).
- * 
  * @param G - Graph
  * @param scale - Scale factor for positions
  * @param center - Coordinate pair around which to center the layout
  * @param dim - Dimension of layout (must be 2)
+ * @param seed - Random seed for reproducible layouts
  * @returns Positions dictionary keyed by node
  */
 export function planarLayout(
-  G: Graph,
-  scale: number = 1,
-  center: number[] | null = null,
-  dim: number = 2
+    G: Graph,
+    scale: number = 1,
+    center: number[] | null = null,
+    dim: number = 2,
+    seed: number | null = null,
 ): 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);
-  
-  // Planar layout requires a proper Graph, not just a list of nodes
-  if (Array.isArray(processed.G)) {
-    throw new Error('Planar 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], dim);
 
-  const nodes = getNodesFromGraph(graph);
-  const edges = getEdgesFromGraph(graph);
+    // Planar layout requires a proper Graph, not just a list of nodes
+    if (Array.isArray(processed.G)) {
+        throw new Error("Planar layout requires a Graph with edges, not just a list of nodes");
+    }
 
-  if (nodes.length === 0) {
-    return {};
-  }
+    const graph = processed.G;
+    center = processed.center;
 
-  // Check if graph is planar and get embedding
-  const { isPlanar, embedding } = checkPlanarity(graph, nodes, edges);
+    const nodes = getNodesFromGraph(graph);
+    const edges = getEdgesFromGraph(graph);
 
-  if (!isPlanar) {
-    throw new Error("G is not planar.");
-  }
+    if (nodes.length === 0) {
+        return {};
+    }
 
-  if (!embedding) {
-    throw new Error("Failed to generate planar embedding.");
-  }
+    // Check if graph is planar and get embedding
+    const { isPlanar, embedding } = checkPlanarity(graph, nodes, edges, seed);
 
-  // Convert embedding to positions
-  let pos = combinatorialEmbeddingToPos(embedding, nodes);
+    if (!isPlanar) {
+        throw new Error("G is not planar.");
+    }
 
-  // Rescale the positions
-  pos = rescaleLayout(pos, scale, center) as PositionMap;
+    if (!embedding) {
+        throw new Error("Failed to generate planar embedding.");
+    }
 
-  return pos;
-}
+    // Convert embedding to positions
+    let pos = combinatorialEmbeddingToPos(embedding, nodes);
+
+    // Rescale the positions
+    pos = rescaleLayout(pos, scale, center) as PositionMap;
+
+    return pos;
+}