@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AtlaspackWorker = void 0;
+var _sideEffectDetector = require("./side-effect-detector");
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
   _assert = function () {
@@ -39,6 +40,13 @@ function _worker_threads() {
   };
   return data;
 }
+function _logger() {
+  const data = _interopRequireWildcard(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
 function _module() {
   const data = _interopRequireWildcard(require("module"));
   _module = function () {
@@ -48,36 +56,74 @@ function _module() {
 }
 var _jsCallable = require("../jsCallable");
 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 }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/* eslint-disable import/first */
+
+// Install side effect detection patches BEFORE importing any modules that use fs
+const sideEffectDetector = new _sideEffectDetector.SideEffectDetector();
+sideEffectDetector.install();
+
+// @ts-expect-error TS2305
+
 const CONFIG = Symbol.for('parcel-plugin-config');
 class AtlaspackWorker {
   #resolvers;
   #transformers;
   #fs;
+  #packageManager;
+  #options;
+  #sideEffectDetector;
   constructor() {
     this.#resolvers = new Map();
     this.#transformers = new Map();
     this.#fs = new (_fs().NodeFS)();
+    this.#packageManager = new (_packageManager().NodePackageManager)(this.#fs, '/');
+    this.#sideEffectDetector = sideEffectDetector; // Use the global detector that was installed before imports
+  }
+  clearState() {
+    this.#resolvers.clear();
+    this.#transformers.clear();
+    this.#options = undefined;
   }
   loadPlugin = (0, _jsCallable.jsCallable)(async ({
     kind,
     specifier,
-    resolveFrom
+    resolveFrom,
+    options
   }) => {
-    let customRequire = _module().createRequire(resolveFrom);
-    let resolvedPath = customRequire.resolve(specifier);
-    // $FlowFixMe
-    let resolvedModule = await import(resolvedPath);
+    // Use packageManager.require() instead of dynamic import() to support TypeScript plugins
+    let resolvedModule = await this.#packageManager.require(specifier, resolveFrom, {
+      shouldAutoInstall: false
+    });
     let instance = undefined;
-    if (resolvedModule.default && resolvedModule.default[CONFIG]) {
+    // Check for CommonJS export (module.exports = new Plugin(...))
+    if (resolvedModule[CONFIG]) {
+      instance = resolvedModule[CONFIG];
+    } else if (resolvedModule.default && resolvedModule.default[CONFIG]) {
+      // ESM default export
       instance = resolvedModule.default[CONFIG];
     } else if (resolvedModule.default && resolvedModule.default.default && resolvedModule.default.default[CONFIG]) {
+      // Double-wrapped default export
       instance = resolvedModule.default.default[CONFIG];
     } else {
       throw new Error(`Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`);
     }
+    if (this.#options == null) {
+      this.#options = {
+        ...options,
+        inputFS: this.#fs,
+        outputFS: this.#fs,
+        packageManager: this.#packageManager,
+        shouldAutoInstall: false
+      };
+    }
+
+    // Set feature flags in the worker process
+    let featureFlagsModule = await this.#packageManager.require('@atlaspack/feature-flags', __filename, {
+      shouldAutoInstall: false
+    });
+    featureFlagsModule.setFeatureFlags(options.featureFlags);
     switch (kind) {
       case 'resolver':
         this.#resolvers.set(specifier, {
@@ -85,55 +131,45 @@ class AtlaspackWorker {
         });
         break;
       case 'transformer':
-        this.#transformers.set(specifier, {
-          transformer: instance
-        });
-        break;
+        {
+          return this.initializeTransformer(instance, specifier);
+        }
     }
   });
   runResolverResolve = (0, _jsCallable.jsCallable)(async ({
     key,
     dependency: napiDependency,
     specifier,
-    pipeline,
-    pluginOptions
+    pipeline
   }) => {
     const state = this.#resolvers.get(key);
     if (!state) {
       throw new Error(`Resolver not found: ${key}`);
     }
-    let packageManager = state.packageManager;
-    if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, pluginOptions.projectRoot);
-      state.packageManager = packageManager;
-    }
     const env = new _compat.Environment(napiDependency.env);
     const dependency = new _compat.Dependency(napiDependency, env);
     const defaultOptions = {
-      logger: new _compat.PluginLogger(),
+      logger: new (_logger().PluginLogger)({
+        origin: key
+      }),
       tracer: new _compat.PluginTracer(),
-      options: new _compat.PluginOptions({
-        ...pluginOptions,
-        packageManager,
-        shouldAutoInstall: false,
-        inputFS: this.#fs,
-        outputFS: this.#fs
-      })
+      options: new _compat.PluginOptions(this.options)
     };
     if (!('config' in state)) {
       var _state$resolver$loadC, _state$resolver;
+      // @ts-expect-error TS2345
       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: new _compat.PluginConfig({
-          env,
+          env: napiDependency.env,
+          plugin: key,
           isSource: true,
-          searchPath: specifier,
-          projectRoot: pluginOptions.projectRoot,
-          fs: this.#fs,
-          packageManager
-        }),
+          searchPath: 'index'
+        }, this.options),
         ...defaultOptions
       }));
     }
