snowpack/lib/config.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.loadConfiguration = exports.createConfiguration = exports.validatePluginLoadResult = exports.expandCliFlags = exports.DEFAULT_PACKAGES_LOCAL_CONFIG = void 0;
const deepmerge_1 = require("deepmerge");
const fs_1 = require("fs");
const is_plain_object_1 = require("is-plain-object");
const jsonschema_1 = require("jsonschema");
const colors_1 = require("kleur/colors");
const os_1 = __importDefault(require("os"));
const path_1 = __importDefault(require("path"));
const logger_1 = require("./logger");
const plugin_esbuild_1 = require("./plugins/plugin-esbuild");
const util_1 = require("./util");
const CONFIG_NAME = 'snowpack';
const ALWAYS_EXCLUDE = ['**/node_modules/**/*'];
// default settings
const DEFAULT_ROOT = process.cwd();
const DEFAULT_CONFIG = {
    root: DEFAULT_ROOT,
    plugins: [],
    alias: {},
    exclude: [],
    routes: [],
    devOptions: {
        secure: false,
        hostname: 'localhost',
        port: 8080,
        open: 'default',
        output: 'dashboard',
        hmrDelay: 0,
        hmrPort: undefined,
        hmrErrorOverlay: true,
    },
    buildOptions: {
        out: 'build',
        baseUrl: '/',
        metaUrlPath: '_snowpack',
        clean: true,
        sourcemap: false,
        watch: false,
        htmlFragments: false,
        ssr: false,
    },
    testOptions: {
        files: ['__tests__/**/*', '**/*.@(spec|test).*'],
    },
    packageOptions: { source: 'local' },
};
exports.DEFAULT_PACKAGES_LOCAL_CONFIG = {
    source: 'local',
    external: [],
    packageLookupFields: [],
    knownEntrypoints: [],
};
const REMOTE_PACKAGE_ORIGIN = 'https://pkg.snowpack.dev';
const DEFAULT_PACKAGES_REMOTE_CONFIG = {
    source: 'remote',
    origin: REMOTE_PACKAGE_ORIGIN,
    external: [],
    cache: '.snowpack',
    types: false,
};
const configSchema = {
    type: 'object',
    properties: {
        extends: { type: 'string' },
        exclude: { type: 'array', items: { type: 'string' } },
        plugins: { type: 'array' },
        alias: {
            type: 'object',
            additionalProperties: { type: 'string' },
        },
        mount: {
            type: 'object',
            additionalProperties: {
                oneOf: [
                    { type: 'string' },
                    {
                        type: ['object'],
                        properties: {
                            url: { type: 'string' },
                            static: { type: 'boolean' },
                            resolve: { type: 'boolean' },
                        },
                    },
                ],
            },
        },
        devOptions: {
            type: 'object',
            properties: {
                secure: { type: 'boolean' },
                port: { type: 'number' },
                bundle: { type: 'boolean' },
                open: { type: 'string' },
                output: { type: 'string', enum: ['stream', 'dashboard'] },
                hmr: { type: 'boolean' },
                hmrDelay: { type: 'number' },
                hmrPort: { type: 'number' },
                hmrErrorOverlay: { type: 'boolean' },
            },
        },
        packageOptions: {
            type: 'object',
            properties: {
                dest: { type: 'string' },
                external: { type: 'array', items: { type: 'string' } },
                treeshake: { type: 'boolean' },
                installTypes: { type: 'boolean' },
                polyfillNode: { type: 'boolean' },
                env: {
                    type: 'object',
                    additionalProperties: {
                        oneOf: [
                            { id: 'EnvVarString', type: 'string' },
                            { id: 'EnvVarNumber', type: 'number' },
                            { id: 'EnvVarTrue', type: 'boolean', enum: [true] },
                        ],
                    },
                },
                rollup: {
                    type: 'object',
                    properties: {
                        context: { type: 'string' },
                        plugins: { type: 'array', items: { type: 'object' } },
                        dedupe: {
                            type: 'array',
                            items: { type: 'string' },
                        },
                    },
                },
            },
        },
        buildOptions: {
            type: ['object'],
            properties: {
                out: { type: 'string' },
                baseUrl: { type: 'string' },
                clean: { type: 'boolean' },
                sourcemap: { type: 'boolean' },
                watch: { type: 'boolean' },
                ssr: { type: 'boolean' },
                htmlFragments: { type: 'boolean' },
                jsxFactory: { type: 'string' },
                jsxFragment: { type: 'string' },
            },
        },
        testOptions: {
            type: 'object',
            properties: {
                files: { type: 'array', items: { type: 'string' } },
            },
        },
        experiments: {
            type: ['object'],
            properties: {},
        },
        optimize: {
            type: ['object'],
            properties: {},
        },
        proxy: {
            type: 'object',
        },
    },
};
/**
 * Convert CLI flags to an incomplete Snowpack config representation.
 * We need to be careful about setting properties here if the flag value
 * is undefined, since the deep merge strategy would then overwrite good
 * defaults with 'undefined'.
 */
