@graphty/layout 1.2.3 → 1.2.4

package/test/utils-graph.test.ts

@@ -1,155 +0,0 @@
-/**
- * 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

@@ -1,77 +0,0 @@
-/**
- * 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]);
-  });
-});

package/test/utils-numpy.test.ts

@@ -1,272 +0,0 @@
-/**
- * Tests for NumPy-like utility functions
- */
-
-import { describe, it, expect } from 'vitest';
-import { np } from '../src/utils/numpy';
-
-describe('NumPy Utils', () => {
-  describe('zeros', () => {
-    it('should create 1D array of zeros', () => {
-      expect(np.zeros(3)).toEqual([0, 0, 0]);
-      expect(np.zeros(0)).toEqual([]);
-      expect(np.zeros(1)).toEqual([0]);
-    });
-
-    it('should create 1D array from single-element array shape', () => {
-      expect(np.zeros([3])).toEqual([0, 0, 0]);
-      expect(np.zeros([0])).toEqual([]);
-    });
-
-    it('should create 2D array of zeros', () => {
-      expect(np.zeros([2, 3])).toEqual([[0, 0, 0], [0, 0, 0]]);
-      expect(np.zeros([3, 2])).toEqual([[0, 0], [0, 0], [0, 0]]);
-      expect(np.zeros([1, 1])).toEqual([[0]]);
-    });
-
-    it('should create 3D array of zeros', () => {
-      const result = np.zeros([2, 2, 2]) as number[][][];
-      expect(result).toEqual([
-        [[0, 0], [0, 0]],
-        [[0, 0], [0, 0]]
-      ]);
-    });
-  });
-
-  describe('ones', () => {
-    it('should create 1D array of ones', () => {
-      expect(np.ones(3)).toEqual([1, 1, 1]);
-      expect(np.ones(0)).toEqual([]);
-      expect(np.ones(1)).toEqual([1]);
-    });
-
-    it('should create 1D array from single-element array shape', () => {
-      expect(np.ones([3])).toEqual([1, 1, 1]);
-      expect(np.ones([0])).toEqual([]);
-    });
-
-    it('should create 2D array of ones', () => {
-      expect(np.ones([2, 3])).toEqual([[1, 1, 1], [1, 1, 1]]);
-      expect(np.ones([3, 2])).toEqual([[1, 1], [1, 1], [1, 1]]);
-    });
-
-    it('should create 3D array of ones', () => {
-      const result = np.ones([2, 1, 2]) as number[][][];
-      expect(result).toEqual([
-        [[1, 1]],
-        [[1, 1]]
-      ]);
-    });
-  });
-
-  describe('linspace', () => {
-    it('should create linearly spaced array', () => {
-      const result = np.linspace(0, 1, 5);
-      expect(result).toHaveLength(5);
-      expect(result[0]).toBe(0);
-      expect(result[4]).toBe(1);
-      expect(result[2]).toBeCloseTo(0.5);
-    });
-
-    it('should handle single point', () => {
-      expect(np.linspace(5, 5, 1)).toEqual([5]);
-    });
-
-    it('should handle reverse range', () => {
-      const result = np.linspace(10, 0, 3);
-      expect(result).toEqual([10, 5, 0]);
-    });
-
-    it('should handle negative numbers', () => {
-      const result = np.linspace(-1, 1, 3);
-      expect(result).toEqual([-1, 0, 1]);
-    });
-  });
-
-  describe('array', () => {
-    it('should copy arrays', () => {
-      const input = [1, 2, 3];
-      const result = np.array(input);
-      expect(result).toEqual(input);
-      expect(result).not.toBe(input); // different reference
-    });
-
-    it('should wrap non-arrays', () => {
-      expect(np.array(5)).toEqual([5]);
-      expect(np.array('hello')).toEqual(['hello']);
-      expect(np.array(null)).toEqual([null]);
-    });
-
-    it('should handle nested arrays', () => {
-      const input = [[1, 2], [3, 4]];
-      const result = np.array(input);
-      expect(result).toEqual(input);
-      expect(result).not.toBe(input);
-    });
-  });
-
-  describe('repeat', () => {
-    it('should repeat single values', () => {
-      expect(np.repeat(5, 3)).toEqual([5, 5, 5]);
-      expect(np.repeat('a', 2)).toEqual(['a', 'a']);
-    });
-
-    it('should repeat arrays', () => {
-      expect(np.repeat([1, 2], 2)).toEqual([1, 2, 1, 2]);
-      expect(np.repeat([1, 2, 3], 3)).toEqual([1, 2, 3, 1, 2, 3, 1, 2, 3]);
-    });
-
-    it('should handle zero repeats', () => {
-      expect(np.repeat(5, 0)).toEqual([]);
-      expect(np.repeat([1, 2], 0)).toEqual([]);
-    });
-
-    it('should handle single repeat', () => {
-      expect(np.repeat([1, 2, 3], 1)).toEqual([1, 2, 3]);
-    });
-  });
-
-  describe('mean', () => {
-    it('should calculate mean of 1D array', () => {
-      expect(np.mean([1, 2, 3, 4, 5])).toBe(3);
-      expect(np.mean([2, 4, 6])).toBe(4);
-      expect(np.mean([10])).toBe(10);
-    });
-
-    it('should calculate mean of 2D array (flatten)', () => {
-      expect(np.mean([[1, 2], [3, 4]])).toBe(2.5);
-      expect(np.mean([[1, 1], [1, 1]])).toBe(1);
-    });
-
-    it('should calculate mean along axis 0 (columns)', () => {
-      const result = np.mean([[1, 2, 3], [4, 5, 6]], 0) as number[];
-      expect(result).toEqual([2.5, 3.5, 4.5]);
-    });
-
-    it('should calculate mean along axis 1 (rows)', () => {
-      const result = np.mean([[1, 2, 3], [4, 5, 6]], 1) as number[];
-      expect(result).toEqual([2, 5]);
-    });
-
-    it('should handle empty arrays', () => {
-      expect(np.mean([])).toBeNaN();
-    });
-
-    it('should handle nested empty arrays', () => {
-      expect(np.mean([[], []])).toBeNaN();
-    });
-  });
-
-  describe('add', () => {
-    it('should add two numbers', () => {
-      expect(np.add(5, 3)).toBe(8);
-      expect(np.add(-2, 7)).toBe(5);
-    });
-
-    it('should add number to array', () => {
-      expect(np.add(2, [1, 2, 3])).toEqual([3, 4, 5]);
-      expect(np.add([1, 2, 3], 10)).toEqual([11, 12, 13]);
-    });
-
-    it('should add two arrays element-wise', () => {
-      expect(np.add([1, 2, 3], [4, 5, 6])).toEqual([5, 7, 9]);
-      expect(np.add([10, 20], [1, 2])).toEqual([11, 22]);
-    });
-
-    it('should handle negative numbers', () => {
-      expect(np.add([-1, -2], [1, 2])).toEqual([0, 0]);
-      expect(np.add(5, [-3, -7])).toEqual([2, -2]);
-    });
-  });
-
-  describe('subtract', () => {
-    it('should subtract two numbers', () => {
-      expect(np.subtract(8, 3)).toBe(5);
-      expect(np.subtract(-2, 7)).toBe(-9);
-    });
-
-    it('should subtract number from array', () => {
-      expect(np.subtract(10, [1, 2, 3])).toEqual([9, 8, 7]);
-      expect(np.subtract([5, 6, 7], 2)).toEqual([3, 4, 5]);
-    });
-
-    it('should subtract two arrays element-wise', () => {
-      expect(np.subtract([5, 7, 9], [1, 2, 3])).toEqual([4, 5, 6]);
-      expect(np.subtract([10, 20], [3, 5])).toEqual([7, 15]);
-    });
-
-    it('should handle negative results', () => {
-      expect(np.subtract([1, 2], [5, 7])).toEqual([-4, -5]);
-    });
-  });
-
-  describe('max', () => {
-    it('should return single number as-is', () => {
-      expect(np.max(42)).toBe(42);
-      expect(np.max(-5)).toBe(-5);
-    });
-
-    it('should find max in 1D array', () => {
-      expect(np.max([1, 5, 3, 9, 2])).toBe(9);
-      expect(np.max([-10, -5, -20])).toBe(-5);
-      expect(np.max([7])).toBe(7);
-    });
-
-    it('should find max in nested arrays', () => {
-      expect(np.max([[1, 2], [3, 4]])).toBe(4);
-      expect(np.max([[10, 5], [2, 8], [1, 12]])).toBe(12);
-    });
-
-    it('should handle deeply nested arrays', () => {
-      expect(np.max([[[1, 2]], [[3, 4]]])).toBe(4);
-    });
-  });
-
-  describe('min', () => {
-    it('should return single number as-is', () => {
-      expect(np.min(42)).toBe(42);
-      expect(np.min(-5)).toBe(-5);
-    });
-
-    it('should find min in 1D array', () => {
-      expect(np.min([1, 5, 3, 9, 2])).toBe(1);
-      expect(np.min([-10, -5, -20])).toBe(-20);
-      expect(np.min([7])).toBe(7);
-    });
-
-    it('should find min in nested arrays', () => {
-      expect(np.min([[1, 2], [3, 4]])).toBe(1);
-      expect(np.min([[10, 5], [2, 8], [1, 12]])).toBe(1);
-    });
-
-    it('should handle deeply nested arrays', () => {
-      expect(np.min([[[1, 2]], [[3, 4]]])).toBe(1);
-    });
-  });
-
-  describe('norm', () => {
-    it('should calculate Euclidean norm', () => {
-      expect(np.norm([3, 4])).toBe(5); // 3-4-5 triangle
-      expect(np.norm([1, 0])).toBe(1);
-      expect(np.norm([0, 0])).toBe(0);
-    });
-
-    it('should handle negative values', () => {
-      expect(np.norm([-3, 4])).toBe(5);
-      expect(np.norm([-3, -4])).toBe(5);
-    });
-
-    it('should handle single element', () => {
-      expect(np.norm([5])).toBe(5);
-      expect(np.norm([-7])).toBe(7);
-    });
-
-    it('should handle higher dimensions', () => {
-      expect(np.norm([1, 2, 2])).toBeCloseTo(3); // sqrt(1 + 4 + 4) = 3
-    });
-
-    it('should handle empty array', () => {
-      expect(np.norm([])).toBe(0);
-    });
-  });
-});

