source: trip-planner-front/node_modules/pinkie/index.js@ 76712b2

'use strict';

var PENDING = 'pending';
var SETTLED = 'settled';
var FULFILLED = 'fulfilled';
var REJECTED = 'rejected';
var NOOP = function () {};
var isNode = typeof global !== 'undefined' && typeof global.process !== 'undefined' && typeof global.process.emit === 'function';

var asyncSetTimer = typeof setImmediate === 'undefined' ? setTimeout : setImmediate;
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')) {
                        // then should be retrieved only once
                        var then = value.then;

                        if (typeof then === 'function') {
                                then.call(value, function (val) {
                                        if (!resolved) {
                                                resolved = true;

                                                if (value === val) {
                                                        fulfill(promise, val);
                                                } else {
                                                        resolve(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);
        if (!promise._handled && isNode) {
                global.process.emit('unhandledRejection', promise._data, promise);
        }
}

function notifyRejectionHandled(promise) {
        global.process.emit('rejectionHandled', 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,
        _handled: false,

        then: function (onFulfillment, onRejection) {
                var subscriber = {
                        owner: this,
                        then: new this.constructor(NOOP),
                        fulfilled: onFulfillment,
                        rejected: onRejection
                };

                if ((onRejection || onFulfillment) && !this._handled) {
                        this._handled = true;
                        if (this._state === REJECTED && isNode) {
                                asyncCall(notifyRejectionHandled, this);
                        }
                }

                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;