function expandCliFlags(flags) {
    const result = {
        packageOptions: {},
        devOptions: {},
        buildOptions: {},
        experiments: {},
    };
    const { help, version, reload, config, ...relevantFlags } = flags;
    const CLI_ONLY_FLAGS = ['quiet', 'verbose'];
    for (const [flag, val] of Object.entries(relevantFlags)) {
        if (flag === '_' || flag.includes('-')) {
            continue;
        }
        if (configSchema.properties[flag]) {
            result[flag] = val;
            continue;
        }
        if (flag === 'source') {
            result.packageOptions = { source: val };
            continue;
        }
        if (configSchema.properties.experiments.properties[flag]) {
            result.experiments[flag] = val;
            continue;
        }
        if (configSchema.properties.optimize.properties[flag]) {
            result.optimize = result.optimize || {};
            result.optimize[flag] = val;
            continue;
        }
        if (configSchema.properties.packageOptions.properties[flag]) {
            result.packageOptions[flag] = val;
            continue;
        }
        if (configSchema.properties.devOptions.properties[flag]) {
            result.devOptions[flag] = val;
            continue;
        }
        if (configSchema.properties.buildOptions.properties[flag]) {
            result.buildOptions[flag] = val;
            continue;
        }
        if (CLI_ONLY_FLAGS.includes(flag)) {
            continue;
        }
        logger_1.logger.error(`Unknown CLI flag: "${flag}"`);
        process.exit(1);
    }
    if (result.packageOptions.env) {
        result.packageOptions.env = result.packageOptions.env.reduce((acc, id) => {
            const index = id.indexOf('=');
            const [key, val] = index > 0 ? [id.substr(0, index), id.substr(index + 1)] : [id, true];
            acc[key] = val;
            return acc;
        }, {});
    }
    return result;
}
exports.expandCliFlags = expandCliFlags;
/** load and normalize plugins from config */
function loadPlugins(config) {
    const plugins = [];
    function execPluginFactory(pluginFactory, pluginOptions = {}) {
        let plugin = null;
        plugin = pluginFactory(config, pluginOptions);
        return plugin;
    }
    function loadPluginFromConfig(pluginLoc, options) {
        if (!path_1.default.isAbsolute(pluginLoc)) {
            throw new Error(`Snowpack Internal Error: plugin ${pluginLoc} should have been resolved to an absolute path.`);
        }
        const pluginRef = util_1.NATIVE_REQUIRE(pluginLoc);
        let plugin;
        try {
            plugin = typeof pluginRef.default === 'function' ? pluginRef.default : pluginRef;
            if (typeof plugin !== 'function')
                logger_1.logger.error(`plugin ${pluginLoc} must export a function.`);
            plugin = execPluginFactory(plugin, options);
        }
        catch (err) {
            logger_1.logger.error(err.toString());
            throw err;
        }
        if (!plugin.name) {
            plugin.name = path_1.default.relative(process.cwd(), pluginLoc);
        }
        // Add any internal plugin methods. Placeholders are okay when individual
        // commands implement these differently.
        plugin.markChanged = (file) => {
            logger_1.logger.debug(`clearCache(${file}) called, but function not yet hooked up.`, {
                name: plugin.name,
            });
        };
        // Finish up.
        validatePlugin(plugin);
        return plugin;
    }
    // 2. config.plugins
    config.plugins.forEach((ref) => {
        const pluginName = Array.isArray(ref) ? ref[0] : ref;
        const pluginOptions = Array.isArray(ref) ? ref[1] : {};
        const plugin = loadPluginFromConfig(pluginName, pluginOptions);
        logger_1.logger.debug(`loaded plugin: ${pluginName}`);
        plugins.push(plugin);
    });
    // add internal JS handler plugin
    plugins.push(execPluginFactory(plugin_esbuild_1.esbuildPlugin, { input: ['.mjs', '.jsx', '.ts', '.tsx'] }));
    const extensionMap = plugins.reduce((map, { resolve }) => {
        if (resolve) {
            for (const inputExt of resolve.input) {
                map[inputExt] = resolve.output;
            }
        }
        return map;
    }, {});
    return {
        plugins,
        extensionMap,
    };
}
function normalizeMount(config) {
    var _a, _b;
    const mountedDirs = config.mount || {};
    const normalizedMount = {};
    for (const [mountDir, rawMountEntry] of Object.entries(mountedDirs)) {
        const mountEntry = typeof rawMountEntry === 'string'
            ? { url: rawMountEntry, static: false, resolve: true }
            : rawMountEntry;
        if (!mountEntry.url) {
            handleConfigError(`mount[${mountDir}]: Object "${mountEntry.url}" missing required "url" option.`);
            return normalizedMount;
        }
        if (mountEntry.url[0] !== '/') {
            handleConfigError(`mount[${mountDir}]: Value "${mountEntry.url}" must be a URL path, and start with a "/"`);
        }
        normalizedMount[util_1.removeTrailingSlash(mountDir)] = {
            url: mountEntry.url === '/' ? '/' : util_1.removeTrailingSlash(mountEntry.url),
            static: (_a = mountEntry.static) !== null && _a !== void 0 ? _a : false,
            resolve: (_b = mountEntry.resolve) !== null && _b !== void 0 ? _b : true,
        };
    }
    // if no mounted directories, mount the root directory to the base URL
    if (!Object.keys(normalizedMount).length) {
        normalizedMount[process.cwd()] = {
            url: '/',
            static: false,
            resolve: true,
        };
    }
    return normalizedMount;
}
function normalizeRoutes(routes) {
    return routes.map(({ src, dest, match }, i) => {
        // Normalize
        if (typeof dest === 'string') {
            dest = util_1.addLeadingSlash(dest);
        }
        if (!src.startsWith('^')) {
            src = '^' + src;
        }
        if (!src.endsWith('$')) {
            src = src + '$';
        }
        // Validate
        try {
            return { src, dest, match: match || 'all', _srcRegex: new RegExp(src) };
        }
        catch (err) {
            throw new Error(`config.routes[${i}].src: invalid regular expression syntax "${src}"`);
        }
    });
}
/** resolve --dest relative to cwd, etc. */
function normalizeConfig(_config) {
    var _a, _b, _c, _d, _e, _f, _g, _h;
    // TODO: This function is really fighting with TypeScript. Now that we have an accurate
    // SnowpackUserConfig type, we can have this function construct a fresh config object
    // from scratch instead of trying to modify the user's config object in-place.
    let config = _config;
    if (config.packageOptions.source === 'local') {
        config.packageOptions.rollup = config.packageOptions.rollup || {};
        config.packageOptions.rollup.plugins = config.packageOptions.rollup.plugins || [];
    }
    config.exclude = Array.from(new Set([...ALWAYS_EXCLUDE, `${config.buildOptions.out}/**/*`, ...config.exclude]));
    // normalize config URL/path values
    config.buildOptions.out = util_1.removeTrailingSlash(config.buildOptions.out);
    config.buildOptions.baseUrl = util_1.addTrailingSlash(config.buildOptions.baseUrl);
    config.buildOptions.metaUrlPath = util_1.removeTrailingSlash(util_1.addLeadingSlash(config.buildOptions.metaUrlPath));
    config.mount = normalizeMount(config);
    config.routes = normalizeRoutes(config.routes);
    if (config.optimize && JSON.stringify(config.optimize) !== '{}') {
        config.optimize = {
            entrypoints: (_a = config.optimize.entrypoints) !== null && _a !== void 0 ? _a : 'auto',
            preload: (_b = config.optimize.preload) !== null && _b !== void 0 ? _b : false,
            bundle: (_c = config.optimize.bundle) !== null && _c !== void 0 ? _c : false,
            splitting: (_d = config.optimize.splitting) !== null && _d !== void 0 ? _d : false,
            treeshake: (_e = config.optimize.treeshake) !== null && _e !== void 0 ? _e : true,
            manifest: (_f = config.optimize.manifest) !== null && _f !== void 0 ? _f : false,
            target: (_g = config.optimize.target) !== null && _g !== void 0 ? _g : 'es2020',
            minify: (_h = config.optimize.minify) !== null && _h !== void 0 ? _h : false,
        };
    }
    else {
        config.optimize = undefined;
    }
    // new pipeline
    const { plugins, extensionMap } = loadPlugins(config);
    config.plugins = plugins;
    config._extensionMap = extensionMap;
    // If any plugins defined knownEntrypoints, add them here
    for (const { knownEntrypoints } of config.plugins) {
        if (knownEntrypoints && config.packageOptions.source === 'local') {
            config.packageOptions.knownEntrypoints = config.packageOptions.knownEntrypoints.concat(knownEntrypoints);
        }
    }
    plugins.forEach((plugin) => {
        if (plugin.config) {
            plugin.config(config);
        }
    });
    return config;
}
function handleConfigError(msg) {
    logger_1.logger.error(msg);
    process.exit(1);
}
function handleValidationErrors(filepath, err) {
    logger_1.logger.error(`! ${filepath}\n${err.message}`);
    logger_1.logger.info(colors_1.dim(`See https://www.snowpack.dev for more info.`));
    process.exit(1);
}
function handleDeprecatedConfigError(mainMsg, ...msgs) {
    logger_1.logger.error(`${mainMsg}
${msgs.join('\n')}
See https://www.snowpack.dev for more info.`);
    process.exit(1);
}
function valdiateDeprecatedConfig(rawConfig) {
    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
    if (rawConfig.scripts) {
        handleDeprecatedConfigError('[v3.0] Legacy "scripts" config is deprecated in favor of "plugins". Safe to remove if empty.');
    }
    if (rawConfig.proxy) {
        handleDeprecatedConfigError('[v3.0] Legacy "proxy" config is deprecated in favor of "routes". Safe to remove if empty.');
    }
    if ((_a = rawConfig.buildOptions) === null || _a === void 0 ? void 0 : _a.metaDir) {
        handleDeprecatedConfigError('[v3.0] "config.buildOptions.metaDir" is now "config.buildOptions.metaUrlPath".');
    }
    if ((_b = rawConfig.buildOptions) === null || _b === void 0 ? void 0 : _b.webModulesUrl) {
        handleDeprecatedConfigError('[v3.0] "config.buildOptions.webModulesUrl" is now always set within the "config.buildOptions.metaUrlPath" directory.');
    }
    if ((_c = rawConfig.buildOptions) === null || _c === void 0 ? void 0 : _c.sourceMaps) {
        handleDeprecatedConfigError('[v3.0] "config.buildOptions.sourceMaps" is now "config.buildOptions.sourcemap".');
    }
    if (rawConfig.installOptions) {
        handleDeprecatedConfigError('[v3.0] "config.installOptions" is now "config.packageOptions". Safe to remove if empty.');
    }
    if ((_d = rawConfig.packageOptions) === null || _d === void 0 ? void 0 : _d.externalPackage) {
        handleDeprecatedConfigError('[v3.0] "config.installOptions.externalPackage" is now "config.packageOptions.external".');
    }
    if ((_e = rawConfig.packageOptions) === null || _e === void 0 ? void 0 : _e.treeshake) {
        handleDeprecatedConfigError('[v3.0] "config.installOptions.treeshake" is now "config.optimize.treeshake".');
    }
    if (rawConfig.install) {
        handleDeprecatedConfigError('[v3.0] "config.install" is now "config.packageOptions.knownEntrypoints". Safe to remove if empty.');
    }
    if ((_f = rawConfig.experiments) === null || _f === void 0 ? void 0 : _f.source) {
        handleDeprecatedConfigError('[v3.0] Experiment promoted! "config.experiments.source" is now "config.packageOptions.source".');
    }
    if (((_g = rawConfig.packageOptions) === null || _g === void 0 ? void 0 : _g.source) === 'skypack') {
        handleDeprecatedConfigError('[v3.0] Renamed! "config.experiments.source=skypack" is now "config.packageOptions.source=remote".');
    }
    if ((_h = rawConfig.experiments) === null || _h === void 0 ? void 0 : _h.ssr) {
        handleDeprecatedConfigError('[v3.0] Experiment promoted! "config.experiments.ssr" is now "config.buildOptions.ssr".');
    }
    if ((_j = rawConfig.experiments) === null || _j === void 0 ? void 0 : _j.optimize) {
        handleDeprecatedConfigError('[v3.0] Experiment promoted! "config.experiments.optimize" is now "config.optimize".');
    }
    if ((_k = rawConfig.experiments) === null || _k === void 0 ? void 0 : _k.routes) {
        handleDeprecatedConfigError('[v3.0] Experiment promoted! "config.experiments.routes" is now "config.routes".');
    }
    if ((_l = rawConfig.devOptions) === null || _l === void 0 ? void 0 : _l.fallback) {
        handleDeprecatedConfigError('[v3.0] Deprecated! "devOptions.fallback" is now replaced by "routes".\n' +
            'More info: https://www.snowpack.dev/guides/routing');
    }
}
function validatePlugin(plugin) {
    const pluginName = plugin.name;
    if (plugin.resolve && !plugin.load) {
        handleConfigError(`[${pluginName}] "resolve" config found but "load()" method missing.`);
    }
    if (!plugin.resolve && plugin.load) {
        handleConfigError(`[${pluginName}] "load" method found but "resolve()" config missing.`);
    }
    if (plugin.resolve && !Array.isArray(plugin.resolve.input)) {
        handleConfigError(`[${pluginName}] "resolve.input" should be an array of input file extensions.`);
    }
    if (plugin.resolve && !Array.isArray(plugin.resolve.output)) {
        handleConfigError(`[${pluginName}] "resolve.output" should be an array of output file extensions.`);
    }
}
function validatePluginLoadResult(plugin, result) {
    const pluginName = plugin.name;
    if (!result) {
        return;
    }
    const isValidSingleResultType = typeof result === 'string' || Buffer.isBuffer(result);
    if (isValidSingleResultType && plugin.resolve.output.length !== 1) {
        handleConfigError(`[plugin=${pluginName}] "load()" returned a string, but "resolve.output" contains multiple possible outputs. If multiple outputs are expected, the object return format is required.`);
    }
    const unexpectedOutput = typeof result === 'object' &&
        Object.keys(result).find((fileExt) => !plugin.resolve.output.includes(fileExt));
    if (unexpectedOutput) {
        handleConfigError(`[plugin=${pluginName}] "load()" returned entry "${unexpectedOutput}" not found in "resolve.output": ${plugin.resolve.output}`);
    }
}
exports.validatePluginLoadResult = validatePluginLoadResult;
/**
 * Get the config base path, that all relative config values should resolve to. In order:
 *   - The directory of the config file path, if it exists.
 *   - The config.root value, if given.
 *   - Otherwise, the current working directory of the process.
 */
