@atlaspack/core 2.16.2-canary.27 → 2.16.2-canary.270

package/lib/Atlaspack.js

@@ -123,37 +123,43 @@ function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return
 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 }; }
 // eslint-disable-next-line no-unused-vars
+
 (0, _registerCoreWithSerializer.registerCoreWithSerializer)();
 const INTERNAL_TRANSFORM = exports.INTERNAL_TRANSFORM = Symbol('internal_transform');
 const INTERNAL_RESOLVE = exports.INTERNAL_RESOLVE = Symbol('internal_resolve');
-const WORKER_PATH = exports.WORKER_PATH = _path().default.join(__dirname, 'worker.js');
+let WORKER_PATH = exports.WORKER_PATH = _path().default.join(__dirname, 'worker.js');
+if (__filename.endsWith('.ts')) {
+  exports.WORKER_PATH = WORKER_PATH = _path().default.join(__dirname, 'worker.ts');
+}
 class Atlaspack {
-  #requestTracker /*: RequestTracker*/;
-  #config /*: AtlaspackConfig*/;
-  #farm /*: WorkerFarm*/;
-  #initialized /*: boolean*/ = false;
-  #disposable /*: Disposable */;
-  #initialOptions /*: InitialAtlaspackOptions */;
-  #reporterRunner /*: ReporterRunner*/;
-  #resolvedOptions /*: ?AtlaspackOptions*/ = null;
-  #optionsRef /*: SharedReference */;
-  #watchAbortController /*: AbortController*/;
-  #watchQueue /*: PromiseQueue<?BuildEvent>*/ = new (_utils2().PromiseQueue)({
+  // @ts-expect-error TS2564
+  #requestTracker;
+  // @ts-expect-error TS2564
+  #config;
+  // @ts-expect-error TS2564
+  #farm;
+  #initialized = false;
+  // @ts-expect-error TS2564
+  #disposable;
+  #initialOptions;
+  // @ts-expect-error TS2564
+  #reporterRunner;
+  #resolvedOptions = null;
+  // @ts-expect-error TS2564
+  #optionsRef;
+  // @ts-expect-error TS2564
+  #watchAbortController;
+  #watchQueue = new (_utils2().PromiseQueue)({
     maxConcurrent: 1
   });
-  #watchEvents /*: ValueEmitter<
-               | {|
-               +error: Error,
-               +buildEvent?: void,
-               |}
-               | {|
-               +buildEvent: BuildEvent,
-               +error?: void,
-               |},
-               > */;
-  #watcherSubscription /*: ?AsyncSubscription*/;
-  #watcherCount /*: number*/ = 0;
-  #requestedAssetIds /*: Set<string>*/ = new Set();
+  // @ts-expect-error TS2564
+  #watchEvents;
+  #watcherSubscription;
+  #watcherCount = 0;
+  #requestedAssetIds = new Set();
+
+  // @ts-expect-error TS2564
+
   constructor(options) {
     this.#initialOptions = options;
   }
@@ -203,8 +209,6 @@ class Atlaspack {
         throw new Error('Atlaspack v3 must be run with lmdb lite cache');
       }
       const lmdb = resolvedOptions.cache.getNativeRef();
-
-      // $FlowFixMe
       const version = require('../package.json').version;
       await lmdb.put('current_session_version', Buffer.from(version));
       let threads = undefined;
@@ -215,16 +219,21 @@ class Atlaspack {
       }
       rustAtlaspack = await _atlaspackV.AtlaspackV3.create({
         ...options,
+        // @ts-expect-error TS2353
         corePath: _path().default.join(__dirname, '..'),
         threads,
         entries: Array.isArray(entries) ? entries : entries == null ? undefined : [entries],
         env: resolvedOptions.env,
         fs: inputFS && new _atlaspackV.FileSystemV3(inputFS),
-        // $FlowFixMe ProjectPath is a string
         defaultTargetOptions: resolvedOptions.defaultTargetOptions,
-        lmdb
+        lmdb,
+        featureFlags: resolvedOptions.featureFlags
+      });
+      this.#disposable.add(() => {
+        rustAtlaspack.end();
       });
     }
+    // @ts-expect-error TS2454
     this.rustAtlaspack = rustAtlaspack;
     let {
       config
@@ -270,6 +279,7 @@ class Atlaspack {
     this.#requestTracker = await _RequestTracker.default.init({
       farm: this.#farm,
       options: resolvedOptions,
+      // @ts-expect-error TS2454
       rustAtlaspack
     });
     this.#initialized = true;
