@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/src/requests/{BundleGraphRequest.js → BundleGraphRequest.ts}

@@ -1,13 +1,10 @@
-// @flow strict-local
-
-import type {Async, Bundle as IBundle, Namer} from '@atlaspack/types';
+import type {Async} from '@atlaspack/types';
 import type {SharedReference} from '@atlaspack/workers';
 import type {AtlaspackConfig, LoadedPlugin} from '../AtlaspackConfig';
 import type {StaticRunOpts, RunAPI} from '../RequestTracker';
 import type {
   Asset,
   AssetGroup,
-  Bundle as InternalBundle,
   Config,
   DevDepRequest,
   AtlaspackOptions,
@@ -17,19 +14,15 @@ import type {ConfigAndCachePath} from './AtlaspackConfigRequest';
 
 import fs from 'fs';
 import invariant from 'assert';
-import assert from 'assert';
 import nullthrows from 'nullthrows';
-import {PluginLogger} from '@atlaspack/logger';
+import {instrumentAsync, PluginLogger} from '@atlaspack/logger';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import AssetGraph from '../AssetGraph';
-import BundleGraph from '../public/BundleGraph';
 import InternalBundleGraph, {bundleGraphEdgeTypes} from '../BundleGraph';
 import MutableBundleGraph from '../public/MutableBundleGraph';
-import {Bundle, NamedBundle} from '../public/Bundle';
 import {report} from '../ReporterRunner';
 import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
-import {unique, setSymmetricDifference} from '@atlaspack/utils';
 import {hashString} from '@atlaspack/rust';
 import PluginOptions from '../public/PluginOptions';
 import applyRuntimes from '../applyRuntimes';
@@ -42,19 +35,16 @@ import {
   createDevDependency,
   getDevDepRequests,
   invalidateDevDeps,
-  runDevDepRequest,
 } from './DevDepRequest';
-import {createConfig} from '../InternalConfig';
-import {
-  loadPluginConfig,
-  runConfigRequest,
-  type PluginWithLoadConfig,
-} from './ConfigRequest';
+import {PluginWithLoadConfig} from './ConfigRequest';
+import {fromProjectPathRelative} from '../projectPath';
 import {
-  joinProjectPath,
-  fromProjectPathRelative,
-  toProjectPathUnsafe,
-} from '../projectPath';
+  validateBundles,
+  nameBundle,
+  loadPluginConfigWithDevDeps,
+  runDevDepRequest as runDevDepRequestShared,
+  dumpBundleGraphSnapshot,
+} from './BundleGraphRequestUtils';
 import createAssetGraphRequestJS from './AssetGraphRequest';
 import {createAssetGraphRequestRust} from './AssetGraphRequestRust';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
@@ -66,34 +56,30 @@ import {
 } from './asset-graph-dot';
 import {Priority} from '../types';
 
-type BundleGraphRequestInput = {|
-  requestedAssetIds: Set<string>,
-  signal?: AbortSignal,
-  optionsRef: SharedReference,
-|};
-
-type BundleGraphRequestResult = {|
-  bundleGraph: InternalBundleGraph,
-|};
+type BundleGraphRequestInput = {
+  requestedAssetIds: Set<string>;
+  signal?: AbortSignal;
+  optionsRef: SharedReference;
+};
 
-type RunInput = {|
-  input: BundleGraphRequestInput,
-  ...StaticRunOpts<BundleGraphResult>,
-|};
+type RunInput = {
+  input: BundleGraphRequestInput;
+} & StaticRunOpts<BundleGraphResult>;
 
 // TODO: Rename to BundleGraphRequestResult
