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

package/lib/DominatorBundler/EdgeContentGraph.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EdgeContentGraph = void 0;
+function _graph() {
+  const data = require("@atlaspack/graph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * A `ContentGraph` that also stores weights on edges.
+ *
+ * @template N The type of the node weight.
+ * @template EW The type of the edge weight.
+ */
+class EdgeContentGraph extends _graph().ContentGraph {
+  #edgeWeights = new Map();
+  clone() {
+    const newGraph = new EdgeContentGraph();
+    let nodeId = 0;
+    for (let node of this.nodes) {
+      const contentKey = this._nodeIdToContentKey.get(nodeId);
+      if (node == null) {
+        // Add null node to preserve node ids
+        // $FlowFixMe
+        newGraph.addNode(null);
+      } else if (contentKey == null) {
+        newGraph.addNode(node);
+      } else {
+        newGraph.addNodeByContentKey(contentKey, node);
+      }
+      nodeId += 1;
+    }
+    for (let edge of this.getAllEdges()) {
+      const weight = this.getEdgeWeight(edge.from, edge.to);
+      newGraph.addWeightedEdge(edge.from, edge.to, edge.type, weight);
+    }
+    if (this.rootNodeId != null) {
+      const rootNodeContentKey = this._nodeIdToContentKey.get(this.rootNodeId);
+      const newGraphRootNodeId = newGraph.getNodeIdByContentKey((0, _nullthrows().default)(rootNodeContentKey));
+      newGraph.setRootNodeId(newGraphRootNodeId);
+    }
+    return newGraph;
+  }
+  addWeightedEdge(from, to, type, weight) {
+    this.addEdge(from, to, type);
+    if (weight != null) {
+      this.#edgeWeights.set([String(from), String(to)].join(','), weight);
+    }
+  }
+  getEdgeWeight(from, to) {
+    return this.#edgeWeights.get([String(from), String(to)].join(',')) ?? null;
+  }
+}
+exports.EdgeContentGraph = EdgeContentGraph;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/bundler-experimental",
-  "version": "2.12.1-canary.3624+888b09f09",
+  "version": "2.12.1-canary.3626+da1500b0a",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -16,19 +16,19 @@
     "parcel": "^2.12.0"
   },
   "dependencies": {
-    "@atlaspack/core": "2.12.1-canary.3624+888b09f09",
-    "@atlaspack/diagnostic": "2.12.1-canary.3624+888b09f09",
-    "@atlaspack/feature-flags": "2.12.1-canary.3624+888b09f09",
-    "@atlaspack/graph": "3.2.1-canary.3624+888b09f09",
-    "@atlaspack/logger": "2.12.1-canary.3624+888b09f09",
-    "@atlaspack/plugin": "2.12.1-canary.3624+888b09f09",
-    "@atlaspack/rust": "2.12.1-canary.3624+888b09f09",
-    "@atlaspack/types": "2.12.1-canary.3624+888b09f09",
-    "@atlaspack/utils": "2.12.1-canary.3624+888b09f09",
+    "@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",
     "nullthrows": "^1.1.1"
   },
   "devDependencies": {
-    "@atlaspack/fs": "2.12.1-canary.3624+888b09f09"
+    "@atlaspack/fs": "2.12.1-canary.3626+da1500b0a"
   },
-  "gitHead": "888b09f09be9a7e0ef6e6416a9a85d19c59fc8bc"
+  "gitHead": "da1500b0afb03ecb698c26d71ee0f75a644312aa"
 }

package/src/DominatorBundler/EdgeContentGraph.js

