define( [
|
"./core",
|
"./var/slice",
|
"./callbacks"
|
], function( jQuery, slice ) {
|
|
jQuery.extend( {
|
|
Deferred: function( func ) {
|
var tuples = [
|
|
// action, add listener, listener list, final state
|
[ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ],
|
[ "reject", "fail", jQuery.Callbacks( "once memory" ), "rejected" ],
|
[ "notify", "progress", jQuery.Callbacks( "memory" ) ]
|
],
|
state = "pending",
|
promise = {
|
state: function() {
|
return state;
|
},
|
always: function() {
|
deferred.done( arguments ).fail( arguments );
|
return this;
|
},
|
then: function( /* fnDone, fnFail, fnProgress */ ) {
|
var fns = arguments;
|
return jQuery.Deferred( function( newDefer ) {
|
jQuery.each( tuples, function( i, tuple ) {
|
var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
|
|
// deferred[ done | fail | progress ] for forwarding actions to newDefer
|
deferred[ tuple[ 1 ] ]( function() {
|
var returned = fn && fn.apply( this, arguments );
|
if ( returned && jQuery.isFunction( returned.promise ) ) {
|
returned.promise()
|
.progress( newDefer.notify )
|
.done( newDefer.resolve )
|
.fail( newDefer.reject );
|
} else {
|
newDefer[ tuple[ 0 ] + "With" ](
|
this === promise ? newDefer.promise() : this,
|
fn ? [ returned ] : arguments
|
);
|
}
|
} );
|
} );
|
fns = null;
|
} ).promise();
|
},
|
|
// Get a promise for this deferred
|
// If obj is provided, the promise aspect is added to the object
|
promise: function( obj ) {
|
return obj != null ? jQuery.extend( obj, promise ) : promise;
|
}
|
},
|
deferred = {};
|
|
// Keep pipe for back-compat
|
promise.pipe = promise.then;
|
|
// Add list-specific methods
|
jQuery.each( tuples, function( i, tuple ) {
|
var list = tuple[ 2 ],
|
stateString = tuple[ 3 ];
|
|
// promise[ done | fail | progress ] = list.add
|
promise[ tuple[ 1 ] ] = list.add;
|
|
// Handle state
|
if ( stateString ) {
|
list.add( function() {
|
|
// state = [ resolved | rejected ]
|
state = stateString;
|
|
// [ reject_list | resolve_list ].disable; progress_list.lock
|
}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
|
}
|
|
// deferred[ resolve | reject | notify ]
|
deferred[ tuple[ 0 ] ] = function() {
|
deferred[ tuple[ 0 ] + "With" ]( this === deferred ? promise : this, arguments );
|
return this;
|
};
|
deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
|
} );
|
|
// Make the deferred a promise
|
promise.promise( deferred );
|
|
// Call given func if any
|
if ( func ) {
|
func.call( deferred, deferred );
|
}
|
|
// All done!
|
return deferred;
|
},
|
|
// Deferred helper
|
when: function( subordinate /* , ..., subordinateN */ ) {
|
var i = 0,
|
resolveValues = slice.call( arguments ),
|
length = resolveValues.length,
|
|
// the count of uncompleted subordinates
|
remaining = length !== 1 ||
|
( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
|
|
// the master Deferred.
|
// If resolveValues consist of only a single Deferred, just use that.
|
deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
|
|
// Update function for both resolve and progress values
|
updateFunc = function( i, contexts, values ) {
|
return function( value ) {
|
contexts[ i ] = this;
|
values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
|
if ( values === progressValues ) {
|
deferred.notifyWith( contexts, values );
|
} else if ( !( --remaining ) ) {
|
deferred.resolveWith( contexts, values );
|
}
|
};
|
},
|
|
progressValues, progressContexts, resolveContexts;
|
|
// Add listeners to Deferred subordinates; treat others as resolved
|
if ( length > 1 ) {
|
progressValues = new Array( length );
|
progressContexts = new Array( length );
|
resolveContexts = new Array( length );
|
for ( ; i < length; i++ ) {
|
if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
|
resolveValues[ i ].promise()
|
.progress( updateFunc( i, progressContexts, progressValues ) )
|
.done( updateFunc( i, resolveContexts, resolveValues ) )
|
.fail( deferred.reject );
|
} else {
|
--remaining;
|
}
|
}
|
}
|
|
// If we're not waiting on anything, resolve the master
|
if ( !remaining ) {
|
deferred.resolveWith( resolveContexts, resolveValues );
|
}
|
|
return deferred.promise();
|
}
|
} );
|
|
return jQuery;
|
} );
|
