refactor(algorithms): convert path-planting functions to arrow functions

Convert path-planting functions from function declarations to arrow functions:
- plantGroundTruthPaths (export)
- signalStrengthToMI (internal)
- pathId (internal)

Also reorder imports to group type imports together and add JSDoc @param
tags for better documentation.

Author: Mearman

packages/algorithms/src/evaluation/path-planting/heterogeneous-planting.ts

@@ -4,10 +4,10 @@
  * For graphs with multiple node types (e.g., OpenAlex with Works, Authors, Institutions)
  */
 
-import type { Edge, Node } from '../../types/graph';
 import { Graph } from '../../graph/graph';
 import type { Path } from '../../types/algorithm-results';
-import { plantGroundTruthPaths, type PlantedPathConfig } from './path-generator';
+import type { Edge, Node } from '../../types/graph';
+import { type PlantedPathConfig,plantGroundTruthPaths } from './path-generator';
 
 /**
  * Extended configuration for heterogeneous graphs.
@@ -22,16 +22,17 @@ export interface HeterogeneousPathConfig<N extends Node, E extends Edge> extends
 
 /**
  * Type-safe node type check.
+ * @param node
  */
-function getNodeType<N extends Node>(node: N): string {
+const getNodeType = <N extends Node>(node: N): string => {
   if ('type' in node && typeof node.type === 'string') {
     return node.type;
   }
   if ('entityType' in node && typeof node.entityType === 'string') {
     return node.entityType;
   }
   return 'unknown';
-}
+};
 
 /**
  * Plant paths in heterogeneous graphs respecting entity type constraints.
@@ -45,11 +46,7 @@ function getNodeType<N extends Node>(node: N): string {
  * @param config - Planting configuration
  * @returns Graph with planted heterogeneous paths
  */
