API change

Gruntfile.js

@@ -24,6 +24,7 @@ module.exports = function (grunt) {
 					"src/cookie.js",
 					"src/data.js",
 					"src/datalist.js",
+					"src/deferred.js",
 					"src/element.js",
 					"src/filter.js",
 					"src/json.js",
@@ -74,7 +75,7 @@ module.exports = function (grunt) {
 				         " * @version <%= pkg.version %>\n" +
 				         " */\n",
 				mangle: {
-					except: ["abaaso", "DataList", "DataListFilter", "DataStore", "Promise"]
+					except: ["abaaso", "DataList", "DataListFilter", "DataStore", "Deferred", "Promise"]
 				}
 			},
 			dist: {

lib/abaaso.js

@@ -6,7 +6,7 @@
  * @license BSD-3 <https://raw.github.com/avoidwork/abaaso/master/LICENSE>
  * @link http://abaaso.com
  * @module abaaso
- * @version 3.6.25
+ * @version 3.7.0
  */
 ( function ( global ) {
 
@@ -4362,6 +4362,175 @@ function DataList ( element, store, template ) {
 DataList.prototype = datalist.methods;
 DataList.prototype.constructor = DataList;
 
+/**
+ * Deferreds
+ * 
+ * @type {Object}
+ */
+var deferred = {
+	/**
+	 * Deferred factory
+	 * 
+	 * @method factory
+	 * @return {Object} Deferred
+	 */
+	factory : function () {
+		return new Deferred();
+	},
+
+	// Inherited by deferreds
+	methods : {
+		/**
+		 * Registers a function to execute after Promise is reconciled
+		 * 
+		 * @param  {Function} arg Function to execute
+		 * @return {Object}       Deferred
+		 */
+		always : function ( arg ) {
+			if ( typeof arg !== "function" ) {
+				throw Error( label.error.invalidArguments );
+			}
+
+			if ( this.promise.resolved() ) {
+				throw Error( label.error.promiseResolved.replace( "{{outcome}}", this.promise.outcome ) );
+			}
+
+			this.onAlways.push( arg );
+
+			return this;
+		},
+
+		/**
+		 * Registers a function to execute after Promise is resolved
+		 * 
+		 * @param  {Function} arg Function to execute
+		 * @return {Object}       Deferred
+		 */
+		done : function ( arg ) {
+			if ( typeof arg !== "function" ) {
+				throw Error( label.error.invalidArguments );
+			}
+
+			if ( this.promise.resolved() ) {
+				throw Error( label.error.promiseResolved.replace( "{{outcome}}", this.promise.outcome ) );
+			}
+
+			this.onDone.push( arg );
+
+			return this;
+		},
+
+		/**
+		 * Registers a function to execute after Promise is rejected
+		 * 
+		 * @param  {Function} arg Function to execute
+		 * @return {Object}       Deferred
+		 */
+		fail : function ( arg ) {
+			if ( typeof arg !== "function" ) {
+				throw Error( label.error.invalidArguments );
+			}
+
+			if ( this.promise.resolved() ) {
+				throw Error( label.error.promiseResolved.replace( "{{outcome}}", this.promise.outcome ) );
+			}
+
+			this.onFail.push( arg );
+
+			return this;
+		},
+
+		/**
+		 * Determines if Deferred is rejected
+		 * 
+		 * @return {Boolean} `true` if rejected
+		 */
+		isRejected : function () {
+			return ( this.promise.state === promise.state.broken );
+		},
+
+		/**
+		 * Determines if Deferred is resolved
+		 * 
+		 * @return {Boolean} `true` if rejected
+		 */
+		isResolved : function () {
+			return ( this.promise.state === promise.state.resolved );
+		},
+
+		/**
+		 * Rejects the Promise
+		 * 
+		 * @param  {Mixed} arg Rejection outcome
+		 * @return {Object}    Deferred
+		 */
+		reject : function ( arg ) {
+			this.promise.reject.call( this.promise, arg );
+
+			return this;
+		},
+
+		/**
+		 * Resolves the Promise
+		 * 
+		 * @param  {Mixed} arg Resolution outcome
+		 * @return {Object}    Deferred
+		 */
+		resolve : function ( arg ) {
+			this.promise.resolve.call( this.promise, arg );
+
+			return this;
+		}
+	}
+};
+
+
+/**
+ * Deferred factory
+ *
+ * @class Deferred
+ * @namespace abaaso
+ * @return {Object} Instance of Deferred
+ */
+function Deferred () {
+	var self      = this;
+
+	this.promise  = promise.factory();
+	this.onDone   = [];
+	this.onAlways = [];
+	this.onFail   = [];
+
+	utility.when( this.promise ).then( function ( arg ) {
+		array.each( self.onDone, function ( i ) {
+			i( arg );
+		});
+
+		array.each( self.onAlways, function ( i ) {
+			i( arg );
+		});
+
+		self.onAlways = [];
+		self.onDone   = [];
+		self.onFail   = [];
+	}, function ( arg ) {
+		array.each( self.onFail, function ( i ) {
+			i( arg );
+		});
+
+		array.each( self.onAlways, function ( i ) {
+			i( arg );
+		});
+
+		self.onAlways = [];
+		self.onDone   = [];
+		self.onFail   = [];
+	});
+};
+
+// Setting prototype & constructor loop
+Deferred.prototype = deferred.methods;
+Deferred.prototype.constructor = Deferred;
+
 /**
  * Element methods
  *
@@ -6463,9 +6632,13 @@ var promise = {
 						self.outcome      = null;
 						result.parentNode = self;
 						result.then( function ( arg ) {
-							self.resolve( arg );
+							array.each( self.children, function ( i ) {
+								i.resolve( arg );
+							});
 						}, function ( arg ) {
-							self.reject( arg );
+							array.each( self.children, function ( i ) {
+								i.reject( arg );
+							});
 						});
 					}
 
@@ -6483,8 +6656,9 @@ var promise = {
 				return fn(false);
 			});
 
-			// Setting reference to `self`
+			// Setting references
 			deferred.parentNode = self;
+			self.children.push( deferred );
 
 			return deferred;
 		}
@@ -6507,7 +6681,13 @@ var promise = {
 		    i, reason, result;
 
 		if ( this.state !== promise.state.pending ) {
-			throw Error( label.error.promiseResolved.replace( "{{outcome}}", this.outcome ) );
+			// Walking "forward" from a reverse chain or a fork, we've already been here...
+			if ( ( this.parentNode !== null && this.parentNode.state === promise.state.resolved ) || this.children.length > 0 ) {
+				return;
+			}
+			else {
+				throw Error( label.error.promiseResolved.replace( "{{outcome}}", this.outcome ) );
+			}
 		}
 
 		this.state   = state;
@@ -6604,6 +6784,7 @@ var promise = {
  * @return {Object} Instance of Promise
  */
 function Promise () {
+	this.children   = [];
 	this.error      = [];
 	this.fulfill    = [];
 	this.parentNode = null;
@@ -9451,15 +9632,25 @@ var utility = {
 			array.each( promises, function ( p ) {
 				p.then( function ( arg) {
 					if ( ++i === nth && !deferred.resolved()) {
-						deferred.resolve( promises.map( function ( obj ) {
-							return obj.outcome;
-						}));
+						if ( promises.length > 1 ) {
+							deferred.resolve( promises.map( function ( obj ) {
+								return obj.outcome;
+							}));
+						}
+						else {
+							deferred.resolve( promises[0].outcome );
+						}
 					}
 				}, function ( e ) {
 					if ( !deferred.resolved() ) {
-						deferred.reject( promises.map( function ( obj ) {
-							return obj.outcome;
-						}));
+						if ( promises.length > 1 ) {
+							deferred.reject( promises.map( function ( obj ) {
+								return obj.outcome;
+							}));
+						}
+						else {
+							deferred.reject( promises[0].outcome );
+						}
 					}
 				});
 			});
@@ -9581,7 +9772,7 @@ var xhr = function () {
 	    XMLHttpRequest, headers, handler, handlerError, state;
 
 	headers = {
-		"User-Agent"   : "abaaso/3.6.25 node.js/" + process.versions.node.replace( /^v/, "" ) + " (" + string.capitalize( process.platform ) + " V8/" + process.versions.v8 + " )",
+		"User-Agent"   : "abaaso/3.7.0 node.js/" + process.versions.node.replace( /^v/, "" ) + " (" + string.capitalize( process.platform ) + " V8/" + process.versions.v8 + " )",
 		"Content-Type" : "text/plain",
 		"Accept"       : "*/*"
 	};
@@ -10539,11 +10730,12 @@ return {
 	},
 	debounce        : utility.debounce,
 	decode          : json.decode,
-	defer           : utility.defer,
+	defer           : deferred.factory,
 	define          : utility.define,
 	del             : function ( uri, success, failure, headers, timeout ) {
 		return client.request( uri, "DELETE", success, failure, null, headers, timeout );
 	},
+	delay           : utility.defer,
 	destroy         : element.destroy,
 	encode          : json.encode,
 	error           : utility.error,
@@ -10704,7 +10896,7 @@ return {
 	update          : element.update,
 	uuid            : utility.uuid,
 	validate        : validate.test,
-	version         : "3.6.25",
+	version         : "3.7.0",
 	walk            : utility.walk,
 	when            : utility.when
 };

package.json

@@ -1,7 +1,7 @@
 {
   "name": "abaaso",
   "description": "abaaso is a modern, lightweight Enterprise class RESTful JavaScript application framework.",
-  "version": "3.6.25",
+  "version": "3.7.0",
   "homepage": "http://abaaso.com",
   "author": {
     "name": "Jason Mulligan",