@atlaspack/core 2.12.1-canary.3354

package/test/BundleGraph.test.js

@@ -0,0 +1,121 @@
+// @flow strict-local
+
+import assert from 'assert';
+import BundleGraph from '../src/BundleGraph';
+import {DEFAULT_ENV, DEFAULT_TARGETS} from './test-utils';
+import AssetGraph, {nodeFromAssetGroup} from '../src/AssetGraph';
+import {createAsset as _createAsset} from '../src/assetUtils';
+import {createDependency as _createDependency} from '../src/Dependency';
+import {toProjectPath} from '../src/projectPath';
+
+function createAsset(opts) {
+  return _createAsset('/', opts);
+}
+
+function createDependency(opts) {
+  return _createDependency('/', opts);
+}
+
+const id1 = '0123456789abcdef0123456789abcdef';
+const id2 = '9876543210fedcba9876543210fedcba';
+
+describe('BundleGraph', () => {
+  it('assigns publicIds to assets', () => {
+    let bundleGraph = BundleGraph.fromAssetGraph(
+      createMockAssetGraph([id1, id2]),
+      false,
+    );
+    assert.deepEqual(
+      getAssets(bundleGraph).map(a => bundleGraph.getAssetPublicId(a)),
+      ['296TI', '4DGUq'],
+    );
+  });
+
+  it('uses a longer publicId if there is a collision', () => {
+    let bundleGraph = BundleGraph.fromAssetGraph(
+      createMockAssetGraph([id1, id1.slice(0, 16) + '7' + id1.slice(17)]),
+      false,
+    );
+    assert.deepEqual(
+      getAssets(bundleGraph).map(a => bundleGraph.getAssetPublicId(a)),
+      ['296TI', '296TII'],
+    );
+  });
+});
+
+function getAssets(bundleGraph) {
+  let assets = [];
+  bundleGraph.traverse(node => {
+    if (node.type === 'asset') {
+      assets.push(node.value);
+    }
+  });
+  return assets;
+}
+
+const stats = {size: 0, time: 0};
+function createMockAssetGraph(ids: [string, string]) {
+  let graph = new AssetGraph();
+  graph.setRootConnections({entries: [toProjectPath('/', '/index')]});
+
+  graph.resolveEntry(
+    toProjectPath('/', '/index'),
+    [
+      {
+        filePath: toProjectPath('/', '/path/to/index/src/main.js'),
+        packagePath: toProjectPath('/', '/path/to/index'),
+      },
+    ],
+    '1',
+  );
+  graph.resolveTargets(
+    {
+      filePath: toProjectPath('/', '/path/to/index/src/main.js'),
+      packagePath: toProjectPath('/', '/path/to/index'),
+    },
+    DEFAULT_TARGETS,
+    '2',
+  );
+
+  let dep = createDependency({
+    specifier: 'path/to/index/src/main.js',
+    specifierType: 'esm',
+    env: DEFAULT_ENV,
+    target: DEFAULT_TARGETS[0],
+  });
+  let sourcePath = '/index.js';
+  let filePath = toProjectPath('/', sourcePath);
+  let req = {filePath, env: DEFAULT_ENV};
+  graph.resolveDependency(dep, nodeFromAssetGroup(req).value, '3');
+
+  let dep1 = createDependency({
+    specifier: 'dependent-asset-1',
+    specifierType: 'esm',
+    env: DEFAULT_ENV,
+    sourcePath,
+  });
+
+  let assets = [
+    createAsset({
+      id: ids[0],
+      filePath,
+      type: 'js',
+      isSource: true,
+      stats,
+      dependencies: new Map([['dep1', dep1]]),
+      env: DEFAULT_ENV,
+    }),
+    createAsset({
+      id: ids[1],
+      filePath,
+      type: 'js',
+      isSource: true,
+      stats,
+      dependencies: new Map([['dep1', dep1]]),
+      env: DEFAULT_ENV,
+    }),
+  ];
+  graph.resolveAssetGroup(req, assets, '4');
+
+  return graph;
+}

package/test/EntryRequest.test.js

