@atlaspack/core 2.12.1-canary.3463 → 2.12.1-canary.3465

package/lib/atlaspack-v3/worker/compat/mutable-asset.js

@@ -19,6 +19,7 @@ class MutableAsset {
   #inner;
   #ast;
   #contents;
+  #astDirty;
   get astGenerator() {
     throw new Error('get MutableAsset.astGenerator');
   }
@@ -47,6 +48,7 @@ class MutableAsset {
     this.#contents = Buffer.from(asset.code);
     this.fs = fs;
     this.env = env;
+    this.#astDirty = false;
   }
 
   // eslint-disable-next-line require-await
@@ -54,10 +56,11 @@ class MutableAsset {
     return this.#ast;
   }
   setAST(ast) {
+    this.#astDirty = true;
     this.#ast = ast;
   }
   isASTDirty() {
-    throw new Error('MutableAsset.isASTDirty()');
+    return this.#astDirty;
   }
 
   // eslint-disable-next-line require-await
@@ -91,7 +94,8 @@ class MutableAsset {
     });
   }
   getMap() {
-    throw new Error('MutableAsset.getMap');
+    // TODO: Provide source maps once they exist
+    return Promise.resolve(null);
   }
 
   // eslint-disable-next-line no-unused-vars
@@ -122,23 +126,23 @@ class MutableAsset {
 
   // eslint-disable-next-line no-unused-vars
   invalidateOnFileChange() {
-    throw new Error('MutableAsset.invalidateOnFileChange()');
+    // TODO: Forward invalidations to Rust
   }
 
   // eslint-disable-next-line no-unused-vars
   invalidateOnFileCreate() {
-    throw new Error('MutableAsset.invalidateOnFileCreate()');
+    // TODO: Forward invalidations to Rust
   }
 
   // eslint-disable-next-line no-unused-vars
   invalidateOnEnvChange() {
-    throw new Error('MutableAsset.invalidateOnEnvChange()');
+    // TODO: Forward invalidations to Rust
   }
   invalidateOnStartup() {
-    throw new Error('MutableAsset.invalidateOnStartup()');
+    // TODO: Forward invalidations to Rust
   }
   invalidateOnBuild() {
-    throw new Error('MutableAsset.invalidateOnBuild()');
+    // TODO: Forward invalidations to Rust
   }
 }
 exports.MutableAsset = MutableAsset;

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

