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

package/dist/requests/AssetRequest.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createAssetRequest;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+const rust_1 = require("@atlaspack/rust");
+const AtlaspackConfigRequest_1 = __importDefault(require("./AtlaspackConfigRequest"));
+const DevDepRequest_1 = require("./DevDepRequest");
+const ConfigRequest_1 = require("./ConfigRequest");
+const projectPath_1 = require("../projectPath");
+const ReporterRunner_1 = require("../ReporterRunner");
+const RequestTracker_1 = require("../RequestTracker");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+function createAssetRequest(input) {
+    return {
+        type: RequestTracker_1.requestTypes.asset_request,
+        id: getId(input),
+        run,
+        input,
+    };
+}
+const type = 'asset_request';
+function getId(input) {
+    return (0, rust_1.hashString)(type +
+        (0, projectPath_1.fromProjectPathRelative)(input.filePath) +
+        (0, EnvironmentManager_1.toEnvironmentId)(input.env) +
+        String(input.isSource) +
+        String(input.sideEffects) +
+        (input.code ?? '') +
+        ':' +
+        (input.pipeline ?? '') +
+        ':' +
+        (input.query ?? ''));
+}
+// @ts-expect-error TS7031
+async function run({ input, api, farm, invalidateReason, options }) {
+    (0, ReporterRunner_1.report)({
+        type: 'buildProgress',
+        phase: 'transforming',
+        filePath: (0, projectPath_1.fromProjectPath)(options.projectRoot, input.filePath),
+    });
+    api.invalidateOnFileUpdate(input.filePath);
+    let start = Date.now();
+    let { optionsRef, ...rest } = input;
+    let { cachePath } = (0, nullthrows_1.default)(
+    // @ts-expect-error TS2347
+    await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+    let previousDevDepRequests = new Map(await Promise.all(api
+        .getSubRequests()
+        // @ts-expect-error TS7006
+        .filter((req) => req.requestType === RequestTracker_1.requestTypes.dev_dep_request)
+        // @ts-expect-error TS7006
+        .map(async (req) => [
+        req.id,
+        // @ts-expect-error TS2347
+        (0, nullthrows_1.default)(await api.getRequestResult(req.id)),
+    ])));
+    let request = {
+        ...rest,
+        invalidateReason,
+        devDeps: new Map([...previousDevDepRequests.entries()]
+            // @ts-expect-error TS2769
+            .filter(([id]) => api.canSkipSubrequest(id))
+            .map(([, req]) => [
+            `${req.specifier}:${(0, projectPath_1.fromProjectPathRelative)(req.resolveFrom)}`,
+            req.hash,
+        ])),
+        invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()]
+            // @ts-expect-error TS2769
+            .filter(([id]) => !api.canSkipSubrequest(id))
+            .flatMap(([, req]) => {
+            return [
+                {
+                    specifier: req.specifier,
+                    resolveFrom: req.resolveFrom,
+                },
+                // @ts-expect-error TS7006
+                ...(req.additionalInvalidations ?? []).map((i) => ({
+                    specifier: i.specifier,
+                    resolveFrom: i.resolveFrom,
+                })),
+            ];
+        })),
+    };
+    let { assets, configRequests, error, invalidations, devDepRequests } = (await farm.createHandle('runTransform', input.isSingleChangeRebuild)({
+        configCachePath: cachePath,
+        optionsRef,
+        request,
+    }));
+    let time = Date.now() - start;
+    if (assets) {
+        for (let asset of assets) {
+            asset.stats.time = time;
+        }
+    }
+    for (let filePath of invalidations.invalidateOnFileChange) {
+        api.invalidateOnFileUpdate(filePath);
+        api.invalidateOnFileDelete(filePath);
+    }
+    for (let invalidation of invalidations.invalidateOnFileCreate) {
+        api.invalidateOnFileCreate(invalidation);
+    }
+    for (let env of invalidations.invalidateOnEnvChange) {
+        api.invalidateOnEnvChange(env);
+    }
+    for (let option of invalidations.invalidateOnOptionChange) {
+        api.invalidateOnOptionChange(option);
+    }
+    if (invalidations.invalidateOnStartup) {
+        api.invalidateOnStartup();
+    }
+    if (invalidations.invalidateOnBuild) {
+        api.invalidateOnBuild();
+    }
+    for (let devDepRequest of devDepRequests) {
+        await (0, DevDepRequest_1.runDevDepRequest)(api, devDepRequest);
+    }
+    for (let configRequest of configRequests) {
+        await (0, ConfigRequest_1.runConfigRequest)(api, configRequest);
+    }
+    if (error != null) {
+        throw new diagnostic_1.default({ diagnostic: error });
+    }
+    else {
+        return (0, nullthrows_1.default)(assets);
+    }
+}

