@atlaspack/core 2.12.1-dev.3401 → 2.12.1-dev.3450

package/src/atlaspack-v3/worker/worker.js

@@ -1,14 +1,312 @@
 // @flow
+import assert from 'assert';
 import * as napi from '@atlaspack/rust';
+import {NodeFS} from '@atlaspack/fs';
+import {NodePackageManager} from '@atlaspack/package-manager';
+import type {
+  Resolver,
+  Transformer,
+  PluginOptions,
+  Dependency,
+  FilePath,
+  FileSystem,
+  ConfigResultWithFilePath,
+  PackageJSON,
+} from '@atlaspack/types';
 import {workerData} from 'worker_threads';
-import type {ResolverNapi} from '../plugins/Resolver';
+import * as module from 'module';
+
+import {AssetCompat} from './compat';
+import type {InnerAsset} from './compat';
+import {jsCallable} from '../jsCallable';
+import type {JsCallable} from '../jsCallable';
+import Environment from '../../public/Environment';
+
+const CONFIG = Symbol.for('parcel-plugin-config');
 
 export class AtlaspackWorker {
-  #resolvers: Map<string, ResolverNapi>;
+  #resolvers: Map<string, ResolverState<any>>;
+  #fs: FileSystem;
+
+  constructor() {
+    this.#resolvers = new Map();
+    this.#fs = new NodeFS();
+  }
+
+  loadPlugin: JsCallable<[LoadPluginOptions], Promise<void>> = jsCallable(
+    async ({kind, specifier, resolveFrom}) => {
+      let customRequire = module.createRequire(resolveFrom);
+      let resolvedPath = customRequire.resolve(specifier);
+      // $FlowFixMe
+      let resolvedModule = await import(resolvedPath);
+
+      let instance = undefined;
+      if (resolvedModule.default && resolvedModule.default[CONFIG]) {
+        instance = resolvedModule.default[CONFIG];
+      } else if (
+        resolvedModule.default &&
+        resolvedModule.default.default &&
+        resolvedModule.default.default[CONFIG]
+      ) {
+        instance = resolvedModule.default.default[CONFIG];
+      } else {
+        throw new Error(
+          `Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`,
+        );
+      }
+
+      switch (kind) {
+        case 'resolver':
+          this.#resolvers.set(specifier, {resolver: instance});
+          break;
+      }
+    },
+  );
+
+  runResolverResolve: JsCallable<
+    [RunResolverResolveOptions],
+    Promise<RunResolverResolveResult>,
+  > = jsCallable(
+    async ({key, dependency, specifier, pipeline, projectRoot}) => {
+      const state = this.#resolvers.get(key);
+      if (!state) {
+        throw new Error(`Resolver not found: ${key}`);
+      }
+
+      let packageManager = state.packageManager;
+      if (!packageManager) {
+        packageManager = new NodePackageManager(this.#fs, projectRoot);
+        state.packageManager = packageManager;
+      }
+
+      const defaultOptions = {
+        get logger() {
+          // $FlowFixMe
+          return globalThis.console;
+        },
+        tracer: {
+          enabled: false,
+          createMeasurement: () => null,
+        },
+        options: {
+          get mode() {
+            throw new Error('Resolver.resolve.options.mode');
+          },
+          parcelVersion: 'TODO',
+          packageManager,
+          env: process.env,
+          get hmrOptions() {
+            throw new Error('Resolver.resolve.options.hmrOptions');
+          },
+          get serveOptions() {
+            throw new Error('Resolver.resolve.options.serveOptions');
+          },
+          get shouldBuildLazily() {
+            throw new Error('Resolver.resolve.options.shouldBuildLazily');
+          },
+          shouldAutoInstall: false,
+          get logLevel() {
+            throw new Error('Resolver.resolve.options.logLevel');
+          },
+          projectRoot,
+          get cacheDir() {
+            throw new Error('Resolver.resolve.options.cacheDir');
+          },
+          inputFS: this.#fs,
+          outputFS: this.#fs,
+          get instanceId() {
+            throw new Error('Resolver.resolve.options.instanceId');
+          },
+          get detailedReport() {
+            throw new Error('Resolver.resolve.options.detailedReport');
+          },
+          get featureFlags() {
+            throw new Error('Resolver.resolve.options.featureFlags');
+          },
+        },
+      };
+
+      if (!('config' in state)) {
+        state.config = await state.resolver.loadConfig?.({
+          config: {
+            isSource: true,
+            searchPath: '',
+            // $FlowFixMe This isn't correct to flow but is enough to satisfy the runtime checks
+            env: new Environment(dependency.env, {
+              projectRoot,
+              hmrOptions: undefined,
+            }),
+            invalidateOnFileChange(): void {},
+            invalidateOnFileCreate(): void {},
+            invalidateOnEnvChange(): void {},
+            invalidateOnStartup(): void {},
+            invalidateOnBuild(): void {},
+            addDevDependency(): void {},
+            setCacheKey(): void {},
+            getConfig<T>(): Promise<?ConfigResultWithFilePath<T>> {
+              throw new Error('Resolver.loadConfig.config.getConfig');
+            },
+            getConfigFrom<T>(): Promise<?ConfigResultWithFilePath<T>> {
+              throw new Error('Resolver.loadConfig.config.getConfigFrom');
+            },
+            getPackage(): Promise<?PackageJSON> {
+              throw new Error('Resolver.loadConfig.config.getPackage');
+            },
+          },
+          ...defaultOptions,
+        });
+      }
+
+      const result = await state.resolver.resolve({
+        specifier,
+        dependency,
+        pipeline,
+        config: state.config,
+        ...defaultOptions,
+      });
+
+      if (!result) {
+        return {
+          invalidations: [],
+          resolution: {type: 'unresolved'},
+        };
+      }
+
+      return {
+        invalidations: [],
+        resolution: {
+          type: 'resolved',
+          filePath: result.filePath || '',
+          canDefer: result.canDefer || false,
+          sideEffects: result.sideEffects || false,
+          code: result.code || undefined,
+          meta: result.meta || undefined,
+          pipeline: result.pipeline || undefined,
+          priority: result.priority && PriorityMap[result.priority],
+          query: result.query && result.query.toString(),
+        },
+      };
+    },
+  );
 
   ping() {
     // console.log('Hi');
   }
+
+  async runTransformer({
+    resolveFrom,
+    specifier,
+    options,
+    asset,
+  }: {|
+    resolveFrom: string,
+    specifier: string,
+    options: PluginOptions,
+    asset: InnerAsset,
+  |}): any {
+    const customRequire = module.createRequire(resolveFrom);
+    const resolvedPath = customRequire.resolve(specifier);
+    // $FlowFixMe
+    const transformerModule = await import(resolvedPath);
+    const transformer: Transformer<*> =
+      transformerModule.default.default[CONFIG];
+
+    let assetCompat = new AssetCompat(asset, options);
+
+    try {
+      if (transformer.parse) {
+        // $FlowFixMe
+        const ast = await transformer.parse({asset: assetCompat}); // missing "config"
+        // $FlowFixMe
+        assetCompat.setAST(ast);
+      }
+
+      // $FlowFixMe
+      const result = await transformer.transform({
+        // $FlowFixMe
+        asset: assetCompat,
+        options,
+        config: null,
+      });
+
+      if (transformer.generate) {
+        // $FlowFixMe
+        let output = await transformer.generate({
+          // $FlowFixMe
+          asset: assetCompat,
+          // $FlowFixMe
+          ast: assetCompat.getAST(),
+        });
+        // $FlowFixMe
+        assetCompat.setCode(output.content);
+      }
+
+      assert(
+        result.length === 1,
+        '[V3] Unimplemented: Multiple asset return from Node transformer',
+      );
+      assert(
+        result[0] === assetCompat,
+        '[V3] Unimplemented: New asset returned from Node transformer',
+      );
+
+      return {
+        asset,
+        dependencies: assetCompat._dependencies,
+      };
+    } catch (e) {
+      // TODO: Improve error logging from JS plugins. Without this you currently
+      // only see the error message, no stack trace.
+      // eslint-disable-next-line no-console
+      console.error(e);
+      throw e;
+    }
+  }
 }
 
 napi.registerWorker(workerData.tx_worker, new AtlaspackWorker());
+
+type ResolverState<T> = {|
+  resolver: Resolver<T>,
+  config?: T,
+  packageManager?: NodePackageManager,
+|};
+
+type LoadPluginOptions = {|
+  kind: 'resolver',
+  specifier: string,
+  resolveFrom: string,
+|};
+
+type RunResolverResolveOptions = {|
+  key: string,
+  dependency: Dependency,
+  specifier: FilePath,
+  pipeline: ?string,
+  projectRoot: string,
+|};
+
+type RunResolverResolveResult = {|
+  invalidations: Array<*>,
+  resolution:
+    | {|type: 'unresolved'|}
+    | {|type: 'excluded'|}
+    | {|
+        type: 'resolved',
+        canDefer: boolean,
+        filePath: string,
+        sideEffects: boolean,
+        code?: string,
+        meta?: mixed,
+        pipeline?: string,
+        priority?: number,
+        query?: string,
+      |},
+|};
+
+const PriorityMap = {
+  sync: 0,
+  parallel: 1,
+  lazy: 2,
+  conditional: 3,
+};

package/src/public/BundleGraph.js

@@ -332,4 +332,110 @@ export default class BundleGraph<TBundle: IBundle>
       targetToInternalTarget(target),
     );
   }
