Spaces:
Sleeping
Sleeping
/** | |
* slice() reference. | |
*/ | |
var slice = Array.prototype.slice; | |
/** | |
* Expose `co`. | |
*/ | |
module.exports = co['default'] = co.co = co; | |
/** | |
* Wrap the given generator `fn` into a | |
* function that returns a promise. | |
* This is a separate function so that | |
* every `co()` call doesn't create a new, | |
* unnecessary closure. | |
* | |
* @param {GeneratorFunction} fn | |
* @return {Function} | |
* @api public | |
*/ | |
co.wrap = function (fn) { | |
createPromise.__generatorFunction__ = fn; | |
return createPromise; | |
function createPromise() { | |
return co.call(this, fn.apply(this, arguments)); | |
} | |
}; | |
/** | |
* Execute the generator function or a generator | |
* and return a promise. | |
* | |
* @param {Function} fn | |
* @return {Promise} | |
* @api public | |
*/ | |
function co(gen) { | |
var ctx = this; | |
var args = slice.call(arguments, 1) | |
// we wrap everything in a promise to avoid promise chaining, | |
// which leads to memory leak errors. | |
// see https://github.com/tj/co/issues/180 | |
return new Promise(function(resolve, reject) { | |
if (typeof gen === 'function') gen = gen.apply(ctx, args); | |
if (!gen || typeof gen.next !== 'function') return resolve(gen); | |
onFulfilled(); | |
/** | |
* @param {Mixed} res | |
* @return {Promise} | |
* @api private | |
*/ | |
function onFulfilled(res) { | |
var ret; | |
try { | |
ret = gen.next(res); | |
} catch (e) { | |
return reject(e); | |
} | |
next(ret); | |
} | |
/** | |
* @param {Error} err | |
* @return {Promise} | |
* @api private | |
*/ | |
function onRejected(err) { | |
var ret; | |
try { | |
ret = gen.throw(err); | |
} catch (e) { | |
return reject(e); | |
} | |
next(ret); | |
} | |
/** | |
* Get the next value in the generator, | |
* return a promise. | |
* | |
* @param {Object} ret | |
* @return {Promise} | |
* @api private | |
*/ | |
function next(ret) { | |
if (ret.done) return resolve(ret.value); | |
var value = toPromise.call(ctx, ret.value); | |
if (value && isPromise(value)) return value.then(onFulfilled, onRejected); | |
return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, ' | |
+ 'but the following object was passed: "' + String(ret.value) + '"')); | |
} | |
}); | |
} | |
/** | |
* Convert a `yield`ed value into a promise. | |
* | |
* @param {Mixed} obj | |
* @return {Promise} | |
* @api private | |
*/ | |
function toPromise(obj) { | |
if (!obj) return obj; | |
if (isPromise(obj)) return obj; | |
if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj); | |
if ('function' == typeof obj) return thunkToPromise.call(this, obj); | |
if (Array.isArray(obj)) return arrayToPromise.call(this, obj); | |
if (isObject(obj)) return objectToPromise.call(this, obj); | |
return obj; | |
} | |
/** | |
* Convert a thunk to a promise. | |
* | |
* @param {Function} | |
* @return {Promise} | |
* @api private | |
*/ | |
function thunkToPromise(fn) { | |
var ctx = this; | |
return new Promise(function (resolve, reject) { | |
fn.call(ctx, function (err, res) { | |
if (err) return reject(err); | |
if (arguments.length > 2) res = slice.call(arguments, 1); | |
resolve(res); | |
}); | |
}); | |
} | |
/** | |
* Convert an array of "yieldables" to a promise. | |
* Uses `Promise.all()` internally. | |
* | |
* @param {Array} obj | |
* @return {Promise} | |
* @api private | |
*/ | |
function arrayToPromise(obj) { | |
return Promise.all(obj.map(toPromise, this)); | |
} | |
/** | |
* Convert an object of "yieldables" to a promise. | |
* Uses `Promise.all()` internally. | |
* | |
* @param {Object} obj | |
* @return {Promise} | |
* @api private | |
*/ | |
function objectToPromise(obj){ | |
var results = new obj.constructor(); | |
var keys = Object.keys(obj); | |
var promises = []; | |
for (var i = 0; i < keys.length; i++) { | |
var key = keys[i]; | |
var promise = toPromise.call(this, obj[key]); | |
if (promise && isPromise(promise)) defer(promise, key); | |
else results[key] = obj[key]; | |
} | |
return Promise.all(promises).then(function () { | |
return results; | |
}); | |
function defer(promise, key) { | |
// predefine the key in the result | |
results[key] = undefined; | |
promises.push(promise.then(function (res) { | |
results[key] = res; | |
})); | |
} | |
} | |
/** | |
* Check if `obj` is a promise. | |
* | |
* @param {Object} obj | |
* @return {Boolean} | |
* @api private | |
*/ | |
function isPromise(obj) { | |
return 'function' == typeof obj.then; | |
} | |
/** | |
* Check if `obj` is a generator. | |
* | |
* @param {Mixed} obj | |
* @return {Boolean} | |
* @api private | |
*/ | |
function isGenerator(obj) { | |
return 'function' == typeof obj.next && 'function' == typeof obj.throw; | |
} | |
/** | |
* Check if `obj` is a generator function. | |
* | |
* @param {Mixed} obj | |
* @return {Boolean} | |
* @api private | |
*/ | |
function isGeneratorFunction(obj) { | |
var constructor = obj.constructor; | |
if (!constructor) return false; | |
if ('GeneratorFunction' === constructor.name || 'GeneratorFunction' === constructor.displayName) return true; | |
return isGenerator(constructor.prototype); | |
} | |
/** | |
* Check for plain object. | |
* | |
* @param {Mixed} val | |
* @return {Boolean} | |
* @api private | |
*/ | |
function isObject(val) { | |
return Object == val.constructor; | |
} | |