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

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

@@ -18,6 +18,20 @@ function napi() {
   };
   return data;
 }
+function _fs() {
+  const data = require("@atlaspack/fs");
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _packageManager() {
+  const data = require("@atlaspack/package-manager");
+  _packageManager = function () {
+    return data;
+  };
+  return data;
+}
 function _worker_threads() {
   const data = require("worker_threads");
   _worker_threads = function () {
@@ -34,14 +48,17 @@ function _module() {
 }
 var _compat = require("./compat");
 var _jsCallable = require("../jsCallable");
+var _Environment = _interopRequireDefault(require("../../public/Environment"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const CONFIG = Symbol.for('parcel-plugin-config');
 class AtlaspackWorker {
   #resolvers;
+  #fs;
   constructor() {
     this.#resolvers = new Map();
+    this.#fs = new (_fs().NodeFS)();
   }
   loadPlugin = (0, _jsCallable.jsCallable)(async ({
     kind,
@@ -55,44 +72,118 @@ class AtlaspackWorker {
     let instance = undefined;
     if (resolvedModule.default && resolvedModule.default[CONFIG]) {
       instance = resolvedModule.default[CONFIG];
-    } else if (resolvedModule.default && resolvedModule.default.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, instance);
+        this.#resolvers.set(specifier, {
+          resolver: instance
+        });
         break;
     }
   });
   runResolverResolve = (0, _jsCallable.jsCallable)(async ({
     key,
     dependency,
-    specifier
+    specifier,
+    pipeline,
+    projectRoot
   }) => {
-    const resolver = this.#resolvers.get(key);
-    if (!resolver) {
+    const state = this.#resolvers.get(key);
+    if (!state) {
       throw new Error(`Resolver not found: ${key}`);
     }
-    const result = await resolver.resolve({
-      specifier,
-      dependency,
-      get options() {
-        throw new Error('TODO: Resolver.resolve.options');
-      },
+    let packageManager = state.packageManager;
+    if (!packageManager) {
+      packageManager = new (_packageManager().NodePackageManager)(this.#fs, projectRoot);
+      state.packageManager = packageManager;
+    }
+    const defaultOptions = {
       get logger() {
-        throw new Error('TODO: Resolver.resolve.logger');
-      },
-      get tracer() {
-        throw new Error('TODO: Resolver.resolve.tracer');
+        // $FlowFixMe
+        return globalThis.console;
       },
-      get pipeline() {
-        throw new Error('TODO: Resolver.resolve.pipeline');
+      tracer: {
+        enabled: false,
+        createMeasurement: () => null
       },
-      get config() {
-        throw new Error('TODO: Resolver.resolve.config');
+      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)) {
+      var _state$resolver$loadC, _state$resolver;
+      state.config = await ((_state$resolver$loadC = (_state$resolver = state.resolver).loadConfig) === null || _state$resolver$loadC === void 0 ? void 0 : _state$resolver$loadC.call(_state$resolver, {
+        config: {
+          isSource: true,
+          searchPath: '',
+          // $FlowFixMe This isn't correct to flow but is enough to satisfy the runtime checks
+          env: new _Environment.default(dependency.env, {
+            projectRoot,
+            hmrOptions: undefined
+          }),
+          invalidateOnFileChange() {},
+          invalidateOnFileCreate() {},
+          invalidateOnEnvChange() {},
+          invalidateOnStartup() {},
+          invalidateOnBuild() {},
+          addDevDependency() {},
+          setCacheKey() {},
+          getConfig() {
+            throw new Error('Resolver.loadConfig.config.getConfig');
+          },
+          getConfigFrom() {
+            throw new Error('Resolver.loadConfig.config.getConfigFrom');
+          },
+          getPackage() {
+            throw new Error('Resolver.loadConfig.config.getPackage');
+          }
+        },
+        ...defaultOptions
+      }));
+    }
+    const result = await state.resolver.resolve({
+      specifier,
+      dependency,
+      pipeline,
+      config: state.config,
+      ...defaultOptions
     });
     if (!result) {
       return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-dev.3443+d1170cfc7",
+  "version": "2.12.1-dev.3450+58845ef87",
   "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-dev.3443+d1170cfc7",
-    "@atlaspack/diagnostic": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/events": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/feature-flags": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/fs": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/graph": "3.2.1-dev.3443+d1170cfc7",
-    "@atlaspack/logger": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/package-manager": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/plugin": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/profiler": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/rust": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/types": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/utils": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/workers": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/cache": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/diagnostic": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/events": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/feature-flags": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/fs": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/graph": "3.2.1-dev.3450+58845ef87",
+    "@atlaspack/logger": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/package-manager": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/plugin": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/profiler": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/rust": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/types": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/utils": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/workers": "2.12.1-dev.3450+58845ef87",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -57,5 +57,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "d1170cfc79beb290b2a066f472f68f71f7d7cb23"
+  "gitHead": "58845ef87446fcedb7d7d8876440c64184645cbb"
 }

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

@@ -1,12 +1,17 @@
 // @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 * as module from 'module';
@@ -15,14 +20,17 @@ 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, Resolver<*>>;
+  #resolvers: Map<string, ResolverState<any>>;
+  #fs: FileSystem;
 
   constructor() {
     this.#resolvers = new Map();
+    this.#fs = new NodeFS();
   }
 
   loadPlugin: JsCallable<[LoadPluginOptions], Promise<void>> = jsCallable(
@@ -37,6 +45,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 +57,7 @@ export class AtlaspackWorker {
 
       switch (kind) {
         case 'resolver':
-          this.#resolvers.set(specifier, instance);
+          this.#resolvers.set(specifier, {resolver: instance});
           break;
       }
     },
@@ -57,54 +66,128 @@ 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}`);
-    }
+  > = 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'},
+        };
+      }
 
-    const result = await resolver.resolve({
-      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) {
       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: result.priority && PriorityMap[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');
@@ -183,6 +266,12 @@ export class AtlaspackWorker {
 
 napi.registerWorker(workerData.tx_worker, new AtlaspackWorker());
 
+type ResolverState<T> = {|
+  resolver: Resolver<T>,
+  config?: T,
+  packageManager?: NodePackageManager,
+|};
+
 type LoadPluginOptions = {|
   kind: 'resolver',
   specifier: string,
@@ -193,6 +282,8 @@ type RunResolverResolveOptions = {|
   key: string,
   dependency: Dependency,
   specifier: FilePath,
+  pipeline: ?string,
+  projectRoot: string,
 |};
 
 type RunResolverResolveResult = {|

package/test/requests/WriteBundleRequest.test.js

@@ -66,7 +66,7 @@ async function javascriptReplaceHashReferences(
   return output;
 }
 
-describe.only('replaceStream', () => {
+describe('replaceStream', () => {
   const hashReferences = new Map([
     ['HASH_REF_1234567890123456', 'HASH_REF_replacedwithstri'],
   ]);