@atlaspack/core 2.12.1-canary.3354

package/test/TargetRequest.test.js

@@ -0,0 +1,1715 @@
+// @flow strict-local
+
+import assert from 'assert';
+import path from 'path';
+import tempy from 'tempy';
+import {inputFS as fs} from '@atlaspack/test-utils';
+import {md} from '@atlaspack/diagnostic';
+import {normalizeSeparators} from '@atlaspack/utils';
+import {TargetResolver} from '../src/requests/TargetRequest';
+import {DEFAULT_OPTIONS as _DEFAULT_OPTIONS, relative} from './test-utils';
+
+const DEFAULT_OPTIONS = {
+  ..._DEFAULT_OPTIONS,
+  defaultTargetOptions: {
+    ..._DEFAULT_OPTIONS.defaultTargetOptions,
+    sourceMaps: true,
+  },
+};
+
+const COMMON_TARGETS_FIXTURE_PATH = path.join(
+  __dirname,
+  'fixtures/common-targets',
+);
+
+const COMMON_TARGETS_IGNORE_FIXTURE_PATH = path.join(
+  __dirname,
+  'fixtures/common-targets-ignore',
+);
+
+const CUSTOM_TARGETS_FIXTURE_PATH = path.join(
+  __dirname,
+  'fixtures/custom-targets',
+);
+
+const CUSTOM_TARGETS_DISTDIR_FIXTURE_PATH = path.join(
+  __dirname,
+  'fixtures/custom-targets-distdir',
+);
+
+const INVALID_TARGETS_FIXTURE_PATH = path.join(
+  __dirname,
+  'fixtures/invalid-targets',
+);
+
+const INVALID_ENGINES_FIXTURE_PATH = path.join(
+  __dirname,
+  'fixtures/invalid-engines',
+);
+
+const INVALID_DISTPATH_FIXTURE_PATH = path.join(
+  __dirname,
+  'fixtures/invalid-distpath',
+);
+
+const DEFAULT_DISTPATH_FIXTURE_PATHS = {
+  none: path.join(__dirname, 'fixtures/targets-default-distdir-none'),
+  one: path.join(__dirname, 'fixtures/targets-default-distdir-one'),
+  two: path.join(__dirname, 'fixtures/targets-default-distdir-two'),
+};
+
+const CONTEXT_FIXTURE_PATH = path.join(__dirname, 'fixtures/context');
+
+describe('TargetResolver', () => {
+  let cacheDir;
+  beforeEach(() => {
+    cacheDir = tempy.directory();
+  });
+
+  afterEach(() => {
+    return fs.rimraf(cacheDir);
+  });
+
+  let api = {
+    invalidateOnFileCreate() {},
+    invalidateOnFileUpdate() {},
+    invalidateOnConfigKeyChange() {},
+    invalidateOnFileDelete() {},
+    invalidateOnEnvChange() {},
+    invalidateOnOptionChange() {},
+    invalidateOnStartup() {},
+    invalidateOnBuild() {},
+    getInvalidations() {
+      return [];
+    },
+    runRequest() {
+      throw new Error('Not implemented');
+    },
+    storeResult() {},
+    canSkipSubrequest() {
+      return false;
+    },
+    getPreviousResult() {},
+    getRequestResult() {},
+    getSubRequests() {
+      return [];
+    },
+    getInvalidSubRequests() {
+      return [];
+    },
+  };
+
+  it('resolves exactly specified targets', async () => {
+    let targetResolver = new TargetResolver(api, {
+      ...DEFAULT_OPTIONS,
+      targets: {
+        customA: {
+          context: 'browser',
+          distDir: 'customA',
+        },
+        customB: {
+          distDir: 'customB',
+          distEntry: 'b.js',
+          engines: {
+            node: '>= 8.0.0',
+          },
+        },
+      },
+    });
+
+    assert.deepEqual(
+      await targetResolver.resolve(COMMON_TARGETS_FIXTURE_PATH),
+      [
+        {
+          name: 'customA',
+          publicUrl: '/',
+          distDir: normalizeSeparators(path.resolve('customA')),
+          env: {
+            id: '1d40417b63734b32',
+            context: 'browser',
+            includeNodeModules: true,
+            engines: {
+              browsers: ['> 0.25%'],
+            },
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: false,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+        },
+        {
+          name: 'customB',
+          publicUrl: '/',
+          distEntry: 'b.js',
+          distDir: normalizeSeparators(path.resolve('customB')),
+          env: {
+            id: '928f0d1c941b2e57',
+            context: 'node',
+            includeNodeModules: false,
+            engines: {
+              node: '>= 8.0.0',
+            },
+            outputFormat: 'commonjs',
+            isLibrary: false,
+            shouldOptimize: false,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+        },
+      ],
+    );
+  });
+
+  it('resolves common targets from package.json', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+
+    assert.deepEqual(
+      await targetResolver.resolve(COMMON_TARGETS_FIXTURE_PATH),
+      [
+        {
+          name: 'main',
+          distDir: 'fixtures/common-targets/dist/main',
+          distEntry: 'index.js',
+          publicUrl: '/',
+          env: {
+            id: 'b552bd32da37fa8b',
+            context: 'node',
+            engines: {
+              node: '>= 8.0.0',
+            },
+            includeNodeModules: false,
+            outputFormat: 'commonjs',
+            isLibrary: true,
+            shouldOptimize: false,
+            shouldScopeHoist: true,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(COMMON_TARGETS_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              column: 11,
+              line: 2,
+            },
+            end: {
+              column: 31,
+              line: 2,
+            },
+          },
+        },
+        {
+          name: 'module',
+          distDir: 'fixtures/common-targets/dist/module',
+          distEntry: 'index.js',
+          publicUrl: '/',
+          env: {
+            id: '8804e4eb97e2703e',
+            context: 'browser',
+            engines: {
+              browsers: ['last 1 version'],
+            },
+            includeNodeModules: false,
+            outputFormat: 'esmodule',
+            isLibrary: true,
+            shouldOptimize: false,
+            shouldScopeHoist: true,
+            sourceMap: {
+              inlineSources: true,
+            },
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(COMMON_TARGETS_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              column: 13,
+              line: 3,
+            },
+            end: {
+              column: 35,
+              line: 3,
+            },
+          },
+        },
+        {
+          name: 'browser',
+          distDir: 'fixtures/common-targets/dist/browser',
+          distEntry: 'index.js',
+          publicUrl: '/assets',
+          env: {
+            id: 'a7ed3e73c53f1923',
+            context: 'browser',
+            engines: {
+              browsers: ['last 1 version'],
+            },
+            includeNodeModules: false,
+            outputFormat: 'commonjs',
+            isLibrary: true,
+            shouldOptimize: false,
+            shouldScopeHoist: true,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(COMMON_TARGETS_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              column: 14,
+              line: 4,
+            },
+            end: {
+              column: 37,
+              line: 4,
+            },
+          },
+        },
+      ],
+    );
+  });
+
+  it('allows ignoring common targets from package.json', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+
+    assert.deepEqual(
+      await targetResolver.resolve(COMMON_TARGETS_IGNORE_FIXTURE_PATH),
+      [
+        {
+          name: 'app',
+          distDir: relative(
+            path.join(COMMON_TARGETS_IGNORE_FIXTURE_PATH, 'dist'),
+          ),
+          distEntry: 'index.js',
+          publicUrl: '/',
+          env: {
+            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',
+          },
+          loc: {
+            filePath: relative(
+              path.join(COMMON_TARGETS_IGNORE_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              column: 10,
+              line: 3,
+            },
+            end: {
+              column: 25,
+              line: 3,
+            },
+          },
+        },
+      ],
+    );
+  });
+
+  it('resolves custom targets from package.json', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    assert.deepEqual(
+      await targetResolver.resolve(CUSTOM_TARGETS_FIXTURE_PATH),
+      [
+        {
+          name: 'main',
+          distDir: 'fixtures/custom-targets/dist/main',
+          distEntry: 'index.js',
+          publicUrl: '/',
+          env: {
+            id: 'b552bd32da37fa8b',
+            context: 'node',
+            engines: {
+              node: '>= 8.0.0',
+            },
+            includeNodeModules: false,
+            outputFormat: 'commonjs',
+            isLibrary: true,
+            shouldOptimize: false,
+            shouldScopeHoist: true,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(CUSTOM_TARGETS_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              column: 11,
+              line: 2,
+            },
+            end: {
+              column: 31,
+              line: 2,
+            },
+          },
+        },
+        {
+          name: 'browserModern',
+          distDir: 'fixtures/custom-targets/dist/browserModern',
+          distEntry: 'index.js',
+          publicUrl: '/',
+          env: {
+            id: '1f28e9ceaf633d83',
+            context: 'browser',
+            engines: {
+              browsers: ['last 1 version'],
+            },
+            includeNodeModules: true,
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: false,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(CUSTOM_TARGETS_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              column: 20,
+              line: 3,
+            },
+            end: {
+              column: 49,
+              line: 3,
+            },
+          },
+        },
+        {
+          name: 'browserLegacy',
+          distDir: 'fixtures/custom-targets/dist/browserLegacy',
+          distEntry: 'index.js',
+          publicUrl: '/',
+          env: {
+            id: '767bf6e6b675c4f3',
+            context: 'browser',
+            engines: {
+              browsers: ['ie11'],
+            },
+            includeNodeModules: true,
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: false,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(CUSTOM_TARGETS_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              column: 20,
+              line: 4,
+            },
+            end: {
+              column: 49,
+              line: 4,
+            },
+          },
+        },
+      ],
+    );
+  });
+
+  it('should not optimize libraries by default', async () => {
+    let targetResolver = new TargetResolver(api, {
+      ...DEFAULT_OPTIONS,
+      mode: 'production',
+      defaultTargetOptions: {
+        ...DEFAULT_OPTIONS.defaultTargetOptions,
+        shouldOptimize: true,
+      },
+    });
+
+    assert.deepEqual(
+      await targetResolver.resolve(CUSTOM_TARGETS_FIXTURE_PATH),
+      [
+        {
+          name: 'main',
+          distDir: 'fixtures/custom-targets/dist/main',
+          distEntry: 'index.js',
+          publicUrl: '/',
+          env: {
+            id: 'b552bd32da37fa8b',
+            context: 'node',
+            engines: {
+              node: '>= 8.0.0',
+            },
+            includeNodeModules: false,
+            outputFormat: 'commonjs',
+            isLibrary: true,
+            shouldOptimize: false,
+            shouldScopeHoist: true,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(CUSTOM_TARGETS_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              column: 11,
+              line: 2,
+            },
+            end: {
+              column: 31,
+              line: 2,
+            },
+          },
+        },
+        {
+          name: 'browserModern',
+          distDir: 'fixtures/custom-targets/dist/browserModern',
+          distEntry: 'index.js',
+          publicUrl: '/',
+          env: {
+            id: 'ed7c0e65adee71c9',
+            context: 'browser',
+            engines: {
+              browsers: ['last 1 version'],
+            },
+            includeNodeModules: true,
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: true,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(CUSTOM_TARGETS_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              column: 20,
+              line: 3,
+            },
+            end: {
+              column: 49,
+              line: 3,
+            },
+          },
+        },
+        {
+          name: 'browserLegacy',
+          distDir: 'fixtures/custom-targets/dist/browserLegacy',
+          distEntry: 'index.js',
+          publicUrl: '/',
+          env: {
+            id: 'f7692543e59e4c0a',
+            context: 'browser',
+            engines: {
+              browsers: ['ie11'],
+            },
+            includeNodeModules: true,
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: true,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(CUSTOM_TARGETS_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              column: 20,
+              line: 4,
+            },
+            end: {
+              column: 49,
+              line: 4,
+            },
+          },
+        },
+      ],
+    );
+  });
+
+  it('resolves explicit distDir for custom targets from package.json', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    assert.deepEqual(
+      await targetResolver.resolve(CUSTOM_TARGETS_DISTDIR_FIXTURE_PATH),
+      [
+        {
+          name: 'app',
+          distDir: 'fixtures/custom-targets-distdir/www',
+          distEntry: undefined,
+          publicUrl: 'www',
+          env: {
+            id: 'ddb6ac7c9a3a9178',
+            context: 'browser',
+            engines: {
+              browsers: '> 0.25%',
+            },
+            includeNodeModules: true,
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: false,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(CUSTOM_TARGETS_DISTDIR_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              line: 3,
+              column: 5,
+            },
+            end: {
+              line: 3,
+              column: 10,
+            },
+          },
+        },
+      ],
+    );
+  });
+
+  it('skips targets with custom entry source for default entry', async () => {
+    let targetResolver = new TargetResolver(api, {
+      ...DEFAULT_OPTIONS,
+      targets: {
+        customA: {
+          context: 'browser',
+          distDir: 'customA',
+          source: 'customA/index.js',
+        },
+        customB: {
+          distDir: 'customB',
+        },
+      },
+    });
+
+    assert.deepEqual(
+      await targetResolver.resolve(COMMON_TARGETS_FIXTURE_PATH),
+      [
+        {
+          name: 'customB',
+          distDir: normalizeSeparators(path.resolve('customB')),
+          publicUrl: '/',
+          env: {
+            id: '1d40417b63734b32',
+            context: 'browser',
+            engines: {
+              browsers: ['> 0.25%'],
+            },
+            includeNodeModules: true,
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: false,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+        },
+      ],
+    );
+  });
+
+  it('skips other targets with custom entry', async () => {
+    let targetResolver = new TargetResolver(api, {
+      ...DEFAULT_OPTIONS,
+      targets: {
+        customA: {
+          context: 'browser',
+          distDir: 'customA',
+          source: 'customA/index.js',
+        },
+        customB: {
+          distDir: 'customB',
+        },
+      },
+    });
+
+    assert.deepEqual(
+      await targetResolver.resolve(COMMON_TARGETS_FIXTURE_PATH, 'customA'),
+      [
+        {
+          name: 'customA',
+          distDir: normalizeSeparators(path.resolve('customA')),
+          publicUrl: '/',
+          env: {
+            id: '1d40417b63734b32',
+            context: 'browser',
+            engines: {
+              browsers: ['> 0.25%'],
+            },
+            includeNodeModules: true,
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: false,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          source: 'customA/index.js',
+        },
+      ],
+    );
+  });
+
+  it('resolves main target with context from package.json', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    assert.deepEqual(await targetResolver.resolve(CONTEXT_FIXTURE_PATH), [
+      {
+        name: 'main',
+        distDir: 'fixtures/context/dist/main',
+        distEntry: 'index.js',
+        publicUrl: '/',
+        env: {
+          id: '6aafdb9eaa4a3812',
+          context: 'node',
+          engines: {
+            browsers: [
+              'last 1 Chrome version',
+              'last 1 Safari version',
+              'last 1 Firefox version',
+              'last 1 Edge version',
+            ],
+          },
+          includeNodeModules: false,
+          isLibrary: true,
+          outputFormat: 'commonjs',
+          shouldOptimize: false,
+          shouldScopeHoist: true,
+          sourceMap: {},
+          loc: undefined,
+          sourceType: 'module',
+        },
+        loc: {
+          filePath: relative(path.join(CONTEXT_FIXTURE_PATH, 'package.json')),
+          start: {
+            column: 11,
+            line: 2,
+          },
+          end: {
+            column: 31,
+            line: 2,
+          },
+        },
+      },
+    ]);
+  });
+
+  it('errors when the main target contains a non-js extension', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let fixture = path.join(__dirname, 'fixtures/application-targets');
+    let code = await fs.readFile(path.join(fixture, 'package.json'), 'utf8');
+
+    // $FlowFixMe
+    await assert.rejects(() => targetResolver.resolve(fixture), {
+      diagnostics: [
+        {
+          message: 'Unexpected output file type .html in target "main"',
+          origin: '@atlaspack/core',
+          codeFrames: [
+            {
+              filePath: path.join(fixture, 'package.json'),
+              language: 'json',
+              code,
+              codeHighlights: [
+                {
+                  end: {
+                    column: 27,
+                    line: 2,
+                  },
+                  message: 'File extension must be .js, .mjs, or .cjs',
+                  start: {
+                    column: 11,
+                    line: 2,
+                  },
+                },
+              ],
+            },
+          ],
+          hints: [
+            'The "main" field is meant for libraries. If you meant to output a .html file, either remove the "main" field or choose a different target name.',
+          ],
+          documentationURL:
+            'https://parceljs.org/features/targets/#library-targets',
+        },
+      ],
+    });
+  });
+
+  it('errors when the main target uses the global output format', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let fixture = path.join(__dirname, 'fixtures/main-global');
+    let code = await fs.readFile(path.join(fixture, 'package.json'), 'utf8');
+
+    // $FlowFixMe
+    await assert.rejects(() => targetResolver.resolve(fixture), {
+      diagnostics: [
+        {
+          message:
+            'The "global" output format is not supported in the "main" target.',
+          origin: '@atlaspack/core',
+          codeFrames: [
+            {
+              filePath: path.join(fixture, 'package.json'),
+              language: 'json',
+              code,
+              codeHighlights: [
+                {
+                  message: undefined,
+                  end: {
+                    column: 30,
+                    line: 5,
+                  },
+                  start: {
+                    column: 23,
+                    line: 5,
+                  },
+                },
+              ],
+            },
+          ],
+          hints: [
+            'The "main" field is meant for libraries. The outputFormat must be either "commonjs" or "esmodule". Either change or remove the declared outputFormat.',
+          ],
+          documentationURL:
+            'https://parceljs.org/features/targets/#library-targets',
+        },
+      ],
+    });
+  });
+
+  it('errors when the main target uses the esmodule output format without a .mjs extension or "type": "module" field', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let fixture = path.join(__dirname, 'fixtures/main-mjs');
+    let code = await fs.readFile(path.join(fixture, 'package.json'), 'utf8');
+
+    // $FlowFixMe
+    await assert.rejects(() => targetResolver.resolve(fixture), {
+      diagnostics: [
+        {
+          message:
+            'Output format "esmodule" cannot be used in the "main" target without a .mjs extension or "type": "module" field.',
+          origin: '@atlaspack/core',
+          codeFrames: [
+            {
+              filePath: path.join(fixture, 'package.json'),
+              language: 'json',
+              code,
+              codeHighlights: [
+                {
+                  message: 'Declared output format defined here',
+                  end: {
+                    column: 32,
+                    line: 5,
+                  },
+                  start: {
+                    column: 23,
+                    line: 5,
+                  },
+                },
+                {
+                  message: 'Inferred output format defined here',
+                  end: {
+                    column: 25,
+                    line: 2,
+                  },
+                  start: {
+                    column: 11,
+                    line: 2,
+                  },
+                },
+              ],
+            },
+          ],
+          hints: [
+            'Either change the output file extension to .mjs, add "type": "module" to package.json, or remove the declared outputFormat.',
+          ],
+          documentationURL:
+            'https://parceljs.org/features/targets/#library-targets',
+        },
+      ],
+    });
+  });
+
+  it('errors when the inferred output format does not match the declared one in common targets', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let fixture = path.join(__dirname, 'fixtures/main-format-mismatch');
+    let code = await fs.readFile(path.join(fixture, 'package.json'), 'utf8');
+
+    // $FlowFixMe
+    await assert.rejects(() => targetResolver.resolve(fixture), {
+      diagnostics: [
+        {
+          message:
+            'Declared output format "esmodule" does not match expected output format "commonjs".',
+          origin: '@atlaspack/core',
+          codeFrames: [
+            {
+              filePath: path.join(fixture, 'package.json'),
+              language: 'json',
+              code,
+              codeHighlights: [
+                {
+                  message: 'Declared output format defined here',
+                  end: {
+                    column: 32,
+                    line: 5,
+                  },
+                  start: {
+                    column: 23,
+                    line: 5,
+                  },
+                },
+                {
+                  message: 'Inferred output format defined here',
+                  end: {
+                    column: 26,
+                    line: 2,
+                  },
+                  start: {
+                    column: 11,
+                    line: 2,
+                  },
+                },
+              ],
+            },
+          ],
+          hints: [
+            'Either remove the target\'s declared "outputFormat" or change the extension to .mjs or .js.',
+          ],
+          documentationURL:
+            'https://parceljs.org/features/targets/#library-targets',
+        },
+      ],
+    });
+  });
+
+  it('errors when the inferred output format does not match the declared one in custom targets', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let fixture = path.join(__dirname, 'fixtures/custom-format-mismatch');
+    let code = await fs.readFile(path.join(fixture, 'package.json'), 'utf8');
+
+    // $FlowFixMe
+    await assert.rejects(() => targetResolver.resolve(fixture), {
+      diagnostics: [
+        {
+          message:
+            'Declared output format "commonjs" does not match expected output format "esmodule".',
+          origin: '@atlaspack/core',
+          codeFrames: [
+            {
+              filePath: path.join(fixture, 'package.json'),
+              language: 'json',
+              code,
+              codeHighlights: [
+                {
+                  message: 'Declared output format defined here',
+                  end: {
+                    column: 32,
+                    line: 5,
+                  },
+                  start: {
+                    column: 23,
+                    line: 5,
+                  },
+                },
+                {
+                  message: 'Inferred output format defined here',
+                  end: {
+                    column: 26,
+                    line: 2,
+                  },
+                  start: {
+                    column: 11,
+                    line: 2,
+                  },
+                },
+              ],
+            },
+          ],
+          hints: [
+            'Either remove the target\'s declared "outputFormat" or change the extension to .cjs or .js.',
+          ],
+          documentationURL:
+            'https://parceljs.org/features/targets/#library-targets',
+        },
+      ],
+    });
+  });
+
+  it('errors when a common library target turns scope hoisting off', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let fixture = path.join(__dirname, 'fixtures/library-scopehoist');
+    let code = await fs.readFile(path.join(fixture, 'package.json'), 'utf8');
+
+    // $FlowFixMe
+    await assert.rejects(() => targetResolver.resolve(fixture), {
+      diagnostics: [
+        {
+          message: 'Scope hoisting cannot be disabled for library targets.',
+          origin: '@atlaspack/core',
+          codeFrames: [
+            {
+              filePath: path.join(fixture, 'package.json'),
+              language: 'json',
+              code,
+              codeHighlights: [
+                {
+                  message: undefined,
+                  end: {
+                    column: 25,
+                    line: 5,
+                  },
+                  start: {
+                    column: 21,
+                    line: 5,
+                  },
+                },
+              ],
+            },
+          ],
+          hints: [
+            'The "main" target is meant for libraries. Either remove the "scopeHoist" option, or use a different target name.',
+          ],
+          documentationURL:
+            'https://parceljs.org/features/targets/#library-targets',
+        },
+      ],
+    });
+  });
+
+  it('errors when a custom library target turns scope hoisting off', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let fixture = path.join(__dirname, 'fixtures/library-custom-scopehoist');
+    let code = await fs.readFile(path.join(fixture, 'package.json'), 'utf8');
+
+    // $FlowFixMe
+    await assert.rejects(() => targetResolver.resolve(fixture), {
+      diagnostics: [
+        {
+          message: 'Scope hoisting cannot be disabled for library targets.',
+          origin: '@atlaspack/core',
+          codeFrames: [
+            {
+              filePath: path.join(fixture, 'package.json'),
+              language: 'json',
+              code,
+              codeHighlights: [
+                {
+                  message: undefined,
+                  end: {
+                    column: 25,
+                    line: 6,
+                  },
+                  start: {
+                    column: 21,
+                    line: 6,
+                  },
+                },
+                {
+                  message: undefined,
+                  end: {
+                    column: 23,
+                    line: 5,
+                  },
+                  start: {
+                    column: 20,
+                    line: 5,
+                  },
+                },
+              ],
+            },
+          ],
+          hints: ['Either remove the "scopeHoist" or "isLibrary" option.'],
+          documentationURL:
+            'https://parceljs.org/features/targets/#library-targets',
+        },
+      ],
+    });
+  });
+
+  it('should infer output format for custom targets by extension', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let fixture = path.join(__dirname, 'fixtures/custom-format-infer-ext');
+
+    assert.deepEqual(await targetResolver.resolve(fixture), [
+      {
+        name: 'test',
+        distDir: relative(path.join(fixture, 'dist')),
+        distEntry: 'index.mjs',
+        publicUrl: '/',
+        env: {
+          id: '439701173a9199ea',
+          context: 'browser',
+          engines: {
+            browsers: [
+              'last 1 Chrome version',
+              'last 1 Safari version',
+              'last 1 Firefox version',
+              'last 1 Edge version',
+            ],
+          },
+          includeNodeModules: true,
+          outputFormat: 'esmodule',
+          isLibrary: false,
+          shouldOptimize: false,
+          shouldScopeHoist: false,
+          sourceMap: {},
+          loc: undefined,
+          sourceType: 'module',
+        },
+        loc: {
+          filePath: relative(path.join(fixture, 'package.json')),
+          start: {
+            column: 11,
+            line: 2,
+          },
+          end: {
+            column: 27,
+            line: 2,
+          },
+        },
+      },
+    ]);
+  });
+
+  it('should infer output format for custom targets by "type": "module" field', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let fixture = path.join(__dirname, 'fixtures/custom-format-infer-type');
+
+    assert.deepEqual(await targetResolver.resolve(fixture), [
+      {
+        name: 'test',
+        distDir: relative(path.join(fixture, 'dist')),
+        distEntry: 'index.js',
+        publicUrl: '/',
+        env: {
+          id: '439701173a9199ea',
+          context: 'browser',
+          engines: {
+            browsers: [
+              'last 1 Chrome version',
+              'last 1 Safari version',
+              'last 1 Firefox version',
+              'last 1 Edge version',
+            ],
+          },
+          includeNodeModules: true,
+          outputFormat: 'esmodule',
+          isLibrary: false,
+          shouldOptimize: false,
+          shouldScopeHoist: false,
+          sourceMap: {},
+          loc: undefined,
+          sourceType: 'module',
+        },
+        loc: {
+          filePath: relative(path.join(fixture, 'package.json')),
+          start: {
+            column: 11,
+            line: 3,
+          },
+          end: {
+            column: 26,
+            line: 3,
+          },
+        },
+      },
+    ]);
+  });
+
+  it('resolves a subset of package.json targets when given a list of names', async () => {
+    let targetResolver = new TargetResolver(api, {
+      ...DEFAULT_OPTIONS,
+      targets: ['main', 'browser'],
+    });
+
+    assert.deepEqual(
+      await targetResolver.resolve(COMMON_TARGETS_FIXTURE_PATH),
+      [
+        {
+          name: 'main',
+          distDir: 'fixtures/common-targets/dist/main',
+          distEntry: 'index.js',
+          publicUrl: '/',
+          env: {
+            id: 'b552bd32da37fa8b',
+            context: 'node',
+            engines: {
+              node: '>= 8.0.0',
+            },
+            includeNodeModules: false,
+            outputFormat: 'commonjs',
+            isLibrary: true,
+            shouldOptimize: false,
+            shouldScopeHoist: true,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(COMMON_TARGETS_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              column: 11,
+              line: 2,
+            },
+            end: {
+              column: 31,
+              line: 2,
+            },
+          },
+        },
+        {
+          name: 'browser',
+          distDir: 'fixtures/common-targets/dist/browser',
+          distEntry: 'index.js',
+          publicUrl: '/assets',
+          env: {
+            id: 'a7ed3e73c53f1923',
+            context: 'browser',
+            engines: {
+              browsers: ['last 1 version'],
+            },
+            includeNodeModules: false,
+            outputFormat: 'commonjs',
+            isLibrary: true,
+            shouldOptimize: false,
+            shouldScopeHoist: true,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(COMMON_TARGETS_FIXTURE_PATH, 'package.json'),
+            ),
+            start: {
+              column: 14,
+              line: 4,
+            },
+            end: {
+              column: 37,
+              line: 4,
+            },
+          },
+        },
+      ],
+    );
+  });
+
+  it('generates a default target in serve mode', async () => {
+    let serveDistDir = path.join(DEFAULT_OPTIONS.cacheDir, 'dist');
+
+    let targetResolver = new TargetResolver(api, {
+      ...DEFAULT_OPTIONS,
+      serveOptions: {distDir: serveDistDir, port: 1234},
+    });
+
+    assert.deepEqual(
+      await targetResolver.resolve(COMMON_TARGETS_FIXTURE_PATH),
+      [
+        {
+          name: 'default',
+          distDir: '.atlaspack-cache/dist',
+          publicUrl: '/',
+          env: {
+            id: 'd6ea1d42532a7575',
+            context: 'browser',
+            engines: {
+              browsers: [
+                'last 1 Chrome version',
+                'last 1 Safari version',
+                'last 1 Firefox version',
+                'last 1 Edge version',
+              ],
+            },
+            includeNodeModules: true,
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: false,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+        },
+      ],
+    );
+  });
+
+  it('generates the correct distDir with no explicit targets', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+
+    assert.deepEqual(
+      await targetResolver.resolve(DEFAULT_DISTPATH_FIXTURE_PATHS.none),
+      [
+        {
+          name: 'default',
+          distDir: relative(
+            path.join(DEFAULT_DISTPATH_FIXTURE_PATHS.none, 'dist'),
+          ),
+          publicUrl: '/',
+          env: {
+            id: 'a9c07d094d038c73',
+            context: 'browser',
+            engines: {
+              browsers: ['Chrome 80'],
+            },
+            includeNodeModules: true,
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: false,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+        },
+      ],
+    );
+  });
+
+  it('generates the correct distDir with one explicit target', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+
+    assert.deepEqual(
+      await targetResolver.resolve(DEFAULT_DISTPATH_FIXTURE_PATHS.one),
+      [
+        {
+          name: 'browserModern',
+          distDir: relative(
+            path.join(DEFAULT_DISTPATH_FIXTURE_PATHS.one, 'dist'),
+          ),
+          distEntry: undefined,
+          publicUrl: '/',
+          env: {
+            id: 'a9c07d094d038c73',
+            context: 'browser',
+            engines: {
+              browsers: ['Chrome 80'],
+            },
+            includeNodeModules: true,
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: false,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(DEFAULT_DISTPATH_FIXTURE_PATHS.one, 'package.json'),
+            ),
+            start: {
+              line: 3,
+              column: 5,
+            },
+            end: {
+              line: 3,
+              column: 20,
+            },
+          },
+        },
+      ],
+    );
+  });
+
+  it('generates the correct distDirs with two explicit targets', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+
+    assert.deepEqual(
+      await targetResolver.resolve(DEFAULT_DISTPATH_FIXTURE_PATHS.two),
+      [
+        {
+          name: 'browserModern',
+          distDir: relative(
+            path.join(
+              DEFAULT_DISTPATH_FIXTURE_PATHS.two,
+              'dist',
+              'browserModern',
+            ),
+          ),
+          distEntry: undefined,
+          publicUrl: '/',
+          env: {
+            id: '1f28e9ceaf633d83',
+            context: 'browser',
+            engines: {
+              browsers: ['last 1 version'],
+            },
+            includeNodeModules: true,
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: false,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(DEFAULT_DISTPATH_FIXTURE_PATHS.two, 'package.json'),
+            ),
+            start: {
+              line: 3,
+              column: 5,
+            },
+            end: {
+              line: 3,
+              column: 20,
+            },
+          },
+        },
+        {
+          name: 'browserLegacy',
+          distDir: relative(
+            path.join(
+              DEFAULT_DISTPATH_FIXTURE_PATHS.two,
+              'dist',
+              'browserLegacy',
+            ),
+          ),
+          distEntry: undefined,
+          publicUrl: '/',
+          env: {
+            id: '824e113c03cab3c8',
+            context: 'browser',
+            engines: {
+              browsers: ['IE 11'],
+            },
+            includeNodeModules: true,
+            outputFormat: 'global',
+            isLibrary: false,
+            shouldOptimize: false,
+            shouldScopeHoist: false,
+            sourceMap: {},
+            loc: undefined,
+            sourceType: 'module',
+          },
+          loc: {
+            filePath: relative(
+              path.join(DEFAULT_DISTPATH_FIXTURE_PATHS.two, 'package.json'),
+            ),
+            start: {
+              line: 10,
+              column: 5,
+            },
+            end: {
+              line: 10,
+              column: 20,
+            },
+          },
+        },
+      ],
+    );
+  });
+
+  it('rejects invalid or unknown fields', async () => {
+    let code =
+      '{\n' +
+      '\t"targets": {\n' +
+      '\t\t"main": {\n' +
+      '\t\t\t"includeNodeModules": [\n' +
+      '\t\t\t\t"react",\n' +
+      '\t\t\t\ttrue\n' +
+      '\t\t\t],\n' +
+      '\t\t\t"context": "nodes",\n' +
+      '\t\t\t"outputFormat": "module",\n' +
+      '\t\t\t"sourceMap": {\n' +
+      '\t\t\t\t"sourceRoot": "asd",\n' +
+      '\t\t\t\t"inline": "false",\n' +
+      '\t\t\t\t"verbose": true\n' +
+      '\t\t\t},\n' +
+      '\t\t\t"engines": {\n' +
+      '\t\t\t\t"node": "12",\n' +
+      '\t\t\t\t"browser": "Chrome 70"\n' +
+      '\t\t\t}\n' +
+      '\t\t}\n' +
+      '\t}\n' +
+      '}';
+    let targetResolver = new TargetResolver(api, {
+      ...DEFAULT_OPTIONS,
+      ...JSON.parse(code),
+    });
+
+    // $FlowFixMe assert.rejects is Node 10+
+    await assert.rejects(
+      () => targetResolver.resolve(COMMON_TARGETS_FIXTURE_PATH),
+      {
+        message: 'Invalid target descriptor for target "main"',
+        diagnostics: [
+          {
+            message: 'Invalid target descriptor for target "main"',
+            origin: '@atlaspack/core',
+            codeFrames: [
+              {
+                filePath: undefined,
+                language: 'json',
+                code,
+                codeHighlights: [
+                  {
+                    start: {line: 6, column: 5},
+                    end: {line: 6, column: 8},
+                    message: 'Expected a wildcard or filepath',
+                  },
+                  {
+                    start: {line: 8, column: 15},
+                    end: {line: 8, column: 21},
+                    message: 'Did you mean "node"?',
+                  },
+                  {
+                    start: {line: 9, column: 20},
+                    end: {line: 9, column: 27},
+                    message: 'Did you mean "esmodule"?',
+                  },
+                  {
+                    start: {line: 12, column: 15},
+                    end: {line: 12, column: 21},
+                    message: 'Expected type boolean',
+                  },
+                  {
+                    start: {line: 13, column: 5},
+                    end: {line: 13, column: 13},
+                    message: 'Possible values: "inlineSources"',
+                  },
+                  {
+                    start: {line: 17, column: 5},
+                    end: {line: 17, column: 13},
+                    message: 'Did you mean "browsers"?',
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    );
+  });
+
+  it('rejects invalid or unknown fields in package.json', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let code = await fs.readFileSync(
+      path.join(INVALID_TARGETS_FIXTURE_PATH, 'package.json'),
+      'utf8',
+    );
+    // $FlowFixMe assert.rejects is Node 10+
+    await assert.rejects(
+      () => targetResolver.resolve(INVALID_TARGETS_FIXTURE_PATH),
+      {
+        diagnostics: [
+          {
+            message: 'Invalid target descriptor for target "module"',
+            origin: '@atlaspack/core',
+            codeFrames: [
+              {
+                filePath: path.join(
+                  INVALID_TARGETS_FIXTURE_PATH,
+                  'package.json',
+                ),
+                language: 'json',
+                code,
+                codeHighlights: [
+                  {
+                    start: {line: 9, column: 29},
+                    end: {line: 9, column: 35},
+                    message: 'Expected type boolean',
+                  },
+                  {
+                    start: {line: 11, column: 7},
+                    end: {line: 11, column: 17},
+                    message: 'Did you mean "publicUrl"?',
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    );
+  });
+
+  it('rejects invalid engines in package.json', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let code = await fs.readFileSync(
+      path.join(INVALID_ENGINES_FIXTURE_PATH, 'package.json'),
+      'utf8',
+    );
+    // $FlowFixMe assert.rejects is Node 10+
+    await assert.rejects(
+      () => targetResolver.resolve(INVALID_ENGINES_FIXTURE_PATH),
+      {
+        diagnostics: [
+          {
+            message: 'Invalid engines in package.json',
+            origin: '@atlaspack/core',
+            codeFrames: [
+              {
+                filePath: path.join(
+                  INVALID_ENGINES_FIXTURE_PATH,
+                  'package.json',
+                ),
+                language: 'json',
+                code,
+                codeHighlights: [
+                  {
+                    end: {
+                      column: 13,
+                      line: 8,
+                    },
+                    message: 'Did you mean "browsers"?',
+                    start: {
+                      column: 5,
+                      line: 8,
+                    },
+                  },
+                  {
+                    end: {
+                      column: 5,
+                      line: 7,
+                    },
+                    message: 'Expected type string',
+                    start: {
+                      column: 13,
+                      line: 5,
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    );
+  });
+
+  it('rejects target distpath in package.json', async () => {
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let code = await fs.readFileSync(
+      path.join(INVALID_DISTPATH_FIXTURE_PATH, 'package.json'),
+      'utf8',
+    );
+    // $FlowFixMe assert.rejects is Node 10+
+    await assert.rejects(
+      () => targetResolver.resolve(INVALID_DISTPATH_FIXTURE_PATH),
+      {
+        diagnostics: [
+          {
+            message: 'Invalid distPath for target "legacy"',
+            origin: '@atlaspack/core',
+            codeFrames: [
+              {
+                filePath: path.join(
+                  INVALID_DISTPATH_FIXTURE_PATH,
+                  'package.json',
+                ),
+                language: 'json',
+                code,
+                codeHighlights: [
+                  {
+                    end: {
+                      column: 13,
+                      line: 2,
+                    },
+                    message: 'Expected type string',
+                    start: {
+                      column: 13,
+                      line: 2,
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    );
+  });
+
+  it('rejects duplicate target paths', async () => {
+    let fixture = path.join(__dirname, 'fixtures/duplicate-targets');
+    let targetResolver = new TargetResolver(api, DEFAULT_OPTIONS);
+    let code = await fs.readFileSync(
+      path.join(fixture, 'package.json'),
+      'utf8',
+    );
+    // $FlowFixMe assert.rejects is Node 10+
+    await assert.rejects(() => targetResolver.resolve(fixture), {
+      diagnostics: [
+        {
+          message: md`Multiple targets have the same destination path "${path.normalize(
+            'dist/index.js',
+          )}"`,
+          origin: '@atlaspack/core',
+          codeFrames: [
+            {
+              filePath: path.join(fixture, 'package.json'),
+              language: 'json',
+              code,
+              codeHighlights: [
+                {
+                  end: {
+                    column: 25,
+                    line: 2,
+                  },
+                  message: undefined,
+                  start: {
+                    column: 11,
+                    line: 2,
+                  },
+                },
+                {
+                  end: {
+                    column: 27,
+                    line: 3,
+                  },
+                  message: undefined,
+                  start: {
+                    column: 13,
+                    line: 3,
+                  },
+                },
+              ],
+            },
+          ],
+          hints: [
+            'Try removing the duplicate targets, or changing the destination paths.',
+          ],
+        },
+      ],
+    });
+  });
+});