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

package/dist/requests/BundleGraphRequest.js

@@ -0,0 +1,447 @@
+"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 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 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 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 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,
+            });
+            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_2.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;
+                assetGraph.setNeedsBundling();
+            }
+            let configResult = (0, nullthrows_1.default)(await input.api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+            (0, utils_2.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_2.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_2.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';
+        }
+    }
+    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) {
+        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);
+    }
+    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);
+    }
+    async bundle({ graph, changedAssets, assetRequests, }) {
+        (0, ReporterRunner_1.report)({
+            type: 'buildProgress',
+            phase: 'bundling',
+        });
+        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);
+        if (graph.safeToIncrementallyBundle && previousBundleGraphResult == null) {
+            graph.safeToIncrementallyBundle = false;
+            graph.setNeedsBundling();
+        }
+        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);
+                }
+            }
+            else {
+                internalBundleGraph = BundleGraph_2.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);
+                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 bundler.bundle({
+                    bundleGraph: mutableBundleGraph,
+                    config: this.configs.get(plugin.name)?.result,
+                    options: this.pluginOptions,
+                    logger,
+                    tracer,
+                });
+                measurement && measurement.end();
+                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,
+                    assetGraphBundlingVersion: graph.getBundlingVersion(),
+                    changedAssets: new Map(),
+                    assetRequests: [],
+                }, 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_2.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) => this.nameBundle(namers, bundle, internalBundleGraph)));
+            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);
+            }
+            this.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);
+        this.api.storeResult({
+            bundleGraph: internalBundleGraph,
+            assetGraphBundlingVersion: graph.getBundlingVersion(),
+            changedAssets: new Map(),
+            assetRequests: [],
+        }, this.cacheKey);
+        return {
+            bundleGraph: internalBundleGraph,
+            assetGraphBundlingVersion: graph.getBundlingVersion(),
+            changedAssets: changedRuntimes,
+            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');
+    }
+}