feat(prompt): rewrite codebase to use inquirer - UPDATED with current master (#2697)

* feat(prompt): rewrite codebase to use inquirer

* fix(prompt): simplify logic used to compute maxLength

* test(prompt): add basic input test

* fix(prompt): small code refactor

* fix: correct linting issues, add missing dependencies

* fix: add missing tsconfig reference

* fix: update lock file after merge

* fix: correct issue with mac-os tab completion

* chore: code review

* fix: integrate review feedback

* style: prettier

Co-authored-by: Armano <armano2@users.noreply.github.com>

Author: escapedcat

.eslintrc.js

@@ -52,6 +52,7 @@ module.exports = {
 				'@typescript-eslint/no-var-requires': 'off',
 				'@typescript-eslint/no-inferrable-types': 'off',
 				'@typescript-eslint/no-non-null-assertion': 'off',
+				'@typescript-eslint/triple-slash-reference': 'off',
 
 				// TODO: enable those rules?
 				'no-empty': 'off',

@commitlint/prompt-cli/cli.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 const execa = require('execa');
+const inquirer = require('inquirer');
 const {prompter} = require('@commitlint/prompt');
 
-const _ = undefined;
-const prompt = () => prompter(_, commit);
-
 main().catch((err) => {
 	setTimeout(() => {
 		throw err;
@@ -21,7 +19,7 @@ function main() {
 				process.exit(1);
 			}
 		})
-		.then(() => prompt());
+		.then(() => prompter(inquirer, commit));
 }
 
 function isStageEmpty() {

@commitlint/prompt-cli/package.json

@@ -37,6 +37,7 @@
   },
   "dependencies": {
     "@commitlint/prompt": "^14.1.0",
+    "inquirer": "^6.5.2",
     "execa": "^5.0.0"
   },
   "gitHead": "70f7f4688b51774e7ac5e40e896cdaa3f132b2bc"

@commitlint/prompt/package.json

@@ -38,15 +38,19 @@
   },
   "devDependencies": {
     "@commitlint/utils": "^14.0.0",
-    "commitizen": "4.2.4"
+    "@commitlint/types": "^13.2.0",
+    "@commitlint/config-angular": "^13.2.0",
+    "@types/inquirer": "^6.5.0",
+    "inquirer": "^6.5.2",
+    "commitizen": "^4.2.4"
   },
   "dependencies": {
     "@commitlint/ensure": "^14.1.0",
     "@commitlint/load": "^14.1.0",
     "@commitlint/types": "^14.0.0",
     "chalk": "^4.0.0",
-    "throat": "^6.0.0",
-    "vorpal": "^1.12.0"
+    "lodash": "^4.17.19",
+    "inquirer": "^6.5.2"
   },
   "gitHead": "70f7f4688b51774e7ac5e40e896cdaa3f132b2bc"
 }

@commitlint/prompt/src/index.ts

@@ -1,18 +1,10 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-import vorpal from 'vorpal';
-import input from './input';
+import inquirer from 'inquirer';
+import {input} from './input';
 
 type Commit = (input: string) => void;
 
-/**
- * Entry point for commitizen
- * @param _ inquirer instance passed by commitizen, unused
- * @param commit callback to execute with complete commit message
- * @return {void}
- */
-export function prompter(_: unknown, commit: Commit): void {
-	input(vorpal).then((message) => {
+export function prompter(cz: typeof inquirer, commit: Commit): void {
+	input(cz.prompt).then((message) => {
 		commit(message);
 	});
 }

@commitlint/prompt/src/input.test.ts

@@ -0,0 +1,96 @@
+import {Answers, PromptModule, QuestionCollection} from 'inquirer';
+/// <reference path="./inquirer/inquirer.d.ts" />
+import {input} from './input';
+import chalk from 'chalk';
+
+jest.mock(
+	'@commitlint/load',
+	() => {
+		return () => require('@commitlint/config-angular');
+	},
+	{
+		virtual: true,
+	}
+);
+
+test('should work with all fields filled', async () => {
+	const prompt = stub({
+		'input-custom': {
+			type: 'fix',
+			scope: 'test',
+			subject: 'subject',
+			body: 'body',
+			footer: 'footer',
+		},
+	});
+	const message = await input(prompt);
+	expect(message).toEqual('fix(test): subject\n' + 'body\n' + 'footer');
+});
+
+test('should work without scope', async () => {
+	const prompt = stub({
+		'input-custom': {
+			type: 'fix',
+			scope: '',
+			subject: 'subject',
+			body: 'body',
+			footer: 'footer',
+		},
+	});
+	const message = await input(prompt);
+	expect(message).toEqual('fix: subject\n' + 'body\n' + 'footer');
+});
+
+test('should fail without type', async () => {
+	const spy = jest.spyOn(console, 'error').mockImplementation();
+	const prompt = stub({
+		'input-custom': {
+			type: '',
+			scope: '',
+			subject: '',
+			body: '',
+			footer: '',
+		},
+	});
+	const message = await input(prompt);
+	expect(message).toEqual('');
+	expect(console.error).toHaveBeenCalledTimes(1);
+	expect(console.error).toHaveBeenLastCalledWith(
+		new Error(`⚠ ${chalk.bold('type')} may not be empty.`)
+	);
+	spy.mockRestore();
+});
+
+function stub(config: Record<string, Record<string, unknown>>): PromptModule {
+	const prompt = async (questions: QuestionCollection): Promise<any> => {
+		const result: Answers = {};
+		const resolvedConfig = Array.isArray(questions) ? questions : [questions];
+		for (const promptConfig of resolvedConfig) {
+			const configType = promptConfig.type || 'input';
+			const questions = config[configType];
+			if (!questions) {
+				throw new Error(`Unexpected config type: ${configType}`);
+			}
+			const answer = questions[promptConfig.name!];
+			if (answer == null) {
+				throw new Error(`Unexpected config name: ${promptConfig.name}`);
+			}
+			const validate = promptConfig.validate;
+			if (validate) {
+				const validationResult = validate(answer, result);
+				if (validationResult !== true) {
+					throw new Error(validationResult || undefined);
+				}
+			}
+
+			result[promptConfig.name!] = answer;
+		}
+		return result;
+	};
+	prompt.registerPrompt = () => {
+		return prompt;
+	};
+	prompt.restoreDefaultPrompts = () => true;
+	prompt.prompts = {};
+	return prompt as any as PromptModule;
+}

@commitlint/prompt/src/input.ts

@@ -1,29 +1,21 @@
 import load from '@commitlint/load';
-import throat from 'throat';
+import {DistinctQuestion, PromptModule} from 'inquirer';
 
 import format from './library/format';
 import getPrompt from './library/get-prompt';
 import settings from './settings';
-import {InputSetting, Prompter, Result} from './library/types';
-import {getHasName, getMaxLength, getRules} from './library/utils';
+import type {InputSetting, Result} from './library/types';
 
-export default input;
+import {getHasName, getMaxLength, getRules} from './library/utils';
+import InputCustomPrompt from './inquirer/InputCustomPrompt';
 
 /**
  * Get user input by interactive prompt based on
  * conventional-changelog-lint rules.
  * @param prompter
  * @return commit message
  */
-async function input(prompter: () => Prompter): Promise<string> {
-	const results: Result = {
-		type: null,
-		scope: null,
-		subject: null,
-		body: null,
-		footer: null,
-	};
-
+export async function input(prompter: PromptModule): Promise<string> {
 	const {rules} = await load();
 	const parts = ['type', 'scope', 'subject', 'body', 'footer'] as const;
 	const headerParts = ['type', 'scope', 'subject'];
@@ -33,31 +25,28 @@ async function input(prompter: () => Prompter): Promise<string> {
 	);
 	const maxLength = getMaxLength(headerLengthRule);
 
-	await Promise.all(
-		parts.map(
-			throat(1, async (input) => {
-				const inputRules = getRules(input, rules);
-				const inputSettings: InputSetting = settings[input];
-
-				if (headerParts.includes(input) && maxLength < Infinity) {
-					inputSettings.header = {
-						length: maxLength,
-					};
-				}
-
-				results[input] = await getPrompt(input, {
-					rules: inputRules,
-					settings: inputSettings,
-					results,
-					prompter,
-				});
-			})
-		)
-	).catch((err) => {
+	try {
+		const questions: DistinctQuestion<Result>[] = [];
+		prompter.registerPrompt('input-custom', InputCustomPrompt);
+
+		for (const input of parts) {
+			const inputSetting: InputSetting = settings[input];
+			const inputRules = getRules(input, rules);
+			if (headerParts.includes(input) && maxLength < Infinity) {
+				inputSetting.header = {
+					length: maxLength,
+				};
+			}
+			const question = getPrompt(input, inputRules, inputSetting);
+			if (question) {
+				questions.push(question);
+			}
+		}
+
+		const results = await prompter<Result>(questions);
+		return format(results);
+	} catch (err) {
 		console.error(err);
 		return '';
-	});
-
-	// Return the results
-	return format(results);
+	}
 }

@commitlint/prompt/src/inquirer/InputCustomPrompt.ts

@@ -0,0 +1,117 @@
+/// <reference path="./inquirer.d.ts" />
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import InputPrompt from 'inquirer/lib/prompts/input';
+import observe from 'inquirer/lib/utils/events';
+import {Interface as ReadlineInterface, Key} from 'readline';
+import type {Subscription} from 'rxjs/internal/Subscription';
+
+import Answers = inquirer.Answers;
+import InputCustomOptions = inquirer.InputCustomOptions;
+import SuccessfulPromptStateData = inquirer.prompts.SuccessfulPromptStateData;
+
+interface KeyDescriptor {
+	value: string;
+	key: Key;
+}
+
+export default class InputCustomPrompt<
+	TQuestion extends InputCustomOptions = InputCustomOptions
+> extends InputPrompt<TQuestion> {
+	private lineSubscription: Subscription;
+	private readonly tabCompletion: string[];
+
+	constructor(
+		question: TQuestion,
+		readLine: ReadlineInterface,
+		answers: Answers
+	) {
+		super(question, readLine, answers);
+
+		if (this.opt.log) {
+			this.rl.write(this.opt.log(answers));
+		}
+
+		if (!this.opt.maxLength) {
+			this.throwParamError('maxLength');
+		}
+
+		const events = observe(this.rl);
+		this.lineSubscription = events.keypress.subscribe(
+			this.onKeyPress2.bind(this)
+		);
+		this.tabCompletion = (this.opt.tabCompletion || [])
+			.map((item) => item.value)
+			.sort((a, b) => a.localeCompare(b));
+	}
+
+	onEnd(state: SuccessfulPromptStateData): void {
+		this.lineSubscription.unsubscribe();
+		super.onEnd(state);
+	}
+
+	/**
+	 * @see https://nodejs.org/api/readline.html#readline_rl_write_data_key
+	 * @see https://nodejs.org/api/readline.html#readline_rl_line
+	 */
+	updateLine(line: string): void {
+		this.rl.write(null as any, {ctrl: true, name: 'b'});
+		this.rl.write(null as any, {ctrl: true, name: 'd'});
+		this.rl.write(line.substr(this.rl.line.length));
+	}
+
+	onKeyPress2(e: KeyDescriptor): void {
+		if (e.key.name === 'tab' && this.tabCompletion.length > 0) {
+			let line = this.rl.line.trim();
+			if (line.length > 0) {
+				for (const item of this.tabCompletion) {
+					if (item.startsWith(line) && item !== line) {
+						line = item;
+						break;
+					}
+				}
+			}
+			this.updateLine(line);
+		}
+	}
+
+	measureInput(input: string): number {
+		if (this.opt.filter) {
+			return this.opt.filter(input).length;
+		}
+		return input.length;
+	}
+
+	render(error?: string): void {
+		const answered = this.status === 'answered';
+
+		let message = this.getQuestion();
+		const length = this.measureInput(this.rl.line);
+
+		if (answered) {
+			message += chalk.cyan(this.answer);
+		} else if (this.opt.transformer) {
+			message += this.opt.transformer(this.rl.line, this.answers, {});
+		}
+
+		let bottomContent = '';
+
+		if (error) {
+			bottomContent = chalk.red('>> ') + error;
+		} else if (!answered) {
+			const maxLength = this.opt.maxLength(this.answers);
+			if (maxLength < Infinity) {
+				const lengthRemaining = maxLength - length;
+				const color =
+					lengthRemaining <= 5
+						? chalk.red
+						: lengthRemaining <= 10
+						? chalk.yellow
+						: chalk.grey;
+				bottomContent = color(`${lengthRemaining} characters left`);
+			}
+		}
+
+		this.screen.render(message, bottomContent);
+	}
+}

@commitlint/prompt/src/inquirer/inquirer.d.ts

@@ -0,0 +1,23 @@
+import {Answers, InputQuestionOptions} from 'inquirer';
+
+declare module 'inquirer' {
+	interface InputCustomCompletionOption {
+		value: string;
+		description?: string;
+	}
+
+	export interface InputCustomOptions<T extends Answers = Answers>
+		extends InputQuestionOptions<T> {
+		/**
+		 * @inheritdoc
+		 */
+		type?: 'input-custom';
+		log?(answers?: T): string;
+		tabCompletion?: InputCustomCompletionOption[];
+		maxLength(answers?: T): number;
+	}
+
+	interface QuestionMap<T extends Answers = Answers> {
+		'input-custom': InputCustomOptions<T>;
+	}
+}

@commitlint/prompt/src/library/format.test.ts

@@ -0,0 +1,55 @@
+import {Result} from './types';
+import format from './format';
+
+test('should return empty string', () => {
+	const result: Result = {};
+	expect(format(result)).toBe(' ');
+});
+
+test('should omit scope', () => {
+	const result: Result = {
+		type: 'fix',
+		subject: 'test',
+	};
+	expect(format(result)).toBe('fix: test');
+});
+
+test('should include scope', () => {
+	const result: Result = {
+		type: 'fix',
+		scope: 'prompt',
+		subject: 'test',
+	};
+	expect(format(result)).toBe('fix(prompt): test');
+});
+
+test('should include body', () => {
+	const result: Result = {
+		type: 'fix',
+		scope: 'prompt',
+		subject: 'test',
+		body: 'some body',
+	};
+	expect(format(result)).toBe('fix(prompt): test\nsome body');
+});
+
+test('should include footer', () => {
+	const result: Result = {
+		type: 'fix',
+		scope: 'prompt',
+		subject: 'test',
+		footer: 'some footer',
+	};
+	expect(format(result)).toBe('fix(prompt): test\nsome footer');
+});
+
+test('should include body and footer', () => {
+	const result: Result = {
+		type: 'fix',
+		scope: 'prompt',
+		subject: 'test',
+		body: 'some body',
+		footer: 'some footer',
+	};
+	expect(format(result)).toBe('fix(prompt): test\nsome body\nsome footer');
+});

@commitlint/prompt/src/library/format.ts

@@ -1,29 +1,35 @@
 import chalk from 'chalk';
-import {Result} from './types';
-
-export default format;
+import {Result, ResultPart} from './types';
 
 /**
  * Get formatted commit message
  * @param input object containing structured results
  * @param debug show debug information in commit message
  * @return formatted debug message
  */
-function format(input: Result, debug = false): string {
+export default function format(input: Result, debug = false): string {
+	const defaultInput = {
+		type: undefined,
+		scope: undefined,
+		subject: undefined,
+		body: undefined,
+		footer: undefined,
+		...input,
+	};
 	const results = debug
-		? Object.entries(input).reduce<Result>((registry, [name, value]) => {
-				registry[name as 'type' | 'scope' | 'subject' | 'body' | 'footer'] =
-					value === null ? chalk.grey(`<${name}>`) : chalk.bold(value);
+		? Object.entries(defaultInput).reduce<Result>((registry, [name, value]) => {
+				registry[name as ResultPart] =
+					value === undefined ? chalk.grey(`<${name}>`) : chalk.bold(value);
 				return registry;
 		  }, {})
-		: input;
+		: defaultInput;
 
 	// Return formatted string
 	const {type, scope, subject, body, footer} = results;
 	return [
-		`${type}${scope ? '(' : ''}${scope}${scope ? ')' : ''}${
-			type || scope ? ':' : ''
-		} ${subject}`,
+		`${type || ''}${scope ? `(${scope})` : ''}${type || scope ? ':' : ''} ${
+			subject || ''
+		}`,
 		body,
 		footer,
 	]

@commitlint/prompt/src/library/get-prompt.test.ts

@@ -1,239 +1,123 @@
 import chalk from 'chalk';
+import {InputCustomOptions} from 'inquirer';
 
-import type {InputSetting, Prompter, Result, RuleEntry} from './types';
+import type {InputSetting, RuleEntry, Result, ResultPart} from './types';
 
 import format from './format';
 import getForcedCaseFn from './get-forced-case-fn';
 import getForcedLeadingFn from './get-forced-leading-fn';
 import meta from './meta';
 import {
 	enumRuleIsActive,
-	ruleIsNotApplicable,
-	ruleIsApplicable,
-	ruleIsActive,
 	getHasName,
 	getMaxLength,
+	ruleIsActive,
+	ruleIsApplicable,
+	ruleIsNotApplicable,
 } from './utils';
 
+const EOL = '\n';
+
 /**
  * Get a cli prompt based on rule configuration
  * @param type type of the data to gather
- * @param context rules to parse
+ * @param rules
+ * @param settings
  * @return prompt instance
  */
 export default function getPrompt(
-	type: string,
-	context: {
-		rules?: RuleEntry[];
-		settings?: InputSetting;
-		results?: Result;
-		prompter?: () => Prompter;
-	} = {}
-): Promise<string | undefined> {
-	const {rules = [], settings = {}, results = {}, prompter} = context;
-
-	if (typeof prompter !== 'function') {
-		throw new TypeError('Missing prompter function in getPrompt context');
-	}
-
-	const prompt = prompter();
-
-	if (typeof prompt.removeAllListeners !== 'function') {
-		throw new TypeError(
-			'getPrompt: prompt.removeAllListeners is not a function'
-		);
-	}
-
-	if (typeof prompt.command !== 'function') {
-		throw new TypeError('getPrompt: prompt.command is not a function');
-	}
-
-	if (typeof prompt.catch !== 'function') {
-		throw new TypeError('getPrompt: prompt.catch is not a function');
-	}
-
-	if (typeof prompt.addListener !== 'function') {
-		throw new TypeError('getPrompt: prompt.addListener is not a function');
-	}
-
-	if (typeof prompt.log !== 'function') {
-		throw new TypeError('getPrompt: prompt.log is not a function');
-	}
-
-	if (typeof prompt.delimiter !== 'function') {
-		throw new TypeError('getPrompt: prompt.delimiter is not a function');
-	}
-
-	if (typeof prompt.show !== 'function') {
-		throw new TypeError('getPrompt: prompt.show is not a function');
-	}
-
-	const enumRule = rules.filter(getHasName('enum')).find(enumRuleIsActive);
-
-	const emptyRule = rules.find(getHasName('empty'));
-
-	const mustBeEmpty =
-		emptyRule && ruleIsActive(emptyRule) && ruleIsApplicable(emptyRule);
+	type: ResultPart,
+	rules: RuleEntry[] = [],
+	settings: InputSetting = {}
+): InputCustomOptions<Result> | null {
+	const emptyRule = rules.filter(getHasName('empty')).find(ruleIsActive);
 
-	const mayNotBeEmpty =
-		emptyRule && ruleIsActive(emptyRule) && ruleIsNotApplicable(emptyRule);
-
-	const mayBeEmpty = !mayNotBeEmpty;
+	const mustBeEmpty = emptyRule ? ruleIsApplicable(emptyRule) : false;
 
 	if (mustBeEmpty) {
-		prompt.removeAllListeners('keypress');
-		prompt.removeAllListeners('client_prompt_submit');
-		prompt.ui.redraw.done();
-		return Promise.resolve(undefined);
+		return null;
 	}
 
-	const caseRule = rules.find(getHasName('case'));
-
-	const forceCaseFn = getForcedCaseFn(caseRule);
+	const required = emptyRule ? ruleIsNotApplicable(emptyRule) : false;
 
-	const leadingBlankRule = rules.find(getHasName('leading-blank'));
-
-	const forceLeadingBlankFn = getForcedLeadingFn(leadingBlankRule);
+	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 headerLength = settings.header ? settings.header.length : Infinity;
-
-	const remainingHeaderLength = headerLength
-		? headerLength -
-		  [
-				results.type,
-				results.scope,
-				results.scope ? '()' : '',
-				results.type && results.scope ? ':' : '',
-				results.subject,
-		  ].join('').length
-		: Infinity;
-
-	const maxLength = Math.min(inputMaxLength, remainingHeaderLength);
-
-	return new Promise((resolve) => {
-		// Add the defined enums as sub commands if applicable
-		if (enumRule) {
-			const [, [, , enums]] = enumRule;
+	const enumRule = rules.filter(getHasName('enum')).find(enumRuleIsActive);
 
-			enums.forEach((enumerable) => {
+	const tabCompletion = enumRule
+		? enumRule[1][2].map((enumerable) => {
 				const enumSettings = (settings.enumerables || {})[enumerable] || {};
-				prompt
-					.command(enumerable)
-					.description(enumSettings.description || '')
-					.action(() => {
-						prompt.removeAllListeners();
-						prompt.ui.redraw.done();
-						return resolve(forceLeadingBlankFn(forceCaseFn(enumerable)));
-					});
+				return {
+					value: forceLeadingBlankFn(forceCaseFn(enumerable)),
+					description: enumSettings.description || '',
+				};
+		  })
+		: [];
+
+	const maxLength = (res: Result) => {
+		let remainingHeaderLength = Infinity;
+		if (settings.header && settings.header.length) {
+			const header = format({
+				type: res.type,
+				scope: res.scope,
+				subject: res.subject,
 			});
-		} else {
-			prompt.catch('[text...]').action((parameters) => {
-				const {text = ''} = parameters;
-				prompt.removeAllListeners();
-				prompt.ui.redraw.done();
-				return resolve(forceLeadingBlankFn(forceCaseFn(text.join(' '))));
-			});
-		}
-
-		if (mayBeEmpty) {
-			// Add an easy exit command
-			prompt
-				.command(':skip')
-				.description('Skip the input if possible.')
-				.action(() => {
-					prompt.removeAllListeners();
-					prompt.ui.redraw.done();
-					resolve('');
-				});
+			remainingHeaderLength = settings.header.length - header.length;
 		}
-
-		// Handle empty input
-		const onSubmit = (input: string) => {
-			if (input.length > 0) {
-				return;
+		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!';
 			}
-
-			// Show help if enum is defined and input may not be empty
-			if (mayNotBeEmpty) {
-				prompt.ui.log(chalk.yellow(`⚠ ${chalk.bold(type)} may not be empty.`));
+			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.`;
 			}
 
-			if (mayBeEmpty) {
-				prompt.ui.log(
-					chalk.blue(
-						`ℹ Enter ${chalk.bold(':skip')} to omit ${chalk.bold(type)}.`
-					)
-				);
+			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(', ')}.`;
 			}
-
-			if (enumRule) {
-				prompt.exec('help');
+			return true;
+		},
+		tabCompletion,
+		log(answers?: Result) {
+			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;
 			}
-		};
-
-		const drawRemaining = (length: number) => {
-			if (length < Infinity) {
-				const colors = [
-					{
-						threshold: 5,
-						color: chalk.red,
-					},
-					{
-						threshold: 10,
-						color: chalk.yellow,
-					},
-					{
-						threshold: Infinity,
-						color: chalk.grey,
-					},
-				];
-
-				const el = colors.find((item) => item.threshold >= length);
-				const color = el ? el.color : chalk.grey;
-				prompt.ui.redraw(color(`${length} characters left`));
+			if (answers) {
+				prefix += EOL + `${format(answers, true)}` + EOL;
 			}
-		};
-
-		const onKey = (event: {value: string}) => {
-			const sanitized = forceCaseFn(event.value);
-			const cropped = sanitized.slice(0, maxLength);
-
-			// We **could** do live editing, but there are some quirks to solve
-			/* const live = merge({}, results, {
-				[type]: cropped
-			});
-			prompt.ui.redraw(`\n\n${format(live, true)}\n\n`); */
-
-			if (maxLength) {
-				drawRemaining(maxLength - cropped.length);
-			}
-			prompt.ui.input(cropped);
-		};
-
-		prompt.addListener('keypress', onKey);
-		prompt.addListener('client_prompt_submit', onSubmit);
-
-		prompt.log(
-			`\n\nPlease enter a ${chalk.bold(type)}: ${meta({
-				optional: !mayNotBeEmpty,
-				required: mayNotBeEmpty,
-				'tab-completion': typeof enumRule !== 'undefined',
-				header: typeof settings.header !== 'undefined',
-				'multi-line': settings.multiline,
-			})}`
-		);
-
-		if (settings.description) {
-			prompt.log(chalk.grey(`${settings.description}\n`));
-		}
-
-		prompt.log(`\n\n${format(results, true)}\n\n`);
-
-		drawRemaining(maxLength);
-
-		prompt.delimiter(`❯ ${type}:`).show();
-	});
+			return prefix + EOL;
+		},
+		maxLength,
+		transformer(value: string) {
+			return forceCaseFn(value);
+		},
+	};
 }

@commitlint/prompt/src/library/get-prompt.ts

@@ -19,37 +19,6 @@ export type InputSetting = {
 	};
 };
 
-export type Result = Partial<
-	Record<'type' | 'scope' | 'subject' | 'body' | 'footer', null | string>
->;
+export type ResultPart = 'type' | 'scope' | 'subject' | 'body' | 'footer';
 
-export interface PrompterCommand {
-	description(value: string): this;
-	action(
-		action: (args: {
-			[key: string]: any;
-			options: {
-				[key: string]: any;
-			};
-		}) => Promise<void> | void
-	): this;
-}
-
-export interface Prompter {
-	delimiter(value: string): this;
-	show(): this;
-	exec(command: string): Promise<any>;
-	log(text?: string): void;
-	catch(command: string, description?: string): PrompterCommand;
-	command(command: string, description?: string): PrompterCommand;
-	removeAllListeners(input?: string): void;
-	addListener(input: string, cb: (event: any) => void): void;
-	ui: {
-		log(text?: string): void;
-		input(text?: string): string;
-		redraw: {
-			(text: string, ...texts: string[]): void;
-			done(): void;
-		};
-	};
-}
+export type Result = Partial<Record<ResultPart, string | undefined>>;

@commitlint/prompt/src/library/types.ts

@@ -7,5 +7,5 @@
   },
   "include": ["./src"],
   "exclude": ["./src/**/*.test.ts", "./lib/**/*"],
-  "references": [{"path": "../cli"}]
+  "references": [{"path": "../types"}, {"path": "../load"}]
 }