Merge branch 'v2' into cssnano-configuration

packages/bundlers/default/src/DefaultBundler.js

@@ -70,25 +70,25 @@ export default (new Bundler({
 
         let assets = bundleGraph.getDependencyAssets(dependency);
         let resolution = bundleGraph.getDependencyResolution(dependency);
-        // Create a new bundle for entries, async deps, isolated assets, and inline assets.
+        let bundleGroup = context?.bundleGroup;
+        // Create a new bundle for entries, lazy/parallel dependencies, isolated/inline assets.
         if (
-          (dependency.isEntry && resolution) ||
-          (dependency.isAsync && resolution) ||
-          (dependency.isIsolated && resolution) ||
-          resolution?.isIsolated ||
-          resolution?.isInline
+          resolution &&
+          (!bundleGroup ||
+            dependency.priority === 'lazy' ||
+            dependency.priority === 'parallel' ||
+            resolution.bundleBehavior === 'isolated' ||
+            resolution.bundleBehavior === 'inline')
         ) {
-          let bundleGroup = context?.bundleGroup;
           let bundleByType: Map<string, Bundle> =
             context?.bundleByType ?? new Map();
 
-          // Only create a new bundle group for entries, async dependencies, and isolated assets.
+          // Only create a new bundle group for entries, lazy dependencies, and isolated assets.
           // Otherwise, the bundle is loaded together with the parent bundle.
           if (
             !bundleGroup ||
-            dependency.isEntry ||
-            dependency.isAsync ||
-            resolution.isIsolated
+            dependency.priority === 'lazy' ||
+            resolution.bundleBehavior === 'isolated'
           ) {
             bundleGroup = bundleGraph.createBundleGroup(
               dependency,
@@ -101,8 +101,11 @@ export default (new Bundler({
           for (let asset of assets) {
             let bundle = bundleGraph.createBundle({
               entryAsset: asset,
-              isEntry: asset.isInline ? false : Boolean(dependency.isEntry),
-              isInline: asset.isInline,
+              isEntry:
+                asset.bundleBehavior === 'inline'
+                  ? false
+                  : dependency.isEntry || dependency.needsStableName,
+              isInline: asset.bundleBehavior === 'inline',
               target: bundleGroup.target,
             });
             bundleByType.set(bundle.type, bundle);
@@ -132,9 +135,9 @@ export default (new Bundler({
         invariant(context != null);
         invariant(context.parentNode.type === 'asset');
         invariant(context.parentBundle != null);
+        invariant(bundleGroup != null);
         let parentAsset = context.parentNode.value;
         let parentBundle = context.parentBundle;
-        let bundleGroup = nullthrows(context.bundleGroup);
         let bundleByType = nullthrows(context.bundleByType);
 
         for (let asset of assets) {
@@ -156,11 +159,13 @@ export default (new Bundler({
               type: asset.type,
               target: bundleGroup.target,
               isEntry:
-                asset.isInline || dependency.isEntry === false
+                asset.bundleBehavior === 'inline' ||
+                (dependency.priority === 'parallel' &&
+                  !dependency.needsStableName)
                   ? false
                   : parentBundle.isEntry,
-              isInline: asset.isInline,
-              isSplittable: asset.isSplittable ?? true,
+              isInline: asset.bundleBehavior === 'inline',
+              isSplittable: asset.isBundleSplittable ?? true,
               pipeline: asset.pipeline,
             });
             bundleByType.set(bundle.type, bundle);
@@ -254,7 +259,7 @@ export default (new Bundler({
       if (
         node.type !== 'dependency' ||
         node.value.isEntry ||
-        !node.value.isAsync
+        node.value.priority !== 'lazy'
       ) {
         return;
       }
@@ -265,7 +270,7 @@ export default (new Bundler({
       }
 
       let dependency = node.value;
-      if (dependency.isURL) {
+      if (dependency.specifierType === 'url') {
         // Don't internalize dependencies on URLs, e.g. `new Worker('foo.js')`
         return;
       }

packages/core/core/src/AssetGraph.js

@@ -216,11 +216,13 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
     let depNodes = targets.map(target => {
       let node = nodeFromDep(
         createDependency({
-          moduleSpecifier: entry.filePath,
+          specifier: entry.filePath,
+          specifierType: 'esm', // ???
           pipeline: target.pipeline,
           target: target,
           env: target.env,
           isEntry: true,
+          needsStableName: true,
           symbols: target.env.isLibrary
             ? new Map([['*', {local: '*', isWeak: true, loc: null}]])
             : undefined,
@@ -423,9 +425,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
 
       let dependentAssets = [];
       for (let dep of asset.dependencies.values()) {
-        let dependentAsset = assets.find(
-          a => a.uniqueKey === dep.moduleSpecifier,
-        );
+        let dependentAsset = assets.find(a => a.uniqueKey === dep.specifier);
         if (dependentAsset) {
           dependentAssetKeys.push(dependentAsset.uniqueKey);
           dependentAssets.push(dependentAsset);
@@ -470,7 +470,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
         depNode.value.meta = existing.value.meta;
       }
       let dependentAsset = dependentAssets.find(
-        a => a.uniqueKey === dep.moduleSpecifier,
+        a => a.uniqueKey === dep.specifier,
       );
       if (dependentAsset) {
         depNode.complete = true;

packages/core/core/src/BundleGraph.js

@@ -25,6 +25,7 @@ import invariant from 'assert';
 import nullthrows from 'nullthrows';
 import {objectSortedEntriesDeep} from '@parcel/utils';
 import {Hash, hashString} from '@parcel/hash';
+import {Priority} from './types';
 
 import {getBundleGroupId, getPublicId} from './utils';
 import {ALL_EDGE_TYPES, mapVisitor} from './Graph';
@@ -274,7 +275,7 @@ export default class BundleGraph {
   }
 
   internalizeAsyncDependency(bundle: Bundle, dependency: Dependency) {
-    if (!dependency.isAsync) {
+    if (dependency.priority === Priority.sync) {
       throw new Error('Expected an async dependency');
     }
 
@@ -688,8 +689,11 @@ export default class BundleGraph {
       this._graph
         .getNodeIdsConnectedTo(assetNodeId, 'references')
         .map(id => this._graph.getNode(id))
-        .filter(node => node?.type === 'dependency' && node.value.isAsync)
-        .length > 0
+        .filter(
+          node =>
+            node?.type === 'dependency' &&
+            node.value.priority === Priority.lazy,
+        ).length > 0
     ) {
       // If this asset is referenced by any async dependency, it's referenced.
       return true;

packages/core/core/src/CommittedAsset.js

@@ -1,18 +1,12 @@
 // @flow strict-local
 
-import type {
-  AST,
-  Blob,
-  ConfigResult,
-  FilePath,
-  PackageJSON,
-} from '@parcel/types';
+import type {AST, Blob} from '@parcel/types';
 import type {Asset, Dependency, ParcelOptions} from './types';
 
 import {Readable} from 'stream';
 import SourceMap from '@parcel/source-map';
 import {bufferStream, blobToStream, streamFromPromise} from '@parcel/utils';
-import {getConfig, generateFromAST} from './assetUtils';
+import {generateFromAST} from './assetUtils';
 import {deserializeRaw} from './serializer';
 
 export default class CommittedAsset {
@@ -140,18 +134,4 @@ export default class CommittedAsset {
   getDependencies(): Array<Dependency> {
     return Array.from(this.value.dependencies.values());
   }
-
-  async getConfig(
-    filePaths: Array<FilePath>,
-    options: ?{|
-      packageKey?: string,
-      parse?: boolean,
-    |},
-  ): Promise<ConfigResult | null> {
-    return (await getConfig(this, filePaths, options))?.config;
-  }
-
-  getPackage(): Promise<PackageJSON | null> {
-    return this.getConfig(['package.json']);
-  }
 }

packages/core/core/src/Dependency.js

@@ -2,22 +2,23 @@
 import type {
   SourceLocation,
   Meta,
-  ModuleSpecifier,
+  DependencySpecifier,
   Symbol,
 } from '@parcel/types';
 import type {Dependency, Environment, Target} from './types';
 import {hashString} from '@parcel/hash';
+import {SpecifierType, Priority} from './types';
 
 type DependencyOpts = {|
   id?: string,
   sourcePath?: string,
   sourceAssetId?: string,
-  moduleSpecifier: ModuleSpecifier,
-  isAsync?: boolean,
+  specifier: DependencySpecifier,
+  specifierType: $Keys<typeof SpecifierType>,
+  priority?: $Keys<typeof Priority>,
+  needsStableName?: boolean,
   isEntry?: boolean,
   isOptional?: boolean,
-  isURL?: boolean,
-  isIsolated?: boolean,
   loc?: SourceLocation,
   env: Environment,
   meta?: Meta,
@@ -35,7 +36,7 @@ export function createDependency(opts: DependencyOpts): Dependency {
     opts.id ||
     hashString(
       (opts.sourceAssetId ?? '') +
-        opts.moduleSpecifier +
+        opts.specifier +
         opts.env.id +
         (opts.target ? JSON.stringify(opts.target) : '') +
         (opts.pipeline ?? ''),
@@ -44,11 +45,11 @@ export function createDependency(opts: DependencyOpts): Dependency {
   return {
     ...opts,
     id,
-    isAsync: opts.isAsync ?? false,
-    isEntry: opts.isEntry,
+    specifierType: SpecifierType[opts.specifierType],
+    priority: Priority[opts.priority ?? 'sync'],
+    needsStableName: opts.needsStableName ?? false,
+    isEntry: opts.isEntry ?? false,
     isOptional: opts.isOptional ?? false,
-    isURL: opts.isURL ?? false,
-    isIsolated: opts.isIsolated ?? false,
     meta: opts.meta || {},
     symbols: opts.symbols,
   };

packages/core/core/src/InternalConfig.js

@@ -17,7 +17,7 @@ type ConfigOpts = {|
   isSource?: boolean,
   env?: Environment,
   result?: ConfigResult,
-  includedFiles?: Set<FilePath>,
+  invalidateOnFileChange?: Set<FilePath>,
   invalidateOnFileCreate?: Array<FileCreateInvalidation>,
   invalidateOnOptionChange?: Set<string>,
   devDeps?: Array<DevDepOptions>,
@@ -30,7 +30,7 @@ export function createConfig({
   searchPath,
   env,
   result,
-  includedFiles,
+  invalidateOnFileChange,
   invalidateOnFileCreate,
   invalidateOnOptionChange,
   devDeps,
@@ -44,7 +44,7 @@ export function createConfig({
     env: environment,
     result: result ?? null,
     resultHash: null,
-    includedFiles: includedFiles ?? new Set(),
+    invalidateOnFileChange: invalidateOnFileChange ?? new Set(),
     invalidateOnFileCreate: invalidateOnFileCreate ?? [],
     invalidateOnOptionChange: invalidateOnOptionChange ?? new Set(),
     devDeps: devDeps ?? [],

packages/core/core/src/PackagerRunner.js

@@ -213,7 +213,7 @@ export default class PackagerRunner {
           this.previousDevDeps,
           this.options,
         );
-        let key = `${devDep.moduleSpecifier}:${devDep.resolveFrom}`;
+        let key = `${devDep.specifier}:${devDep.resolveFrom}`;
         this.devDepRequests.set(key, devDepRequest);
       }
 
@@ -366,7 +366,7 @@ export default class PackagerRunner {
       // the potential for lazy require() that aren't executed until the request runs.
       let devDepRequest = await createDevDependency(
         {
-          moduleSpecifier: name,
+          specifier: name,
           resolveFrom,
         },
         packager,
@@ -445,7 +445,7 @@ export default class PackagerRunner {
         // the potential for lazy require() that aren't executed until the request runs.
         let devDepRequest = await createDevDependency(
           {
-            moduleSpecifier: optimizer.name,
+            specifier: optimizer.name,
             resolveFrom: optimizer.resolveFrom,
           },
           optimizer,

packages/core/core/src/Transformation.js

@@ -251,7 +251,7 @@ export default class Transformation {
     for (let transformer of pipeline.transformers) {
       await this.addDevDependency(
         {
-          moduleSpecifier: transformer.name,
+          specifier: transformer.name,
           resolveFrom: transformer.resolveFrom,
           range: transformer.range,
         },
@@ -315,7 +315,7 @@ export default class Transformation {
         hashes += await getConfigHash(config, transformer.name, this.options);
 
         for (let devDep of config.devDeps) {
-          let key = `${devDep.moduleSpecifier}:${devDep.resolveFrom}`;
+          let key = `${devDep.specifier}:${devDep.resolveFrom}`;
           hashes += nullthrows(this.devDepRequests.get(key)).hash;
         }
       }
@@ -328,14 +328,14 @@ export default class Transformation {
     opts: DevDepOptions,
     transformer: LoadedPlugin<Transformer> | TransformerWithNameAndConfig,
   ): Promise<void> {
-    let {moduleSpecifier, resolveFrom, range} = opts;
-    let key = `${moduleSpecifier}:${resolveFrom}`;
+    let {specifier, resolveFrom, range} = opts;
+    let key = `${specifier}:${resolveFrom}`;
     if (this.devDepRequests.has(key)) {
       return;
     }
 
     // Ensure that the package manager has an entry for this resolution.
-    await this.options.packageManager.resolve(moduleSpecifier, resolveFrom, {
+    await this.options.packageManager.resolve(specifier, resolveFrom, {
       range,
     });
 
@@ -633,7 +633,8 @@ export default class Transformation {
         await pipeline.resolverRunner.resolve(
           createDependency({
             env: asset.value.env,
-            moduleSpecifier: to,
+            specifier: to,
+            specifierType: 'esm', // ???
             sourcePath: from,
           }),
         ),