update to Promises/A+ polyfill

Author: steffans

src/lib/promise.js

@@ -1,56 +1,212 @@
 /**
- * Promise polyfill. (https://gist.github.com/briancavalier/814313)
+ * Promises/A+ polyfill v1.1.0 (https://github.com/bramstein/promis)
  */
 
-function Promise (executor) {
-    executor(this.resolve.bind(this), this.reject.bind(this));
-    this._thens = [];
+function Promise(executor) {
+
+    this.state = Promise.State.PENDING;
+    this.value = undefined;
+    this.deferred = [];
+
+    var promise = this;
+
+    try {
+        executor(function (x) {
+            promise.resolve(x);
+        }, function (r) {
+            promise.reject(r);
+        });
+    } catch (e) {
+        promise.reject(e);
+    }
 }
 
-Promise.prototype = {
+Promise.State = {
+    RESOLVED: 0,
+    REJECTED: 1,
+    PENDING: 2
+};
 
-    then: function (onResolve, onReject, onProgress) {
-        this._thens.push({resolve: onResolve, reject: onReject, progress: onProgress});
-    },
+Promise.reject = function (r) {
+    return new Promise(function (resolve, reject) {
+        reject(r);
+    });
+};
+
+Promise.resolve = function (x) {
+    return new Promise(function (resolve, reject) {
+        resolve(x);
+    });
+};
 
-    'catch': function (onReject) {
-        this._thens.push({reject: onReject});
-    },
+Promise.all = function all(iterable) {
+    return new Promise(function (resolve, reject) {
+        var count = 0,
+            result = [];
 
-    resolve: function (value) {
-        this._complete('resolve', value);
-    },
+        if (iterable.length === 0) {
+            resolve(result);
+        }
 
-    reject: function (reason) {
-        this._complete('reject', reason);
-    },
+        function resolver(i) {
+            return function (x) {
+                result[i] = x;
+                count += 1;
 
-    progress: function (status) {
+                if (count === iterable.length) {
+                    resolve(result);
+                }
+            };
+        }
 
-        var i = 0, aThen;
+        for (var i = 0; i < iterable.length; i += 1) {
+            iterable[i].then(resolver(i), reject);
+        }
+    });
+};
 
-        while (aThen = this._thens[i++]) {
-            aThen.progress && aThen.progress(status);
+Promise.race = function race(iterable) {
+    return new Promise(function (resolve, reject) {
+        for (var i = 0; i < iterable.length; i += 1) {
+            iterable[i].then(resolve, reject);
         }
-    },
+    });
+};
 
-    _complete: function (which, arg) {
+var p = Promise.prototype;
 
-        this.then = which === 'resolve' ?
-            function (resolve, reject) { resolve && resolve(arg); } :
-            function (resolve, reject) { reject && reject(arg); };
+p.resolve = function resolve(x) {
+    var promise = this;
 
-        this.resolve = this.reject = this.progress =
-            function () { throw new Error('Promise already completed.'); };
+    if (promise.state === Promise.State.PENDING) {
+        if (x === promise) {
+            throw new TypeError('Promise settled with itself.');
+        }
+
+        var called = false;
+
+        try {
+            var then = x && x['then'];
+
+            if (x !== null && typeof x === 'object' && typeof then === 'function') {
+                then.call(x, function (x) {
+                    if (!called) {
+                        promise.resolve(x);
+                    }
+                    called = true;
+
+                }, function (r) {
+                    if (!called) {
+                        promise.reject(r);
+                    }
+                    called = true;
+                });
+                return;
+            }
+        } catch (e) {
+            if (!called) {
+                promise.reject(e);
+            }
+            return;
+        }
+        promise.state = Promise.State.RESOLVED;
+        promise.value = x;
+        promise.notify();
+    }
+};
 
-        var aThen, i = 0;
+p.reject = function reject(reason) {
+    var promise = this;
 
-        while (aThen = this._thens[i++]) {
-            aThen[which] && aThen[which](arg);
+    if (promise.state === Promise.State.PENDING) {
+        if (reason === promise) {
+            throw new TypeError('Promise settled with itself.');
         }
 
-        delete this._thens;
+        promise.state = Promise.State.REJECTED;
+        promise.value = reason;
+        promise.notify();
     }
 };
 
-module.exports = window.Promise ? window.Promise : Promise;
+p.notify = function notify() {
+    var promise = this;
+
+    async(function () {
+        if (promise.state !== Promise.State.PENDING) {
+            while (promise.deferred.length) {
+                var deferred = promise.deferred.shift(),
+                    onResolved = deferred[0],
+                    onRejected = deferred[1],
+                    resolve = deferred[2],
+                    reject = deferred[3];
+
+                try {
+                    if (promise.state === Promise.State.RESOLVED) {
+                        if (typeof onResolved === 'function') {
+                            resolve(onResolved.call(undefined, promise.value));
+                        } else {
+                            resolve(promise.value);
+                        }
+                    } else if (promise.state === Promise.State.REJECTED) {
+                        if (typeof onRejected === 'function') {
+                            resolve(onRejected.call(undefined, promise.value));
+                        } else {
+                            reject(promise.value);
+                        }
+                    }
+                } catch (e) {
+                    reject(e);
+                }
+            }
+        }
+    });
+};
+
+p.catch = function (onRejected) {
+    return this.then(undefined, onRejected);
+};
+
+p.then = function then(onResolved, onRejected) {
+    var promise = this;
+
+    return new Promise(function (resolve, reject) {
+        promise.deferred.push([onResolved, onRejected, resolve, reject]);
+        promise.notify();
+    });
+};
+
+var queue = [];
+var async = function (callback) {
+    queue.push(callback);
+
+    if (queue.length === 1) {
+        async.async();
+    }
+};
+
+async.run = function () {
+    while (queue.length) {
+        queue[0]();
+        queue.shift();
+    }
+};
+
+if (window.MutationObserver) {
+    var el = document.createElement('div');
+    var mo = new MutationObserver(async.run);
+
+    mo.observe(el, {
+        attributes: true
+    });
+
+    async.async = function () {
+        el.setAttribute("x", 0);
+    };
+} else {
+    async.async = function () {
+        setTimeout(async.run);
+    };
+}
+
+module.exports = window.Promise || Promise;