@atlaspack/core 2.12.1-canary.3427 → 2.12.1-canary.3429

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

@@ -33,11 +33,82 @@ function _module() {
   return data;
 }
 var _compat = require("./compat");
+var _jsCallable = require("../jsCallable");
 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;
+  constructor() {
+    this.#resolvers = new Map();
+  }
+  loadPlugin = (0, _jsCallable.jsCallable)(async ({
+    kind,
+    specifier,
+    resolveFrom
+  }) => {
+    let customRequire = _module().createRequire(resolveFrom);
+    let resolvedPath = customRequire.resolve(specifier);
+    // $FlowFixMe
+    let resolvedModule = await import(resolvedPath);
+    switch (kind) {
+      case 'resolver':
+        this.#resolvers.set(specifier, resolvedModule.default[CONFIG]);
+        break;
+    }
+  });
+  runResolverResolve = (0, _jsCallable.jsCallable)(async ({
+    key,
+    dependency,
+    specifier
+  }) => {
+    const resolver = this.#resolvers.get(key);
+    if (!resolver) {
+      throw new Error('Resolver not found');
+    }
+    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'
+        }
+      };
+    }
+    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');
   }
@@ -97,4 +168,9 @@ class AtlaspackWorker {
   }
 }
 exports.AtlaspackWorker = AtlaspackWorker;
-napi().registerWorker(_worker_threads().workerData.tx_worker, new AtlaspackWorker());
+napi().registerWorker(_worker_threads().workerData.tx_worker, new AtlaspackWorker());
+const PriorityMap = {
+  sync: 0,
+  parallel: 1,
+  lazy: 2
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3427+a86b8559a",
+  "version": "2.12.1-canary.3429+8cd6d09ce",
   "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.3427+a86b8559a",
-    "@atlaspack/diagnostic": "2.12.1-canary.3427+a86b8559a",
-    "@atlaspack/events": "2.12.1-canary.3427+a86b8559a",
-    "@atlaspack/feature-flags": "2.12.1-canary.3427+a86b8559a",
-    "@atlaspack/fs": "2.12.1-canary.3427+a86b8559a",
-    "@atlaspack/graph": "3.2.1-canary.3427+a86b8559a",
-    "@atlaspack/logger": "2.12.1-canary.3427+a86b8559a",
-    "@atlaspack/package-manager": "2.12.1-canary.3427+a86b8559a",
-    "@atlaspack/plugin": "2.12.1-canary.3427+a86b8559a",
-    "@atlaspack/profiler": "2.12.1-canary.3427+a86b8559a",
-    "@atlaspack/rust": "2.12.1-canary.3427+a86b8559a",
-    "@atlaspack/types": "2.12.1-canary.3427+a86b8559a",
-    "@atlaspack/utils": "2.12.1-canary.3427+a86b8559a",
-    "@atlaspack/workers": "2.12.1-canary.3427+a86b8559a",
+    "@atlaspack/cache": "2.12.1-canary.3429+8cd6d09ce",
+    "@atlaspack/diagnostic": "2.12.1-canary.3429+8cd6d09ce",
+    "@atlaspack/events": "2.12.1-canary.3429+8cd6d09ce",
+    "@atlaspack/feature-flags": "2.12.1-canary.3429+8cd6d09ce",
+    "@atlaspack/fs": "2.12.1-canary.3429+8cd6d09ce",
+    "@atlaspack/graph": "3.2.1-canary.3429+8cd6d09ce",
+    "@atlaspack/logger": "2.12.1-canary.3429+8cd6d09ce",
+    "@atlaspack/package-manager": "2.12.1-canary.3429+8cd6d09ce",
+    "@atlaspack/plugin": "2.12.1-canary.3429+8cd6d09ce",
+    "@atlaspack/profiler": "2.12.1-canary.3429+8cd6d09ce",
+    "@atlaspack/rust": "2.12.1-canary.3429+8cd6d09ce",
+    "@atlaspack/types": "2.12.1-canary.3429+8cd6d09ce",
+    "@atlaspack/utils": "2.12.1-canary.3429+8cd6d09ce",
+    "@atlaspack/workers": "2.12.1-canary.3429+8cd6d09ce",
     "@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": "a86b8559a2aefd7033eb14e71320308f7ece0122"
+  "gitHead": "8cd6d09ce1b68f1848c298ea900334b8d47c9fd9"
 }

package/src/atlaspack-v3/jsCallable.js

@@ -1,5 +1,9 @@
 // @flow strict-local
 
+export type JsCallable<Args: $ReadOnlyArray<mixed>, Return> = (
+  ...Args
+) => Return;
+
 export function jsCallable<Args: $ReadOnlyArray<mixed>, Return>(
   fn: (...Args) => Return,
 ): (...Args) => Return {

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

@@ -1,16 +1,97 @@
 // @flow
 import assert from 'assert';
 import * as napi from '@atlaspack/rust';
-import type {Transformer, PluginOptions} from '@atlaspack/types';
+import type {
+  Resolver,
+  Transformer,
+  PluginOptions,
+  Dependency,
+  FilePath,
+} from '@atlaspack/types';
 import {workerData} from 'worker_threads';
 import * as module from 'module';
 
 import {AssetCompat} from './compat';
 import type {InnerAsset} 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<*>>;
+
+  constructor() {
+    this.#resolvers = new Map();
+  }
+
+  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);
+
+      switch (kind) {
+        case 'resolver':
+          this.#resolvers.set(specifier, resolvedModule.default[CONFIG]);
+          break;
+      }
+    },
+  );
+
+  runResolverResolve: JsCallable<
+    [RunResolverResolveOptions],
+    Promise<RunResolverResolveResult>,
+  > = jsCallable(async ({key, dependency, specifier}) => {
+    const resolver = this.#resolvers.get(key);
+    if (!resolver) {
+      throw new Error('Resolver not found');
+    }
+
+    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'},
+      };
+    }
+
+    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');
   }
@@ -87,3 +168,39 @@ export class AtlaspackWorker {
 }
 
 napi.registerWorker(workerData.tx_worker, new AtlaspackWorker());
+
+type LoadPluginOptions = {|
+  kind: 'resolver',
+  specifier: string,
+  resolveFrom: string,
+|};
+
+type RunResolverResolveOptions = {|
+  key: string,
+  dependency: Dependency,
+  specifier: FilePath,
+|};
+
+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,
+};