@atlaspack/core 2.16.2-canary.37 → 2.16.2-canary.371

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

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.MutableAsset = void 0;
 function _sourceMap() {
-  const data = _interopRequireDefault(require("@parcel/source-map"));
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
   _sourceMap = function () {
     return data;
   };
@@ -20,10 +20,14 @@ function _stream() {
 }
 var _bitflags = require("./bitflags");
 var _assetSymbols = require("./asset-symbols");
-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 }; }
+// @ts-expect-error TS2694
+
 class MutableAsset {
+  // @ts-expect-error TS2564
+
+  // @ts-expect-error TS2416
+
   #astDirty;
   #ast;
   #contents;
@@ -34,6 +38,8 @@ class MutableAsset {
   get astGenerator() {
     throw new Error('get MutableAsset.astGenerator');
   }
+
+  // @ts-expect-error TS1051
   set astGenerator(value) {
     throw new Error('set MutableAsset.astGenerator');
   }
@@ -106,7 +112,6 @@ class MutableAsset {
     // Only create the source map if it is requested
     if (!this.#sourceMap && this.#map && typeof this.#map === 'string') {
       let sourceMap = new (_sourceMap().default)(this.#projectRoot);
-      // $FlowFixMe Flow is dumb
       sourceMap.addVLQMap(JSON.parse(this.#map));
       this.#sourceMap = sourceMap;
     }
@@ -126,32 +131,32 @@ class MutableAsset {
   }
 
   // eslint-disable-next-line no-unused-vars
-  addDependency() {
+  addDependency(options) {
     throw new Error('MutableAsset.addDependency()');
   }
 
   // eslint-disable-next-line no-unused-vars
-  addURLDependency() {
+  addURLDependency(url, opts) {
     throw new Error('MutableAsset.addURLDependency()');
   }
 
   // eslint-disable-next-line no-unused-vars
-  setEnvironment() {
+  setEnvironment(opts) {
     throw new Error('MutableAsset.setEnvironment()');
   }
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnFileChange() {
+  invalidateOnFileChange(invalidation) {
     // TODO: Forward invalidations to Rust
   }
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnFileCreate() {
+  invalidateOnFileCreate(invalidation) {
     // TODO: Forward invalidations to Rust
   }
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnEnvChange() {
+  invalidateOnEnvChange(invalidation) {
     // TODO: Forward invalidations to Rust
   }
   invalidateOnStartup() {

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

@@ -5,56 +5,35 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PluginConfig = void 0;
 var _Config = _interopRequireDefault(require("../../../public/Config"));
+var _InternalConfig = require("../../../InternalConfig");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class PluginConfig {
-  #projectRoot;
   #inner;
-  constructor({
-    env,
-    isSource,
-    searchPath,
-    projectRoot,
-    fs,
-    packageManager
-  }) {
-    this.env = env;
-    this.isSource = isSource;
-    this.searchPath = searchPath;
-    this.#inner = new _Config.default(
-    // $FlowFixMe
-    {
-      invalidateOnConfigKeyChange: [],
-      invalidateOnFileCreate: [],
-      invalidateOnFileChange: new Set(),
-      devDeps: [],
-      // $FlowFixMe
-      searchPath: searchPath.replace(projectRoot + '/', '')
-    },
-    // $FlowFixMe
-    {
-      projectRoot,
-      inputFS: fs,
-      outputFS: fs,
-      packageManager
-    });
+  constructor(configOpts, options) {
+    let internalConfig = (0, _InternalConfig.createConfig)(configOpts);
+    this.isSource = internalConfig.isSource;
+    this.searchPath = internalConfig.searchPath;
+    // @ts-expect-error TS2564
+    this.env = internalConfig.env;
+    this.#inner = new _Config.default(internalConfig, options);
   }
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnFileChange() {}
+  invalidateOnFileChange(filePath) {}
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnFileCreate() {}
+  invalidateOnFileCreate(invalidations) {}
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnEnvChange() {}
+  invalidateOnEnvChange(invalidation) {}
   invalidateOnStartup() {}
   invalidateOnBuild() {}
 
   // eslint-disable-next-line no-unused-vars
-  addDevDependency() {}
+  addDevDependency(options) {}
 
   // eslint-disable-next-line no-unused-vars
-  setCacheKey() {}
+  setCacheKey(key) {}
   getConfig(
   // eslint-disable-next-line no-unused-vars
   filePaths,

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.PluginOptions = void 0;
 class PluginOptions {
   #options;
+  used = false;
   get env() {
     if (!('env' in this.#options)) {
       return process.env;
@@ -18,18 +19,21 @@ class PluginOptions {
     if (!('projectRoot' in this.#options)) {
       throw new Error('PluginOptions.projectRoot');
     }
+    this.used = true;
     return this.#options.projectRoot;
   }
   get packageManager() {
     if (!('packageManager' in this.#options)) {
       throw new Error('PluginOptions.packageManager');
     }
+    this.used = true;
     return this.#options.packageManager;
   }
   get mode() {
     if (!('mode' in this.#options)) {
       throw new Error('PluginOptions.mode');
     }
+    this.used = true;
     return this.#options.mode;
   }
   get parcelVersion() {
@@ -38,30 +42,35 @@ class PluginOptions {
       // throw new Error('PluginOptions.parcelVersion');
     }
 
+    this.used = true;
     return this.#options.parcelVersion;
   }
   get hmrOptions() {
     if (!('hmrOptions' in this.#options)) {
       throw new Error('PluginOptions.hmrOptions');
     }
+    this.used = true;
     return this.#options.hmrOptions;
   }
   get serveOptions() {
     if (!('serveOptions' in this.#options)) {
       throw new Error('PluginOptions.serveOptions');
     }
+    this.used = true;
     return this.#options.serveOptions;
   }
   get shouldBuildLazily() {
     if (!('shouldBuildLazily' in this.#options)) {
       throw new Error('PluginOptions.shouldBuildLazily');
     }
+    this.used = true;
     return this.#options.shouldBuildLazily;
   }
   get shouldAutoInstall() {
     if (!('shouldAutoInstall' in this.#options)) {
       throw new Error('PluginOptions.shouldAutoInstall');
     }
+    this.used = true;
     return this.#options.shouldAutoInstall;
   }
   get logLevel() {
@@ -74,39 +83,46 @@ class PluginOptions {
     if (!('cacheDir' in this.#options)) {
       throw new Error('PluginOptions.cacheDir');
     }
+    this.used = true;
     return this.#options.cacheDir;
   }
   get inputFS() {
     if (!('inputFS' in this.#options)) {
       throw new Error('PluginOptions.inputFS');
     }
+    this.used = true;
     return this.#options.inputFS;
   }
   get outputFS() {
     if (!('outputFS' in this.#options)) {
       throw new Error('PluginOptions.outputFS');
     }
+    this.used = true;
     return this.#options.outputFS;
   }
   get instanceId() {
     if (!('instanceId' in this.#options)) {
       throw new Error('PluginOptions.instanceId');
     }
+    this.used = true;
     return this.#options.instanceId;
   }
   get detailedReport() {
     if (!('detailedReport' in this.#options)) {
       throw new Error('PluginOptions.detailedReport');
     }
+    this.used = true;
     return this.#options.detailedReport;
   }
   get featureFlags() {
     if (!('featureFlags' in this.#options)) {
       throw new Error('PluginOptions.featureFlags');
     }
+    this.used = true;
     return this.#options.featureFlags;
   }
   constructor(options) {
+    // @ts-expect-error TS2322
     this.#options = options;
   }
 }

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

@@ -5,6 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PluginTracer = void 0;
 class PluginTracer {
+  // @ts-expect-error TS2564
+
+  // @ts-expect-error TS2416
   createMeasurement() {
     throw new Error('PluginTracer.createMeasurement');
   }

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

@@ -4,6 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Target = void 0;
+// @ts-expect-error TS2305
+
 class Target {
   constructor(inner, env) {
     this.distDir = inner.distDir;

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

@@ -1,3 +1,6 @@
 "use strict";
 
+if (process.env.ATLASPACK_SOURCES === 'true' || process.env.ATLASPACK_BUILD_ENV === 'test' || process.env.ATLASPACK_SELF_BUILD) {
+  require('@atlaspack/babel-register');
+}
 require('./worker');

package/lib/atlaspack-v3/worker/side-effect-detector.js

@@ -0,0 +1,215 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultDetector = exports.SideEffectDetector = void 0;
+function _async_hooks() {
+  const data = require("async_hooks");
+  _async_hooks = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * Side effect detector using AsyncLocalStorage to track filesystem and environment variable
+ * access across concurrent async operations in a Node.js worker thread.
+ *
+ * Usage:
+ *   const detector = new SideEffectDetector();
+ *   detector.install();
+ *
+ *   const [result, sideEffects] = await detector.monitorSideEffects(async () => {
+ *     return await someOperation();
+ *   });
+ *
+ *   console.log(sideEffects.fsUsage);   // Array of filesystem accesses
+ *   console.log(sideEffects.envUsage);  // Array of environment variable accesses
+ */
+class SideEffectDetector {
+  constructor() {
+    this.asyncStorage = new (_async_hooks().AsyncLocalStorage)();
+    this.patchesInstalled = false;
+    this.originalMethods = {};
+  }
+
+  /**
+   * Install global patches for filesystem and environment variable monitoring.
+   * This should be called once when the worker starts up.
+   */
+  install() {
+    if (this.patchesInstalled) {
+      return;
+    }
+    this._patchFilesystem();
+    this._patchProcessEnv();
+    this.patchesInstalled = true;
+  }
+
+  /**
+   * Monitor side effects for an async operation.
+   *
+   * @param {Function} fn - Async function to monitor
+   * @param {Object} options - Optional configuration
+   * @param {string} options.label - Optional label for debugging
+   * @returns {Promise<[any, SideEffects]>} Tuple of [result, sideEffects]
+   */
+  monitorSideEffects(packageName, fn) {
+    if (!this.patchesInstalled) {
+      throw new Error('SideEffectDetector: install() must be called before monitorSideEffects()');
+    }
+    const context = {
+      fsUsage: [],
+      envUsage: {
+        vars: new Set(),
+        didEnumerate: false
+      },
+      packageName: packageName
+    };
+    return this.asyncStorage.run(context, async () => {
+      const result = await fn();
+      return [result, context];
+    });
+  }
+
+  /**
+   * Get the current monitoring context, if any.
+   * Useful for debugging or custom instrumentation.
+   *
+   * @returns {Object|null} Current context or null if not monitoring
+   */
+  getCurrentContext() {
+    return this.asyncStorage.getStore() || null;
+  }
+
+  /**
+   * Check if currently monitoring side effects.
+   *
+   * @returns {boolean}
+   */
+  isMonitoring() {
+    return this.asyncStorage.getStore() !== undefined;
+  }
+
+  /**
+   * Patch filesystem methods to record access.
+   * @private
+   */
+  _patchFilesystem() {
+    // Inline require this to avoid babel transformer issue
+    const fs = require('fs');
+    const methodsToPatch = [
+    // Sync methods
+    'readFileSync', 'writeFileSync', 'appendFileSync', 'existsSync', 'statSync', 'lstatSync', 'readdirSync', 'mkdirSync', 'rmdirSync', 'unlinkSync', 'copyFileSync', 'renameSync', 'chmodSync', 'chownSync',
+    // Async methods
+    'readFile', 'writeFile', 'appendFile', 'stat', 'lstat', 'readdir', 'mkdir', 'rmdir', 'unlink', 'copyFile', 'rename', 'chmod', 'chown'];
+    methodsToPatch.forEach(method => {
+      if (typeof fs[method] === 'function') {
+        this.originalMethods[method] = fs[method];
+        const self = this;
+
+        // @ts-expect-error Dynamic method patching
+        fs[method] = function (path, ...args) {
+          // Record filesystem access in current context
+          const context = self.asyncStorage.getStore();
+          if (context) {
+            context.fsUsage.push({
+              method,
+              path: typeof path === 'string' ? path : path === null || path === void 0 ? void 0 : path.toString()
+            });
+          }
+          return self.originalMethods[method].call(this, path, ...args);
+        };
+      }
+    });
+
+    // Handle fs.promises methods
+    if (fs.promises) {
+      const promiseMethodsToPatch = ['readFile', 'writeFile', 'appendFile', 'stat', 'lstat', 'readdir', 'mkdir', 'rmdir', 'unlink', 'copyFile', 'rename', 'chmod', 'chown'];
+      const promises = fs.promises;
+      promiseMethodsToPatch.forEach(method => {
+        if (typeof promises[method] === 'function') {
+          const originalKey = `promises_${method}`;
+          this.originalMethods[originalKey] = promises[method];
+          // eslint-disable-next-line @typescript-eslint/no-this-alias
+          const self = this;
+          promises[method] = function (path, ...args) {
+            const context = self.asyncStorage.getStore();
+            if (context) {
+              context.fsUsage.push({
+                method: `promises.${method}`,
+                path: typeof path === 'string' ? path : String(path)
+              });
+            }
+            return self.originalMethods[originalKey].call(this, path, ...args);
+          };
+        }
+      });
+    }
+  }
+
+  /**
+   * Patch process.env to record environment variable access.
+   * @private
+   */
+  _patchProcessEnv() {
+    if (this.originalMethods.processEnv) {
+      return; // Already patched
+    }
+
+    this.originalMethods.processEnv = process.env;
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    // The following environment variables are allowed to be accessed by transformers
+    const allowedVars = new Set(['ATLASPACK_ENABLE_SENTRY',
+    // TODO we should also add the other atlaspack env vars here
+    'NODE_V8_COVERAGE', 'VSCODE_INSPECTOR_OPTIONS', 'NODE_INSPECTOR_IPC', 'FORCE_COLOR', 'NO_COLOR', 'TTY']);
+
+    // Create a proxy that intercepts property access
+    process.env = new Proxy(this.originalMethods.processEnv, {
+      get(target, property) {
+        const context = self.asyncStorage.getStore();
+        if (context && typeof property === 'string') {
+          // Only record if this is a real environment variable access
+          // (not internal properties like 'constructor', 'valueOf', etc.)
+          if (!allowedVars.has(property) && (property in target || !property.startsWith('_'))) {
+            context.envUsage.vars.add(property);
+          }
+        }
+        return target[property];
+      },
+      set(target, property, value) {
+        const context = self.asyncStorage.getStore();
+        if (context && typeof property === 'string') {
+          if (!allowedVars.has(property) && property in target) {
+            context.envUsage.vars.add(property);
+          }
+        }
+        target[property] = value;
+        return true;
+      },
+      has(target, property) {
+        const context = self.asyncStorage.getStore();
+        if (context && typeof property === 'string') {
+          if (!allowedVars.has(property) && property in target) {
+            context.envUsage.vars.add(property);
+          }
+        }
+        return property in target;
+      },
+      ownKeys(target) {
+        const context = self.asyncStorage.getStore();
+        if (context) {
+          context.envUsage.didEnumerate = true;
+        }
+        return Object.keys(target);
+      }
+    });
+  }
+}
+
+/**
+ * Default instance for convenience. Most workers will only need one detector.
+ */
+exports.SideEffectDetector = SideEffectDetector;
+const defaultDetector = exports.defaultDetector = new SideEffectDetector();