1 files changed, 42 insertions, 73 deletions

diff --git a/node_modules/montage/core/promise.js b/node_modules/montage/core/promise.js
index 80c63943..aabe113d 100755
--- a/node_modules/montage/core/promise.js
+++ b/node_modules/montage/core/promise.js
@@ -5,7 +5,7 @@
  </copyright> */
 
 // Scope:
-//  * ES5, W3C setImmediate (shimmed if necessary)
+//  * ES5
 //  * speed and economy of memory before safety and securability
 //  * run-time compatibility via thenability
 
@@ -30,13 +30,15 @@
 
 "use strict";
 
+var TIMER;
 try {
     // bootstrapping can't handle relative identifiers
-    require("core/shim/timers"); // setImmediate
+    TIMER = require("core/next-tick");
 } catch (exception) {
     // in this case, node can't handle absolute identifiers
-    require("./shim/timers"); // setImmediate
+    TIMER = require("./next-tick");
 }
+var nextTick = TIMER.nextTick;
 
 // merely ensures that the returned value can respond to
 // messages; does not guarantee a full promise API
@@ -107,17 +109,10 @@ var PrimordialPromise = Creatable.create({
         value: function (descriptor, promiseDescriptor) {
 
             // automatically subcreate each of the contained promise types
-            var creation = Object.create(this, {
-                DeferredPromise: {
-                    value: this.DeferredPromise.create(promiseDescriptor)
-                },
-                FulfilledPromise: {
-                    value: this.FulfilledPromise.create(promiseDescriptor)
-                },
-                RejectedPromise: {
-                    value: this.RejectedPromise.create(promiseDescriptor)
-                }
-            });
+            var creation = Object.create(this);
+            creation.DeferredPromise = this.DeferredPromise.create(promiseDescriptor);
+            creation.FulfilledPromise = this.FulfilledPromise.create(promiseDescriptor);
+            creation.RejectedPromise = this.RejectedPromise.create(promiseDescriptor);
 
             if (descriptor) {
                 Object.defineProperties(creation, descriptor);
@@ -125,17 +120,13 @@ var PrimordialPromise = Creatable.create({
 
             // create static reflections of all new promise methods
             if (promiseDescriptor) {
-                var statics = {};
                 Object.keys(promiseDescriptor).forEach(function (name) {
-                    statics[name] = {
-                        value: function (value) {
-                            var args = Array.prototype.slice.call(arguments, 1);
-                            var promise = this.ref(value);
-                            return promise[name].apply(promise, args);
-                        }
+                    creation[name] = function (value) {
+                        var args = Array.prototype.slice.call(arguments, 1);
+                        var promise = this.ref(value);
+                        return promise[name].apply(promise, args);
                     };
                 });
-                Object.defineProperties(creation, statics);
             }
 
             return creation;
@@ -182,15 +173,10 @@ var PrimordialPromise = Creatable.create({
 
     fulfill: {
         value: function (value) {
-            return this.FulfilledPromise.create({
-                _value: {
-                    value: value,
-                    writable: true
-                },
-                Promise: {
-                    value: this
-                }
-            });
+            var self = Object.create(this.FulfilledPromise);
+            self._value = value;
+            self.Promise = this;
+            return self;
         }
     },
 
@@ -246,17 +232,10 @@ var PrimordialPromise = Creatable.create({
 
     reject: {
         value: function (reason, error) {
-            var self = this.RejectedPromise.create({
-                _reason: {
-                    value: reason
-                },
-                _error: {
-                    value: error
-                },
-                Promise: {
-                    value: this
-                }
-            });
+            var self = Object.create(this.RejectedPromise);
+            self._reason = reason;
+            self._error = error;
+            self.Promise = this;
             errors.push(error && error.stack || self);
             return self;
         }
@@ -310,31 +289,13 @@ var PrimordialPromise = Creatable.create({
     defer: {
         value: function () {
             var deferred;
-            var promise = this.DeferredPromise.create({
-                _pending: {
-                    value: [],
-                    writable: true
-                },
-                _value: {
-                    value: undefined,
-                    writable: true
-                },
-                Promise: {
-                    value: this
-                }
-            });
-            deferred = this.Deferred.create({
-                promise: {
-                    value: promise,
-                    enumerable: true
-                },
-                Promise: {
-                    value: this
-                }
-            });
-            Object.defineProperty(promise, "_deferred", {
-                value: deferred
-            });
+            var promise = Object.create(this.DeferredPromise);
+            promise._pending = [];
+            promise.Promise = this;
+            deferred = Object.create(this.Deferred);
+            deferred.promise = promise;
+            deferred.Promise = this;
+            promise._deferred = deferred;
             return deferred;
         }
     },
@@ -349,7 +310,7 @@ var PrimordialPromise = Creatable.create({
                     }
                     this.promise._value = value = toPromise(value);
                     this.promise._pending.forEach(function (pending) {
-                        setImmediate(function () {
+                        nextTick(function () {
                             value.sendPromise.apply(value, pending);
                         });
                     });
@@ -380,7 +341,7 @@ var PrimordialPromise = Creatable.create({
                     } else {
                         var args = arguments,
                             value = this._value;
-                        setImmediate(function () {
+                        nextTick(function () {
                             value.sendPromise.apply(value, args);
                         });
                     }
@@ -415,6 +376,14 @@ var Promise = PrimordialPromise.create({}, { // Descriptor for each of the three
         }
     },
 
+    spread: {
+        value: function (fulfilled, rejected) {
+            return this.all().then(function (args) {
+                return fulfilled.apply(void 0, args);
+            }, rejected);
+        }
+    },
+
     then: {
         value: function (fulfilled, rejected) {
             var self = this;
@@ -425,7 +394,7 @@ var Promise = PrimordialPromise.create({}, { // Descriptor for each of the three
                 try {
                     deferred.resolve(fulfilled ? fulfilled(value) : value);
                 } catch (error) {
-                    console.log(error.stack);
+                    console.error(error.stack);
                     deferred.reject(error.message, error);
                 }
             }
@@ -445,7 +414,7 @@ var Promise = PrimordialPromise.create({}, { // Descriptor for each of the three
                 }
             }
 
-            setImmediate(function () {
+            nextTick(function () {
                 self.sendPromise(
                     function (value) {
                         if (done) {
@@ -478,7 +447,7 @@ var Promise = PrimordialPromise.create({}, { // Descriptor for each of the three
         value: function (name, args) {
             var deferred = Promise.defer();