@parcel/graph 2.9.4-nightly.2999 → 2.9.4-nightly.3004

package/lib/AdjacencyList.js

@@ -354,6 +354,20 @@ class AdjacencyList {
     }
     return nodes;
   }
+  forEachNodeIdConnectedFromReverse(from, fn) {
+    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;
+        }
+        edge = this.#edges.prevOut(edge);
+      }
+      node = this.#nodes.next(node);
+    }
+  }
 
   /**
    * Get the list of nodes connected to this node.

package/lib/BitSet.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BitSet = void 0;
+// Small wasm program that exposes the `ctz` instruction.
+// https://developer.mozilla.org/en-US/docs/WebAssembly/Reference/Numeric/Count_trailing_zeros
+const wasmBuf = new Uint8Array([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x06, 0x01, 0x60, 0x01, 0x7f, 0x01, 0x7f, 0x03, 0x02, 0x01, 0x00, 0x07, 0x0d, 0x01, 0x09, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x30, 0x00, 0x00, 0x0a, 0x07, 0x01, 0x05, 0x00, 0x20, 0x00, 0x68, 0x0b, 0x00, 0x0f, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x02, 0x08, 0x01, 0x00, 0x01, 0x00, 0x03, 0x6e, 0x75, 0x6d]);
+
+// eslint-disable-next-line
+const {
+  trailing0
+} = new WebAssembly.Instance(new WebAssembly.Module(wasmBuf)).exports;
+class BitSet {
+  constructor(maxBits) {
+    this.bits = new Uint32Array(Math.ceil(maxBits / 32));
+  }
+  clone() {
+    let res = new BitSet(this.capacity);
+    res.bits.set(this.bits);
+    return res;
+  }
+  static union(a, b) {
+    let res = a.clone();
+    res.union(b);
+    return res;
+  }
+  get capacity() {
+    return this.bits.length * 32;
+  }
+  add(bit) {
+    this.bits[bit >>> 5] |= 1 << (bit & 31);
+  }
+  delete(bit) {
+    this.bits[bit >>> 5] &= ~(1 << (bit & 31));
+  }
+  has(bit) {
+    return Boolean(this.bits[bit >>> 5] & 1 << (bit & 31));
+  }
+  clear() {
+    this.bits.fill(0);
+  }
+  intersect(other) {
+    for (let i = 0; i < this.bits.length; i++) {
+      this.bits[i] &= other.bits[i];
+    }
+  }
+  union(other) {
+    for (let i = 0; i < this.bits.length; i++) {
+      this.bits[i] |= other.bits[i];
+    }
+  }
+  remove(other) {
+    for (let i = 0; i < this.bits.length; i++) {
+      this.bits[i] &= ~other.bits[i];
+    }
+  }
+  forEach(fn) {
+    // https://lemire.me/blog/2018/02/21/iterating-over-set-bits-quickly/
+    let bits = this.bits;
+    for (let k = 0; k < bits.length; k++) {
+      let v = bits[k];
+      while (v !== 0) {
+        let t = (v & -v) >>> 0;
+        // $FlowFixMe
+        fn((k << 5) + trailing0(v));
+        v ^= t;
+      }
+    }
+  }
+}
+exports.BitSet = BitSet;

package/lib/Graph.js

@@ -7,13 +7,7 @@ exports.default = exports.ALL_EDGE_TYPES = void 0;
 exports.mapVisitor = mapVisitor;
 var _types = require("./types");
 var _AdjacencyList = _interopRequireDefault(require("./AdjacencyList"));
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
+var _BitSet = require("./BitSet");
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
   _nullthrows = function () {
@@ -26,7 +20,7 @@ const ALL_EDGE_TYPES = -1;
 exports.ALL_EDGE_TYPES = ALL_EDGE_TYPES;
 class Graph {
   constructor(opts) {
-    this.nodes = (opts === null || opts === void 0 ? void 0 : opts.nodes) || new Map();
+    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();
@@ -56,23 +50,23 @@ class Graph {
   }
   addNode(node) {
     let id = this.adjacencyList.addNode();
-    this.nodes.set(id, node);
+    this.nodes.push(node);
     return id;
   }
   hasNode(id) {
-    return this.nodes.has(id);
+    return this.nodes[id] != null;
   }
   getNode(id) {
-    return this.nodes.get(id);
+    return this.nodes[id];
   }
   addEdge(from, to, type = 1) {
     if (Number(type) === 0) {
       throw new Error(`Edge type "${type}" not allowed`);
     }
-    if (!this.getNode(from)) {
+    if (this.getNode(from) == null) {
       throw new Error(`"from" node '${(0, _types.fromNodeId)(from)}' not found`);
     }
-    if (!this.getNode(to)) {
+    if (this.getNode(to) == null) {
       throw new Error(`"to" node '${(0, _types.fromNodeId)(to)}' not found`);
     }
     return this.adjacencyList.addEdge(from, to, type);
@@ -109,8 +103,7 @@ class Graph {
     } of this.adjacencyList.getOutboundEdgesByType(nodeId)) {
       this._removeEdge(nodeId, to, type);
     }
-    let wasRemoved = this.nodes.delete(nodeId);
-    (0, _assert().default)(wasRemoved);
+    this.nodes[nodeId] = null;
   }
   removeEdges(nodeId, type = 1) {
     if (!this.hasNode(nodeId)) {
@@ -164,7 +157,7 @@ class Graph {
   }
   updateNode(nodeId, node) {
     this._assertHasNodeId(nodeId);
-    this.nodes.set(nodeId, node);
+    this.nodes[nodeId] = node;
   }
 
   // Update a node's downstream nodes making sure to prune any orphaned branches
@@ -183,11 +176,16 @@ class Graph {
     }
   }
   traverse(visit, startNodeId, type = 1) {
-    return this.dfs({
-      visit,
-      startNodeId,
-      getChildren: nodeId => this.getNodeIdsConnectedFrom(nodeId, type)
-    });
+    let enter = typeof visit === 'function' ? visit : visit.enter;
+    if (type === ALL_EDGE_TYPES && enter && (typeof visit === 'function' || !visit.exit)) {
+      return this.dfsFast(enter, startNodeId);
+    } else {
+      return this.dfs({
+        visit,
+        startNodeId,
+        getChildren: nodeId => this.getNodeIdsConnectedFrom(nodeId, type)
+      });
+    }
   }
   filteredTraverse(filter, visit, startNodeId, type) {
     return this.traverse(mapVisitor(filter, visit), startNodeId, type);
@@ -199,6 +197,66 @@ class Graph {
       getChildren: nodeId => this.getNodeIdsConnectedTo(nodeId, type)
     });
   }
+  dfsFast(visit, startNodeId) {
+    let traversalStartNode = (0, _nullthrows().default)(startNodeId !== null && startNodeId !== void 0 ? startNodeId : this.rootNodeId, 'A start node is required to traverse');
+    this._assertHasNodeId(traversalStartNode);
+    let visited;
+    if (!this._visited || this._visited.capacity < this.nodes.length) {
+      this._visited = new _BitSet.BitSet(this.nodes.length);
+      visited = this._visited;
+    } else {
+      visited = this._visited;
+      visited.clear();
+    }
+    // Take shared instance to avoid re-entrancy issues.
+    this._visited = null;
+    let stopped = false;
+    let skipped = false;
+    let actions = {
+      skipChildren() {
+        skipped = true;
+      },
+      stop() {
+        stopped = true;
+      }
+    };
+    let queue = [{
+      nodeId: traversalStartNode,
+      context: null
+    }];
+    while (queue.length !== 0) {
+      let {
+        nodeId,
+        context
+      } = queue.pop();
+      if (!this.hasNode(nodeId) || visited.has(nodeId)) continue;
+      visited.add(nodeId);
+      skipped = false;
+      let newContext = visit(nodeId, context, actions);
+      if (typeof newContext !== 'undefined') {
+        // $FlowFixMe[reassign-const]
+        context = newContext;
+      }
+      if (skipped) {
+        continue;
+      }
+      if (stopped) {
+        this._visited = visited;
+        return context;
+      }
+      this.adjacencyList.forEachNodeIdConnectedFromReverse(nodeId, child => {
+        if (!visited.has(child)) {
+          queue.push({
+            nodeId: child,
+            context
+          });
+        }
+        return false;
+      });
+    }
+    this._visited = visited;
+    return null;
+  }
   dfs({
     visit,
     startNodeId,
@@ -206,7 +264,16 @@ class Graph {
   }) {
     let traversalStartNode = (0, _nullthrows().default)(startNodeId !== null && startNodeId !== void 0 ? startNodeId : this.rootNodeId, 'A start node is required to traverse');
     this._assertHasNodeId(traversalStartNode);
-    let visited = new Set();
+    let visited;
+    if (!this._visited || this._visited.capacity < this.nodes.length) {
+      this._visited = new _BitSet.BitSet(this.nodes.length);
+      visited = this._visited;
+    } else {
+      visited = this._visited;
+      visited.clear();
+    }
+    // Take shared instance to avoid re-entrancy issues.
+    this._visited = null;
     let stopped = false;
     let skipped = false;
     let actions = {
@@ -261,7 +328,9 @@ class Graph {
         return context;
       }
     };
-    return walk(traversalStartNode);
+    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

@@ -9,6 +9,12 @@ Object.defineProperty(exports, "ALL_EDGE_TYPES", {
     return _Graph.ALL_EDGE_TYPES;
   }
 });
+Object.defineProperty(exports, "BitSet", {
+  enumerable: true,
+  get: function () {
+    return _BitSet.BitSet;
+  }
+});
 Object.defineProperty(exports, "ContentGraph", {
   enumerable: true,
   get: function () {
@@ -42,6 +48,7 @@ Object.defineProperty(exports, "toNodeId", {
 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 _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/graph",
-  "version": "2.9.4-nightly.2999+c182930c6",
+  "version": "2.9.4-nightly.3004+375a2e51e",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
   "publishConfig": {
@@ -20,7 +20,8 @@
     "node": ">= 12.0.0"
   },
   "dependencies": {
+    "@parcel/utils": "2.0.0-nightly.1381+375a2e51e",
     "nullthrows": "^1.1.1"
   },
-  "gitHead": "c182930c631e3bf06034d5b350064152b57206ce"
+  "gitHead": "375a2e51e102e27d0d514781feae28b888cc4c08"
 }

package/src/AdjacencyList.js

@@ -467,6 +467,24 @@ export default class AdjacencyList<TEdgeType: number = 1> {
     return nodes;
   }
 
+  forEachNodeIdConnectedFromReverse(
+    from: NodeId,
+    fn: (nodeId: NodeId) => boolean,
+  ) {
+    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;
+        }
+        edge = this.#edges.prevOut(edge);
+      }
+      node = this.#nodes.next(node);
+    }
+  }
+
   /**
    * Get the list of nodes connected to this node.
    */

