@atlaspack/core 2.32.1 → 2.33.1

package/dist/requests/BundleGraphRequestUtils.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBundles = validateBundles;
+exports.nameBundle = nameBundle;
+exports.loadPluginConfigWithDevDeps = loadPluginConfigWithDevDeps;
+exports.runDevDepRequest = runDevDepRequest;
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const logger_1 = require("@atlaspack/logger");
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const utils_1 = require("@atlaspack/utils");
+const BundleGraph_1 = __importDefault(require("../public/BundleGraph"));
+const Bundle_1 = require("../public/Bundle");
+const InternalConfig_1 = require("../InternalConfig");
+const DevDepRequest_1 = require("./DevDepRequest");
+const ConfigRequest_1 = require("./ConfigRequest");
+const projectPath_1 = require("../projectPath");
+const profiler_1 = require("@atlaspack/profiler");
+/**
+ * Validates that all bundles have unique names.
+ * Throws an assertion error if duplicate bundle names are found.
+ */
+function validateBundles(bundleGraph) {
+    const bundles = bundleGraph.getBundles();
+    const bundleNames = bundles.map((b) => (0, projectPath_1.joinProjectPath)(b.target.distDir, (0, nullthrows_1.default)(b.name)));
+    assert_1.default.deepEqual(bundleNames, (0, utils_1.unique)(bundleNames), 'Bundles must have unique name. Conflicting names: ' +
+        [
+            ...(0, utils_1.setSymmetricDifference)(new Set(bundleNames), new Set((0, utils_1.unique)(bundleNames))),
+        ].join());
+}
+/**
+ * Names a bundle by running through the configured namers until one returns a name.
+ */
+async function nameBundle(namers, internalBundle, internalBundleGraph, options, pluginOptions, configs) {
+    const bundle = Bundle_1.Bundle.get(internalBundle, internalBundleGraph, options);
+    const bundleGraph = new BundleGraph_1.default(internalBundleGraph, Bundle_1.NamedBundle.get.bind(Bundle_1.NamedBundle), options);
+    for (const namer of namers) {
+        let measurement;
+        try {
+            measurement = profiler_1.tracer.createMeasurement(namer.name, 'namer', bundle.id);
+            const name = await namer.plugin.name({
+                bundle,
+                bundleGraph,
+                config: configs.get(namer.name)?.result,
+                options: pluginOptions,
+                logger: new logger_1.PluginLogger({ origin: namer.name }),
+                tracer: new profiler_1.PluginTracer({ origin: namer.name, category: 'namer' }),
+            });
+            if (name != null) {
+                internalBundle.name = name;
+                const { hashReference } = internalBundle;
+                internalBundle.displayName = name.includes(hashReference)
+                    ? name.replace(hashReference, '[hash]')
+                    : name;
+                return;
+            }
+        }
+        catch (e) {
+            throw new diagnostic_1.default({
+                diagnostic: (0, diagnostic_1.errorToDiagnostic)(e, {
+                    origin: namer.name,
+                }),
+            });
+        }
+        finally {
+            measurement && measurement.end();
+        }
+    }
+    throw new Error('Unable to name bundle');
+}
+/**
+ * Loads configuration for a plugin and tracks its dev dependencies.
+ */
+async function loadPluginConfigWithDevDeps(plugin, options, api, previousDevDeps, devDepRequests, configs) {
+    const config = (0, InternalConfig_1.createConfig)({
+        plugin: plugin.name,
+        searchPath: (0, projectPath_1.toProjectPathUnsafe)('index'),
+    });
+    await (0, ConfigRequest_1.loadPluginConfig)(plugin, config, options);
+    await (0, ConfigRequest_1.runConfigRequest)(api, config);
+    for (const devDep of config.devDeps) {
+        const devDepRequest = await (0, DevDepRequest_1.createDevDependency)(devDep, previousDevDeps, options);
+        await runDevDepRequest(api, devDepRequest, devDepRequests);
+    }
+    configs.set(plugin.name, config);
+}
+/**
+ * Runs a dev dependency request and tracks it in the devDepRequests map.
+ */
+async function runDevDepRequest(api, devDepRequest, devDepRequests) {
+    const { specifier, resolveFrom } = devDepRequest;
+    const key = `${specifier}:${(0, projectPath_1.fromProjectPathRelative)(resolveFrom)}`;
+    devDepRequests.set(key, devDepRequest);
+    await (0, DevDepRequest_1.runDevDepRequest)(api, devDepRequest);
+}

