Prompt.prototype.handleSubmitEvents = function (submit) {
var self = this;
var validate = runAsync(this.opt.validate);
var filter = runAsync(this.opt.filter);
var validation = submit.flatMap(function (value) {
return filter(value).then(function (filteredValue) {
return validate(filteredValue, self.answers).then(function (isValid) {
return {isValid: isValid, value: filteredValue};
});
}, function (err) {
return {isValid: err};
});
}).share();
var success = validation
.filter(function (state) {
return state.isValid === true;
})
.take(1);
var error = validation
.filter(function (state) {
return state.isValid !== true;
})
.takeUntil(success);
return {
success: success,
error: error
};
};
self.env.runLoop.add(queueName, function (completed) {
debug('Running ' + methodName);
self.emit('method:' + methodName);
runAsync(
function () {
self.async = function () {
return this.async();
}.bind(this);
return method.apply(self, self.args);
},
// runAsync return a promise which wraps first function.
// So ensure the callback function never throw an error.
function (err) {
if (err) {
debug('An error occured while running ' + methodName, err);
if (self.listeners('error').length > 0) {
self.emit('error', err);
}
cb(err);
return;
}
completed();
}
)();
});
return exports.createObservableFromAsync(function () {
var done = this.async();
runAsync(question[prop], function (value) {
question[prop] = value;
done(question);
}, answers);
});
return defer(() =>
from(
runAsync(question.when)(answers).then(shouldRun => {
if (shouldRun) {
return question;
}
})
).pipe(filter(val => val != null))
return Rx.Observable.defer(() =>
Rx.Observable.fromPromise(
runAsync(question.when)(answers).then(shouldRun => {
if (shouldRun) {
return question;
}
})
).filter(val => val != null)
var validation = submit.flatMap(function (value) {
return runAsync(self.opt.validate)(
self.getCurrentValue(value),
self.answers
).then(function (isValid) {
return {isValid: isValid, value: self.getCurrentValue(value)};
});
}).share();
return rx.Observable.create(function (obs) {
if (_.isBoolean(question.when)) {
handleResult(obs, question.when);
return;
}
runAsync(question.when, function (shouldRun) {
handleResult(obs, shouldRun);
}, answers);
});
Facebook.prototype.query = function(query, method) {
var self = this;
var method = (typeof method === 'undefined') ? 'get' : method;
var data = runAsync(function(done) {
self.fb[method](query, function(err, res) {
done(null, res);
});
});
return data.result;
}
return rx.Observable.defer(function () {
return rx.Observable.fromPromise(
runAsync(question.when)(answers).then(function (shouldRun) {
if (shouldRun) {
return question;
}
})
).filter(function (val) {
return val != null;
});
});
exports.fetchAsyncQuestionProperty = function (question, prop, answers) {
if (!_.isFunction(question[prop])) {
return rx.Observable.return(question);
}
return rx.Observable.fromPromise(runAsync(question[prop])(answers)
.then(function (value) {
question[prop] = value;
return question;
})
);
};
self.env.runLoop.add(queueName, completed => {
debug(`Running ${methodName}`);
self.emit(`method:${methodName}`);
runAsync(function () {
self.async = () => this.async();
return method.apply(self, self.args);
})().then(completed).catch(err => {
debug(`An error occured while running ${methodName}`, err);
// Ensure we emit the error event outside the promise context so it won't be
// swallowed when there's no listeners.
setImmediate(() => {
self.emit('error', err);
cb(err);
});
});
});
Prompt.prototype._run = function (cb) {
this.done = cb;
var events = observe(this.rl);
events.normalizedUpKey.takeUntil(events.line).forEach(this.onUpKey.bind(this));
events.normalizedDownKey.takeUntil(events.line).forEach(this.onDownKey.bind(this));
events.numberKey.takeUntil(events.line).forEach(this.onNumberKey.bind(this));
events.line
.take(1)
.map(this.getCurrentValue.bind(this))
.flatMap(runAsync(this.opt.filter))
.forEach(this.onSubmit.bind(this));
// Init the prompt
cliCursor.hide();
this.render();
return this;
};
self.env.runLoop.add(queueName, function (completed) {
debug('Running ' + methodName);
self.emit('method:' + methodName);
runAsync(function () {
self.async = function () {
return this.async();
}.bind(this);
return method.apply(self, self.args);
})().then(completed).catch(function (err) {
debug('An error occured while running ' + methodName, err);
// Ensure we emit the error event outside the promise context so it won't be
// swallowed when there's no listeners.
setImmediate(function () {
self.emit('error', err);
cb(err);
});
});
});
self.env.runLoop.add(queueName, function (completed) {
debug('Running ' + methodName);
self.emit('method:' + methodName);
runAsync(
function () {
self.async = function () {
return this.async();
}.bind(this);
return method.apply(self, self.args);
},
function (err) {
if (err) {
debug('An error occured while running ' + methodName, err);
self.emit('error', err);
}
completed();
}
)();
});
function createAsyncScopeEval (scope, opts) {
opts = opts || {}
const mdVarNames = []
const mdVarValues = []
Object.keys(scope || {})
.map(scopeVarName => {
mdVarNames.push(scopeVarName)
mdVarValues.push(scope[scopeVarName])
})
return runAsync(code => {
const funcBody = `${opts.useStrict ? "'use strict';" : ''}return (${code})`
try {
return Function
.apply(null, mdVarNames.concat(funcBody))
.apply(null, mdVarValues)
} catch (err) {
return Promise.reject(err)
}
})
}
Prompt.prototype.filter = function (input, cb) {
return runAsync(this.opt.filter, cb)(input);
};
return rx.Observable.create(function (obs) {
runAsync(func, function (value) {
obs.onNext(value);
obs.onCompleted();
});
});
flatMap(value => runAsync(self.opt.filter)(value).catch(err => err))
.flatMap(function (value) {
return runAsync(self.opt.filter)(value).catch(function (err) {
return err;
});
})
Prompt.prototype.validate = function (input, cb) {
runAsync(this.opt.validate, cb, input);
};
return rx.Observable.create(function (observer) {
runAsync(self.opt.validate, function (isValid) {
observer.onNext({ isValid: isValid, value: self.getCurrentValue(value) });
observer.onCompleted();
}, self.getCurrentValue(value), self.answers);
});