@graphty/layout 1.2.0 → 1.2.2

package/src/utils/random.ts

@@ -0,0 +1,53 @@
+/**
+ * Random number generator for seed-based randomization
+ * Maintains exact same functionality as original implementation
+ */
+
+export class RandomNumberGenerator {
+  private seed: number;
+  private m: number;
+  private a: number;
+  private c: number;
+  private _state: number;
+
+  constructor(seed?: number) {
+    this.seed = seed || Math.floor(Math.random() * 1000000);
+    this.m = 2 ** 35 - 31;
+    this.a = 185852;
+    this.c = 1;
+    this._state = this.seed % this.m;
+  }
+
+  _next(): number {
+    this._state = (this.a * this._state + this.c) % this.m;
+    return this._state / this.m;
+  }
+
+  rand(shape: number | number[] | null = null): number | number[] | number[][] {
+    if (shape === null) {
+      return this._next();
+    }
+
+    if (typeof shape === 'number') {
+      const result: number[] = [];
+      for (let i = 0; i < shape; i++) {
+        result.push(this._next());
+      }
+      return result;
+    }
+
+    if (shape.length === 1) {
+      const result: number[] = [];
+      for (let i = 0; i < shape[0]; i++) {
+        result.push(this._next());
+      }
+      return result;
+    }
+
+    const result: any[] = [];
+    for (let i = 0; i < shape[0]; i++) {
+      result.push(this.rand(shape.slice(1)));
+    }
+    return result;
+  }
+}

package/src/utils/rescale.ts

@@ -0,0 +1,137 @@
+/**
+ * Layout rescaling utilities
+ */
+
+import { PositionMap } from '../types';
+
+/**
+ * Returns scaled position array/dict to (-scale, scale) in all axes.
+ * 
+ * @param pos - Position dictionary or array
+ * @param scale - Scale factor for positions
+ * @param center - Coordinate pair around which to center the layout
+ * @returns Rescaled positions dictionary
+ */
+export function rescaleLayout(
+  pos: PositionMap | number[][],
+  scale: number = 1,
+  center: number[] = [0, 0]
+): PositionMap | number[][] {
+  // Check if pos is empty
+  if (Array.isArray(pos)) {
+    if (pos.length === 0) return [];
+  } else {
+    if (Object.keys(pos).length === 0) return {};
+  }
+
+  // Extract position values
+  const posValues: number[][] = Array.isArray(pos) ? pos : Object.values(pos);
+  const dim = posValues[0].length;
+
+  // Calculate center of positions
+  const posCenter = Array(dim).fill(0);
+  for (const p of posValues) {
+    for (let i = 0; i < dim; i++) {
+      posCenter[i] += p[i] / posValues.length;
+    }
+  }
+
+  // Center positions
+  let centeredPos: PositionMap | number[][] = {};
+  if (Array.isArray(pos)) {
+    centeredPos = pos.map(p => p.map((val, i) => val - posCenter[i]));
+  } else {
+    for (const [node, p] of Object.entries(pos)) {
+      (centeredPos as PositionMap)[node] = p.map((val, i) => val - posCenter[i]);
+    }
+  }
+
+  // Find maximum distance from center
+  let maxDistance = 0;
+  const centeredValues = Array.isArray(centeredPos) ? centeredPos : Object.values(centeredPos);
+  for (const p of centeredValues) {
+    const distance = Math.sqrt(p.reduce((sum, val) => sum + val * val, 0));
+    maxDistance = Math.max(maxDistance, distance);
+  }
+
+  // Rescale
+  let scaledPos: PositionMap | number[][] = Array.isArray(pos) ? [] : {};
+
+  if (maxDistance > 0) {
+    const scaleFactor = scale / maxDistance;
+
+    if (Array.isArray(pos)) {
+      (scaledPos as number[][]) = (centeredPos as number[][]).map(p =>
+        p.map((val, i) => val * scaleFactor + center[i])
+      );
+    } else {
+      for (const [node, p] of Object.entries(centeredPos as PositionMap)) {
+        (scaledPos as PositionMap)[node] = p.map((val, i) => val * scaleFactor + center[i]);
+      }
+    }
+  } else {
+    // All nodes at the same position
+    if (Array.isArray(pos)) {
+      (scaledPos as number[][]) = Array(pos.length).fill(0).map(() => [...center]);
+    } else {
+      for (const node of Object.keys(pos)) {
+        (scaledPos as PositionMap)[node] = [...center];
+      }
+    }
+  }
+
+  return scaledPos;
+}
+
+/**
+ * Return a dictionary of scaled positions centered at (0, 0).
+ * 
+ * @param pos - Dictionary of positions
+ * @param scale - Scale factor for positions
+ * @returns Dictionary of scaled positions
+ */
+export function rescaleLayoutDict(
+  pos: PositionMap,
+  scale: number = 1
+): PositionMap {
+  if (Object.keys(pos).length === 0) {
+    return {};
+  }
+
+  // Extract positions as array
+  const posArray = Object.values(pos);
+
+  // Find center of positions
+  const center: number[] = [];
+  for (let d = 0; d < posArray[0].length; d++) {
+    center[d] = posArray.reduce((sum, p) => sum + p[d], 0) / posArray.length;
+  }
+
+  // Center positions
+  const centeredPos: PositionMap = {};
+  for (const [node, p] of Object.entries(pos)) {
+    centeredPos[node] = p.map((val, d) => val - center[d]);
+  }
+
+  // Find maximum distance from center
+  let maxDist = 0;
+  for (const p of Object.values(centeredPos)) {
+    const dist = Math.sqrt(p.reduce((sum, val) => sum + val * val, 0));
+    maxDist = Math.max(maxDist, dist);
+  }
+
+  // Scale positions
+  const scaledPos: PositionMap = {};
+  if (maxDist > 0) {
+    for (const [node, p] of Object.entries(centeredPos)) {
+      scaledPos[node] = p.map(val => val * scale / maxDist);
+    }
+  } else {
+    // All points at the center
+    for (const node of Object.keys(centeredPos)) {
+      scaledPos[node] = Array(centeredPos[node].length).fill(0);
+    }
+  }
+
+  return scaledPos;
+}

