feat: allow conditional traversal during depthFirstSearch algorithm

Author: JesusTheHun

src/algorithms/depthFirstSearch/depthFirstSearch.spec.ts

@@ -3,23 +3,21 @@ import { Graph } from '../../Graph.js';
 import { depthFirstSearch } from './index.js';
 
 describe('depthFirstSearch', () => {
-  it.todo(
-    'Should return the nodes connected to the source node with the correct type of edge.',
-    function () {
-      const graph = new Graph<string, { type: 'follow' | 'stop' }>();
+  it('Should return the nodes connected to the source node with the correct type of edge.', function () {
+    const graph = new Graph<string, { type: 'foo' | 'bar' }>();
 
-      // Shoes depend on socks.
-      // Socks need to be put on before shoes.
-      graph.addEdge('a', 'b', undefined, { type: 'follow' });
+    graph.addEdge('a', 'b', undefined, { type: 'foo' });
+    graph.addEdge('b', 'c', undefined, { type: 'bar' });
+    graph.addEdge('b', 'd', undefined, { type: 'bar' });
+    graph.addEdge('b', 'e', undefined, { type: 'foo' });
 
-      const nodes = depthFirstSearch(graph, {
-        visit: (source, target, graph) =>
-          graph.getEdgeProperties(source, target).type === 'follow',
-      });
+    const nodes = depthFirstSearch(graph, {
+      shouldFollow: (source, target, graph) =>
+        graph.getEdgeProperties(source, target).type === 'foo',
+    });
 
-      // expect(sorted.length).toEqual(8);
-      expect(nodes).toContain('socks');
-      expect(nodes).toContain('shoes');
-    },
-  );
+    expect(nodes).toContain('a');
+    expect(nodes).toContain('b');
+    expect(nodes).toContain('e');
+  });
 });

src/algorithms/depthFirstSearch/depthFirstVisit.ts

@@ -1,6 +1,6 @@
 import { CycleError } from '../../CycleError.js';
 import { Graph } from '../../Graph.js';
-import { Edge, NoInfer } from '../../types.js';
+import { NoInfer } from '../../types.js';
 import { DepthFirstSearchOptions } from './types.js';
 
 export function depthFirstVisit<Node, LinkProps>(
@@ -9,9 +9,9 @@ export function depthFirstVisit<Node, LinkProps>(
   visited: Set<NoInfer<Node>>,
   visiting: Set<NoInfer<Node>>,
   node: NoInfer<Node>,
-  opts: Pick<DepthFirstSearchOptions<Node, LinkProps>, 'errorOnCycle' | 'visit'>,
+  opts: Pick<DepthFirstSearchOptions<Node, LinkProps>, 'errorOnCycle' | 'shouldFollow'>,
 ) {
-  const { errorOnCycle = false, visit } = opts;
+  const { errorOnCycle = false, shouldFollow } = opts;
 
   if (visiting.has(node) && errorOnCycle) {
     throw new CycleError('Cycle found');
@@ -22,9 +22,8 @@ export function depthFirstVisit<Node, LinkProps>(
     visiting.add(node);
 
     graph.adjacent(node)?.forEach((n) => {
-      // TODO
-      // const shouldVisit = visit === undefined || (visit && visit(node, n, graph));
-      // if (!shouldVisit) return;
+      const follow = shouldFollow === undefined || shouldFollow(node, n, graph);
+      if (!follow) return;
 
       depthFirstVisit(graph, nodeList, visited, visiting, n, opts);
     });

src/algorithms/depthFirstSearch/types.ts

@@ -27,7 +27,7 @@ export type DepthFirstSearchOptions<Node, LinkProps> = {
    * @param graph the graph instance being explored
    * @returns boolean
    */
-  visit?: (
+  shouldFollow?: (
     source: NoInfer<Node>,
     target: NoInfer<Node>,
     graph: Graph<Node, LinkProps>,