@commitlint/cz-commitlint/lib/Question.js

Commitizen adapter using the commitlint.config.js

import chalk from "chalk";
import inquirer from "inquirer";
export default class Question {
    _question;
    messages;
    skip;
    _maxLength;
    _minLength;
    title;
    caseFn;
    fullStopFn;
    multipleValueDelimiters;
    multipleSelectDefaultDelimiter;
    constructor(name, { title, enumList, messages, defaultValue, when, skip, fullStopFn, caseFn, maxLength, minLength, multipleValueDelimiters, multipleSelectDefaultDelimiter, }) {
        if (!name || typeof name !== "string")
            throw new Error("Question: name is required");
        this._maxLength = maxLength ?? Infinity;
        this._minLength = minLength ?? 0;
        this.messages = messages;
        this.title = title ?? "";
        this.skip = skip ?? false;
        this.fullStopFn = fullStopFn ?? ((_) => _);
        this.caseFn =
            caseFn ??
                ((input, delimiter) => Array.isArray(input) ? input.join(delimiter) : input);
        this.multipleValueDelimiters = multipleValueDelimiters;
        this.multipleSelectDefaultDelimiter = multipleSelectDefaultDelimiter;
        if (enumList && Array.isArray(enumList)) {
            this._question = {
                type: multipleSelectDefaultDelimiter ? "checkbox" : "list",
                choices: skip
                    ? [
                        ...enumList,
                        new inquirer.Separator(),
                        {
                            name: "empty",
                            value: "",
                        },
                    ]
                    : [...enumList],
            };
        }
        else if (/^is[A-Z]/.test(name)) {
            this._question = {
                type: "confirm",
            };
        }
        else {
            this._question = {
                type: "input",
                transformer: this.transformer.bind(this),
            };
        }
        Object.assign(this._question, {
            name,
            default: defaultValue,
            when,
            validate: this.validate.bind(this),
            filter: this.filter.bind(this),
            message: this.decorateMessage.bind(this),
        });
    }
    getMessage(key) {
        return this.messages[key] ?? "";
    }
    get question() {
        return this._question;
    }
    get maxLength() {
        return this._maxLength;
    }
    set maxLength(maxLength) {
        this._maxLength = maxLength;
    }
    get minLength() {
        return this._minLength;
    }
    set minLength(minLength) {
        this._minLength = minLength;
    }
    beforeQuestionStart(_answers) {
        return;
    }
    validate(input) {
        const output = this.filter(input);
        const questionName = this.question.name ?? "";
        if (!this.skip && output.length === 0) {
            return this.getMessage("emptyWarning").replace(/%s/g, questionName);
        }
        if (output.length > this.maxLength) {
            return this.getMessage("upperLimitWarning")
                .replace(/%s/g, questionName)
                .replace(/%d/g, `${output.length - this.maxLength}`);
        }
        if (output.length < this.minLength) {
            return this.getMessage("lowerLimitWarning")
                .replace(/%s/g, questionName)
                .replace(/%d/g, `${this.minLength - output.length}`);
        }
        return true;
    }
    filter(input) {
        let toCased;
        if (Array.isArray(input)) {
            toCased = this.caseFn(input, this.multipleSelectDefaultDelimiter);
        }
        else if (this.multipleValueDelimiters) {
            const segments = input.split(this.multipleValueDelimiters);
            const casedString = this.caseFn(segments, ",");
            const casedSegments = casedString.split(",");
            toCased = input.replace(new RegExp(`[^${this.multipleValueDelimiters.source}]+`, "g"), (segment) => {
                return casedSegments[segments.indexOf(segment)];
            });
        }
        else {
            toCased = this.caseFn(input);
        }
        return this.fullStopFn(toCased);
    }
    transformer(input, _answers) {
        const output = this.filter(input);
        if (this.maxLength === Infinity && this.minLength === 0) {
            return output;
        }
        const color = output.length <= this.maxLength && output.length >= this.minLength
            ? chalk.green
            : chalk.red;
        return color("(" + output.length + ") " + output);
    }
    decorateMessage(_answers) {
        if (this.beforeQuestionStart) {
            this.beforeQuestionStart(_answers);
        }
        if (this.question.type === "input") {
            const countLimitMessage = (() => {
                const messages = [];
                if (this.minLength > 0 && this.getMessage("min")) {
                    messages.push(this.getMessage("min").replace(/%d/g, this.minLength + ""));
                }
                if (this.maxLength < Infinity && this.getMessage("max")) {
                    messages.push(this.getMessage("max").replace(/%d/g, this.maxLength + ""));
                }
                return messages.join(", ");
            })();
            const skipMessage = this.skip && this.getMessage("skip");
            return (this.title +
                (skipMessage ? ` ${skipMessage}` : "") +
                ":" +
                (countLimitMessage ? ` ${countLimitMessage}` : "") +
                "\n");
        }
        else {
            return `${this.title}:`;
        }
    }
}
//# sourceMappingURL=Question.js.map