@parcel/graph 3.2.1-dev.3268 → 3.2.1-dev.3303

package/lib/AdjacencyList.js

@@ -240,7 +240,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

@@ -33,12 +33,12 @@ class ContentGraph extends _Graph.default {
 
   // $FlowFixMe[prop-missing]
   static deserialize(opts) {
-    // $FlowFixMe
     return new ContentGraph(opts);
   }
 
   // $FlowFixMe[prop-missing]
   serialize() {
+    // $FlowFixMe[prop-missing]
     return {
       ...super.serialize(),
       _contentKeyToNodeId: this._contentKeyToNodeId,

package/lib/Graph.js

@@ -17,6 +17,15 @@ function _nullthrows() {
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/graph",
-  "version": "3.2.1-dev.3268+10d19ff8a",
+  "version": "3.2.1-dev.3303+3edb0d741",
   "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.12.1-dev.3303+3edb0d741",
     "nullthrows": "^1.1.1"
   },
-  "gitHead": "10d19ff8a34dd8f479847aadf9865be48a8fad84"
+  "gitHead": "3edb0d7419831e49cfa7ea8c52b4f7127a16ae52"
 }

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/ContentGraph.js

@@ -12,7 +12,6 @@ export type ContentGraphOpts<TNode, TEdgeType: number = 1> = {|
 export type SerializedContentGraph<TNode, TEdgeType: number = 1> = {|
   ...SerializedGraph<TNode, TEdgeType>,
   _contentKeyToNodeId: Map<ContentKey, NodeId>,
-  _nodeIdToContentKey: Map<NodeId, ContentKey>,
 |};
 
 export default class ContentGraph<TNode, TEdgeType: number = 1> extends Graph<
@@ -37,14 +36,14 @@ export default class ContentGraph<TNode, TEdgeType: number = 1> extends Graph<
 
   // $FlowFixMe[prop-missing]
   static deserialize(
-    opts: SerializedContentGraph<TNode, TEdgeType>,
+    opts: ContentGraphOpts<TNode, TEdgeType>,
   ): ContentGraph<TNode, TEdgeType> {
-    // $FlowFixMe
     return new ContentGraph(opts);
   }
 
   // $FlowFixMe[prop-missing]
   serialize(): SerializedContentGraph<TNode, TEdgeType> {
+    // $FlowFixMe[prop-missing]
     return {
       ...super.serialize(),
       _contentKeyToNodeId: this._contentKeyToNodeId,

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>;
@@ -49,7 +94,7 @@ export default class Graph<TNode, TEdgeType: number = 1> {
   }
 
   static deserialize(
-    opts: SerializedGraph<TNode, TEdgeType>,
+    opts: GraphOpts<TNode, TEdgeType>,
   ): Graph<TNode, TEdgeType> {
     return new this({
       nodes: opts.nodes,
@@ -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/src/types.js

@@ -9,7 +9,7 @@ export function fromNodeId(x: NodeId): number {
   return x;
 }
 
-export type ContentKey = string | number;
+export type ContentKey = string;
 
 export type Edge<TEdgeType: number> = {|
   from: 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;