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

package/src/requests/BundleGraphRequestUtils.ts

@@ -0,0 +1,323 @@
+/**
+ * Shared utilities for BundleGraphRequest and BundleGraphRequestRust.
+ *
+ * This module contains common functionality used by both the JS and native
+ * bundling paths, such as bundle validation, naming, and configuration loading.
+ */
+import type {Async, Bundle as IBundle, Namer} from '@atlaspack/types';
+import type {SharedReference} from '@atlaspack/workers';
+import type {AtlaspackConfig, LoadedPlugin} from '../AtlaspackConfig';
+import type {RunAPI} from '../RequestTracker';
+import type {
+  Bundle as InternalBundle,
+  Config,
+  DevDepRequest,
+  AtlaspackOptions,
+  DevDepRequestRef,
+} from '../types';
+
+import assert from 'assert';
+import fs from 'fs';
+import nullthrows from 'nullthrows';
+import path from 'path';
+import {PluginLogger} from '@atlaspack/logger';
+import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
+import {unique, setSymmetricDifference} from '@atlaspack/utils';
+import InternalBundleGraph, {bundleGraphEdgeTypes} from '../BundleGraph';
+import BundleGraph from '../public/BundleGraph';
+import {Bundle, NamedBundle} from '../public/Bundle';
+import PluginOptions from '../public/PluginOptions';
+import {createConfig} from '../InternalConfig';
+import {
+  createDevDependency,
+  runDevDepRequest as runDevDepRequestInternal,
+} from './DevDepRequest';
+import {
+  loadPluginConfig,
+  runConfigRequest,
+  PluginWithLoadConfig,
+} from './ConfigRequest';
+import {
+  joinProjectPath,
+  fromProjectPathRelative,
+  toProjectPathUnsafe,
+} from '../projectPath';
+import {tracer, PluginTracer} from '@atlaspack/profiler';
+import type {BundleGraphResult} from './BundleGraphRequest';
+
+/**
+ * Validates that all bundles have unique names.
+ * Throws an assertion error if duplicate bundle names are found.
+ */
+export function validateBundles(bundleGraph: InternalBundleGraph): void {
+  const bundles = bundleGraph.getBundles();
+
+  const 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(),
+  );
+}
+
+/**
+ * Dump a canonical JSON snapshot of the bundle graph for parity comparison.
+ * Gated by ATLASPACK_DUMP_BUNDLE_GRAPH environment variable which specifies the output directory.
+ * The snapshot captures bundle identity, type, contained assets, and bundle group structure
+ * in a deterministic, sorted format suitable for diffing.
+ */
+export function dumpBundleGraphSnapshot(
+  bundleGraph: InternalBundleGraph,
+  variant: 'js' | 'rust',
+): void {
+  let outDir = process.env.ATLASPACK_DUMP_BUNDLE_GRAPH;
+  if (!outDir) return;
+
+  let filename =
+    variant === 'js' ? 'bundle-graph-js.json' : 'bundle-graph-rust.json';
+  let outPath = path.join(outDir, filename);
+
+  fs.mkdirSync(outDir, {recursive: true});
+
+  let bundles = bundleGraph.getBundles();
+  let bundlesSnapshot = bundles
+    .map((bundle) => {
+      let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.id);
+      let containedAssetNodeIds = bundleGraph._graph.getNodeIdsConnectedFrom(
+        bundleNodeId,
+        bundleGraphEdgeTypes.contains,
+      );
+      let containedAssets = containedAssetNodeIds
+        .map((nodeId) => bundleGraph._graph.getNode(nodeId))
+        .flatMap((node) => {
+          if (node?.type !== 'asset') return [];
+          return [
+            {
+              id: node.value.id,
+              filePath: fromProjectPathRelative(node.value.filePath),
+            },
+          ];
+        })
+        .sort((a, b) => a.filePath.localeCompare(b.filePath));
+
+      // Resolve mainEntry and entry asset file paths
+      let mainEntryPath: string | null = null;
+      let entryAssetPaths: string[] = [];
+      if (bundle.mainEntryId) {
+        let mainEntryNodeId = bundleGraph._graph.getNodeIdByContentKey(
+          bundle.mainEntryId,
+        );
+        let mainEntryNode = bundleGraph._graph.getNode(mainEntryNodeId);
+        if (mainEntryNode?.type === 'asset') {
+          mainEntryPath = fromProjectPathRelative(mainEntryNode.value.filePath);
+        }
+      }
+      for (let entryId of bundle.entryAssetIds) {
+        let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(entryId);
+        let entryNode = bundleGraph._graph.getNode(entryNodeId);
+        if (entryNode?.type === 'asset') {
+          entryAssetPaths.push(
+            fromProjectPathRelative(entryNode.value.filePath),
+          );
+        }
+      }
+      entryAssetPaths.sort();
+
+      return {
+        id: bundle.id,
+        type: bundle.type,
+        bundleBehavior: bundle.bundleBehavior ?? null,
+        needsStableName: bundle.needsStableName,
+        isSplittable: bundle.isSplittable,
+        isPlaceholder: bundle.isPlaceholder,
+        mainEntryPath,
+        entryAssetPaths,
+        assets: containedAssets.map((a) => a.filePath),
+      };
+    })
+    .sort((a, b) => {
+      // Sort by mainEntryPath first, then by sorted assets as tiebreaker
+      let aKey = a.mainEntryPath || a.assets.join(',');
+      let bKey = b.mainEntryPath || b.assets.join(',');
+      return aKey.localeCompare(bKey);
+    });
+
+  let bundleGroupsSnapshot = bundleGraph._graph.nodes
+    .flatMap((node) => {
+      if (node?.type !== 'bundle_group') return [];
+
+      let bundleGroup = node.value;
+
+      // Resolve entry asset file path
+      let entryAssetPath: string | null = null;
+      try {
+        let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(
+          bundleGroup.entryAssetId,
+        );
+        let entryNode = bundleGraph._graph.getNode(entryNodeId);
+        if (entryNode?.type === 'asset') {
+          entryAssetPath = fromProjectPathRelative(entryNode.value.filePath);
+        }
+      } catch {
+        // Content key not found
+      }
+
+      let bundlesInGroup = bundleGraph.getBundlesInBundleGroup(bundleGroup);
+      let bundlePaths = bundlesInGroup
+        .map((b) => {
+          // Use mainEntry file path if available, otherwise bundle id as fallback
+          if (b.mainEntryId) {
+            try {
+              let nodeId = bundleGraph._graph.getNodeIdByContentKey(
+                b.mainEntryId,
+              );
+              let node = bundleGraph._graph.getNode(nodeId);
+              if (node?.type === 'asset') {
+                return fromProjectPathRelative(node.value.filePath);
+              }
+            } catch {
+              // fallback
+            }
+          }
+          return `[bundle:${b.id}]`;
+        })
+        .sort();
+
+      return [
+        {
+          entryAssetPath:
+            entryAssetPath ?? `[unknown:${bundleGroup.entryAssetId}]`,
+          bundlePaths,
+        },
+      ];
+    })
+    .sort((a, b) => a.entryAssetPath.localeCompare(b.entryAssetPath));
+
+  let totalAssets = bundleGraph._graph.nodes.filter(
+    (node) => node?.type === 'asset',
+  ).length;
+
+  let snapshot = {
+    version: 1,
+    variant,
+    stats: {
+      totalBundles: bundlesSnapshot.length,
+      totalBundleGroups: bundleGroupsSnapshot.length,
+      totalAssets,
+    },
+    bundles: bundlesSnapshot,
+    bundleGroups: bundleGroupsSnapshot,
+  };
+
+  fs.writeFileSync(outPath, JSON.stringify(snapshot, null, 2), 'utf8');
+  // eslint-disable-next-line no-console
+  console.log(`[BundleGraphSnapshot] Wrote ${variant} snapshot to ${outPath}`);
+}
+
+/**
+ * Names a bundle by running through the configured namers until one returns a name.
+ */
+export async function nameBundle(
+  namers: Array<LoadedPlugin<Namer<unknown>>>,
+  internalBundle: InternalBundle,
+  internalBundleGraph: InternalBundleGraph,
+  options: AtlaspackOptions,
+  pluginOptions: PluginOptions,
+  configs: Map<string, Config>,
+): Promise<void> {
+  const bundle = Bundle.get(internalBundle, internalBundleGraph, options);
+  const bundleGraph = new BundleGraph<IBundle>(
+    internalBundleGraph,
+    NamedBundle.get.bind(NamedBundle),
+    options,
+  );
+
+  for (const namer of namers) {
+    let measurement;
+    try {
+      measurement = tracer.createMeasurement(namer.name, 'namer', bundle.id);
+      const name = await namer.plugin.name({
+        bundle,
+        bundleGraph,
+        config: configs.get(namer.name)?.result,
+        options: pluginOptions,
+        logger: new PluginLogger({origin: namer.name}),
+        tracer: new PluginTracer({origin: namer.name, category: 'namer'}),
+      });
+
+      if (name != null) {
+        internalBundle.name = name;
+        const {hashReference} = internalBundle;
+        internalBundle.displayName = name.includes(hashReference)
+          ? name.replace(hashReference, '[hash]')
+          : name;
+
+        return;
+      }
+    } catch (e: any) {
+      throw new ThrowableDiagnostic({
+        diagnostic: errorToDiagnostic(e, {
+          origin: namer.name,
+        }),
+      });
+    } finally {
+      measurement && measurement.end();
+    }
+  }
+
+  throw new Error('Unable to name bundle');
+}
+
+/**
+ * Loads configuration for a plugin and tracks its dev dependencies.
+ */
+export async function loadPluginConfigWithDevDeps<
+  T extends PluginWithLoadConfig,
+>(
+  plugin: LoadedPlugin<T>,
+  options: AtlaspackOptions,
+  api: RunAPI<BundleGraphResult>,
+  previousDevDeps: Map<string, string>,
+  devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>,
+  configs: Map<string, Config>,
+): Promise<void> {
+  const config = createConfig({
+    plugin: plugin.name,
+    searchPath: toProjectPathUnsafe('index'),
+  });
+
+  await loadPluginConfig(plugin, config, options);
+  await runConfigRequest(api, config);
+  for (const devDep of config.devDeps) {
+    const devDepRequest = await createDevDependency(
+      devDep,
+      previousDevDeps,
+      options,
+    );
+    await runDevDepRequest(api, devDepRequest, devDepRequests);
+  }
+
+  configs.set(plugin.name, config);
+}
+
+/**
+ * Runs a dev dependency request and tracks it in the devDepRequests map.
+ */
+export async function runDevDepRequest(
+  api: RunAPI<BundleGraphResult>,
+  devDepRequest: DevDepRequest | DevDepRequestRef,
+  devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>,
+): Promise<void> {
+  const {specifier, resolveFrom} = devDepRequest;
+  const key = `${specifier}:${fromProjectPathRelative(resolveFrom)}`;
+  devDepRequests.set(key, devDepRequest);
+  await runDevDepRequestInternal(api, devDepRequest);
+}

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

