update dependencies and allow empty question set

ts/index.ts

@@ -1 +1 @@
-export * from './smartinteract.classes.smartinteract'
+export * from './smartinteract.classes.smartinteract'

ts/smartinteract.classes.smartinteract.ts

@@ -1,30 +1,30 @@
 import * as plugins from './smartinteract.plugins'
-import * as q from 'q'
+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
+  name: string
+  value: any
 }
 
 export interface IQuestionObject {
-    name: string
-    type: questionType
-    message: string
-    default: any
-    choices?: string[] | IChoiceObject[]
-    validate?: IValidateFunction
+  name: string
+  type: questionType
+  message: string
+  default: any
+  choices?: string[] | IChoiceObject[]
+  validate?: IValidateFunction
 }
 
 export interface IAnswerObject {
-    name: string,
-    value: any
+  name: string,
+  value: any
 }
 
 export interface IValidateFunction {
-    (anyObject: any): boolean
+  (anyObject: any): boolean
 }
 
 /**
@@ -32,117 +32,116 @@ export interface IValidateFunction {
  */
 export class SmartInteract {
 
-    /**
-     * holds  the qestion queue, that is emptied once you call 
-     */
-    private questionMap = new Objectmap<IQuestionObject>()
+  /**
+   * 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)
-        }
+  /**
+   * 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): q.Promise<IAnswerObject> {
-        let done = q.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
+  }
+  /**
+   * 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)
     }
 
-    /**
-     * add questions to queue
-     */
-    addQuestions(questionArrayArg: IQuestionObject[]) {
-        this.questionMap.addArray(questionArrayArg)
-    }
+    return done.promise
+  }
 
-    /**
-     * run the  question queue
-     */
-    runQueue() {
-        let done = q.defer<AnswerBucket>()
-        let answerBucket = new AnswerBucket()
-        let handleQuestion = () => {
-            let oneQuestion = this.questionMap.getOneAndRemove()
-            this.askQuestion(oneQuestion).then((answerArg: IAnswerObject) => {
-                answerBucket.addAnswer(answerArg)
-                if (!this.questionMap.isEmpty()) {
-                    handleQuestion() // recursion: as questions until empty
-                } else {
-                    done.resolve(answerBucket) // when empty, then resolve promise
-                }
-            })
-        }
-        handleQuestion()
-        return done.promise
-    }
+  /**
+   * add questions to queue
+   */
+  addQuestions (questionArrayArg: IQuestionObject[]) {
+    this.questionMap.addArray(questionArrayArg)
+  }
 
-    /**
-     * checks if the current env is valid for userinput
-     */
-    private isValidEnv(): boolean {
-        if (!process.env.CI) {
-            return true
-        } else {
-            return false
-        }
+  /**
+   * 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>()
+  answerMap = new Objectmap<IAnswerObject>()
 
-    /**
-     * add an answer to the bucket
-     */
-    addAnswer(answerArg: IAnswerObject) {
-        this.answerMap.add(answerArg)
-    }
+  /**
+   * 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 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()
-    }
+  /**
+   * gets all answers as array
+   */
+  getAllAnswers () {
+    return this.answerMap.getArray()
+  }
 }

ts/smartinteract.plugins.ts

@@ -2,5 +2,5 @@ import 'typings-global'
 import * as inquirer from 'inquirer'
 
 export {
-    inquirer
-}
+  inquirer
+}