package/src/BitSet.js

@@ -0,0 +1,93 @@
+// @flow strict-local
+
+// Small wasm program that exposes the `ctz` instruction.
+// https://developer.mozilla.org/en-US/docs/WebAssembly/Reference/Numeric/Count_trailing_zeros
+const wasmBuf = new Uint8Array([
+  0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x06, 0x01, 0x60, 0x01,
+  0x7f, 0x01, 0x7f, 0x03, 0x02, 0x01, 0x00, 0x07, 0x0d, 0x01, 0x09, 0x74, 0x72,
+  0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x30, 0x00, 0x00, 0x0a, 0x07, 0x01, 0x05,
+  0x00, 0x20, 0x00, 0x68, 0x0b, 0x00, 0x0f, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x02,
+  0x08, 0x01, 0x00, 0x01, 0x00, 0x03, 0x6e, 0x75, 0x6d,
+]);
+
+// eslint-disable-next-line
+const {trailing0} = new WebAssembly.Instance(new WebAssembly.Module(wasmBuf))
+  .exports;
+
+export class BitSet {
+  bits: Uint32Array;
+
+  constructor(maxBits: number) {
+    this.bits = new Uint32Array(Math.ceil(maxBits / 32));
+  }
+
+  clone(): BitSet {
+    let res = new BitSet(this.capacity);
+    res.bits.set(this.bits);
+    return res;
+  }
+
+  static union(a: BitSet, b: BitSet): BitSet {
+    let res = a.clone();
+    res.union(b);
+    return res;
+  }
+
+  get capacity(): number {
+    return this.bits.length * 32;
+  }
+
+  add(bit: number) {
+    let i = bit >>> 5;
+    let b = bit & 31;
+    this.bits[i] |= 1 << b;
+  }
+
+  delete(bit: number) {
+    let i = bit >>> 5;
+    let b = bit & 31;
+    this.bits[i] &= ~(1 << b);
+  }
+
+  has(bit: number): boolean {
+    let i = bit >>> 5;
+    let b = bit & 31;
+    return Boolean(this.bits[i] & (1 << b));
+  }
+
+  clear() {
+    this.bits.fill(0);
+  }
+
+  intersect(other: BitSet) {
+    for (let i = 0; i < this.bits.length; i++) {
+      this.bits[i] &= other.bits[i];
+    }
+  }
+
+  union(other: BitSet) {
+    for (let i = 0; i < this.bits.length; i++) {
+      this.bits[i] |= other.bits[i];
+    }
+  }
+
+  remove(other: BitSet) {
+    for (let i = 0; i < this.bits.length; i++) {
+      this.bits[i] &= ~other.bits[i];
+    }
+  }
+
+  forEach(fn: (bit: number) => void) {
+    // https://lemire.me/blog/2018/02/21/iterating-over-set-bits-quickly/
+    let bits = this.bits;
+    for (let k = 0; k < bits.length; k++) {
+      let v = bits[k];
+      while (v !== 0) {
+        let t = (v & -v) >>> 0;
+        // $FlowFixMe
+        fn((k << 5) + trailing0(v));
+        v ^= t;
+      }
+    }
+  }
+}

