@atlaspack/graph 3.2.1-dev.3520 → 3.2.1-dev.3566

package/lib/AdjacencyList.js

@@ -450,16 +450,36 @@ class AdjacencyList {
     }
     return nodes;
   }
-  forEachNodeIdConnectedFromReverse(from, fn) {
+  forEachNodeIdConnectedFromReverse(from, fn, type = _Graph.ALL_EDGE_TYPES) {
+    const matches = node => type === _Graph.ALL_EDGE_TYPES || type === this.#nodes.typeOf(node);
     let node = this.#nodes.head(from);
     while (node !== null) {
-      let edge = this.#nodes.lastOut(node);
-      while (edge !== null) {
-        let to = this.#edges.to(edge);
-        if (fn(to)) {
-          return;
+      if (matches(node)) {
+        let edge = this.#nodes.lastOut(node);
+        while (edge !== null) {
+          let to = this.#edges.to(edge);
+          if (fn(to)) {
+            return;
+          }
+          edge = this.#edges.prevOut(edge);
+        }
+      }
+      node = this.#nodes.next(node);
+    }
+  }
+  forEachNodeIdConnectedTo(to, fn, type = 1) {
+    const matches = node => type === _Graph.ALL_EDGE_TYPES || type === this.#nodes.typeOf(node);
+    let node = this.#nodes.head(to);
+    while (node !== null) {
+      if (matches(node)) {
+        let edge = this.#nodes.firstIn(node);
+        while (edge !== null) {
+          let from = this.#edges.from(edge);
+          if (fn(from)) {
+            return;
+          }
+          edge = this.#edges.nextIn(edge);
         }
-        edge = this.#edges.prevOut(edge);
       }
       node = this.#nodes.next(node);
     }
@@ -813,6 +833,7 @@ class SharedTypeMap {
   // Trick Flow into believing in `Symbol.iterator`.
   // See https://github.com/facebook/flow/issues/1163#issuecomment-353523840
   /*:: @@iterator(): Iterator<TAddress> { return ({}: any); } */
+
   // $FlowFixMe[unsupported-syntax]
   *[Symbol.iterator]() {
     let max = this.count;

package/lib/Graph.js

@@ -31,7 +31,10 @@ class Graph {
     this.nodes = (opts === null || opts === void 0 ? void 0 : opts.nodes) || [];
     this.setRootNodeId(opts === null || opts === void 0 ? void 0 : opts.rootNodeId);
     let adjacencyList = opts === null || opts === void 0 ? void 0 : opts.adjacencyList;
-    this.adjacencyList = adjacencyList ? _AdjacencyList.default.deserialize(adjacencyList) : new _AdjacencyList.default();
+    let initialCapacity = opts === null || opts === void 0 ? void 0 : opts.initialCapacity;
+    this.adjacencyList = adjacencyList ? _AdjacencyList.default.deserialize(adjacencyList) : new _AdjacencyList.default(typeof initialCapacity === 'number' ? {
+      initialCapacity
+    } : undefined);
   }
   setRootNodeId(id) {
     this.rootNodeId = id;
@@ -82,6 +85,17 @@ class Graph {
   hasEdge(from, to, type = 1) {
     return this.adjacencyList.hasEdge(from, to, type);
   }
+  forEachNodeIdConnectedTo(to, fn, type = ALL_EDGE_TYPES) {
+    this._assertHasNodeId(to);
+    this.adjacencyList.forEachNodeIdConnectedTo(to, fn, type);
+  }
+  forEachNodeIdConnectedFrom(from, fn, type = ALL_EDGE_TYPES) {
+    this._assertHasNodeId(from);
+    this.adjacencyList.forEachNodeIdConnectedFromReverse(from, id => {
+      fn(id);
+      return false;
+    }, type);
+  }
   getNodeIdsConnectedTo(nodeId, type = 1) {
     this._assertHasNodeId(nodeId);
     return this.adjacencyList.getNodeIdsConnectedTo(nodeId, type);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/graph",
-  "version": "3.2.1-dev.3520+8a5346e28",
+  "version": "3.2.1-dev.3566+facdfb05f",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -16,8 +16,8 @@
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/feature-flags": "2.12.1-dev.3520+8a5346e28",
+    "@atlaspack/feature-flags": "2.12.1-dev.3566+facdfb05f",
     "nullthrows": "^1.1.1"
   },
-  "gitHead": "8a5346e28c1bb3b9cd40f1c4e77c66dd6666f1e4"
+  "gitHead": "facdfb05f693e50037a82a4afa101adf093fd8c9"
 }

package/src/AdjacencyList.js

@@ -598,16 +598,46 @@ export default class AdjacencyList<TEdgeType: number = 1> {
   forEachNodeIdConnectedFromReverse(
     from: NodeId,
     fn: (nodeId: NodeId) => boolean,
+    type: AllEdgeTypes | TEdgeType | NullEdgeType = ALL_EDGE_TYPES,
   ) {
+    const matches = (node) =>
+      type === ALL_EDGE_TYPES || type === this.#nodes.typeOf(node);
+
     let node = this.#nodes.head(from);
     while (node !== null) {
-      let edge = this.#nodes.lastOut(node);
-      while (edge !== null) {
-        let to = this.#edges.to(edge);
-        if (fn(to)) {
-          return;
+      if (matches(node)) {
+        let edge = this.#nodes.lastOut(node);
+        while (edge !== null) {
+          let to = this.#edges.to(edge);
+          if (fn(to)) {
+            return;
+          }
+          edge = this.#edges.prevOut(edge);
+        }
+      }
+      node = this.#nodes.next(node);
+    }
+  }
+
+  forEachNodeIdConnectedTo(
+    to: NodeId,
+    fn: (nodeId: NodeId) => boolean | void,
+    type: AllEdgeTypes | TEdgeType | NullEdgeType = 1,
+  ) {
+    const matches = (node) =>
+      type === ALL_EDGE_TYPES || type === this.#nodes.typeOf(node);
+
+    let node = this.#nodes.head(to);
+    while (node !== null) {
+      if (matches(node)) {
+        let edge = this.#nodes.firstIn(node);
+        while (edge !== null) {
+          let from = this.#edges.from(edge);
+          if (fn(from)) {
+            return;
+          }
+          edge = this.#edges.nextIn(edge);
         }
-        edge = this.#edges.prevOut(edge);
       }
       node = this.#nodes.next(node);
     }
@@ -973,6 +1003,7 @@ export class SharedTypeMap<TItemType, THash, TAddress: number>
   // Trick Flow into believing in `Symbol.iterator`.
   // See https://github.com/facebook/flow/issues/1163#issuecomment-353523840
   /*:: @@iterator(): Iterator<TAddress> { return ({}: any); } */
+
   // $FlowFixMe[unsupported-syntax]
   *[Symbol.iterator](): Iterator<TAddress> {
     let max = this.count;
@@ -1086,6 +1117,7 @@ export class NodeTypeMap<TEdgeType> extends SharedTypeMap<
   get nextId(): NodeId {
     return toNodeId(this.data[NodeTypeMap.#NEXT_ID]);
   }
+
   set nextId(nextId: NodeId) {
     this.data[NodeTypeMap.#NEXT_ID] = fromNodeId(nextId);
   }

package/src/Graph.js

@@ -17,6 +17,7 @@ export type GraphOpts<TNode, TEdgeType: number = 1> = {|
   nodes?: Array<TNode | null>,
   adjacencyList?: SerializedAdjacencyList<TEdgeType>,
   rootNodeId?: ?NodeId,
+  initialCapacity?: number,
 |};
 
 export type SerializedGraph<TNode, TEdgeType: number = 1> = {|
@@ -84,9 +85,12 @@ export default class Graph<TNode, TEdgeType: number = 1> {
     this.setRootNodeId(opts?.rootNodeId);
 
     let adjacencyList = opts?.adjacencyList;
+    let initialCapacity = opts?.initialCapacity;
     this.adjacencyList = adjacencyList
       ? AdjacencyList.deserialize(adjacencyList)
-      : new AdjacencyList<TEdgeType>();
+      : new AdjacencyList<TEdgeType>(
+          typeof initialCapacity === 'number' ? {initialCapacity} : undefined,
+        );
   }
 
   setRootNodeId(id: ?NodeId) {
@@ -159,6 +163,33 @@ export default class Graph<TNode, TEdgeType: number = 1> {
     return this.adjacencyList.hasEdge(from, to, type);
   }
 
+  forEachNodeIdConnectedTo(
+    to: NodeId,
+    fn: (nodeId: NodeId) => boolean | void,
+    type: AllEdgeTypes | TEdgeType | NullEdgeType = ALL_EDGE_TYPES,
+  ) {
+    this._assertHasNodeId(to);
+
+    this.adjacencyList.forEachNodeIdConnectedTo(to, fn, type);
+  }
+
+  forEachNodeIdConnectedFrom(
+    from: NodeId,
+    fn: (nodeId: NodeId) => void,
+    type: AllEdgeTypes | TEdgeType | NullEdgeType = ALL_EDGE_TYPES,
+  ) {
+    this._assertHasNodeId(from);
+
+    this.adjacencyList.forEachNodeIdConnectedFromReverse(
+      from,
+      (id) => {
+        fn(id);
+        return false;
+      },
+      type,
+    );
+  }
+
   getNodeIdsConnectedTo(
     nodeId: NodeId,
     type:

package/test/AdjacencyList.test.js

@@ -1,11 +1,13 @@
 // @flow strict-local
 
 import assert from 'assert';
+import sinon from 'sinon';
 import path from 'path';
 import {Worker} from 'worker_threads';
 
 import AdjacencyList, {NodeTypeMap, EdgeTypeMap} from '../src/AdjacencyList';
 import {toNodeId} from '../src/types';
+import {ALL_EDGE_TYPES} from '../src/Graph';
 
 describe('AdjacencyList', () => {
   it('constructor should initialize an empty graph', () => {
@@ -272,6 +274,218 @@ describe('AdjacencyList', () => {
     assert.ok(graph.hasEdge(b, c, [2, 3]));
   });
 
+  describe('forEachNodeIdConnectedTo', () => {
+    it('iterates no edges if there are none', () => {
+      const graph = new AdjacencyList();
+      const a = graph.addNode();
+      const b = graph.addNode();
+      const c = graph.addNode();
+
+      graph.addEdge(a, b);
+      graph.addEdge(c, b);
+
+      const callback = sinon.spy(() => {});
+      graph.forEachNodeIdConnectedTo(c, callback);
+
+      assert.equal(callback.callCount, 0);
+    });
+
+    it('iterates incoming edges to a node', () => {
+      const graph = new AdjacencyList();
+      const a = graph.addNode();
+      const b = graph.addNode();
+      const c = graph.addNode();
+
+      graph.addEdge(a, b);
+      graph.addEdge(c, b);
+
+      const nodeIds = [];
+      graph.forEachNodeIdConnectedTo(b, (id) => {
+        nodeIds.push(id);
+      });
+
+      assert.deepEqual(nodeIds, [a, c]);
+    });
+
+    it('stops traversal if the return value is true', () => {
+      const graph = new AdjacencyList();
+      const a = graph.addNode();
+      const b = graph.addNode();
+      const c = graph.addNode();
+      const d = graph.addNode();
+
+      graph.addEdge(a, d);
+      graph.addEdge(b, d);
+      graph.addEdge(c, d);
+
+      const nodeIds = [];
+      graph.forEachNodeIdConnectedTo(d, (nodeId) => {
+        nodeIds.push(nodeId);
+        return true;
+      });
+
+      assert.deepEqual(nodeIds, [a]);
+    });
+
+    it('terminates if the graph is cyclic', () => {
+      const graph = new AdjacencyList();
+      const a = graph.addNode();
+      const b = graph.addNode();
+      const c = graph.addNode();
+
+      graph.addEdge(a, b);
+      graph.addEdge(c, b);
+      graph.addEdge(b, b);
+
+      const nodeIds = [];
+      graph.forEachNodeIdConnectedTo(b, (id) => {
+        nodeIds.push(id);
+      });
+
+      assert.deepEqual(nodeIds, [a, c, b]);
+    });
+
+    it('respects the edge type', () => {
+      const graph = new AdjacencyList();
+      const a = graph.addNode();
+      const b = graph.addNode();
+      const c = graph.addNode();
+
+      graph.addEdge(a, b);
+      graph.addEdge(c, b, 2);
+
+      const nodeIds = [];
+      graph.forEachNodeIdConnectedTo(b, (id) => {
+        nodeIds.push(id);
+      });
+
+      assert.deepEqual(nodeIds, [a]);
+    });
+
+    it('iterates all edges if all edge type is provided', () => {
+      const graph = new AdjacencyList();
+      const a = graph.addNode();
+      const b = graph.addNode();
+      const c = graph.addNode();
+
+      graph.addEdge(a, b);
+      graph.addEdge(c, b, 2);
+
+      const nodeIds = [];
+      graph.forEachNodeIdConnectedTo(
+        b,
+        (id) => {
+          nodeIds.push(id);
+        },
+        ALL_EDGE_TYPES,
+      );
+
+      assert.deepEqual(nodeIds, [a, c]);
+    });
+  });
+
+  describe('forEachNodeIdConnectedFromReverse', () => {
+    it('iterates no edges if there are none', () => {
+      const graph = new AdjacencyList();
+      const a = graph.addNode();
+      const b = graph.addNode();
+      const c = graph.addNode();
+
+      graph.addEdge(a, b);
+      graph.addEdge(b, c);
+
+      const callback = sinon.spy(() => false);
+      graph.forEachNodeIdConnectedFromReverse(c, callback);
+
+      assert.equal(callback.callCount, 0);
+    });
+
+    it('iterates outgoing edges from a node', () => {
+      const graph = new AdjacencyList();
+      const a = graph.addNode();
+      const b = graph.addNode();
+      const c = graph.addNode();
+      const d = graph.addNode();
+      const e = graph.addNode();
+
+      graph.addEdge(a, b, 1);
+      graph.addEdge(a, c, 2);
+      graph.addEdge(b, d, 3);
+      graph.addEdge(c, e, 4);
+
+      const nodeIds = [];
+      graph.forEachNodeIdConnectedFromReverse(a, (nodeId) => {
+        nodeIds.push(nodeId);
+        return false;
+      });
+
+      assert.deepEqual(nodeIds, [b, c]);
+    });
+
+    it('terminates if the graph is cyclic', () => {
+      const graph = new AdjacencyList();
+      const a = graph.addNode();
+      const b = graph.addNode();
+      const c = graph.addNode();
+
+      graph.addEdge(a, b);
+      graph.addEdge(a, c);
+      graph.addEdge(a, a);
+
+      const nodeIds = [];
+      graph.forEachNodeIdConnectedFromReverse(a, (nodeId) => {
+        nodeIds.push(nodeId);
+        return false;
+      });
+
+      assert.deepEqual(nodeIds, [a, c, b]);
+    });
+
+    it('stops traversal if the return value is true', () => {
+      const graph = new AdjacencyList();
+      const a = graph.addNode();
+      const b = graph.addNode();
+      const c = graph.addNode();
+      const d = graph.addNode();
+
+      graph.addEdge(a, b);
+      graph.addEdge(a, c);
+      graph.addEdge(a, d);
+
+      const nodeIds = [];
+      graph.forEachNodeIdConnectedFromReverse(a, (nodeId) => {
+        nodeIds.push(nodeId);
+        return true;
+      });
+
+      assert.deepEqual(nodeIds, [d]);
+    });
+
+    it('filters edges by type', () => {
+      const graph = new AdjacencyList();
+      const a = graph.addNode();
+      const b = graph.addNode();
+      const c = graph.addNode();
+      const d = graph.addNode();
+
+      graph.addEdge(a, b, 2);
+      graph.addEdge(a, c, 2);
+      graph.addEdge(a, d);
+
+      const nodeIds = [];
+      graph.forEachNodeIdConnectedFromReverse(
+        a,
+        (nodeId) => {
+          nodeIds.push(nodeId);
+          return false;
+        },
+        2,
+      );
+
+      assert.deepEqual(nodeIds, [c, b]);
+    });
+  });
+
   describe('deserialize', function () {
     this.timeout(10000);
 

package/test/Graph.test.js

@@ -556,4 +556,52 @@ describe('Graph', () => {
       });
     });
   });
+
+  describe('forEachNodeConnectedTo', () => {
+    it('calls the callback for each node connected to the given node', () => {
+      const graph = new Graph();
+      const a = graph.addNode('0');
+      const b = graph.addNode('1');
+      const c = graph.addNode('2');
+      const d = graph.addNode('3');
+      graph.addNode('disconnected-1');
+      graph.addNode('disconnected-2');
+      graph.addEdge(a, b);
+      graph.addEdge(b, c);
+      graph.addEdge(b, d);
+      graph.addEdge(a, c);
+      graph.addEdge(c, d);
+
+      const order = [];
+      graph.forEachNodeIdConnectedTo(d, (node) => {
+        order.push(node);
+      });
+
+      assert.deepEqual(order, [b, c]);
+    });
+  });
+
+  describe('forEachNodeConnectedFrom', () => {
+    it('calls the callback for each node connected from the given node', () => {
+      const graph = new Graph();
+      const a = graph.addNode('0');
+      const b = graph.addNode('1');
+      const c = graph.addNode('2');
+      const d = graph.addNode('3');
+      graph.addNode('disconnected-1');
+      graph.addNode('disconnected-2');
+      graph.addEdge(a, b);
+      graph.addEdge(b, c);
+      graph.addEdge(b, d);
+      graph.addEdge(a, c);
+      graph.addEdge(c, d);
+
+      const order = [];
+      graph.forEachNodeIdConnectedFrom(a, (node) => {
+        order.push(node);
+      });
+
+      assert.deepEqual(order, [c, b]);
+    });
+  });
 });