@atlaspack/bundler-experimental 2.12.1-canary.3626 → 2.12.1-canary.3628

package/lib/DominatorBundler/cycleBreaker/findStronglyConnectedComponents.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findStronglyConnectedComponents = findStronglyConnectedComponents;
+/**
+ * Robert Tarjan's algorithm to find strongly connected components in a graph.
+ *
+ * Time complexity: O(V + E)
+ * Space complexity (worst case): O(V)
+ *
+ * * https://web.archive.org/web/20170829214726id_/http://www.cs.ucsb.edu/~gilbert/cs240a/old/cs240aSpr2011/slides/TarjanDFS.pdf
+ * * https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+ */
+function findStronglyConnectedComponents(graph) {
+  const result = [];
+  let index = 0;
+  const stack = [];
+  const state = new Array(graph.nodes.length).fill(null).map(() => ({
+    index: null,
+    lowlink: null,
+    onStack: false
+  }));
+  graph.nodes.forEach((node, nodeId) => {
+    if (node != null && state[nodeId].index == null) {
+      strongConnect(nodeId);
+    }
+  });
+  function strongConnect(nodeId) {
+    const nodeState = state[nodeId];
+    nodeState.index = index;
+    nodeState.lowlink = index;
+    index += 1;
+    stack.push(nodeId);
+    nodeState.onStack = true;
+    for (let neighborId of graph.getNodeIdsConnectedFrom(nodeId)) {
+      const neighborState = state[neighborId];
+      if (neighborState.index == null) {
+        strongConnect(neighborId);
+        nodeState.lowlink = Math.min(Number(nodeState.lowlink), Number(neighborState.lowlink));
+      } else if (neighborState.onStack) {
+        nodeState.lowlink = Math.min(Number(nodeState.lowlink), Number(neighborState.index));
+      }
+    }
+    if (nodeState.lowlink === nodeState.index) {
+      const component = [];
+      let member;
+      do {
+        member = stack.pop();
+        state[member].onStack = false;
+        component.push(member);
+      } while (member !== nodeId);
+      result.push(component);
+    }
+  }
+  return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/bundler-experimental",
-  "version": "2.12.1-canary.3626+da1500b0a",
+  "version": "2.12.1-canary.3628+719a78290",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -16,19 +16,19 @@
     "parcel": "^2.12.0"
   },
   "dependencies": {
-    "@atlaspack/core": "2.12.1-canary.3626+da1500b0a",
-    "@atlaspack/diagnostic": "2.12.1-canary.3626+da1500b0a",
-    "@atlaspack/feature-flags": "2.12.1-canary.3626+da1500b0a",
-    "@atlaspack/graph": "3.2.1-canary.3626+da1500b0a",
-    "@atlaspack/logger": "2.12.1-canary.3626+da1500b0a",
-    "@atlaspack/plugin": "2.12.1-canary.3626+da1500b0a",
-    "@atlaspack/rust": "2.12.1-canary.3626+da1500b0a",
-    "@atlaspack/types": "2.12.1-canary.3626+da1500b0a",
-    "@atlaspack/utils": "2.12.1-canary.3626+da1500b0a",
+    "@atlaspack/core": "2.12.1-canary.3628+719a78290",
+    "@atlaspack/diagnostic": "2.12.1-canary.3628+719a78290",
+    "@atlaspack/feature-flags": "2.12.1-canary.3628+719a78290",
+    "@atlaspack/graph": "3.2.1-canary.3628+719a78290",
+    "@atlaspack/logger": "2.12.1-canary.3628+719a78290",
+    "@atlaspack/plugin": "2.12.1-canary.3628+719a78290",
+    "@atlaspack/rust": "2.12.1-canary.3628+719a78290",
+    "@atlaspack/types": "2.12.1-canary.3628+719a78290",
+    "@atlaspack/utils": "2.12.1-canary.3628+719a78290",
     "nullthrows": "^1.1.1"
   },
   "devDependencies": {
-    "@atlaspack/fs": "2.12.1-canary.3626+da1500b0a"
+    "@atlaspack/fs": "2.12.1-canary.3628+719a78290"
   },
-  "gitHead": "da1500b0afb03ecb698c26d71ee0f75a644312aa"
+  "gitHead": "719a7829084ea6e2cdabba030f913b0801dde852"
 }

package/src/DominatorBundler/cycleBreaker/findStronglyConnectedComponents.js