@@ -96,7 +96,7 @@ class AtlaspackWorker {
     dependency: napiDependency,
     specifier,
     pipeline,
-    projectRoot
+    options
   }) => {
     const state = this.#resolvers.get(key);
     if (!state) {
@@ -104,7 +104,7 @@ class AtlaspackWorker {
     }
     let packageManager = state.packageManager;
     if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, projectRoot);
+      packageManager = new (_packageManager().NodePackageManager)(this.#fs, options.projectRoot);
       state.packageManager = packageManager;
     }
     const env = new _compat.Environment(napiDependency.env);
@@ -113,9 +113,9 @@ class AtlaspackWorker {
       logger: new _compat.PluginLogger(),
       tracer: new _compat.PluginTracer(),
       options: new _compat.PluginOptions({
+        ...options,
         packageManager,
         shouldAutoInstall: false,
-        projectRoot,
         inputFS: this.#fs,
         outputFS: this.#fs
       })
@@ -164,7 +164,7 @@ class AtlaspackWorker {
   runTransformerTransform = (0, _jsCallable.jsCallable)(async ({
     key,
     env: napiEnv,
-    projectRoot,
+    options,
     asset: innerAsset
   }) => {
     var _transformer$loadConf;
@@ -174,7 +174,7 @@ class AtlaspackWorker {
     }
     let packageManager = state.packageManager;
     if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, projectRoot);
+      packageManager = new (_packageManager().NodePackageManager)(this.#fs, options.projectRoot);
       state.packageManager = packageManager;
     }
     const transformer = state.transformer;
@@ -184,9 +184,9 @@ class AtlaspackWorker {
       logger: new _compat.PluginLogger(),
       tracer: new _compat.PluginTracer(),
       options: new _compat.PluginOptions({
+        ...options,
         packageManager,
         shouldAutoInstall: false,
-        projectRoot,
         inputFS: this.#fs,
         outputFS: this.#fs
       })
@@ -222,21 +222,20 @@ class AtlaspackWorker {
     });
     if (transformer.generate) {
       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
-      });
-      if (typeof output.content === 'string') {
-        mutableAsset.setCode(output.content);
-      } else if (output.content instanceof Buffer) {
-        mutableAsset.setBuffer(output.content);
-      } else {
-        mutableAsset.setStream(output.content);
+      if (ast) {
+        // $FlowFixMe "Cannot call `transformer.generate` because  undefined [1] is not a function." 🤷‍♀️
+        const output = await transformer.generate({
+          asset: mutableAsset,
+          ast,
+          ...defaultOptions
+        });
+        if (typeof output.content === 'string') {
+          mutableAsset.setCode(output.content);
+        } else if (output.content instanceof Buffer) {
+          mutableAsset.setBuffer(output.content);
+        } else {
+          mutableAsset.setStream(output.content);
+        }
       }
     }
     (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3463+fb58d0760",
+  "version": "2.12.1-canary.3465+963983d20",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,20 +20,20 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/cache": "2.12.1-canary.3463+fb58d0760",
-    "@atlaspack/diagnostic": "2.12.1-canary.3463+fb58d0760",
-    "@atlaspack/events": "2.12.1-canary.3463+fb58d0760",
-    "@atlaspack/feature-flags": "2.12.1-canary.3463+fb58d0760",
-    "@atlaspack/fs": "2.12.1-canary.3463+fb58d0760",
-    "@atlaspack/graph": "3.2.1-canary.3463+fb58d0760",
-    "@atlaspack/logger": "2.12.1-canary.3463+fb58d0760",
-    "@atlaspack/package-manager": "2.12.1-canary.3463+fb58d0760",
-    "@atlaspack/plugin": "2.12.1-canary.3463+fb58d0760",
-    "@atlaspack/profiler": "2.12.1-canary.3463+fb58d0760",
-    "@atlaspack/rust": "2.12.1-canary.3463+fb58d0760",
-    "@atlaspack/types": "2.12.1-canary.3463+fb58d0760",
-    "@atlaspack/utils": "2.12.1-canary.3463+fb58d0760",
-    "@atlaspack/workers": "2.12.1-canary.3463+fb58d0760",
+    "@atlaspack/cache": "2.12.1-canary.3465+963983d20",
+    "@atlaspack/diagnostic": "2.12.1-canary.3465+963983d20",
+    "@atlaspack/events": "2.12.1-canary.3465+963983d20",
+    "@atlaspack/feature-flags": "2.12.1-canary.3465+963983d20",
+    "@atlaspack/fs": "2.12.1-canary.3465+963983d20",
+    "@atlaspack/graph": "3.2.1-canary.3465+963983d20",
+    "@atlaspack/logger": "2.12.1-canary.3465+963983d20",
+    "@atlaspack/package-manager": "2.12.1-canary.3465+963983d20",
+    "@atlaspack/plugin": "2.12.1-canary.3465+963983d20",
+    "@atlaspack/profiler": "2.12.1-canary.3465+963983d20",
+    "@atlaspack/rust": "2.12.1-canary.3465+963983d20",
+    "@atlaspack/types": "2.12.1-canary.3465+963983d20",
+    "@atlaspack/utils": "2.12.1-canary.3465+963983d20",
+    "@atlaspack/workers": "2.12.1-canary.3465+963983d20",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -64,5 +64,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "fb58d07602ff89f132a7c5c985fce2a47e3ebe84"
+  "gitHead": "963983d206eac681e7a2bc8cd08043e42d0440a8"
 }

package/src/atlaspack-v3/worker/compat/mutable-asset.js

@@ -43,6 +43,7 @@ export class MutableAsset implements IMutableAsset {
   #inner: InnerAsset;
   #ast: ?AST;
   #contents: Buffer;
+  #astDirty: boolean;
 
   get astGenerator(): ?ASTGenerator {
     throw new Error('get MutableAsset.astGenerator');
@@ -74,6 +75,7 @@ export class MutableAsset implements IMutableAsset {
     this.#contents = Buffer.from(asset.code);
     this.fs = fs;
     this.env = env;
+    this.#astDirty = false;
   }
 
   // eslint-disable-next-line require-await
@@ -82,11 +84,12 @@ export class MutableAsset implements IMutableAsset {
   }
 
   setAST(ast: AST): void {
+    this.#astDirty = true;
     this.#ast = ast;
   }
 
   isASTDirty(): boolean {
-    throw new Error('MutableAsset.isASTDirty()');
+    return this.#astDirty;
   }
 
   // eslint-disable-next-line require-await
@@ -128,7 +131,8 @@ export class MutableAsset implements IMutableAsset {
   }
 
   getMap(): Promise<?SourceMap> {
-    throw new Error('MutableAsset.getMap');
+    // TODO: Provide source maps once they exist
+    return Promise.resolve(null);
   }
 
   // eslint-disable-next-line no-unused-vars
@@ -161,24 +165,24 @@ export class MutableAsset implements IMutableAsset {
 
   // eslint-disable-next-line no-unused-vars
   invalidateOnFileChange(invalidation: FilePath): void {
-    throw new Error('MutableAsset.invalidateOnFileChange()');
+    // TODO: Forward invalidations to Rust
   }
 
   // eslint-disable-next-line no-unused-vars
   invalidateOnFileCreate(invalidation: FileCreateInvalidation): void {
-    throw new Error('MutableAsset.invalidateOnFileCreate()');
+    // TODO: Forward invalidations to Rust
   }
 
   // eslint-disable-next-line no-unused-vars
   invalidateOnEnvChange(invalidation: string): void {
-    throw new Error('MutableAsset.invalidateOnEnvChange()');
+    // TODO: Forward invalidations to Rust
   }
 
   invalidateOnStartup(): void {
-    throw new Error('MutableAsset.invalidateOnStartup()');
+    // TODO: Forward invalidations to Rust
   }
 
   invalidateOnBuild(): void {
-    throw new Error('MutableAsset.invalidateOnBuild()');
+    // TODO: Forward invalidations to Rust
   }
 }

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

@@ -76,13 +76,7 @@ export class AtlaspackWorker {
     [RunResolverResolveOptions],
     Promise<RunResolverResolveResult>,
   > = jsCallable(
-    async ({
-      key,
-      dependency: napiDependency,
-      specifier,
-      pipeline,
-      projectRoot,
-    }) => {
+    async ({key, dependency: napiDependency, specifier, pipeline, options}) => {
       const state = this.#resolvers.get(key);
       if (!state) {
         throw new Error(`Resolver not found: ${key}`);
@@ -90,7 +84,7 @@ export class AtlaspackWorker {
 
       let packageManager = state.packageManager;
       if (!packageManager) {
-        packageManager = new NodePackageManager(this.#fs, projectRoot);
+        packageManager = new NodePackageManager(this.#fs, options.projectRoot);
         state.packageManager = packageManager;
       }
 
@@ -101,9 +95,9 @@ export class AtlaspackWorker {
         logger: new PluginLogger(),
         tracer: new PluginTracer(),
         options: new PluginOptions({
+          ...options,
           packageManager,
           shouldAutoInstall: false,
-          projectRoot,
           inputFS: this.#fs,
           outputFS: this.#fs,
         }),
@@ -155,71 +149,68 @@ export class AtlaspackWorker {
   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,
-      });
-
-      if (transformer.parse) {
-        const ast = await transformer.parse({
-          asset: mutableAsset,
-          config,
-          get resolve() {
-            throw new Error('Transformer.parse.resolve()');
-          },
-          ...defaultOptions,
-        });
-        if (ast) {
-          mutableAsset.setAST(ast);
-        }
-      }
-
-      const result = await state.transformer.transform({
+  > = jsCallable(async ({key, env: napiEnv, options, 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, options.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({
+        ...options,
+        packageManager,
+        shouldAutoInstall: false,
+        inputFS: this.#fs,
+        outputFS: this.#fs,
+      }),
+    };
+
+    const config = await transformer.loadConfig?.({
+      config: new PluginConfig({
+        env,
+        isSource: true,
+        searchPath: '',
+      }),
+      ...defaultOptions,
+    });
+
+    if (transformer.parse) {
+      const ast = await transformer.parse({
         asset: mutableAsset,
         config,
         get resolve() {
-          throw new Error('Transformer.transform.resolve()');
+          throw new Error('Transformer.parse.resolve()');
         },
         ...defaultOptions,
       });
-
-      if (transformer.generate) {
-        const ast = await mutableAsset.getAST();
-        if (!ast) {
-          throw new Error('Transformer.generate.ast');
-        }
+      if (ast) {
+        mutableAsset.setAST(ast);
+      }
+    }
+
+    const result = await state.transformer.transform({
+      asset: mutableAsset,
+      config,
+      get resolve() {
+        throw new Error('Transformer.transform.resolve()');
+      },
+      ...defaultOptions,
+    });
+
+    if (transformer.generate) {
+      const ast = await mutableAsset.getAST();
+      if (ast) {
         // $FlowFixMe "Cannot call `transformer.generate` because  undefined [1] is not a function." 🤷‍♀️
         const output = await transformer.generate({
           asset: mutableAsset,
@@ -235,38 +226,38 @@ export class AtlaspackWorker {
           mutableAsset.setStream(output.content);
         }
       }
-
-      assert(
-        result.length === 1,
-        '[V3] Unimplemented: Multiple asset return from Node transformer',
-      );
-
-      assert(
-        result[0] === mutableAsset,
-        '[V3] Unimplemented: New asset returned from Node transformer',
-      );
-
-      return {
-        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,
-        },
-      };
-    },
-  );
+    }
+
+    assert(
+      result.length === 1,
+      '[V3] Unimplemented: Multiple asset return from Node transformer',
+    );
+
+    assert(
+      result[0] === mutableAsset,
+      '[V3] Unimplemented: New asset returned from Node transformer',
+    );
+
+    return {
+      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,
+      },
+    };
+  });
 }
 
 napi.registerWorker(workerData.tx_worker, new AtlaspackWorker());
@@ -288,12 +279,17 @@ type LoadPluginOptions = {|
   resolveFrom: string,
 |};
 
+type RpcPluginOptions = {|
+  projectRoot: string,
+  mode: string,
+|};
+
 type RunResolverResolveOptions = {|
   key: string,
   dependency: napi.Dependency,
   specifier: FilePath,
   pipeline: ?string,
-  projectRoot: string,
+  options: RpcPluginOptions,
 |};
 
 type RunResolverResolveResult = {|
@@ -317,7 +313,7 @@ type RunResolverResolveResult = {|
 type RunTransformerTransformOptions = {|
   key: string,
   env: napi.Environment,
-  projectRoot: string,
+  options: RpcPluginOptions,
   asset: napi.Asset,
 |};