123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370
import type { Cursor } from "../ansi/cursor_position.ts";import { tty } from "../ansi/tty.ts";import { KeyCode, parse } from "../keycode/key_code.ts";import { blue, bold, dim, green, italic, red, yellow } from "./deps.ts";import { Figures } from "./figures.ts";
/** Prompt validation return tape. */export type ValidateResult = string | boolean | Promise<string | boolean>;
/** Input keys options. */export interface GenericPromptKeys {  submit?: string[];}
/** Generic prompt options. */export interface GenericPromptOptions<T, V> {  message: string;  default?: T;  validate?: (value: V) => ValidateResult;  transform?: (value: V) => T | undefined;  hint?: string;  pointer?: string;  indent?: string;  keys?: GenericPromptKeys;  cbreak?: boolean;}
/** Generic prompt settings. */export interface GenericPromptSettings<T, V>  extends GenericPromptOptions<T, V> {  pointer: string;  indent: string;}
/** Static generic prompt interface. */export interface StaticGenericPrompt<  T,  V,  O extends GenericPromptOptions<T, V>,  S extends GenericPromptSettings<T, V>,  P extends GenericPrompt<T, V, S>,> {  inject?(value: T): void;
  prompt(options: O): Promise<T>;}
/** Generic prompt representation. */export abstract class GenericPrompt<  T,  V,  S extends GenericPromptSettings<T, V>,> {  protected static injectedValue: unknown | undefined;  protected readonly settings: S;  protected readonly tty = tty;  protected readonly indent: string;  protected readonly cursor: Cursor = {    x: 0,    y: 0,  };  #value: T | undefined;  #lastError: string | undefined;  #isFirstRun = true;
  /**   * Inject prompt value. Can be used for unit tests or pre selections.   * @param value Input value.   */  public static inject(value: unknown): void {    GenericPrompt.injectedValue = value;  }
  protected constructor(settings: S) {    this.settings = {      ...settings,      keys: {        submit: ["enter", "return"],        ...(settings.keys ?? {}),      },    };    this.indent = this.settings.indent ?? " ";  }
  /** Execute the prompt and show cursor on end. */  public async prompt(): Promise<T> {    try {      return await this.#execute();    } finally {      this.tty.cursorShow();    }  }
  /** Clear prompt output. */  protected clear(): void {    this.tty.cursorLeft.eraseDown();  }
  /** Execute the prompt. */  #execute = async (): Promise<T> => {    // Throw errors on unit tests.    if (typeof GenericPrompt.injectedValue !== "undefined" && this.#lastError) {      throw new Error(await this.error());    }
    await this.render();    this.#lastError = undefined;
    if (!await this.read()) {      return this.#execute();    }
    if (typeof this.#value === "undefined") {      throw new Error("internal error: failed to read value");    }
    this.clear();    const successMessage: string | undefined = this.success(      this.#value,    );    if (successMessage) {      console.log(successMessage);    }
    GenericPrompt.injectedValue = undefined;    this.tty.cursorShow();
    return this.#value;  };
  /** Render prompt. */  protected async render(): Promise<void> {    const result: [string, string | undefined, string | undefined] =      await Promise.all([        this.message(),        this.body?.(),        this.footer(),      ]);
    const content: string = result.filter(Boolean).join("\n");    const y: number = content.split("\n").length - this.cursor.y - 1;
    if (!this.#isFirstRun || this.#lastError) {      this.clear();    }    this.#isFirstRun = false;
    if (Deno.build.os === "windows") {      console.log(content);      this.tty.cursorUp();    } else {      Deno.stdout.writeSync(new TextEncoder().encode(content));    }
    if (y) {      this.tty.cursorUp(y);    }    this.tty.cursorTo(this.cursor.x);  }
  /** Read user input from stdin, handle events and validate user input. */  protected async read(): Promise<boolean> {    if (typeof GenericPrompt.injectedValue !== "undefined") {      const value: V = GenericPrompt.injectedValue as V;      await this.#validateValue(value);    } else {      const events: KeyCode[] = await this.#readKey();
      if (!events.length) {        return false;      }
      for (const event of events) {        await this.handleEvent(event);      }    }
    return typeof this.#value !== "undefined";  }
  protected submit(): Promise<void> {    return this.#validateValue(this.getValue());  }
  protected message(): string {    return `${this.settings.indent}${yellow("?")} ` +      bold(this.settings.message) + this.defaults();  }
  protected defaults(): string {    let defaultMessage = "";    if (typeof this.settings.default !== "undefined") {      defaultMessage += dim(` (${this.format(this.settings.default)})`);    }    return defaultMessage;  }
  /** Get prompt success message. */  protected success(value: T): string | undefined {    return `${this.settings.indent}${yellow("?")} ` +      bold(this.settings.message) + this.defaults() +      " " + this.settings.pointer +      " " + green(this.format(value));  }
  protected body?(): string | undefined | Promise<string | undefined>;
  protected footer(): string | undefined {    return this.error() ?? this.hint();  }
  protected error(): string | undefined {    return this.#lastError      ? this.settings.indent + red(bold(`${Figures.CROSS} `) + this.#lastError)      : undefined;  }
  protected hint(): string | undefined {    return this.settings.hint      ? this.settings.indent +        italic(blue(dim(`${Figures.POINTER} `) + this.settings.hint))      : undefined;  }
  /**   * Handle user input event.   * @param event Key event.   */  protected async handleEvent(event: KeyCode): Promise<void> {    switch (true) {      case event.name === "c" && event.ctrl:        this.clear();        this.tty.cursorShow();        Deno.exit(0);        return;      case this.isKey(this.settings.keys, "submit", event):        await this.submit();        break;    }  }
  /**   * Map input value to output value.   * @param value Input value.   * @return Output value.   */  protected abstract transform(value: V): T | undefined;
  /**   * Validate input value.   * @param value User input value.   * @return True on success, false or error message on error.   */  protected abstract validate(value: V): ValidateResult;
  /**   * Format output value.   * @param value Output value.   */  protected abstract format(value: T): string;
  /** Get input value. */  protected abstract getValue(): V;
  /** Read user input from stdin and pars ansi codes. */  #readKey = async (): Promise<KeyCode[]> => {    const data: Uint8Array = await this.#readChar();
    return data.length ? parse(data) : [];  };
  /** Read user input from stdin. */  #readChar = async (): Promise<Uint8Array> => {    const buffer = new Uint8Array(8);    const isTty = Deno.isatty(Deno.stdin.rid);
    if (isTty) {      // cbreak is only supported on deno >= 1.6.0, suppress ts-error.      (Deno.setRaw as setRaw)(        Deno.stdin.rid,        true,        { cbreak: this.settings.cbreak === true },      );    }    const nread: number | null = await Deno.stdin.read(buffer);
    if (isTty) {      Deno.setRaw(Deno.stdin.rid, false);    }
    if (nread === null) {      return buffer;    }
    return buffer.subarray(0, nread);  };
  /**   * Map input value to output value. If a custom transform handler ist set, the   * custom handler will be executed, otherwise the default transform handler   * from the prompt will be executed.   * @param value The value to transform.   */  #transformValue = (value: V): T | undefined => {    return this.settings.transform      ? this.settings.transform(value)      : this.transform(value);  };
  /**   * Validate input value. Set error message if validation fails and transform   * output value on success.   * If a default value is set, the default will be used as value without any   * validation.   * If a custom validation handler ist set, the custom handler will   * be executed, otherwise a prompt specific default validation handler will be   * executed.   * @param value The value to validate.   */  #validateValue = async (value: V): Promise<void> => {    if (!value && typeof this.settings.default !== "undefined") {      this.#value = this.settings.default;      return;    }
    this.#value = undefined;    this.#lastError = undefined;
    const validation =      await (this.settings.validate        ? this.settings.validate(value)        : this.validate(value));
    if (validation === false) {      this.#lastError = `Invalid answer.`;    } else if (typeof validation === "string") {      this.#lastError = validation;    } else {      this.#value = this.#transformValue(value);    }  };
  /**   * Check if key event has given name or sequence.   * @param keys  Key map.   * @param name  Key name.   * @param event Key event.   */  protected isKey<K extends unknown, N extends keyof K>(    keys: K | undefined,    name: N,    event: KeyCode,  ): boolean {    // deno-lint-ignore no-explicit-any    const keyNames: Array<unknown> | undefined = keys?.[name] as any;    return typeof keyNames !== "undefined" && (      (typeof event.name !== "undefined" &&        keyNames.indexOf(event.name) !== -1) ||      (typeof event.sequence !== "undefined" &&        keyNames.indexOf(event.sequence) !== -1)    );  }}
type setRaw = (  rid: number,  mode: boolean,  options?: { cbreak?: boolean },) => void;