package/test/utils-params.test.ts

@@ -1,99 +0,0 @@
-/**
- * Tests for parameter processing utilities
- */
-
-import { describe, it, expect } from 'vitest';
-import { _processParams } from '../src/utils/params';
-import { createTestGraph } from './test-utils';
-
-describe('Parameter Utils', () => {
-  describe('_processParams', () => {
-    it('should use default center when null', () => {
-      const graph = createTestGraph([1, 2], [[1, 2]]);
-      const result = _processParams(graph, null, 2);
-      
-      expect(result.G).toBe(graph);
-      expect(result.center).toEqual([0, 0]);
-    });
-
-    it('should use default center when undefined', () => {
-      const nodes = [1, 2, 3];
-      const result = _processParams(nodes, null, 3);
-      
-      expect(result.G).toBe(nodes);
-      expect(result.center).toEqual([0, 0, 0]);
-    });
-
-    it('should preserve provided center', () => {
-      const graph = createTestGraph([1, 2], [[1, 2]]);
-      const center = [5, 10];
-      const result = _processParams(graph, center, 2);
-      
-      expect(result.G).toBe(graph);
-      expect(result.center).toBe(center);
-    });
-
-    it('should work with array of nodes', () => {
-      const nodes = ['a', 'b', 'c'];
-      const center = [1, 2, 3];
-      const result = _processParams(nodes, center, 3);
-      
-      expect(result.G).toBe(nodes);
-      expect(result.center).toBe(center);
-    });
-
-    it('should throw error when center length does not match dimension', () => {
-      const graph = createTestGraph([1, 2], [[1, 2]]);
-      
-      expect(() => {
-        _processParams(graph, [1, 2], 3); // center has 2 elements, dim is 3
-      }).toThrow('length of center coordinates must match dimension of layout');
-    });
-
-    it('should throw error when center is too long', () => {
-      const nodes = [1, 2, 3];
-      
-      expect(() => {
-        _processParams(nodes, [1, 2, 3, 4], 2); // center has 4 elements, dim is 2
-      }).toThrow('length of center coordinates must match dimension of layout');
-    });
-
-    it('should throw error when center is too short', () => {
-      const graph = createTestGraph([1], []);
-      
-      expect(() => {
-        _processParams(graph, [1], 3); // center has 1 element, dim is 3
-      }).toThrow('length of center coordinates must match dimension of layout');
-    });
-
-    it('should work with 1D layouts', () => {
-      const graph = createTestGraph([1, 2], [[1, 2]]);
-      const result = _processParams(graph, [5], 1);
-      
-      expect(result.center).toEqual([5]);
-    });
-
-    it('should work with high-dimensional layouts', () => {
-      const nodes = [1, 2, 3];
-      const center = [1, 2, 3, 4, 5];
-      const result = _processParams(nodes, center, 5);
-      
-      expect(result.center).toBe(center);
-    });
-
-    it('should handle empty center array for 0D (edge case)', () => {
-      const graph = createTestGraph([1], []);
-      const result = _processParams(graph, [], 0);
-      
-      expect(result.center).toEqual([]);
-    });
-
-    it('should create correct default center for various dimensions', () => {
-      const graph = createTestGraph([1], []);
-      
-      expect(_processParams(graph, null, 1).center).toEqual([0]);
-      expect(_processParams(graph, null, 4).center).toEqual([0, 0, 0, 0]);
-      expect(_processParams(graph, null, 0).center).toEqual([]);
-    });
-  });
-});