@@ -0,0 +1,62 @@
+// @flow strict-local
+
+import {ContentGraph, type NodeId} from '@atlaspack/graph';
+import nullthrows from 'nullthrows';
+
+/**
+ * A `ContentGraph` that also stores weights on edges.
+ *
+ * @template N The type of the node weight.
+ * @template EW The type of the edge weight.
+ */
+export class EdgeContentGraph<N, EW> extends ContentGraph<N, number> {
+  #edgeWeights: Map<string, EW> = new Map();
+
+  clone(): EdgeContentGraph<N, EW> {
+    const newGraph: EdgeContentGraph<N, EW> = new EdgeContentGraph();
+    let nodeId = 0;
+    for (let node of this.nodes) {
+      const contentKey = this._nodeIdToContentKey.get(nodeId);
+      if (node == null) {
+        // Add null node to preserve node ids
+        // $FlowFixMe
+        newGraph.addNode(null);
+      } else if (contentKey == null) {
+        newGraph.addNode(node);
+      } else {
+        newGraph.addNodeByContentKey(contentKey, node);
+      }
+      nodeId += 1;
+    }
+    for (let edge of this.getAllEdges()) {
+      const weight = this.getEdgeWeight(edge.from, edge.to);
+      newGraph.addWeightedEdge(edge.from, edge.to, edge.type, weight);
+    }
+
+    if (this.rootNodeId != null) {
+      const rootNodeContentKey = this._nodeIdToContentKey.get(this.rootNodeId);
+      const newGraphRootNodeId = newGraph.getNodeIdByContentKey(
+        nullthrows(rootNodeContentKey),
+      );
+      newGraph.setRootNodeId(newGraphRootNodeId);
+    }
+
+    return newGraph;
+  }
+
+  addWeightedEdge(
+    from: NodeId,
+    to: NodeId,
+    type: number,
+    weight: EW | null,
+  ): void {
+    this.addEdge(from, to, type);
+    if (weight != null) {
+      this.#edgeWeights.set([String(from), String(to)].join(','), weight);
+    }
+  }
+
+  getEdgeWeight(from: NodeId, to: NodeId): EW | null {
+    return this.#edgeWeights.get([String(from), String(to)].join(',')) ?? null;
+  }
+}

package/test/DominatorBundler/EdgeContentGraph.test.js

@@ -0,0 +1,58 @@
+// @flow strict-local
+
+import assert from 'assert';
+import {EdgeContentGraph} from '../../src/DominatorBundler/EdgeContentGraph';
+
+describe('EdgeContentGraph', () => {
+  describe('addWeightedEdge', () => {
+    it('creates an edge between two nodes', () => {
+      const graph = new EdgeContentGraph<string, number>();
+      const a = graph.addNode('a');
+      const b = graph.addNode('b');
+      const edgeType = 1;
+      const weight = 10;
+      graph.addWeightedEdge(a, b, edgeType, weight);
+      const ids = graph.getNodeIdsConnectedFrom(a);
+      assert.deepEqual(ids, [b]);
+    });
+
+    it('should add and get edge weights', () => {
+      const graph = new EdgeContentGraph<string, number>();
+      const a = graph.addNode('a');
+      const b = graph.addNode('b');
+      const c = graph.addNode('b');
+
+      const edgeType = 1;
+      const weight1 = 10;
+      const weight2 = 20;
+
+      graph.addWeightedEdge(a, b, edgeType, weight1);
+      graph.addWeightedEdge(b, c, edgeType, weight2);
+
+      assert.equal(graph.getEdgeWeight(a, b), weight1);
+      assert.equal(graph.getEdgeWeight(b, c), weight2);
+    });
+  });
+
+  describe('clone', () => {
+    it('clones the graph', () => {
+      const graph = new EdgeContentGraph<string, number>();
+      const a = graph.addNode('a');
+      const b = graph.addNode('b');
+      const c = graph.addNode('c');
+
+      const edgeType = 1;
+      const weight1 = 10;
+      const weight2 = 20;
+
+      graph.addWeightedEdge(a, b, edgeType, weight1);
+      graph.addWeightedEdge(b, c, edgeType, weight2);
+
+      const clonedGraph = graph.clone();
+      assert.deepEqual(clonedGraph.nodes, graph.nodes);
+      assert.deepEqual(clonedGraph.getAllEdges(), graph.getAllEdges());
+      assert.equal(clonedGraph.getEdgeWeight(a, b), weight1);
+      assert.equal(clonedGraph.getEdgeWeight(b, c), weight2);
+    });
+  });
+});

