@parcel/graph 3.2.1-nightly.3141 → 3.3.0

package/lib/AdjacencyList.js

@@ -21,7 +21,7 @@ function _nullthrows() {
 var _sharedBuffer = require("./shared-buffer");
 var _types = require("./types");
 var _Graph = require("./Graph");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /** The address of the node in the nodes map. */
 /** The address of the edge in the edges map. */
 // eslint-disable-next-line no-unused-vars
@@ -89,7 +89,6 @@ const MAX_LINK_TRIES = 3;
 class AdjacencyList {
   #nodes /*: NodeTypeMap<TEdgeType | NullEdgeType> */;
   #edges /*: EdgeTypeMap<TEdgeType | NullEdgeType> */;
-
   #params /*: AdjacencyListParams */;
 
   /**
@@ -240,7 +239,7 @@ class AdjacencyList {
    *
    * Note that this method does not increment the node count
    * (that only happens in `addEdge`), it _may_ preemptively resize
-   * the nodes array if it is at capacity, under the asumption that
+   * the nodes array if it is at capacity, under the assumption that
    * at least 1 edge to or from this new node will be added.
    *
    * Returns the id of the added node.

package/lib/ContentGraph.js

@@ -12,7 +12,7 @@ function _nullthrows() {
   };
   return data;
 }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class ContentGraph extends _Graph.default {
   constructor(opts) {
     if (opts) {

package/lib/Graph.js

@@ -15,8 +15,17 @@ function _nullthrows() {
   };
   return data;
 }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const ALL_EDGE_TYPES = exports.ALL_EDGE_TYPES = -1;
+
+/**
+ * Internal type used for queue iterative DFS implementation.
+ */
+
+/**
+ * Options for DFS traversal.
+ */
+
 class Graph {
   constructor(opts) {
     this.nodes = (opts === null || opts === void 0 ? void 0 : opts.nodes) || [];
@@ -197,7 +206,7 @@ class Graph {
     });
   }
   dfsFast(visit, startNodeId) {
-    let traversalStartNode = (0, _nullthrows().default)(startNodeId !== null && startNodeId !== void 0 ? startNodeId : this.rootNodeId, 'A start node is required to traverse');
+    let traversalStartNode = (0, _nullthrows().default)(startNodeId ?? this.rootNodeId, 'A start node is required to traverse');
     this._assertHasNodeId(traversalStartNode);
     let visited;
     if (!this._visited || this._visited.capacity < this.nodes.length) {
@@ -259,7 +268,7 @@ class Graph {
 
   // A post-order implementation of dfsFast
   postOrderDfsFast(visit, startNodeId) {
-    let traversalStartNode = (0, _nullthrows().default)(startNodeId !== null && startNodeId !== void 0 ? startNodeId : this.rootNodeId, 'A start node is required to traverse');
+    let traversalStartNode = (0, _nullthrows().default)(startNodeId ?? this.rootNodeId, 'A start node is required to traverse');
     this._assertHasNodeId(traversalStartNode);
     let visited;
     if (!this._visited || this._visited.capacity < this.nodes.length) {
@@ -301,12 +310,18 @@ class Graph {
     }
     this._visited = visited;
   }
+
+  /**
+   * Iterative implementation of DFS that supports all use-cases.
+   *
+   * This replaces `dfs` and will replace `dfsFast`.
+   */
   dfs({
     visit,
     startNodeId,
     getChildren
   }) {
-    let traversalStartNode = (0, _nullthrows().default)(startNodeId !== null && startNodeId !== void 0 ? startNodeId : this.rootNodeId, 'A start node is required to traverse');
+    let traversalStartNode = (0, _nullthrows().default)(startNodeId ?? this.rootNodeId, 'A start node is required to traverse');
     this._assertHasNodeId(traversalStartNode);
     let visited;
     if (!this._visited || this._visited.capacity < this.nodes.length) {
@@ -328,53 +343,76 @@ class Graph {
         stopped = true;
       }
     };
-    let walk = (nodeId, context) => {
-      if (!this.hasNode(nodeId)) return;
-      visited.add(nodeId);
-      skipped = false;
-      let enter = typeof visit === 'function' ? visit : visit.enter;
-      if (enter) {
-        let newContext = enter(nodeId, context, actions);
+    const queue = [{
+      nodeId: traversalStartNode,
+      context: null
+    }];
+    const enter = typeof visit === 'function' ? visit : visit.enter;
+    while (queue.length !== 0) {
+      const command = queue.pop();
+      if (command.exit != null) {
+        let {
+          nodeId,
+          context,
+          exit
+        } = command;
+        let newContext = exit(nodeId, command.context, actions);
         if (typeof newContext !== 'undefined') {
           // $FlowFixMe[reassign-const]
           context = newContext;
         }
-      }
-      if (skipped) {
-        return;
-      }
-      if (stopped) {
-        return context;
-      }
-      for (let child of getChildren(nodeId)) {
-        if (visited.has(child)) {
+        if (skipped) {
           continue;
         }
-        visited.add(child);
-        let result = walk(child, context);
         if (stopped) {
-          return result;
+          this._visited = visited;
+          return context;
         }
-      }
-      if (typeof visit !== 'function' && visit.exit &&
-      // Make sure the graph still has the node: it may have been removed between enter and exit
-      this.hasNode(nodeId)) {
-        let newContext = visit.exit(nodeId, context, actions);
-        if (typeof newContext !== 'undefined') {
-          // $FlowFixMe[reassign-const]
-          context = newContext;
+      } else {
+        let {
+          nodeId,
+          context
+        } = command;
+        if (!this.hasNode(nodeId) || visited.has(nodeId)) continue;
+        visited.add(nodeId);
+        skipped = false;
+        if (enter) {
+          let newContext = enter(nodeId, context, actions);
+          if (typeof newContext !== 'undefined') {
+            // $FlowFixMe[reassign-const]
+            context = newContext;
+          }
+        }
+        if (skipped) {
+          continue;
+        }
+        if (stopped) {
+          this._visited = visited;
+          return context;
+        }
+        if (typeof visit !== 'function' && visit.exit) {
+          queue.push({
+            nodeId,
+            exit: visit.exit,
+            context
+          });
+        }
+
+        // TODO turn into generator function
+        const children = getChildren(nodeId);
+        for (let i = children.length - 1; i > -1; i -= 1) {
+          const child = children[i];
+          if (visited.has(child)) {
+            continue;
+          }
+          queue.push({
+            nodeId: child,
+            context
+          });
         }
       }
-      if (skipped) {
-        return;
-      }
-      if (stopped) {
-        return context;
-      }
-    };
-    let result = walk(traversalStartNode);
+    }
     this._visited = visited;
-    return result;
   }
   bfs(visit) {
     let rootNodeId = (0, _nullthrows().default)(this.rootNodeId, 'A root node is required to traverse');

package/lib/index.js

@@ -49,6 +49,6 @@ var _types = require("./types");
 var _Graph = _interopRequireWildcard(require("./Graph"));
 var _ContentGraph = _interopRequireDefault(require("./ContentGraph"));
 var _BitSet = require("./BitSet");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/graph",
-  "version": "3.2.1-nightly.3141+4042e306a",
+  "version": "3.3.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
   "publishConfig": {
@@ -17,10 +17,11 @@
   "main": "lib/index.js",
   "source": "src/index.js",
   "engines": {
-    "node": ">= 12.0.0"
+    "node": ">= 16.0.0"
   },
   "dependencies": {
+    "@parcel/feature-flags": "2.13.0",
     "nullthrows": "^1.1.1"
   },
-  "gitHead": "4042e306aef005f9bf407a189681b4049599719d"
+  "gitHead": "a53f8f3ba1025c7ea8653e9719e0a61ef9717079"
 }

package/src/AdjacencyList.js

@@ -30,7 +30,7 @@ export type AdjacencyListOptions<TEdgeType> = {|
   minGrowFactor?: number,
   /** The size after which to grow the capacity by the minimum factor. */
   peakCapacity?: number,
-  /** The percentage of deleted edges above which the capcity should shink. */
+  /** The percentage of deleted edges above which the capacity should shrink. */
   unloadFactor?: number,
   /** The amount by which to shrink the capacity. */
   shrinkFactor?: number,
@@ -328,7 +328,7 @@ export default class AdjacencyList<TEdgeType: number = 1> {
    *
    * Note that this method does not increment the node count
    * (that only happens in `addEdge`), it _may_ preemptively resize
-   * the nodes array if it is at capacity, under the asumption that
+   * the nodes array if it is at capacity, under the assumption that
    * at least 1 edge to or from this new node will be added.
    *
    * Returns the id of the added node.

package/src/Graph.js

@@ -28,6 +28,51 @@ export type SerializedGraph<TNode, TEdgeType: number = 1> = {|
 export type AllEdgeTypes = -1;
 export const ALL_EDGE_TYPES: AllEdgeTypes = -1;
 
+type DFSCommandVisit<TContext> = {|
+  nodeId: NodeId,
+  context: TContext | null,
+|};
+
+type DFSCommandExit<TContext> = {|
+  nodeId: NodeId,
+  exit: GraphTraversalCallback<NodeId, TContext>,
+  context: TContext | null,
+|};
+
+/**
+ * Internal type used for queue iterative DFS implementation.
+ */
+type DFSCommand<TContext> =
+  | DFSCommandVisit<TContext>
+  | DFSCommandExit<TContext>;
+
+/**
+ * Options for DFS traversal.
+ */
+export type DFSParams<TContext> = {|
+  visit: GraphVisitor<NodeId, TContext>,
+  /**
+   * Custom function to get next entries to visit.
+   *
+   * This can be a performance bottleneck as arrays are created on every node visit.
+   *
+   * @deprecated This will be replaced by a static `traversalType` set of orders in the future
+   *
+   * Currently, this is only used in 3 ways:
+   *
+   * - Traversing down the tree (normal DFS)
+   * - Traversing up the tree (ancestors)
+   * - Filtered version of traversal; which does not need to exist at the DFS level as the visitor
+   *   can handle filtering
+   * - Sorted traversal of BundleGraph entries, which does not have a clear use-case, but may
+   *   not be safe to remove
+   *
+   * Only due to the latter we aren't replacing this.
+   */
+  getChildren: (nodeId: NodeId) => Array<NodeId>,
+  startNodeId?: ?NodeId,
+|};
+
 export default class Graph<TNode, TEdgeType: number = 1> {
   nodes: Array<TNode | null>;
   adjacencyList: AdjacencyList<TEdgeType>;
@@ -449,15 +494,16 @@ export default class Graph<TNode, TEdgeType: number = 1> {
     return;
   }
 
+  /**
+   * Iterative implementation of DFS that supports all use-cases.
+   *
+   * This replaces `dfs` and will replace `dfsFast`.
+   */
   dfs<TContext>({
     visit,
     startNodeId,
     getChildren,
-  }: {|
-    visit: GraphVisitor<NodeId, TContext>,
-    getChildren(nodeId: NodeId): Array<NodeId>,
-    startNodeId?: ?NodeId,
-  |}): ?TContext {
+  }: DFSParams<TContext>): ?TContext {
     let traversalStartNode = nullthrows(
       startNodeId ?? this.rootNodeId,
       'A start node is required to traverse',
@@ -486,65 +532,74 @@ export default class Graph<TNode, TEdgeType: number = 1> {
       },
     };
 
-    let walk = (nodeId, context: ?TContext) => {
-      if (!this.hasNode(nodeId)) return;
-      visited.add(nodeId);
+    const queue: DFSCommand<TContext>[] = [
+      {nodeId: traversalStartNode, context: null},
+    ];
+    const enter = typeof visit === 'function' ? visit : visit.enter;
+    while (queue.length !== 0) {
+      const command = queue.pop();
 
-      skipped = false;
-      let enter = typeof visit === 'function' ? visit : visit.enter;
-      if (enter) {
-        let newContext = enter(nodeId, context, actions);
+      if (command.exit != null) {
+        let {nodeId, context, exit} = command;
+        let newContext = exit(nodeId, command.context, actions);
         if (typeof newContext !== 'undefined') {
           // $FlowFixMe[reassign-const]
           context = newContext;
         }
-      }
 
-      if (skipped) {
-        return;
-      }
+        if (skipped) {
+          continue;
+        }
 
-      if (stopped) {
-        return context;
-      }
+        if (stopped) {
+          this._visited = visited;
+          return context;
+        }
+      } else {
+        let {nodeId, context} = command;
+        if (!this.hasNode(nodeId) || visited.has(nodeId)) continue;
+        visited.add(nodeId);
+
+        skipped = false;
+        if (enter) {
+          let newContext = enter(nodeId, context, actions);
+          if (typeof newContext !== 'undefined') {
+            // $FlowFixMe[reassign-const]
+            context = newContext;
+          }
+        }
 
-      for (let child of getChildren(nodeId)) {
-        if (visited.has(child)) {
+        if (skipped) {
           continue;
         }
 
-        visited.add(child);
-        let result = walk(child, context);
         if (stopped) {
-          return result;
+          this._visited = visited;
+          return context;
         }
-      }
 
-      if (
-        typeof visit !== 'function' &&
-        visit.exit &&
-        // Make sure the graph still has the node: it may have been removed between enter and exit
-        this.hasNode(nodeId)
-      ) {
-        let newContext = visit.exit(nodeId, context, actions);
-        if (typeof newContext !== 'undefined') {
-          // $FlowFixMe[reassign-const]
-          context = newContext;
+        if (typeof visit !== 'function' && visit.exit) {
+          queue.push({
+            nodeId,
+            exit: visit.exit,
+            context,
+          });
         }
-      }
 
-      if (skipped) {
-        return;
-      }
+        // TODO turn into generator function
+        const children = getChildren(nodeId);
+        for (let i = children.length - 1; i > -1; i -= 1) {
+          const child = children[i];
+          if (visited.has(child)) {
+            continue;
+          }
 
-      if (stopped) {
-        return context;
+          queue.push({nodeId: child, context});
+        }
       }
-    };
+    }
 
-    let result = walk(traversalStartNode);
     this._visited = visited;
-    return result;
   }
 
   bfs(visit: (nodeId: NodeId) => ?boolean): ?NodeId {

package/test/AdjacencyList.test.js

@@ -292,7 +292,8 @@ describe('AdjacencyList', () => {
       let work = new Promise(resolve => worker.on('message', resolve));
       worker.postMessage(originalSerialized);
       let received = AdjacencyList.deserialize(await work);
-      await worker.terminate();
+      // eslint-disable-next-line no-unused-vars
+      const _terminatePromise = worker.terminate();
 
       assert.deepEqual(received.serialize().nodes, graph.serialize().nodes);
       assert.deepEqual(received.serialize().edges, graph.serialize().edges);

package/test/Graph.test.js

@@ -2,9 +2,10 @@
 
 import assert from 'assert';
 import sinon from 'sinon';
+import type {TraversalActions} from '@parcel/types-internal';
 
 import Graph from '../src/Graph';
-import {toNodeId} from '../src/types';
+import {toNodeId, type NodeId} from '../src/types';
 
 describe('Graph', () => {
   it('constructor should initialize an empty graph', () => {
@@ -340,4 +341,219 @@ describe('Graph', () => {
     assert.deepEqual(graph.nodes.filter(Boolean), ['root']);
     assert.deepStrictEqual(Array.from(graph.getAllEdges()), []);
   });
+
+  describe('dfs(...)', () => {
+    it(`throws if the graph is empty`, () => {
+      const graph = new Graph();
+      const visit = sinon.stub();
+      const getChildren = sinon.stub();
+      assert.throws(() => {
+        graph.dfs({
+          visit,
+          startNodeId: 0,
+          getChildren,
+        });
+      }, /Does not have node 0/);
+    });
+
+    it(`visits a single node`, () => {
+      const graph = new Graph();
+      graph.addNode('root');
+      const visit = sinon.stub();
+      const getChildren = () => [];
+      graph.dfs({
+        visit,
+        startNodeId: 0,
+        getChildren,
+      });
+
+      assert(visit.calledOnce);
+    });
+
+    it(`visits all connected nodes in DFS order`, () => {
+      const graph = new Graph();
+      graph.addNode('0');
+      graph.addNode('1');
+      graph.addNode('2');
+      graph.addNode('3');
+      graph.addNode('disconnected-1');
+      graph.addNode('disconnected-2');
+      graph.addEdge(0, 1);
+      graph.addEdge(0, 2);
+      graph.addEdge(1, 3);
+      graph.addEdge(2, 3);
+
+      const order = [];
+      const visit = (node: NodeId) => {
+        order.push(node);
+      };
+      const getChildren = (node: NodeId) => graph.getNodeIdsConnectedFrom(node);
+      graph.dfs({
+        visit,
+        startNodeId: 0,
+        getChildren,
+      });
+
+      assert.deepEqual(order, [0, 1, 3, 2]);
+    });
+
+    describe(`actions tests`, () => {
+      it(`skips children if skip is called on a node`, () => {
+        const graph = new Graph();
+        graph.addNode('0');
+        graph.addNode('1');
+        graph.addNode('2');
+        graph.addNode('3');
+        graph.addNode('disconnected-1');
+        graph.addNode('disconnected-2');
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 2);
+        graph.addEdge(0, 3);
+
+        const order = [];
+        const visit = (
+          node: NodeId,
+          context: mixed | null,
+          actions: TraversalActions,
+        ) => {
+          if (node === 1) actions.skipChildren();
+          order.push(node);
+        };
+        const getChildren = (node: NodeId) =>
+          graph.getNodeIdsConnectedFrom(node);
+        graph.dfs({
+          visit,
+          startNodeId: 0,
+          getChildren,
+        });
+
+        assert.deepEqual(order, [0, 1, 3]);
+      });
+
+      it(`stops the traversal if stop is called`, () => {
+        const graph = new Graph();
+        graph.addNode('0');
+        graph.addNode('1');
+        graph.addNode('2');
+        graph.addNode('3');
+        graph.addNode('disconnected-1');
+        graph.addNode('disconnected-2');
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 2);
+        graph.addEdge(1, 3);
+        graph.addEdge(0, 2);
+        graph.addEdge(2, 3);
+
+        const order = [];
+        const visit = (
+          node: NodeId,
+          context: mixed | null,
+          actions: TraversalActions,
+        ) => {
+          order.push(node);
+          if (node === 1) {
+            actions.stop();
+            return 'result';
+          }
+          return 'other';
+        };
+        const getChildren = (node: NodeId) =>
+          graph.getNodeIdsConnectedFrom(node);
+        const result = graph.dfs({
+          visit,
+          startNodeId: 0,
+          getChildren,
+        });
+
+        assert.deepEqual(order, [0, 1]);
+        assert.equal(result, 'result');
+      });
+    });
+
+    describe(`context tests`, () => {
+      it(`passes the context between visitors`, () => {
+        const graph = new Graph();
+        graph.addNode('0');
+        graph.addNode('1');
+        graph.addNode('2');
+        graph.addNode('3');
+        graph.addNode('disconnected-1');
+        graph.addNode('disconnected-2');
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 2);
+        graph.addEdge(1, 3);
+        graph.addEdge(0, 2);
+        graph.addEdge(2, 3);
+
+        const contexts = [];
+        const visit = (node: NodeId, context: mixed | null) => {
+          contexts.push([node, context]);
+          return `node-${node}-created-context`;
+        };
+        const getChildren = (node: NodeId) =>
+          graph.getNodeIdsConnectedFrom(node);
+        const result = graph.dfs({
+          visit,
+          startNodeId: 0,
+          getChildren,
+        });
+
+        assert.deepEqual(contexts, [
+          [0, undefined],
+          [1, 'node-0-created-context'],
+          [2, 'node-1-created-context'],
+          [3, 'node-2-created-context'],
+        ]);
+        assert.equal(result, undefined);
+      });
+    });
+
+    describe(`exit visitor tests`, () => {
+      it(`calls the exit visitor`, () => {
+        const graph = new Graph();
+        graph.addNode('0');
+        graph.addNode('1');
+        graph.addNode('2');
+        graph.addNode('3');
+        graph.addNode('disconnected-1');
+        graph.addNode('disconnected-2');
+        graph.addEdge(0, 1);
+        graph.addEdge(1, 2);
+        graph.addEdge(1, 3);
+        graph.addEdge(0, 2);
+
+        const contexts = [];
+        const visit = (node: NodeId, context: mixed | null) => {
+          contexts.push([node, context]);
+          return `node-${node}-created-context`;
+        };
+        const visitExit = (node: NodeId, context: mixed | null) => {
+          contexts.push(['exit', node, context]);
+          return `node-exit-${node}-created-context`;
+        };
+        const getChildren = (node: NodeId) =>
+          graph.getNodeIdsConnectedFrom(node);
+        const result = graph.dfs({
+          visit: {
+            enter: visit,
+            exit: visitExit,
+          },
+          startNodeId: 0,
+          getChildren,
+        });
+
+        assert.deepEqual(contexts, [
+          [0, undefined],
+          [1, 'node-0-created-context'],
+          [2, 'node-1-created-context'],
+          ['exit', 2, 'node-2-created-context'],
+          [3, 'node-1-created-context'],
+          ['exit', 3, 'node-3-created-context'],
+          ['exit', 1, 'node-1-created-context'],
+          ['exit', 0, 'node-0-created-context'],
+        ]);
+        assert.equal(result, undefined);
+      });
+    });
+  });
 });

package/test/integration/adjacency-list-shared-array.js

@@ -6,7 +6,7 @@ const {
   EdgeTypeMap,
 } = require('../../src/AdjacencyList');
 
-parentPort.once('message', (serialized) => {
+parentPort.once('message', serialized => {
   let graph = AdjacencyList.deserialize(serialized);
   serialized.nodes.forEach((v, i) => {
     if (i < NodeTypeMap.HEADER_SIZE) return;