123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177
import { ACTIONS } from './types.ts';import type { IConfig } from './types.ts';import Printer from './printer.ts';import History from './history.ts';import { deferred } from "https://deno.land/std@0.205.0/async/mod.ts";
export default class InputLoop {	private buf = new Uint8Array(1024);	done = false;	out = new Printer();	history = new History();
	constructor(args?: IConfig) {		this.out = new Printer(args);	}
	private coerceChoice = (value: string | number): string => {		if (typeof value === 'number') {			return String(value);		}		return value;	}
	private cleanInput = (value?: string): string => {		return value?.replace('\n', '').replace('\r', '') ?? '';	}
	/**	 * Repeats the last prompt	 * @param {string | number} value value to auto-select	 */	public repeat = (value?: string | number) => {		const retrievedHistory = this.history.retrieve();		if (retrievedHistory.action) {			if (retrievedHistory.action === ACTIONS.CHOOSE) {				return this.choose(retrievedHistory.argument as string[], retrievedHistory.lastOptionClose, retrievedHistory.privateInput, value);			}			if (retrievedHistory.action === ACTIONS.QUESTION) {				return this.question(retrievedHistory.argument as string, retrievedHistory.includeNewline, retrievedHistory.privateInput, value);			}		}	}
	/**	 * Read input from the console	 * @param {boolean} privateInput should use private input (requires --unstable flag)	 * @returns {Promise<string>} The value read	 */	public read = async (privateInput: boolean): Promise<string> => {		if (privateInput) {			const result = await this.readPrivate();			this.out.newline();			return result;		}		return new Promise(async (resolve, reject) => {			const n = await Deno.stdin.read(this.buf);
			if (n) {				resolve(this.cleanInput(new TextDecoder().decode(this.buf.subarray(0, n))));			} else {				reject();			}		});	}
	private readPrivate = async (): Promise<string> => {		(Deno as any).setRaw?.(Deno.stdin.rid, true);		const p = deferred<string>();		let input = '';
		let n = await Deno.stdin.read(this.buf);
		while (n) {			const text = new TextDecoder().decode(this.buf.subarray(0, n));			if (text.includes('\n') || text.includes('\r')) {				(Deno as any).setRaw?.(Deno.stdin.rid, false);				p.resolve(input);				break;			}			if (text.includes('\u0003') || text.includes('\u0004')) {				(Deno as any).setRaw?.(Deno.stdin.rid, false);				p.resolve('');				Deno.exit();			}			input += text;			n = await Deno.stdin.read(this.buf);		}
		return p;	}
	public wait = async (question?: string, includeNewline?: boolean): Promise<boolean> => {		this.out.print(question ?? 'Press any key to continue...', includeNewline ?? true);		(Deno as any).setRaw?.(Deno.stdin.rid, true);		const p = deferred<boolean>();
		let n = await Deno.stdin.read(this.buf);
		if (n) {			(Deno as any).setRaw?.(Deno.stdin.rid, false);			p.resolve(true);		} else {			p.resolve(false);		}
		return p;	}
	/**	 * Prompts the user to choose from a list of options	 * @param {string[]} options	 * @param {boolean} lastOptionClose Whether selecting the last option in the list should close the loop	 * @param {boolean} privateInput Use private input (requires --unstable flag)	 * @param {string | number} choice value to auto-select	 * @returns {Promise<boolean[]>} An array of booleans representing which index was selected	 */	public choose = async (options: string[], lastOptionClose?: boolean, privateInput?: boolean, choice?: string | number): Promise<boolean[]> => {		this.out.newline();		this.out.divider(30);		options.forEach((option: string, index: number) => {			this.out.print(`${index}: ${option}`, true);		});		this.out.divider(30);
		// Allow passing a result directly instead of prompting for it.		// Mostly used for testing without the need for interactive input
		let result: string;		if (choice !== undefined) {			result = this.cleanInput(this.coerceChoice(choice));		} else {			result = await this.read(privateInput ?? false);		}
		this.history.save(options, ACTIONS.CHOOSE, lastOptionClose ?? false, undefined, privateInput ?? false);
		if (lastOptionClose && result === String(options.length - 1)) {			this.close();		}
		return options.map((_option: string, index: number) => {			if (result === String(index)) {				return true;			}			return false;		});	}
	/**	 * Prompts the user to answer a question	 * @param {string} question	 * @param {boolean} includeNewline Include a newline before asking for the input	 * @param {boolean} privateInput Use private input (requires --unstable flag)	 * @param {string | number} value value to auto-select	 * @returns {Promise<string>} The value entered	 */	public question = async (question: string, includeNewline?: boolean, privateInput?: boolean, value?: string | number): Promise<string> => {		this.out.print(question, includeNewline ?? true);
		this.history.save(question, ACTIONS.QUESTION, undefined, includeNewline ?? true, privateInput ?? false);
		if (value) {			return this.cleanInput(this.coerceChoice(value));		}
		const result = await this.read(privateInput ?? false);		return result;	}
	/**	 * Closes the loop	 */	public close = () => {		this.done = true;	}}