package/test/arf-layout.test.ts

@@ -6,7 +6,7 @@ import {
   starGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('ARF Layout', () => {
   describe('Basic functionality', () => {

package/test/bfs-layout.test.ts

@@ -7,7 +7,7 @@ import {
   wheelGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('BFS Layout', () => {
   describe('Basic functionality', () => {

package/test/bipartite-layout.test.ts

@@ -2,7 +2,7 @@ import { describe, it, assert } from 'vitest';
 import { 
   bipartiteLayout,
   bipartiteGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Bipartite Layout', () => {
   describe('Basic functionality', () => {

package/test/circular-layout.test.ts

@@ -7,7 +7,7 @@ import {
   wheelGraph,
   gridGraph,
   randomGraph
-} from '../layout.js';
+} from '../src';
 
 describe('Circular Layout', () => {
   describe('Basic functionality', () => {

package/test/forceatlas2-layout.test.ts

@@ -7,7 +7,7 @@ import {
   gridGraph,
   randomGraph,
   scaleFreeGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('ForceAtlas2 Layout', () => {
   describe('Basic functionality', () => {

package/test/fruchterman-reingold-layout.test.ts

@@ -6,7 +6,7 @@ import {
   starGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Fruchterman-Reingold Layout', () => {
   describe('Basic functionality', () => {

package/test/graph-generators.test.ts

@@ -9,7 +9,7 @@ import {
   bipartiteGraph,
   scaleFreeGraph,
   circularLayout
-} from '../layout.ts';
+} from '../src';
 
 describe('Graph Generators', () => {
   describe('completeGraph', () => {

package/test/kamada-kawai-layout.test.ts

@@ -6,7 +6,7 @@ import {
   starGraph,
   gridGraph,
   randomGraph
-} from '../layout.js';
+} from '../src';
 
 describe('Kamada-Kawai Layout', () => {
   describe('Basic functionality', () => {

package/test/multipartite-layout.test.ts

@@ -4,7 +4,7 @@ import {
   completeGraph,
   cycleGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Multipartite Layout', () => {
   describe('Basic functionality', () => {

package/test/planar-layout.test.ts

@@ -6,7 +6,7 @@ import {
   starGraph,
   gridGraph,
   wheelGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Planar Layout', () => {
   describe('Basic functionality', () => {

package/test/random-layout.test.ts

@@ -5,7 +5,7 @@ import {
   cycleGraph,
   starGraph,
   gridGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Random Layout', () => {
   describe('Basic functionality', () => {

package/test/rescale-layout.test.ts

@@ -6,7 +6,7 @@ import {
   randomLayout,
   completeGraph,
   starGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Rescale Layout', () => {
   describe('Dictionary format (rescaleLayout)', () => {

package/test/shell-layout.test.ts

@@ -7,7 +7,7 @@ import {
   wheelGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Shell Layout', () => {
   describe('Basic functionality', () => {

package/test/spectral-layout.test.ts

@@ -6,7 +6,7 @@ import {
   starGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Spectral Layout', () => {
   describe('Basic functionality', () => {

package/test/spiral-layout.test.ts

@@ -6,7 +6,7 @@ import {
   starGraph,
   gridGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Spiral Layout', () => {
   describe('Basic functionality', () => {

package/test/spring-layout.test.ts

@@ -5,7 +5,7 @@ import {
   cycleGraph,
   starGraph,
   randomGraph
-} from '../layout.ts';
+} from '../src';
 
 describe('Spring Layout', () => {
   describe('Basic functionality', () => {

package/test/test-utils.ts

@@ -0,0 +1,34 @@
+/**
+ * Test utilities and helper functions
+ */
+
+import { Graph, Node, Edge } from '../src/types';
+
+/**
+ * Create a simple test graph for testing
+ */
+export function createTestGraph(nodes: Node[], edges: Edge[]): Graph {
+  return {
+    nodes: () => nodes,
+    edges: () => edges,
+    adjacency: function() {
+      const adj = new Map<Node, Map<Node, number>>();
+      
+      // Initialize adjacency for all nodes
+      for (const node of nodes) {
+        adj.set(node, new Map());
+      }
+      
+      // Add edges
+      for (const [source, target] of edges) {
+        if (!adj.has(source)) adj.set(source, new Map());
+        if (!adj.has(target)) adj.set(target, new Map());
+        
+        adj.get(source)!.set(target, 1);
+        adj.get(target)!.set(source, 1);
+      }
+      
+      return adj;
+    }
+  };
+}

package/test/utils-graph.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Tests for graph utility functions
+ */
+
+import { describe, it, expect } from 'vitest';
+import { 
+  getNodesFromGraph, 
+  getEdgesFromGraph, 
+  getNodeDegree, 
+  getNeighbors 
+} from '../src/utils/graph';
+import { createTestGraph } from './test-utils';
+
+describe('Graph Utils', () => {
+  describe('getNodesFromGraph', () => {
+    it('should return array as-is when given array of nodes', () => {
+      const nodes = [1, 2, 3, 'a', 'b'];
+      const result = getNodesFromGraph(nodes);
+      expect(result).toEqual(nodes);
+      expect(result).toBe(nodes); // same reference
+    });
+
+    it('should call nodes() method when given graph object', () => {
+      const graph = createTestGraph([1, 2, 3], [[1, 2], [2, 3]]);
+      const result = getNodesFromGraph(graph);
+      expect(result).toEqual([1, 2, 3]);
+    });
+
+    it('should handle empty array', () => {
+      const result = getNodesFromGraph([]);
+      expect(result).toEqual([]);
+    });
+
+    it('should handle empty graph', () => {
+      const graph = createTestGraph([], []);
+      const result = getNodesFromGraph(graph);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('getEdgesFromGraph', () => {
+    it('should return empty array when given array of nodes', () => {
+      const nodes = [1, 2, 3, 'a', 'b'];
+      const result = getEdgesFromGraph(nodes);
+      expect(result).toEqual([]);
+    });
+
+    it('should call edges() method when given graph object', () => {
+      const edges = [[1, 2], [2, 3], [3, 1]];
+      const graph = createTestGraph([1, 2, 3], edges);
+      const result = getEdgesFromGraph(graph);
+      expect(result).toEqual(edges);
+    });
+
+    it('should handle empty array', () => {
+      const result = getEdgesFromGraph([]);
+      expect(result).toEqual([]);
+    });
+
+    it('should handle graph with no edges', () => {
+      const graph = createTestGraph([1, 2, 3], []);
+      const result = getEdgesFromGraph(graph);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('getNodeDegree', () => {
+    it('should return 0 for graph without edges method', () => {
+      const graph = { nodes: () => [1, 2, 3] } as any;
+      const result = getNodeDegree(graph, 1);
+      expect(result).toBe(0);
+    });
+
+    it('should calculate degree correctly for connected node', () => {
+      const graph = createTestGraph([1, 2, 3, 4], [[1, 2], [1, 3], [1, 4], [2, 3]]);
+      expect(getNodeDegree(graph, 1)).toBe(3); // connected to 2, 3, 4
+      expect(getNodeDegree(graph, 2)).toBe(2); // connected to 1, 3
+      expect(getNodeDegree(graph, 3)).toBe(2); // connected to 1, 2
+      expect(getNodeDegree(graph, 4)).toBe(1); // connected to 1
+    });
+
+    it('should return 0 for isolated node', () => {
+      const graph = createTestGraph([1, 2, 3], [[1, 2]]);
+      expect(getNodeDegree(graph, 3)).toBe(0);
+    });
+
+    it('should handle self-loops correctly', () => {
+      const graph = createTestGraph([1, 2], [[1, 1], [1, 2]]);
+      expect(getNodeDegree(graph, 1)).toBe(2); // self-loop + edge to 2
+    });
+
+    it('should handle node not in graph', () => {
+      const graph = createTestGraph([1, 2, 3], [[1, 2]]);
+      expect(getNodeDegree(graph, 999)).toBe(0);
+    });
+
+    it('should handle empty graph', () => {
+      const graph = createTestGraph([], []);
+      expect(getNodeDegree(graph, 1)).toBe(0);
+    });
+  });
+
+  describe('getNeighbors', () => {
+    it('should return empty array for graph without edges method', () => {
+      const graph = { nodes: () => [1, 2, 3] } as any;
+      const result = getNeighbors(graph, 1);
+      expect(result).toEqual([]);
+    });
+
+    it('should return neighbors correctly', () => {
+      const graph = createTestGraph([1, 2, 3, 4], [[1, 2], [1, 3], [2, 4], [3, 4]]);
+      
+      const neighbors1 = getNeighbors(graph, 1);
+      expect(neighbors1.sort()).toEqual([2, 3]);
+      
+      const neighbors2 = getNeighbors(graph, 2);
+      expect(neighbors2.sort()).toEqual([1, 4]);
+      
+      const neighbors4 = getNeighbors(graph, 4);
+      expect(neighbors4.sort()).toEqual([2, 3]);
+    });
+
+    it('should return empty array for isolated node', () => {
+      const graph = createTestGraph([1, 2, 3], [[1, 2]]);
+      expect(getNeighbors(graph, 3)).toEqual([]);
+    });
+
+    it('should handle self-loops correctly', () => {
+      const graph = createTestGraph([1, 2], [[1, 1], [1, 2]]);
+      const neighbors = getNeighbors(graph, 1);
+      expect(neighbors.sort()).toEqual([1, 2]); // includes self and neighbor
+    });
+
+    it('should not duplicate neighbors in undirected edges', () => {
+      const graph = createTestGraph([1, 2, 3], [[1, 2], [2, 1], [1, 3]]); // bidirectional edge
+      const neighbors = getNeighbors(graph, 1);
+      expect(neighbors.sort()).toEqual([2, 3]); // should not duplicate node 2
+    });
+
+    it('should handle node not in graph', () => {
+      const graph = createTestGraph([1, 2, 3], [[1, 2]]);
+      expect(getNeighbors(graph, 999)).toEqual([]);
+    });
+
+    it('should handle empty graph', () => {
+      const graph = createTestGraph([], []);
+      expect(getNeighbors(graph, 1)).toEqual([]);
+    });
+
+    it('should work with string node IDs', () => {
+      const graph = createTestGraph(['a', 'b', 'c'], [['a', 'b'], ['b', 'c']]);
+      expect(getNeighbors(graph, 'b').sort()).toEqual(['a', 'c']);
+    });
+  });
+});

package/test/utils-index.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Tests for utils index exports
+ */
+
+import { describe, it, expect } from 'vitest';
+
+describe('Utils Index', () => {
+  it('should export all utility functions from numpy', async () => {
+    const { np } = await import('../src/utils/index');
+    expect(np).toBeDefined();
+    expect(typeof np.zeros).toBe('function');
+    expect(typeof np.ones).toBe('function');
+    expect(typeof np.linspace).toBe('function');
+    expect(typeof np.array).toBe('function');
+    expect(typeof np.repeat).toBe('function');
+    expect(typeof np.mean).toBe('function');
+    expect(typeof np.add).toBe('function');
+    expect(typeof np.subtract).toBe('function');
+    expect(typeof np.max).toBe('function');
+    expect(typeof np.min).toBe('function');
+    expect(typeof np.norm).toBe('function');
+  });
+
+  it('should export RandomNumberGenerator class', async () => {
+    const { RandomNumberGenerator } = await import('../src/utils/index');
+    expect(RandomNumberGenerator).toBeDefined();
+    expect(typeof RandomNumberGenerator).toBe('function');
+    
+    const rng = new RandomNumberGenerator(123);
+    expect(typeof rng.rand).toBe('function');
+  });
+
+  it('should export graph utility functions', async () => {
+    const { getNodesFromGraph, getEdgesFromGraph, getNodeDegree, getNeighbors } = await import('../src/utils/index');
+    expect(typeof getNodesFromGraph).toBe('function');
+    expect(typeof getEdgesFromGraph).toBe('function');
+    expect(typeof getNodeDegree).toBe('function');
+    expect(typeof getNeighbors).toBe('function');
+  });
+
+  it('should export parameter processing functions', async () => {
+    const { _processParams } = await import('../src/utils/index');
+    expect(typeof _processParams).toBe('function');
+  });
+
+  it('should export rescale functions', async () => {
+    const { rescaleLayout, rescaleLayoutDict } = await import('../src/utils/index');
+    expect(typeof rescaleLayout).toBe('function');
+    expect(typeof rescaleLayoutDict).toBe('function');
+  });
+
+  it('should allow importing everything with wildcard', async () => {
+    const utils = await import('../src/utils/index');
+    
+    // Check that key exports are available
+    expect(utils.np).toBeDefined();
+    expect(utils.RandomNumberGenerator).toBeDefined();
+    expect(utils.getNodesFromGraph).toBeDefined();
+    expect(utils._processParams).toBeDefined();
+    expect(utils.rescaleLayout).toBeDefined();
+  });
+
+  it('should work with destructured imports', async () => {
+    // Test that the typical usage patterns work
+    const { np, RandomNumberGenerator, getNodesFromGraph } = await import('../src/utils/index');
+    
+    // Quick functional test
+    expect(np.zeros(3)).toEqual([0, 0, 0]);
+    
+    const rng = new RandomNumberGenerator(42);
+    const value = rng.rand() as number;
+    expect(typeof value).toBe('number');
+    
+    const nodes = getNodesFromGraph([1, 2, 3]);
+    expect(nodes).toEqual([1, 2, 3]);
+  });
+});