527 lines
11 KiB
JavaScript
527 lines
11 KiB
JavaScript
|
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.co = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
||
|
|
var PinkiePromise = require('pinkie-promise');
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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 PinkiePromise(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 PinkiePromise(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 PinkiePromise.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;
|
||
|
|
}
|
||
|
|
|
||
|
|
},{"pinkie-promise":2}],2:[function(require,module,exports){
|
||
|
|
(function (global){
|
||
|
|
'use strict';
|
||
|
|
|
||
|
|
module.exports = global.Promise || require('pinkie');
|
||
|
|
|
||
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
|
|
},{"pinkie":3}],3:[function(require,module,exports){
|
||
|
|
'use strict';
|
||
|
|
|
||
|
|
var PENDING = 'pending';
|
||
|
|
var SETTLED = 'settled';
|
||
|
|
var FULFILLED = 'fulfilled';
|
||
|
|
var REJECTED = 'rejected';
|
||
|
|
var NOOP = function () {};
|
||
|
|
|
||
|
|
// async calls
|
||
|
|
var asyncSetTimer = typeof setImmediate !== 'undefined' ? setImmediate : setTimeout;
|
||
|
|
var asyncQueue = [];
|
||
|
|
var asyncTimer;
|
||
|
|
|
||
|
|
function asyncFlush() {
|
||
|
|
// run promise callbacks
|
||
|
|
for (var i = 0; i < asyncQueue.length; i++) {
|
||
|
|
asyncQueue[i][0](asyncQueue[i][1]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// reset async asyncQueue
|
||
|
|
asyncQueue = [];
|
||
|
|
asyncTimer = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
function asyncCall(callback, arg) {
|
||
|
|
asyncQueue.push([callback, arg]);
|
||
|
|
|
||
|
|
if (!asyncTimer) {
|
||
|
|
asyncTimer = true;
|
||
|
|
asyncSetTimer(asyncFlush, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function invokeResolver(resolver, promise) {
|
||
|
|
function resolvePromise(value) {
|
||
|
|
resolve(promise, value);
|
||
|
|
}
|
||
|
|
|
||
|
|
function rejectPromise(reason) {
|
||
|
|
reject(promise, reason);
|
||
|
|
}
|
||
|
|
|
||
|
|
try {
|
||
|
|
resolver(resolvePromise, rejectPromise);
|
||
|
|
} catch (e) {
|
||
|
|
rejectPromise(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function invokeCallback(subscriber) {
|
||
|
|
var owner = subscriber.owner;
|
||
|
|
var settled = owner._state;
|
||
|
|
var value = owner._data;
|
||
|
|
var callback = subscriber[settled];
|
||
|
|
var promise = subscriber.then;
|
||
|
|
|
||
|
|
if (typeof callback === 'function') {
|
||
|
|
settled = FULFILLED;
|
||
|
|
try {
|
||
|
|
value = callback(value);
|
||
|
|
} catch (e) {
|
||
|
|
reject(promise, e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!handleThenable(promise, value)) {
|
||
|
|
if (settled === FULFILLED) {
|
||
|
|
resolve(promise, value);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (settled === REJECTED) {
|
||
|
|
reject(promise, value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function handleThenable(promise, value) {
|
||
|
|
var resolved;
|
||
|
|
|
||
|
|
try {
|
||
|
|
if (promise === value) {
|
||
|
|
throw new TypeError('A promises callback cannot return that same promise.');
|
||
|
|
}
|
||
|
|
|
||
|
|
if (value && (typeof value === 'function' || typeof value === 'object')) {
|
||
|
|
var then = value.then; // then should be retrived only once
|
||
|
|
|
||
|
|
if (typeof then === 'function') {
|
||
|
|
then.call(value, function (val) {
|
||
|
|
if (!resolved) {
|
||
|
|
resolved = true;
|
||
|
|
|
||
|
|
if (value !== val) {
|
||
|
|
resolve(promise, val);
|
||
|
|
} else {
|
||
|
|
fulfill(promise, val);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, function (reason) {
|
||
|
|
if (!resolved) {
|
||
|
|
resolved = true;
|
||
|
|
|
||
|
|
reject(promise, reason);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} catch (e) {
|
||
|
|
if (!resolved) {
|
||
|
|
reject(promise, e);
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
function resolve(promise, value) {
|
||
|
|
if (promise === value || !handleThenable(promise, value)) {
|
||
|
|
fulfill(promise, value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function fulfill(promise, value) {
|
||
|
|
if (promise._state === PENDING) {
|
||
|
|
promise._state = SETTLED;
|
||
|
|
promise._data = value;
|
||
|
|
|
||
|
|
asyncCall(publishFulfillment, promise);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function reject(promise, reason) {
|
||
|
|
if (promise._state === PENDING) {
|
||
|
|
promise._state = SETTLED;
|
||
|
|
promise._data = reason;
|
||
|
|
|
||
|
|
asyncCall(publishRejection, promise);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function publish(promise) {
|
||
|
|
promise._then = promise._then.forEach(invokeCallback);
|
||
|
|
}
|
||
|
|
|
||
|
|
function publishFulfillment(promise) {
|
||
|
|
promise._state = FULFILLED;
|
||
|
|
publish(promise);
|
||
|
|
}
|
||
|
|
|
||
|
|
function publishRejection(promise) {
|
||
|
|
promise._state = REJECTED;
|
||
|
|
publish(promise);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @class
|
||
|
|
*/
|
||
|
|
function Promise(resolver) {
|
||
|
|
if (typeof resolver !== 'function') {
|
||
|
|
throw new TypeError('Promise resolver ' + resolver + ' is not a function');
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this instanceof Promise === false) {
|
||
|
|
throw new TypeError('Failed to construct \'Promise\': Please use the \'new\' operator, this object constructor cannot be called as a function.');
|
||
|
|
}
|
||
|
|
|
||
|
|
this._then = [];
|
||
|
|
|
||
|
|
invokeResolver(resolver, this);
|
||
|
|
}
|
||
|
|
|
||
|
|
Promise.prototype = {
|
||
|
|
constructor: Promise,
|
||
|
|
|
||
|
|
_state: PENDING,
|
||
|
|
_then: null,
|
||
|
|
_data: undefined,
|
||
|
|
|
||
|
|
then: function (onFulfillment, onRejection) {
|
||
|
|
var subscriber = {
|
||
|
|
owner: this,
|
||
|
|
then: new this.constructor(NOOP),
|
||
|
|
fulfilled: onFulfillment,
|
||
|
|
rejected: onRejection
|
||
|
|
};
|
||
|
|
|
||
|
|
if (this._state === FULFILLED || this._state === REJECTED) {
|
||
|
|
// already resolved, call callback async
|
||
|
|
asyncCall(invokeCallback, subscriber);
|
||
|
|
} else {
|
||
|
|
// subscribe
|
||
|
|
this._then.push(subscriber);
|
||
|
|
}
|
||
|
|
|
||
|
|
return subscriber.then;
|
||
|
|
},
|
||
|
|
|
||
|
|
'catch': function (onRejection) {
|
||
|
|
return this.then(null, onRejection);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
Promise.all = function (promises) {
|
||
|
|
if (!Array.isArray(promises)) {
|
||
|
|
throw new TypeError('You must pass an array to Promise.all().');
|
||
|
|
}
|
||
|
|
|
||
|
|
return new Promise(function (resolve, reject) {
|
||
|
|
var results = [];
|
||
|
|
var remaining = 0;
|
||
|
|
|
||
|
|
function resolver(index) {
|
||
|
|
remaining++;
|
||
|
|
return function (value) {
|
||
|
|
results[index] = value;
|
||
|
|
if (!--remaining) {
|
||
|
|
resolve(results);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
for (var i = 0, promise; i < promises.length; i++) {
|
||
|
|
promise = promises[i];
|
||
|
|
|
||
|
|
if (promise && typeof promise.then === 'function') {
|
||
|
|
promise.then(resolver(i), reject);
|
||
|
|
} else {
|
||
|
|
results[i] = promise;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!remaining) {
|
||
|
|
resolve(results);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
Promise.race = function (promises) {
|
||
|
|
if (!Array.isArray(promises)) {
|
||
|
|
throw new TypeError('You must pass an array to Promise.race().');
|
||
|
|
}
|
||
|
|
|
||
|
|
return new Promise(function (resolve, reject) {
|
||
|
|
for (var i = 0, promise; i < promises.length; i++) {
|
||
|
|
promise = promises[i];
|
||
|
|
|
||
|
|
if (promise && typeof promise.then === 'function') {
|
||
|
|
promise.then(resolve, reject);
|
||
|
|
} else {
|
||
|
|
resolve(promise);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
Promise.resolve = function (value) {
|
||
|
|
if (value && typeof value === 'object' && value.constructor === Promise) {
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
return new Promise(function (resolve) {
|
||
|
|
resolve(value);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
Promise.reject = function (reason) {
|
||
|
|
return new Promise(function (resolve, reject) {
|
||
|
|
reject(reason);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
module.exports = Promise;
|
||
|
|
|
||
|
|
},{}]},{},[1])(1)
|
||
|
|
});
|