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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/bundler-experimental",
-  "version": "2.12.1-canary.3624+888b09f09",
+  "version": "2.12.1-canary.3625+6c4f222b8",
   "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.3625+6c4f222b8",
+    "@atlaspack/diagnostic": "2.12.1-canary.3625+6c4f222b8",
+    "@atlaspack/feature-flags": "2.12.1-canary.3625+6c4f222b8",
+    "@atlaspack/graph": "3.2.1-canary.3625+6c4f222b8",
+    "@atlaspack/logger": "2.12.1-canary.3625+6c4f222b8",
+    "@atlaspack/plugin": "2.12.1-canary.3625+6c4f222b8",
+    "@atlaspack/rust": "2.12.1-canary.3625+6c4f222b8",
+    "@atlaspack/types": "2.12.1-canary.3625+6c4f222b8",
+    "@atlaspack/utils": "2.12.1-canary.3625+6c4f222b8",
     "nullthrows": "^1.1.1"
   },
   "devDependencies": {
-    "@atlaspack/fs": "2.12.1-canary.3624+888b09f09"
+    "@atlaspack/fs": "2.12.1-canary.3625+6c4f222b8"
   },
-  "gitHead": "888b09f09be9a7e0ef6e6416a9a85d19c59fc8bc"
+  "gitHead": "6c4f222b816a32ea2ac5cef41a1784e8d044f142"
 }

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(),
+      );
+    });
+  });
+});