package/test/fixtureFromGraph.js

@@ -0,0 +1,190 @@
+// @flow strict-local
+
+/*!
+ * This module provides a way to write fixtures where we don't care about the
+ * code within the assets; only the shape of the asset graphs.
+ */
+import type {FileSystem} from '@atlaspack/fs';
+import path from 'path';
+
+/**
+ * A node in the fixture graph
+ */
+export type GraphEntry = AssetEntry;
+
+/**
+ * An asset in the fixture graph. Just a path and dependencies
+ */
+export type AssetEntry = {|
+  type: 'asset',
+  value: {|
+    filePath: string,
+    dependencies: DependencyEntry[],
+  |},
+|};
+
+/**
+ * Sync or async dependency between assets
+ */
+export type DependencyEntry = {|
+  type: 'dependency',
+  value: {|
+    from: string,
+    to: string,
+    type: 'sync' | 'async',
+  |},
+|};
+
+export type DependencySpec = {|
+  to: string,
+  type: 'sync' | 'async',
+|};
+
+/**
+ * Create an asset node in the fixture graph
+ */
+export function asset(
+  path: string,
+  dependencies?: (string | DependencySpec)[],
+): GraphEntry {
+  return {
+    type: 'asset',
+    value: {
+      filePath: path,
+      dependencies:
+        dependencies?.map((dependency) => {
+          if (typeof dependency === 'string') {
+            return {
+              type: 'dependency',
+              value: {
+                from: path,
+                to: dependency,
+                type: 'sync',
+              },
+            };
+          } else {
+            return {
+              type: 'dependency',
+              value: {
+                from: path,
+                to: dependency.to,
+                type: dependency.type,
+              },
+            };
+          }
+        }) ?? [],
+    },
+  };
+}
+
+/**
+ * Create the files for a fixture graph over the `fs` filesystem.
+ */
+export async function fixtureFromGraph(
+  dirname: string,
+  fs: FileSystem,
+  entries: GraphEntry[],
+): Promise<string> {
+  await fs.mkdirp(dirname);
+
+  for (let entry of entries) {
+    if (entry.type === 'asset') {
+      const dependencies = entry.value.dependencies ?? [];
+      const symbols = dependencies
+        .filter((d) => d.value.type === 'sync')
+        .map((_, i) => `d${i}`);
+      const asyncDependencies = dependencies
+        .filter((d) => d.value.type === 'async')
+        .map((d) => `import('./${d.value.to}')`);
+      const contents = [
+        ...dependencies
+          .filter((d) => {
+            return d.value.type === 'sync';
+          })
+          .map((dependency, i) => {
+            return `import ${symbols[i]} from './${dependency.value.to}';`;
+          }),
+        `export default function run() { return [${[
+          ...symbols,
+          ...asyncDependencies,
+        ].join(', ')}] }`,
+      ].join('\n');
+
+      await fs.writeFile(path.join(dirname, entry.value.filePath), contents);
+    }
+  }
+
+  return dotFromGraph(entries);
+}
+
+/**
+ * Create a graphviz dot string from a fixture graph
+ *
+ * The contents of the GraphViz file will contain (in this order):
+ *
+ * * the list of all asset nodes
+ * * the dependencies between assets
+ *
+ * Given a graph build with:
+ *
+ * ```
+ * fixtureFromGraph('dir', fs, [
+ *   asset('a.js', ['b.js', 'c.js']),
+ *   asset('b.js', ['d.js']),
+ *   asset('d.js'),
+ * ])
+ * ```
+ *
+ * The output will be:
+ * ```
+ * digraph assets {
+ *   labelloc="t";
+ *   label="Assets";
+ *
+ *   "a.js";
+ *   "b.js";
+ *   "c.js";
+ *   "d.js";
+ *
+ *   "a.js" -> "b.js";
+ *   "a.js" -> "c.js";
+ *   "b.js" -> "d.js";
+ * }
+ * ```
+ *
+ * That is:
+ *
+ * * iterate all nodes and declare them
+ * * iterate all dependencies between nodes and declare them
+ *
+ */
+export function dotFromGraph(entries: GraphEntry[]): string {
+  const contents = [];
+
+  for (let entry of entries) {
+    if (entry.type === 'asset') {
+      const asset = entry.value;
+      contents.push(`"${asset.filePath}";`);
+    }
+  }
+
+  contents.push('');
+
+  for (let entry of entries) {
+    if (entry.type === 'asset') {
+      const asset = entry.value;
+      for (let dependency of entry.value.dependencies) {
+        contents.push(`"${asset.filePath}" -> "${dependency.value.to}";`);
+      }
+    }
+  }
+
+  return `
+digraph assets {
+  labelloc="t";
+  label="Assets";
+
+${contents.map((line) => (line.length > 0 ? `  ${line}` : '')).join('\n')}
+}
+  `.trim();
+}