package/dist/requests/AtlaspackBuildRequest.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createAtlaspackBuildRequest;
+const BundleGraphRequest_1 = __importDefault(require("./BundleGraphRequest"));
+const WriteBundlesRequest_1 = __importDefault(require("./WriteBundlesRequest"));
+const utils_1 = require("../utils");
+const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
+const BundleGraph_1 = require("../BundleGraph");
+const ReporterRunner_1 = require("../ReporterRunner");
+const BundleGraph_2 = __importDefault(require("../public/BundleGraph"));
+const Bundle_1 = require("../public/Bundle");
+const Asset_1 = require("../public/Asset");
+const profiler_1 = require("@atlaspack/profiler");
+const RequestTracker_1 = require("../RequestTracker");
+function createAtlaspackBuildRequest(input) {
+    return {
+        type: RequestTracker_1.requestTypes.atlaspack_build_request,
+        id: 'atlaspack_build_request',
+        run,
+        input,
+    };
+}
+// @ts-expect-error TS7031
+async function run({ input, api, options, rustAtlaspack }) {
+    let { optionsRef, requestedAssetIds, signal } = input;
+    let bundleGraphRequest = (0, BundleGraphRequest_1.default)({
+        optionsRef,
+        requestedAssetIds,
+        signal,
+    });
+    let { bundleGraph, changedAssets, assetRequests } = await api.runRequest(bundleGraphRequest, {
+        force: Boolean(rustAtlaspack) ||
+            (options.shouldBuildLazily && requestedAssetIds.size > 0),
+    });
+    // @ts-expect-error TS2345
+    (0, dumpGraphToGraphViz_1.default)(bundleGraph._graph, 'BundleGraph', BundleGraph_1.bundleGraphEdgeTypes);
+    await (0, ReporterRunner_1.report)({
+        type: 'buildProgress',
+        phase: 'bundled',
+        bundleGraph: new BundleGraph_2.default(bundleGraph, 
+        // @ts-expect-error TS2304
+        (bundle, bundleGraph, options) => Bundle_1.NamedBundle.get(bundle, bundleGraph, options), options),
+        changedAssets: new Map(Array.from(changedAssets).map(([id, asset]) => [
+            id,
+            (0, Asset_1.assetFromValue)(asset, options),
+        ])),
+    });
+    let packagingMeasurement = profiler_1.tracer.createMeasurement('packaging');
+    let writeBundlesRequest = (0, WriteBundlesRequest_1.default)({
+        bundleGraph,
+        optionsRef,
+    });
+    let bundleInfo = await api.runRequest(writeBundlesRequest);
+    packagingMeasurement && packagingMeasurement.end();
+    (0, utils_1.assertSignalNotAborted)(signal);
+    return { bundleGraph, bundleInfo, changedAssets, assetRequests };
+}

package/dist/requests/AtlaspackConfigRequest.js

