Class InquirerPresenter

Prompts questions to the user using the Inquirer library

Implements

Presenter

Index

Constructors

Methods

checkbox confirm input list place print printCards

Constructors

constructor

new InquirerPresenter(): InquirerPresenter
Returns InquirerPresenter

Methods

checkbox

checkbox<T, ValidateParam>(
    options: {
        choices: { name: string; value: T }[];
        message: Presentable[];
        type: string;
        validate?: (
            input: T[],
            validateParam: ValidateParam,
        ) => string | true | Promise<string | true>;
        validateParam?: ValidateParam;
    },
): () => Promise<any>
Allow the user to select multiple or no options from a list

The validator function passed must not use any closure variables to work properly over a serialized interface
Type Parameters
- T
- ValidateParam
Parameters
- options: {
      choices: { name: string; value: T }[];
      message: Presentable[];
      type: string;
      validate?: (
          input: T[],
          validateParam: ValidateParam,
      ) => string | true | Promise<string | true>;
      validateParam?: ValidateParam;
  }
  the options to pass
Returns () => Promise<any>
Implementation of Presenter.checkbox
- Defined in libs/core/src/intermediary/inquirer-presenter.ts:20

confirm

confirm(options: { message: Presentable[] }): () => Promise<any>
Prompt the user a simple yes/no question
Parameters
- options: { message: Presentable[] }
  the options to pass
Returns () => Promise<any>
Implementation of Presenter.confirm
- Defined in libs/core/src/intermediary/inquirer-presenter.ts:51

input

input<ValidateParam>(
    options: {
        message: Presentable[];
        validate?: (
            input: string,
            param: ValidateParam,
        ) => string | true | Promise<string | true>;
        validateParam?: ValidateParam;
    },
): () => Promise<any>
Allow a user to input a text string of their choice

The validator function passed must not use any closure variables to work properly over a serialized interface
Type Parameters
- ValidateParam
Parameters
- options: {
      message: Presentable[];
      validate?: (
          input: string,
          param: ValidateParam,
      ) => string | true | Promise<string | true>;
      validateParam?: ValidateParam;
  }
  the options to pass
Returns () => Promise<any>
Implementation of Presenter.input
- Defined in libs/core/src/intermediary/inquirer-presenter.ts:40

list

list<T>(
    options: {
        choices: { name: string; value: T }[];
        message: Presentable[];
        type: string;
    },
): () => Promise<any>
Allows a user to select from a list
Type Parameters
- T
Parameters
- options: { choices: { name: string; value: T }[]; message: Presentable[]; type: string }
  the options to pass
Returns () => Promise<any>
Implementation of Presenter.list
- Defined in libs/core/src/intermediary/inquirer-presenter.ts:31

place

place<T, ValidateParam>(
    options: {
        choices: { name: string; value: T }[];
        message: Presentable[];
        placeholder: string;
        validate?: (
            input: number,
            param: ValidateParam,
        ) => string | true | Promise<string | true>;
        validateParam?: ValidateParam;
    },
): () => Promise<any>
Allow a user to decide wherein a list to place an item

The validator function passed must not use any closure variables to work properly over a serialized interface
Type Parameters
- T
- ValidateParam
Parameters
- options: {
      choices: { name: string; value: T }[];
      message: Presentable[];
      placeholder: string;
      validate?: (
          input: number,
          param: ValidateParam,
      ) => string | true | Promise<string | true>;
      validateParam?: ValidateParam;
  }
  the options to pass
Returns () => Promise<any>
Implementation of Presenter.place
- Defined in libs/core/src/intermediary/inquirer-presenter.ts:60

print

print(options: { message: undefined | Presentable[] }): () => void
Print a message or list of serializables
Parameters
- options: { message: undefined | Presentable[] }
  the options to pass
Returns () => void
Implementation of Presenter.print
- Defined in libs/core/src/intermediary/inquirer-presenter.ts:71

printCards

printCards(options: { cards: Card[] }): () => Card[] | Promise<Card[]>
Show the user their hand (and allow them to rearrange in relevant contexts)
Parameters
- options: { cards: Card[] }
  options the options to pass
Returns () => Card[] | Promise<Card[]>
Implementation of Presenter.printCards
- Defined in libs/core/src/intermediary/inquirer-presenter.ts:15