package/test/fixtureFromGraph.test.js

@@ -0,0 +1,106 @@
+// @flow strict-local
+
+import {MemoryFS} from '@atlaspack/fs';
+import assert from 'assert';
+import {workerFarm} from '@atlaspack/test-utils';
+import {asset, fixtureFromGraph, dotFromGraph} from './fixtureFromGraph';
+
+describe('fixtureFromGraph', () => {
+  before(async function () {
+    this.timeout(10000);
+    // Warm up worker farm so that the first test doesn't account for this time.
+    await workerFarm.callAllWorkers('ping', []);
+  });
+
+  it('can create fixtures for single files', async () => {
+    const fs = new MemoryFS(workerFarm);
+    await fixtureFromGraph('dir', fs, [
+      asset('file1.js'),
+      asset('file2.js'),
+      asset('file3.js'),
+    ]);
+
+    assert.deepEqual(await fs.readdir('dir'), [
+      'file1.js',
+      'file2.js',
+      'file3.js',
+    ]);
+    assert.equal(
+      await fs.readFile('dir/file1.js', 'utf8'),
+      'export default function run() { return [] }',
+    );
+  });
+
+  it('will create files with imports between themselves', async () => {
+    const fs = new MemoryFS(workerFarm);
+    await fixtureFromGraph('dir', fs, [
+      asset('file1.js', ['file2.js', 'file3.js']),
+      asset('file2.js'),
+      asset('file3.js'),
+    ]);
+
+    assert.deepEqual(await fs.readdir('dir'), [
+      'file1.js',
+      'file2.js',
+      'file3.js',
+    ]);
+    assert.equal(
+      await fs.readFile('dir/file1.js', 'utf8'),
+      `
+import d0 from './file2.js';
+import d1 from './file3.js';
+export default function run() { return [d0, d1] }
+      `.trim(),
+    );
+  });
+
+  it('will create files with async imports between themselves', async () => {
+    const fs = new MemoryFS(workerFarm);
+    await fixtureFromGraph('dir', fs, [
+      asset('file1.js', ['file2.js', {to: 'file3.js', type: 'async'}]),
+      asset('file2.js'),
+      asset('file3.js'),
+    ]);
+
+    assert.deepEqual(await fs.readdir('dir'), [
+      'file1.js',
+      'file2.js',
+      'file3.js',
+    ]);
+    assert.equal(
+      await fs.readFile('dir/file1.js', 'utf8'),
+      `
+import d0 from './file2.js';
+export default function run() { return [d0, import('./file3.js')] }
+      `.trim(),
+    );
+  });
+
+  describe('dotFromGraph', () => {
+    it('creates a dot string from a graph', () => {
+      const graph = [
+        asset('file1.js', ['file2.js', 'file3.js']),
+        asset('file2.js'),
+        asset('file3.js'),
+      ];
+      const dot = dotFromGraph(graph);
+
+      assert.equal(
+        dot,
+        `
+digraph assets {
+  labelloc="t";
+  label="Assets";
+
+  "file1.js";
+  "file2.js";
+  "file3.js";
+
+  "file1.js" -> "file2.js";
+  "file1.js" -> "file3.js";
+}
+        `.trim(),
+      );
+    });
+  });
+});