@commitlint/load/lib/load.js

Load shared commitlint configuration

import path from 'node:path';
import { validateConfig } from '@commitlint/config-validator';
import executeRule from '@commitlint/execute-rule';
import resolveExtends, { resolveFrom, resolveFromSilent, resolveGlobalSilent, loadParserPreset, } from '@commitlint/resolve-extends';
import isPlainObject from 'lodash.isplainobject';
import merge from 'lodash.merge';
import uniq from 'lodash.uniq';
import { loadConfig } from './utils/load-config.js';
import { loadParserOpts } from './utils/load-parser-opts.js';
import loadPlugin from './utils/load-plugin.js';
/**
 * formatter should be kept as is when unable to resolve it from config directory
 */
const resolveFormatter = (formatter, parent) => {
    try {
        return resolveFrom(formatter, parent);
    }
    catch (error) {
        return formatter;
    }
};
export default async function load(seed = {}, options = {}) {
    const cwd = typeof options.cwd === 'undefined' ? process.cwd() : options.cwd;
    const loaded = await loadConfig(cwd, options.file);
    const baseDirectory = loaded?.filepath ? path.dirname(loaded.filepath) : cwd;
    const configFilePath = loaded?.filepath;
    let config = {};
    if (loaded) {
        validateConfig(loaded.filepath || '', loaded.config);
        config = loaded.config;
    }
    // Merge passed config with file based options
    config = merge({
        extends: [],
        plugins: [],
        rules: {},
    }, config, seed);
    // Resolve parserPreset key
    if (typeof config.parserPreset === 'string') {
        const resolvedParserPreset = resolveFrom(config.parserPreset, configFilePath);
        config.parserPreset = {
            name: config.parserPreset,
            ...(await loadParserPreset(resolvedParserPreset)),
        };
    }
    // Resolve extends key
    const extended = await resolveExtends(config, {
        prefix: 'commitlint-config',
        cwd: baseDirectory,
        parserPreset: await config.parserPreset,
    });
    if (!extended.formatter || typeof extended.formatter !== 'string') {
        extended.formatter = '@commitlint/format';
    }
    let plugins = {};
    if (Array.isArray(extended.plugins)) {
        for (const plugin of uniq(extended.plugins)) {
            if (typeof plugin === 'string') {
                plugins = await loadPlugin(plugins, plugin, process.env.DEBUG === 'true');
            }
            else {
                plugins.local = plugin;
            }
        }
    }
    const rules = (await Promise.all(Object.entries(extended.rules || {}).map((entry) => executeRule(entry)))).reduce((registry, item) => {
        // type of `item` can be null, but Object.entries always returns key pair
        const [key, value] = item;
        registry[key] = value;
        return registry;
    }, {});
    const helpUrl = typeof extended.helpUrl === 'string'
        ? extended.helpUrl
        : typeof config.helpUrl === 'string'
            ? config.helpUrl
            : 'https://github.com/conventional-changelog/commitlint/#what-is-commitlint';
    const prompt = extended.prompt && isPlainObject(extended.prompt) ? extended.prompt : {};
    return {
        extends: Array.isArray(extended.extends)
            ? extended.extends
            : typeof extended.extends === 'string'
                ? [extended.extends]
                : [],
        // Resolve config-relative formatter module
        formatter: resolveFormatter(extended.formatter, configFilePath),
        // Resolve parser-opts from preset
        parserPreset: await loadParserOpts(extended.parserPreset),
        ignores: extended.ignores,
        defaultIgnores: extended.defaultIgnores,
        plugins: plugins,
        rules: rules,
        helpUrl: helpUrl,
        prompt,
    };
}
export { resolveFrom, resolveFromSilent, resolveGlobalSilent };
//# sourceMappingURL=load.js.map