@atlaspack/core 2.24.1 → 2.24.2-dev-ts-project-refs-d30e9754f.0

package/dist/requests/BundleGraphRequest.js

@@ -0,0 +1,441 @@
+"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 = 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 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.js')(jsAssetGraph, assetGraph);
+            // }
+            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, 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');
+    }
+}

package/dist/requests/ConfigRequest.js

@@ -0,0 +1,222 @@
+"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.loadPluginConfig = loadPluginConfig;
+exports.getValueAtPath = getValueAtPath;
+exports.getConfigKeyContentHash = getConfigKeyContentHash;
+exports.runConfigRequest = runConfigRequest;
+exports.getConfigHash = getConfigHash;
+exports.getConfigRequests = getConfigRequests;
+const utils_1 = require("@atlaspack/utils");
+const build_cache_1 = require("@atlaspack/build-cache");
+const logger_1 = require("@atlaspack/logger");
+const PluginOptions_1 = __importDefault(require("../public/PluginOptions"));
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const Config_1 = __importDefault(require("../public/Config"));
+const utils_2 = require("../utils");
+const assetUtils_1 = require("../assetUtils");
+const rust_1 = require("@atlaspack/rust");
+const profiler_1 = require("@atlaspack/profiler");
+const RequestTracker_1 = require("../RequestTracker");
+const projectPath_1 = require("../projectPath");
+async function loadPluginConfig(loadedPlugin, config, options) {
+    let loadConfig = loadedPlugin.plugin.loadConfig;
+    if (!loadConfig) {
+        return;
+    }
+    try {
+        config.result = await loadConfig({
+            config: new Config_1.default(config, options),
+            options: new PluginOptions_1.default((0, utils_2.optionsProxy)(options, (option) => {
+                config.invalidateOnOptionChange.add(option);
+            })),
+            logger: new logger_1.PluginLogger({ origin: loadedPlugin.name }),
+            tracer: new profiler_1.PluginTracer({
+                origin: loadedPlugin.name,
+                category: 'loadConfig',
+            }),
+        });
+    }
+    catch (e) {
+        throw new diagnostic_1.default({
+            diagnostic: (0, diagnostic_1.errorToDiagnostic)(e, {
+                origin: loadedPlugin.name,
+            }),
+        });
+    }
+}
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+function getValueAtPath(obj, key) {
+    let current = obj;
+    for (let part of key) {
+        if (current == null) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+const configKeyCache = (0, build_cache_1.createBuildCache)();
+async function getConfigKeyContentHash(filePath, configKey, options) {
+    let cacheKey = `${(0, projectPath_1.fromProjectPathRelative)(filePath)}:${JSON.stringify(configKey)}`;
+    let cachedValue = configKeyCache.get(cacheKey);
+    if (cachedValue) {
+        // @ts-expect-error TS2322
+        return cachedValue;
+    }
+    const conf = await (0, utils_1.readConfig)(options.inputFS, (0, projectPath_1.fromProjectPath)(options.projectRoot, filePath));
+    const value = getValueAtPath(conf?.config, configKey);
+    if (conf == null || value == null) {
+        // This can occur when a config key has been removed entirely during `respondToFSEvents`
+        return '';
+    }
+    const contentHash = typeof value === 'object'
+        ? (0, utils_1.hashObject)(value)
+        : (0, rust_1.hashString)(JSON.stringify(value));
+    configKeyCache.set(cacheKey, contentHash);
+    return contentHash;
+}
+async function runConfigRequest(api, configRequest) {
+    let { invalidateOnFileChange, invalidateOnConfigKeyChange, invalidateOnFileCreate, invalidateOnEnvChange, invalidateOnOptionChange, invalidateOnStartup, invalidateOnBuild, } = configRequest;
+    // If there are no invalidations, then no need to create a node.
+    if (invalidateOnFileChange.size === 0 &&
+        invalidateOnConfigKeyChange.length === 0 &&
+        invalidateOnFileCreate.length === 0 &&
+        invalidateOnOptionChange.size === 0 &&
+        invalidateOnEnvChange.size === 0 &&
+        !invalidateOnStartup &&
+        !invalidateOnBuild) {
+        return;
+    }
+    await api.runRequest({
+        id: 'config_request:' + configRequest.id,
+        type: RequestTracker_1.requestTypes.config_request,
+        run: async ({ api, options }) => {
+            for (let filePath of invalidateOnFileChange) {
+                api.invalidateOnFileUpdate(filePath);
+                api.invalidateOnFileDelete(filePath);
+            }
+            for (let { filePath, configKey } of invalidateOnConfigKeyChange) {
+                let contentHash = await getConfigKeyContentHash(filePath, configKey, options);
+                api.invalidateOnConfigKeyChange(filePath, configKey, contentHash);
+            }
+            for (let invalidation of invalidateOnFileCreate) {
+                api.invalidateOnFileCreate(invalidation);
+            }
+            for (let env of invalidateOnEnvChange) {
+                api.invalidateOnEnvChange(env);
+            }
+            for (let option of invalidateOnOptionChange) {
+                api.invalidateOnOptionChange(option);
+            }
+            if (invalidateOnStartup) {
+                api.invalidateOnStartup();
+            }
+            if (invalidateOnBuild) {
+                api.invalidateOnBuild();
+            }
+        },
+        input: null,
+    });
+}
+async function getConfigHash(config, pluginName, options) {
+    if (config.result == null) {
+        return '';
+    }
+    let hash = new rust_1.Hash();
+    hash.writeString(config.id);
+    // If there is no result hash set by the transformer, default to hashing the included
+    // files if any, otherwise try to hash the config result itself.
+    if (config.cacheKey == null) {
+        if (config.invalidateOnFileChange.size > 0) {
+            hash.writeString(await (0, assetUtils_1.getInvalidationHash)([...config.invalidateOnFileChange].map((filePath) => ({
+                type: 'file',
+                filePath,
+            })), options));
+        }
+        else if (config.result != null) {
+            try {
+                hash.writeBuffer((0, build_cache_1.serializeRaw)(config.result));
+            }
+            catch (err) {
+                throw new diagnostic_1.default({
+                    diagnostic: {
+                        message: 'Config result is not hashable because it contains non-serializable objects. Please use config.setCacheKey to set the hash manually.',
+                        origin: pluginName,
+                    },
+                });
+            }
+        }
+    }
+    else {
+        hash.writeString(config.cacheKey ?? '');
+    }
+    return hash.finish();
+}
+function getConfigRequests(configs) {
+    return configs
+        .filter((config) => {
+        // No need to send to the graph if there are no invalidations.
+        return (config.invalidateOnFileChange.size > 0 ||
+            config.invalidateOnConfigKeyChange.length > 0 ||
+            config.invalidateOnFileCreate.length > 0 ||
+            config.invalidateOnEnvChange.size > 0 ||
+            config.invalidateOnOptionChange.size > 0 ||
+            config.invalidateOnStartup ||
+            config.invalidateOnBuild);
+    })
+        .map((config) => ({
+        id: config.id,
+        invalidateOnFileChange: config.invalidateOnFileChange,
+        invalidateOnConfigKeyChange: config.invalidateOnConfigKeyChange,
+        invalidateOnFileCreate: config.invalidateOnFileCreate,
+        invalidateOnEnvChange: config.invalidateOnEnvChange,
+        invalidateOnOptionChange: config.invalidateOnOptionChange,
+        invalidateOnStartup: config.invalidateOnStartup,
+        invalidateOnBuild: config.invalidateOnBuild,
+    }));
+}