@@ -0,0 +1,215 @@
+// @flow strict-local
+import assert from 'assert';
+import path from 'path';
+import {md} from '@atlaspack/diagnostic';
+import {inputFS as fs} from '@atlaspack/test-utils';
+import {EntryResolver} from '../src/requests/EntryRequest';
+import {DEFAULT_OPTIONS as _DEFAULT_OPTIONS} from './test-utils';
+
+const DEFAULT_OPTIONS = {
+  ..._DEFAULT_OPTIONS,
+  defaultTargetOptions: {
+    ..._DEFAULT_OPTIONS.defaultTargetOptions,
+    sourceMaps: true,
+  },
+};
+
+const INVALID_SOURCE_MISSING_FIXTURE_PATH = path.join(
+  __dirname,
+  'fixtures/invalid-source-missing',
+);
+
+const INVALID_SOURCE_NOT_FILE_FIXTURE_PATH = path.join(
+  __dirname,
+  'fixtures/invalid-source-not-file',
+);
+
+const INVALID_TARGET_SOURCE_MISSING_FIXTURE_PATH = path.join(
+  __dirname,
+  'fixtures/invalid-target-source-missing',
+);
+
+const INVALID_TARGET_SOURCE_NOT_FILE_FIXTURE_PATH = path.join(
+  __dirname,
+  'fixtures/invalid-target-source-not-file',
+);
+
+const GLOB_LIKE_FIXTURE_PATH = path.join(
+  __dirname,
+  'fixtures/glob-like/[entry].js',
+);
+
+describe('EntryResolver', function () {
+  let entryResolver = new EntryResolver({...DEFAULT_OPTIONS});
+
+  it('rejects missing source in package.json', async function () {
+    this.timeout(10000);
+    // $FlowFixMe assert.rejects is Node 10+
+    await assert.rejects(
+      () => entryResolver.resolveEntry(INVALID_SOURCE_MISSING_FIXTURE_PATH),
+      {
+        diagnostics: [
+          {
+            origin: '@atlaspack/core',
+            message: md`${path.join(
+              path.relative(fs.cwd(), INVALID_SOURCE_MISSING_FIXTURE_PATH),
+              'missing.js',
+            )} does not exist.`,
+            codeFrames: [
+              {
+                filePath: path.join(
+                  INVALID_SOURCE_MISSING_FIXTURE_PATH,
+                  'package.json',
+                ),
+                codeHighlights: [
+                  {
+                    message: undefined,
+                    start: {
+                      line: 4,
+                      column: 13,
+                    },
+                    end: {
+                      line: 4,
+                      column: 24,
+                    },
+                  },
+                ],
+              },
+            ],
+            hints: [],
+          },
+        ],
+      },
+    );
+  });
+  it('rejects non-file source in package.json', async function () {
+    this.timeout(10000);
+    // $FlowFixMe assert.rejects is Node 10+
+    await assert.rejects(
+      () => entryResolver.resolveEntry(INVALID_SOURCE_NOT_FILE_FIXTURE_PATH),
+      {
+        diagnostics: [
+          {
+            origin: '@atlaspack/core',
+            message: md`${path.join(
+              path.relative(fs.cwd(), INVALID_SOURCE_NOT_FILE_FIXTURE_PATH),
+              'src',
+            )} is not a file.`,
+            codeFrames: [
+              {
+                filePath: path.join(
+                  INVALID_SOURCE_NOT_FILE_FIXTURE_PATH,
+                  'package.json',
+                ),
+                codeHighlights: [
+                  {
+                    message: undefined,
+                    start: {
+                      line: 4,
+                      column: 13,
+                    },
+                    end: {
+                      line: 4,
+                      column: 17,
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    );
+  });
+  it('rejects missing target source in package.json', async function () {
+    this.timeout(10000);
+    // $FlowFixMe assert.rejects is Node 10+
+    await assert.rejects(
+      () =>
+        entryResolver.resolveEntry(INVALID_TARGET_SOURCE_MISSING_FIXTURE_PATH),
+      {
+        diagnostics: [
+          {
+            origin: '@atlaspack/core',
+            message: md`${path.join(
+              path.relative(
+                fs.cwd(),
+                INVALID_TARGET_SOURCE_MISSING_FIXTURE_PATH,
+              ),
+              'missing.js',
+            )} does not exist.`,
+            codeFrames: [
+              {
+                filePath: path.join(
+                  INVALID_TARGET_SOURCE_MISSING_FIXTURE_PATH,
+                  'package.json',
+                ),
+                codeHighlights: [
+                  {
+                    message: undefined,
+                    start: {
+                      line: 6,
+                      column: 17,
+                    },
+                    end: {
+                      line: 6,
+                      column: 28,
+                    },
+                  },
+                ],
+              },
+            ],
+            hints: [],
+          },
+        ],
+      },
+    );
+  });
+  it('rejects non-file target source in package.json', async function () {
+    this.timeout(10000);
+    // $FlowFixMe assert.rejects is Node 10+
+    await assert.rejects(
+      () =>
+        entryResolver.resolveEntry(INVALID_TARGET_SOURCE_NOT_FILE_FIXTURE_PATH),
+      {
+        diagnostics: [
+          {
+            origin: '@atlaspack/core',
+            message: md`${path.join(
+              path.relative(
+                fs.cwd(),
+                INVALID_TARGET_SOURCE_NOT_FILE_FIXTURE_PATH,
+              ),
+              'src',
+            )} is not a file.`,
+            codeFrames: [
+              {
+                filePath: path.join(
+                  INVALID_TARGET_SOURCE_NOT_FILE_FIXTURE_PATH,
+                  'package.json',
+                ),
+                codeHighlights: [
+                  {
+                    message: undefined,
+                    start: {
+                      line: 6,
+                      column: 17,
+                    },
+                    end: {
+                      line: 6,
+                      column: 21,
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    );
+  });
+  it('does not time out on glob-like entry', async function () {
+    this.timeout(10000);
+    await entryResolver.resolveEntry(GLOB_LIKE_FIXTURE_PATH);
+  });
+});

package/test/Environment.test.js

@@ -0,0 +1,99 @@
+// @flow strict-local
+
+import assert from 'assert';
+import {createEnvironment} from '../src/Environment';
+
+describe('Environment', () => {
+  it('assigns a default environment with nothing passed', () => {
+    assert.deepEqual(createEnvironment(), {
+      id: 'c242f987e3544367',
+      context: 'browser',
+      engines: {
+        browsers: ['> 0.25%'],
+      },
+      includeNodeModules: true,
+      outputFormat: 'global',
+      isLibrary: false,
+      shouldOptimize: false,
+      shouldScopeHoist: false,
+      sourceMap: undefined,
+      loc: undefined,
+      sourceType: 'module',
+    });
+  });
+
+  it('assigns a node context if a node engine is given', () => {
+    assert.deepEqual(createEnvironment({engines: {node: '>= 10.0.0'}}), {
+      id: '69e0ab7220ee8f7a',
+      context: 'node',
+      engines: {
+        node: '>= 10.0.0',
+      },
+      includeNodeModules: false,
+      outputFormat: 'commonjs',
+      isLibrary: false,
+      shouldOptimize: false,
+      shouldScopeHoist: false,
+      sourceMap: undefined,
+      loc: undefined,
+      sourceType: 'module',
+    });
+  });
+
+  it('assigns a browser context if browser engines are given', () => {
+    assert.deepEqual(
+      createEnvironment({engines: {browsers: ['last 1 version']}}),
+      {
+        id: '4b5c9005af8c5b19',
+        context: 'browser',
+        engines: {
+          browsers: ['last 1 version'],
+        },
+        includeNodeModules: true,
+        outputFormat: 'global',
+        isLibrary: false,
+        shouldOptimize: false,
+        shouldScopeHoist: false,
+        sourceMap: undefined,
+        loc: undefined,
+        sourceType: 'module',
+      },
+    );
+  });
+
+  it('assigns default engines for node', () => {
+    assert.deepEqual(createEnvironment({context: 'node'}), {
+      id: 'f7c9644283a8698f',
+      context: 'node',
+      engines: {
+        node: '>= 8.0.0',
+      },
+      includeNodeModules: false,
+      outputFormat: 'commonjs',
+      isLibrary: false,
+      shouldOptimize: false,
+      shouldScopeHoist: false,
+      sourceMap: undefined,
+      loc: undefined,
+      sourceType: 'module',
+    });
+  });
+
+  it('assigns default engines for browsers', () => {
+    assert.deepEqual(createEnvironment({context: 'browser'}), {
+      id: 'c242f987e3544367',
+      context: 'browser',
+      engines: {
+        browsers: ['> 0.25%'],
+      },
+      includeNodeModules: true,
+      outputFormat: 'global',
+      isLibrary: false,
+      shouldOptimize: false,
+      shouldScopeHoist: false,
+      sourceMap: undefined,
+      loc: undefined,
+      sourceType: 'module',
+    });
+  });
+});

package/test/InternalAsset.test.js

@@ -0,0 +1,76 @@
+// @flow strict-local
+
+import assert from 'assert';
+import UncommittedAsset from '../src/UncommittedAsset';
+import {createAsset as _createAsset} from '../src/assetUtils';
+import {createEnvironment} from '../src/Environment';
+import {DEFAULT_OPTIONS} from './test-utils';
+import {toProjectPath} from '../src/projectPath';
+
+function createAsset(opts) {
+  return _createAsset('/', opts);
+}
+
+const stats = {time: 0, size: 0};
+
+describe('InternalAsset', () => {
+  it('only includes connected files once per filePath', () => {
+    let asset = new UncommittedAsset({
+      value: createAsset({
+        filePath: toProjectPath('/', '/foo/asset.js'),
+        env: createEnvironment(),
+        stats,
+        type: 'js',
+        isSource: true,
+      }),
+      options: DEFAULT_OPTIONS,
+    });
+    asset.invalidateOnFileChange(toProjectPath('/', '/foo/file'));
+    asset.invalidateOnFileChange(toProjectPath('/', '/foo/file'));
+    assert.deepEqual(
+      asset.invalidations.invalidateOnFileChange,
+      new Set(['foo/file']),
+    );
+  });
+
+  it('only includes dependencies once per id', () => {
+    let asset = new UncommittedAsset({
+      value: createAsset({
+        filePath: toProjectPath('/', '/foo/asset.js'),
+        env: createEnvironment(),
+        stats,
+        type: 'js',
+        isSource: true,
+      }),
+      options: DEFAULT_OPTIONS,
+    });
+
+    asset.addDependency({specifier: './foo', specifierType: 'esm'});
+    asset.addDependency({specifier: './foo', specifierType: 'esm'});
+    let dependencies = asset.getDependencies();
+    assert(dependencies.length === 1);
+    assert(dependencies[0].specifier === './foo');
+  });
+
+  it('includes different dependencies if their id differs', () => {
+    let asset = new UncommittedAsset({
+      value: createAsset({
+        filePath: toProjectPath('/', '/foo/asset.js'),
+        env: createEnvironment(),
+        stats,
+        type: 'js',
+        isSource: true,
+      }),
+      options: DEFAULT_OPTIONS,
+    });
+
+    asset.addDependency({specifier: './foo', specifierType: 'esm'});
+    asset.addDependency({
+      specifier: './foo',
+      specifierType: 'esm',
+      env: {context: 'web-worker', engines: {}},
+    });
+    let dependencies = asset.getDependencies();
+    assert(dependencies.length === 2);
+  });
+});

package/test/PackagerRunner.test.js

@@ -0,0 +1,27 @@
+// // @flow
+// 'use strict';
+
+// const PackagerRunner = require('../src/PackagerRunner');
+// const assert = require('assert');
+// const path = require('path');
+
+// const config = require('@atlaspack/config-default');
+
+// describe('PackagerRunner', () => {
+//   it('works', async () => {
+//     let bundle = {
+//       destPath: path.join(__dirname, 'dist', 'bundle.js'),
+//       assets: [
+//         {blobs: {code: require.resolve('./fixtures/module-a')}},
+//         {blobs: {code: require.resolve('./fixtures/module-b')}},
+//       ],
+//     };
+
+//     let packagerRunner = new PackagerRunner({
+//       atlaspackConfig: config,
+//       options: {}
+//     });
+
+//     await packagerRunner.runPackager({ bundle });
+//   });
+// });

package/test/PublicAsset.test.js

@@ -0,0 +1,40 @@
+// @flow strict-local
+
+import assert from 'assert';
+import {Asset, MutableAsset} from '../src/public/Asset';
+import UncommittedAsset from '../src/UncommittedAsset';
+import {createAsset as _createAsset} from '../src/assetUtils';
+import {createEnvironment} from '../src/Environment';
+import {DEFAULT_OPTIONS} from './test-utils';
+import {toProjectPath} from '../src/projectPath';
+
+function createAsset(opts) {
+  return _createAsset('/', opts);
+}
+
+describe('Public Asset', () => {
+  let internalAsset;
+  beforeEach(() => {
+    internalAsset = new UncommittedAsset({
+      options: DEFAULT_OPTIONS,
+      value: createAsset({
+        filePath: toProjectPath('/', '/does/not/exist'),
+        type: 'js',
+        env: createEnvironment({}),
+        isSource: true,
+        stats: {size: 0, time: 0},
+      }),
+    });
+  });
+
+  it('returns the same public Asset given an internal asset', () => {
+    assert.equal(new Asset(internalAsset), new Asset(internalAsset));
+  });
+
+  it('returns the same public MutableAsset given an internal asset', () => {
+    assert.equal(
+      new MutableAsset(internalAsset),
+      new MutableAsset(internalAsset),
+    );
+  });
+});

package/test/PublicBundle.test.js

@@ -0,0 +1,68 @@
+// @flow strict-local
+import type {Bundle as InternalBundle} from '../src/types';
+
+import assert from 'assert';
+import {ContentGraph} from '@atlaspack/graph';
+
+import {Bundle, NamedBundle, PackagedBundle} from '../src/public/Bundle';
+import BundleGraph from '../src/BundleGraph';
+import {createEnvironment} from '../src/Environment';
+import {DEFAULT_OPTIONS} from './test-utils';
+import {toProjectPath} from '../src/projectPath';
+
+describe('Public Bundle', () => {
+  let internalBundle: InternalBundle;
+  let bundleGraph;
+  beforeEach(() => {
+    let env = createEnvironment({});
+    internalBundle = {
+      id: '123',
+      hashReference: '@@HASH_REFERENCE_123',
+      entryAssetIds: [],
+      mainEntryId: null,
+      type: 'js',
+      env,
+      name: null,
+      displayName: null,
+      publicId: null,
+      pipeline: null,
+      needsStableName: null,
+      bundleBehavior: null,
+      isSplittable: true,
+      target: {
+        env,
+        distDir: toProjectPath('/', '/'),
+        name: '',
+        publicUrl: '',
+      },
+    };
+
+    bundleGraph = new BundleGraph({
+      graph: new ContentGraph(),
+      assetPublicIds: new Set(),
+      publicIdByAssetId: new Map(),
+      bundleContentHashes: new Map(),
+    });
+  });
+
+  it('returns the same public Bundle given an internal bundle', () => {
+    assert.equal(
+      Bundle.get(internalBundle, bundleGraph, DEFAULT_OPTIONS),
+      Bundle.get(internalBundle, bundleGraph, DEFAULT_OPTIONS),
+    );
+  });
+
+  it('returns the same public NamedBundle given an internal bundle', () => {
+    assert.equal(
+      NamedBundle.get(internalBundle, bundleGraph, DEFAULT_OPTIONS),
+      NamedBundle.get(internalBundle, bundleGraph, DEFAULT_OPTIONS),
+    );
+  });
+
+  it('returns the same public PackagedBundle given an internal bundle', () => {
+    assert.equal(
+      PackagedBundle.get(internalBundle, bundleGraph, DEFAULT_OPTIONS),
+      PackagedBundle.get(internalBundle, bundleGraph, DEFAULT_OPTIONS),
+    );
+  });
+});

package/test/PublicDependency.test.js

@@ -0,0 +1,22 @@
+// @flow strict-local
+
+import assert from 'assert';
+import {createEnvironment} from '../src/Environment';
+import {createDependency} from '../src/Dependency';
+import {getPublicDependency} from '../src/public/Dependency';
+import {DEFAULT_OPTIONS} from './test-utils';
+
+describe('Public Dependency', () => {
+  it('returns the same public Dependency given an internal dependency', () => {
+    let internalDependency = createDependency('/', {
+      specifier: 'foo',
+      specifierType: 'esm',
+      env: createEnvironment({}),
+    });
+
+    assert.equal(
+      getPublicDependency(internalDependency, DEFAULT_OPTIONS),
+      getPublicDependency(internalDependency, DEFAULT_OPTIONS),
+    );
+  });
+});

package/test/PublicEnvironment.test.js

@@ -0,0 +1,27 @@
+// @flow strict-local
+
+import assert from 'assert';
+import {createEnvironment} from '../src/Environment';
+import PublicEnvironment from '../src/public/Environment';
+import {DEFAULT_OPTIONS} from './test-utils';
+
+describe('Public Environment', () => {
+  it('has correct support data for ChromeAndroid', () => {
+    let env = new PublicEnvironment(
+      createEnvironment({
+        context: 'browser',
+        engines: {
+          browsers: ['last 1 Chrome version', 'last 1 ChromeAndroid version'],
+        },
+        outputFormat: 'esmodule',
+      }),
+      DEFAULT_OPTIONS,
+    );
+
+    assert(env.supports('esmodules'));
+    assert(env.supports('dynamic-import'));
+    assert(env.supports('worker-module'));
+    assert(env.supports('import-meta-url'));
+    assert(env.supports('arrow-functions'));
+  });
+});