+
+    // @ts-expect-error TS2345
     const result = await state.resolver.resolve({
       specifier,
       dependency,
@@ -157,14 +193,25 @@ class AtlaspackWorker {
         }
       };
     }
+    // A resolver may return a result without filePath to indicate it didn't
+    // resolve the dependency (equivalent to returning null). The JS-side
+    // PathRequest treats this as "try the next resolver".
+    if (!result.filePath) {
+      return {
+        invalidations: [],
+        resolution: {
+          type: 'unresolved'
+        }
+      };
+    }
     return {
       invalidations: [],
       resolution: {
         type: 'resolved',
-        filePath: result.filePath || '',
+        filePath: result.filePath,
         canDefer: result.canDefer || false,
-        sideEffects: result.sideEffects || false,
-        code: result.code || undefined,
+        sideEffects: result.sideEffects ?? true,
+        code: result.code ?? undefined,
         meta: result.meta || undefined,
         pipeline: result.pipeline || undefined,
         priority: _compat.dependencyPriorityMap.intoNullable(result.priority),
@@ -174,52 +221,60 @@ class AtlaspackWorker {
   });
   runTransformerTransform = (0, _jsCallable.jsCallable)(async ({
     key,
-    env: napiEnv,
-    options,
     asset: innerAsset
   }, contents, map) => {
-    var _transformer$loadConf;
-    const state = this.#transformers.get(key);
-    if (!state) {
+    const instance = this.#transformers.get(key);
+    if (!instance) {
       throw new Error(`Transformer not found: ${key}`);
     }
-    let packageManager = state.packageManager;
-    if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, options.projectRoot);
-      state.packageManager = packageManager;
-    }
-    const transformer = state.transformer;
+    let {
+      transformer,
+      config,
+      allowedEnv = new Set()
+    } = instance;
+    let cacheBailouts = [];
     const resolveFunc = (from, to) => {
       let customRequire = _module().createRequire(from);
       let resolvedPath = customRequire.resolve(to);
+      // Tranformer not cacheable due to use of the resolve function
+
+      cacheBailouts.push(`resolve(${from}, ${to})`);
       return Promise.resolve(resolvedPath);
     };
-    const env = new _compat.Environment(napiEnv);
-    const mutableAsset = new _compat.MutableAsset(innerAsset, contents, env, this.#fs, map, options.projectRoot);
+    const env = new _compat.Environment(innerAsset.env);
+    let mutableAsset = new _compat.MutableAsset(innerAsset,
+    // @ts-expect-error TS2345
+    contents, env, this.#fs, map, this.options.projectRoot);
+    const pluginOptions = new _compat.PluginOptions(this.options);
     const defaultOptions = {
-      logger: new _compat.PluginLogger(),
+      logger: new (_logger().PluginLogger)({
+        origin: key
+      }),
       tracer: new _compat.PluginTracer(),
-      options: new _compat.PluginOptions({
-        ...options,
-        packageManager,
-        shouldAutoInstall: false,
-        inputFS: this.#fs,
-        outputFS: this.#fs
-      })
+      options: pluginOptions
     };
-    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: innerAsset.filePath,
-        projectRoot: options.projectRoot,
-        fs: this.#fs,
-        packageManager
-      }),
-      ...defaultOptions
-    }));
+    if (transformer.loadConfig) {
+      if (config != null) {
+        throw new Error(`Transformer (${key}) should not implement 'setup' and 'loadConfig'`);
+      }
+      // @ts-expect-error TS2345
+      config = await transformer.loadConfig({
+        config: new _compat.PluginConfig({
+          plugin: key,
+          isSource: innerAsset.isSource,
+          searchPath: innerAsset.filePath,
+          env
+        }, this.options),
+        ...defaultOptions
+      });
+
+      // Transformer uses the deprecated loadConfig API, so mark as not
+      // cachable
+      cacheBailouts.push(`Transformer.loadConfig`);
+    }
     if (transformer.parse) {
       const ast = await transformer.parse({
+        // @ts-expect-error TS2322
         asset: mutableAsset,
         config,
         resolve: resolveFunc,
@@ -228,18 +283,37 @@ class AtlaspackWorker {
       if (ast) {
         mutableAsset.setAST(ast);
       }
+      cacheBailouts.push(`Transformer.parse`);
     }
-    const result = await state.transformer.transform({
+    const [result, sideEffects] = await this.#sideEffectDetector.monitorSideEffects(key, () => transformer.transform({
+      // @ts-expect-error TS2322
       asset: mutableAsset,
       config,
       resolve: resolveFunc,
       ...defaultOptions
-    });
+    }));
+    if (sideEffects.envUsage.didEnumerate) {
+      cacheBailouts.push(`Env access: enumeration of process.env`);
+    }
+    for (let variable of sideEffects.envUsage.vars) {
+      if (variable in allowedEnv) {
+        continue;
+      }
+      cacheBailouts.push(`Env access: ${variable}`);
+    }
+    for (let {
+      method,
+      path
+    } of sideEffects.fsUsage) {
+      cacheBailouts.push(`FS usage: ${method}(${path})`);
+    }
+    (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');
     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({
+          // @ts-expect-error TS2322
           asset: mutableAsset,
           ast,
           ...defaultOptions
@@ -249,6 +323,7 @@ class AtlaspackWorker {
         } else if (output.content instanceof Buffer) {
           mutableAsset.setBuffer(output.content);
         } else {
+          // @ts-expect-error TS2345
           mutableAsset.setStream(output.content);
         }
         if (output.map) {
@@ -256,8 +331,17 @@ class AtlaspackWorker {
         }
       }
     }
-    (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');
+    let assetBuffer = await mutableAsset.getBuffer();
+
+    // If the asset has no code, we set the buffer to null, which we can
+    // detect in Rust, to avoid passing back an empty buffer, which we can't.
+    if (assetBuffer.length === 0) {
+      assetBuffer = null;
+    }
+    if (pluginOptions.used) {
+      // Plugin options accessed, so not cachable
+      cacheBailouts.push(`Plugin options accessed`);
+    }
     return [{
       id: mutableAsset.id,
       bundleBehavior: _compat.bundleBehaviorMap.intoNullable(mutableAsset.bundleBehavior),
@@ -273,16 +357,84 @@ class AtlaspackWorker {
       symbols: mutableAsset.symbols.intoNapi(),
       type: mutableAsset.type,
       uniqueKey: mutableAsset.uniqueKey
-    }, await mutableAsset.getBuffer(),
+    }, assetBuffer,
     // Only send back the map if it has changed
     mutableAsset.isMapDirty ?
-    // $FlowFixMe A dirty map means this will be valid
-    JSON.stringify((await mutableAsset.getMap()).toVLQ()) : ''];
+    // @ts-expect-error TS2533
+    JSON.stringify((await mutableAsset.getMap()).toVLQ()) : '',
+    // Limit to first 10 bailouts
+    cacheBailouts.slice(0, 10)];
   });
