siegel/lib/core/client_build/module_rules/merge.js

Web application development ecosystem

import isExists from '../../../common/is/exists/index.js';
const mergeLoaders = (userLoader, defaultLoader) => {
    const result = typeof userLoader == 'string'
        ? userLoader
        : isExists(defaultLoader) && userLoader === true
            ? defaultLoader
            : userLoader.enabled !== false
                ? {
                    ...defaultLoader,
                    ...userLoader,
                    options: typeof userLoader.options == 'function'
                        ? userLoader.options(defaultLoader.options)
                        : userLoader.options
                }
                : undefined;
    if (isExists(result) && typeof result != 'string')
        delete result['enabled'];
    return result;
};
const addRule = (rules, ruleParams) => {
    const { regExpString, ruleOptions, loadersOrder, loaders = {}, defaultLoaders = {} } = ruleParams;
    const use = [];
    loadersOrder.forEach(loaderKey => {
        const userLoader = loaders[loaderKey];
        if (userLoader != false) {
            const mergedLoaders = mergeLoaders(userLoader || true, defaultLoaders[loaderKey]);
            mergedLoaders && use.push(mergedLoaders);
        }
    });
    rules.push({
        test: new RegExp(regExpString),
        use,
        ...ruleOptions
    });
};
function addWithoutMerge(rules, module, regExpString) {
    const { ruleOptions, enabled = true, loaders, loadersOrder } = module;
    enabled && addRule(rules, {
        regExpString, loaders,
        loadersOrder: typeof loadersOrder == 'function'
            ? loadersOrder([])
            : loadersOrder || [],
        ruleOptions: typeof ruleOptions == 'function'
            ? ruleOptions({})
            : ruleOptions || {}
    });
}
function merge(defaultModules, userModules = { rules: {} }) {
    const rules = [];
    const { order: userRulesOrder, rules: userRules = {} } = userModules;
    const { order: defaultRulesOrder, rules: defaultRules } = defaultModules;
    const rulesOrder = userRulesOrder
        ? typeof userRulesOrder == 'function'
            ? userRulesOrder(defaultRulesOrder)
            : userRulesOrder
        : defaultRulesOrder;
    rulesOrder.forEach(regExpModuleKey => {
        const defaultRule = defaultRules[regExpModuleKey];
        const userRule = userRules[regExpModuleKey];
        if (userRule && defaultRule) {
            if (userRule.enabled != false) {
                const { ruleOptions, loaders, loadersOrder, rewriteRegExp } = userRule;
                const { ruleOptions: defaultRuleOptions = {}, loaders: defaultLoaders, loadersOrder: defaultLoadersOrder } = defaultRule;
                addRule(rules, {
                    loaders, defaultLoaders,
                    regExpString: rewriteRegExp || regExpModuleKey,
                    loadersOrder: loadersOrder
                        ? typeof loadersOrder == 'function'
                            ? loadersOrder(defaultLoadersOrder)
                            : loadersOrder
                        : defaultLoadersOrder,
                    ruleOptions: ruleOptions
                        ? typeof ruleOptions == 'function'
                            ? ruleOptions(defaultRuleOptions)
                            : { ...defaultRuleOptions, ...ruleOptions }
                        : defaultRuleOptions
                });
            }
        }
        else
            addWithoutMerge(rules, defaultRule || userRule, regExpModuleKey);
    });
    return rules;
}
export default merge;