@atlaspack/core 2.12.1-canary.3418 → 2.12.1-canary.3420

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

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AssetCompat = void 0;
+var _Environment = _interopRequireDefault(require("../../public/Environment"));
+var _types = require("../../types");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class AssetCompat {
+  // TODO: Type properly
+
+  constructor(_inner, options) {
+    this._inner = _inner;
+    // $FlowFixMe This isn't correct to flow but is enough to satisfy the runtime checks
+    this.env = new _Environment.default(_inner.env, options);
+    this._dependencies = [];
+  }
+  get id() {
+    return this._inner.id;
+  }
+  get filePath() {
+    return this._inner.filePath;
+  }
+  get type() {
+    return this._inner.type;
+  }
+  set type(value) {
+    this._inner.type = value;
+  }
+  get bundleBehavior() {
+    let bundleBehavior = this._inner.bundleBehavior;
+    return bundleBehavior == null ? null : _types.BundleBehaviorNames[bundleBehavior];
+  }
+  set bundleBehavior(bundleBehavior) {
+    this._inner.bundleBehavior = bundleBehavior ? _types.BundleBehavior[bundleBehavior] : null;
+  }
+  getCode() {
+    return Buffer.from(this._inner.code).toString();
+  }
+  setCode(code) {
+    this._inner.code = Array.from(new TextEncoder().encode(code));
+  }
+  getAST() {
+    return this._ast;
+  }
+  setAST(ast) {
+    this._ast = ast;
+  }
+  addDependency() {
+    throw new Error('[V3] Unimplemented: Asset.addDependency not yet implemented');
+  }
+  addURLDependency() {
+    throw new Error('[V3] Unimplemented: Asset.addURLDependency not yet implemented');
+  }
+}
+exports.AssetCompat = AssetCompat;

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