@@ -336,6 +346,8 @@ class Atlaspack {
     if (!this.#initialized) {
       await this._init();
     }
+
+    // @ts-expect-error TS7034
     let watchEventsDisposable;
     if (cb) {
       watchEventsDisposable = this.#watchEvents.addListener(({
@@ -355,8 +367,11 @@ class Atlaspack {
       this.#watchQueue.run();
     }
     this.#watcherCount++;
+
+    // @ts-expect-error TS7034
     let unsubscribePromise;
     const unsubscribe = async () => {
+      // @ts-expect-error TS7005
       if (watchEventsDisposable) {
         watchEventsDisposable.dispose();
       }
@@ -374,9 +389,12 @@ class Atlaspack {
     };
     return {
       unsubscribe() {
+        // @ts-expect-error TS7005
         if (unsubscribePromise == null) {
           unsubscribePromise = unsubscribe();
         }
+
+        // @ts-expect-error TS7005
         return unsubscribePromise;
       }
     };
@@ -387,7 +405,6 @@ class Atlaspack {
   } = {
     /*::...null*/
   }) {
-    this.#requestTracker.setSignal(signal);
     let options = (0, _nullthrows().default)(this.#resolvedOptions);
     try {
       if (options.shouldProfile) {
@@ -395,6 +412,11 @@ class Atlaspack {
       }
       if (options.shouldTrace) {
         _profiler().tracer.enable();
+        // We need to ensure the tracer is disabled when Atlaspack is disposed as it is a module level object.
+        // While rare (except for tests), if another instance is created later it should not have tracing enabled.
+        this.#disposable.add(() => {
+          _profiler().tracer.disable();
+        });
       }
       await this.#reporterRunner.report({
         type: 'buildStart'
@@ -409,19 +431,21 @@ class Atlaspack {
         bundleGraph,
         bundleInfo,
         changedAssets,
-        assetRequests
+        assetRequests,
+        scopeHoistingStats
       } = await this.#requestTracker.runRequest(request, {
         force: true
       });
       this.#requestedAssetIds.clear();
       await (0, _dumpGraphToGraphViz.default)(
-      // $FlowFixMe
+      // @ts-expect-error TS2345
       this.#requestTracker.graph, 'RequestGraph', _RequestTracker.requestGraphEdgeTypes);
       let event = {
         type: 'buildSuccess',
         changedAssets: new Map(Array.from(changedAssets).map(([id, asset]) => [id, (0, _Asset.assetFromValue)(asset, options)])),
         bundleGraph: new _BundleGraph.default(bundleGraph, (bundle, bundleGraph, options) => _Bundle.PackagedBundle.getWithInfo(bundle, bundleGraph, options, bundleInfo.get(bundle.id)), options),
         buildTime: Date.now() - startTime,
+        // @ts-expect-error TS7006
         requestBundle: async bundle => {
           let bundleNode = bundleGraph._graph.getNodeByContentKey(bundle.id);
           (0, _assert().default)((bundleNode === null || bundleNode === void 0 ? void 0 : bundleNode.type) === 'bundle', 'Bundle does not exist');
@@ -433,7 +457,8 @@ class Atlaspack {
               bundleGraph: event.bundleGraph,
               buildTime: 0,
               requestBundle: event.requestBundle,
-              unstable_requestStats: {}
+              unstable_requestStats: {},
+              scopeHoistingStats: event.scopeHoistingStats
             };
           }
           for (let assetId of bundleNode.value.entryAssetIds) {
@@ -447,15 +472,22 @@ class Atlaspack {
           }
           let results = await this.#watchQueue.run();
           let result = results.filter(Boolean).pop();
+          // @ts-expect-error TS18049
           if (result.type === 'buildFailure') {
+            // @ts-expect-error TS18049
             throw new BuildError(result.diagnostics);
           }
           return result;
         },
-        unstable_requestStats: this.#requestTracker.flushStats()
+        unstable_requestStats: this.#requestTracker.flushStats(),
+        scopeHoistingStats
       };
+
+      // @ts-expect-error TS2345
       await this.#reporterRunner.report(event);
-      await this.#requestTracker.runRequest((0, _ValidationRequest.default)({
+      await this.#requestTracker.runRequest(
+      // @ts-expect-error TS2345
+      (0, _ValidationRequest.default)({
         optionsRef: this.#optionsRef,
         assetRequests
       }), {
@@ -464,6 +496,8 @@ class Atlaspack {
       if (this.#reporterRunner.errors.length) {
         throw this.#reporterRunner.errors;
       }
+
+      // @ts-expect-error TS2322
       return event;
     } catch (e) {
       if (e instanceof _utils.BuildAbortError) {
@@ -475,7 +509,10 @@ class Atlaspack {
         diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic],
         unstable_requestStats: this.#requestTracker.flushStats()
       };
+
+      // @ts-expect-error TS2345
       await this.#reporterRunner.report(event);
+      // @ts-expect-error TS2322
       return event;
     } finally {
       if (this.isProfiling) {
@@ -510,7 +547,9 @@ class Atlaspack {
       if (this.rustAtlaspack) {
         nativeInvalid = await this.rustAtlaspack.respondToFsEvents(events);
       }
-      let isInvalid = await this.#requestTracker.respondToFSEvents(events, Number.POSITIVE_INFINITY);
+      let {
+        didInvalidate: isInvalid
+      } = await this.#requestTracker.respondToFSEvents(events, Number.POSITIVE_INFINITY);
       if ((nativeInvalid || isInvalid) && this.#watchQueue.getNumWaiting() === 0) {
         if (this.#watchAbortController) {
           this.#watchAbortController.abort();
@@ -586,7 +625,11 @@ class Atlaspack {
       requestedAssetIds: this.#requestedAssetIds
     };
     const start = Date.now();
-    const result = await this.#requestTracker.runRequest(this.rustAtlaspack != null ? (0, _AssetGraphRequestRust.createAssetGraphRequestRust)(this.rustAtlaspack)(input) : (0, _AssetGraphRequest.default)(input), {
+    const result = await this.#requestTracker.runRequest(this.rustAtlaspack != null ?
+    // @ts-expect-error TS2345
+    (0, _AssetGraphRequestRust.createAssetGraphRequestRust)(this.rustAtlaspack)(input) :
+    // @ts-expect-error TS2345
+    (0, _AssetGraphRequest.default)(input), {
       force: true
     });
     const duration = Date.now() - start;
@@ -673,6 +716,7 @@ class Atlaspack {
       return null;
     }
     return {
+      // @ts-expect-error TS2322
       filePath: (0, _projectPath.fromProjectPath)(projectRoot, res.filePath),
       code: res.code,
       query: res.query,

package/lib/AtlaspackConfig.js

@@ -90,6 +90,7 @@ class AtlaspackConfig {
   }
   async loadPlugin(node) {
     let plugin = await this._loadPlugin(node);
+    // @ts-expect-error TS2322
     return {
       ...plugin,
       name: node.packageName,
@@ -196,6 +197,7 @@ class AtlaspackConfig {
     let [patternPipeline, patternGlob] = pattern.split(':');
     if (!patternGlob) {
       patternGlob = patternPipeline;
+      // @ts-expect-error TS2322
       patternPipeline = null;
     }
     let re = this.regexCache.get(patternGlob);
@@ -235,6 +237,7 @@ class AtlaspackConfig {
     }
     for (let pattern in globMap) {
       if (this.isGlobMatch(filePath, pattern)) {
+        // @ts-expect-error TS2345
         matches.push(globMap[pattern]);
       }
     }
@@ -250,7 +253,7 @@ class AtlaspackConfig {
       return pipeline;
     };
     let res = flatten();
-    // $FlowFixMe afaik this should work
+    // @ts-expect-error TS2322
     return res;
   }
   async missingPluginError(plugins, message, key) {
@@ -258,7 +261,13 @@ class AtlaspackConfig {
     if (Array.isArray(plugins)) {
       configsWithPlugin = new Set(getConfigPaths(this.options, plugins));
     } else {
-      configsWithPlugin = new Set(Object.keys(plugins).flatMap(k => Array.isArray(plugins[k]) ? getConfigPaths(this.options, plugins[k]) : [getConfigPath(this.options, plugins[k])]));
+      configsWithPlugin = new Set(Object.keys(plugins).flatMap(k =>
+      // @ts-expect-error TS7053
+      Array.isArray(plugins[k]) ?
+      // @ts-expect-error TS7053
+      getConfigPaths(this.options, plugins[k]) :
+      // @ts-expect-error TS7053
+      [getConfigPath(this.options, plugins[k])]));
     }
     if (configsWithPlugin.size === 0) {
       configsWithPlugin.add((0, _projectPath.fromProjectPath)(this.options.projectRoot, this.filePath));
@@ -291,8 +300,11 @@ class AtlaspackConfig {
 }
 exports.AtlaspackConfig = AtlaspackConfig;
 function getConfigPaths(options, nodes) {
-  return nodes.map(node => node !== '...' ? getConfigPath(options, node) : null).filter(Boolean);
+  return nodes
+  // @ts-expect-error TS2339
+  .map(node => node !== '...' ? getConfigPath(options, node) : null).filter(Boolean);
 }
 function getConfigPath(options, node) {
+  // @ts-expect-error TS2339
   return (0, _projectPath.fromProjectPath)(options.projectRoot, node.resolveFrom);
 }

package/lib/AtlaspackConfig.schema.js

@@ -6,15 +6,17 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 exports.validatePackageName = validatePackageName;
 // Parcel validates plugin package names due to:
-//
 // * https://github.com/parcel-bundler/parcel/issues/3397#issuecomment-521353931
-//
 // Ultimately:
-//
 // * We do not care about package names
 // * Validation makes interop between parcel/atlaspack confusing.
-//
-function validatePackageName() {}
+function validatePackageName(
+// eslint-disable-next-line no-unused-vars
+pkg,
+// eslint-disable-next-line no-unused-vars
+pluginType,
+// eslint-disable-next-line no-unused-vars
+key) {}
 const validatePluginName = (pluginType, key) => {
   return val => {
     // allow plugin spread...