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

package/lib/requests/BundleGraphRequest.js

@@ -32,6 +32,13 @@ function _logger() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _diagnostic() {
   const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
   _diagnostic = function () {
@@ -39,7 +46,6 @@ function _diagnostic() {
   };
   return data;
 }
-var _AssetGraph = _interopRequireDefault(require("../AssetGraph"));
 var _BundleGraph = _interopRequireDefault(require("../public/BundleGraph"));
 var _BundleGraph2 = _interopRequireWildcard(require("../BundleGraph"));
 var _MutableBundleGraph = _interopRequireDefault(require("../public/MutableBundleGraph"));
@@ -85,6 +91,7 @@ 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 }; }
 // TODO: Rename to BundleGraphRequestResult
+
 function applySideEffectsForLoadableImports(assetGraph) {
   // Avoid revisiting nodes
   let updatedAssetIds = new Set();
@@ -131,7 +138,7 @@ function createBundleGraphRequest(input) {
         signal
       } = input.input;
       let measurement = _profiler().tracer.createMeasurement('building');
-      let createAssetGraphRequest = input.rustAtlaspack ? (0, _AssetGraphRequestRust.createAssetGraphRequestRust)(input.rustAtlaspack) : _AssetGraphRequest.default;
+      let createAssetGraphRequest = (0, _featureFlags().getFeatureFlag)('atlaspackV3') && input.rustAtlaspack ? (0, _AssetGraphRequestRust.createAssetGraphRequestRust)(input.rustAtlaspack) : _AssetGraphRequest.default;
       let request = createAssetGraphRequest({
         name: 'Main',
         entries: options.entries,
@@ -145,8 +152,10 @@ function createBundleGraphRequest(input) {
         assetGraph,
         changedAssets,
         assetRequests
-      } = await api.runRequest(request, {
-        force: Boolean(input.rustAtlaspack) || options.shouldBuildLazily && requestedAssetIds.size > 0
+      } = await (0, _logger().instrumentAsync)('asset-graph-request', () => {
+        return api.runRequest(request, {
+          force: Boolean(input.rustAtlaspack) || options.shouldBuildLazily && requestedAssetIds.size > 0
+        });
       });
       if ((_input$options$featur = input.options.featureFlags) !== null && _input$options$featur !== void 0 && _input$options$featur.loadableSideEffects) {
         applySideEffectsForLoadableImports(assetGraph);
@@ -171,7 +180,11 @@ function createBundleGraphRequest(input) {
       //       force: true,
       //     },
       //   );
-      //   require('./asset-graph-diff.js')(jsAssetGraph, assetGraph);
+      //   require('./asset-graph-diff.ts')(
+      //     jsAssetGraph,
+      //     assetGraph,
+      //     options.projectRoot,
+      //   );
       // }
 
       measurement && measurement.end();
@@ -183,6 +196,7 @@ function createBundleGraphRequest(input) {
       let subRequestsInvalid = Boolean(invalidateReason & _constants.OPTION_CHANGE) || input.api.getSubRequests().some(req => !input.api.canSkipSubrequest(req.id));
       if (subRequestsInvalid) {
         assetGraph.safeToIncrementallyBundle = false;
+        assetGraph.setNeedsBundling();
       }
       let configResult = (0, _nullthrows().default)(await input.api.runRequest((0, _AtlaspackConfigRequest.default)()));
       (0, _utils2.assertSignalNotAborted)(signal);
@@ -204,7 +218,7 @@ function createBundleGraphRequest(input) {
         res.changedAssets.set(id, asset);
       }
       await (0, _dumpGraphToGraphViz.default)(
-      // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381 (Windows only)
+      // @ts-expect-error TS2345
       res.bundleGraph._graph, 'BundleGraph', _BundleGraph2.bundleGraphEdgeTypes);
       return res;
     },
@@ -225,7 +239,12 @@ class BundlerRunner {
     this.devDepRequests = new Map();
     this.configs = new Map();
     this.pluginOptions = new _PluginOptions.default((0, _utils2.optionsProxy)(this.options, api.invalidateOnOptionChange));
-    this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-BundleGraph';
+    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      const key = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
+      this.cacheKey = `BundleGraph/${_constants.ATLASPACK_VERSION}/${options.mode}/${key}`;
+    } else {
+      this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-BundleGraph';
+    }
   }
   async loadConfigs() {
     // Load all configs up front so we can use them in the cache key
@@ -280,16 +299,11 @@ class BundlerRunner {
     } = plugin;
 
     // if a previous asset graph hash is passed in, check if the bundle graph is also available
-    let previousBundleGraphResult;
-    if (graph.safeToIncrementallyBundle) {
-      try {
-        previousBundleGraphResult = await this.api.getPreviousResult();
-      } catch {
-        // if the bundle graph had an error or was removed, don't fail the build
-      }
-    }
-    if (previousBundleGraphResult == null) {
+    const previousBundleGraphResult = await this.api.getPreviousResult();
+    const canIncrementallyBundle = (previousBundleGraphResult === null || previousBundleGraphResult === void 0 ? void 0 : previousBundleGraphResult.assetGraphBundlingVersion) != null && graph.canIncrementallyBundle(previousBundleGraphResult.assetGraphBundlingVersion);
+    if (graph.safeToIncrementallyBundle && previousBundleGraphResult == null) {
       graph.safeToIncrementallyBundle = false;
+      graph.setNeedsBundling();
     }
     let internalBundleGraph;
     let logger = new (_logger().PluginLogger)({
@@ -300,7 +314,7 @@ class BundlerRunner {
       category: 'bundle'
     });
     try {
-      if (previousBundleGraphResult) {
+      if (canIncrementallyBundle && previousBundleGraphResult) {
         internalBundleGraph = previousBundleGraphResult.bundleGraph;
         for (let changedAssetId of changedAssets.keys()) {
           // Copy over the whole node to also have correct symbol data
@@ -314,7 +328,7 @@ class BundlerRunner {
         (0, _assert().default)(internalBundleGraph != null); // ensures the graph was created
 
         await (0, _dumpGraphToGraphViz.default)(
-        // $FlowFixMe
+        // @ts-expect-error TS2345
         internalBundleGraph._graph, 'before_bundle', _BundleGraph2.bundleGraphEdgeTypes);
         let mutableBundleGraph = new _MutableBundleGraph.default(internalBundleGraph, this.options);
         let measurement;
@@ -355,7 +369,7 @@ class BundlerRunner {
           } finally {
             optimizeMeasurement && optimizeMeasurement.end();
             await (0, _dumpGraphToGraphViz.default)(
-            // $FlowFixMe[incompatible-call]
+            // @ts-expect-error TS2345
             internalBundleGraph._graph, 'after_optimize');
           }
         }
@@ -372,6 +386,7 @@ class BundlerRunner {
       if (internalBundleGraph != null) {
         this.api.storeResult({
           bundleGraph: internalBundleGraph,
+          assetGraphBundlingVersion: graph.getBundlingVersion(),
           changedAssets: new Map(),
           assetRequests: []
         }, this.cacheKey);
@@ -384,12 +399,12 @@ class BundlerRunner {
     } finally {
       if (internalBundleGraph != null) {
         await (0, _dumpGraphToGraphViz.default)(
-        // $FlowFixMe[incompatible-call]
+        // @ts-expect-error TS2345
         internalBundleGraph._graph, 'after_bundle', _BundleGraph2.bundleGraphEdgeTypes);
       }
     }
     let changedRuntimes = new Map();
-    if (!previousBundleGraphResult) {
+    if (!previousBundleGraphResult || !canIncrementallyBundle) {
       let namers = await this.config.getNamers();
       // inline bundles must still be named so the PackagerRunner
       // can match them to the correct packager/optimizer plugins.
@@ -397,7 +412,7 @@ class BundlerRunner {
         includeInline: true
       });
       await Promise.all(bundles.map(bundle => this.nameBundle(namers, bundle, internalBundleGraph)));
-      changedRuntimes = await (0, _applyRuntimes.default)({
+      changedRuntimes = await (0, _logger().instrumentAsync)('applyRuntimes', () => (0, _applyRuntimes.default)({
         bundleGraph: internalBundleGraph,
         api: this.api,
         config: this.config,
@@ -407,7 +422,7 @@ class BundlerRunner {
         previousDevDeps: this.previousDevDeps,
         devDepRequests: this.devDepRequests,
         configs: this.configs
-      });
+      }));
 
       // Add dev deps for namers, AFTER running them to account for lazy require().
       for (let namer of namers) {
@@ -423,15 +438,17 @@ class BundlerRunner {
       internalBundleGraph.getBundleGraphHash();
     }
     await (0, _dumpGraphToGraphViz.default)(
-    // $FlowFixMe
+    // @ts-expect-error TS2345
     internalBundleGraph._graph, 'after_runtimes', _BundleGraph2.bundleGraphEdgeTypes);
     this.api.storeResult({
       bundleGraph: internalBundleGraph,
+      assetGraphBundlingVersion: graph.getBundlingVersion(),
       changedAssets: new Map(),
       assetRequests: []
     }, this.cacheKey);
     return {
       bundleGraph: internalBundleGraph,
+      assetGraphBundlingVersion: graph.getBundlingVersion(),
       changedAssets: changedRuntimes,
       assetRequests
     };

package/lib/requests/ConfigRequest.js

@@ -6,7 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.getConfigHash = getConfigHash;
 exports.getConfigKeyContentHash = getConfigKeyContentHash;
 exports.getConfigRequests = getConfigRequests;
+exports.getValueAtPath = getValueAtPath;
 exports.loadPluginConfig = loadPluginConfig;
+exports.loadPluginSetup = loadPluginSetup;
 exports.runConfigRequest = runConfigRequest;
 function _utils() {
   const data = require("@atlaspack/utils");
@@ -86,19 +88,66 @@ async function loadPluginConfig(loadedPlugin, config, options) {
     });
   }
 }
+async function loadPluginSetup(pluginName, setup, config, options) {
+  try {
+    let result = await setup({
+      config: new _Config.default(config, options),
+      options: new _PluginOptions.default((0, _utils2.optionsProxy)(options, option => {
+        config.invalidateOnOptionChange.add(option);
+      })),
+      logger: new (_logger().PluginLogger)({
+        origin: pluginName
+      }),
+      tracer: new (_profiler().PluginTracer)({
+        origin: pluginName,
+        category: 'setup'
+      })
+    });
+    config.result = result.config;
+  } catch (e) {
+    throw new (_diagnostic().default)({
+      diagnostic: (0, _diagnostic().errorToDiagnostic)(e, {
+        origin: pluginName
+      })
+    });
+  }
+}
+
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+function getValueAtPath(obj, key) {
+  let current = obj;
+  for (let part of key) {
+    if (current == null) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}
 const configKeyCache = (0, _buildCache().createBuildCache)();
 async function getConfigKeyContentHash(filePath, configKey, options) {
-  let cacheKey = `${(0, _projectPath.fromProjectPathRelative)(filePath)}:${configKey}`;
+  let cacheKey = `${(0, _projectPath.fromProjectPathRelative)(filePath)}:${JSON.stringify(configKey)}`;
   let cachedValue = configKeyCache.get(cacheKey);
   if (cachedValue) {
+    // @ts-expect-error TS2322
     return cachedValue;
   }
-  let conf = await (0, _utils().readConfig)(options.inputFS, (0, _projectPath.fromProjectPath)(options.projectRoot, filePath));
-  if (conf == null || conf.config[configKey] == null) {
+  const conf = await (0, _utils().readConfig)(options.inputFS, (0, _projectPath.fromProjectPath)(options.projectRoot, filePath));
+  const value = getValueAtPath(conf === null || conf === void 0 ? void 0 : conf.config, configKey);
+  if (conf == null || value == null) {
     // This can occur when a config key has been removed entirely during `respondToFSEvents`
     return '';
   }
-  let contentHash = typeof conf.config[configKey] === 'object' ? (0, _utils().hashObject)(conf.config[configKey]) : (0, _rust().hashString)(JSON.stringify(conf.config[configKey]));
+  const contentHash = typeof value === 'object' ? (0, _utils().hashObject)(value) : (0, _rust().hashString)(JSON.stringify(value));
   configKeyCache.set(cacheKey, contentHash);
   return contentHash;
 }

package/lib/requests/DevDepRequest.js

@@ -89,14 +89,32 @@ async function createDevDependency(opts, requestDevDeps, options) {
   return devDepRequest;
 }
 async function getDevDepRequests(api) {
-  let previousDevDepRequests = new Map(await Promise.all(api.getSubRequests().filter(req => req.requestType === _RequestTracker.requestTypes.dev_dep_request).map(async req => [req.id, (0, _nullthrows().default)(await api.getRequestResult(req.id))])));
+  async function getPreviousDevDepRequests() {
+    const allDevDepRequests = await Promise.all(api.getSubRequests().filter(req => req.requestType === _RequestTracker.requestTypes.dev_dep_request).map(async req => [req.id, await api.getRequestResult(req.id)]));
+    const nonNullDevDepRequests = [];
+    for (const [id, result] of allDevDepRequests) {
+      if (result != null) {
+        nonNullDevDepRequests.push([id, result]);
+      }
+    }
+
+    // @ts-expect-error TS2769
+    return new Map(nonNullDevDepRequests);
+  }
+  const previousDevDepRequests = await getPreviousDevDepRequests();
   return {
-    devDeps: new Map([...previousDevDepRequests.entries()].filter(([id]) => api.canSkipSubrequest(id)).map(([, req]) => [`${req.specifier}:${(0, _projectPath.fromProjectPathRelative)(req.resolveFrom)}`, req.hash])),
-    invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()].filter(([id]) => !api.canSkipSubrequest(id)).flatMap(([, req]) => {
+    devDeps: new Map([...previousDevDepRequests.entries()]
+    // @ts-expect-error TS2769
+    .filter(([id]) => api.canSkipSubrequest(id)).map(([, req]) => [`${req.specifier}:${(0, _projectPath.fromProjectPathRelative)(req.resolveFrom)}`, req.hash])),
+    invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()]
+    // @ts-expect-error TS2769
+    .filter(([id]) => !api.canSkipSubrequest(id)).flatMap(([, req]) => {
       return [{
         specifier: req.specifier,
         resolveFrom: req.resolveFrom
-      }, ...(req.additionalInvalidations ?? []).map(i => ({
+      },
+      // @ts-expect-error TS7006
+      ...(req.additionalInvalidations ?? []).map(i => ({
         specifier: i.specifier,
         resolveFrom: i.resolveFrom
       }))];
@@ -122,7 +140,9 @@ function invalidateDevDeps(invalidDevDeps, options, config) {
 }
 const devDepRequests = (0, _buildCache().createBuildCache)();
 function resolveDevDepRequestRef(devDepRequestRef) {
-  const devDepRequest = devDepRequestRef.type === 'ref' ? devDepRequests.get(devDepRequestRef.hash) : devDepRequestRef;
+  const devDepRequest =
+  // @ts-expect-error TS2339
+  devDepRequestRef.type === 'ref' ? devDepRequests.get(devDepRequestRef.hash) : devDepRequestRef;
   if (devDepRequest == null) {
     throw new Error(`Worker send back a reference to a missing dev dep request.
 
@@ -132,15 +152,21 @@ ${process.env.NODE_ENV === 'test' ? `If this is a unit test, call atlaspack.clea
 
 This is a bug in Atlaspack.`);
   }
+
+  // @ts-expect-error TS2339
   if (devDepRequestRef.type !== 'ref') {
+    // @ts-expect-error TS2345
     devDepRequests.set(devDepRequest.hash, devDepRequest);
   }
+
+  // @ts-expect-error TS2322
   return devDepRequest;
 }
 async function runDevDepRequest(api, devDepRequestRef) {
   await api.runRequest({
     id: 'dev_dep_request:' + devDepRequestRef.specifier + ':' + devDepRequestRef.hash,
     type: _RequestTracker.requestTypes.dev_dep_request,
+    // @ts-expect-error TS2322
     run: ({
       api
     }) => {

package/lib/requests/EntryRequest.js

@@ -47,6 +47,8 @@ function createEntryRequest(input) {
     input
   };
 }
+
+// @ts-expect-error TS7031
 async function run({
   input,
   api,

package/lib/requests/PackageRequest.js

@@ -15,6 +15,14 @@ function _nullthrows() {
 var _ConfigRequest = require("./ConfigRequest");
 var _DevDepRequest = require("./DevDepRequest");
 var _AtlaspackConfigRequest = _interopRequireDefault(require("./AtlaspackConfigRequest"));
+var _EnvironmentManager = require("../EnvironmentManager");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createPackageRequest(input) {
   return {
@@ -27,7 +35,8 @@ function createPackageRequest(input) {
 async function run({
   input,
   api,
-  farm
+  farm,
+  rustAtlaspack
 }) {
   let {
     bundleGraphReference,
@@ -44,6 +53,10 @@ async function run({
   let {
     cachePath
   } = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
+  if ((0, _featureFlags().getFeatureFlag)('nativePackager') && (0, _featureFlags().getFeatureFlag)('nativePackagerSSRDev') && rustAtlaspack && (0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context === 'tesseract' && bundle.type === 'js') {
+    // Once this actually does something, the code below will be in an `else` block (i.e. we'll only run one or the other)
+    await rustAtlaspack.package();
+  }
   let {
     devDepRequests,
     configRequests,
@@ -77,11 +90,12 @@ async function run({
         api.invalidateOnOptionChange(invalidation.key);
         break;
       default:
+        // @ts-expect-error TS2339
         throw new Error(`Unknown invalidation type: ${invalidation.type}`);
     }
   }
 
-  // $FlowFixMe[cannot-write] time is marked read-only, but this is the exception
+  // @ts-expect-error TS2540
   bundleInfo.time = Date.now() - start;
   api.storeResult(bundleInfo);
   return bundleInfo;

package/lib/requests/PathRequest.js

@@ -26,6 +26,13 @@ function _logger() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
   _nullthrows = function () {
@@ -50,7 +57,6 @@ function _utils() {
 var _ReporterRunner = require("../ReporterRunner");
 var _Dependency = require("../public/Dependency");
 var _PluginOptions = _interopRequireDefault(require("../public/PluginOptions"));
-var _AtlaspackConfig = require("../AtlaspackConfig");
 var _AtlaspackConfigRequest = _interopRequireWildcard(require("./AtlaspackConfigRequest"));
 var _utils2 = require("../utils");
 var _projectPath = require("../projectPath");
@@ -78,12 +84,16 @@ function createPathRequest(input) {
     input
   };
 }
+
+// @ts-expect-error TS7031
 async function run({
   input,
   api,
   options
 }) {
-  let configResult = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
+  let configResult = (0, _nullthrows().default)(
+  // @ts-expect-error TS2347
+  await api.runRequest((0, _AtlaspackConfigRequest.default)()));
   let config = (0, _AtlaspackConfigRequest.getCachedAtlaspackConfig)(configResult, options);
   let {
     devDeps,
@@ -127,7 +137,7 @@ async function run({
     let err = new (_diagnostic().default)({
       diagnostic: result.diagnostics
     });
-    // $FlowFixMe[prop-missing]
+    // @ts-expect-error TS2339
     err.code = 'MODULE_NOT_FOUND';
     throw err;
   }
@@ -170,26 +180,34 @@ class ResolverRunner {
           plugin: plugin.name,
           searchPath: (0, _projectPath.toProjectPathUnsafe)('index')
         });
+
+        // @ts-expect-error TS2345
         await (0, _ConfigRequest.loadPluginConfig)(plugin, config, this.options);
         configCache.set(plugin.name, config);
+        // @ts-expect-error TS2345
         this.configs.set(plugin.name, config);
       }
       if (config) {
+        // @ts-expect-error TS2339
         for (let devDep of config.devDeps) {
           let devDepRequest = await (0, _DevDepRequest.createDevDependency)(devDep, this.previousDevDeps, this.options);
           this.runDevDepRequest(devDepRequest);
         }
+
+        // @ts-expect-error TS2345
         this.configs.set(plugin.name, config);
       }
     }
   }
   runDevDepRequest(devDepRequest) {
+    // @ts-expect-error TS2339
     if (devDepRequest.type !== 'ref') {
       let {
         specifier,
         resolveFrom
       } = devDepRequest;
       let key = `${specifier}:${(0, _projectPath.fromProjectPathRelative)(resolveFrom)}`;
+      // @ts-expect-error TS2345
       this.devDepRequests.set(key, devDepRequest);
     }
   }
@@ -259,6 +277,9 @@ class ResolverRunner {
           }
           if (result.priority != null) {
             dependency.priority = _types.Priority[result.priority];
+            if ((0, _featureFlags().getFeatureFlag)('hmrImprovements')) {
+              dependency.resolverPriority = dependency.priority;
+            }
           }
           if (result.invalidateOnEnvChange) {
             invalidateOnEnvChange.push(...result.invalidateOnEnvChange);