@atlaspack/core 2.16.2-canary.33 → 2.16.2-canary.330

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

@@ -1,4 +1,3 @@
-// @flow strict-local
 import type {
   Async,
   FilePath,
@@ -13,6 +12,7 @@ import type {
   PureAtlaspackConfigPipeline,
   AtlaspackOptions,
   ProcessedAtlaspackConfig,
+  AtlaspackPluginNode,
 } from '../types';
 
 import {createBuildCache} from '@atlaspack/build-cache';
@@ -40,33 +40,33 @@ import {toProjectPath} from '../projectPath';
 import {requestTypes} from '../RequestTracker';
 import {optionsProxy} from '../utils';
 
-type ConfigMap<K, V> = {[K]: V, ...};
+// @ts-expect-error TS2344
+type ConfigMap<K, V> = Partial<Record<K, V>>;
 
-export type ConfigAndCachePath = {|
-  config: ProcessedAtlaspackConfig,
-  cachePath: string,
-|};
+export type ConfigAndCachePath = {
+  config: ProcessedAtlaspackConfig;
+  cachePath: string;
+};
 
-type RunOpts<TResult> = {|
-  input: null,
-  ...StaticRunOpts<TResult>,
-|};
+type RunOpts<TResult> = {
+  input: null;
+} & StaticRunOpts<TResult>;
 
-export type AtlaspackConfigRequest = {|
-  id: string,
-  type: typeof requestTypes.atlaspack_config_request,
-  input: null,
+export type AtlaspackConfigRequest = {
+  id: string;
+  type: typeof requestTypes.atlaspack_config_request;
+  input: null;
   run: (
-    RunOpts<AtlaspackConfigRequestResult>,
-  ) => Async<AtlaspackConfigRequestResult>,
-|};
+    arg1: RunOpts<AtlaspackConfigRequestResult>,
+  ) => Async<AtlaspackConfigRequestResult>;
+};
 
 export type AtlaspackConfigRequestResult = ConfigAndCachePath;
 
-type AtlaspackConfigChain = {|
-  config: ProcessedAtlaspackConfig,
-  extendedFiles: Array<FilePath>,
-|};
+type AtlaspackConfigChain = {
+  config: ProcessedAtlaspackConfig;
+  extendedFiles: Array<FilePath>;
+};
 
 const type = 'atlaspack_config_request';
 
@@ -79,10 +79,9 @@ export default function createAtlaspackConfigRequest(): AtlaspackConfigRequest {
         config,
         extendedFiles,
         usedDefault,
-      }: {|
-        ...AtlaspackConfigChain,
-        usedDefault: boolean,
-      |} = await loadAtlaspackConfig(
+      }: AtlaspackConfigChain & {
+        usedDefault: boolean;
+      } = await loadAtlaspackConfig(
         optionsProxy(options, api.invalidateOnOptionChange),
       );
 
@@ -122,18 +121,22 @@ export function getCachedAtlaspackConfig(
   let {config: processedConfig, cachePath} = result;
   let config = atlaspackConfigCache.get(cachePath);
   if (config) {
+    // @ts-expect-error TS2740
     return config;
   }
 
   config = new AtlaspackConfig(processedConfig, options);
 
   atlaspackConfigCache.set(cachePath, config);
+  // @ts-expect-error TS2322
   return config;
 }
 