+
+  // Given a set of dependencies, return any conditions where those dependencies are either
+  // the true or false dependency for those conditions. This is currently used to work out which
+  // conditions belong to a bundle in packaging.
+  getConditionsForDependencies(deps: Array<IDependency>): Set<{|
+    publicId: string,
+    key: string,
+    ifTrueDependency: IDependency,
+    ifFalseDependency: IDependency,
+    ifTrueAssetId: string,
+    ifFalseAssetId: string,
+  |}> {
+    const conditions = new Set();
+    const depIds = deps.map(dep => dep.id);
+    for (const condition of this.#graph._conditions.values()) {
+      if (
+        depIds.includes(condition.ifTrueDependency.id) ||
+        depIds.includes(condition.ifFalseDependency.id)
+      ) {
+        const [trueAsset, falseAsset] = [
+          condition.ifTrueDependency,
+          condition.ifFalseDependency,
+        ].map(dep => {
+          const resolved = nullthrows(this.#graph.resolveAsyncDependency(dep));
+          if (resolved.type === 'asset') {
+            return resolved.value;
+          } else {
+            return this.#graph.getAssetById(resolved.value.entryAssetId);
+          }
+        });
+
+        conditions.add({
+          publicId: condition.publicId,
+          key: condition.key,
+          ifTrueDependency: nullthrows(
+            deps.find(dep => dep.id === condition.ifTrueDependency.id),
+            'ifTrueDependency was null',
+          ),
+          ifFalseDependency: nullthrows(
+            deps.find(dep => dep.id === condition.ifFalseDependency.id),
+            'ifFalseDependency was null',
+          ),
+          ifTrueAssetId: this.#graph.getAssetPublicId(trueAsset),
+          ifFalseAssetId: this.#graph.getAssetPublicId(falseAsset),
+        });
+      }
+    }
+
+    return conditions;
+  }
+
+  // This is used to generate information for building a manifest that can
+  // be used by a webserver to understand which conditions are used by which bundles,
+  // and which bundles those conditions require depending on what they evaluate to.
+  getConditionalBundleMapping(): Map<
+    TBundle,
+    Map<
+      string,
+      {|
+        ifTrueBundles: Array<TBundle>,
+        ifFalseBundles: Array<TBundle>,
+      |},
+    >,
+  > {
+    let bundleConditions = new Map();
+
+    // Convert the internal references in conditions to public API references
+    for (const cond of this.#graph._conditions.values()) {
+      let assets = Array.from(cond.assets).map(asset =>
+        nullthrows(this.getAssetById(asset.id)),
+      );
+      let bundles = new Set<TBundle>();
+      let ifTrueBundles = [];
+      let ifFalseBundles = [];
+      for (const asset of assets) {
+        const bundlesWithAsset = this.getBundlesWithAsset(asset);
+        for (const bundle of bundlesWithAsset) {
+          bundles.add(bundle);
+        }
+        const assetDeps = this.getDependencies(asset);
+        const depToBundles = dep => {
+          const publicDep = nullthrows(
+            assetDeps.find(assetDep => dep.id === assetDep.id),
+          );
+          const resolved = nullthrows(this.resolveAsyncDependency(publicDep));
+          invariant(resolved.type === 'bundle_group');
+          return this.getBundlesInBundleGroup(resolved.value);
+        };
+        ifTrueBundles.push(...depToBundles(cond.ifTrueDependency));
+        ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
+      }
+
+      for (let bundle of bundles) {
+        const conditions = bundleConditions.get(bundle) ?? new Map();
+
+        conditions.set(cond.key, {
+          ifTrueBundles,
+          ifFalseBundles,
+        });
+
+        bundleConditions.set(bundle, conditions);
+      }
+    }
+
+    return bundleConditions;
+  }
 }