package/src/Graph.js

@@ -3,20 +3,24 @@
 import {fromNodeId} from './types';
 import AdjacencyList, {type SerializedAdjacencyList} from './AdjacencyList';
 import type {Edge, NodeId} from './types';
-import type {TraversalActions, GraphVisitor} from '@parcel/types';
+import type {
+  TraversalActions,
+  GraphVisitor,
+  GraphTraversalCallback,
+} from '@parcel/types';
+import {BitSet} from './BitSet';
 
-import assert from 'assert';
 import nullthrows from 'nullthrows';
 
 export type NullEdgeType = 1;
 export type GraphOpts<TNode, TEdgeType: number = 1> = {|
-  nodes?: Map<NodeId, TNode>,
+  nodes?: Array<TNode | null>,
   adjacencyList?: SerializedAdjacencyList<TEdgeType>,
   rootNodeId?: ?NodeId,
 |};
 
 export type SerializedGraph<TNode, TEdgeType: number = 1> = {|
-  nodes: Map<NodeId, TNode>,
+  nodes: Array<TNode | null>,
   adjacencyList: SerializedAdjacencyList<TEdgeType>,
   rootNodeId: ?NodeId,
 |};
@@ -25,12 +29,13 @@ export type AllEdgeTypes = -1;
 export const ALL_EDGE_TYPES: AllEdgeTypes = -1;
 
 export default class Graph<TNode, TEdgeType: number = 1> {
-  nodes: Map<NodeId, TNode>;
+  nodes: Array<TNode | null>;
   adjacencyList: AdjacencyList<TEdgeType>;
   rootNodeId: ?NodeId;
+  _visited: ?BitSet;
 
   constructor(opts: ?GraphOpts<TNode, TEdgeType>) {
-    this.nodes = opts?.nodes || new Map();
+    this.nodes = opts?.nodes || [];
     this.setRootNodeId(opts?.rootNodeId);
 
     let adjacencyList = opts?.adjacencyList;
@@ -69,16 +74,16 @@ export default class Graph<TNode, TEdgeType: number = 1> {
 
   addNode(node: TNode): NodeId {
     let id = this.adjacencyList.addNode();
-    this.nodes.set(id, node);
+    this.nodes.push(node);
     return id;
   }
 
   hasNode(id: NodeId): boolean {
-    return this.nodes.has(id);
+    return this.nodes[id] != null;
   }
 
   getNode(id: NodeId): ?TNode {
-    return this.nodes.get(id);
+    return this.nodes[id];
   }
 
   addEdge(
@@ -90,11 +95,11 @@ export default class Graph<TNode, TEdgeType: number = 1> {
       throw new Error(`Edge type "${type}" not allowed`);
     }
 
-    if (!this.getNode(from)) {
+    if (this.getNode(from) == null) {
       throw new Error(`"from" node '${fromNodeId(from)}' not found`);
     }
 
-    if (!this.getNode(to)) {
+    if (this.getNode(to) == null) {
       throw new Error(`"to" node '${fromNodeId(to)}' not found`);
     }
 
@@ -156,8 +161,7 @@ export default class Graph<TNode, TEdgeType: number = 1> {
       this._removeEdge(nodeId, to, type);
     }
 
-    let wasRemoved = this.nodes.delete(nodeId);
-    assert(wasRemoved);
+    this.nodes[nodeId] = null;
   }
 
   removeEdges(nodeId: NodeId, type: TEdgeType | NullEdgeType = 1) {
@@ -237,7 +241,7 @@ export default class Graph<TNode, TEdgeType: number = 1> {
 
   updateNode(nodeId: NodeId, node: TNode): void {
     this._assertHasNodeId(nodeId);
-    this.nodes.set(nodeId, node);
+    this.nodes[nodeId] = node;
   }
 
   // Update a node's downstream nodes making sure to prune any orphaned branches
@@ -277,11 +281,20 @@ export default class Graph<TNode, TEdgeType: number = 1> {
       | Array<TEdgeType | NullEdgeType>
       | AllEdgeTypes = 1,
   ): ?TContext {
-    return this.dfs({
-      visit,
-      startNodeId,
-      getChildren: nodeId => this.getNodeIdsConnectedFrom(nodeId, type),
-    });
+    let enter = typeof visit === 'function' ? visit : visit.enter;
+    if (
+      type === ALL_EDGE_TYPES &&
+      enter &&
+      (typeof visit === 'function' || !visit.exit)
+    ) {
+      return this.dfsFast(enter, startNodeId);
+    } else {
+      return this.dfs({
+        visit,
+        startNodeId,
+        getChildren: nodeId => this.getNodeIdsConnectedFrom(nodeId, type),
+      });
+    }
   }
 
   filteredTraverse<TValue, TContext>(
@@ -309,6 +322,72 @@ export default class Graph<TNode, TEdgeType: number = 1> {
     });
   }
 
+  dfsFast<TContext>(
+    visit: GraphTraversalCallback<NodeId, TContext>,
+    startNodeId: ?NodeId,
+  ): ?TContext {
+    let traversalStartNode = nullthrows(
+      startNodeId ?? this.rootNodeId,
+      'A start node is required to traverse',
+    );
+    this._assertHasNodeId(traversalStartNode);
+
+    let visited;
+    if (!this._visited || this._visited.capacity < this.nodes.length) {
+      this._visited = new BitSet(this.nodes.length);
+      visited = this._visited;
+    } else {
+      visited = this._visited;
+      visited.clear();
+    }
+    // Take shared instance to avoid re-entrancy issues.
+    this._visited = null;
+
+    let stopped = false;
+    let skipped = false;
+    let actions: TraversalActions = {
+      skipChildren() {
+        skipped = true;
+      },
+      stop() {
+        stopped = true;
+      },
+    };
+
+    let queue = [{nodeId: traversalStartNode, context: null}];
+    while (queue.length !== 0) {
+      let {nodeId, context} = queue.pop();
+      if (!this.hasNode(nodeId) || visited.has(nodeId)) continue;
+      visited.add(nodeId);
+
+      skipped = false;
+      let newContext = visit(nodeId, context, actions);
+      if (typeof newContext !== 'undefined') {
+        // $FlowFixMe[reassign-const]
+        context = newContext;
+      }
+
+      if (skipped) {
+        continue;
+      }
+
+      if (stopped) {
+        this._visited = visited;
+        return context;
+      }
+
+      this.adjacencyList.forEachNodeIdConnectedFromReverse(nodeId, child => {
+        if (!visited.has(child)) {
+          queue.push({nodeId: child, context});
+        }
+        return false;
+      });
+    }
+
+    this._visited = visited;
+    return null;
+  }
+
   dfs<TContext>({
     visit,
     startNodeId,
@@ -324,7 +403,17 @@ export default class Graph<TNode, TEdgeType: number = 1> {
     );
     this._assertHasNodeId(traversalStartNode);
 
-    let visited = new Set<NodeId>();
+    let visited;
+    if (!this._visited || this._visited.capacity < this.nodes.length) {
+      this._visited = new BitSet(this.nodes.length);
+      visited = this._visited;
+    } else {
+      visited = this._visited;
+      visited.clear();
+    }
+    // Take shared instance to avoid re-entrancy issues.
+    this._visited = null;
+
     let stopped = false;
     let skipped = false;
     let actions: TraversalActions = {
@@ -392,7 +481,9 @@ export default class Graph<TNode, TEdgeType: number = 1> {
       }
     };
 
-    return walk(traversalStartNode);
+    let result = walk(traversalStartNode);
+    this._visited = visited;
+    return result;
   }
 
   bfs(visit: (nodeId: NodeId) => ?boolean): ?NodeId {

package/src/index.js

@@ -6,3 +6,4 @@ export type {ContentGraphOpts, SerializedContentGraph} from './ContentGraph';
 export {toNodeId, fromNodeId} from './types';
 export {default as Graph, ALL_EDGE_TYPES, mapVisitor} from './Graph';
 export {default as ContentGraph} from './ContentGraph';
+export {BitSet} from './BitSet';

package/src/types.js

@@ -1,7 +1,7 @@
 // @flow strict-local
 
 // forcing NodeId to be opaque as it should only be created once
-export opaque type NodeId = number;
+export type NodeId = number;
 export function toNodeId(x: number): NodeId {
   return x;
 }

package/test/BitSet.test.js

@@ -0,0 +1,98 @@
+// @flow strict-local
+
+import assert from 'assert';
+import {BitSet} from '../src/BitSet';
+
+function assertValues(set: BitSet, values: Array<number>) {
+  let setValues = [];
+  set.forEach(bit => {
+    setValues.push(bit);
+  });
+
+  for (let value of values) {
+    assert(set.has(value), 'Set.has returned false');
+    assert(
+      setValues.some(v => v === value),
+      'Set values is missing value',
+    );
+  }
+
+  assert(
+    setValues.length === values.length,
+    `Expected ${values.length} values but got ${setValues.length}`,
+  );
+}
+
+describe('BitSet', () => {
+  it('clone should return a set with the same values', () => {
+    let set1 = new BitSet(5);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = set1.clone();
+
+    assertValues(set2, [1, 3]);
+  });
+
+  it('clear should remove all values from the set', () => {
+    let set1 = new BitSet(5);
+    set1.add(1);
+    set1.add(3);
+
+    set1.clear();
+
+    assertValues(set1, []);
+  });
+
+  it('delete should remove values from the set', () => {
+    let set1 = new BitSet(5);
+    set1.add(1);
+    set1.add(3);
+    set1.add(5);
+
+    set1.delete(3);
+
+    assertValues(set1, [1, 5]);
+  });
+
+  it('should intersect with another BitSet', () => {
+    let set1 = new BitSet(5);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = new BitSet(5);
+    set2.add(3);
+    set2.add(5);
+
+    set1.intersect(set2);
+    assertValues(set1, [3]);
+  });
+
+  it('should union with another BitSet', () => {
+    let set1 = new BitSet(5);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = new BitSet(5);
+    set2.add(3);
+    set2.add(5);
+
+    set1.union(set2);
+    assertValues(set1, [1, 3, 5]);
+  });
+
+  it('BitSet.union should create a new BitSet with the union', () => {
+    let set1 = new BitSet(5);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = new BitSet(5);
+    set2.add(3);
+    set2.add(5);
+
+    let set3 = BitSet.union(set1, set2);
+    assertValues(set1, [1, 3]);
+    assertValues(set2, [3, 5]);
+    assertValues(set3, [1, 3, 5]);
+  });
+});

package/test/Graph.test.js

@@ -9,7 +9,7 @@ import {toNodeId} from '../src/types';
 describe('Graph', () => {
   it('constructor should initialize an empty graph', () => {
     let graph = new Graph();
-    assert.deepEqual(graph.nodes, new Map());
+    assert.deepEqual(graph.nodes, []);
     assert.deepEqual([...graph.getAllEdges()], []);
   });
 
@@ -17,7 +17,7 @@ describe('Graph', () => {
     let graph = new Graph();
     let node = {};
     let id = graph.addNode(node);
-    assert.equal(graph.nodes.get(id), node);
+    assert.equal(graph.getNode(id), node);
   });
 
   it('errors when traversing a graph with no root', () => {
@@ -117,10 +117,10 @@ describe('Graph', () => {
     graph.addEdge(nodeB, nodeD);
 
     graph.removeEdge(nodeA, nodeB);
-    assert(graph.nodes.has(nodeA));
-    assert(graph.nodes.has(nodeD));
-    assert(!graph.nodes.has(nodeB));
-    assert(!graph.nodes.has(nodeC));
+    assert(graph.hasNode(nodeA));
+    assert(graph.hasNode(nodeD));
+    assert(!graph.hasNode(nodeB));
+    assert(!graph.hasNode(nodeC));
     assert.deepEqual(
       [...graph.getAllEdges()],
       [{from: nodeA, to: nodeD, type: 1}],
@@ -164,7 +164,7 @@ describe('Graph', () => {
 
     graph.removeNode(nodeB);
 
-    assert.deepEqual([...graph.nodes.keys()], [nodeA, nodeC, nodeF]);
+    assert.deepEqual(graph.nodes.filter(Boolean), ['a', 'c', 'f']);
     assert.deepEqual(Array.from(graph.getAllEdges()), [
       {from: nodeA, to: nodeC, type: 1},
       {from: nodeC, to: nodeF, type: 1},
@@ -209,7 +209,7 @@ describe('Graph', () => {
 
     graph.removeNode(nodeB);
 
-    assert.deepEqual([...graph.nodes.keys()], [nodeA, nodeC, nodeF]);
+    assert.deepEqual(graph.nodes.filter(Boolean), ['a', 'c', 'f']);
     assert.deepEqual(Array.from(graph.getAllEdges()), [
       {from: nodeA, to: nodeC, type: 1},
       {from: nodeC, to: nodeF, type: 1},
@@ -337,7 +337,7 @@ describe('Graph', () => {
 
     graph.removeNode(node1);
 
-    assert.strictEqual(graph.nodes.size, 1);
+    assert.deepEqual(graph.nodes.filter(Boolean), ['root']);
     assert.deepStrictEqual(Array.from(graph.getAllEdges()), []);
   });
 });