package/lib/atlaspack-v3/AtlaspackV3.js

@@ -72,6 +72,9 @@ class AtlaspackV3 {
   buildAssetGraph() {
     return (0, _rust().atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
   }
+  buildBundleGraph() {
+    return (0, _rust().atlaspackNapiBuildBundleGraph)(this._atlaspack_napi);
+  }
   loadBundleGraph(bundleGraph) {
     const {
       nodesJson,

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

@@ -381,7 +381,8 @@ class AtlaspackWorker {
       setup = {
         conditions: setupResult === null || setupResult === void 0 ? void 0 : setupResult.conditions,
         config,
-        env: allowedEnv
+        env: allowedEnv,
+        disableCache: setupResult === null || setupResult === void 0 ? void 0 : setupResult.disableCache
       };
     }
     this.#transformers.set(specifier, {

package/lib/requests/AtlaspackBuildRequest.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = createAtlaspackBuildRequest;
 var _BundleGraphRequest = _interopRequireDefault(require("./BundleGraphRequest"));
+var _BundleGraphRequestRust = _interopRequireDefault(require("./BundleGraphRequestRust"));
 var _WriteBundlesRequest = _interopRequireDefault(require("./WriteBundlesRequest"));
 var _utils = require("../utils");
 var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
@@ -49,7 +50,11 @@ async function run({
     requestedAssetIds,
     signal
   } = input;
-  let bundleGraphRequest = (0, _BundleGraphRequest.default)({
+  let bundleGraphRequest = (0, _featureFlags().getFeatureFlag)('nativeBundling') && rustAtlaspack ? (0, _BundleGraphRequestRust.default)({
+    optionsRef,
+    requestedAssetIds,
+    signal
+  }) : (0, _BundleGraphRequest.default)({
     optionsRef,
     requestedAssetIds,
     signal

package/lib/requests/BundleGraphRequest.js

@@ -46,19 +46,10 @@ function _diagnostic() {
   };
   return data;
 }
-var _BundleGraph = _interopRequireDefault(require("../public/BundleGraph"));
-var _BundleGraph2 = _interopRequireWildcard(require("../BundleGraph"));
+var _BundleGraph = _interopRequireWildcard(require("../BundleGraph"));
 var _MutableBundleGraph = _interopRequireDefault(require("../public/MutableBundleGraph"));
-var _Bundle = require("../public/Bundle");
 var _ReporterRunner = require("../ReporterRunner");
 var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
 function _rust() {
   const data = require("@atlaspack/rust");
   _rust = function () {
@@ -69,12 +60,11 @@ function _rust() {
 var _PluginOptions = _interopRequireDefault(require("../public/PluginOptions"));
 var _applyRuntimes = _interopRequireDefault(require("../applyRuntimes"));
 var _constants = require("../constants");
-var _utils2 = require("../utils");
+var _utils = require("../utils");
 var _AtlaspackConfigRequest = _interopRequireWildcard(require("./AtlaspackConfigRequest"));
 var _DevDepRequest = require("./DevDepRequest");
-var _InternalConfig = require("../InternalConfig");
-var _ConfigRequest = require("./ConfigRequest");
 var _projectPath = require("../projectPath");
+var _BundleGraphRequestUtils = require("./BundleGraphRequestUtils");
 var _AssetGraphRequest = _interopRequireDefault(require("./AssetGraphRequest"));
 var _AssetGraphRequestRust = require("./AssetGraphRequestRust");
 function _profiler() {
@@ -188,7 +178,7 @@ function createBundleGraphRequest(input) {
       // }
 
       measurement && measurement.end();
-      (0, _utils2.assertSignalNotAborted)(signal);
+      (0, _utils.assertSignalNotAborted)(signal);
 
       // If any subrequests are invalid (e.g. dev dep requests or config requests),
       // bail on incremental bundling. We also need to invalidate for option changes,
@@ -199,7 +189,7 @@ function createBundleGraphRequest(input) {
         assetGraph.setNeedsBundling();
       }
       let configResult = (0, _nullthrows().default)(await input.api.runRequest((0, _AtlaspackConfigRequest.default)()));
-      (0, _utils2.assertSignalNotAborted)(signal);
+      (0, _utils.assertSignalNotAborted)(signal);
       let atlaspackConfig = (0, _AtlaspackConfigRequest.getCachedAtlaspackConfig)(configResult, input.options);
       let {
         devDeps,
@@ -219,7 +209,7 @@ function createBundleGraphRequest(input) {
       }
       await (0, _dumpGraphToGraphViz.default)(
       // @ts-expect-error TS2345
-      res.bundleGraph._graph, 'BundleGraph', _BundleGraph2.bundleGraphEdgeTypes);
+      res.bundleGraph._graph, 'BundleGraph', _BundleGraph.bundleGraphEdgeTypes);
       return res;
     },
     input
@@ -238,7 +228,7 @@ class BundlerRunner {
     this.previousDevDeps = previousDevDeps;
     this.devDepRequests = new Map();
     this.configs = new Map();
-    this.pluginOptions = new _PluginOptions.default((0, _utils2.optionsProxy)(this.options, api.invalidateOnOptionChange));
+    this.pluginOptions = new _PluginOptions.default((0, _utils.optionsProxy)(this.options, api.invalidateOnOptionChange));
     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}`;
@@ -260,26 +250,10 @@ class BundlerRunner {
     }
   }
   async loadConfig(plugin) {
-    let config = (0, _InternalConfig.createConfig)({
-      plugin: plugin.name,
-      searchPath: (0, _projectPath.toProjectPathUnsafe)('index')
-    });
-    await (0, _ConfigRequest.loadPluginConfig)(plugin, config, this.options);
-    await (0, _ConfigRequest.runConfigRequest)(this.api, config);
-    for (let devDep of config.devDeps) {
-      let devDepRequest = await (0, _DevDepRequest.createDevDependency)(devDep, this.previousDevDeps, this.options);
-      await this.runDevDepRequest(devDepRequest);
-    }
-    this.configs.set(plugin.name, config);
+    await (0, _BundleGraphRequestUtils.loadPluginConfigWithDevDeps)(plugin, this.options, this.api, this.previousDevDeps, this.devDepRequests, this.configs);
   }
   async runDevDepRequest(devDepRequest) {
-    let {
-      specifier,
-      resolveFrom
-    } = devDepRequest;
-    let key = `${specifier}:${(0, _projectPath.fromProjectPathRelative)(resolveFrom)}`;
-    this.devDepRequests.set(key, devDepRequest);
-    await (0, _DevDepRequest.runDevDepRequest)(this.api, devDepRequest);
+    await (0, _BundleGraphRequestUtils.runDevDepRequest)(this.api, devDepRequest, this.devDepRequests);
   }
   async bundle({
     graph,
@@ -324,12 +298,12 @@ class BundlerRunner {
         }
       } else {
         var _this$configs$get;
-        internalBundleGraph = _BundleGraph2.default.fromAssetGraph(graph, this.options.mode === 'production');
+        internalBundleGraph = _BundleGraph.default.fromAssetGraph(graph, this.options.mode === 'production');
         (0, _assert().default)(internalBundleGraph != null); // ensures the graph was created
 
         await (0, _dumpGraphToGraphViz.default)(
         // @ts-expect-error TS2345
-        internalBundleGraph._graph, 'before_bundle', _BundleGraph2.bundleGraphEdgeTypes);
+        internalBundleGraph._graph, 'before_bundle', _BundleGraph.bundleGraphEdgeTypes);
         let mutableBundleGraph = new _MutableBundleGraph.default(internalBundleGraph, this.options);
         let measurement;
         let measurementFilename;
@@ -400,7 +374,7 @@ class BundlerRunner {
       if (internalBundleGraph != null) {
         await (0, _dumpGraphToGraphViz.default)(
         // @ts-expect-error TS2345
-        internalBundleGraph._graph, 'after_bundle', _BundleGraph2.bundleGraphEdgeTypes);
+        internalBundleGraph._graph, 'after_bundle', _BundleGraph.bundleGraphEdgeTypes);
       }
     }
     let changedRuntimes = new Map();
@@ -411,7 +385,7 @@ class BundlerRunner {
       let bundles = internalBundleGraph.getBundles({
         includeInline: true
       });
-      await Promise.all(bundles.map(bundle => this.nameBundle(namers, bundle, internalBundleGraph)));
+      await Promise.all(bundles.map(bundle => (0, _BundleGraphRequestUtils.nameBundle)(namers, bundle, internalBundleGraph, this.options, this.pluginOptions, this.configs)));
       changedRuntimes = await (0, _logger().instrumentAsync)('applyRuntimes', () => (0, _applyRuntimes.default)({
         bundleGraph: internalBundleGraph,
         api: this.api,
@@ -432,14 +406,14 @@ class BundlerRunner {
         }, this.previousDevDeps, this.options);
         await this.runDevDepRequest(devDepRequest);
       }
-      this.validateBundles(internalBundleGraph);
+      (0, _BundleGraphRequestUtils.validateBundles)(internalBundleGraph);
 
       // Pre-compute the hashes for each bundle so they are only computed once and shared between workers.
       internalBundleGraph.getBundleGraphHash();
     }
     await (0, _dumpGraphToGraphViz.default)(
     // @ts-expect-error TS2345
-    internalBundleGraph._graph, 'after_runtimes', _BundleGraph2.bundleGraphEdgeTypes);
+    internalBundleGraph._graph, 'after_runtimes', _BundleGraph.bundleGraphEdgeTypes);
     this.api.storeResult({
       bundleGraph: internalBundleGraph,
       assetGraphBundlingVersion: graph.getBundlingVersion(),
@@ -453,50 +427,4 @@ class BundlerRunner {
       assetRequests
     };
   }
-  validateBundles(bundleGraph) {
-    let bundles = bundleGraph.getBundles();
-    let bundleNames = bundles.map(b => (0, _projectPath.joinProjectPath)(b.target.distDir, (0, _nullthrows().default)(b.name)));
-    _assert().default.deepEqual(bundleNames, (0, _utils().unique)(bundleNames), 'Bundles must have unique name. Conflicting names: ' + [...(0, _utils().setSymmetricDifference)(new Set(bundleNames), new Set((0, _utils().unique)(bundleNames)))].join());
-  }
-  async nameBundle(namers, internalBundle, internalBundleGraph) {
-    let bundle = _Bundle.Bundle.get(internalBundle, internalBundleGraph, this.options);
-    let bundleGraph = new _BundleGraph.default(internalBundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), this.options);
-    for (let namer of namers) {
-      let measurement;
-      try {
-        var _this$configs$get3;
-        measurement = _profiler().tracer.createMeasurement(namer.name, 'namer', bundle.id);
-        let name = await namer.plugin.name({
-          bundle,
-          bundleGraph,
-          config: (_this$configs$get3 = this.configs.get(namer.name)) === null || _this$configs$get3 === void 0 ? void 0 : _this$configs$get3.result,
-          options: this.pluginOptions,
-          logger: new (_logger().PluginLogger)({
-            origin: namer.name
-          }),
-          tracer: new (_profiler().PluginTracer)({
-            origin: namer.name,
-            category: 'namer'
-          })
-        });
-        if (name != null) {
-          internalBundle.name = name;
-          let {
-            hashReference
-          } = internalBundle;
-          internalBundle.displayName = name.includes(hashReference) ? name.replace(hashReference, '[hash]') : name;
-          return;
-        }
-      } catch (e) {
-        throw new (_diagnostic().default)({
-          diagnostic: (0, _diagnostic().errorToDiagnostic)(e, {
-            origin: namer.name
-          })
-        });
-      } finally {
-        measurement && measurement.end();
-      }
-    }
-    throw new Error('Unable to name bundle');
-  }
 }