@graphty/layout 1.3.2 → 1.4.0

package/src/algorithms/planarity/check.ts

@@ -10,14 +10,14 @@ import { isK5, isK33 } from "./special-graphs";
 /**
  * Check if graph is planar using a simplified version of Boyer-Myrvold algorithm.
  * Returns planarity and embedding information.
- * @param G - Graph
+ * @param _G - Graph (reserved for future use)
  * @param nodes - List of nodes
  * @param edges - List of edges
  * @param seed - Random seed for deterministic embedding generation
  * @returns Object containing isPlanar flag and embedding
  */
 export function checkPlanarity(
-    G: Graph,
+    _G: Graph,
     nodes: Node[],
     edges: Edge[],
     seed: number | null = null,

package/src/algorithms/planarity/embedding.ts

@@ -90,11 +90,11 @@ export function createTriangulationEmbedding(nodes: Node[], edges: Edge[], seed:
 /**
  * Find a simple cycle in the graph (for outer face)
  * @param nodes - List of nodes
- * @param edges - List of edges
+ * @param _edges - List of edges (reserved for future use)
  * @param adjMap - Adjacency map
  * @returns Cycle as array of nodes, or null if none found
  */
-export function findCycle(nodes: Node[], edges: Edge[], adjMap: Record<Node, Set<Node>>): Node[] | null {
+export function findCycle(nodes: Node[], _edges: Edge[], adjMap: Record<Node, Set<Node>>): Node[] | null {
     if (nodes.length === 0) {return null;}
     if (nodes.length <= 2) {return nodes;} // Not a real cycle but handle it
 
@@ -167,7 +167,7 @@ export function findCycle(nodes: Node[], edges: Edge[], adjMap: Record<Node, Set
         let current = u;
 
         while (parent[current] !== undefined && parent[current] !== v) {
-            current = parent[current]!;
+            current = parent[current] as Node;
             cycle.push(current);
         }
 

package/src/algorithms/planarity/special-graphs.ts

@@ -86,7 +86,7 @@ export function tryFindBipartitePartition(nodes: Node[], edges: Edge[]): [Node[]
     colorMap[nodes[0]] = 0;
 
     while (queue.length > 0) {
-        const node = queue.shift()!;
+        const node = queue.shift() as Node;
         const nodeColor = colorMap[node];
 
         for (const neighbor of adjList[node]) {

package/src/generators/bipartite.ts

@@ -28,7 +28,7 @@ export function bipartiteGraph(
     const random =
         seed !== undefined
             ? () => {
-                  currentSeed = (currentSeed! * 9301 + 49297) % 233280;
+                  currentSeed = ((currentSeed as number) * 9301 + 49297) % 233280;
                   return currentSeed / 233280;
               }
             : Math.random;

package/src/generators/random.ts

@@ -20,7 +20,7 @@ export function randomGraph(n: number, p: number, seed?: number): Graph {
     const random =
         seed !== undefined
             ? () => {
-                  currentSeed = (currentSeed! * 9301 + 49297) % 233280;
+                  currentSeed = ((currentSeed as number) * 9301 + 49297) % 233280;
                   return currentSeed / 233280;
               }
             : Math.random;

package/src/generators/scale-free.ts

@@ -25,7 +25,7 @@ export function scaleFreeGraph(n: number, m: number, seed?: number): Graph {
     const random =
         seed !== undefined
             ? () => {
-                  currentSeed = (currentSeed! * 9301 + 49297) % 233280;
+                  currentSeed = ((currentSeed as number) * 9301 + 49297) % 233280;
                   return currentSeed / 233280;
               }
             : Math.random;
@@ -42,7 +42,7 @@ export function scaleFreeGraph(n: number, m: number, seed?: number): Graph {
     // 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);
+        const totalDegree = degrees.reduce((sum: number, d: number) => sum + d, 0);
 
         // Choose m targets based on preferential attachment
         while (targets.size < m) {
@@ -50,7 +50,7 @@ export function scaleFreeGraph(n: number, m: number, seed?: number): Graph {
             let cumSum = 0;
 
             for (let j = 0; j < i; j++) {
-                cumSum += degrees[j];
+                cumSum += degrees[j] as number;
                 if (r <= cumSum && !targets.has(j)) {
                     targets.add(j);
                     break;

package/src/layouts/basic/random.ts

@@ -23,7 +23,7 @@ export function randomLayout(
 ): PositionMap {
     const processed = _processParams(G, center, dim);
     const nodes = getNodesFromGraph(processed.G);
-    center = processed.center;
+    ({ center } = processed);
 
     const rng = new RandomNumberGenerator(seed ?? undefined);
     const pos: PositionMap = {};

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

@@ -40,7 +40,7 @@ export function arfLayout(
         const rng = new RandomNumberGenerator(seed ?? undefined);
         const defaultPos: PositionMap = {};
         nodes.forEach((node: Node) => {
-            if (!pos![node]) {
+            if (!(pos as PositionMap)[node]) {
                 defaultPos[node] = [rng.rand() as number, rng.rand() as number];
             }
         });

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

@@ -1,5 +1,5 @@
 import type { Edge, Graph, Node, PositionMap } from "../../types";
-import { getEdgesFromGraph,getNodesFromGraph } from "../../utils/graph";
+import { getNodesFromGraph } from "../../utils/graph";
 import { _processParams } from "../../utils/params";
 import { RandomNumberGenerator } from "../../utils/random";
 import { rescaleLayout } from "../../utils/rescale";
@@ -17,7 +17,7 @@ import { rescaleLayout } from "../../utils/rescale";
  * @param nodeMass - Dictionary mapping nodes to their masses
  * @param nodeSize - Dictionary mapping nodes to their sizes
  * @param weight - Edge attribute for weight
- * @param dissuadeHubs - Whether to prevent hub nodes from clustering
+ * @param _dissuadeHubs - Whether to prevent hub nodes from clustering (unused)
  * @param linlog - Whether to use logarithmic attraction
  * @param seed - Random seed for initial positions
  * @param dim - Dimension of layout
@@ -35,7 +35,7 @@ export function forceatlas2Layout(
     nodeMass: Record<Node, number> | null = null,
     nodeSize: Record<Node, number> | null = null,
     weight: string | null = null,
-    dissuadeHubs: boolean = false,
+    _dissuadeHubs: boolean = false,
     linlog: boolean = false,
     seed: number | null = null,
     dim: number = 2,
@@ -75,8 +75,8 @@ export function forceatlas2Layout(
         }
     } else {
         // Some nodes don't have positions, initialize within the range of existing positions
-        const minPos = Array(dim).fill(Number.POSITIVE_INFINITY);
-        const maxPos = Array(dim).fill(Number.NEGATIVE_INFINITY);
+        const minPos: number[] = Array(dim).fill(Number.POSITIVE_INFINITY);
+        const maxPos: number[] = Array(dim).fill(Number.NEGATIVE_INFINITY);
 
         // Find min and max of existing positions
         for (const node in pos) {
@@ -125,17 +125,22 @@ export function forceatlas2Layout(
     // Set node masses and sizes
     for (let i = 0; i < nodes.length; i++) {
         const node = nodes[i];
-        mass[i] =
-            nodeMass && nodeMass[node] ? nodeMass[node] : Array.isArray(graph) ? 1 : getNodeDegree(graph, node) + 1;
+        if (nodeMass && nodeMass[node]) {
+            mass[i] = nodeMass[node];
+        } else if (Array.isArray(graph)) {
+            mass[i] = 1;
+        } else {
+            mass[i] = getNodeDegree(graph, node) + 1;
+        }
 
         size[i] = nodeSize && nodeSize[node] ? nodeSize[node] : 1;
     }
 
     // Create adjacency matrix
     const n = nodes.length;
-    const A = Array(n)
+    const A: number[][] = Array(n)
         .fill(0)
-        .map(() => Array(n).fill(0));
+        .map(() => Array(n).fill(0) as number[]);
 
     // Populate adjacency matrix with edge weights
     const edges = Array.isArray(graph) ? ([] as Edge[]) : graph.edges();
@@ -159,66 +164,69 @@ export function forceatlas2Layout(
     }
 
     // Initialize force arrays
-    const gravities = Array(n)
+    const gravities: number[][] = Array(n)
         .fill(0)
-        .map(() => Array(dim).fill(0));
-    const attraction = Array(n)
+        .map(() => Array(dim).fill(0) as number[]);
+    const attraction: number[][] = Array(n)
         .fill(0)
-        .map(() => Array(dim).fill(0));
-    const repulsion = Array(n)
+        .map(() => Array(dim).fill(0) as number[]);
+    const repulsion: number[][] = Array(n)
         .fill(0)
-        .map(() => Array(dim).fill(0));
+        .map(() => Array(dim).fill(0) as number[]);
 
     // Simulation parameters
     let speed = 1;
     let speedEfficiency = 1;
-    const swing = 1;
-    const traction = 1;
+    const _swing = 1; // Reserved for adaptive speed control
+    const _traction = 1; // Reserved for adaptive speed control
 
     // Helper function to estimate factor for force scaling
     function estimateFactor(
-        n: number,
-        swing: number,
-        traction: number,
-        speed: number,
-        speedEfficiency: number,
-        jitterTolerance: number,
+        nodeCount: number,
+        swingValue: number,
+        tractionValue: number,
+        currentSpeed: number,
+        currentSpeedEfficiency: number,
+        jitterToleranceParam: number,
     ): [number, number] {
+        let resultSpeed = currentSpeed;
+        let resultSpeedEfficiency = currentSpeedEfficiency;
+
         // Optimal jitter parameters
-        const optJitter = 0.05 * Math.sqrt(n);
+        const optJitter = 0.05 * Math.sqrt(nodeCount);
         const minJitter = Math.sqrt(optJitter);
         const maxJitter = 10;
         const minSpeedEfficiency = 0.05;
 
         // Estimate jitter based on current state
-        const other = Math.min(maxJitter, (optJitter * traction) / (n * n));
-        let jitter = jitterTolerance * Math.max(minJitter, other);
+        const other = Math.min(maxJitter, (optJitter * tractionValue) / (nodeCount * nodeCount));
+        let jitter = jitterToleranceParam * Math.max(minJitter, other);
 
         // Adjust speed efficiency based on swing/traction ratio
-        if (swing / traction > 2.0) {
-            if (speedEfficiency > minSpeedEfficiency) {
-                speedEfficiency *= 0.5;
+        if (swingValue / tractionValue > 2.0) {
+            if (resultSpeedEfficiency > minSpeedEfficiency) {
+                resultSpeedEfficiency *= 0.5;
             }
-            jitter = Math.max(jitter, jitterTolerance);
+            jitter = Math.max(jitter, jitterToleranceParam);
         }
 
         // Calculate target speed
-        const targetSpeed = swing === 0 ? Number.POSITIVE_INFINITY : (jitter * speedEfficiency * traction) / swing;
+        const targetSpeed = swingValue === 0 ? Number.POSITIVE_INFINITY : (jitter * resultSpeedEfficiency * tractionValue) / swingValue;
 
         // Further adjust speed efficiency
-        if (swing > jitter * traction) {
-            if (speedEfficiency > minSpeedEfficiency) {
-                speedEfficiency *= 0.7;
+        if (swingValue > jitter * tractionValue) {
+            if (resultSpeedEfficiency > minSpeedEfficiency) {
+                resultSpeedEfficiency *= 0.7;
             }
-        } else if (speed < 1000) {
-            speedEfficiency *= 1.3;
+        } else if (resultSpeed < 1000) {
+            resultSpeedEfficiency *= 1.3;
         }
 
         // Limit the speed increase
         const maxRise = 0.5;
-        speed = speed + Math.min(targetSpeed - speed, maxRise * speed);
+        resultSpeed = resultSpeed + Math.min(targetSpeed - resultSpeed, maxRise * resultSpeed);
 
-        return [speed, speedEfficiency];
+        return [resultSpeed, resultSpeedEfficiency];
     }
 
     // Main simulation loop
@@ -233,17 +241,17 @@ export function forceatlas2Layout(
         }
 
         // Compute pairwise differences and distances
-        const diff = Array(n)
+        const diff: number[][][] = Array(n)
             .fill(0)
             .map(() =>
                 Array(n)
                     .fill(0)
-                    .map(() => Array(dim).fill(0)),
+                    .map(() => Array(dim).fill(0) as number[]),
             );
 
-        const distance = Array(n)
+        const distance: number[][] = Array(n)
             .fill(0)
-            .map(() => Array(n).fill(0));
+            .map(() => Array(n).fill(0) as number[]);
 
         for (let i = 0; i < n; i++) {
             for (let j = 0; j < n; j++) {
@@ -253,7 +261,7 @@ export function forceatlas2Layout(
                     diff[i][j][d] = posArray[i][d] - posArray[j][d];
                 }
 
-                distance[i][j] = Math.sqrt(diff[i][j].reduce((sum, d) => sum + d * d, 0));
+                distance[i][j] = Math.sqrt(diff[i][j].reduce((sum: number, d: number) => sum + d * d, 0));
                 // Prevent division by zero
                 if (distance[i][j] < 0.01) {distance[i][j] = 0.01;}
             }
@@ -324,7 +332,7 @@ export function forceatlas2Layout(
 
         // Calculate gravity forces
         // First find the center of mass
-        const centerOfMass = Array(dim).fill(0);
+        const centerOfMass: number[] = Array(dim).fill(0);
         for (let i = 0; i < n; i++) {
             for (let d = 0; d < dim; d++) {
                 centerOfMass[d] += posArray[i][d] / n;
@@ -344,7 +352,7 @@ export function forceatlas2Layout(
                 }
             } else {
                 // Regular gravity model
-                const dist = Math.sqrt(posCentered.reduce((sum, val) => sum + val * val, 0));
+                const dist = Math.sqrt(posCentered.reduce((sum: number, val: number) => sum + val * val, 0));
 
                 if (dist > 0.01) {
                     for (let d = 0; d < dim; d++) {
@@ -369,13 +377,13 @@ export function forceatlas2Layout(
 
             // Calculate swing and traction for this node
             const oldPos = [...posArray[i]];
-            const newPos = oldPos.map((p, d) => p + update[i][d]);
+            const newPos = oldPos.map((p, d) => p + (update[i][d] as number));
 
             const swingVector = oldPos.map((p, d) => p - newPos[d]);
             const tractionVector = oldPos.map((p, d) => p + newPos[d]);
 
-            const swingMagnitude = Math.sqrt(swingVector.reduce((sum, val) => sum + val * val, 0));
-            const tractionMagnitude = Math.sqrt(tractionVector.reduce((sum, val) => sum + val * val, 0));
+            const swingMagnitude = Math.sqrt(swingVector.reduce((sum: number, val: number) => sum + val * val, 0));
+            const tractionMagnitude = Math.sqrt(tractionVector.reduce((sum: number, val: number) => sum + val * val, 0));
 
             totalSwing += mass[i] * swingMagnitude;
             totalTraction += 0.5 * mass[i] * tractionMagnitude;
@@ -399,7 +407,7 @@ export function forceatlas2Layout(
 
             if (adjustSizes) {
                 // Calculate displacement magnitude
-                const df = Math.sqrt(update[i].reduce((sum, val) => sum + val * val, 0));
+                const df = Math.sqrt(update[i].reduce((sum: number, val: number) => sum + val * val, 0));
                 const swinging = mass[i] * df;
 
                 // Determine scaling factor with size adjustments
@@ -407,7 +415,7 @@ export function forceatlas2Layout(
                 factor = Math.min(factor * df, 10) / df;
             } else {
                 // Standard scaling factor
-                const swinging = mass[i] * Math.sqrt(update[i].reduce((sum, val) => sum + val * val, 0));
+                const swinging = (mass[i] as number) * Math.sqrt(update[i].reduce((sum: number, val: number) => sum + val * val, 0));
                 factor = speed / (1 + Math.sqrt(speed * swinging));
             }
 

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

@@ -2,7 +2,7 @@
  * Fruchterman-Reingold force-directed layout algorithm
  */
 
-import { Edge, Graph, Node, PositionMap } from "../../types";
+import type { Graph, Node, PositionMap } from "../../types";
 import { getEdgesFromGraph,getNodesFromGraph } from "../../utils/graph";
 import { _processParams } from "../../utils/params";
 import { RandomNumberGenerator } from "../../utils/random";
@@ -34,7 +34,7 @@ export function fruchtermanReingoldLayout(
 ): PositionMap {
     const processed = _processParams(G, center, dim);
     const graph = processed.G;
-    center = processed.center;
+    ({ center } = processed);
 
     const nodes = getNodesFromGraph(graph);
     const edges = getEdgesFromGraph(graph);

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

@@ -1,5 +1,4 @@
-import type { DistanceMap } from "../../algorithms/optimization";
-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";
@@ -28,7 +27,7 @@ export function kamadaKawaiLayout(
 ): PositionMap {
     const processed = _processParams(G, center, dim);
     const graph = processed.G;
-    center = processed.center;
+    ({ center } = processed);
 
     const nodes = getNodesFromGraph(graph);
 

package/src/layouts/geometric/circular.ts

@@ -28,7 +28,7 @@ export function circularLayout(
 
     const processed = _processParams(G, center, dim);
     const nodes = getNodesFromGraph(processed.G);
-    center = processed.center;
+    ({ center } = processed);
 
     const pos: PositionMap = {};
 

package/src/layouts/geometric/shell.ts

@@ -29,7 +29,7 @@ export function shellLayout(
 
     const processed = _processParams(G, center, dim);
     const nodes = getNodesFromGraph(processed.G);
-    center = processed.center;
+    ({ center } = processed);
 
     const pos: PositionMap = {};
 

package/src/layouts/geometric/spiral.ts

@@ -2,7 +2,7 @@
  * Spiral layout algorithm
  */
 
-import { Graph, Node, PositionMap } from "../../types";
+import type { Graph, PositionMap } from "../../types";
 import { getNodesFromGraph } from "../../utils/graph";
 import { _processParams } from "../../utils/params";
 import { rescaleLayout } from "../../utils/rescale";
@@ -31,7 +31,7 @@ export function spiralLayout(
 
     const processed = _processParams(G, center || [0, 0], dim);
     const nodes = getNodesFromGraph(processed.G);
-    center = processed.center;
+    ({ center } = processed);
 
     const pos: PositionMap = {};
 
@@ -74,7 +74,7 @@ export function spiralLayout(
     }
 
     // Rescale positions and add center offset
-    const scaledPositions = rescaleLayout(posArray as any, scale) as any;
+    const scaledPositions = rescaleLayout(posArray, scale) as number[][];
     for (let i = 0; i < scaledPositions.length; i++) {
         scaledPositions[i][0] += center[0];
         scaledPositions[i][1] += center[1];

package/src/layouts/hierarchical/bfs.ts

@@ -1,4 +1,4 @@
-import type { Edge, Graph, Node, PositionMap } from "../../types";
+import type { Graph, Node, PositionMap } from "../../types";
 import { getNeighbors,getNodesFromGraph } from "../../utils/graph";
 import { _processParams } from "../../utils/params";
 import { multipartiteLayout } from "./multipartite";
@@ -27,7 +27,7 @@ export function bfsLayout(
     }
 
     const graph = processed.G;
-    center = processed.center;
+    ({ center } = processed);
 
     const allNodes = getNodesFromGraph(graph);
 

package/src/layouts/hierarchical/bipartite.ts

@@ -31,7 +31,7 @@ export function bipartiteLayout(
 
     const processed = _processParams(G, center || [0, 0], 2);
     const graph = processed.G;
-    center = processed.center;
+    ({ center } = processed);
 
     const allNodes = getNodesFromGraph(graph);
 

package/src/layouts/hierarchical/multipartite.ts

@@ -1,5 +1,5 @@
 import type { Graph, Node, PositionMap } from "../../types";
-import { getNeighbors,getNodesFromGraph } from "../../utils/graph";
+import { getNodesFromGraph } from "../../utils/graph";
 import { _processParams } from "../../utils/params";
 import { rescaleLayout } from "../../utils/rescale";
 
@@ -25,7 +25,7 @@ export function multipartiteLayout(
 
     const processed = _processParams(G, center || [0, 0], 2);
     const graph = processed.G;
-    center = processed.center;
+    ({ center } = processed);
 
     const allNodes = getNodesFromGraph(graph);
 
@@ -58,7 +58,7 @@ export function multipartiteLayout(
     let pos: PositionMap = {};
 
     // Process each layer
-    Object.entries(layers).forEach(([layer, nodes], layerIdx) => {
+    Object.entries(layers).forEach(([_layer, nodes], layerIdx) => {
         const layerNodes = Array.isArray(nodes) ? nodes : [nodes];
         const layerSize = layerNodes.length;
 

package/src/layouts/specialized/planar.ts

@@ -3,7 +3,7 @@
  */
 
 import { checkPlanarity, combinatorialEmbeddingToPos } from "../../algorithms/planarity";
-import { Edge, Graph, Node, PositionMap } from "../../types";
+import type { Graph, PositionMap } from "../../types";
 import { getEdgesFromGraph,getNodesFromGraph } from "../../utils/graph";
 import { _processParams } from "../../utils/params";
 import { rescaleLayout } from "../../utils/rescale";
@@ -36,7 +36,7 @@ export function planarLayout(
     }
 
     const graph = processed.G;
-    center = processed.center;
+    ({ center } = processed);
 
     const nodes = getNodesFromGraph(graph);
     const edges = getEdgesFromGraph(graph);

package/src/layouts/specialized/spectral.ts

@@ -2,7 +2,7 @@
  * Spectral layout algorithm using eigenvectors of the graph Laplacian
  */
 
-import { Edge, Graph, Node, PositionMap } from "../../types";
+import type { Graph, Node, PositionMap } from "../../types";
 import { getEdgesFromGraph,getNodesFromGraph } from "../../utils/graph";
 import { _processParams } from "../../utils/params";
 import { rescaleLayout } from "../../utils/rescale";
@@ -23,7 +23,7 @@ export function spectralLayout(
 ): PositionMap {
     const processed = _processParams(G, center, dim);
     const graph = processed.G;
-    center = processed.center;
+    ({ center } = processed);
 
     const nodes = getNodesFromGraph(graph);
 
@@ -47,9 +47,9 @@ export function spectralLayout(
         nodeIndices[node] = i;
     });
 
-    const A = Array(N)
+    const A: number[][] = Array(N)
         .fill(0)
-        .map(() => Array(N).fill(0));
+        .map(() => Array(N).fill(0) as number[]);
     const edges = getEdgesFromGraph(graph);
 
     for (const [source, target] of edges) {
@@ -60,12 +60,12 @@ export function spectralLayout(
     }
 
     // Create Laplacian matrix: L = D - A where D is degree matrix
-    const L = Array(N)
+    const L: number[][] = Array(N)
         .fill(0)
-        .map(() => Array(N).fill(0));
+        .map(() => Array(N).fill(0) as number[]);
     for (let i = 0; i < N; i++) {
         // Compute degree (sum of row)
-        L[i][i] = A[i].reduce((sum, val) => sum + val, 0);
+        L[i][i] = A[i].reduce((sum: number, val: number) => sum + val, 0);
         for (let j = 0; j < N; j++) {
             L[i][j] -= A[i][j];
         }
@@ -95,7 +95,7 @@ export function spectralLayout(
         // This is a simplification of the actual algorithm
         for (let iter = 0; iter < 100; iter++) {
             // Apply Laplacian
-            const newVec = Array(N).fill(0);
+            const newVec: number[] = Array(N).fill(0);
             for (let i = 0; i < N; i++) {
                 for (let j = 0; j < N; j++) {
                     newVec[i] += L[i][j] * vector[j];
@@ -103,13 +103,13 @@ export function spectralLayout(
             }
 
             // Orthogonalize against the constant vector (eigenvector with eigenvalue 0)
-            const mean = newVec.reduce((acc, val) => acc + val, 0) / N;
+            const mean = newVec.reduce((acc: number, val: number) => acc + val, 0) / N;
             newVec.forEach((val, idx, arr) => {
                 arr[idx] = val - mean;
             });
 
             // Normalize
-            const newNorm = Math.sqrt(newVec.reduce((acc, val) => acc + val * val, 0));
+            const newNorm = Math.sqrt(newVec.reduce((acc: number, val: number) => acc + val * val, 0));
             if (newNorm < 1e-10) {continue;} // Skip if vector is close to zero
 
             vector = newVec.map((val) => val / newNorm);
@@ -129,7 +129,7 @@ export function spectralLayout(
     }
 
     // Rescale and create position dictionary
-    const scaledPositions = rescaleLayout(positions as any, scale);
+    const scaledPositions = rescaleLayout(positions, scale);
     const pos: PositionMap = {};
     nodes.forEach((node: Node, i: number) => {
         pos[node] = (scaledPositions as number[][])[i].map((val: number, j: number) => val + center[j]);

package/src/types/graph.ts

@@ -9,5 +9,5 @@ export type Edge = [Node, Node];
 export type Graph = {
     nodes: () => Node[];
     edges: () => Edge[];
-    getEdgeData?: (source: Node, target: Node, attr: string) => any;
+    getEdgeData?: (source: Node, target: Node, attr: string) => number | undefined;
 };

package/src/utils/numpy.ts

@@ -4,28 +4,28 @@
  */
 
 export const np = {
-    zeros: function (shape: number | number[]): number | number[] | number[][] | any[] {
+    zeros: function (shape: number | number[]): number[] | number[][] {
         if (typeof shape === "number") {
-            return Array(shape).fill(0);
+            return Array(shape).fill(0) as number[];
         }
         if (shape.length === 1) {
-            return Array(shape[0]).fill(0);
+            return Array(shape[0]).fill(0) as number[];
         }
         return Array(shape[0])
             .fill(0)
-            .map(() => this.zeros(shape.slice(1)));
+            .map(() => this.zeros(shape.slice(1))) as number[][];
     },
 
-    ones: function (shape: number | number[]): number | any[] {
+    ones: function (shape: number | number[]): number[] | number[][] {
         if (typeof shape === "number") {
-            return Array(shape).fill(1);
+            return Array(shape).fill(1) as number[];
         }
         if (shape.length === 1) {
-            return Array(shape[0]).fill(1);
+            return Array(shape[0]).fill(1) as number[];
         }
         return Array(shape[0])
             .fill(1)
-            .map(() => this.ones(shape.slice(1)));
+            .map(() => this.ones(shape.slice(1))) as number[][];
     },
 
     linspace: function (start: number, stop: number, num: number): number[] {
@@ -36,12 +36,12 @@ export const np = {
         return Array.from({ length: num }, (_, i) => start + i * step);
     },
 
-    array: function (arr: any): any[] {
+    array: function (arr: number | number[]): number[] {
         return Array.isArray(arr) ? [...arr] : [arr];
     },
 
-    repeat: function (a: any, repeats: number): any[] {
-        const result: any[] = [];
+    repeat: function (a: number | number[], repeats: number): number[] {
+        const result: number[] = [];
         for (let i = 0; i < repeats; i++) {
             result.push(...np.array(a));
         }