-export type BundleGraphResult = {|
-  bundleGraph: InternalBundleGraph,
-  changedAssets: Map<string, Asset>,
-  assetRequests: Array<AssetGroup>,
-|};
-
-type BundleGraphRequest = {|
-  id: string,
-  +type: typeof requestTypes.bundle_graph_request,
-  run: (RunInput) => Async<BundleGraphResult>,
-  input: BundleGraphRequestInput,
-|};
+export type BundleGraphResult = {
+  bundleGraph: InternalBundleGraph;
+  changedAssets: Map<string, Asset>;
+  assetRequests: Array<AssetGroup>;
+  didIncrementallyBundle: boolean;
+};
+
+type BundleGraphRequest = {
+  id: string;
+  readonly type: typeof requestTypes.bundle_graph_request;
+  run: (arg1: RunInput) => Async<BundleGraphResult>;
+  input: BundleGraphRequestInput;
+};
 
 function applySideEffectsForLoadableImports(assetGraph: AssetGraph) {
   // Avoid revisiting nodes
@@ -147,9 +133,10 @@ export default function createBundleGraphRequest(
       let {optionsRef, requestedAssetIds, signal} = input.input;
       let measurement = tracer.createMeasurement('building');
 
-      let createAssetGraphRequest = input.rustAtlaspack
-        ? createAssetGraphRequestRust(input.rustAtlaspack)
-        : createAssetGraphRequestJS;
+      let createAssetGraphRequest =
+        getFeatureFlag('atlaspackV3') && input.rustAtlaspack
+          ? createAssetGraphRequestRust(input.rustAtlaspack)
+          : createAssetGraphRequestJS;
 
       let request = createAssetGraphRequest({
         name: 'Main',
@@ -159,14 +146,17 @@ export default function createBundleGraphRequest(
         lazyIncludes: options.lazyIncludes,
         lazyExcludes: options.lazyExcludes,
         requestedAssetIds,
+        skipSymbolProp: getFeatureFlag('rustSymbolTracker'),
       });
 
-      let {assetGraph, changedAssets, assetRequests} = await api.runRequest(
-        request,
-        {
-          force:
-            Boolean(input.rustAtlaspack) ||
-            (options.shouldBuildLazily && requestedAssetIds.size > 0),
+      let {assetGraph, changedAssets, assetRequests} = await instrumentAsync(
+        'asset-graph-request',
+        () => {
+          return api.runRequest(request, {
+            force:
+              Boolean(input.rustAtlaspack) ||
+              (options.shouldBuildLazily && requestedAssetIds.size > 0),
+          });
         },
       );
 
@@ -198,7 +188,11 @@ export default function createBundleGraphRequest(
       //       force: true,
       //     },
       //   );
-      //   require('./asset-graph-diff.js')(jsAssetGraph, assetGraph);
+      //   require('./asset-graph-diff.ts')(
+      //     jsAssetGraph,
+      //     assetGraph,
+      //     options.projectRoot,
+      //   );
       // }
 
       measurement && measurement.end();
@@ -245,7 +239,7 @@ export default function createBundleGraphRequest(
       }
 
       await dumpGraphToGraphViz(
-        // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381 (Windows only)
+        // @ts-expect-error TS2345
         res.bundleGraph._graph,
         'BundleGraph',
         bundleGraphEdgeTypes,
@@ -283,21 +277,12 @@ class BundlerRunner {
     this.pluginOptions = new PluginOptions(
       optionsProxy(this.options, api.invalidateOnOptionChange),
     );
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      const key = hashString(
+    this.cacheKey =
+      hashString(
         `${ATLASPACK_VERSION}:BundleGraph:${
           JSON.stringify(options.entries) ?? ''
         }${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-      );
-      this.cacheKey = `BundleGraph/${ATLASPACK_VERSION}/${options.mode}/${key}`;
-    } else {
-      this.cacheKey =
-        hashString(
-          `${ATLASPACK_VERSION}:BundleGraph:${
-            JSON.stringify(options.entries) ?? ''
-          }${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-        ) + '-BundleGraph';
-    }
+      ) + '-BundleGraph';
   }
 
   async loadConfigs() {
@@ -316,62 +301,47 @@ class BundlerRunner {
     }
   }
 
-  async loadConfig<T: PluginWithLoadConfig>(plugin: LoadedPlugin<T>) {
-    let config = createConfig({
-      plugin: plugin.name,
-      searchPath: toProjectPathUnsafe('index'),
-    });
-
-    await loadPluginConfig(plugin, config, this.options);
-    await runConfigRequest(this.api, config);
-    for (let devDep of config.devDeps) {
-      let devDepRequest = await createDevDependency(
-        devDep,
-        this.previousDevDeps,
-        this.options,
-      );
-      await this.runDevDepRequest(devDepRequest);
-    }
-
-    this.configs.set(plugin.name, config);
+  async loadConfig<T extends PluginWithLoadConfig>(plugin: LoadedPlugin<T>) {
+    await loadPluginConfigWithDevDeps(
+      plugin,
+      this.options,
+      this.api,
+      this.previousDevDeps,
+      this.devDepRequests,
+      this.configs,
+    );
   }
 
   async runDevDepRequest(devDepRequest: DevDepRequest | DevDepRequestRef) {
-    let {specifier, resolveFrom} = devDepRequest;
-    let key = `${specifier}:${fromProjectPathRelative(resolveFrom)}`;
-    this.devDepRequests.set(key, devDepRequest);
-    await runDevDepRequest(this.api, devDepRequest);
+    await runDevDepRequestShared(this.api, devDepRequest, this.devDepRequests);
   }
 
   async bundle({
     graph,
     changedAssets,
     assetRequests,
-  }: {|
-    graph: AssetGraph,
-    changedAssets: Map<string, Asset>,
-    assetRequests: Array<AssetGroup>,
-  |}): Promise<BundleGraphResult> {
+  }: {
+    graph: AssetGraph;
+    changedAssets: Map<string, Asset>;
+    assetRequests: Array<AssetGroup>;
+  }): Promise<BundleGraphResult> {
     report({
       type: 'buildProgress',
       phase: 'bundling',
     });
-
+    let didIncrementallyBundle = false;
     await this.loadConfigs();
 
     let plugin = await this.config.getBundler();
     let {plugin: bundler, name, resolveFrom} = plugin;
 
     // if a previous asset graph hash is passed in, check if the bundle graph is also available
-    let previousBundleGraphResult: ?BundleGraphRequestResult;
-    if (graph.safeToIncrementallyBundle) {
-      try {
-        previousBundleGraphResult = await this.api.getPreviousResult();
-      } catch {
-        // if the bundle graph had an error or was removed, don't fail the build
-      }
-    }
-    if (previousBundleGraphResult == null) {
+    const previousBundleGraphResult: BundleGraphResult | null | undefined =
+      await this.api.getPreviousResult();
+    const canIncrementallyBundle =
+      previousBundleGraphResult != null && graph.canIncrementallyBundle();
+
+    if (graph.safeToIncrementallyBundle && previousBundleGraphResult == null) {
       graph.safeToIncrementallyBundle = false;
     }
 
@@ -383,7 +353,7 @@ class BundlerRunner {
       category: 'bundle',
     });
     try {
-      if (previousBundleGraphResult) {
+      if (canIncrementallyBundle && previousBundleGraphResult) {
         internalBundleGraph = previousBundleGraphResult.bundleGraph;
         for (let changedAssetId of changedAssets.keys()) {
           // Copy over the whole node to also have correct symbol data
@@ -393,6 +363,7 @@ class BundlerRunner {
           invariant(changedAssetNode.type === 'asset');
           internalBundleGraph.updateAsset(changedAssetNode);
         }
+        didIncrementallyBundle = true;
       } else {
         internalBundleGraph = InternalBundleGraph.fromAssetGraph(
           graph,
@@ -401,7 +372,7 @@ class BundlerRunner {
         invariant(internalBundleGraph != null); // ensures the graph was created
 
         await dumpGraphToGraphViz(
-          // $FlowFixMe
+          // @ts-expect-error TS2345
           internalBundleGraph._graph,
           'before_bundle',
           bundleGraphEdgeTypes,
@@ -426,16 +397,20 @@ class BundlerRunner {
         }
 
         // this the normal bundle workflow (bundle, optimizing, run-times, naming)
-        await bundler.bundle({
-          bundleGraph: mutableBundleGraph,
-          config: this.configs.get(plugin.name)?.result,
-          options: this.pluginOptions,
-          logger,
-          tracer,
+        await instrumentAsync('bundle (V2)', async () => {
+          await bundler.bundle({
+            bundleGraph: mutableBundleGraph,
+            config: this.configs.get(plugin.name)?.result,
+            options: this.pluginOptions,
+            logger,
+            tracer,
+          });
         });
 
         measurement && measurement.end();
 
+        dumpBundleGraphSnapshot(internalBundleGraph, 'js');
+
         if (this.pluginOptions.mode === 'production') {
           let optimizeMeasurement;
           try {
@@ -452,7 +427,7 @@ class BundlerRunner {
               options: this.pluginOptions,
               logger,
             });
-          } catch (e) {
+          } catch (e: any) {
             throw new ThrowableDiagnostic({
               diagnostic: errorToDiagnostic(e, {
                 origin: plugin.name,
@@ -461,7 +436,7 @@ class BundlerRunner {
           } finally {
             optimizeMeasurement && optimizeMeasurement.end();
             await dumpGraphToGraphViz(
-              // $FlowFixMe[incompatible-call]
+              // @ts-expect-error TS2345
               internalBundleGraph._graph,
               'after_optimize',
             );
@@ -480,13 +455,14 @@ class BundlerRunner {
         );
         await this.runDevDepRequest(devDepRequest);
       }
-    } catch (e) {
+    } catch (e: any) {
       if (internalBundleGraph != null) {
         this.api.storeResult(
           {
             bundleGraph: internalBundleGraph,
             changedAssets: new Map(),
             assetRequests: [],
+            didIncrementallyBundle,
           },
           this.cacheKey,
         );
@@ -500,7 +476,7 @@ class BundlerRunner {
     } finally {
       if (internalBundleGraph != null) {
         await dumpGraphToGraphViz(
-          // $FlowFixMe[incompatible-call]
+          // @ts-expect-error TS2345
           internalBundleGraph._graph,
           'after_bundle',
           bundleGraphEdgeTypes,
@@ -509,28 +485,37 @@ class BundlerRunner {
     }
 
     let changedRuntimes = new Map();
-    if (!previousBundleGraphResult) {
+    if (!previousBundleGraphResult || !canIncrementallyBundle) {
       let namers = await this.config.getNamers();
       // inline bundles must still be named so the PackagerRunner
       // can match them to the correct packager/optimizer plugins.
       let bundles = internalBundleGraph.getBundles({includeInline: true});
       await Promise.all(
         bundles.map((bundle) =>
-          this.nameBundle(namers, bundle, internalBundleGraph),
+          nameBundle(
+            namers,
+            bundle,
+            internalBundleGraph,
+            this.options,
+            this.pluginOptions,
+            this.configs,
+          ),
         ),
       );
 
-      changedRuntimes = await applyRuntimes({
-        bundleGraph: internalBundleGraph,
-        api: this.api,
-        config: this.config,
-        options: this.options,
-        optionsRef: this.optionsRef,
-        pluginOptions: this.pluginOptions,
-        previousDevDeps: this.previousDevDeps,
-        devDepRequests: this.devDepRequests,
-        configs: this.configs,
-      });
+      changedRuntimes = await instrumentAsync('applyRuntimes', () =>
+        applyRuntimes({
+          bundleGraph: internalBundleGraph,
+          api: this.api,
+          config: this.config,
+          options: this.options,
+          optionsRef: this.optionsRef,
+          pluginOptions: this.pluginOptions,
+          previousDevDeps: this.previousDevDeps,
+          devDepRequests: this.devDepRequests,
+          configs: this.configs,
+        }),
+      );
 
       // Add dev deps for namers, AFTER running them to account for lazy require().
       for (let namer of namers) {
@@ -545,14 +530,14 @@ class BundlerRunner {
         await this.runDevDepRequest(devDepRequest);
       }
 
-      this.validateBundles(internalBundleGraph);
+      validateBundles(internalBundleGraph);
 
       // Pre-compute the hashes for each bundle so they are only computed once and shared between workers.
       internalBundleGraph.getBundleGraphHash();
     }
 
     await dumpGraphToGraphViz(
-      // $FlowFixMe
+      // @ts-expect-error TS2345
       internalBundleGraph._graph,
       'after_runtimes',
       bundleGraphEdgeTypes,
@@ -563,6 +548,7 @@ class BundlerRunner {
         bundleGraph: internalBundleGraph,
         changedAssets: new Map(),
         assetRequests: [],
+        didIncrementallyBundle,
       },
       this.cacheKey,
     );
@@ -571,73 +557,7 @@ class BundlerRunner {
       bundleGraph: internalBundleGraph,
       changedAssets: changedRuntimes,
       assetRequests,
+      didIncrementallyBundle,
     };
   }
-
-  validateBundles(bundleGraph: InternalBundleGraph): void {
-    let bundles = bundleGraph.getBundles();
-
-    let bundleNames = bundles.map((b) =>
-      joinProjectPath(b.target.distDir, nullthrows(b.name)),
-    );
-    assert.deepEqual(
-      bundleNames,
-      unique(bundleNames),
-      'Bundles must have unique name. Conflicting names: ' +
-        [
-          ...setSymmetricDifference(
-            new Set(bundleNames),
-            new Set(unique(bundleNames)),
-          ),
-        ].join(),
-    );
-  }
-
-  async nameBundle(
-    namers: Array<LoadedPlugin<Namer<mixed>>>,
-    internalBundle: InternalBundle,
-    internalBundleGraph: InternalBundleGraph,
-  ): Promise<void> {
-    let bundle = Bundle.get(internalBundle, internalBundleGraph, this.options);
-    let bundleGraph = new BundleGraph<IBundle>(
-      internalBundleGraph,
-      NamedBundle.get.bind(NamedBundle),
-      this.options,
-    );
-
-    for (let namer of namers) {
-      let measurement;
-      try {
-        measurement = tracer.createMeasurement(namer.name, 'namer', bundle.id);
-        let name = await namer.plugin.name({
-          bundle,
-          bundleGraph,
-          config: this.configs.get(namer.name)?.result,
-          options: this.pluginOptions,
-          logger: new PluginLogger({origin: namer.name}),
-          tracer: new PluginTracer({origin: namer.name, category: 'namer'}),
-        });
-
-        if (name != null) {
-          internalBundle.name = name;
-          let {hashReference} = internalBundle;
-          internalBundle.displayName = name.includes(hashReference)
-            ? name.replace(hashReference, '[hash]')
-            : name;
-
-          return;
-        }
-      } catch (e) {
-        throw new ThrowableDiagnostic({
-          diagnostic: errorToDiagnostic(e, {
-            origin: namer.name,
-          }),
-        });
-      } finally {
-        measurement && measurement.end();
-      }
-    }
-
-    throw new Error('Unable to name bundle');
-  }
 }