+  get options() {
+    if (this.#options == null) {
+      throw new Error('Plugin options have not been initialized');
+    }
+    return this.#options;
+  }
+  async initializeTransformer(instance, specifier) {
+    let transformer = instance;
+    let setup, config, allowedEnv;
+    let packageManager = new (_packageManager().NodePackageManager)(this.#fs, this.options.projectRoot);
+    if (transformer.setup) {
+      var _setupResult$env;
+      let setupResult = await transformer.setup({
+        logger: new (_logger().PluginLogger)({
+          origin: specifier
+        }),
+        options: new _compat.PluginOptions({
+          ...this.options,
+          shouldAutoInstall: false,
+          inputFS: this.#fs,
+          outputFS: this.#fs,
+          packageManager
+        }),
+        config: new _compat.PluginConfig({
+          plugin: specifier,
+          searchPath: 'index',
+          // Consider project setup config as source
+          isSource: true
+        }, this.options)
+      });
+      config = setupResult === null || setupResult === void 0 ? void 0 : setupResult.config;
+      allowedEnv = Object.fromEntries((setupResult === null || setupResult === void 0 || (_setupResult$env = setupResult.env) === null || _setupResult$env === void 0 ? void 0 : _setupResult$env.map(env => [env, process.env[env]])) || []);
+
+      // Always add the following env vars to the cache key
+      allowedEnv['NODE_ENV'] = process.env['NODE_ENV'];
+      setup = {
+        conditions: setupResult === null || setupResult === void 0 ? void 0 : setupResult.conditions,
+        config,
+        env: allowedEnv,
+        disableCache: setupResult === null || setupResult === void 0 ? void 0 : setupResult.disableCache
+      };
+    }
+    this.#transformers.set(specifier, {
+      transformer,
+      config,
+      packageManager,
+      allowedEnv
+    });
+    return setup;
+  }
 }
 
