@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/dist/requests/BundleGraphRequest.js

@@ -0,0 +1,381 @@
+"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.default = createBundleGraphRequest;
+const fs_1 = __importDefault(require("fs"));
+const assert_1 = __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 = __importStar(require("../BundleGraph"));
+const MutableBundleGraph_1 = __importDefault(require("../public/MutableBundleGraph"));
+const ReporterRunner_1 = require("../ReporterRunner");
+const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
+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_1 = require("../utils");
+const AtlaspackConfigRequest_1 = __importStar(require("./AtlaspackConfigRequest"));
+const DevDepRequest_1 = require("./DevDepRequest");
+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");
+const RequestTracker_1 = require("../RequestTracker");
+const asset_graph_dot_1 = require("./asset-graph-dot");
+const types_1 = require("../types");
+function applySideEffectsForLoadableImports(assetGraph) {
+    // Avoid revisiting nodes
+    let updatedAssetIds = new Set();
+    assetGraph.traverse((nodeId) => {
+        let node = (0, nullthrows_1.default)(assetGraph.getNode(nodeId));
+        if (node.type !== 'dependency' ||
+            node.value.specifier.indexOf('@confluence/loadable') === -1) {
+            return;
+        }
+        assetGraph.traverseAncestors(nodeId, (ancestorNodeId, _, actions) => {
+            if (updatedAssetIds.has(ancestorNodeId)) {
+                actions.skipChildren();
+                return;
+            }
+            let ancestorNode = (0, nullthrows_1.default)(assetGraph.getNode(ancestorNodeId));
+            // Async boundaries will catch the side effects
+            if (ancestorNode.type === 'dependency' &&
+                ancestorNode.value.priority !== types_1.Priority.sync) {
+                actions.skipChildren();
+            }
+            // inline-requires optimizer is only checking assets
+            if (ancestorNode.type !== 'asset') {
+                return;
+            }
+            updatedAssetIds.add(ancestorNodeId);
+            ancestorNode.value.sideEffects = true;
+        });
+    }, assetGraph.rootNodeId);
+}
+function createBundleGraphRequest(input) {
+    return {
+        type: RequestTracker_1.requestTypes.bundle_graph_request,
+        id: 'BundleGraph',
+        run: async (input) => {
+            let { options, api, invalidateReason } = input;
+            let { optionsRef, requestedAssetIds, signal } = input.input;
+            let measurement = profiler_1.tracer.createMeasurement('building');
+            let createAssetGraphRequest = (0, feature_flags_1.getFeatureFlag)('atlaspackV3') && input.rustAtlaspack
+                ? (0, AssetGraphRequestRust_1.createAssetGraphRequestRust)(input.rustAtlaspack)
+                : AssetGraphRequest_1.default;
+            let request = createAssetGraphRequest({
+                name: 'Main',
+                entries: options.entries,
+                optionsRef,
+                shouldBuildLazily: options.shouldBuildLazily,
+                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, {
+                    force: Boolean(input.rustAtlaspack) ||
+                        (options.shouldBuildLazily && requestedAssetIds.size > 0),
+                });
+            });
+            if (input.options.featureFlags?.loadableSideEffects) {
+                applySideEffectsForLoadableImports(assetGraph);
+            }
+            let debugAssetGraphDotPath = (0, asset_graph_dot_1.getDebugAssetGraphDotPath)();
+            if (debugAssetGraphDotPath !== null) {
+                await fs_1.default.promises.writeFile(debugAssetGraphDotPath, (0, asset_graph_dot_1.assetGraphToDot)(assetGraph, (0, asset_graph_dot_1.getDebugAssetGraphDotOptions)()), 'utf8');
+            }
+            // if (input.rustAtlaspack && process.env.NATIVE_COMPARE === 'true') {
+            //   let {assetGraph: jsAssetGraph} = await api.runRequest(
+            //     createAssetGraphRequestJS({
+            //       name: 'Main',
+            //       entries: options.entries,
+            //       optionsRef,
+            //       shouldBuildLazily: options.shouldBuildLazily,
+            //       lazyIncludes: options.lazyIncludes,
+            //       lazyExcludes: options.lazyExcludes,
+            //       requestedAssetIds,
+            //     }),
+            //     {
+            //       force: true,
+            //     },
+            //   );
+            //   require('./asset-graph-diff.ts')(
+            //     jsAssetGraph,
+            //     assetGraph,
+            //     options.projectRoot,
+            //   );
+            // }
+            measurement && measurement.end();
+            (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.
+            let subRequestsInvalid = Boolean(invalidateReason & constants_1.OPTION_CHANGE) ||
+                input.api
+                    .getSubRequests()
+                    .some((req) => !input.api.canSkipSubrequest(req.id));
+            if (subRequestsInvalid) {
+                assetGraph.safeToIncrementallyBundle = false;
+            }
+            let configResult = (0, nullthrows_1.default)(await input.api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+            (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);
+            let bundlingMeasurement = profiler_1.tracer.createMeasurement('bundling');
+            let builder = new BundlerRunner(input, atlaspackConfig, devDeps);
+            let res = await builder.bundle({
+                graph: assetGraph,
+                changedAssets: changedAssets,
+                assetRequests,
+            });
+            bundlingMeasurement && bundlingMeasurement.end();
+            for (let [id, asset] of changedAssets) {
+                res.changedAssets.set(id, asset);
+            }
+            await (0, dumpGraphToGraphViz_1.default)(
+            // @ts-expect-error TS2345
+            res.bundleGraph._graph, 'BundleGraph', BundleGraph_1.bundleGraphEdgeTypes);
+            return res;
+        },
+        input,
+    };
+}
+class BundlerRunner {
+    constructor({ input, api, options }, config, previousDevDeps) {
+        this.options = options;
+        this.api = api;
+        this.optionsRef = input.optionsRef;
+        this.config = config;
+        this.previousDevDeps = previousDevDeps;
+        this.devDepRequests = new Map();
+        this.configs = new Map();
+        this.pluginOptions = new PluginOptions_1.default((0, utils_1.optionsProxy)(this.options, api.invalidateOnOptionChange));
+        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
+        let bundler = await this.config.getBundler();
+        await this.loadConfig(bundler);
+        let namers = await this.config.getNamers();
+        for (let namer of namers) {
+            await this.loadConfig(namer);
+        }
+        let runtimes = await this.config.getRuntimes();
+        for (let runtime of runtimes) {
+            await this.loadConfig(runtime);
+        }
+    }
+    async loadConfig(plugin) {
+        await (0, BundleGraphRequestUtils_1.loadPluginConfigWithDevDeps)(plugin, this.options, this.api, this.previousDevDeps, this.devDepRequests, this.configs);
+    }
+    async runDevDepRequest(devDepRequest) {
+        await (0, BundleGraphRequestUtils_1.runDevDepRequest)(this.api, devDepRequest, this.devDepRequests);
+    }
+    async bundle({ graph, changedAssets, assetRequests, }) {
+        (0, ReporterRunner_1.report)({
+            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 != null && graph.canIncrementallyBundle();
+        if (graph.safeToIncrementallyBundle && previousBundleGraphResult == null) {
+            graph.safeToIncrementallyBundle = false;
+        }
+        let internalBundleGraph;
+        let logger = new logger_1.PluginLogger({ origin: name });
+        let tracer = new profiler_1.PluginTracer({
+            origin: name,
+            category: 'bundle',
+        });
+        try {
+            if (canIncrementallyBundle && previousBundleGraphResult) {
+                internalBundleGraph = previousBundleGraphResult.bundleGraph;
+                for (let changedAssetId of changedAssets.keys()) {
+                    // Copy over the whole node to also have correct symbol data
+                    let changedAssetNode = (0, nullthrows_1.default)(graph.getNodeByContentKey(changedAssetId));
+                    (0, assert_1.default)(changedAssetNode.type === 'asset');
+                    internalBundleGraph.updateAsset(changedAssetNode);
+                }
+                didIncrementallyBundle = true;
+            }
+            else {
+                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_1.bundleGraphEdgeTypes);
+                let mutableBundleGraph = new MutableBundleGraph_1.default(internalBundleGraph, this.options);
+                let measurement;
+                let measurementFilename;
+                if (tracer.enabled) {
+                    measurementFilename = graph
+                        .getEntryAssets()
+                        .map((asset) => (0, projectPath_1.fromProjectPathRelative)(asset.filePath))
+                        .join(', ');
+                    measurement = tracer.createMeasurement(plugin.name, 'bundling:bundle', measurementFilename);
+                }
+                // this the normal bundle workflow (bundle, optimizing, run-times, naming)
+                await (0, logger_1.instrumentAsync)('bundle (V2)', async () => {
+                    await bundler.bundle({
+                        bundleGraph: mutableBundleGraph,
+                        config: this.configs.get(plugin.name)?.result,
+                        options: this.pluginOptions,
+                        logger,
+                        tracer,
+                    });
+                });
+                measurement && measurement.end();
+                (0, BundleGraphRequestUtils_1.dumpBundleGraphSnapshot)(internalBundleGraph, 'js');
+                if (this.pluginOptions.mode === 'production') {
+                    let optimizeMeasurement;
+                    try {
+                        if (tracer.enabled) {
+                            optimizeMeasurement = tracer.createMeasurement(plugin.name, 'bundling:optimize', (0, nullthrows_1.default)(measurementFilename));
+                        }
+                        await bundler.optimize({
+                            bundleGraph: mutableBundleGraph,
+                            config: this.configs.get(plugin.name)?.result,
+                            options: this.pluginOptions,
+                            logger,
+                        });
+                    }
+                    catch (e) {
+                        throw new diagnostic_1.default({
+                            diagnostic: (0, diagnostic_1.errorToDiagnostic)(e, {
+                                origin: plugin.name,
+                            }),
+                        });
+                    }
+                    finally {
+                        optimizeMeasurement && optimizeMeasurement.end();
+                        await (0, dumpGraphToGraphViz_1.default)(
+                        // @ts-expect-error TS2345
+                        internalBundleGraph._graph, 'after_optimize');
+                    }
+                }
+                // Add dev dependency for the bundler. This must be done AFTER running it due to
+                // the potential for lazy require() that aren't executed until the request runs.
+                let devDepRequest = await (0, DevDepRequest_1.createDevDependency)({
+                    specifier: name,
+                    resolveFrom,
+                }, this.previousDevDeps, this.options);
+                await this.runDevDepRequest(devDepRequest);
+            }
+        }
+        catch (e) {
+            if (internalBundleGraph != null) {
+                this.api.storeResult({
+                    bundleGraph: internalBundleGraph,
+                    changedAssets: new Map(),
+                    assetRequests: [],
+                    didIncrementallyBundle,
+                }, this.cacheKey);
+            }
+            throw new diagnostic_1.default({
+                diagnostic: (0, diagnostic_1.errorToDiagnostic)(e, {
+                    origin: name,
+                }),
+            });
+        }
+        finally {
+            if (internalBundleGraph != null) {
+                await (0, dumpGraphToGraphViz_1.default)(
+                // @ts-expect-error TS2345
+                internalBundleGraph._graph, 'after_bundle', BundleGraph_1.bundleGraphEdgeTypes);
+            }
+        }
+        let changedRuntimes = new Map();
+        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.
+            let bundles = internalBundleGraph.getBundles({ includeInline: true });
+            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,
+                config: this.config,
+                options: this.options,
+                optionsRef: this.optionsRef,
+                pluginOptions: this.pluginOptions,
+                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) {
+                let devDepRequest = await (0, DevDepRequest_1.createDevDependency)({
+                    specifier: namer.name,
+                    resolveFrom: namer.resolveFrom,
+                }, this.previousDevDeps, this.options);
+                await this.runDevDepRequest(devDepRequest);
+            }
+            (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_1.bundleGraphEdgeTypes);
+        this.api.storeResult({
+            bundleGraph: internalBundleGraph,
+            changedAssets: new Map(),
+            assetRequests: [],
+            didIncrementallyBundle,
+        }, this.cacheKey);
+        return {
+            bundleGraph: internalBundleGraph,
+            changedAssets: changedRuntimes,
+            assetRequests,
+            didIncrementallyBundle,
+        };
+    }
+}