@atlaspack/core 2.16.2-canary.27 → 2.16.2-canary.270

package/dist/PackagerRunner.js

@@ -0,0 +1,545 @@
+"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 });
+const assert_1 = __importDefault(require("assert"));
+const build_cache_1 = require("@atlaspack/build-cache");
+const utils_1 = require("@atlaspack/utils");
+const logger_1 = require("@atlaspack/logger");
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const stream_1 = require("stream");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const path_1 = __importDefault(require("path"));
+const url_1 = __importDefault(require("url"));
+const rust_1 = require("@atlaspack/rust");
+const Bundle_1 = require("./public/Bundle");
+const BundleGraph_1 = __importStar(require("./public/BundleGraph"));
+const PluginOptions_1 = __importDefault(require("./public/PluginOptions"));
+const Config_1 = __importDefault(require("./public/Config"));
+const constants_1 = require("./constants");
+const projectPath_1 = require("./projectPath");
+const InternalConfig_1 = require("./InternalConfig");
+const ConfigRequest_1 = require("./requests/ConfigRequest");
+const DevDepRequest_1 = require("./requests/DevDepRequest");
+const assetUtils_1 = require("./assetUtils");
+const utils_2 = require("./utils");
+const DevDepRequest_2 = require("./requests/DevDepRequest");
+const profiler_1 = require("@atlaspack/profiler");
+const EnvironmentManager_1 = require("./EnvironmentManager");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const BOUNDARY_LENGTH = constants_1.HASH_REF_PREFIX.length + 32 - 1;
+// Packager/optimizer configs are not bundle-specific, so we only need to
+// load them once per build.
+const pluginConfigs = (0, build_cache_1.createBuildCache)();
+class PackagerRunner {
+    constructor({ config, options, report, previousDevDeps, previousInvalidations, }) {
+        this.config = config;
+        this.options = options;
+        this.report = report;
+        this.previousDevDeps = previousDevDeps;
+        this.devDepRequests = new Map();
+        this.previousInvalidations = previousInvalidations;
+        this.invalidations = new Map();
+        this.pluginOptions = new PluginOptions_1.default((0, utils_2.optionsProxy)(this.options, (option) => {
+            let invalidation = {
+                type: 'option',
+                key: option,
+            };
+            this.invalidations.set((0, assetUtils_1.getInvalidationId)(invalidation), invalidation);
+        }));
+    }
+    async run(bundleGraph, bundle, invalidDevDeps) {
+        (0, DevDepRequest_2.invalidateDevDeps)(invalidDevDeps, this.options, this.config);
+        let { configs, bundleConfigs } = await this.loadConfigs(bundleGraph, bundle);
+        let bundleInfo = (await this.getBundleInfoFromCache(bundleGraph, bundle, configs, bundleConfigs)) ??
+            (await this.getBundleInfo(bundle, bundleGraph, configs, bundleConfigs));
+        let configRequests = (0, ConfigRequest_1.getConfigRequests)([
+            ...configs.values(),
+            ...bundleConfigs.values(),
+        ]);
+        let devDepRequests = (0, DevDepRequest_1.getWorkerDevDepRequests)([
+            ...this.devDepRequests.values(),
+        ]);
+        return {
+            bundleInfo,
+            configRequests,
+            devDepRequests,
+            invalidations: [...this.invalidations.values()],
+        };
+    }
+    async loadConfigs(bundleGraph, bundle) {
+        let configs = new Map();
+        let bundleConfigs = new Map();
+        await this.loadConfig(bundleGraph, bundle, configs, bundleConfigs);
+        for (let inlineBundle of bundleGraph.getInlineBundles(bundle)) {
+            await this.loadConfig(bundleGraph, inlineBundle, configs, bundleConfigs);
+        }
+        return { configs, bundleConfigs };
+    }
+    async loadConfig(bundleGraph, bundle, configs, bundleConfigs) {
+        let name = (0, nullthrows_1.default)(bundle.name);
+        let plugin = await this.config.getPackager(name);
+        await this.loadPluginConfig(bundleGraph, bundle, plugin, configs, bundleConfigs);
+        let optimizers = await this.config.getOptimizers(name, bundle.pipeline);
+        for (let optimizer of optimizers) {
+            await this.loadPluginConfig(bundleGraph, bundle, optimizer, configs, bundleConfigs);
+        }
+    }
+    async loadPluginConfig(bundleGraph, bundle, plugin, configs, bundleConfigs) {
+        if (!configs.has(plugin.name)) {
+            // Only load config for a plugin once per build.
+            let existing = pluginConfigs.get(plugin.name);
+            if (existing != null) {
+                // @ts-expect-error TS2345
+                configs.set(plugin.name, existing);
+            }
+            else {
+                if (plugin.plugin.loadConfig != null) {
+                    let config = (0, InternalConfig_1.createConfig)({
+                        plugin: plugin.name,
+                        searchPath: (0, projectPath_1.toProjectPathUnsafe)('index'),
+                    });
+                    await (0, ConfigRequest_1.loadPluginConfig)(plugin, config, this.options);
+                    for (let devDep of config.devDeps) {
+                        let devDepRequest = await (0, DevDepRequest_1.createDevDependency)(devDep, this.previousDevDeps, this.options);
+                        let key = `${devDep.specifier}:${(0, projectPath_1.fromProjectPath)(this.options.projectRoot, devDep.resolveFrom)}`;
+                        this.devDepRequests.set(key, devDepRequest);
+                    }
+                    pluginConfigs.set(plugin.name, config);
+                    configs.set(plugin.name, config);
+                }
+            }
+        }
+        let loadBundleConfig = plugin.plugin.loadBundleConfig;
+        if (!bundleConfigs.has(plugin.name) && loadBundleConfig != null) {
+            let config = (0, InternalConfig_1.createConfig)({
+                plugin: plugin.name,
+                searchPath: (0, projectPath_1.joinProjectPath)(bundle.target.distDir, bundle.name ?? bundle.id),
+            });
+            config.result = await loadBundleConfig({
+                bundle: Bundle_1.NamedBundle.get(bundle, bundleGraph, this.options),
+                bundleGraph: new BundleGraph_1.default(bundleGraph, Bundle_1.NamedBundle.get.bind(Bundle_1.NamedBundle), this.options),
+                config: new Config_1.default(config, this.options),
+                options: new PluginOptions_1.default(this.options),
+                logger: new logger_1.PluginLogger({ origin: plugin.name }),
+                tracer: new profiler_1.PluginTracer({ origin: plugin.name, category: 'loadConfig' }),
+            });
+            bundleConfigs.set(plugin.name, config);
+        }
+    }
+    async getBundleInfoFromCache(bundleGraph, bundle, configs, bundleConfigs) {
+        if (this.options.shouldDisableCache) {
+            return;
+        }
+        let cacheKey = await this.getCacheKey(bundle, bundleGraph, configs, bundleConfigs, this.previousInvalidations);
+        let infoKey = PackagerRunner.getInfoKey(cacheKey);
+        return this.options.cache.get(infoKey);
+    }
+    async getBundleInfo(bundle, bundleGraph, configs, bundleConfigs) {
+        let { type, contents, map, scopeHoistingStats } = await this.getBundleResult(bundle, bundleGraph, configs, bundleConfigs);
+        // Recompute cache keys as they may have changed due to dev dependencies.
+        let cacheKey = await this.getCacheKey(bundle, bundleGraph, configs, bundleConfigs, [...this.invalidations.values()]);
+        let cacheKeys = {
+            content: PackagerRunner.getContentKey(cacheKey),
+            map: PackagerRunner.getMapKey(cacheKey),
+            info: PackagerRunner.getInfoKey(cacheKey),
+        };
+        let cachedResult = await this.writeToCache(cacheKeys, type, contents, map);
+        if (utils_1.debugTools['scope-hoisting-stats']) {
+            return { ...cachedResult, scopeHoistingStats };
+        }
+        return cachedResult;
+    }
+    async getBundleResult(bundle, bundleGraph, configs, bundleConfigs) {
+        let packaged = await this.package(bundle, bundleGraph, configs, bundleConfigs);
+        let type = packaged.type ?? bundle.type;
+        let res = await this.optimize(bundle, bundleGraph, type, packaged.contents, packaged.map, configs, bundleConfigs);
+        let map = res.map != null ? await this.generateSourceMap(bundle, res.map) : null;
+        return {
+            type: res.type ?? type,
+            contents: res.contents,
+            map,
+            scopeHoistingStats: packaged.scopeHoistingStats,
+        };
+    }
+    getSourceMapReference(bundle, map) {
+        if (map &&
+            bundle.env.sourceMap &&
+            bundle.bundleBehavior !== 'inline' &&
+            bundle.bundleBehavior !== 'inlineIsolated') {
+            if (bundle.env.sourceMap && bundle.env.sourceMap.inline) {
+                return this.generateSourceMap((0, Bundle_1.bundleToInternalBundle)(bundle), map);
+            }
+            else {
+                return path_1.default.basename(bundle.name) + '.map';
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    async package(internalBundle, bundleGraph, configs, bundleConfigs) {
+        let bundle = Bundle_1.NamedBundle.get(internalBundle, bundleGraph, this.options);
+        this.report({
+            type: 'buildProgress',
+            phase: 'packaging',
+            bundle,
+        });
+        let packager = await this.config.getPackager(bundle.name);
+        let { name, resolveFrom, plugin } = packager;
+        let measurement;
+        try {
+            measurement = profiler_1.tracer.createMeasurement(name, 'packaging', bundle.name, {
+                type: bundle.type,
+            });
+            return await plugin.package({
+                config: configs.get(name)?.result,
+                bundleConfig: bundleConfigs.get(name)?.result,
+                bundle,
+                bundleGraph: new BundleGraph_1.default(bundleGraph, Bundle_1.NamedBundle.get.bind(Bundle_1.NamedBundle), this.options),
+                getSourceMapReference: (map) => {
+                    return this.getSourceMapReference(bundle, map);
+                },
+                options: this.pluginOptions,
+                logger: new logger_1.PluginLogger({ origin: name }),
+                tracer: new profiler_1.PluginTracer({ origin: name, category: 'package' }),
+                getInlineBundleContents: async (bundle, bundleGraph) => {
+                    if (bundle.bundleBehavior !== 'inline' &&
+                        bundle.bundleBehavior !== 'inlineIsolated') {
+                        throw new Error('Bundle is not inline and unable to retrieve contents');
+                    }
+                    let { contents } = await this.getBundleResult((0, Bundle_1.bundleToInternalBundle)(bundle), (0, BundleGraph_1.bundleGraphToInternalBundleGraph)(bundleGraph), configs, bundleConfigs);
+                    return { contents };
+                },
+            });
+        }
+        catch (e) {
+            throw new diagnostic_1.default({
+                diagnostic: (0, diagnostic_1.errorToDiagnostic)(e, {
+                    origin: name,
+                    filePath: path_1.default.join(bundle.target.distDir, bundle.name),
+                }),
+            });
+        }
+        finally {
+            measurement && measurement.end();
+            // Add dev dependency for the packager. 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);
+            this.devDepRequests.set(`${name}:${(0, projectPath_1.fromProjectPathRelative)(resolveFrom)}`, devDepRequest);
+        }
+    }
+    async optimize(internalBundle, internalBundleGraph, type, contents, map, configs, bundleConfigs) {
+        let bundle = Bundle_1.NamedBundle.get(internalBundle, internalBundleGraph, this.options);
+        let bundleGraph = new BundleGraph_1.default(internalBundleGraph, Bundle_1.NamedBundle.get.bind(Bundle_1.NamedBundle), this.options);
+        let optimizers = await this.config.getOptimizers(bundle.name, internalBundle.pipeline);
+        if (!optimizers.length) {
+            return { type: bundle.type, contents, map };
+        }
+        this.report({
+            type: 'buildProgress',
+            phase: 'optimizing',
+            bundle,
+        });
+        let optimized = {
+            type,
+            contents,
+            map,
+        };
+        for (let optimizer of optimizers) {
+            let measurement;
+            try {
+                measurement = profiler_1.tracer.createMeasurement(optimizer.name, 'optimize', bundle.name);
+                let next = await optimizer.plugin.optimize({
+                    config: configs.get(optimizer.name)?.result,
+                    bundleConfig: bundleConfigs.get(optimizer.name)?.result,
+                    bundle,
+                    bundleGraph,
+                    contents: optimized.contents,
+                    map: optimized.map,
+                    getSourceMapReference: (map) => {
+                        return this.getSourceMapReference(bundle, map);
+                    },
+                    options: this.pluginOptions,
+                    logger: new logger_1.PluginLogger({ origin: optimizer.name }),
+                    tracer: new profiler_1.PluginTracer({
+                        origin: optimizer.name,
+                        category: 'optimize',
+                    }),
+                });
+                optimized.type = next.type ?? optimized.type;
+                optimized.contents = next.contents;
+                optimized.map = next.map;
+            }
+            catch (e) {
+                throw new diagnostic_1.default({
+                    diagnostic: (0, diagnostic_1.errorToDiagnostic)(e, {
+                        origin: optimizer.name,
+                        filePath: path_1.default.join(bundle.target.distDir, bundle.name),
+                    }),
+                });
+            }
+            finally {
+                measurement && measurement.end();
+                // Add dev dependency for the optimizer. 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: optimizer.name,
+                    resolveFrom: optimizer.resolveFrom,
+                }, this.previousDevDeps, this.options);
+                this.devDepRequests.set(`${optimizer.name}:${(0, projectPath_1.fromProjectPathRelative)(optimizer.resolveFrom)}`, devDepRequest);
+            }
+        }
+        return optimized;
+    }
+    async generateSourceMap(bundle, map) {
+        // sourceRoot should be a relative path between outDir and rootDir for node.js targets
+        let filePath = (0, projectPath_1.joinProjectPath)(bundle.target.distDir, (0, nullthrows_1.default)(bundle.name));
+        let fullPath = (0, projectPath_1.fromProjectPath)(this.options.projectRoot, filePath);
+        let sourceRoot = path_1.default.relative(path_1.default.dirname(fullPath), this.options.projectRoot);
+        let inlineSources = false;
+        const bundleEnv = (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env);
+        if (bundle.target) {
+            const bundleTargetEnv = (0, EnvironmentManager_1.fromEnvironmentId)(bundle.target.env);
+            if (bundleEnv.sourceMap && bundleEnv.sourceMap.sourceRoot !== undefined) {
+                sourceRoot = bundleEnv.sourceMap.sourceRoot;
+            }
+            else if (this.options.serveOptions &&
+                bundleTargetEnv.context === 'browser') {
+                sourceRoot = '/__parcel_source_root';
+            }
+            if (bundleEnv.sourceMap &&
+                bundleEnv.sourceMap.inlineSources !== undefined) {
+                inlineSources = bundleEnv.sourceMap.inlineSources;
+            }
+            else if (bundleTargetEnv.context !== 'node') {
+                // inlining should only happen in production for browser targets by default
+                inlineSources = this.options.mode === 'production';
+            }
+        }
+        let mapFilename = fullPath + '.map';
+        let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
+        if ((0, feature_flags_1.getFeatureFlag)('omitSourcesContentInMemory') && !isInlineMap) {
+            if (!(bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources === false)) {
+                /*
+                  We're omitting sourcesContent during transformation to allow GC to run.
+                  Ensure sources are still inlined into the final source maps written to disk. UNLESS the user explicitly disabled inlineSources.
+                */
+                inlineSources = true;
+            }
+        }
+        let stringified = await map.stringify({
+            file: path_1.default.basename(mapFilename),
+            fs: this.options.inputFS,
+            rootDir: this.options.projectRoot,
+            sourceRoot: !inlineSources
+                ? url_1.default.format(url_1.default.parse(sourceRoot + '/'))
+                : undefined,
+            inlineSources,
+            format: isInlineMap ? 'inline' : 'string',
+        });
+        (0, assert_1.default)(typeof stringified === 'string');
+        return stringified;
+    }
+    async getCacheKey(bundle, bundleGraph, configs, bundleConfigs, invalidations) {
+        let configResults = {};
+        for (let [pluginName, config] of configs) {
+            if (config) {
+                configResults[pluginName] = await (0, ConfigRequest_1.getConfigHash)(config, pluginName, this.options);
+            }
+        }
+        let globalInfoResults = {};
+        for (let [pluginName, config] of bundleConfigs) {
+            if (config) {
+                globalInfoResults[pluginName] = await (0, ConfigRequest_1.getConfigHash)(config, pluginName, this.options);
+            }
+        }
+        let devDepHashes = await this.getDevDepHashes(bundle);
+        for (let inlineBundle of bundleGraph.getInlineBundles(bundle)) {
+            devDepHashes += await this.getDevDepHashes(inlineBundle);
+        }
+        let invalidationHash = await (0, assetUtils_1.getInvalidationHash)(invalidations, this.options);
+        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+            const hash = (0, rust_1.hashString)(constants_1.ATLASPACK_VERSION +
+                devDepHashes +
+                invalidationHash +
+                bundle.target.publicUrl +
+                bundleGraph.getHash(bundle) +
+                JSON.stringify(configResults) +
+                JSON.stringify(globalInfoResults) +
+                this.options.mode +
+                (this.options.shouldBuildLazily ? 'lazy' : 'eager'));
+            return path_1.default.join(bundle.displayName ?? bundle.name ?? bundle.id, hash);
+        }
+        return (0, rust_1.hashString)(constants_1.ATLASPACK_VERSION +
+            devDepHashes +
+            invalidationHash +
+            bundle.target.publicUrl +
+            bundleGraph.getHash(bundle) +
+            JSON.stringify(configResults) +
+            JSON.stringify(globalInfoResults) +
+            this.options.mode +
+            (this.options.shouldBuildLazily ? 'lazy' : 'eager'));
+    }
+    async getDevDepHashes(bundle) {
+        let name = (0, nullthrows_1.default)(bundle.name);
+        let packager = await this.config.getPackager(name);
+        let optimizers = await this.config.getOptimizers(name);
+        let key = `${packager.name}:${(0, projectPath_1.fromProjectPathRelative)(packager.resolveFrom)}`;
+        let devDepHashes = this.devDepRequests.get(key)?.hash ?? this.previousDevDeps.get(key) ?? '';
+        for (let { name, resolveFrom } of optimizers) {
+            let key = `${name}:${(0, projectPath_1.fromProjectPathRelative)(resolveFrom)}`;
+            devDepHashes +=
+                this.devDepRequests.get(key)?.hash ??
+                    this.previousDevDeps.get(key) ??
+                    '';
+        }
+        return devDepHashes;
+    }
+    async readFromCache(cacheKey) {
+        let contentKey = PackagerRunner.getContentKey(cacheKey);
+        let mapKey = PackagerRunner.getMapKey(cacheKey);
+        let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
+        let contentExists = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
+            ? isLargeBlob
+            : isLargeBlob || (await this.options.cache.has(contentKey));
+        if (!contentExists) {
+            return null;
+        }
+        let mapExists = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
+            ? await this.options.cache.hasLargeBlob(mapKey)
+            : await this.options.cache.has(mapKey);
+        return {
+            contents: isLargeBlob
+                ? this.options.cache.getStream(contentKey)
+                : (0, utils_1.blobToStream)(await this.options.cache.getBlob(contentKey)),
+            map: mapExists
+                ? (0, utils_1.blobToStream)((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
+                    ? await this.options.cache.getLargeBlob(mapKey)
+                    : await this.options.cache.getBlob(mapKey))
+                : null,
+        };
+    }
+    async writeToCache(cacheKeys, type, contents, map) {
+        let size = 0;
+        let hash;
+        // @ts-expect-error TS2702
+        let hashReferences = [];
+        let isLargeBlob = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements');
+        // TODO: don't replace hash references in binary files??
+        if (contents instanceof stream_1.Readable) {
+            if (!(0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+                isLargeBlob = true;
+            }
+            let boundaryStr = '';
+            let h = new rust_1.Hash();
+            await this.options.cache.setStream(cacheKeys.content, (0, utils_1.blobToStream)(contents).pipe(
+            // @ts-expect-error TS2554
+            new utils_1.TapStream((buf) => {
+                let str = boundaryStr + buf.toString();
+                hashReferences = hashReferences.concat(str.match(constants_1.HASH_REF_REGEX) ?? []);
+                size += buf.length;
+                h.writeBuffer(buf);
+                boundaryStr = str.slice(str.length - BOUNDARY_LENGTH);
+            })));
+            hash = h.finish();
+        }
+        else if (typeof contents === 'string') {
+            let buffer = Buffer.from(contents);
+            size = buffer.byteLength;
+            hash = (0, rust_1.hashBuffer)(buffer);
+            hashReferences = contents.match(constants_1.HASH_REF_REGEX) ?? [];
+            if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+                await this.options.cache.setLargeBlob(cacheKeys.content, buffer);
+            }
+            else {
+                await this.options.cache.setBlob(cacheKeys.content, buffer);
+            }
+        }
+        else {
+            size = contents.length;
+            hash = (0, rust_1.hashBuffer)(contents);
+            hashReferences = contents.toString().match(constants_1.HASH_REF_REGEX) ?? [];
+            if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+                await this.options.cache.setLargeBlob(cacheKeys.content, contents);
+            }
+            else {
+                await this.options.cache.setBlob(cacheKeys.content, contents);
+            }
+        }
+        if (map != null) {
+            if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+                await this.options.cache.setLargeBlob(cacheKeys.map, map);
+            }
+            else {
+                await this.options.cache.setBlob(cacheKeys.map, map);
+            }
+        }
+        let info = {
+            type,
+            size,
+            hash,
+            hashReferences,
+            cacheKeys,
+            isLargeBlob,
+        };
+        await this.options.cache.set(cacheKeys.info, info);
+        return info;
+    }
+    static getContentKey(cacheKey) {
+        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+            return `PackagerRunner/${constants_1.ATLASPACK_VERSION}/${cacheKey}/content`;
+        }
+        return (0, rust_1.hashString)(`${cacheKey}:content`);
+    }
+    static getMapKey(cacheKey) {
+        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+            return `PackagerRunner/${constants_1.ATLASPACK_VERSION}/${cacheKey}/map`;
+        }
+        return (0, rust_1.hashString)(`${cacheKey}:map`);
+    }
+    static getInfoKey(cacheKey) {
+        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+            return `PackagerRunner/${constants_1.ATLASPACK_VERSION}/${cacheKey}/info`;
+        }
+        return (0, rust_1.hashString)(`${cacheKey}:info`);
+    }
+}
+exports.default = PackagerRunner;