-// Create napi worker and send it back to main thread
+// Forward all logger events from this worker thread to the main thread so
+// they are re-emitted into the main-thread logger and reach reporters.
 exports.AtlaspackWorker = AtlaspackWorker;
+_logger().default.onLog(event => {
+  _worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage({
+    type: 'logEvent',
+    event
+  });
+});
+
+// Create napi worker and send it back to main thread
 const worker = new AtlaspackWorker();
 const napiWorker = napi().newNodejsWorker(worker);
-_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage(napiWorker);
+_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage(napiWorker);
+_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.setMaxListeners(_worker_threads().parentPort.getMaxListeners() + 1);
+_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.addListener('message', message => {
+  if (message === 'clearState') {
+    worker.clearState();
+    _worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage('stateCleared');
+  }
+});

package/lib/constants.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.VALID = exports.STARTUP = exports.OPTION_CHANGE = exports.INITIAL_BUILD = exports.HASH_REF_REGEX = exports.HASH_REF_PREFIX = exports.HASH_REF_HASH_LEN = exports.FILE_UPDATE = exports.FILE_DELETE = exports.FILE_CREATE = exports.ERROR = exports.ENV_CHANGE = exports.ATLASPACK_VERSION = void 0;
 var _package = require("../package.json");
-// $FlowFixMe
 const ATLASPACK_VERSION = exports.ATLASPACK_VERSION = _package.version;
 const HASH_REF_PREFIX = exports.HASH_REF_PREFIX = 'HASH_REF_';
 const HASH_REF_HASH_LEN = exports.HASH_REF_HASH_LEN = 16;