re-write core.js

Author: Forbes Lindesay

lib/core.js

@@ -1,105 +1,111 @@
 'use strict';
 
-var asap = require('asap')
+var asap = require('asap/raw')
 
-// Use Symbol if it's available, but otherwise just
-// generate a random string as this is probably going
-// to be unique
-var handleSymbol = typeof Symbol === 'function' ?
-    Symbol() :
-    (
-      '_promise_internal_key_handle_' +
-      Math.random().toString(35).substr(2, 10) + '_'
-    )
+function noop() {};
 
 module.exports = Promise;
 function Promise(fn) {
   if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new')
   if (typeof fn !== 'function') throw new TypeError('not a function')
-  var state = null
-  var value = null
-  var deferreds = []
-  var self = this
-
-  this.then = function(onFulfilled, onRejected) {
-    return new self.constructor(function(resolve, reject) {
-      handle(new Handler(onFulfilled, onRejected, resolve, reject))
-    })
+  this._state = 0;
+  this._value = null;
+  this._deferreds = [];
+  if (fn === noop) return;
+  doResolve(fn, this);
+}
+Promise.prototype._safeThen = function (onFulfilled, onRejected) {
+  var self = this;
+  return new this.constructor(function (resolve, reject) {
+    var res = new Promise(noop);
+    res.then(resolve, reject);
+    self._handle(new Handler(onFulfilled, onRejected, res));
+  });
+};
+Promise.prototype.then = function(onFulfilled, onRejected) {
+  if (this.constructor !== Promise) return this._safeThen(onFulfilled, onRejected);
+  var res = new Promise(noop);
+  this._handle(new Handler(onFulfilled, onRejected, res));
+  return res;
+};
+Promise.prototype._handle = function(deferred) {
+  if (this._state === 3) {
+    this._value._handle(deferred);
+    return;
   }
-  this.then[handleSymbol] = handle;
-  function handle(deferred) {
-    return internalHandle(deferred);
+  if (this._state === 0) {
+    this._deferreds.push(deferred);
+    return;
   }
-  function internalHandle(deferred) {
-    if (state === null) {
-      deferreds.push(deferred)
+  var state = this._state;
+  var value = this._value;
+  asap(function() {
+    var cb = state === 1 ? deferred.onFulfilled : deferred.onRejected
+    if (cb === null) {
+      (state === 1 ? deferred.resolve(value) : deferred.reject(value))
       return
     }
-    asap(function() {
-      var cb = state ? deferred.onFulfilled : deferred.onRejected
-      if (cb === null) {
-        (state ? deferred.resolve : deferred.reject)(value)
-        return
-      }
-      var ret
-      try {
-        ret = cb(value)
+    var ret
+    try {
+      ret = cb(value)
+    }
+    catch (e) {
+      deferred.reject(e)
+      return
+    }
+    deferred.resolve(ret)
+  });
+};
+Promise.prototype._resolve = function(newValue) {
+  try { //Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
+    if (newValue === this) throw new TypeError('A promise cannot be resolved with itself.')
+    if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+      if (
+        newValue instanceof Promise &&
+        newValue._handle === this._handle &&
+        newValue.then === this.then
+      ) {
+        this._state = 3;
+        this._value = newValue;
+        for (var i = 0; i < this._deferreds.length; i++) {
+          newValue._handle(this._deferreds[i]);
+        }
+        return;
       }
-      catch (e) {
-        deferred.reject(e)
+      var then = newValue.then
+      if (typeof then === 'function') {
+        doResolve(then.bind(newValue), this)
         return
       }
-      deferred.resolve(ret)
-    })
-  }
-
-  function resolve(newValue) {
-    try { //Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
-      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.')
-      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
-        var then = newValue.then
-        if (typeof then === 'function') {
-          if (typeof then[handleSymbol] === 'function') {
-            // to prevent a memory leak, we adopt the value of the other promise
-            // allowing this promise to be garbage collected as soon as nobody
-            // has a reference to it
-            internalHandle = then[handleSymbol];
-            deferreds.forEach(function (deferred) {
-              internalHandle(deferred);
-            });
-          } else {
-            doResolve(then.bind(newValue), resolve, reject)
-          }
-          return
-        }
-      }
-      state = true
-      value = newValue
-      finale()
-    } catch (e) { reject(e) }
-  }
-
-  function reject(newValue) {
-    state = false
-    value = newValue
-    finale()
-  }
-
-  function finale() {
-    for (var i = 0, len = deferreds.length; i < len; i++)
-      handle(deferreds[i])
-    deferreds = null
-  }
+    }
+    this._state = 1
+    this._value = newValue
+    this._finale()
+  } catch (e) { this._reject(e) }
+}
 
-  doResolve(fn, resolve, reject)
+Promise.prototype._reject = function (newValue) {
+  this._state = 2
+  this._value = newValue
+  this._finale()
+}
+Promise.prototype._finale = function () {
+  for (var i = 0; i < this._deferreds.length; i++)
+    this._handle(this._deferreds[i])
+  this._deferreds = null
 }
 
 
-function Handler(onFulfilled, onRejected, resolve, reject){
+function Handler(onFulfilled, onRejected, promise){
   this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null
   this.onRejected = typeof onRejected === 'function' ? onRejected : null
-  this.resolve = resolve
-  this.reject = reject
+  this.promise = promise;
+}
+Handler.prototype.resolve = function (value) {
+  this.promise._resolve(value);
+};
+Handler.prototype.reject = function (value) {
+  this.promise._reject(value);
 }
 
 /**
@@ -108,21 +114,21 @@ function Handler(onFulfilled, onRejected, resolve, reject){
  *
  * Makes no guarantees about asynchrony.
  */
-function doResolve(fn, onFulfilled, onRejected) {
+function doResolve(fn, promise) {
   var done = false;
   try {
     fn(function (value) {
       if (done) return
       done = true
-      onFulfilled(value)
+      promise._resolve(value)
     }, function (reason) {
       if (done) return
       done = true
-      onRejected(reason)
+      promise._reject(reason)
     })
   } catch (ex) {
     if (done) return
     done = true
-    onRejected(ex)
+    promise._reject(ex)
   }
-}
+}