@@ -4,6 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AtlaspackWorker = void 0;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
 function napi() {
   const data = _interopRequireWildcard(require("@atlaspack/rust"));
   napi = function () {
@@ -25,22 +32,68 @@ function _module() {
   };
   return data;
 }
+var _compat = require("./compat");
 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 {
-  #transformers;
-  constructor() {
-    this.#transformers = new Map();
-  }
   ping() {
     // console.log('Hi');
   }
-  async transformerRegister(resolve_from, specifier) {
-    let customRequire = _module().createRequire(resolve_from);
+  async runTransformer({
+    resolveFrom,
+    specifier,
+    options,
+    asset
+  }) {
+    let customRequire = _module().createRequire(resolveFrom);
     let resolvedPath = customRequire.resolve(specifier);
     // $FlowFixMe
-    let transformer = await import(resolvedPath);
-    this.#transformers.set(`${resolve_from}:${specifier}`, transformer);
+    let transformerModule = await import(resolvedPath);
+    let transformer = transformerModule.default.default[CONFIG];
+    let assetCompat = new _compat.AssetCompat(asset, options);
+    try {
+      if (transformer.parse) {
+        // $FlowFixMe
+        let ast = await transformer.parse({
+          asset: assetCompat
+        });
+        // $FlowFixMe
+        assetCompat.setAST(ast);
+      }
+
+      // $FlowFixMe
+      let 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);
+      }
+      (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
+      (0, _assert().default)(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;
+    }
   }
 }
 exports.AtlaspackWorker = AtlaspackWorker;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3418+49a56fea2",
+  "version": "2.12.1-canary.3420+5b4f23756",
   "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.3418+49a56fea2",
-    "@atlaspack/diagnostic": "2.12.1-canary.3418+49a56fea2",
-    "@atlaspack/events": "2.12.1-canary.3418+49a56fea2",
-    "@atlaspack/feature-flags": "2.12.1-canary.3418+49a56fea2",
-    "@atlaspack/fs": "2.12.1-canary.3418+49a56fea2",
-    "@atlaspack/graph": "3.2.1-canary.3418+49a56fea2",
-    "@atlaspack/logger": "2.12.1-canary.3418+49a56fea2",
-    "@atlaspack/package-manager": "2.12.1-canary.3418+49a56fea2",
-    "@atlaspack/plugin": "2.12.1-canary.3418+49a56fea2",
-    "@atlaspack/profiler": "2.12.1-canary.3418+49a56fea2",
-    "@atlaspack/rust": "2.12.1-canary.3418+49a56fea2",
-    "@atlaspack/types": "2.12.1-canary.3418+49a56fea2",
-    "@atlaspack/utils": "2.12.1-canary.3418+49a56fea2",
-    "@atlaspack/workers": "2.12.1-canary.3418+49a56fea2",
+    "@atlaspack/cache": "2.12.1-canary.3420+5b4f23756",
+    "@atlaspack/diagnostic": "2.12.1-canary.3420+5b4f23756",
+    "@atlaspack/events": "2.12.1-canary.3420+5b4f23756",
+    "@atlaspack/feature-flags": "2.12.1-canary.3420+5b4f23756",
+    "@atlaspack/fs": "2.12.1-canary.3420+5b4f23756",
+    "@atlaspack/graph": "3.2.1-canary.3420+5b4f23756",
+    "@atlaspack/logger": "2.12.1-canary.3420+5b4f23756",
+    "@atlaspack/package-manager": "2.12.1-canary.3420+5b4f23756",
+    "@atlaspack/plugin": "2.12.1-canary.3420+5b4f23756",
+    "@atlaspack/profiler": "2.12.1-canary.3420+5b4f23756",
+    "@atlaspack/rust": "2.12.1-canary.3420+5b4f23756",
+    "@atlaspack/types": "2.12.1-canary.3420+5b4f23756",
+    "@atlaspack/utils": "2.12.1-canary.3420+5b4f23756",
+    "@atlaspack/workers": "2.12.1-canary.3420+5b4f23756",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -55,5 +55,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "49a56fea20468bd4cb26ecf69f9b3a200986a35b"
+  "gitHead": "5b4f237563b0c1b826807a4aa01d78e4d8bb15f4"
 }

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

@@ -0,0 +1,82 @@
+// @flow
+import type {PluginOptions, BundleBehavior, AST} from '@atlaspack/types';
+
+import Environment from '../../public/Environment';
+import {
+  BundleBehaviorNames,
+  BundleBehavior as BundleBehaviorMap,
+} from '../../types';
+
+export type InnerAsset = {|
+  id: string,
+  filePath: string,
+  code: Array<number>,
+  type: string,
+  bundleBehavior: number | null,
+  env: any,
+|};
+
+export class AssetCompat {
+  _inner: InnerAsset;
+  _ast: ?AST;
+  // TODO: Type properly
+  _dependencies: Array<any>;
+
+  constructor(_inner: InnerAsset, options: PluginOptions) {
+    this._inner = _inner;
+    // $FlowFixMe This isn't correct to flow but is enough to satisfy the runtime checks
+    this.env = new Environment(_inner.env, options);
+    this._dependencies = [];
+  }
+
+  get id(): string {
+    return this._inner.id;
+  }
+
+  get filePath(): string {
+    return this._inner.filePath;
+  }
+
+  get type(): string {
+    return this._inner.type;
+  }
+  set type(value: string) {
+    this._inner.type = value;
+  }
+
+  get bundleBehavior(): ?BundleBehavior {
+    let bundleBehavior = this._inner.bundleBehavior;
+    return bundleBehavior == null ? null : BundleBehaviorNames[bundleBehavior];
+  }
+  set bundleBehavior(bundleBehavior: ?BundleBehavior): void {
+    this._inner.bundleBehavior = bundleBehavior
+      ? BundleBehaviorMap[bundleBehavior]
+      : null;
+  }
+
+  getCode(): string {
+    return Buffer.from(this._inner.code).toString();
+  }
+  setCode(code: string) {
+    this._inner.code = Array.from(new TextEncoder().encode(code));
+  }
+
+  getAST(): ?AST {
+    return this._ast;
+  }
+  setAST(ast: AST) {
+    this._ast = ast;
+  }
+
+  addDependency(): string {
+    throw new Error(
+      '[V3] Unimplemented: Asset.addDependency not yet implemented',
+    );
+  }
+
+  addURLDependency(): string {
+    throw new Error(
+      '[V3] Unimplemented: Asset.addURLDependency not yet implemented',
+    );
+  }
+}

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

@@ -1,26 +1,87 @@
 // @flow
+import assert from 'assert';
 import * as napi from '@atlaspack/rust';
-import type {Transformer} from '@atlaspack/types';
+import type {Transformer, PluginOptions} from '@atlaspack/types';
 import {workerData} from 'worker_threads';
 import * as module from 'module';
 
-export class AtlaspackWorker {
-  #transformers: Map<string, Transformer<any>>;
+import {AssetCompat} from './compat';
+import type {InnerAsset} from './compat';
 
-  constructor() {
-    this.#transformers = new Map();
-  }
+const CONFIG = Symbol.for('parcel-plugin-config');
 
+export class AtlaspackWorker {
   ping() {
     // console.log('Hi');
   }
 
-  async transformerRegister(resolve_from: string, specifier: string) {
-    let customRequire = module.createRequire(resolve_from);
+  async runTransformer({
+    resolveFrom,
+    specifier,
+    options,
+    asset,
+  }: {|
+    resolveFrom: string,
+    specifier: string,
+    options: PluginOptions,
+    asset: InnerAsset,
+  |}): any {
+    let customRequire = module.createRequire(resolveFrom);
     let resolvedPath = customRequire.resolve(specifier);
     // $FlowFixMe
-    let transformer = await import(resolvedPath);
-    this.#transformers.set(`${resolve_from}:${specifier}`, transformer);
+    let transformerModule = await import(resolvedPath);
+    let transformer: Transformer<*> = transformerModule.default.default[CONFIG];
+
+    let assetCompat = new AssetCompat(asset, options);
+
+    try {
+      if (transformer.parse) {
+        // $FlowFixMe
+        let ast = await transformer.parse({asset: assetCompat});
+        // $FlowFixMe
+        assetCompat.setAST(ast);
+      }
+
+      // $FlowFixMe
+      let 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;
+    }
   }
 }