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

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

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginLogger = void 0;
+class PluginLogger {
+  verbose(diagnostic) {
+    // eslint-disable-next-line no-console
+    console.log(diagnostic);
+  }
+  info(diagnostic) {
+    // eslint-disable-next-line no-console
+    console.info(diagnostic);
+  }
+  log(diagnostic) {
+    // eslint-disable-next-line no-console
+    console.log(diagnostic);
+  }
+  warn(diagnostic) {
+    // eslint-disable-next-line no-console
+    console.warn(diagnostic);
+  }
+  error(input) {
+    // eslint-disable-next-line no-console
+    console.error(input);
+  }
+}
+exports.PluginLogger = PluginLogger;

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

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginOptions = void 0;
+class PluginOptions {
+  #options;
+  get env() {
+    if (!('env' in this.#options)) {
+      return process.env;
+      // throw new Error('PluginOptions.env');
+    }
+
+    return this.#options.env;
+  }
+  get projectRoot() {
+    if (!('projectRoot' in this.#options)) {
+      throw new Error('PluginOptions.projectRoot');
+    }
+    return this.#options.projectRoot;
+  }
+  get packageManager() {
+    if (!('packageManager' in this.#options)) {
+      throw new Error('PluginOptions.packageManager');
+    }
+    return this.#options.packageManager;
+  }
+  get mode() {
+    if (!('mode' in this.#options)) {
+      throw new Error('PluginOptions.mode');
+    }
+    return this.#options.mode;
+  }
+  get parcelVersion() {
+    if (!('parcelVersion' in this.#options)) {
+      return 'UNKNOWN VERSION';
+      // throw new Error('PluginOptions.parcelVersion');
+    }
+
+    return this.#options.parcelVersion;
+  }
+  get hmrOptions() {
+    if (!('hmrOptions' in this.#options)) {
+      throw new Error('PluginOptions.hmrOptions');
+    }
+    return this.#options.hmrOptions;
+  }
+  get serveOptions() {
+    if (!('serveOptions' in this.#options)) {
+      throw new Error('PluginOptions.serveOptions');
+    }
+    return this.#options.serveOptions;
+  }
+  get shouldBuildLazily() {
+    if (!('shouldBuildLazily' in this.#options)) {
+      throw new Error('PluginOptions.shouldBuildLazily');
+    }
+    return this.#options.shouldBuildLazily;
+  }
+  get shouldAutoInstall() {
+    if (!('shouldAutoInstall' in this.#options)) {
+      throw new Error('PluginOptions.shouldAutoInstall');
+    }
+    return this.#options.shouldAutoInstall;
+  }
+  get logLevel() {
+    if (!('logLevel' in this.#options)) {
+      throw new Error('PluginOptions.logLevel');
+    }
+    return this.#options.logLevel;
+  }
+  get cacheDir() {
+    if (!('cacheDir' in this.#options)) {
+      throw new Error('PluginOptions.cacheDir');
+    }
+    return this.#options.cacheDir;
+  }
+  get inputFS() {
+    if (!('inputFS' in this.#options)) {
+      throw new Error('PluginOptions.inputFS');
+    }
+    return this.#options.inputFS;
+  }
+  get outputFS() {
+    if (!('outputFS' in this.#options)) {
+      throw new Error('PluginOptions.outputFS');
+    }
+    return this.#options.outputFS;
+  }
+  get instanceId() {
+    if (!('instanceId' in this.#options)) {
+      throw new Error('PluginOptions.instanceId');
+    }
+    return this.#options.instanceId;
+  }
+  get detailedReport() {
+    if (!('detailedReport' in this.#options)) {
+      throw new Error('PluginOptions.detailedReport');
+    }
+    return this.#options.detailedReport;
+  }
+  get featureFlags() {
+    if (!('featureFlags' in this.#options)) {
+      throw new Error('PluginOptions.featureFlags');
+    }
+    return this.#options.featureFlags;
+  }
+  constructor(options) {
+    this.#options = options;
+  }
+}
+exports.PluginOptions = PluginOptions;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginTracer = void 0;
+class PluginTracer {
+  createMeasurement() {
+    throw new Error('PluginTracer.createMeasurement');
+  }
+}
+exports.PluginTracer = PluginTracer;

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Target = void 0;
+class Target {
+  constructor(inner, env) {
+    this.distDir = inner.distDir;
+    this.distEntry = inner.distEntry;
+    this.name = inner.name;
+    this.publicUrl = inner.publicUrl;
+    this.loc = inner.loc;
+    this.env = env;
+  }
+}
+exports.Target = Target;

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

@@ -48,16 +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;
+  #transformers;
   #fs;
   constructor() {
     this.#resolvers = new Map();
+    this.#transformers = new Map();
     this.#fs = new (_fs().NodeFS)();
   }
   loadPlugin = (0, _jsCallable.jsCallable)(async ({
@@ -83,11 +84,16 @@ class AtlaspackWorker {
           resolver: instance
         });
         break;
+      case 'transformer':
+        this.#transformers.set(specifier, {
+          transformer: instance
+        });
+        break;
     }
   });
   runResolverResolve = (0, _jsCallable.jsCallable)(async ({
     key,
-    dependency,
+    dependency: napiDependency,
     specifier,
     pipeline,
     projectRoot
@@ -101,80 +107,27 @@ class AtlaspackWorker {
       packageManager = new (_packageManager().NodePackageManager)(this.#fs, projectRoot);
       state.packageManager = packageManager;
     }
+    const env = new _compat.Environment(napiDependency.env);
+    const dependency = new _compat.Dependency(napiDependency, env);
     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',
+      logger: new _compat.PluginLogger(),
+      tracer: new _compat.PluginTracer(),
+      options: new _compat.PluginOptions({
         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');
-        }
-      }
+        outputFS: this.#fs
+      })
     };
     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: {
+        config: new _compat.PluginConfig({
+          env,
           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');
-          }
-        },
+          searchPath: ''
+        }),
         ...defaultOptions
       }));
     }
@@ -203,74 +156,109 @@ class AtlaspackWorker {
         code: result.code || undefined,
         meta: result.meta || undefined,
         pipeline: result.pipeline || undefined,
-        priority: result.priority && PriorityMap[result.priority],
+        priority: _compat.dependencyPriorityMap.intoNullable(result.priority),
         query: result.query && result.query.toString()
       }
     };
   });
-  ping() {
-    // console.log('Hi');
-  }
-  async runTransformer({
-    resolveFrom,
-    specifier,
-    options,
-    asset
-  }) {
-    const customRequire = _module().createRequire(resolveFrom);
-    const resolvedPath = customRequire.resolve(specifier);
-    // $FlowFixMe
-    const transformerModule = await import(resolvedPath);
-    const transformer = transformerModule.default.default[CONFIG];
-    let assetCompat = new _compat.AssetCompat(asset, options);
-    try {
-      if (transformer.parse) {
-        // $FlowFixMe
-        const ast = await transformer.parse({
-          asset: assetCompat
-        }); // missing "config"
-        // $FlowFixMe
-        assetCompat.setAST(ast);
+  runTransformerTransform = (0, _jsCallable.jsCallable)(async ({
+    key,
+    env: napiEnv,
+    projectRoot,
+    asset: innerAsset
+  }) => {
+    var _transformer$loadConf;
+    const state = this.#transformers.get(key);
+    if (!state) {
+      throw new Error(`Transformer not found: ${key}`);
+    }
+    let packageManager = state.packageManager;
+    if (!packageManager) {
+      packageManager = new (_packageManager().NodePackageManager)(this.#fs, projectRoot);
+      state.packageManager = packageManager;
+    }
+    const transformer = state.transformer;
+    const env = new _compat.Environment(napiEnv);
+    const mutableAsset = new _compat.MutableAsset(innerAsset, this.#fs, env);
+    const defaultOptions = {
+      logger: new _compat.PluginLogger(),
+      tracer: new _compat.PluginTracer(),
+      options: new _compat.PluginOptions({
+        packageManager,
+        shouldAutoInstall: false,
+        projectRoot,
+        inputFS: this.#fs,
+        outputFS: this.#fs
+      })
+    };
+    const config = await ((_transformer$loadConf = transformer.loadConfig) === null || _transformer$loadConf === void 0 ? void 0 : _transformer$loadConf.call(transformer, {
+      config: new _compat.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);
       }
-
-      // $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) {
+      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 (transformer.generate) {
-        // $FlowFixMe
-        let output = await transformer.generate({
-          // $FlowFixMe
-          asset: assetCompat,
-          // $FlowFixMe
-          ast: assetCompat.getAST()
-        });
-        // $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);
       }
-      (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;
     }
-  }
+    (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
+    (0, _assert().default)(result[0] === mutableAsset, '[V3] Unimplemented: New asset returned from Node transformer');
+    return {
+      asset: {
+        id: mutableAsset.id,
+        bundleBehavior: _compat.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
+      }
+    };
+  });
 }
 exports.AtlaspackWorker = AtlaspackWorker;
-napi().registerWorker(_worker_threads().workerData.tx_worker, new AtlaspackWorker());
-const PriorityMap = {
-  sync: 0,
-  parallel: 1,
-  lazy: 2,
-  conditional: 3
-};
+napi().registerWorker(_worker_threads().workerData.tx_worker, new AtlaspackWorker());

package/lib/index.js

@@ -4,12 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
-  registerSerializableClass: true,
-  unregisterSerializableClass: true,
-  prepareForSerialization: true,
-  restoreDeserializedObject: true,
-  serialize: true,
-  deserialize: true,
   Atlaspack: true,
   Parcel: true,
   BuildError: true,
@@ -59,43 +53,6 @@ Object.defineProperty(exports, "default", {
     return _Atlaspack.default;
   }
 });
-Object.defineProperty(exports, "deserialize", {
-  enumerable: true,
-  get: function () {
-    return _serializer.deserialize;
-  }
-});
-Object.defineProperty(exports, "prepareForSerialization", {
-  enumerable: true,
-  get: function () {
-    return _serializer.prepareForSerialization;
-  }
-});
-Object.defineProperty(exports, "registerSerializableClass", {
-  enumerable: true,
-  get: function () {
-    return _serializer.registerSerializableClass;
-  }
-});
-Object.defineProperty(exports, "restoreDeserializedObject", {
-  enumerable: true,
-  get: function () {
-    return _serializer.restoreDeserializedObject;
-  }
-});
-Object.defineProperty(exports, "serialize", {
-  enumerable: true,
-  get: function () {
-    return _serializer.serialize;
-  }
-});
-Object.defineProperty(exports, "unregisterSerializableClass", {
-  enumerable: true,
-  get: function () {
-    return _serializer.unregisterSerializableClass;
-  }
-});
-var _serializer = require("./serializer");
 var _Atlaspack = _interopRequireWildcard(require("./Atlaspack"));
 var _atlaspackV = require("./atlaspack-v3");
 Object.keys(_atlaspackV).forEach(function (key) {

package/lib/projectPath.js

@@ -27,14 +27,22 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * A path that's relative to the project root.
  */
 function toProjectPath_(projectRoot, p) {
+  // 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().default.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 = (0, _utils().relativePath)(projectRoot, p, false);
   if (relative.startsWith('..')) {
     return process.platform === 'win32' ? (0, _utils().normalizeSeparators)(p) : p;

package/lib/registerCoreWithSerializer.js

@@ -4,6 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.registerCoreWithSerializer = registerCoreWithSerializer;
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
 function _graph() {
   const data = require("@atlaspack/graph");
   _graph = function () {
@@ -11,13 +18,12 @@ function _graph() {
   };
   return data;
 }
-var _serializer = require("./serializer");
+var _package = _interopRequireDefault(require("../package.json"));
+var _AtlaspackConfig = _interopRequireDefault(require("./AtlaspackConfig"));
 var _AssetGraph = _interopRequireDefault(require("./AssetGraph"));
 var _BundleGraph = _interopRequireDefault(require("./BundleGraph"));
-var _AtlaspackConfig = _interopRequireDefault(require("./AtlaspackConfig"));
-var _RequestTracker = require("./RequestTracker");
 var _Config = _interopRequireDefault(require("./public/Config"));
-var _package = _interopRequireDefault(require("../package.json"));
+var _RequestTracker = require("./RequestTracker");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 let coreRegistered;
 function registerCoreWithSerializer() {
@@ -39,7 +45,7 @@ function registerCoreWithSerializer() {
     RequestGraph: _RequestTracker.RequestGraph
     // $FlowFixMe[unclear-type]
   })) {
-    (0, _serializer.registerSerializableClass)(packageVersion + ':' + name, ctor);
+    (0, _buildCache().registerSerializableClass)(packageVersion + ':' + name, ctor);
   }
   coreRegistered = true;
 }

package/lib/requests/AtlaspackConfigRequest.js

@@ -56,7 +56,13 @@ function _assert() {
 var _AtlaspackConfig = _interopRequireDefault(require("../AtlaspackConfig.schema"));
 var _utils2 = require("../utils");
 var _AtlaspackConfig2 = _interopRequireDefault(require("../AtlaspackConfig"));
-var _buildCache = require("../buildCache");
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
 var _projectPath = require("../projectPath");
 var _RequestTracker = require("../RequestTracker");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -103,7 +109,7 @@ function createAtlaspackConfigRequest() {
     input: null
   };
 }
-const atlaspackConfigCache = (0, _buildCache.createBuildCache)();
+const atlaspackConfigCache = (0, _buildCache().createBuildCache)();
 function getCachedAtlaspackConfig(result, options) {
   let {
     config: processedConfig,

package/lib/requests/ConfigRequest.js

@@ -15,7 +15,13 @@ function _utils() {
   };
   return data;
 }
-var _serializer = require("../serializer.js");
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
 function _logger() {
   const data = require("@atlaspack/logger");
   _logger = function () {
@@ -50,7 +56,6 @@ function _profiler() {
 }
 var _RequestTracker = require("../RequestTracker");
 var _projectPath = require("../projectPath");
-var _buildCache = require("../buildCache");
 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 }; }
@@ -81,7 +86,7 @@ async function loadPluginConfig(loadedPlugin, config, options) {
     });
   }
 }
-const configKeyCache = (0, _buildCache.createBuildCache)();
+const configKeyCache = (0, _buildCache().createBuildCache)();
 async function getConfigKeyContentHash(filePath, configKey, options) {
   let cacheKey = `${(0, _projectPath.fromProjectPathRelative)(filePath)}:${configKey}`;
   let cachedValue = configKeyCache.get(cacheKey);
@@ -166,7 +171,7 @@ async function getConfigHash(config, pluginName, options) {
       })), options));
     } else if (config.result != null) {
       try {
-        hash.writeBuffer((0, _serializer.serializeRaw)(config.result));
+        hash.writeBuffer((0, _buildCache().serializeRaw)(config.result));
       } catch (err) {
         throw new (_diagnostic().default)({
           diagnostic: {