standard-commit/dist/lib/commitlint.js

conventional commit

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateSubject = exports.commitRead = exports.commitFormatReport = exports.commitLint = exports.loadParserOpts = exports.loadOptions = exports.applyPlugins = exports.applyRules = void 0;
const load_1 = __importDefault(require("@commitlint/load"));
const lint_1 = __importDefault(require("@commitlint/lint"));
const format_1 = __importDefault(require("@commitlint/format"));
const read_1 = __importDefault(require("@commitlint/read"));
const config_conventional_1 = __importDefault(require("@commitlint/config-conventional"));
const conventional_changelog_conventionalcommits_1 = __importDefault(require("conventional-changelog-conventionalcommits"));
const rules_1 = __importDefault(require("@commitlint/rules"));
const message_1 = __importDefault(require("@commitlint/message"));
const config_1 = require("./config");
const parsemsg_1 = require("./parsemsg");
function applyRules(qualifiedConfig, config = config_1.DefaultConfig) {
    // update types
    if (config.types) {
        Object.assign(qualifiedConfig.rules, {
            'type-enum': [2, 'always', config.types],
        });
    }
    // add scope rules
    if (config.promptScope) {
        if (config.promptScope === 'enforce') {
            Object.assign(qualifiedConfig.rules, {
                'scope-empty': [2, 'never'],
            });
            if (Array.isArray(config.scopes)) {
                Object.assign(qualifiedConfig.rules, {
                    'scope-enum': [2, 'always', config.scopes],
                });
            }
        }
    }
    else {
        Object.assign(qualifiedConfig.rules, {
            'scope-empty': [2, 'always'],
        });
    }
    // for backward compat
    Object.assign(qualifiedConfig.rules, {
        'scope-case': [2, 'always', 'lower-case'],
    });
    // add signed-off-by rule
    if (config.enforceSignedOffBy) {
        Object.assign(qualifiedConfig.rules, {
            'signed-off-by': [2, 'always', 'Signed-off-by: '],
        });
    }
    // enforce ref for type
    if (config.enforceIssueRefs == true) {
        Object.assign(qualifiedConfig.rules, {
            'references-empty': [2, 'never'],
        });
    }
    else if (Array.isArray(config.enforceIssueRefs)) {
        Object.assign(qualifiedConfig.rules, {
            'references-empty-enum': [2, 'never', config.enforceIssueRefs],
        });
    }
    if (config.rules) {
        Object.assign(qualifiedConfig.rules, config.rules);
    }
    return qualifiedConfig;
}
exports.applyRules = applyRules;
function applyPlugins(qualifiedConfig, config = config_1.DefaultConfig) {
    Object.assign(qualifiedConfig.plugins, {
        localPlugin: {
            rules: {
                'references-empty-enum': (parsed, when = 'never', value) => {
                    const { references, type } = parsed;
                    if (!type || !value.includes(type)) {
                        return [true];
                    }
                    const negated = when === 'always';
                    const empty = references.length === 0;
                    return [
                        negated ? empty : !empty,
                        (0, message_1.default)([
                            'references',
                            negated ? 'must' : 'must not',
                            `be empty when type is one of [${value.join(', ')}]`,
                        ]),
                    ];
                },
            },
        },
    });
    return qualifiedConfig;
}
exports.applyPlugins = applyPlugins;
async function loadOptions(config) {
    const { rules } = config_conventional_1.default;
    const qualifiedConfig = await (0, load_1.default)({ rules });
    config = { ...config_1.DefaultConfig, ...config };
    applyRules(qualifiedConfig, config);
    applyPlugins(qualifiedConfig, config);
    return qualifiedConfig;
}
exports.loadOptions = loadOptions;
async function loadParserOpts(config) {
    const { issuePrefixes } = config || {};
    const { parserOpts } = await (0, conventional_changelog_conventionalcommits_1.default)({ issuePrefixes });
    return parserOpts;
}
exports.loadParserOpts = loadParserOpts;
async function commitLint(message, config) {
    const parserOpts = await loadParserOpts(config);
    const options = await loadOptions(config);
    const { rules, plugins } = options;
    return (0, lint_1.default)((0, parsemsg_1.sanitizeCommitMessage)(message), rules, { plugins, parserOpts });
}
exports.commitLint = commitLint;
async function commitFormatReport(report) {
    return (0, format_1.default)({
        results: [report],
    }, { color: true });
}
exports.commitFormatReport = commitFormatReport;
async function commitRead(settings) {
    return (0, read_1.default)(settings);
}
exports.commitRead = commitRead;
/** return true or message */
function validateSubject(subject, rules) {
    for (const rule in rules) {
        if (rule.startsWith('subject')) {
            const [sev, when, cfg] = rules[rule];
            if (sev >= 2) {
                const validate = rules_1.default[rule];
                const [result, message] = validate({ subject }, when, cfg);
                if (!result)
                    return message;
            }
        }
    }
    return true;
}
exports.validateSubject = validateSubject;