@atlaspack/core 2.12.1-dev.3443 → 2.12.1-dev.3460

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

@@ -1,28 +1,42 @@
 // @flow
 import assert from 'assert';
 import * as napi from '@atlaspack/rust';
+import type {JsCallable} from '@atlaspack/rust';
+import {NodeFS} from '@atlaspack/fs';
+import {NodePackageManager} from '@atlaspack/package-manager';
 import type {
   Resolver,
   Transformer,
-  PluginOptions,
-  Dependency,
   FilePath,
+  FileSystem,
 } from '@atlaspack/types';
 import {workerData} from 'worker_threads';
 import * as module from 'module';
 
-import {AssetCompat} from './compat';
-import type {InnerAsset} from './compat';
+import {
+  Environment,
+  Dependency,
+  PluginConfig,
+  PluginLogger,
+  PluginTracer,
+  PluginOptions,
+  MutableAsset,
+  bundleBehaviorMap,
+  dependencyPriorityMap,
+} from './compat';
 import {jsCallable} from '../jsCallable';
-import type {JsCallable} from '../jsCallable';
 
 const CONFIG = Symbol.for('parcel-plugin-config');
 
 export class AtlaspackWorker {
-  #resolvers: Map<string, Resolver<*>>;
+  #resolvers: Map<string, ResolverState<any>>;
+  #transformers: Map<string, TransformerState<any>>;
+  #fs: FileSystem;
 
   constructor() {
     this.#resolvers = new Map();
+    this.#transformers = new Map();
+    this.#fs = new NodeFS();
   }
 
   loadPlugin: JsCallable<[LoadPluginOptions], Promise<void>> = jsCallable(
@@ -37,6 +51,7 @@ export class AtlaspackWorker {
         instance = resolvedModule.default[CONFIG];
       } else if (
         resolvedModule.default &&
+        resolvedModule.default.default &&
         resolvedModule.default.default[CONFIG]
       ) {
         instance = resolvedModule.default.default[CONFIG];
@@ -48,7 +63,10 @@ export class AtlaspackWorker {
 
       switch (kind) {
         case 'resolver':
-          this.#resolvers.set(specifier, instance);
+          this.#resolvers.set(specifier, {resolver: instance});
+          break;
+        case 'transformer':
+          this.#transformers.set(specifier, {transformer: instance});
           break;
       }
     },
@@ -57,142 +75,225 @@ export class AtlaspackWorker {
   runResolverResolve: JsCallable<
     [RunResolverResolveOptions],
     Promise<RunResolverResolveResult>,
-  > = jsCallable(async ({key, dependency, specifier}) => {
-    const resolver = this.#resolvers.get(key);
-    if (!resolver) {
-      throw new Error(`Resolver not found: ${key}`);
-    }
-
-    const result = await resolver.resolve({
+  > = jsCallable(
+    async ({
+      key,
+      dependency: napiDependency,
       specifier,
-      dependency,
-      get options() {
-        throw new Error('TODO: Resolver.resolve.options');
-      },
-      get logger() {
-        throw new Error('TODO: Resolver.resolve.logger');
-      },
-      get tracer() {
-        throw new Error('TODO: Resolver.resolve.tracer');
-      },
-      get pipeline() {
-        throw new Error('TODO: Resolver.resolve.pipeline');
-      },
-      get config() {
-        throw new Error('TODO: Resolver.resolve.config');
-      },
-    });
-
-    if (!result) {
+      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 env = new Environment(napiDependency.env);
+      const dependency = new Dependency(napiDependency, env);
+
+      const defaultOptions = {
+        logger: new PluginLogger(),
+        tracer: new PluginTracer(),
+        options: new PluginOptions({
+          packageManager,
+          shouldAutoInstall: false,
+          projectRoot,
+          inputFS: this.#fs,
+          outputFS: this.#fs,
+        }),
+      };
+
+      if (!('config' in state)) {
+        state.config = await state.resolver.loadConfig?.({
+          config: new PluginConfig({
+            env,
+            isSource: true,
+            searchPath: '',
+          }),
+          ...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: 'unresolved'},
+        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: dependencyPriorityMap.intoNullable(result.priority),
+          query: result.query && result.query.toString(),
+        },
       };
-    }
+    },
+  );
 
-    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');
-  }
+  runTransformerTransform: JsCallable<
+    [RunTransformerTransformOptions],
+    Promise<RunTransformerTransformResult>,
+  > = jsCallable(
+    async ({key, env: napiEnv, projectRoot, asset: innerAsset}) => {
+      const state = this.#transformers.get(key);
+      if (!state) {
+        throw new Error(`Transformer not found: ${key}`);
+      }
+
+      let packageManager = state.packageManager;
+      if (!packageManager) {
+        packageManager = new NodePackageManager(this.#fs, projectRoot);
+        state.packageManager = packageManager;
+      }
+
+      const transformer: Transformer<any> = state.transformer;
+      const env = new Environment(napiEnv);
+      const mutableAsset = new MutableAsset(innerAsset, this.#fs, env);
+      const defaultOptions = {
+        logger: new PluginLogger(),
+        tracer: new PluginTracer(),
+        options: new PluginOptions({
+          packageManager,
+          shouldAutoInstall: false,
+          projectRoot,
+          inputFS: this.#fs,
+          outputFS: this.#fs,
+        }),
+      };
+
+      const config = await transformer.loadConfig?.({
+        config: new PluginConfig({
+          env,
+          isSource: true,
+          searchPath: '',
+        }),
+        ...defaultOptions,
+      });
 
-  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);
+        const ast = await transformer.parse({
+          asset: mutableAsset,
+          config,
+          get resolve() {
+            throw new Error('Transformer.parse.resolve()');
+          },
+          ...defaultOptions,
+        });
+        if (ast) {
+          mutableAsset.setAST(ast);
+        }
       }
 
-      // $FlowFixMe
-      const result = await transformer.transform({
-        // $FlowFixMe
-        asset: assetCompat,
-        options,
-        config: null,
+      const result = await state.transformer.transform({
+        asset: mutableAsset,
+        config,
+        get resolve() {
+          throw new Error('Transformer.transform.resolve()');
+        },
+        ...defaultOptions,
       });
 
       if (transformer.generate) {
-        // $FlowFixMe
-        let output = await transformer.generate({
-          // $FlowFixMe
-          asset: assetCompat,
-          // $FlowFixMe
-          ast: assetCompat.getAST(),
+        const ast = await mutableAsset.getAST();
+        if (!ast) {
+          throw new Error('Transformer.generate.ast');
+        }
+        // $FlowFixMe "Cannot call `transformer.generate` because  undefined [1] is not a function." 🤷‍♀️
+        const output = await transformer.generate({
+          asset: mutableAsset,
+          ast,
+          ...defaultOptions,
         });
-        // $FlowFixMe
-        assetCompat.setCode(output.content);
+
+        if (typeof output.content === 'string') {
+          mutableAsset.setCode(output.content);
+        } else if (output.content instanceof Buffer) {
+          mutableAsset.setBuffer(output.content);
+        } else {
+          mutableAsset.setStream(output.content);
+        }
       }
 
       assert(
         result.length === 1,
         '[V3] Unimplemented: Multiple asset return from Node transformer',
       );
+
       assert(
-        result[0] === assetCompat,
+        result[0] === mutableAsset,
         '[V3] Unimplemented: New asset returned from Node transformer',
       );
 
       return {
-        asset,
-        dependencies: assetCompat._dependencies,
+        asset: {
+          id: mutableAsset.id,
+          bundleBehavior: bundleBehaviorMap.intoNullable(
+            mutableAsset.bundleBehavior,
+          ),
+          filePath: mutableAsset.filePath,
+          type: mutableAsset.type,
+          code: Array.from(await mutableAsset.getBuffer()),
+          meta: mutableAsset.meta,
+          pipeline: mutableAsset.pipeline,
+          query: mutableAsset.query.toString(),
+          symbols: mutableAsset.symbols.intoNapi(),
+          uniqueKey: mutableAsset.uniqueKey,
+          sideEffects: mutableAsset.sideEffects,
+          isBundleSplittable: mutableAsset.isBundleSplittable,
+          isSource: mutableAsset.isSource,
+        },
       };
-    } 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 TransformerState<T> = {|
+  packageManager?: NodePackageManager,
+  transformer: Transformer<T>,
+|};
+
 type LoadPluginOptions = {|
-  kind: 'resolver',
+  kind: 'resolver' | 'transformer',
   specifier: string,
   resolveFrom: string,
 |};
 
 type RunResolverResolveOptions = {|
   key: string,
-  dependency: Dependency,
+  dependency: napi.Dependency,
   specifier: FilePath,
+  pipeline: ?string,
+  projectRoot: string,
 |};
 
 type RunResolverResolveResult = {|
@@ -208,14 +309,18 @@ type RunResolverResolveResult = {|
         code?: string,
         meta?: mixed,
         pipeline?: string,
-        priority?: number,
+        priority?: ?number,
         query?: string,
       |},
 |};
 
-const PriorityMap = {
-  sync: 0,
-  parallel: 1,
-  lazy: 2,
-  conditional: 3,
-};
+type RunTransformerTransformOptions = {|
+  key: string,
+  env: napi.Environment,
+  projectRoot: string,
+  asset: napi.Asset,
+|};
+
+type RunTransformerTransformResult = {|
+  asset: napi.RpcAssetResult,
+|};

package/src/dumpGraphToGraphViz.js

@@ -82,7 +82,7 @@ export default async function dumpGraphToGraphViz(
       label = node;
     } else if (node.assets) {
       label = `(${nodeId(id)}), (assetIds: ${[...node.assets]
-        .map(a => {
+        .map((a) => {
           let arr = a.filePath.split('/');
           return arr[arr.length - 1];
         })

package/src/loadDotEnv.js

@@ -26,7 +26,7 @@ export default async function loadEnv(
   ].filter(Boolean);
 
   let envs = await Promise.all(
-    dotenvFiles.map(async dotenvFile => {
+    dotenvFiles.map(async (dotenvFile) => {
       const envPath = await resolveConfig(
         fs,
         filePath,

package/src/projectPath.js

@@ -9,14 +9,22 @@ import {relativePath, normalizeSeparators} from '@atlaspack/utils';
 export opaque type ProjectPath = string;
 
 function toProjectPath_(projectRoot: FilePath, p: FilePath): ProjectPath {
+  // If the file path is not provided, then treat it as though it is already from the project root
   if (p == null) {
     return p;
   }
 
-  // If the file is outside the project root, store an absolute path rather
-  // than a relative one. This way if the project root is moved, the file
-  // references still work. Accessing files outside the project root is not
-  // portable anyway.
+  // If the file path is already relative and it does not begin with . then treat the path as if it
+  // is already from the project root. This prevents relative paths from being processed twice,
+  // most often within `toInternalSourceLocation` when handling loc types from symbols and asset
+  // dependencies.
+  if (p[0] !== '.' && !path.isAbsolute(p)) {
+    return p;
+  }
+
+  // If the file is outside the project root, store an absolute path rather than a relative one.
+  // This way if the project root is moved, the file references still work. Accessing files outside
+  // the project root is not portable anyway.
   let relative = relativePath(projectRoot, p, false);
   if (relative.startsWith('..')) {
     return process.platform === 'win32' ? normalizeSeparators(p) : p;

package/src/public/Asset.js

@@ -162,7 +162,7 @@ class BaseAsset {
   getDependencies(): $ReadOnlyArray<IDependency> {
     return this.#asset
       .getDependencies()
-      .map(dep => getPublicDependency(dep, this.#asset.options));
+      .map((dep) => getPublicDependency(dep, this.#asset.options));
   }
 
   getCode(): Promise<string> {

package/src/public/Bundle.js

@@ -155,7 +155,7 @@ export class Bundle implements IBundle {
   }
 
   getEntryAssets(): Array<IAsset> {
-    return this.#bundle.entryAssetIds.map(id => {
+    return this.#bundle.entryAssetIds.map((id) => {
       let assetNode = this.#bundleGraph._graph.getNodeByContentKey(id);
       invariant(assetNode != null && assetNode.type === 'asset');
       return assetFromValue(assetNode.value, this.#options);
@@ -177,7 +177,7 @@ export class Bundle implements IBundle {
   ): ?TContext {
     return this.#bundleGraph.traverseBundle(
       this.#bundle,
-      mapVisitor(node => {
+      mapVisitor((node) => {
         if (node.type === 'asset') {
           return {
             type: 'asset',
@@ -199,7 +199,7 @@ export class Bundle implements IBundle {
   ): ?TContext {
     return this.#bundleGraph.traverseAssets(
       this.#bundle,
-      mapVisitor(asset => assetFromValue(asset, this.#options), visit),
+      mapVisitor((asset) => assetFromValue(asset, this.#options), visit),
       startAsset ? assetToAssetValue(startAsset) : undefined,
     );
   }

package/src/public/BundleGraph.js

@@ -93,7 +93,7 @@ export default class BundleGraph<TBundle: IBundle>
   getIncomingDependencies(asset: IAsset): Array<IDependency> {
     return this.#graph
       .getIncomingDependencies(assetToAssetValue(asset))
-      .map(dep => getPublicDependency(dep, this.#options));
+      .map((dep) => getPublicDependency(dep, this.#options));
   }
 
   getAssetWithDependency(dep: IDependency): ?IAsset {
@@ -108,7 +108,7 @@ export default class BundleGraph<TBundle: IBundle>
   getBundleGroupsContainingBundle(bundle: IBundle): Array<IBundleGroup> {
     return this.#graph
       .getBundleGroupsContainingBundle(bundleToInternalBundle(bundle))
-      .map(bundleGroup => new BundleGroup(bundleGroup, this.#options));
+      .map((bundleGroup) => new BundleGroup(bundleGroup, this.#options));
   }
 
   getReferencedBundles(
@@ -117,13 +117,13 @@ export default class BundleGraph<TBundle: IBundle>
   ): Array<TBundle> {
     return this.#graph
       .getReferencedBundles(bundleToInternalBundle(bundle), opts)
-      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+      .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
   }
 
   getReferencingBundles(bundle: IBundle): Array<TBundle> {
     return this.#graph
       .getReferencingBundles(bundleToInternalBundle(bundle))
-      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+      .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
   }
 
   resolveAsyncDependency(
@@ -167,7 +167,7 @@ export default class BundleGraph<TBundle: IBundle>
   getDependencies(asset: IAsset): Array<IDependency> {
     return this.#graph
       .getDependencies(assetToAssetValue(asset))
-      .map(dep => getPublicDependency(dep, this.#options));
+      .map((dep) => getPublicDependency(dep, this.#options));
   }
 
   isAssetReachableFromBundle(asset: IAsset, bundle: IBundle): boolean {
@@ -200,13 +200,13 @@ export default class BundleGraph<TBundle: IBundle>
         bundleGroupToInternalBundleGroup(bundleGroup),
         opts,
       )
-      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+      .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
   }
 
   getBundles(opts?: {|includeInline: boolean|}): Array<TBundle> {
     return this.#graph
       .getBundles(opts)
-      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+      .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
   }
 
   isEntryBundleGroup(bundleGroup: IBundleGroup): boolean {
@@ -218,13 +218,13 @@ export default class BundleGraph<TBundle: IBundle>
   getChildBundles(bundle: IBundle): Array<TBundle> {
     return this.#graph
       .getChildBundles(bundleToInternalBundle(bundle))
-      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+      .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
   }
 
   getParentBundles(bundle: IBundle): Array<TBundle> {
     return this.#graph
       .getParentBundles(bundleToInternalBundle(bundle))
-      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+      .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
   }
 
   getSymbolResolution(
@@ -253,7 +253,7 @@ export default class BundleGraph<TBundle: IBundle>
       assetToAssetValue(asset),
       boundary ? bundleToInternalBundle(boundary) : null,
     );
-    return res.map(e => ({
+    return res.map((e) => ({
       asset: assetFromValue(e.asset, this.#options),
       exportSymbol: e.exportSymbol,
       symbol: e.symbol,
@@ -296,7 +296,7 @@ export default class BundleGraph<TBundle: IBundle>
   ): ?TContext {
     return this.#graph.traverseBundles(
       mapVisitor(
-        bundle => this.#createBundle(bundle, this.#graph, this.#options),
+        (bundle) => this.#createBundle(bundle, this.#graph, this.#options),
         visit,
       ),
       startBundle == null ? undefined : bundleToInternalBundle(startBundle),
@@ -306,13 +306,13 @@ export default class BundleGraph<TBundle: IBundle>
   getBundlesWithAsset(asset: IAsset): Array<TBundle> {
     return this.#graph
       .getBundlesWithAsset(assetToAssetValue(asset))
-      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+      .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
   }
 
   getBundlesWithDependency(dependency: IDependency): Array<TBundle> {
     return this.#graph
       .getBundlesWithDependency(dependencyToInternalDependency(dependency))
-      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+      .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
   }
 
   getUsedSymbols(v: IAsset | IDependency): ?$ReadOnlySet<Symbol> {
@@ -345,7 +345,7 @@ export default class BundleGraph<TBundle: IBundle>
     ifFalseAssetId: string,
   |}> {
     const conditions = new Set();
-    const depIds = deps.map(dep => dep.id);
+    const depIds = deps.map((dep) => dep.id);
     for (const condition of this.#graph._conditions.values()) {
       if (
         depIds.includes(condition.ifTrueDependency.id) ||
@@ -354,7 +354,7 @@ export default class BundleGraph<TBundle: IBundle>
         const [trueAsset, falseAsset] = [
           condition.ifTrueDependency,
           condition.ifFalseDependency,
-        ].map(dep => {
+        ].map((dep) => {
           const resolved = nullthrows(this.#graph.resolveAsyncDependency(dep));
           if (resolved.type === 'asset') {
             return resolved.value;
@@ -367,11 +367,11 @@ export default class BundleGraph<TBundle: IBundle>
           publicId: condition.publicId,
           key: condition.key,
           ifTrueDependency: nullthrows(
-            deps.find(dep => dep.id === condition.ifTrueDependency.id),
+            deps.find((dep) => dep.id === condition.ifTrueDependency.id),
             'ifTrueDependency was null',
           ),
           ifFalseDependency: nullthrows(
-            deps.find(dep => dep.id === condition.ifFalseDependency.id),
+            deps.find((dep) => dep.id === condition.ifFalseDependency.id),
             'ifFalseDependency was null',
           ),
           ifTrueAssetId: this.#graph.getAssetPublicId(trueAsset),
@@ -400,7 +400,7 @@ export default class BundleGraph<TBundle: IBundle>
 
     // 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 =>
+      let assets = Array.from(cond.assets).map((asset) =>
         nullthrows(this.getAssetById(asset.id)),
       );
       let bundles = new Set<TBundle>();
@@ -412,9 +412,9 @@ export default class BundleGraph<TBundle: IBundle>
           bundles.add(bundle);
         }
         const assetDeps = this.getDependencies(asset);
-        const depToBundles = dep => {
+        const depToBundles = (dep) => {
           const publicDep = nullthrows(
-            assetDeps.find(assetDep => dep.id === assetDep.id),
+            assetDeps.find((assetDep) => dep.id === assetDep.id),
           );
           const resolved = nullthrows(this.resolveAsyncDependency(publicDep));
           invariant(resolved.type === 'bundle_group');

package/src/public/Config.js

@@ -86,7 +86,7 @@ export default class PublicConfig implements IConfig {
     this.#config.devDeps.push({
       ...devDep,
       resolveFrom: toProjectPath(this.#options.projectRoot, devDep.resolveFrom),
-      additionalInvalidations: devDep.additionalInvalidations?.map(i => ({
+      additionalInvalidations: devDep.additionalInvalidations?.map((i) => ({
         ...i,
         resolveFrom: toProjectPath(this.#options.projectRoot, i.resolveFrom),
       })),