6 var slice = Array.prototype.slice;
12 module.exports = co['default'] = co.co = co;
15 * Wrap the given generator `fn` into a
16 * function that returns a promise.
17 * This is a separate function so that
18 * every `co()` call doesn't create a new,
19 * unnecessary closure.
21 * @param {GeneratorFunction} fn
26 co.wrap = function (fn) {
27 createPromise.__generatorFunction__ = fn;
29 function createPromise() {
30 return co.call(this, fn.apply(this, arguments));
35 * Execute the generator function or a generator
36 * and return a promise.
38 * @param {Function} fn
45 var args = slice.call(arguments, 1)
47 // we wrap everything in a promise to avoid promise chaining,
48 // which leads to memory leak errors.
49 // see https://github.com/tj/co/issues/180
50 return new Promise(function(resolve, reject) {
51 if (typeof gen === 'function') gen = gen.apply(ctx, args);
52 if (!gen || typeof gen.next !== 'function') return resolve(gen);
62 function onFulfilled(res) {
78 function onRejected(err) {
89 * Get the next value in the generator,
98 if (ret.done) return resolve(ret.value);
99 var value = toPromise.call(ctx, ret.value);
100 if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
101 return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, '
102 + 'but the following object was passed: "' + String(ret.value) + '"'));
108 * Convert a `yield`ed value into a promise.
115 function toPromise(obj) {
116 if (!obj) return obj;
117 if (isPromise(obj)) return obj;
118 if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj);
119 if ('function' == typeof obj) return thunkToPromise.call(this, obj);
120 if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
121 if (isObject(obj)) return objectToPromise.call(this, obj);
126 * Convert a thunk to a promise.
133 function thunkToPromise(fn) {
135 return new Promise(function (resolve, reject) {
136 fn.call(ctx, function (err, res) {
137 if (err) return reject(err);
138 if (arguments.length > 2) res = slice.call(arguments, 1);
145 * Convert an array of "yieldables" to a promise.
146 * Uses `Promise.all()` internally.
153 function arrayToPromise(obj) {
154 return Promise.all(obj.map(toPromise, this));
158 * Convert an object of "yieldables" to a promise.
159 * Uses `Promise.all()` internally.
161 * @param {Object} obj
166 function objectToPromise(obj){
167 var results = new obj.constructor();
168 var keys = Object.keys(obj);
170 for (var i = 0; i < keys.length; i++) {
172 var promise = toPromise.call(this, obj[key]);
173 if (promise && isPromise(promise)) defer(promise, key);
174 else results[key] = obj[key];
176 return Promise.all(promises).then(function () {
180 function defer(promise, key) {
181 // predefine the key in the result
182 results[key] = undefined;
183 promises.push(promise.then(function (res) {
190 * Check if `obj` is a promise.
192 * @param {Object} obj
197 function isPromise(obj) {
198 return 'function' == typeof obj.then;
202 * Check if `obj` is a generator.
209 function isGenerator(obj) {
210 return 'function' == typeof obj.next && 'function' == typeof obj.throw;
214 * Check if `obj` is a generator function.
220 function isGeneratorFunction(obj) {
221 var constructor = obj.constructor;
222 if (!constructor) return false;
223 if ('GeneratorFunction' === constructor.name || 'GeneratorFunction' === constructor.displayName) return true;
224 return isGenerator(constructor.prototype);
228 * Check for plain object.
235 function isObject(val) {
236 return Object == val.constructor;