@@ -0,0 +1,490 @@
+"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 = createAtlaspackConfigRequest;
+exports.getCachedAtlaspackConfig = getCachedAtlaspackConfig;
+exports.loadAtlaspackConfig = loadAtlaspackConfig;
+exports.resolveAtlaspackConfig = resolveAtlaspackConfig;
+exports.create = create;
+exports.parseAndProcessConfig = parseAndProcessConfig;
+exports.processConfig = processConfig;
+exports.processConfigChain = processConfigChain;
+exports.resolveExtends = resolveExtends;
+exports.validateConfigFile = validateConfigFile;
+exports.validateNotEmpty = validateNotEmpty;
+exports.mergeConfigs = mergeConfigs;
+exports.getResolveFrom = getResolveFrom;
+exports.mergePipelines = mergePipelines;
+exports.mergeMaps = mergeMaps;
+const build_cache_1 = require("@atlaspack/build-cache");
+const utils_1 = require("@atlaspack/utils");
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const json5_1 = require("json5");
+const path_1 = __importDefault(require("path"));
+const assert_1 = __importDefault(require("assert"));
+const AtlaspackConfig_1 = require("../AtlaspackConfig");
+const AtlaspackConfig_schema_1 = __importDefault(require("../AtlaspackConfig.schema"));
+const projectPath_1 = require("../projectPath");
+const RequestTracker_1 = require("../RequestTracker");
+const utils_2 = require("../utils");
+const type = 'atlaspack_config_request';
+function createAtlaspackConfigRequest() {
+    return {
+        id: type,
+        type: RequestTracker_1.requestTypes[type],
+        async run({ api, options }) {
+            let { config, extendedFiles, usedDefault, } = await loadAtlaspackConfig((0, utils_2.optionsProxy)(options, api.invalidateOnOptionChange));
+            api.invalidateOnFileUpdate(config.filePath);
+            api.invalidateOnFileDelete(config.filePath);
+            for (let filePath of extendedFiles) {
+                let pp = (0, projectPath_1.toProjectPath)(options.projectRoot, filePath);
+                api.invalidateOnFileUpdate(pp);
+                api.invalidateOnFileDelete(pp);
+            }
+            if (usedDefault) {
+                let resolveFrom = getResolveFrom(options.inputFS, options.projectRoot);
+                api.invalidateOnFileCreate({
+                    fileName: '.parcelrc',
+                    aboveFilePath: (0, projectPath_1.toProjectPath)(options.projectRoot, resolveFrom),
+                });
+            }
+            let cachePath = (0, utils_1.hashObject)(config);
+            await options.cache.set(cachePath, config);
+            let result = { config, cachePath };
+            // TODO: don't store config twice (once in the graph and once in a separate cache entry)
+            api.storeResult(result);
+            return result;
+        },
+        input: null,
+    };
+}
+const atlaspackConfigCache = (0, build_cache_1.createBuildCache)();
+function getCachedAtlaspackConfig(result, options) {
+    let { config: processedConfig, cachePath } = result;
+    let config = atlaspackConfigCache.get(cachePath);
+    if (config) {
+        // @ts-expect-error TS2740
+        return config;
+    }
+    config = new AtlaspackConfig_1.AtlaspackConfig(processedConfig, options);
+    atlaspackConfigCache.set(cachePath, config);
+    // @ts-expect-error TS2322
+    return config;
+}
+async function loadAtlaspackConfig(options) {
+    let atlaspackConfig = await resolveAtlaspackConfig(options);
+    if (!atlaspackConfig) {
+        throw new Error('Could not find a .parcelrc');
+    }
+    return atlaspackConfig;
+}
+async function resolveAtlaspackConfig(options) {
+    let resolveFrom = getResolveFrom(options.inputFS, options.projectRoot);
+    let configPath = options.config != null
+        ? (await options.packageManager.resolve(options.config, resolveFrom))
+            .resolved
+        : await (0, utils_1.resolveConfig)(options.inputFS, resolveFrom, ['.parcelrc'], options.projectRoot);
+    let usedDefault = false;
+    if (configPath == null && options.defaultConfig != null) {
+        usedDefault = true;
+        configPath = (await options.packageManager.resolve(options.defaultConfig, resolveFrom)).resolved;
+    }
+    if (configPath == null) {
+        return null;
+    }
+    let contents;
+    try {
+        contents = await options.inputFS.readFile(configPath, 'utf8');
+    }
+    catch (e) {
+        throw new diagnostic_1.default({
+            diagnostic: {
+                message: (0, diagnostic_1.md) `Could not find parcel config at ${path_1.default.relative(options.projectRoot, configPath)}`,
+                origin: '@atlaspack/core',
+            },
+        });
+    }
+    let { config, extendedFiles } = await parseAndProcessConfig(configPath, contents, options);
+    if (options.additionalReporters.length > 0) {
+        config.reporters = [
+            ...options.additionalReporters.map(({ packageName, resolveFrom }) => ({
+                packageName,
+                resolveFrom,
+            })),
+            ...(config.reporters ?? []),
+        ];
+    }
+    return { config, extendedFiles, usedDefault };
+}
+function create(config, options) {
+    return processConfigChain(config, config.filePath, options);
+}
+// eslint-disable-next-line require-await
+async function parseAndProcessConfig(configPath, contents, options) {
+    let config;
+    try {
+        config = (0, json5_1.parse)(contents);
+    }
+    catch (e) {
+        let pos = {
+            line: e.lineNumber,
+            column: e.columnNumber,
+        };
+        throw new diagnostic_1.default({
+            diagnostic: {
+                message: `Failed to parse .parcelrc`,
+                origin: '@atlaspack/core',
+                codeFrames: [
+                    {
+                        filePath: configPath,
+                        language: 'json5',
+                        code: contents,
+                        codeHighlights: [
+                            {
+                                start: pos,
+                                end: pos,
+                                message: (0, diagnostic_1.escapeMarkdown)(e.message),
+                            },
+                        ],
+                    },
+                ],
+            },
+        });
+    }
+    return processConfigChain(config, configPath, options);
+}
+function processPipeline(options, pipeline, keyPath, filePath) {
+    if (pipeline) {
+        return pipeline.map((pkg, i) => {
+            if (pkg === '...')
+                return pkg;
+            return {
+                packageName: pkg,
+                resolveFrom: (0, projectPath_1.toProjectPath)(options.projectRoot, filePath),
+                keyPath: `${keyPath}/${i}`,
+            };
+        });
+    }
+}
+const RESERVED_PIPELINES = new Set([
+    'node:',
+    'npm:',
+    'http:',
+    'https:',
+    'data:',
+    'tel:',
+    'mailto:',
+]);
+async function processMap(map, keyPath, filePath, options) {
+    if (!map)
+        return undefined;
+    let res = {};
+    for (let k in map) {
+        let i = k.indexOf(':');
+        if (i > 0 && RESERVED_PIPELINES.has(k.slice(0, i + 1))) {
+            let code = await options.inputFS.readFile(filePath, 'utf8');
+            throw new diagnostic_1.default({
+                diagnostic: {
+                    message: `Named pipeline '${k.slice(0, i + 1)}' is reserved.`,
+                    origin: '@atlaspack/core',
+                    codeFrames: [
+                        {
+                            filePath: filePath,
+                            language: 'json5',
+                            code,
+                            codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(code, [
+                                {
+                                    key: `${keyPath}/${k}`,
+                                    type: 'key',
+                                },
+                            ]),
+                        },
+                    ],
+                    documentationURL: 'https://parceljs.org/features/dependency-resolution/#url-schemes',
+                },
+            });
+        }
+        if (typeof map[k] === 'string') {
+            res[k] = {
+                packageName: map[k],
+                resolveFrom: (0, projectPath_1.toProjectPath)(options.projectRoot, filePath),
+                keyPath: `${keyPath}/${k}`,
+            };
+        }
+        else {
+            res[k] = processPipeline(options, map[k], `${keyPath}/${k}`, filePath);
+        }
+    }
+    return res;
+}
+async function processConfig(configFile, options) {
+    return {
+        filePath: (0, projectPath_1.toProjectPath)(options.projectRoot, configFile.filePath),
+        ...(configFile.resolveFrom != null
+            ? {
+                resolveFrom: (0, projectPath_1.toProjectPath)(options.projectRoot, configFile.resolveFrom),
+            }
+            : {
+            /*::...null*/
+            }),
+        // @ts-expect-error TS2322
+        resolvers: processPipeline(options, configFile.resolvers, '/resolvers', configFile.filePath),
+        transformers: await processMap(configFile.transformers, '/transformers', configFile.filePath, options),
+        bundler: configFile.bundler != null
+            ? {
+                packageName: configFile.bundler,
+                resolveFrom: (0, projectPath_1.toProjectPath)(options.projectRoot, configFile.filePath),
+                keyPath: '/bundler',
+            }
+            : undefined,
+        // @ts-expect-error TS2322
+        namers: processPipeline(options, configFile.namers, '/namers', configFile.filePath),
+        // @ts-expect-error TS2322
+        runtimes: processPipeline(options, configFile.runtimes, '/runtimes', configFile.filePath),
+        packagers: await processMap(configFile.packagers, '/packagers', configFile.filePath, options),
+        optimizers: await processMap(configFile.optimizers, '/optimizers', configFile.filePath, options),
+        compressors: await processMap(configFile.compressors, '/compressors', configFile.filePath, options),
+        // @ts-expect-error TS2322
+        reporters: processPipeline(options, configFile.reporters, '/reporters', configFile.filePath),
+        validators: await processMap(configFile.validators, '/validators', configFile.filePath, options),
+    };
+}
+async function processConfigChain(configFile, filePath, options) {
+    // Validate config...
+    let relativePath = path_1.default.relative(options.inputFS.cwd(), filePath);
+    validateConfigFile(configFile, relativePath);
+    // Process config...
+    let config = await processConfig({
+        filePath,
+        ...configFile,
+    }, options);
+    let extendedFiles = [];
+    if (configFile.extends != null) {
+        let exts = Array.isArray(configFile.extends)
+            ? configFile.extends
+            : [configFile.extends];
+        let errors = [];
+        if (exts.length !== 0) {
+            let extStartConfig;
+            let i = 0;
+            for (let ext of exts) {
+                try {
+                    let key = Array.isArray(configFile.extends)
+                        ? `/extends/${i}`
+                        : '/extends';
+                    let resolved = await resolveExtends(ext, filePath, key, options);
+                    extendedFiles.push(resolved);
+                    let { extendedFiles: moreExtendedFiles, config: nextConfig } = await processExtendedConfig(filePath, key, ext, resolved, options);
+                    extendedFiles = extendedFiles.concat(moreExtendedFiles);
+                    extStartConfig = extStartConfig
+                        ? mergeConfigs(extStartConfig, nextConfig)
+                        : nextConfig;
+                }
+                catch (err) {
+                    errors.push(err);
+                }
+                i++;
+            }
+            // Merge with the inline config last
+            if (extStartConfig) {
+                config = mergeConfigs(extStartConfig, config);
+            }
+        }
+        if (errors.length > 0) {
+            throw new diagnostic_1.default({
+                diagnostic: errors.flatMap((e) => e.diagnostics ?? (0, diagnostic_1.errorToDiagnostic)(e)),
+            });
+        }
+    }
+    return { config, extendedFiles };
+}
+async function resolveExtends(ext, configPath, extendsKey, options) {
+    if (ext.startsWith('.')) {
+        return path_1.default.resolve(path_1.default.dirname(configPath), ext);
+    }
+    else {
+        try {
+            let { resolved } = await options.packageManager.resolve(ext, configPath);
+            return options.inputFS.realpath(resolved);
+        }
+        catch (err) {
+            let parentContents = await options.inputFS.readFile(configPath, 'utf8');
+            let alternatives = await (0, utils_1.findAlternativeNodeModules)(options.inputFS, ext, path_1.default.dirname(configPath));
+            throw new diagnostic_1.default({
+                diagnostic: {
+                    message: `Cannot find extended parcel config`,
+                    origin: '@atlaspack/core',
+                    codeFrames: [
+                        {
+                            filePath: configPath,
+                            language: 'json5',
+                            code: parentContents,
+                            codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(parentContents, [
+                                {
+                                    key: extendsKey,
+                                    type: 'value',
+                                    message: (0, diagnostic_1.md) `Cannot find module "${ext}"${alternatives[0]
+                                        ? `, did you mean "${alternatives[0]}"?`
+                                        : ''}`,
+                                },
+                            ]),
+                        },
+                    ],
+                },
+            });
+        }
+    }
+}
+async function processExtendedConfig(configPath, extendsKey, extendsSpecifier, resolvedExtendedConfigPath, options) {
+    let contents;
+    try {
+        contents = await options.inputFS.readFile(resolvedExtendedConfigPath, 'utf8');
+    }
+    catch (e) {
+        let parentContents = await options.inputFS.readFile(configPath, 'utf8');
+        let alternatives = await (0, utils_1.findAlternativeFiles)(options.inputFS, extendsSpecifier, path_1.default.dirname(resolvedExtendedConfigPath), options.projectRoot);
+        throw new diagnostic_1.default({
+            diagnostic: {
+                message: 'Cannot find extended parcel config',
+                origin: '@atlaspack/core',
+                codeFrames: [
+                    {
+                        filePath: configPath,
+                        language: 'json5',
+                        code: parentContents,
+                        codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(parentContents, [
+                            {
+                                key: extendsKey,
+                                type: 'value',
+                                message: (0, diagnostic_1.md) `"${extendsSpecifier}" does not exist${alternatives[0] ? `, did you mean "${alternatives[0]}"?` : ''}`,
+                            },
+                        ]),
+                    },
+                ],
+            },
+        });
+    }
+    return parseAndProcessConfig(resolvedExtendedConfigPath, contents, options);
+}
+function validateConfigFile(config, relativePath) {
+    try {
+        validateNotEmpty(config, relativePath);
+    }
+    catch (e) {
+        throw new diagnostic_1.default({
+            diagnostic: {
+                message: e.message,
+                origin: '@atlaspack/core',
+            },
+        });
+    }
+    utils_1.validateSchema.diagnostic(AtlaspackConfig_schema_1.default, { data: config, filePath: relativePath }, '@atlaspack/core', 'Invalid Parcel Config');
+}
+function validateNotEmpty(config, relativePath) {
+    assert_1.default.notDeepStrictEqual(config, {}, `${relativePath} can't be empty`);
+}
+function mergeConfigs(base, ext) {
+    return {
+        filePath: ext.filePath,
+        resolvers: assertPurePipeline(mergePipelines(base.resolvers, ext.resolvers)),
+        transformers: mergeMaps(base.transformers, ext.transformers, mergePipelines),
+        validators: mergeMaps(base.validators, ext.validators, mergePipelines),
+        bundler: ext.bundler || base.bundler,
+        namers: assertPurePipeline(mergePipelines(base.namers, ext.namers)),
+        runtimes: assertPurePipeline(mergePipelines(base.runtimes, ext.runtimes)),
+        packagers: mergeMaps(base.packagers, ext.packagers),
+        optimizers: mergeMaps(base.optimizers, ext.optimizers, mergePipelines),
+        compressors: mergeMaps(base.compressors, ext.compressors, mergePipelines),
+        reporters: assertPurePipeline(mergePipelines(base.reporters, ext.reporters)),
+    };
+}
+function getResolveFrom(fs, projectRoot) {
+    let cwd = fs.cwd();
+    let dir = (0, utils_1.isDirectoryInside)(cwd, projectRoot) ? cwd : projectRoot;
+    return path_1.default.join(dir, 'index');
+}
+function assertPurePipeline(pipeline) {
+    return pipeline.map((s) => {
+        (0, assert_1.default)(typeof s !== 'string');
+        return s;
+    });
+}
+function mergePipelines(base, ext) {
+    if (ext == null) {
+        return base ?? [];
+    }
+    if (ext.filter((v) => v === '...').length > 1) {
+        throw new Error('Only one spread element can be included in a config pipeline');
+    }
+    // Merge the base pipeline if a rest element is defined
+    let spreadIndex = ext.indexOf('...');
+    if (spreadIndex >= 0) {
+        return [
+            ...ext.slice(0, spreadIndex),
+            ...(base ?? []),
+            ...ext.slice(spreadIndex + 1),
+        ];
+    }
+    else {
+        return ext;
+    }
+}
+function mergeMaps(base, ext, merger) {
+    if (!ext || Object.keys(ext).length === 0) {
+        return base || {};
+    }
+    if (!base) {
+        return ext;
+    }
+    let res = {};
+    // Add the extension options first so they have higher precedence in the output glob map
+    for (let k in ext) {
+        let key = k;
+        res[key] =
+            // @ts-expect-error TS2345
+            merger && base[key] != null ? merger(base[key], ext[key]) : ext[key];
+    }
+    // Add base options that aren't defined in the extension
+    for (let k in base) {
+        let key = k;
+        if (res[key] == null) {
+            res[key] = base[key];
+        }
+    }
+    return res;
+}