function getConfigBasePath(configFileLoc, configRoot) {
    return ((configFileLoc && path_1.default.dirname(configFileLoc)) ||
        (configRoot && path_1.default.resolve(process.cwd(), configRoot)) ||
        process.cwd());
}
function resolveRelativeConfigAlias(aliasConfig, configBase) {
    const cleanAliasConfig = {};
    for (const [target, replacement] of Object.entries(aliasConfig)) {
        const isDirectory = target.endsWith('/');
        const isPath = replacement === '.' ||
            replacement === '..' ||
            replacement.startsWith('./') ||
            replacement.startsWith('../') ||
            replacement.startsWith('/');
        if (isPath) {
            cleanAliasConfig[target] = isDirectory
                ? util_1.addTrailingSlash(path_1.default.resolve(configBase, replacement))
                : util_1.removeTrailingSlash(path_1.default.resolve(configBase, replacement));
        }
        else {
            cleanAliasConfig[target] = replacement;
        }
    }
    return cleanAliasConfig;
}
function resolveRelativeConfigMount(mountConfig, configBase) {
    const cleanMountConfig = {};
    for (const [target, replacement] of Object.entries(mountConfig)) {
        cleanMountConfig[path_1.default.resolve(configBase, target)] = replacement;
    }
    return cleanMountConfig;
}
function resolveRelativeConfig(config, configBase) {
    var _a, _b;
    if (config.root) {
        config.root = path_1.default.resolve(configBase, config.root);
    }
    if ((_a = config.buildOptions) === null || _a === void 0 ? void 0 : _a.out) {
        config.buildOptions.out = path_1.default.resolve(configBase, config.buildOptions.out);
    }
    if (((_b = config.packageOptions) === null || _b === void 0 ? void 0 : _b.source) === 'remote' && config.packageOptions.cache) {
        config.packageOptions.cache = path_1.default.resolve(configBase, config.packageOptions.cache);
    }
    if (config.extends && /^[\.\/\\]/.test(config.extends)) {
        config.extends = path_1.default.resolve(configBase, config.extends);
    }
    if (config.plugins) {
        config.plugins = config.plugins.map((plugin) => {
            const name = Array.isArray(plugin) ? plugin[0] : plugin;
            const absName = path_1.default.isAbsolute(name) ? name : require.resolve(name, { paths: [configBase] });
            if (Array.isArray(plugin)) {
                plugin.splice(0, 1, absName);
                return plugin;
            }
            return absName;
        });
    }
    if (config.mount) {
        config.mount = resolveRelativeConfigMount(config.mount, configBase);
    }
    if (config.alias) {
        config.alias = resolveRelativeConfigAlias(config.alias, configBase);
    }
    return config;
}
class ConfigValidationError extends Error {
    constructor(errors) {
        super(`Configuration Error:\n${errors.map((err) => `  - ${err.toString()}`).join(os_1.default.EOL)}`);
    }
}
function validateConfig(config) {
    for (const mountDir of Object.keys(config.mount)) {
        if (!fs_1.existsSync(mountDir)) {
            logger_1.logger.warn(`config.mount[${mountDir}]: mounted directory does not exist.`);
        }
    }
}
function createConfiguration(config = {}) {
    var _a;
    // Validate the configuration object against our schema. Report any errors.
    const { errors: validationErrors } = jsonschema_1.validate(config, configSchema, {
        propertyName: CONFIG_NAME,
        allowUnknownAttributes: false,
    });
    if (validationErrors.length > 0) {
        throw new ConfigValidationError(validationErrors);
    }
    // Inherit any undefined values from the default configuration. If no config argument
    // was passed (or no configuration file found in loadConfiguration) then this function
    // will effectively return a copy of the DEFAULT_CONFIG object.
    const mergedConfig = deepmerge_1.all([
        DEFAULT_CONFIG,
        {
            packageOptions: ((_a = config.packageOptions) === null || _a === void 0 ? void 0 : _a.source) === 'remote'
                ? DEFAULT_PACKAGES_REMOTE_CONFIG
                : exports.DEFAULT_PACKAGES_LOCAL_CONFIG,
        },
        config,
    ], {
        isMergeableObject: (val) => is_plain_object_1.isPlainObject(val) || Array.isArray(val),
    });
    // Resolve relative config values. If using loadConfiguration, all config values should
    // already be resolved relative to the config file path so that this should be a no-op.
    // But, we still need to run it in case you called this function directly.
    const configBase = getConfigBasePath(undefined, config.root);
    resolveRelativeConfig(mergedConfig, configBase);
    const normalizedConfig = normalizeConfig(mergedConfig);
    validateConfig(normalizedConfig);
    return normalizedConfig;
}
exports.createConfiguration = createConfiguration;
function loadConfigurationFile(filename) {
    const loc = path_1.default.resolve(process.cwd(), filename);
    if (!fs_1.existsSync(loc)) {
        return null;
    }
    return { filepath: loc, config: util_1.NATIVE_REQUIRE(loc) };
}
async function loadConfiguration(overrides = {}, configPath) {
    let result = null;
    // if user specified --config path, load that
    if (configPath) {
        result = loadConfigurationFile(configPath);
        if (!result) {
            throw new Error(`Snowpack config file could not be found: ${configPath}`);
        }
    }
    // If no config was found above, search for one.
    result =
        result ||
            loadConfigurationFile('snowpack.config.mjs') ||
            loadConfigurationFile('snowpack.config.cjs') ||
            loadConfigurationFile('snowpack.config.js') ||
            loadConfigurationFile('snowpack.config.json');
    // Support package.json "snowpack" config
    if (!result) {
        const potentialPackageJsonConfig = loadConfigurationFile('package.json');
        if (potentialPackageJsonConfig && potentialPackageJsonConfig.config.snowpack) {
            result = {
                filepath: potentialPackageJsonConfig.filepath,
                config: potentialPackageJsonConfig.config.snowpack,
            };
        }
    }
    if (!result) {
        logger_1.logger.warn('Hint: run "snowpack init" to create a project config file. Using defaults...');
        result = { filepath: undefined, config: {} };
    }
    const { config, filepath } = result;
    const configBase = getConfigBasePath(filepath, config.root);
    valdiateDeprecatedConfig(config);
    valdiateDeprecatedConfig(overrides);
    resolveRelativeConfig(config, configBase);
    let extendConfig = {};
    if (config.extends) {
        const extendConfigLoc = require.resolve(config.extends, { paths: [configBase] });
        const extendResult = loadConfigurationFile(extendConfigLoc);
        if (!extendResult) {
            handleConfigError(`Could not locate "extends" config at ${extendConfigLoc}`);
            process.exit(1);
        }
        extendConfig = extendResult.config;
        const extendValidation = jsonschema_1.validate(extendConfig, configSchema, {
            allowUnknownAttributes: false,
            propertyName: CONFIG_NAME,
        });
        if (extendValidation.errors && extendValidation.errors.length > 0) {
            handleValidationErrors(extendConfigLoc, new ConfigValidationError(extendValidation.errors));
        }
        valdiateDeprecatedConfig(extendConfig);
        resolveRelativeConfig(extendConfig, configBase);
    }
    // if valid, apply config over defaults
    const mergedConfig = deepmerge_1.all([extendConfig, config, overrides], {
        isMergeableObject: (val) => is_plain_object_1.isPlainObject(val) || Array.isArray(val),
    });
    try {
        return createConfiguration(mergedConfig);
    }
    catch (err) {
        if (err instanceof ConfigValidationError) {
            handleValidationErrors(filepath, err);
        }
        throw err;
    }
}
exports.loadConfiguration = loadConfiguration;