@@ -0,0 +1,79 @@
+// @flow strict-local
+
+import type {Graph, NodeId} from '@atlaspack/graph';
+
+export type StronglyConnectedComponent = NodeId[];
+
+/**
+ * Robert Tarjan's algorithm to find strongly connected components in a graph.
+ *
+ * Time complexity: O(V + E)
+ * Space complexity (worst case): O(V)
+ *
+ * * https://web.archive.org/web/20170829214726id_/http://www.cs.ucsb.edu/~gilbert/cs240a/old/cs240aSpr2011/slides/TarjanDFS.pdf
+ * * https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+ */
+export function findStronglyConnectedComponents<T, E: number>(
+  graph: Graph<T, E>,
+): StronglyConnectedComponent[] {
+  type State = {|
+    index: null | NodeId,
+    lowlink: null | NodeId,
+    onStack: boolean,
+  |};
+  const result = [];
+  let index = 0;
+  const stack = [];
+  const state: State[] = new Array(graph.nodes.length).fill(null).map(() => ({
+    index: null,
+    lowlink: null,
+    onStack: false,
+  }));
+  graph.nodes.forEach((node, nodeId) => {
+    if (node != null && state[nodeId].index == null) {
+      strongConnect(nodeId);
+    }
+  });
+  function strongConnect(nodeId) {
+    const nodeState = state[nodeId];
+    nodeState.index = index;
+    nodeState.lowlink = index;
+
+    index += 1;
+
+    stack.push(nodeId);
+    nodeState.onStack = true;
+
+    for (let neighborId of graph.getNodeIdsConnectedFrom(nodeId)) {
+      const neighborState = state[neighborId];
+      if (neighborState.index == null) {
+        strongConnect(neighborId);
+
+        nodeState.lowlink = Math.min(
+          Number(nodeState.lowlink),
+          Number(neighborState.lowlink),
+        );
+      } else if (neighborState.onStack) {
+        nodeState.lowlink = Math.min(
+          Number(nodeState.lowlink),
+          Number(neighborState.index),
+        );
+      }
+    }
+
+    if (nodeState.lowlink === nodeState.index) {
+      const component = [];
+      let member;
+
+      do {
+        member = stack.pop();
+        state[member].onStack = false;
+        component.push(member);
+      } while (member !== nodeId);
+
+      result.push(component);
+    }
+  }
+
+  return result;
+}

package/test/DominatorBundler/cycleBreaker/findStronglyConnectedComponents.js

@@ -0,0 +1,81 @@
+// @flow strict-local
+
+import {Graph} from '@atlaspack/graph';
+import assert from 'assert';
+import {findStronglyConnectedComponents} from '../../../src/DominatorBundler/cycleBreaker/findStronglyConnectedComponents';
+
+describe('findStronglyConnectedComponents', () => {
+  it('should find strongly connected components', () => {
+    /*
+      digraph graph {
+        root -> a;
+        a -> b;
+        b -> a;
+        c;
+      }
+     */
+    const graph = new Graph();
+    const root = graph.addNode('root');
+    graph.setRootNodeId(root);
+    const a = graph.addNode('a');
+    const b = graph.addNode('b');
+    const c = graph.addNode('c');
+
+    graph.addEdge(root, a);
+    graph.addEdge(a, b);
+    graph.addEdge(b, a);
+
+    const result = findStronglyConnectedComponents(graph);
+
+    assert.deepStrictEqual(result, [[b, a], [root], [c]]);
+  });
+
+  it('works over an empty graph with a root', () => {
+    /*
+      digraph graph {
+        root;
+      }
+     */
+    const graph = new Graph();
+    const root = graph.addNode('root');
+    graph.setRootNodeId(root);
+
+    const result = findStronglyConnectedComponents(graph);
+    assert.deepStrictEqual(result, [[root]]);
+  });
+
+  it('works over an empty graph', () => {
+    /*
+      digraph graph {
+      }
+     */
+    const graph = new Graph();
+
+    const result = findStronglyConnectedComponents(graph);
+    assert.deepStrictEqual(result, []);
+  });
+
+  it('returns all nodes if there are no cycles', () => {
+    /*
+      digraph graph {
+        root -> a;
+        a -> b;
+        b -> c;
+      }
+     */
+    const graph = new Graph();
+    const root = graph.addNode('root');
+    graph.setRootNodeId(root);
+    const a = graph.addNode('a');
+    const b = graph.addNode('b');
+    const c = graph.addNode('c');
+
+    graph.addEdge(root, a);
+    graph.addEdge(a, b);
+    graph.addEdge(b, c);
+
+    const result = findStronglyConnectedComponents(graph);
+
+    assert.deepStrictEqual(result, [[c], [b], [a], [root]]);
+  });
+});