@commitlint/prompt/lib/library/get-prompt.js

commitizen prompt using commitlint.config.js

import chalk from 'chalk';
import format from './format.js';
import getForcedCaseFn from './get-forced-case-fn.js';
import getForcedLeadingFn from './get-forced-leading-fn.js';
import meta from './meta.js';
import { enumRuleIsActive, getHasName, getMaxLength, ruleIsActive, ruleIsApplicable, ruleIsNotApplicable, } from './utils.js';
const EOL = '\n';
/**
 * Get a cli prompt based on rule configuration
 * @param type type of the data to gather
 * @param rules
 * @param settings
 * @return prompt instance
 */
export default function getPrompt(type, rules = [], settings = {}) {
    const emptyRule = rules.filter(getHasName('empty')).find(ruleIsActive);
    const mustBeEmpty = emptyRule ? ruleIsApplicable(emptyRule) : false;
    if (mustBeEmpty) {
        return null;
    }
    const required = emptyRule ? ruleIsNotApplicable(emptyRule) : false;
    const forceCaseFn = getForcedCaseFn(rules.find(getHasName('case')));
    const forceLeadingBlankFn = getForcedLeadingFn(rules.find(getHasName('leading-blank')));
    const maxLengthRule = rules.find(getHasName('max-length'));
    const inputMaxLength = getMaxLength(maxLengthRule);
    const enumRule = rules.filter(getHasName('enum')).find(enumRuleIsActive);
    const tabCompletion = enumRule
        ? enumRule[1][2].map((enumerable) => {
            const enumSettings = (settings.enumerables || {})[enumerable] || {};
            return {
                value: forceLeadingBlankFn(forceCaseFn(enumerable)),
                description: enumSettings.description || '',
            };
        })
        : [];
    const maxLength = (res) => {
        let remainingHeaderLength = Infinity;
        if (settings.header && settings.header.length) {
            const header = format({
                type: res.type,
                scope: res.scope,
                subject: res.subject,
            });
            remainingHeaderLength = settings.header.length - header.length;
        }
        return Math.min(inputMaxLength, remainingHeaderLength);
    };
    return {
        type: 'input-custom',
        name: type,
        message: `${type}:`,
        validate(input, answers) {
            if (input.length > maxLength(answers || {})) {
                return 'Input contains too many characters!';
            }
            if (required && input.trim().length === 0) {
                // Show help if enum is defined and input may not be empty
                return `⚠ ${chalk.bold(type)} may not be empty.`;
            }
            const tabValues = tabCompletion.map((item) => item.value);
            if (input.length > 0 &&
                tabValues.length > 0 &&
                !tabValues.includes(input)) {
                return `⚠ ${chalk.bold(type)} must be one of ${tabValues.join(', ')}.`;
            }
            return true;
        },
        tabCompletion,
        log(answers) {
            let prefix = `${chalk.white('Please enter a')} ${chalk.bold(type)}: ${meta({
                optional: !required,
                required: required,
                'tab-completion': typeof enumRule !== 'undefined',
                header: typeof settings.header !== 'undefined',
                'multi-line': settings.multiline,
            })}` + EOL;
            if (settings.description) {
                prefix += chalk.grey(`${settings.description}`) + EOL;
            }
            if (answers) {
                prefix += EOL + `${format(answers, true)}` + EOL;
            }
            return prefix + EOL;
        },
        maxLength,
        transformer(value) {
            return forceCaseFn(value);
        },
        forceLeadingBlankFn,
    };
}
//# sourceMappingURL=get-prompt.js.map