@atlaspack/core 2.32.0 → 2.33.0

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # @atlaspack/core
 
+## 2.33.0
+
+### Minor Changes
+
+- [#993](https://github.com/atlassian-labs/atlaspack/pull/993) [`e058f0e`](https://github.com/atlassian-labs/atlaspack/commit/e058f0e7a0423ba9373e85a7dbd5c1dd43b47916) Thanks [@matt-koko](https://github.com/matt-koko)! - Add disableCache option to TransformerSetup API
+
+### Patch Changes
+
+- [#998](https://github.com/atlassian-labs/atlaspack/pull/998) [`349b19c`](https://github.com/atlassian-labs/atlaspack/commit/349b19c3aca2ccb1ffb5cdcdc74890f4b62228be) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Add initial native bundler boilerplate and single file bundler
+
+- Updated dependencies [[`e058f0e`](https://github.com/atlassian-labs/atlaspack/commit/e058f0e7a0423ba9373e85a7dbd5c1dd43b47916), [`053e375`](https://github.com/atlassian-labs/atlaspack/commit/053e3754c08c5b5dc239e9f7267df289cbbf31ab), [`25c976e`](https://github.com/atlassian-labs/atlaspack/commit/25c976e01c30e536fb1027eab5b17594c604efff), [`1a86b65`](https://github.com/atlassian-labs/atlaspack/commit/1a86b657868ee881ca5acc68661cca208ac37779), [`349b19c`](https://github.com/atlassian-labs/atlaspack/commit/349b19c3aca2ccb1ffb5cdcdc74890f4b62228be), [`9959efe`](https://github.com/atlassian-labs/atlaspack/commit/9959efe30699a2de3b69275be7ecb47afe81c0b6)]:
+  - @atlaspack/rust@3.22.0
+  - @atlaspack/feature-flags@2.29.0
+  - @atlaspack/fs@2.15.47
+  - @atlaspack/graph@3.6.14
+  - @atlaspack/logger@2.14.44
+  - @atlaspack/plugin@2.14.52
+  - @atlaspack/profiler@2.15.13
+  - @atlaspack/types@2.15.42
+  - @atlaspack/utils@3.3.4
+  - @atlaspack/workers@2.14.52
+  - @atlaspack/cache@3.2.47
+  - @atlaspack/source-map@3.2.7
+  - @atlaspack/build-cache@2.13.10
+  - @atlaspack/package-manager@2.14.52
+
+## 2.32.1
+
+### Patch Changes
+
+- [#988](https://github.com/atlassian-labs/atlaspack/pull/988) [`a631dcd`](https://github.com/atlassian-labs/atlaspack/commit/a631dcd961112db072b0f8de0831efd178f355a7) Thanks [@marcins](https://github.com/marcins)! - Implement a basic package() method for the native packager
+
+- [#990](https://github.com/atlassian-labs/atlaspack/pull/990) [`5755a11`](https://github.com/atlassian-labs/atlaspack/commit/5755a114903bbf660e2ada3ae2e7ff6ceac7565b) Thanks [@vykimnguyen](https://github.com/vykimnguyen)! - changes conditional bundleGraphEdgeType value
+
+- [#987](https://github.com/atlassian-labs/atlaspack/pull/987) [`fcaf517`](https://github.com/atlassian-labs/atlaspack/commit/fcaf517010d15c9300393bcad3f9b465689d9d16) Thanks [@vykimnguyen](https://github.com/vykimnguyen)! - add get_bundle_assets
+
+- Updated dependencies [[`a631dcd`](https://github.com/atlassian-labs/atlaspack/commit/a631dcd961112db072b0f8de0831efd178f355a7), [`e9dce31`](https://github.com/atlassian-labs/atlaspack/commit/e9dce3168a8e6727a994bf2a6ac6041eb29f6027), [`59e1345`](https://github.com/atlassian-labs/atlaspack/commit/59e1345f84f43e0632d434ab42c06bf748241985), [`783118c`](https://github.com/atlassian-labs/atlaspack/commit/783118c772f45a0cf6a3b6b447fb9a0e225b25a6), [`fcaf517`](https://github.com/atlassian-labs/atlaspack/commit/fcaf517010d15c9300393bcad3f9b465689d9d16)]:
+  - @atlaspack/rust@3.21.0
+  - @atlaspack/cache@3.2.46
+  - @atlaspack/fs@2.15.46
+  - @atlaspack/logger@2.14.43
+  - @atlaspack/source-map@3.2.6
+  - @atlaspack/utils@3.3.3
+  - @atlaspack/package-manager@2.14.51
+  - @atlaspack/profiler@2.15.12
+  - @atlaspack/workers@2.14.51
+  - @atlaspack/types@2.15.41
+  - @atlaspack/graph@3.6.13
+  - @atlaspack/plugin@2.14.51
+
 ## 2.32.0
 
 ### Minor Changes

package/dist/BundleGraph.js

@@ -43,7 +43,7 @@ exports.bundleGraphEdgeTypes = {
     internal_async: 5,
     // This type is used to mark an edge between a bundle and a conditional bundle.
     // This allows efficient discovery of conditional bundles in packaging
-    conditional: 5,
+    conditional: 6,
 };
 function makeReadOnlySet(set) {
     return new Proxy(set, {
@@ -383,7 +383,7 @@ class BundleGraph {
     }
     /**
      * Serialize the bundle graph for efficient transfer to native Rust code.
-     * Returns a JSON string of nodes and an array of edges.
+     * Returns a JSON string of nodes, an array of edges, and a map of asset IDs to public IDs.
      */
     serializeForNative() {
         const start = performance.now();
@@ -396,16 +396,58 @@ class BundleGraph {
             edges.push([edge.from, edge.to, edge.type]);
             next = edgeIterator.next();
         }
+        // Extract and deduplicate environments
+        const environmentMap = new Map();
+        const extractEnvironment = (envRef) => {
+            const env = (0, EnvironmentManager_1.fromEnvironmentId)(envRef);
+            const envId = env.id;
+            if (!environmentMap.has(envId)) {
+                environmentMap.set(envId, env);
+            }
+            return envId;
+        };
+        // Replace env objects with env IDs in nodes
+        const processedNodes = nodes.map((node) => {
+            const processedNode = { ...node };
+            if (node.type === 'asset' && node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: extractEnvironment(node.value.env),
+                };
+            }
+            else if (node.type === 'dependency' && node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: extractEnvironment(node.value.env),
+                };
+            }
+            else if (node.type === 'bundle' && node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: extractEnvironment(node.value.env),
+                };
+            }
+            return processedNode;
+        });
         // Optimize nodes by omitting null/undefined values to reduce JSON size
-        const optimizedNodes = nodes.map((node) => this._omitNulls(node));
+        const optimizedNodes = processedNodes.map((node) => this._omitNulls(node));
         const nodesJson = JSON.stringify(optimizedNodes);
+        // Serialize environments as array
+        const environments = Array.from(environmentMap.values());
+        const environmentsJson = JSON.stringify(environments);
+        // Convert Map to plain object for serialization
+        const publicIdByAssetId = {};
+        for (const [assetId, publicId] of this._publicIdByAssetId) {
+            publicIdByAssetId[assetId] = publicId;
+        }
         const duration = performance.now() - start;
-        const sizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+        const nodesSizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+        const envsSizeMB = (environmentsJson.length / (1024 * 1024)).toFixed(2);
         logger_1.default.verbose({
             origin: '@atlaspack/core',
-            message: `serializeForNative: ${duration.toFixed(1)}ms, ${sizeMB}MB JSON, ${nodes.length} nodes, ${edges.length} edges`,
+            message: `serializeForNative: ${duration.toFixed(1)}ms, ${nodesSizeMB}MB nodes, ${envsSizeMB}MB envs (${environmentMap.size} unique), ${nodes.length} nodes, ${edges.length} edges`,
         });
-        return { nodesJson, edges };
+        return { nodesJson, edges, publicIdByAssetId, environmentsJson };
     }
     /**
      * Remove null and undefined values from an object to reduce JSON size.
@@ -1164,8 +1206,36 @@ class BundleGraph {
         });
     }
     /**
-     * TODO: Document why this works like this & why visitor order matters
-     * on these use-cases.
+     * Performs a depth-first traversal of all assets and dependencies contained
+     * within a bundle. Only visits nodes that are directly contained in the bundle
+     * (connected via a `contains` edge).
+     *
+     * Entry Asset Ordering:
+     * The traversal guarantees that entry assets are visited in the exact order they
+     * appear in `bundle.entryAssetIds`. This ordering is critical for several reasons:
+     *
+     * 1. **Code Execution Order in Packagers**: Packagers (ScopeHoistingPackager,
+     *    DevPackager) use this traversal to concatenate assets into the final bundle.
+     *    The traversal order determines the execution order of code in the output.
+     *    Entry assets must be processed in their defined order to ensure correct
+     *    initialization sequences.
+     *
+     * 2. **Runtime Injection**: Runtime assets (HMR, bundle manifests) are prepended
+     *    to `entryAssetIds` via `unshift()` in `applyRuntimes.ts`. By honoring the
+     *    array order, runtimes are guaranteed to be visited (and thus output) before
+     *    application entry points, ensuring the runtime infrastructure is available
+     *    when application code executes.
+     *
+     * 3. **Deterministic Builds**: Consistent traversal order ensures reproducible
+     *    bundle output, which is essential for caching and build verification.
+     *
+     * The sorting only applies at the first traversal level (direct children of the
+     * start node). Subsequent levels follow standard DFS order based on the graph's
+     * edge structure.
+     *
+     * @param bundle - The bundle to traverse
+     * @param visit - Visitor callback receiving asset or dependency nodes
+     * @param startAsset - Optional asset to start traversal from (defaults to bundle root)
      */
     traverseBundle(bundle, visit, startAsset) {
         let entries = !startAsset;

package/dist/atlaspack-v3/AtlaspackV3.js

@@ -51,12 +51,15 @@ class AtlaspackV3 {
     buildAssetGraph() {
         return (0, rust_1.atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
     }
+    buildBundleGraph() {
+        return (0, rust_1.atlaspackNapiBuildBundleGraph)(this._atlaspack_napi);
+    }
     loadBundleGraph(bundleGraph) {
-        const { nodesJson, edges } = bundleGraph.serializeForNative();
-        return (0, rust_1.atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges);
+        const { nodesJson, edges, publicIdByAssetId, environmentsJson } = bundleGraph.serializeForNative();
+        return (0, rust_1.atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges, publicIdByAssetId, environmentsJson);
     }
-    package() {
-        return (0, rust_1.atlaspackNapiPackage)(this._atlaspack_napi);
+    package(bundleId) {
+        return (0, rust_1.atlaspackNapiPackage)(this._atlaspack_napi, bundleId);
     }
     async respondToFsEvents(events) {
         // @ts-expect-error TS2488

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

@@ -355,6 +355,7 @@ class AtlaspackWorker {
                 conditions: setupResult?.conditions,
                 config,
                 env: allowedEnv,
+                disableCache: setupResult?.disableCache,
             };
         }
         __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").set(specifier, {

package/dist/requests/AtlaspackBuildRequest.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = createAtlaspackBuildRequest;
 const BundleGraphRequest_1 = __importDefault(require("./BundleGraphRequest"));
+const BundleGraphRequestRust_1 = __importDefault(require("./BundleGraphRequestRust"));
 const WriteBundlesRequest_1 = __importDefault(require("./WriteBundlesRequest"));
 const utils_1 = require("../utils");
 const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
@@ -27,11 +28,17 @@ function createAtlaspackBuildRequest(input) {
 }
 async function run({ input, api, options, rustAtlaspack, }) {
     let { optionsRef, requestedAssetIds, signal } = input;
-    let bundleGraphRequest = (0, BundleGraphRequest_1.default)({
-        optionsRef,
-        requestedAssetIds,
-        signal,
-    });
+    let bundleGraphRequest = (0, feature_flags_1.getFeatureFlag)('nativeBundling') && rustAtlaspack
+        ? (0, BundleGraphRequestRust_1.default)({
+            optionsRef,
+            requestedAssetIds,
+            signal,
+        })
+        : (0, BundleGraphRequest_1.default)({
+            optionsRef,
+            requestedAssetIds,
+            signal,
+        });
     let { bundleGraph, changedAssets, assetRequests } = await api.runRequest(bundleGraphRequest, {
         force: Boolean(rustAtlaspack) ||
             (options.shouldBuildLazily && requestedAssetIds.size > 0),

package/dist/requests/BundleGraphRequest.js

@@ -39,28 +39,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = createBundleGraphRequest;
 const fs_1 = __importDefault(require("fs"));
 const assert_1 = __importDefault(require("assert"));
-const assert_2 = __importDefault(require("assert"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
 const logger_1 = require("@atlaspack/logger");
 const feature_flags_1 = require("@atlaspack/feature-flags");
 const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
-const BundleGraph_1 = __importDefault(require("../public/BundleGraph"));
-const BundleGraph_2 = __importStar(require("../BundleGraph"));
+const BundleGraph_1 = __importStar(require("../BundleGraph"));
 const MutableBundleGraph_1 = __importDefault(require("../public/MutableBundleGraph"));
-const Bundle_1 = require("../public/Bundle");
 const ReporterRunner_1 = require("../ReporterRunner");
 const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
-const utils_1 = require("@atlaspack/utils");
 const rust_1 = require("@atlaspack/rust");
 const PluginOptions_1 = __importDefault(require("../public/PluginOptions"));
 const applyRuntimes_1 = __importDefault(require("../applyRuntimes"));
 const constants_1 = require("../constants");
-const utils_2 = require("../utils");
+const utils_1 = require("../utils");
 const AtlaspackConfigRequest_1 = __importStar(require("./AtlaspackConfigRequest"));
 const DevDepRequest_1 = require("./DevDepRequest");
-const InternalConfig_1 = require("../InternalConfig");
-const ConfigRequest_1 = require("./ConfigRequest");
 const projectPath_1 = require("../projectPath");
+const BundleGraphRequestUtils_1 = require("./BundleGraphRequestUtils");
 const AssetGraphRequest_1 = __importDefault(require("./AssetGraphRequest"));
 const AssetGraphRequestRust_1 = require("./AssetGraphRequestRust");
 const profiler_1 = require("@atlaspack/profiler");
@@ -151,7 +146,7 @@ function createBundleGraphRequest(input) {
             //   );
             // }
             measurement && measurement.end();
-            (0, utils_2.assertSignalNotAborted)(signal);
+            (0, utils_1.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,
             // which are hoisted to direct invalidations on the bundle graph request.
@@ -164,7 +159,7 @@ function createBundleGraphRequest(input) {
                 assetGraph.setNeedsBundling();
             }
             let configResult = (0, nullthrows_1.default)(await input.api.runRequest((0, AtlaspackConfigRequest_1.default)()));
-            (0, utils_2.assertSignalNotAborted)(signal);
+            (0, utils_1.assertSignalNotAborted)(signal);
             let atlaspackConfig = (0, AtlaspackConfigRequest_1.getCachedAtlaspackConfig)(configResult, input.options);
             let { devDeps, invalidDevDeps } = await (0, DevDepRequest_1.getDevDepRequests)(input.api);
             (0, DevDepRequest_1.invalidateDevDeps)(invalidDevDeps, input.options, atlaspackConfig);
@@ -181,7 +176,7 @@ function createBundleGraphRequest(input) {
             }
             await (0, dumpGraphToGraphViz_1.default)(
             // @ts-expect-error TS2345
-            res.bundleGraph._graph, 'BundleGraph', BundleGraph_2.bundleGraphEdgeTypes);
+            res.bundleGraph._graph, 'BundleGraph', BundleGraph_1.bundleGraphEdgeTypes);
             return res;
         },
         input,
@@ -196,7 +191,7 @@ class BundlerRunner {
         this.previousDevDeps = previousDevDeps;
         this.devDepRequests = new Map();
         this.configs = new Map();
-        this.pluginOptions = new PluginOptions_1.default((0, utils_2.optionsProxy)(this.options, api.invalidateOnOptionChange));
+        this.pluginOptions = new PluginOptions_1.default((0, utils_1.optionsProxy)(this.options, api.invalidateOnOptionChange));
         if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
             const key = (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
             this.cacheKey = `BundleGraph/${constants_1.ATLASPACK_VERSION}/${options.mode}/${key}`;
@@ -220,23 +215,10 @@ class BundlerRunner {
         }
     }
     async loadConfig(plugin) {
-        let config = (0, InternalConfig_1.createConfig)({
-            plugin: plugin.name,
-            searchPath: (0, projectPath_1.toProjectPathUnsafe)('index'),
-        });
-        await (0, ConfigRequest_1.loadPluginConfig)(plugin, config, this.options);
-        await (0, ConfigRequest_1.runConfigRequest)(this.api, config);
-        for (let devDep of config.devDeps) {
-            let devDepRequest = await (0, DevDepRequest_1.createDevDependency)(devDep, this.previousDevDeps, this.options);
-            await this.runDevDepRequest(devDepRequest);
-        }
-        this.configs.set(plugin.name, config);
+        await (0, BundleGraphRequestUtils_1.loadPluginConfigWithDevDeps)(plugin, this.options, this.api, this.previousDevDeps, this.devDepRequests, this.configs);
     }
     async runDevDepRequest(devDepRequest) {
-        let { specifier, resolveFrom } = devDepRequest;
-        let key = `${specifier}:${(0, projectPath_1.fromProjectPathRelative)(resolveFrom)}`;
-        this.devDepRequests.set(key, devDepRequest);
-        await (0, DevDepRequest_1.runDevDepRequest)(this.api, devDepRequest);
+        await (0, BundleGraphRequestUtils_1.runDevDepRequest)(this.api, devDepRequest, this.devDepRequests);
     }
     async bundle({ graph, changedAssets, assetRequests, }) {
         (0, ReporterRunner_1.report)({
@@ -271,11 +253,11 @@ class BundlerRunner {
                 }
             }
             else {
-                internalBundleGraph = BundleGraph_2.default.fromAssetGraph(graph, this.options.mode === 'production');
+                internalBundleGraph = BundleGraph_1.default.fromAssetGraph(graph, this.options.mode === 'production');
                 (0, assert_1.default)(internalBundleGraph != null); // ensures the graph was created
                 await (0, dumpGraphToGraphViz_1.default)(
                 // @ts-expect-error TS2345
-                internalBundleGraph._graph, 'before_bundle', BundleGraph_2.bundleGraphEdgeTypes);
+                internalBundleGraph._graph, 'before_bundle', BundleGraph_1.bundleGraphEdgeTypes);
                 let mutableBundleGraph = new MutableBundleGraph_1.default(internalBundleGraph, this.options);
                 let measurement;
                 let measurementFilename;
@@ -350,7 +332,7 @@ class BundlerRunner {
             if (internalBundleGraph != null) {
                 await (0, dumpGraphToGraphViz_1.default)(
                 // @ts-expect-error TS2345
-                internalBundleGraph._graph, 'after_bundle', BundleGraph_2.bundleGraphEdgeTypes);
+                internalBundleGraph._graph, 'after_bundle', BundleGraph_1.bundleGraphEdgeTypes);
             }
         }
         let changedRuntimes = new Map();
@@ -359,7 +341,7 @@ class BundlerRunner {
             // inline bundles must still be named so the PackagerRunner
             // can match them to the correct packager/optimizer plugins.
             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_1.nameBundle)(namers, bundle, internalBundleGraph, this.options, this.pluginOptions, this.configs)));
             changedRuntimes = await (0, logger_1.instrumentAsync)('applyRuntimes', () => (0, applyRuntimes_1.default)({
                 bundleGraph: internalBundleGraph,
                 api: this.api,
@@ -379,13 +361,13 @@ class BundlerRunner {
                 }, this.previousDevDeps, this.options);
                 await this.runDevDepRequest(devDepRequest);
             }
-            this.validateBundles(internalBundleGraph);
+            (0, BundleGraphRequestUtils_1.validateBundles)(internalBundleGraph);
             // Pre-compute the hashes for each bundle so they are only computed once and shared between workers.
             internalBundleGraph.getBundleGraphHash();
         }
         await (0, dumpGraphToGraphViz_1.default)(
         // @ts-expect-error TS2345
-        internalBundleGraph._graph, 'after_runtimes', BundleGraph_2.bundleGraphEdgeTypes);
+        internalBundleGraph._graph, 'after_runtimes', BundleGraph_1.bundleGraphEdgeTypes);
         this.api.storeResult({
             bundleGraph: internalBundleGraph,
             assetGraphBundlingVersion: graph.getBundlingVersion(),
@@ -399,49 +381,4 @@ class BundlerRunner {
             assetRequests,
         };
     }
-    validateBundles(bundleGraph) {
-        let bundles = bundleGraph.getBundles();
-        let bundleNames = bundles.map((b) => (0, projectPath_1.joinProjectPath)(b.target.distDir, (0, nullthrows_1.default)(b.name)));
-        assert_2.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());
-    }
-    async nameBundle(namers, internalBundle, internalBundleGraph) {
-        let bundle = Bundle_1.Bundle.get(internalBundle, internalBundleGraph, this.options);
-        let bundleGraph = new BundleGraph_1.default(internalBundleGraph, Bundle_1.NamedBundle.get.bind(Bundle_1.NamedBundle), this.options);
-        for (let namer of namers) {
-            let measurement;
-            try {
-                measurement = profiler_1.tracer.createMeasurement(namer.name, 'namer', bundle.id);
-                let name = await namer.plugin.name({
-                    bundle,
-                    bundleGraph,
-                    config: this.configs.get(namer.name)?.result,
-                    options: this.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;
-                    let { 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');
-    }
 }