148 lines
3.3 KiB
TypeScript
148 lines
3.3 KiB
TypeScript
import * as plugins from './smartinteract.plugins'
|
|
import * as smartq from 'smartq'
|
|
import { Objectmap } from 'lik'
|
|
|
|
export type questionType = 'input' | 'confirm' | 'list' | 'rawlist' | 'expand' | 'checkbox' | 'password' | 'editor'
|
|
|
|
export interface IChoiceObject {
|
|
name: string
|
|
value: any
|
|
}
|
|
|
|
export interface IQuestionObject {
|
|
name: string
|
|
type: questionType
|
|
message: string
|
|
default: any
|
|
choices?: string[] | IChoiceObject[]
|
|
validate?: IValidateFunction
|
|
}
|
|
|
|
export interface IAnswerObject {
|
|
name: string,
|
|
value: any
|
|
}
|
|
|
|
export interface IValidateFunction {
|
|
(anyObject: any): boolean
|
|
}
|
|
|
|
/**
|
|
* class SmartInteract - allows to specify an user interaction during runtime
|
|
*/
|
|
export class SmartInteract {
|
|
|
|
/**
|
|
* holds the qestion queue, that is emptied once you call
|
|
*/
|
|
private questionMap = new Objectmap<IQuestionObject>()
|
|
|
|
/**
|
|
* constructor of class SmartInteract
|
|
*/
|
|
constructor (questionArrayArg?: IQuestionObject[]) {
|
|
if (questionArrayArg) {
|
|
this.addQuestions(questionArrayArg)
|
|
}
|
|
}
|
|
/**
|
|
* allows you to ask a single question and returns the answer in a promise
|
|
* skips the queue
|
|
*/
|
|
askQuestion (optionsArg: IQuestionObject): Promise<IAnswerObject> {
|
|
let done = smartq.defer<IAnswerObject>()
|
|
if (this.isValidEnv()) {
|
|
plugins.inquirer.prompt([ {
|
|
name: optionsArg.name,
|
|
type: optionsArg.type,
|
|
message: optionsArg.message,
|
|
default: optionsArg.default,
|
|
choices: optionsArg.choices,
|
|
validate: optionsArg.validate
|
|
}]).then((answers: IAnswerObject[]) => {
|
|
done.resolve({
|
|
name: optionsArg.name,
|
|
value: answers[ optionsArg.name ]
|
|
})
|
|
})
|
|
} else {
|
|
let answer: IAnswerObject = {
|
|
name: optionsArg.name,
|
|
value: optionsArg.default
|
|
}
|
|
done.resolve(answer)
|
|
}
|
|
|
|
return done.promise
|
|
}
|
|
|
|
/**
|
|
* add questions to queue
|
|
*/
|
|
addQuestions (questionArrayArg: IQuestionObject[]) {
|
|
this.questionMap.addArray(questionArrayArg)
|
|
}
|
|
|
|
/**
|
|
* run the question queue
|
|
*/
|
|
runQueue () {
|
|
let done = smartq.defer<AnswerBucket>()
|
|
let answerBucket = new AnswerBucket()
|
|
let handleQuestion = async () => {
|
|
if (!this.questionMap.isEmpty()) {
|
|
let oneQuestion = this.questionMap.getOneAndRemove()
|
|
let answer: IAnswerObject = await this.askQuestion(oneQuestion)
|
|
answerBucket.addAnswer(answer)
|
|
handleQuestion() // recursion: as questions until empty
|
|
} else {
|
|
done.resolve(answerBucket) // when empty, then resolve promise
|
|
}
|
|
}
|
|
handleQuestion()
|
|
return done.promise
|
|
}
|
|
|
|
/**
|
|
* checks if the current env is valid for userinput
|
|
*/
|
|
private isValidEnv (): boolean {
|
|
if (!process.env.CI) {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* class AnswerBucket holds answers
|
|
*/
|
|
export class AnswerBucket {
|
|
answerMap = new Objectmap<IAnswerObject>()
|
|
|
|
/**
|
|
* add an answer to the bucket
|
|
*/
|
|
addAnswer (answerArg: IAnswerObject) {
|
|
this.answerMap.add(answerArg)
|
|
}
|
|
|
|
/**
|
|
* gets an answer for a specific name
|
|
*/
|
|
getAnswerFor (nameArg: string) {
|
|
let answer = this.answerMap.find(answerArg => {
|
|
return answerArg.name === nameArg
|
|
})
|
|
return answer.value
|
|
}
|
|
|
|
/**
|
|
* gets all answers as array
|
|
*/
|
|
getAllAnswers () {
|
|
return this.answerMap.getArray()
|
|
}
|
|
}
|