-export async function loadAtlaspackConfig(
-  options: AtlaspackOptions,
-): Promise<{|...AtlaspackConfigChain, usedDefault: boolean|}> {
+export async function loadAtlaspackConfig(options: AtlaspackOptions): Promise<
+  AtlaspackConfigChain & {
+    usedDefault: boolean;
+  }
+> {
   let atlaspackConfig = await resolveAtlaspackConfig(options);
 
   if (!atlaspackConfig) {
@@ -145,7 +148,13 @@ export async function loadAtlaspackConfig(
 
 export async function resolveAtlaspackConfig(
   options: AtlaspackOptions,
-): Promise<?{|...AtlaspackConfigChain, usedDefault: boolean|}> {
+): Promise<
+  | (AtlaspackConfigChain & {
+      usedDefault: boolean;
+    })
+  | null
+  | undefined
+> {
   let resolveFrom = getResolveFrom(options.inputFS, options.projectRoot);
   let configPath =
     options.config != null
@@ -173,7 +182,7 @@ export async function resolveAtlaspackConfig(
   let contents;
   try {
     contents = await options.inputFS.readFile(configPath, 'utf8');
-  } catch (e) {
+  } catch (e: any) {
     throw new ThrowableDiagnostic({
       diagnostic: {
         message: md`Could not find parcel config at ${path.relative(
@@ -189,13 +198,19 @@ export async function resolveAtlaspackConfig(
     await parseAndProcessConfig(configPath, contents, options);
 
   if (options.additionalReporters.length > 0) {
-    config.reporters = [
-      ...options.additionalReporters.map(({packageName, resolveFrom}) => ({
-        packageName,
-        resolveFrom,
-      })),
-      ...(config.reporters ?? []),
-    ];
+    const reporterMap = new Map<PackageName, AtlaspackPluginNode>();
+
+    options.additionalReporters.forEach(({packageName, resolveFrom}) => {
+      reporterMap.set(packageName, {packageName, resolveFrom});
+    });
+
+    config.reporters?.forEach((reporter) => {
+      if (!reporterMap.has(reporter.packageName)) {
+        reporterMap.set(reporter.packageName, reporter);
+      }
+    });
+
+    config.reporters = Array.from(reporterMap.values());
   }
 
   return {config, extendedFiles, usedDefault};
@@ -217,7 +232,7 @@ export async function parseAndProcessConfig(
   let config: RawAtlaspackConfig;
   try {
     config = parse(contents);
-  } catch (e) {
+  } catch (e: any) {
     let pos = {
       line: e.lineNumber,
       column: e.columnNumber,
@@ -249,13 +264,12 @@ export async function parseAndProcessConfig(
 
 function processPipeline(
   options: AtlaspackOptions,
-  pipeline: ?Array<PackageName>,
+  pipeline: Array<PackageName> | null | undefined,
   keyPath: string,
   filePath: FilePath,
 ) {
   if (pipeline) {
     return pipeline.map((pkg, i) => {
-      // $FlowFixMe
       if (pkg === '...') return pkg;
 
       return {
@@ -278,16 +292,13 @@ const RESERVED_PIPELINES = new Set([
 ]);
 
 async function processMap(
-  // $FlowFixMe
-  map: ?ConfigMap<any, any>,
+  map: ConfigMap<any, any> | null | undefined,
   keyPath: string,
   filePath: FilePath,
   options: AtlaspackOptions,
-  // $FlowFixMe
 ): Promise<ConfigMap<any, any> | typeof undefined> {
   if (!map) return undefined;
 
-  // $FlowFixMe
   let res: ConfigMap<any, any> = {};
   for (let k in map) {
     let i = k.indexOf(':');
@@ -346,6 +357,7 @@ export async function processConfig(
       : {
           /*::...null*/
         }),
+    // @ts-expect-error TS2322
     resolvers: processPipeline(
       options,
       configFile.resolvers,
@@ -369,12 +381,14 @@ export async function processConfig(
             keyPath: '/bundler',
           }
         : undefined,
+    // @ts-expect-error TS2322
     namers: processPipeline(
       options,
       configFile.namers,
       '/namers',
       configFile.filePath,
     ),
+    // @ts-expect-error TS2322
     runtimes: processPipeline(
       options,
       configFile.runtimes,
@@ -399,6 +413,7 @@ export async function processConfig(
       configFile.filePath,
       options,
     ),
+    // @ts-expect-error TS2322
     reporters: processPipeline(
       options,
       configFile.reporters,
@@ -437,7 +452,7 @@ export async function processConfigChain(
     let exts = Array.isArray(configFile.extends)
       ? configFile.extends
       : [configFile.extends];
-    let errors = [];
+    let errors: Array<any> = [];
     if (exts.length !== 0) {
       let extStartConfig;
       let i = 0;
@@ -454,7 +469,7 @@ export async function processConfigChain(
           extStartConfig = extStartConfig
             ? mergeConfigs(extStartConfig, nextConfig)
             : nextConfig;
-        } catch (err) {
+        } catch (err: any) {
           errors.push(err);
         }
 
@@ -491,7 +506,7 @@ export async function resolveExtends(
     try {
       let {resolved} = await options.packageManager.resolve(ext, configPath);
       return options.inputFS.realpath(resolved);
-    } catch (err) {
+    } catch (err: any) {
       let parentContents = await options.inputFS.readFile(configPath, 'utf8');
       let alternatives = await findAlternativeNodeModules(
         options.inputFS,
@@ -539,7 +554,7 @@ async function processExtendedConfig(
       resolvedExtendedConfigPath,
       'utf8',
     );
-  } catch (e) {
+  } catch (e: any) {
     let parentContents = await options.inputFS.readFile(configPath, 'utf8');
     let alternatives = await findAlternativeFiles(
       options.inputFS,
@@ -580,7 +595,7 @@ export function validateConfigFile(
 ) {
   try {
     validateNotEmpty(config, relativePath);
-  } catch (e) {
+  } catch (e: any) {
     throw new ThrowableDiagnostic({
       diagnostic: {
         message: e.message,
@@ -650,8 +665,8 @@ function assertPurePipeline(
 }
 
 export function mergePipelines(
-  base: ?ExtendableAtlaspackConfigPipeline,
-  ext: ?ExtendableAtlaspackConfigPipeline,
+  base?: ExtendableAtlaspackConfigPipeline | null,
+  ext?: ExtendableAtlaspackConfigPipeline | null,
 ): ExtendableAtlaspackConfigPipeline {
   if (ext == null) {
     return base ?? [];
@@ -676,9 +691,9 @@ export function mergePipelines(
   }
 }
 
-export function mergeMaps<K: string, V>(
-  base: ?ConfigMap<K, V>,
-  ext: ?ConfigMap<K, V>,
+export function mergeMaps<K extends string, V>(
+  base?: ConfigMap<K, V> | null,
+  ext?: ConfigMap<K, V> | null,
   merger?: (a: V, b: V) => V,
 ): ConfigMap<K, V> {
   if (!ext || Object.keys(ext).length === 0) {
@@ -692,16 +707,15 @@ export function mergeMaps<K: string, V>(
   let res: ConfigMap<K, V> = {};
   // Add the extension options first so they have higher precedence in the output glob map
   for (let k in ext) {
-    //$FlowFixMe Flow doesn't correctly infer the type. See https://github.com/facebook/flow/issues/1736.
-    let key: K = (k: any);
+    let key: K = k as any;
     res[key] =
+      // @ts-expect-error TS2345
       merger && base[key] != null ? merger(base[key], ext[key]) : ext[key];
   }
 
   // Add base options that aren't defined in the extension
   for (let k in base) {
-    // $FlowFixMe
-    let key: K = (k: any);
+    let key: K = k as any;
     if (res[key] == null) {
       res[key] = base[key];
     }

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {Async, Bundle as IBundle, Namer} from '@atlaspack/types';
 import type {SharedReference} from '@atlaspack/workers';
 import type {AtlaspackConfig, LoadedPlugin} from '../AtlaspackConfig';
@@ -19,7 +17,8 @@ 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';
@@ -47,7 +46,7 @@ import {createConfig} from '../InternalConfig';
 import {
   loadPluginConfig,
   runConfigRequest,
-  type PluginWithLoadConfig,
+  PluginWithLoadConfig,
 } from './ConfigRequest';
 import {
   joinProjectPath,
@@ -65,34 +64,30 @@ import {
 } from './asset-graph-dot';
 import {Priority} from '../types';
 
-type BundleGraphRequestInput = {|
-  requestedAssetIds: Set<string>,
-  signal?: AbortSignal,
-  optionsRef: SharedReference,
-|};
+type BundleGraphRequestInput = {
+  requestedAssetIds: Set<string>;
+  signal?: AbortSignal;
+  optionsRef: SharedReference;
+};
 
-type BundleGraphRequestResult = {|
-  bundleGraph: InternalBundleGraph,
-|};
-
-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;
+  assetGraphBundlingVersion: number;
+  changedAssets: Map<string, Asset>;
+  assetRequests: Array<AssetGroup>;
+};
+
+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
@@ -160,12 +155,14 @@ export default function createBundleGraphRequest(
         requestedAssetIds,
       });
 
-      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),
+          });
         },
       );
 
@@ -197,7 +194,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();
@@ -214,6 +215,7 @@ export default function createBundleGraphRequest(
 
       if (subRequestsInvalid) {
         assetGraph.safeToIncrementallyBundle = false;
+        assetGraph.setNeedsBundling();
       }
 
       let configResult = nullthrows(
@@ -244,7 +246,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,
@@ -282,12 +284,21 @@ class BundlerRunner {
     this.pluginOptions = new PluginOptions(
       optionsProxy(this.options, api.invalidateOnOptionChange),
     );
-    this.cacheKey =
-      hashString(
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const key = hashString(
         `${ATLASPACK_VERSION}:BundleGraph:${
           JSON.stringify(options.entries) ?? ''
         }${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-      ) + '-BundleGraph';
+      );
+      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';
+    }
   }
 
   async loadConfigs() {
@@ -306,7 +317,7 @@ class BundlerRunner {
     }
   }
 
-  async loadConfig<T: PluginWithLoadConfig>(plugin: LoadedPlugin<T>) {
+  async loadConfig<T extends PluginWithLoadConfig>(plugin: LoadedPlugin<T>) {
     let config = createConfig({
       plugin: plugin.name,
       searchPath: toProjectPathUnsafe('index'),
@@ -337,11 +348,11 @@ class BundlerRunner {
     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',
@@ -353,16 +364,17 @@ class BundlerRunner {
     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?.assetGraphBundlingVersion != null &&
+      graph.canIncrementallyBundle(
+        previousBundleGraphResult.assetGraphBundlingVersion,
+      );
+
+    if (graph.safeToIncrementallyBundle && previousBundleGraphResult == null) {
       graph.safeToIncrementallyBundle = false;
+      graph.setNeedsBundling();
     }
 
     let internalBundleGraph;
@@ -373,7 +385,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
@@ -391,7 +403,7 @@ class BundlerRunner {
         invariant(internalBundleGraph != null); // ensures the graph was created
 
         await dumpGraphToGraphViz(
-          // $FlowFixMe
+          // @ts-expect-error TS2345
           internalBundleGraph._graph,
           'before_bundle',
           bundleGraphEdgeTypes,
@@ -442,7 +454,7 @@ class BundlerRunner {
               options: this.pluginOptions,
               logger,
             });
-          } catch (e) {
+          } catch (e: any) {
             throw new ThrowableDiagnostic({
               diagnostic: errorToDiagnostic(e, {
                 origin: plugin.name,
@@ -451,7 +463,7 @@ class BundlerRunner {
           } finally {
             optimizeMeasurement && optimizeMeasurement.end();
             await dumpGraphToGraphViz(
-              // $FlowFixMe[incompatible-call]
+              // @ts-expect-error TS2345
               internalBundleGraph._graph,
               'after_optimize',
             );
@@ -470,11 +482,12 @@ class BundlerRunner {
         );
         await this.runDevDepRequest(devDepRequest);
       }
-    } catch (e) {
+    } catch (e: any) {
       if (internalBundleGraph != null) {
         this.api.storeResult(
           {
             bundleGraph: internalBundleGraph,
+            assetGraphBundlingVersion: graph.getBundlingVersion(),
             changedAssets: new Map(),
             assetRequests: [],
           },
@@ -490,7 +503,7 @@ class BundlerRunner {
     } finally {
       if (internalBundleGraph != null) {
         await dumpGraphToGraphViz(
-          // $FlowFixMe[incompatible-call]
+          // @ts-expect-error TS2345
           internalBundleGraph._graph,
           'after_bundle',
           bundleGraphEdgeTypes,
@@ -499,7 +512,7 @@ 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.
@@ -510,17 +523,19 @@ class BundlerRunner {
         ),
       );
 
-      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) {
@@ -542,7 +557,7 @@ class BundlerRunner {
     }
 
     await dumpGraphToGraphViz(
-      // $FlowFixMe
+      // @ts-expect-error TS2345
       internalBundleGraph._graph,
       'after_runtimes',
       bundleGraphEdgeTypes,
@@ -551,6 +566,7 @@ class BundlerRunner {
     this.api.storeResult(
       {
         bundleGraph: internalBundleGraph,
+        assetGraphBundlingVersion: graph.getBundlingVersion(),
         changedAssets: new Map(),
         assetRequests: [],
       },
@@ -559,6 +575,7 @@ class BundlerRunner {
 
     return {
       bundleGraph: internalBundleGraph,
+      assetGraphBundlingVersion: graph.getBundlingVersion(),
       changedAssets: changedRuntimes,
       assetRequests,
     };
@@ -584,7 +601,7 @@ class BundlerRunner {
   }
 
   async nameBundle(
-    namers: Array<LoadedPlugin<Namer<mixed>>>,
+    namers: Array<LoadedPlugin<Namer<unknown>>>,
     internalBundle: InternalBundle,
     internalBundleGraph: InternalBundleGraph,
   ): Promise<void> {
@@ -617,7 +634,7 @@ class BundlerRunner {
 
           return;
         }
-      } catch (e) {
+      } catch (e: any) {
         throw new ThrowableDiagnostic({
           diagnostic: errorToDiagnostic(e, {
             origin: namer.name,