feat: change addEdge signature to accept an object as a 3rd argument.

Author: JesusTheHun

src/Graph.spec-d.ts

@@ -38,11 +38,14 @@ describe('graph types', () => {
   it('should require edge properties if LinkProps is defined', () => {
     const g = new Graph<string, { type: string }>();
 
-    g.addEdge('a', 'b', undefined, { type: 'foo' });
-    g.addEdge('a', 'b', 1, { type: 'foo' });
+    g.addEdge('a', 'b', { props: { type: 'foo' } });
+    g.addEdge('a', 'b', { weight: 1, props: { type: 'foo' } });
 
     // @ts-expect-error
     g.addEdge('a', 'b', 1);
+
+    // @ts-expect-error
+    g.addEdge('a', 'b', { weight: 1 });
   });
 
   it('should not allow edge properties if LinkProps is never', () => {

src/Graph.ts

@@ -116,14 +116,25 @@ export class Graph<Node = string, LinkProps = never> {
    * Adds an edge from the `source` node to `target` node.
    * This method will create the nodes if they were not already added.
    */
-  addEdge(
-    source: Node,
-    target: Node,
-    ...opts: [LinkProps] extends [never]
-      ? [weight?: EdgeWeight]
-      : [weight: EdgeWeight | undefined, linkProps: LinkProps]
-  ): this {
-    const [weight, linkProps] = opts;
+  addEdge(source: Node, target: Node, ...args: AddEdgeArgs<LinkProps>): this {
+    let weight: number | undefined;
+    let linkProps: LinkProps | undefined;
+
+    const firstArg = args[0];
+
+    if (typeof firstArg === 'number') {
+      weight = firstArg;
+    }
+
+    if (typeof firstArg === 'object') {
+      weight = firstArg.weight;
+
+      if (firstArg)
+        linkProps = Object.prototype.hasOwnProperty.call(firstArg, 'props')
+          ? (firstArg as { props: LinkProps }).props
+          : undefined;
+    }
+
     this.addNode(source);
     this.addNode(target);
     const adjacentNodes = this.adjacent(source);
@@ -162,3 +173,7 @@ export class Graph<Node = string, LinkProps = never> {
     return this.edges.get(source)?.has(target) ?? false;
   }
 }
+
+type AddEdgeArgs<LinkProps> = [LinkProps] extends [never]
+  ? [weight?: EdgeWeight] | [opts?: { weight?: EdgeWeight }]
+  : [opts: { weight?: EdgeWeight; props: LinkProps }];

src/algorithms/depthFirstSearch/depthFirstSearch.spec.ts

@@ -6,10 +6,10 @@ describe('depthFirstSearch', () => {
   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' }>();
 
-    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' });
+    graph.addEdge('a', 'b', { props: { type: 'foo' } });
+    graph.addEdge('b', 'c', { props: { type: 'bar' } });
+    graph.addEdge('b', 'd', { props: { type: 'bar' } });
+    graph.addEdge('b', 'e', { props: { type: 'foo' } });
 
     const nodes = depthFirstSearch(graph, {
       shouldFollow: ({ source, target, graph }) =>

src/algorithms/topologicalSort/topologicalSort.spec.ts

@@ -46,13 +46,21 @@ describe('topologicalSort', () => {
   });
 
   it('Should compute topological sort tricky case.', function () {
-    const graph = new Graph(); //      a
-    //     / \
-    graph.addEdge('a', 'b'); //    b   |
-    graph.addEdge('a', 'd'); //    |   d
-    graph.addEdge('b', 'c'); //    c   |
-    graph.addEdge('d', 'e'); //     \ /
-    graph.addEdge('c', 'e'); //      e
+    //     a
+    //    / \
+    //   b   |
+    //   |   d
+    //   c   |
+    //    \ /
+    //     e
+
+    const graph = new Graph();
+
+    graph.addEdge('a', 'b');
+    graph.addEdge('a', 'd');
+    graph.addEdge('b', 'c');
+    graph.addEdge('d', 'e');
+    graph.addEdge('c', 'e');
 
     const sorted = topologicalSort(graph, {
       sourceNodes: ['a'],
@@ -74,9 +82,9 @@ describe('topologicalSort', () => {
   it('Should exclude source nodes with a cycle.', function () {
     const graph = new Graph<string, { type: string }>();
     graph
-      .addEdge('a', 'b', undefined, { type: 'foo' })
-      .addEdge('b', 'c', undefined, { type: 'foo' })
-      .addEdge('c', 'a', undefined, { type: 'bar' });
+      .addEdge('a', 'b', { props: { type: 'foo' } })
+      .addEdge('b', 'c', { props: { type: 'foo' } })
+      .addEdge('c', 'a', { props: { type: 'bar' } });
 
     const sorted = topologicalSort(graph, {
       sourceNodes: ['a'],

src/utils/hasCycle.spec.ts

@@ -45,10 +45,10 @@ describe('hasCycle', () => {
 
   it('should not detect the cycle when the traversing is stopped by the shouldFollow option.', function () {
     const graph = new Graph<string, string>();
-    graph.addEdge('a', 'b', undefined, 'foo');
-    graph.addEdge('b', 'c', undefined, 'foo');
-    graph.addEdge('c', 'd', undefined, 'foo');
-    graph.addEdge('d', 'a', undefined, 'bar');
+    graph.addEdge('a', 'b', { props: 'foo' });
+    graph.addEdge('b', 'c', { props: 'foo' });
+    graph.addEdge('c', 'd', { props: 'foo' });
+    graph.addEdge('d', 'a', { props: 'bar' });
 
     expect(
       hasCycle(graph, {

src/utils/serializeGraph.spec.ts

@@ -18,7 +18,7 @@ describe('serializeGraph', () => {
     const nodeB = { title: 'b' };
 
     const graph = new Graph<{ title: string }, { type: string }>();
-    graph.addEdge(nodeA, nodeB, undefined, { type: 'foo' });
+    graph.addEdge(nodeA, nodeB, { props: { type: 'foo' } });
 
     const serialized = serializeGraph(graph);