@atlaspack/core 2.33.1 → 2.35.0

package/dist/atlaspack-v3/AtlaspackV3.js

@@ -58,8 +58,12 @@ class AtlaspackV3 {
         const { nodesJson, edges, publicIdByAssetId, environmentsJson } = bundleGraph.serializeForNative();
         return (0, rust_1.atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges, publicIdByAssetId, environmentsJson);
     }
-    package(bundleId) {
-        return (0, rust_1.atlaspackNapiPackage)(this._atlaspack_napi, bundleId);
+    updateBundleGraph(bundleGraph, changedAssetIds) {
+        const nodesJson = bundleGraph.serializeAssetNodesForNative(changedAssetIds);
+        return (0, rust_1.atlaspackNapiUpdateBundleGraph)(this._atlaspack_napi, nodesJson);
+    }
+    package(bundleId, options) {
+        return (0, rust_1.atlaspackNapiPackage)(this._atlaspack_napi, bundleId, options);
     }
     async respondToFsEvents(events) {
         // @ts-expect-error TS2488

package/dist/requests/AssetGraphRequest.js

@@ -8,7 +8,6 @@ exports.default = createAssetGraphRequest;
 const logger_1 = __importDefault(require("@atlaspack/logger"));
 const assert_1 = __importDefault(require("assert"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
-const feature_flags_1 = require("@atlaspack/feature-flags");
 const utils_1 = require("@atlaspack/utils");
 const rust_1 = require("@atlaspack/rust");
 const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
@@ -32,8 +31,10 @@ function createAssetGraphRequest(requestInput) {
             let builder = new AssetGraphBuilder(input, prevResult);
             let assetGraphRequest = await builder.build();
             // early break for incremental bundling if production or flag is off;
-            assetGraphRequest.assetGraph.setDisableIncrementalBundling(!input.options.shouldBundleIncrementally ||
-                input.options.mode === 'production');
+            if (!input.options.shouldBundleIncrementally ||
+                input.options.mode === 'production') {
+                assetGraphRequest.assetGraph.safeToIncrementallyBundle = false;
+            }
             if (!input.options.shouldBundleIncrementally ||
                 input.options.mode === 'production') {
                 assetGraphRequest.assetGraph.safeToIncrementallyBundle = false;
@@ -77,14 +78,8 @@ class AssetGraphBuilder {
         this.lazyIncludes = lazyIncludes ?? [];
         this.lazyExcludes = lazyExcludes ?? [];
         this.skipSymbolProp = input.skipSymbolProp ?? false;
-        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-            const key = (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
-            this.cacheKey = `AssetGraph/${constants_1.ATLASPACK_VERSION}/${options.mode}/${key}`;
-        }
-        else {
-            this.cacheKey =
-                (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-AssetGraph';
-        }
+        this.cacheKey =
+            (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-AssetGraph';
         this.isSingleChangeRebuild =
             api
                 .getInvalidSubRequests()
@@ -357,7 +352,6 @@ class AssetGraphBuilder {
                 prevEntries.every((entryId, index) => entryId === currentEntries[index]);
             if (didEntriesChange) {
                 this.assetGraph.safeToIncrementallyBundle = false;
-                this.assetGraph.setNeedsBundling();
             }
         }
     }
@@ -399,13 +393,11 @@ class AssetGraphBuilder {
                         (0, assert_1.default)(otherAsset.type === 'asset');
                         if (!this._areDependenciesEqualForAssets(asset, otherAsset.value)) {
                             this.assetGraph.safeToIncrementallyBundle = false;
-                            this.assetGraph.setNeedsBundling();
                         }
                     }
                     else {
                         // adding a new entry or dependency
                         this.assetGraph.safeToIncrementallyBundle = false;
-                        this.assetGraph.setNeedsBundling();
                     }
                 }
                 this.changedAssets.set(asset.id, asset);
@@ -415,7 +407,6 @@ class AssetGraphBuilder {
         }
         else {
             this.assetGraph.safeToIncrementallyBundle = false;
-            this.assetGraph.setNeedsBundling();
         }
         this.isSingleChangeRebuild = false;
     }

package/dist/requests/AssetGraphRequestRust.js

@@ -1,4 +1,37 @@
 "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 };
 };
@@ -7,7 +40,7 @@ exports.createAssetGraphRequestRust = createAssetGraphRequestRust;
 exports.getAssetGraph = getAssetGraph;
 const assert_1 = __importDefault(require("assert"));
 const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
-const logger_1 = require("@atlaspack/logger");
+const logger_1 = __importStar(require("@atlaspack/logger"));
 const feature_flags_1 = require("@atlaspack/feature-flags");
 const AssetGraph_1 = __importDefault(require("../AssetGraph"));
 const RequestTracker_1 = require("../RequestTracker");
@@ -20,8 +53,8 @@ function createAssetGraphRequestRust(rustAtlaspack) {
     return (input) => ({
         type: RequestTracker_1.requestTypes.asset_graph_request,
         id: input.name,
-        run: async (input) => {
-            let options = input.options;
+        run: async (runInput) => {
+            let options = runInput.options;
             let { assetGraphPromise, commitPromise } = await rustAtlaspack.buildAssetGraph();
             let [serializedAssetGraph, assetGraphError] = (await assetGraphPromise);
             if (assetGraphError) {
@@ -33,23 +66,32 @@ function createAssetGraphRequestRust(rustAtlaspack) {
             let prevResult = null;
             if (serializedAssetGraph.hadPreviousGraph) {
                 prevResult =
-                    await input.api.getPreviousResult();
+                    await runInput.api.getPreviousResult();
             }
             let { assetGraph, changedAssets } = (0, logger_1.instrument)('atlaspack_v3_getAssetGraph', () => getAssetGraph(serializedAssetGraph, prevResult?.assetGraph));
             let changedAssetsPropagation = new Set(changedAssets.keys());
-            let errors = (0, SymbolPropagation_1.propagateSymbols)({
-                options,
-                assetGraph,
-                changedAssetsPropagation,
-                assetGroupsWithRemovedParents: new Set(),
-                previousErrors: new Map(), //this.previousSymbolPropagationErrors,
-            });
-            if (errors.size > 0) {
-                // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
-                // determining which failing export is the root cause is nontrivial (because of circular dependencies).
-                throw new diagnostic_1.default({
-                    diagnostic: [...errors.values()][0],
+            // Skip symbol propagation for runtime assets - they have pre-computed symbol data
+            if (input.skipSymbolProp) {
+                logger_1.default.verbose({
+                    origin: '@atlaspack/core',
+                    message: 'Skipping symbol propagation for runtime asset graph',
+                });
+            }
+            else {
+                let errors = (0, SymbolPropagation_1.propagateSymbols)({
+                    options,
+                    assetGraph,
+                    changedAssetsPropagation,
+                    assetGroupsWithRemovedParents: new Set(),
+                    previousErrors: new Map(), //this.previousSymbolPropagationErrors,
                 });
+                if (errors.size > 0) {
+                    // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
+                    // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+                    throw new diagnostic_1.default({
+                        diagnostic: [...errors.values()][0],
+                    });
+                }
             }
             await (0, dumpGraphToGraphViz_1.default)(assetGraph, 'AssetGraphV3');
             let result = {
@@ -68,8 +110,8 @@ function createAssetGraphRequestRust(rustAtlaspack) {
                     },
                 });
             }
-            await input.api.storeResult(result);
-            input.api.invalidateOnBuild();
+            await runInput.api.storeResult(result);
+            runInput.api.invalidateOnBuild();
             return result;
         },
         input,
@@ -161,14 +203,58 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
         }
         return envId;
     };
-    function updateNode(newNode, isUpdateNode) {
+    function describeNode(node) {
+        const base = { type: node.type, id: node.id };
+        if (node.type === 'asset') {
+            return {
+                ...base,
+                filePath: node.value.filePath,
+                fileType: node.value.type,
+                pipeline: node.value.pipeline,
+            };
+        }
+        else if (node.type === 'dependency') {
+            return {
+                ...base,
+                specifier: node.value.specifier,
+                specifierType: node.value.specifierType,
+                sourceAssetId: node.value.sourceAssetId,
+                sourcePath: node.value.sourcePath,
+            };
+        }
+        return base;
+    }
+    function updateNode(newNode, isUpdateNode, index) {
         if (isUpdateNode) {
             let existingNode = graph.getNodeByContentKey(newNode.id);
             (0, assert_2.default)(existingNode && existingNode.type === newNode.type);
             Object.assign(existingNode, newNode);
         }
         else {
-            graph.addNodeByContentKey(newNode.id, newNode);
+            try {
+                graph.addNodeByContentKey(newNode.id, newNode);
+            }
+            catch (e) {
+                if (e instanceof Error &&
+                    e.message.includes('already has content key')) {
+                    let existingNode = graph.getNodeByContentKey(newNode.id);
+                    let diagnostics = {
+                        contentKey: newNode.id,
+                        newNode: describeNode(newNode),
+                        existingNode: existingNode ? describeNode(existingNode) : null,
+                        iterationIndex: index,
+                        totalSerializedNodes: nodesCount,
+                        newNodesCount: serializedGraph.nodes.length,
+                        updatesCount: serializedGraph.updates.length,
+                        edgesCount: serializedGraph.edges.length,
+                        hadPreviousGraph: !!prevAssetGraph,
+                        safeToSkipBundling: serializedGraph.safeToSkipBundling,
+                        graphNodeCount: graph._contentKeyToNodeId.size,
+                    };
+                    throw new Error(`Graph already has content key '${newNode.id}'. Diagnostics: ${JSON.stringify(diagnostics, null, 2)}`);
+                }
+                throw e;
+            }
         }
     }
     let nodeTypeSwitchoverIndex = serializedGraph.nodes.length;
@@ -215,7 +301,7 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
                 usedSymbolsUpDirty: true,
                 value: asset,
             };
-            updateNode(assetNode, isUpdateNode);
+            updateNode(assetNode, isUpdateNode, index);
         }
         else if (node.type === 'dependency') {
             let { dependency, id } = node.value;
@@ -230,6 +316,17 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
             }
             let usedSymbolsDown = new Set();
             let usedSymbolsUp = new Map();
+            if (node.used_symbols_up) {
+                for (let usedSymbol of node.used_symbols_up) {
+                    // Transform Rust UsedSymbol { symbol: Symbol, asset: string, resolved_symbol: string }
+                    // to JS format { symbol: string, asset: string } where symbol is the resolved name
+                    const exportedName = usedSymbol.symbol.exported;
+                    usedSymbolsUp.set(exportedName, {
+                        asset: usedSymbol.asset,
+                        symbol: usedSymbol.resolved_symbol ?? exportedName,
+                    });
+                }
+            }
             if (dependency.isEntry && dependency.isLibrary) {
                 usedSymbolsDown.add('*');
                 usedSymbolsUp.set('*', undefined);
@@ -248,7 +345,7 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
                 usedSymbolsUpDirtyUp: true,
                 value: dependency,
             };
-            updateNode(depNode, isUpdateNode);
+            updateNode(depNode, isUpdateNode, index);
         }
     }
     if (!reuseEdges) {

package/dist/requests/AtlaspackBuildRequest.js

@@ -39,7 +39,7 @@ async function run({ input, api, options, rustAtlaspack, }) {
             requestedAssetIds,
             signal,
         });
-    let { bundleGraph, changedAssets, assetRequests } = await api.runRequest(bundleGraphRequest, {
+    let { bundleGraph, changedAssets, assetRequests, didIncrementallyBundle, } = await api.runRequest(bundleGraphRequest, {
         force: Boolean(rustAtlaspack) ||
             (options.shouldBuildLazily && requestedAssetIds.size > 0),
     });
@@ -55,7 +55,13 @@ async function run({ input, api, options, rustAtlaspack, }) {
             }
         });
         if (hasSupportedTarget) {
-            await rustAtlaspack.loadBundleGraph(bundleGraph);
+            if (didIncrementallyBundle) {
+                const changedAssetIds = Array.from(changedAssets.keys());
+                await rustAtlaspack.updateBundleGraph(bundleGraph, changedAssetIds);
+            }
+            else {
+                await rustAtlaspack.loadBundleGraph(bundleGraph);
+            }
         }
     }
     // @ts-expect-error TS2345

package/dist/requests/BundleGraphRequest.js

@@ -110,6 +110,7 @@ function createBundleGraphRequest(input) {
                 lazyIncludes: options.lazyIncludes,
                 lazyExcludes: options.lazyExcludes,
                 requestedAssetIds,
+                skipSymbolProp: (0, feature_flags_1.getFeatureFlag)('rustSymbolTracker'),
             });
             let { assetGraph, changedAssets, assetRequests } = await (0, logger_1.instrumentAsync)('asset-graph-request', () => {
                 return api.runRequest(request, {
@@ -156,7 +157,6 @@ function createBundleGraphRequest(input) {
                     .some((req) => !input.api.canSkipSubrequest(req.id));
             if (subRequestsInvalid) {
                 assetGraph.safeToIncrementallyBundle = false;
-                assetGraph.setNeedsBundling();
             }
             let configResult = (0, nullthrows_1.default)(await input.api.runRequest((0, AtlaspackConfigRequest_1.default)()));
             (0, utils_1.assertSignalNotAborted)(signal);
@@ -192,14 +192,8 @@ class BundlerRunner {
         this.devDepRequests = new Map();
         this.configs = new Map();
         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}`;
-        }
-        else {
-            this.cacheKey =
-                (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-BundleGraph';
-        }
+        this.cacheKey =
+            (0, rust_1.hashString)(`${constants_1.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
@@ -225,16 +219,15 @@ class BundlerRunner {
             type: 'buildProgress',
             phase: 'bundling',
         });
+        let didIncrementallyBundle = false;
         await this.loadConfigs();
         let plugin = await this.config.getBundler();
         let { plugin: bundler, name, resolveFrom } = plugin;
         // if a previous asset graph hash is passed in, check if the bundle graph is also available
         const previousBundleGraphResult = await this.api.getPreviousResult();
-        const canIncrementallyBundle = previousBundleGraphResult?.assetGraphBundlingVersion != null &&
-            graph.canIncrementallyBundle(previousBundleGraphResult.assetGraphBundlingVersion);
+        const canIncrementallyBundle = previousBundleGraphResult != null && graph.canIncrementallyBundle();
         if (graph.safeToIncrementallyBundle && previousBundleGraphResult == null) {
             graph.safeToIncrementallyBundle = false;
-            graph.setNeedsBundling();
         }
         let internalBundleGraph;
         let logger = new logger_1.PluginLogger({ origin: name });
@@ -251,6 +244,7 @@ class BundlerRunner {
                     (0, assert_1.default)(changedAssetNode.type === 'asset');
                     internalBundleGraph.updateAsset(changedAssetNode);
                 }
+                didIncrementallyBundle = true;
             }
             else {
                 internalBundleGraph = BundleGraph_1.default.fromAssetGraph(graph, this.options.mode === 'production');
@@ -317,9 +311,9 @@ class BundlerRunner {
             if (internalBundleGraph != null) {
                 this.api.storeResult({
                     bundleGraph: internalBundleGraph,
-                    assetGraphBundlingVersion: graph.getBundlingVersion(),
                     changedAssets: new Map(),
                     assetRequests: [],
+                    didIncrementallyBundle,
                 }, this.cacheKey);
             }
             throw new diagnostic_1.default({
@@ -370,15 +364,15 @@ class BundlerRunner {
         internalBundleGraph._graph, 'after_runtimes', BundleGraph_1.bundleGraphEdgeTypes);
         this.api.storeResult({
             bundleGraph: internalBundleGraph,
-            assetGraphBundlingVersion: graph.getBundlingVersion(),
             changedAssets: new Map(),
             assetRequests: [],
+            didIncrementallyBundle,
         }, this.cacheKey);
         return {
             bundleGraph: internalBundleGraph,
-            assetGraphBundlingVersion: graph.getBundlingVersion(),
             changedAssets: changedRuntimes,
             assetRequests,
+            didIncrementallyBundle,
         };
     }
 }

package/dist/requests/BundleGraphRequestRust.js

@@ -112,10 +112,9 @@ function createBundleGraphRequestRust(input) {
             }
             return {
                 bundleGraph,
-                // Not accurate yet — ok for now.
-                assetGraphBundlingVersion: 0,
                 changedAssets: changedRuntimes,
                 assetRequests: [],
+                didIncrementallyBundle: false,
             };
         },
         input,

package/dist/requests/PackageRequest.js

@@ -34,7 +34,7 @@ async function run({ input, api, farm, rustAtlaspack }) {
         (0, EnvironmentManager_1.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)
-        let result = await rustAtlaspack.package(bundle.id);
+        let result = await rustAtlaspack.package(bundle.id, { inlineRequires: true });
         let error = null;
         [packagingResult, error] = result;
         if (error) {

package/dist/requests/TargetRequest.js

@@ -227,6 +227,7 @@ class TargetResolver {
                         distDir: (0, projectPath_1.toProjectPath)(this.options.projectRoot, path_1.default.resolve(this.fs.cwd(), distDir)),
                         publicUrl: descriptor.publicUrl ??
                             this.options.defaultTargetOptions.publicUrl,
+                        inlineRequires: descriptor.inlineRequires ?? false,
                         env: (0, Environment_1.createEnvironment)({
                             engines: descriptor.engines,
                             context: descriptor.context,
@@ -299,6 +300,7 @@ class TargetResolver {
                         name: 'default',
                         distDir: (0, projectPath_1.toProjectPath)(this.options.projectRoot, this.options.serveOptions.distDir),
                         publicUrl: this.options.defaultTargetOptions.publicUrl ?? '/',
+                        inlineRequires: false,
                         env: (0, Environment_1.createEnvironment)({
                             context: 'browser',
                             engines: {
@@ -705,6 +707,7 @@ class TargetResolver {
                     distDir,
                     distEntry,
                     publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+                    inlineRequires: descriptor.inlineRequires ?? false,
                     env: (0, Environment_1.createEnvironment)({
                         engines: descriptor.engines ?? pkgEngines,
                         // @ts-expect-error TS2322
@@ -870,6 +873,7 @@ class TargetResolver {
                         : distDir),
                     distEntry,
                     publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+                    inlineRequires: descriptor.inlineRequires ?? false,
                     env: (0, Environment_1.createEnvironment)({
                         engines: descriptor.engines ?? pkgEngines,
                         context: descriptor.context,
@@ -932,6 +936,7 @@ class TargetResolver {
                 distDir: this.options.defaultTargetOptions.distDir ??
                     (0, projectPath_1.toProjectPath)(this.options.projectRoot, path_1.default.join(pkgDir, DEFAULT_DIST_DIRNAME)),
                 publicUrl: this.options.defaultTargetOptions.publicUrl,
+                inlineRequires: false,
                 env: (0, Environment_1.createEnvironment)({
                     engines: pkgEngines,
                     // @ts-expect-error TS2322