@farmfe/core/dist/config/mergeConfig.js

Farm is a extremely fast web build tool written in Rust. Farm can start a project in milliseconds and perform HMR within 10ms, making it much faster than similar tools like webpack and vite.

import path, { isAbsolute } from 'node:path';
import { isString } from '../plugin/js/utils.js';
import { isArray, isObject } from '../utils/share.js';
// eslint-disable-next-line @typescript-eslint/no-explicit-any
export function mergeConfig(userConfig, target) {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    const result = { ...userConfig };
    for (const key of Object.keys(target)) {
        const left = result[key];
        const right = target[key];
        if (right === null || right === undefined) {
            continue;
        }
        if (left === null || left === undefined) {
            result[key] = right;
            continue;
        }
        if (isArray(left) || isArray(right)) {
            result[key] = [
                ...new Set([
                    ...(isArray(left) ? left : []),
                    ...(isArray(right) ? right : [])
                ])
            ];
            continue;
        }
        if (isObject(left) && isObject(right)) {
            result[key] = mergeConfig(left, right);
            continue;
        }
        result[key] = right;
    }
    return result;
}
export function mergeFarmCliConfig(cliOption, target) {
    let left = {};
    ([
        'clearScreen',
        'compilation',
        'envDir',
        'envPrefix',
        'plugins',
        'publicDir',
        'server',
        'vitePlugins'
    ]).forEach((key) => {
        const value = cliOption[key];
        if (value || typeof value === 'boolean') {
            left = mergeConfig(left, { [key]: cliOption[key] });
        }
    });
    {
        // root
        const configRootPath = target.root;
        if (cliOption.root) {
            const cliRoot = cliOption.root;
            if (!isAbsolute(cliRoot)) {
                target.root = path.resolve(process.cwd(), cliRoot);
            }
            else {
                target.root = cliRoot;
            }
        }
        else {
            target.root = process.cwd();
        }
        if (configRootPath) {
            target.root = configRootPath;
        }
        if (target.root && !isAbsolute(target.root)) {
            const resolvedRoot = path.resolve(cliOption.configPath, target.root);
            target.root = resolvedRoot;
        }
    }
    if (isString(cliOption.host) || typeof cliOption.host === 'boolean') {
        left = mergeConfig(left, { server: { host: cliOption.host } });
    }
    if (typeof cliOption.minify === 'boolean') {
        left = mergeConfig(left, { compilation: { minify: cliOption.minify } });
    }
    if (cliOption.outDir) {
        left = mergeConfig(left, {
            compilation: { output: { path: cliOption.outDir } }
        });
    }
    if (cliOption.port) {
        left = mergeConfig(left, {
            server: {
                port: cliOption.port
            }
        });
    }
    if (cliOption.mode) {
        left = mergeConfig(left, {
            compilation: {
                mode: cliOption.mode
            }
        });
    }
    if (cliOption.https) {
        left = mergeConfig(left, {
            server: {
                https: cliOption.https
            }
        });
    }
    if (cliOption.sourcemap) {
        left = mergeConfig(left, {
            compilation: { sourcemap: cliOption.sourcemap }
        });
    }
    return mergeConfig(left, target);
}
export function initialCliOptions(options) {
    return {
        ...options
    };
}
//# sourceMappingURL=mergeConfig.js.map