-export function plantHeterogeneousPaths<N extends Node, E extends Edge>(
-  graph: Graph<N, E>,
-  pathTemplate: string[],
-  config: HeterogeneousPathConfig<N, E>
-) {
+export const plantHeterogeneousPaths = <N extends Node, E extends Edge>(graph: Graph<N, E>, pathTemplate: string[], config: HeterogeneousPathConfig<N, E>) => {
   // Validate path template
   if (pathTemplate.length < 2) {
     throw new Error('Path template must have at least 2 node types');
@@ -91,22 +88,21 @@ export function plantHeterogeneousPaths<N extends Node, E extends Edge>(
   // Note: The path generator doesn't enforce intermediate node types,
   // so this is a best-effort implementation
   return plantGroundTruthPaths(graph, extendedConfig);
-}
+};
 
 /**
  * Filter nodes by entity type.
+ * @param nodes
+ * @param entityType
  */
-export function filterNodesByType<N extends Node>(nodes: N[], entityType: string): N[] {
-  return nodes.filter(node => getNodeType(node) === entityType);
-}
+export const filterNodesByType = <N extends Node>(nodes: N[], entityType: string): N[] => nodes.filter(node => getNodeType(node) === entityType);
 
 /**
  * Check if a path follows a type template.
+ * @param path
+ * @param template
  */
-export function pathFollowsTemplate<N extends Node, E extends Edge>(
-  path: Path<N, E>,
-  template: string[]
-): boolean {
+export const pathFollowsTemplate = <N extends Node, E extends Edge>(path: Path<N, E>, template: string[]): boolean => {
   if (path.nodes.length !== template.length) {
     return false;
   }
@@ -119,4 +115,4 @@ export function pathFollowsTemplate<N extends Node, E extends Edge>(
   }
 
   return true;
-}
+};

packages/algorithms/src/evaluation/path-planting/noise-generator.ts

@@ -2,9 +2,9 @@
  * Noise path generation for evaluation
  */
 
-import type { Edge, Node } from '../../types/graph';
 import { Graph } from '../../graph/graph';
 import type { Path } from '../../types/algorithm-results';
+import type { Edge, Node } from '../../types/graph';
 
 /**
  * Add noise paths to make ground truth detection harder.
@@ -20,12 +20,7 @@ import type { Path } from '../../types/algorithm-results';
  * @param seed - Random seed
  * @returns Graph with added noise paths
  */
-export function addNoisePaths<N extends Node, E extends Edge>(
-  graph: Graph<N, E>,
-  groundTruth: Path<N, E>[],
-  numNoisePaths: number,
-  seed?: number
-): Graph<N, E> {
+export const addNoisePaths = <N extends Node, E extends Edge>(graph: Graph<N, E>, groundTruth: Path<N, E>[], numNoisePaths: number, seed?: number): Graph<N, E> => {
   if (numNoisePaths <= 0) {
     return graph;
   }
@@ -89,20 +84,19 @@ export function addNoisePaths<N extends Node, E extends Edge>(
   }
 
   return graph;
-}
+};
 
 /**
  * Create a simple path between two nodes.
+ * @param graph
+ * @param source
+ * @param target
+ * @param length
+ * @param rng
+ * @param nodeOffset
+ * @param edgeOffset
  */
-function createSimplePath<N extends Node, E extends Edge>(
-  graph: Graph<N, E>,
-  source: string,
-  target: string,
-  length: number,
-  rng: SeededRandom,
-  nodeOffset: number,
-  edgeOffset: number
-): Path<N, E> {
+const createSimplePath = <N extends Node, E extends Edge>(graph: Graph<N, E>, source: string, target: string, length: number, rng: SeededRandom, nodeOffset: number, edgeOffset: number): Path<N, E> => {
   const nodes: N[] = [];
   const edges: E[] = [];
 
@@ -159,14 +153,13 @@ function createSimplePath<N extends Node, E extends Edge>(
     edges,
     totalWeight: edges.reduce((sum, e) => sum + (e.weight ?? 0), 0),
   };
-}
+};
 
 /**
  * Generate path signature for deduplication.
+ * @param path
  */
-function pathSignature<N extends Node, E extends Edge>(path: Path<N, E>): string {
-  return path.edges.map(e => `${e.source}-${e.target}`).join('|');
-}
+const pathSignature = <N extends Node, E extends Edge>(path: Path<N, E>): string => path.edges.map(e => `${e.source}-${e.target}`).join('|');
 
 /**
  * Seeded random number generator.
@@ -188,6 +181,8 @@ class SeededRandom {
 
   /**
    * Generate random integer in [min, max].
+   * @param min
+   * @param max
    */
   nextInt(min: number, max: number): number {
     return Math.floor(this.nextDouble() * (max - min + 1)) + min;

packages/algorithms/src/evaluation/path-planting/path-generator.ts

@@ -2,10 +2,10 @@
  * Ground truth path planting for evaluation
  */
 
-import type { Edge, Node } from '../../types/graph';
 import { Graph } from '../../graph/graph';
-import type { Path } from '../../types/algorithm-results';
 import type { RankedPath } from '../../pathfinding/path-ranking';
+import type { Path } from '../../types/algorithm-results';
+import type { Edge, Node } from '../../types/graph';
 
 /**
  * Configuration for planted path generation.
@@ -82,13 +82,16 @@ class SeededRandom {
 
   /**
    * Generate random integer in [min, max].
+   * @param min
+   * @param max
    */
   nextInt(min: number, max: number): number {
     return Math.floor(this.next() * (max - min + 1)) + min;
   }
 
   /**
    * Shuffle array in place.
+   * @param array
    */
   shuffle<T>(array: T[]): T[] {
     const result = [...array];
@@ -102,8 +105,9 @@ class SeededRandom {
 
 /**
  * Convert signal strength to MI value range.
+ * @param signalStrength
  */
-function signalStrengthToMI(signalStrength: 'weak' | 'medium' | 'strong'): { min: number; max: number } {
+const signalStrengthToMI = (signalStrength: 'weak' | 'medium' | 'strong'): { min: number; max: number } => {
   switch (signalStrength) {
     case 'weak':
       return { min: 0.1, max: 0.3 }; // Low MI, hard to distinguish
@@ -112,7 +116,7 @@ function signalStrengthToMI(signalStrength: 'weak' | 'medium' | 'strong'): { min
     case 'strong':
       return { min: 0.8, max: 1.0 }; // High MI, easy to distinguish
   }
-}
+};
 
 /**
  * Plant ground truth paths in a graph for evaluation.
@@ -128,10 +132,7 @@ function signalStrengthToMI(signalStrength: 'weak' | 'medium' | 'strong'): { min
  * @param config - Planting configuration
  * @returns Graph with planted paths and ground truth
  */
-export function plantGroundTruthPaths<N extends Node, E extends Edge>(
-  baseGraph: Graph<N, E>,
-  config: PlantedPathConfig<N, E>
-): PlantedPathResult<N, E> {
+export const plantGroundTruthPaths = <N extends Node, E extends Edge>(baseGraph: Graph<N, E>, config: PlantedPathConfig<N, E>): PlantedPathResult<N, E> => {
   const rng = new SeededRandom(config.seed);
   const miRange = signalStrengthToMI(config.signalStrength);
 
@@ -256,11 +257,10 @@ export function plantGroundTruthPaths<N extends Node, E extends Edge>(
       avgPathMI: totalMI / plantedPaths.length,
     },
   };
-}
+};
 
 /**
  * Generate stable path ID for relevance scoring.
+ * @param path
  */
-function pathId<N extends Node, E extends Edge>(path: Path<N, E>): string {
-  return path.nodes.map(n => n.id).join('→');
-}
+const pathId = <N extends Node, E extends Edge>(path: Path<N, E>): string => path.nodes.map(n => n.id).join('→');