package/src/requests/AssetGraphRequestRust.js

@@ -10,6 +10,7 @@ import type {AtlaspackV3} from '../atlaspack-v3';
 import {toProjectPath} from '../projectPath';
 import {requestTypes, type StaticRunOpts} from '../RequestTracker';
 import {propagateSymbols} from '../SymbolPropagation';
+import type {Environment} from '../types';
 
 import type {
   AssetGraphRequestInput,
@@ -95,9 +96,58 @@ function getAssetGraph(serializedGraph, options) {
 
   graph.safeToIncrementallyBundle = false;
 
+  function mapSymbols({exported, ...symbol}) {
+    let jsSymbol = {
+      local: symbol.local ?? undefined,
+      loc: symbol.loc ?? undefined,
+      meta: undefined,
+      isWeak: symbol.isWeak,
+    };
+
+    if (symbol.exported) {
+      // $FlowFixMe
+      jsSymbol.exported = symbol.exported;
+    }
+
+    if (symbol.isEsmExport) {
+      // $FlowFixMe
+      jsSymbol.meta = {
+        isEsm: true,
+      };
+    }
+    return [exported, jsSymbol];
+  }
+
+  // See crates/atlaspack_core/src/types/environment.rs
   let cachedAssets = new Map();
   let changedAssets = new Map();
   let entry = 0;
+
+  let envs = new Map();
+  let getEnvId = (env: Environment) => {
+    let envKey = [
+      env.context,
+      env.engines.atlaspack,
+      env.engines.browsers,
+      env.engines.electron,
+      env.engines.node,
+      env.includeNodeModules,
+      env.isLibrary,
+      env.outputFormat,
+      env.shouldScopeHoist,
+      env.shouldOptimize,
+      env.sourceType,
+    ].join(':');
+
+    let envId = envs.get(envKey);
+    if (envId == null) {
+      envId = envs.size;
+      envs.set(envKey, envId);
+    }
+
+    return envId;
+  };
+
   for (let node of serializedGraph.nodes) {
     if (node.type === 'root') {
       let index = graph.addNodeByContentKey('@@root', {
@@ -116,20 +166,38 @@ function getAssetGraph(serializedGraph, options) {
         value: null,
       });
     } else if (node.type === 'asset') {
-      let id = node.value.id;
-      let asset = node.value.asset;
+      let asset = node.value;
+      let id = asset.id;
+
+      asset.meta.id = id;
 
       asset = {
         ...asset,
-        id,
+        uniqueKey: asset.uniqueKey ?? undefined,
+        pipeline: asset.pipeline ?? undefined,
+        range: asset.range ?? undefined,
+        resolveFrom: asset.resolveFrom ?? undefined,
+        target: asset.target ?? undefined,
+        plugin: asset.plugin ?? undefined,
+        query: asset.query ?? undefined,
+        configPath: asset.configPath ?? undefined,
+        configKeyPath: asset.configKeyPath ?? undefined,
+        isLargeBlob: asset.isLargeBlob ?? false,
+        isSource: asset.isSource ?? false,
+        sourcePath: asset.sourcePath ?? undefined,
+        env: {
+          ...asset.env,
+          loc: asset.env.loc ?? undefined,
+          id: getEnvId(asset.env),
+          sourceType: asset.env.sourceType,
+        },
+        bundleBehavior:
+          asset.bundleBehavior === 255 ? null : asset.bundleBehavior,
         committed: true,
         contentKey: id,
         filePath: toProjectPath(options.projectRoot, asset.filePath),
-        symbols: asset.hasSymbols
-          ? new Map(
-              asset.symbols.map(({exported, ...symbol}) => [exported, symbol]),
-            )
-          : null,
+        symbols:
+          asset.symbols != null ? new Map(asset.symbols.map(mapSymbols)) : null,
       };
 
       cachedAssets.set(id, asset.code);
@@ -150,18 +218,38 @@ function getAssetGraph(serializedGraph, options) {
       dependency = {
         ...dependency,
         id,
+        env: {
+          ...dependency.env,
+          id: getEnvId(dependency.env),
+          sourceType: dependency.env.sourceType,
+          loc: dependency.env.loc ?? undefined,
+        },
+        pipeline: dependency.pipeline ?? undefined,
+        range: dependency.range ?? undefined,
+        resolveFrom: dependency.resolveFrom ?? undefined,
+        target: dependency.target ?? undefined,
+        bundleBehavior:
+          dependency.bundleBehavior === 255 ? null : dependency.bundleBehavior,
         contentKey: id,
+        loc: dependency.loc
+          ? {
+              ...dependency.loc,
+              filePath: toProjectPath(
+                options.projectRoot,
+                dependency.loc.filePath,
+              ),
+            }
+          : undefined,
         sourcePath: dependency.sourcePath
           ? toProjectPath(options.projectRoot, dependency.sourcePath)
-          : null,
-        symbols: dependency.hasSymbols
-          ? new Map(
-              dependency.symbols.map(({exported, ...symbol}) => [
-                exported,
-                symbol,
-              ]),
-            )
-          : null,
+          : undefined,
+        symbols:
+          // Dependency.symbols are always set to an empty map when scope hoisting
+          // is enabled. Some tests will fail if this is not the case. We should
+          // make this consistant when we re-visit packaging.
+          dependency.symbols != null || dependency.env.shouldScopeHoist
+            ? new Map(dependency.symbols?.map(mapSymbols))
+            : undefined,
       };
       let usedSymbolsDown = new Set();
       let usedSymbolsUp = new Map();

package/src/requests/BundleGraphRequest.js

@@ -118,6 +118,24 @@ export default function createBundleGraphRequest(
         },
       );
 
+      // if (input.rustAtlaspack && process.env.NATIVE_COMPARE === 'true') {
+      //   let {assetGraph: jsAssetGraph} = await api.runRequest(
+      //     createAssetGraphRequestJS({
+      //       name: 'Main',
+      //       entries: options.entries,
+      //       optionsRef,
+      //       shouldBuildLazily: options.shouldBuildLazily,
+      //       lazyIncludes: options.lazyIncludes,
+      //       lazyExcludes: options.lazyExcludes,
+      //       requestedAssetIds,
+      //     }),
+      //     {
+      //       force: true,
+      //     },
+      //   );
+      //   require('./asset-graph-diff.js')(jsAssetGraph, assetGraph);
+      // }
+
       measurement && measurement.end();
       assertSignalNotAborted(signal);