@@ -1,4 +1,3 @@
-// @flow
 import type {
   Async,
   Config as IConfig,
@@ -7,6 +6,7 @@ import type {
   PluginTracer as IPluginTracer,
   NamedBundle as INamedBundle,
   BundleGraph as IBundleGraph,
+  TransformerSetup,
 } from '@atlaspack/types';
 import {readConfig, hashObject} from '@atlaspack/utils';
 import type {
@@ -30,52 +30,56 @@ import {PluginTracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
 import {fromProjectPath, fromProjectPathRelative} from '../projectPath';
 
+type Setup<T> = (arg1: {
+  config: IConfig;
+  options: IPluginOptions;
+  logger: IPluginLogger;
+  tracer: IPluginTracer;
+}) => Async<TransformerSetup<T>>;
+
 export type PluginWithLoadConfig = {
-  loadConfig?: ({|
-    config: IConfig,
-    options: IPluginOptions,
-    logger: IPluginLogger,
-    tracer: IPluginTracer,
-  |}) => Async<mixed>,
-  ...
+  loadConfig?: (arg1: {
+    config: IConfig;
+    options: IPluginOptions;
+    logger: IPluginLogger;
+    tracer: IPluginTracer;
+  }) => Async<unknown>;
 };
 
 export type PluginWithBundleConfig = {
-  loadConfig?: ({|
-    config: IConfig,
-    options: IPluginOptions,
-    logger: IPluginLogger,
-    tracer: IPluginTracer,
-  |}) => Async<mixed>,
-  loadBundleConfig?: ({|
-    bundle: INamedBundle,
-    bundleGraph: IBundleGraph<INamedBundle>,
-    config: IConfig,
-    options: IPluginOptions,
-    logger: IPluginLogger,
-    tracer: IPluginTracer,
-  |}) => Async<mixed>,
-  ...
+  loadConfig?: (arg1: {
+    config: IConfig;
+    options: IPluginOptions;
+    logger: IPluginLogger;
+    tracer: IPluginTracer;
+  }) => Async<unknown>;
+  loadBundleConfig?: (arg1: {
+    bundle: INamedBundle;
+    bundleGraph: IBundleGraph<INamedBundle>;
+    config: IConfig;
+    options: IPluginOptions;
+    logger: IPluginLogger;
+    tracer: IPluginTracer;
+  }) => Async<unknown>;
 };
 
 export type ConfigRequest = {
-  id: string,
-  invalidateOnFileChange: Set<ProjectPath>,
-  invalidateOnConfigKeyChange: Array<{|
-    filePath: ProjectPath,
-    configKey: string,
-  |}>,
-  invalidateOnFileCreate: Array<InternalFileCreateInvalidation>,
-  invalidateOnEnvChange: Set<string>,
-  invalidateOnOptionChange: Set<string>,
-  invalidateOnStartup: boolean,
-  invalidateOnBuild: boolean,
-  ...
+  id: string;
+  invalidateOnFileChange: Set<ProjectPath>;
+  invalidateOnConfigKeyChange: Array<{
+    filePath: ProjectPath;
+    configKey: string[];
+  }>;
+  invalidateOnFileCreate: Array<InternalFileCreateInvalidation>;
+  invalidateOnEnvChange: Set<string>;
+  invalidateOnOptionChange: Set<string>;
+  invalidateOnStartup: boolean;
+  invalidateOnBuild: boolean;
 };
 
-export type ConfigRequestResult = void;
+export type ConfigRequestResult = undefined;
 
-export async function loadPluginConfig<T: PluginWithLoadConfig>(
+export async function loadPluginConfig<T extends PluginWithLoadConfig>(
   loadedPlugin: LoadedPlugin<T>,
   config: Config,
   options: AtlaspackOptions,
@@ -99,7 +103,7 @@ export async function loadPluginConfig<T: PluginWithLoadConfig>(
         category: 'loadConfig',
       }),
     });
-  } catch (e) {
+  } catch (e: any) {
     throw new ThrowableDiagnostic({
       diagnostic: errorToDiagnostic(e, {
         origin: loadedPlugin.name,
@@ -108,41 +112,97 @@ export async function loadPluginConfig<T: PluginWithLoadConfig>(
   }
 }
 
+export async function loadPluginSetup<T>(
+  pluginName: string,
+  setup: Setup<T>,
+  config: Config,
+  options: AtlaspackOptions,
+): Promise<void> {
+  try {
+    let result = await setup({
+      config: new PublicConfig(config, options),
+      options: new PluginOptions(
+        optionsProxy(options, (option) => {
+          config.invalidateOnOptionChange.add(option);
+        }),
+      ),
+      logger: new PluginLogger({origin: pluginName}),
+      tracer: new PluginTracer({
+        origin: pluginName,
+        category: 'setup',
+      }),
+    });
+
+    config.result = result.config;
+  } catch (e: any) {
+    throw new ThrowableDiagnostic({
+      diagnostic: errorToDiagnostic(e, {
+        origin: pluginName,
+      }),
+    });
+  }
+}
+
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+export function getValueAtPath(obj: any, key: string[]): any {
+  let current = obj;
+  for (let part of key) {
+    if (current == null) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}
+
 const configKeyCache = createBuildCache();
 
 export async function getConfigKeyContentHash(
   filePath: ProjectPath,
-  configKey: string,
+  configKey: string[],
   options: AtlaspackOptions,
-): Async<string> {
-  let cacheKey = `${fromProjectPathRelative(filePath)}:${configKey}`;
+): Promise<Async<string>> {
+  let cacheKey = `${fromProjectPathRelative(filePath)}:${JSON.stringify(
+    configKey,
+  )}`;
   let cachedValue = configKeyCache.get(cacheKey);
 
   if (cachedValue) {
+    // @ts-expect-error TS2322
     return cachedValue;
   }
 
-  let conf = await readConfig(
+  const conf = await readConfig(
     options.inputFS,
     fromProjectPath(options.projectRoot, filePath),
   );
 
-  if (conf == null || conf.config[configKey] == null) {
+  const value = getValueAtPath(conf?.config, configKey);
+  if (conf == null || value == null) {
     // This can occur when a config key has been removed entirely during `respondToFSEvents`
     return '';
   }
 
-  let contentHash =
-    typeof conf.config[configKey] === 'object'
-      ? hashObject(conf.config[configKey])
-      : hashString(JSON.stringify(conf.config[configKey]));
+  const contentHash =
+    typeof value === 'object'
+      ? hashObject(value)
+      : hashString(JSON.stringify(value));
 
   configKeyCache.set(cacheKey, contentHash);
 
   return contentHash;
 }
 
-export async function runConfigRequest<TResult: RequestResult>(
+export async function runConfigRequest<TResult extends RequestResult>(
   api: RunAPI<TResult>,
   configRequest: ConfigRequest,
 ) {
@@ -169,7 +229,7 @@ export async function runConfigRequest<TResult: RequestResult>(
     return;
   }
 
-  await api.runRequest<null, void>({
+  await api.runRequest<null, undefined>({
     id: 'config_request:' + configRequest.id,
     type: requestTypes.config_request,
     run: async ({api, options}) => {
@@ -240,7 +300,7 @@ export async function getConfigHash(
     } else if (config.result != null) {
       try {
         hash.writeBuffer(serializeRaw(config.result));
-      } catch (err) {
+      } catch (err: any) {
         throw new ThrowableDiagnostic({
           diagnostic: {
             message: