1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
'use strict';
const _ = {
isPlainObject: require('lodash/isPlainObject'),
clone: require('lodash/clone'),
isArray: require('lodash/isArray'),
get: require('lodash/get'),
set: require('lodash/set'),
isFunction: require('lodash/isFunction'),
};
const { defer, empty, from, of } = require('rxjs');
const { concatMap, filter, publish, reduce } = require('rxjs/operators');
const runAsync = require('run-async');
const utils = require('../utils/utils');
const Base = require('./baseUI');
/**
* Base interface class other can inherits from
*/
class PromptUI extends Base {
constructor(prompts, opt) {
super(opt);
this.prompts = prompts;
}
run(questions, answers) {
// Keep global reference to the answers
if (_.isPlainObject(answers)) {
this.answers = _.clone(answers);
} else {
this.answers = {};
}
// Make sure questions is an array.
if (_.isPlainObject(questions)) {
// It's either an object of questions or a single question
questions = Object.values(questions).every(
(v) => _.isPlainObject(v) && v.name === undefined
)
? Object.entries(questions).map(([name, question]) => ({ name, ...question }))
: [questions];
}
// Create an observable, unless we received one as parameter.
// Note: As this is a public interface, we cannot do an instanceof check as we won't
// be using the exact same object in memory.
const obs = _.isArray(questions) ? from(questions) : questions;
this.process = obs.pipe(
concatMap(this.processQuestion.bind(this)),
publish() // Creates a hot Observable. It prevents duplicating prompts.
);
this.process.connect();
return this.process
.pipe(
reduce((answers, answer) => {
_.set(answers, answer.name, answer.answer);
return answers;
}, this.answers)
)
.toPromise(Promise)
.then(this.onCompletion.bind(this), this.onError.bind(this));
}
/**
* Once all prompt are over
*/
onCompletion() {
this.close();
return this.answers;
}
onError(error) {
this.close();
return Promise.reject(error);
}
processQuestion(question) {
question = _.clone(question);
return defer(() => {
const obs = of(question);
return obs.pipe(
concatMap(this.setDefaultType.bind(this)),
concatMap(this.filterIfRunnable.bind(this)),
concatMap(() =>
utils.fetchAsyncQuestionProperty(question, 'message', this.answers)
),
concatMap(() =>
utils.fetchAsyncQuestionProperty(question, 'default', this.answers)
),
concatMap(() =>
utils.fetchAsyncQuestionProperty(question, 'choices', this.answers)
),
concatMap(this.fetchAnswer.bind(this))
);
});
}
fetchAnswer(question) {
const Prompt = this.prompts[question.type];
this.activePrompt = new Prompt(question, this.rl, this.answers);
return defer(() =>
from(this.activePrompt.run().then((answer) => ({ name: question.name, answer })))
);
}
setDefaultType(question) {
// Default type to input
if (!this.prompts[question.type]) {
question.type = 'input';
}
return defer(() => of(question));
}
filterIfRunnable(question) {
if (
question.askAnswered !== true &&
_.get(this.answers, question.name) !== undefined
) {
return empty();
}
if (question.when === false) {
return empty();
}
if (!_.isFunction(question.when)) {
return of(question);
}
const { answers } = this;
return defer(() =>
from(
runAsync(question.when)(answers).then((shouldRun) => {
if (shouldRun) {
return question;
}
})
).pipe(filter((val) => val != null))
);
}
}
module.exports = PromptUI;
|
