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

package/src/requests/AtlaspackBuildRequest.ts

@@ -0,0 +1,168 @@
+import type {ContentKey} from '@atlaspack/graph';
+import type {Async} from '@atlaspack/types';
+import type {SharedReference} from '@atlaspack/workers';
+
+import type {StaticRunOpts} from '../RequestTracker';
+import type {Asset, AssetGroup, PackagedBundleInfo} from '../types';
+import type BundleGraph from '../BundleGraph';
+
+import createBundleGraphRequest, {
+  BundleGraphResult,
+} from './BundleGraphRequest';
+import createBundleGraphRequestRust from './BundleGraphRequestRust';
+import createWriteBundlesRequest from './WriteBundlesRequest';
+import {assertSignalNotAborted} from '../utils';
+import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
+import {bundleGraphEdgeTypes} from '../BundleGraph';
+import {report} from '../ReporterRunner';
+import IBundleGraph from '../public/BundleGraph';
+import {NamedBundle} from '../public/Bundle';
+import {assetFromValue} from '../public/Asset';
+
+import {tracer} from '@atlaspack/profiler';
+import {requestTypes} from '../RequestTracker';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {fromEnvironmentId} from '../EnvironmentManager';
+import {tracer as atlaspackTracer} from '@atlaspack/logger';
+
+type AtlaspackBuildRequestInput = {
+  optionsRef: SharedReference;
+  requestedAssetIds: Set<string>;
+  signal?: AbortSignal;
+};
+
+export type AtlaspackBuildRequestResult = {
+  bundleGraph: BundleGraph;
+  bundleInfo: Map<string, PackagedBundleInfo>;
+  changedAssets: Map<string, Asset>;
+  assetRequests: Array<AssetGroup>;
+  scopeHoistingStats?: {
+    totalAssets: number;
+    wrappedAssets: number;
+  };
+};
+
+type RunInput<TResult> = {
+  input: AtlaspackBuildRequestInput;
+} & StaticRunOpts<TResult>;
+
+export type AtlaspackBuildRequest = {
+  id: ContentKey;
+  readonly type: typeof requestTypes.atlaspack_build_request;
+  run: (
+    arg1: RunInput<AtlaspackBuildRequestResult>,
+  ) => Async<AtlaspackBuildRequestResult>;
+  input: AtlaspackBuildRequestInput;
+};
+
+export default function createAtlaspackBuildRequest(
+  input: AtlaspackBuildRequestInput,
+): AtlaspackBuildRequest {
+  return {
+    type: requestTypes.atlaspack_build_request,
+    id: 'atlaspack_build_request',
+    run,
+    input,
+  };
+}
+
+async function run({
+  input,
+  api,
+  options,
+  rustAtlaspack,
+}: RunInput<AtlaspackBuildRequestResult>) {
+  let {optionsRef, requestedAssetIds, signal} = input;
+
+  let bundleGraphRequest =
+    getFeatureFlag('nativeBundling') && rustAtlaspack
+      ? createBundleGraphRequestRust({
+          optionsRef,
+          requestedAssetIds,
+          signal,
+        })
+      : createBundleGraphRequest({
+          optionsRef,
+          requestedAssetIds,
+          signal,
+        });
+
+  let {
+    bundleGraph,
+    changedAssets,
+    assetRequests,
+    didIncrementallyBundle,
+  }: BundleGraphResult = await api.runRequest(bundleGraphRequest, {
+    force:
+      Boolean(rustAtlaspack) ||
+      (options.shouldBuildLazily && requestedAssetIds.size > 0),
+  });
+
+  if (
+    getFeatureFlag('nativePackager') &&
+    getFeatureFlag('nativePackagerSSRDev') &&
+    rustAtlaspack
+  ) {
+    let hasSupportedTarget = false;
+    bundleGraph.traverseBundles((bundle, ctx, actions) => {
+      if (
+        fromEnvironmentId(bundle.env).context === 'tesseract' &&
+        bundle.type === 'js'
+      ) {
+        hasSupportedTarget = true;
+        actions.stop();
+      }
+    });
+    if (hasSupportedTarget) {
+      if (didIncrementallyBundle) {
+        const changedAssetIds = Array.from(changedAssets.keys());
+        await rustAtlaspack.updateBundleGraph(bundleGraph, changedAssetIds);
+      } else {
+        await rustAtlaspack.loadBundleGraph(bundleGraph);
+      }
+    }
+  }
+
+  // @ts-expect-error TS2345
+  dumpGraphToGraphViz(bundleGraph._graph, 'BundleGraph', bundleGraphEdgeTypes);
+
+  await report({
+    type: 'buildProgress',
+    phase: 'bundled',
+    bundleGraph: new IBundleGraph(
+      bundleGraph,
+      // @ts-expect-error TS2304
+      (bundle: Bundle, bundleGraph: BundleGraph, options: AtlaspackOptions) =>
+        NamedBundle.get(bundle, bundleGraph, options),
+      options,
+    ),
+    changedAssets: new Map(
+      Array.from(changedAssets).map(([id, asset]: [any, any]) => [
+        id,
+        assetFromValue(asset, options),
+      ]),
+    ),
+  });
+
+  let packagingMeasurement = tracer.createMeasurement('packaging');
+  const span = atlaspackTracer.enter('writeBundles');
+
+  let writeBundlesRequest = createWriteBundlesRequest({
+    bundleGraph,
+    optionsRef,
+  });
+
+  let {bundleInfo, scopeHoistingStats} =
+    await api.runRequest(writeBundlesRequest);
+  packagingMeasurement && packagingMeasurement.end();
+  atlaspackTracer.exit(span);
+  assertSignalNotAborted(signal);
+
+  return {
+    bundleGraph,
+    bundleInfo,
+    changedAssets,
+    assetRequests,
+    scopeHoistingStats,
+  };
+}

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];
     }