xonecas.io
286
Sf

simple-flask-coffee-sass-boilerplate / files

simple-flask-coffee-sass-boilerplate / bower_components / jquery / src / deferred.js

4.3 KB
1define([
2	"./core",
3	"./var/slice",
4	"./callbacks"
5], function( jQuery, slice ) {
6
7jQuery.extend({
8
9	Deferred: function( func ) {
10		var tuples = [
11				// action, add listener, listener list, final state
12				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
13				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
14				[ "notify", "progress", jQuery.Callbacks("memory") ]
15			],
16			state = "pending",
17			promise = {
18				state: function() {
19					return state;
20				},
21				always: function() {
22					deferred.done( arguments ).fail( arguments );
23					return this;
24				},
25				then: function( /* fnDone, fnFail, fnProgress */ ) {
26					var fns = arguments;
27					return jQuery.Deferred(function( newDefer ) {
28						jQuery.each( tuples, function( i, tuple ) {
29							var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
30							// deferred[ done | fail | progress ] for forwarding actions to newDefer
31							deferred[ tuple[1] ](function() {
32								var returned = fn && fn.apply( this, arguments );
33								if ( returned && jQuery.isFunction( returned.promise ) ) {
34									returned.promise()
35										.done( newDefer.resolve )
36										.fail( newDefer.reject )
37										.progress( newDefer.notify );
38								} else {
39									newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
40								}
41							});
42						});
43						fns = null;
44					}).promise();
45				},
46				// Get a promise for this deferred
47				// If obj is provided, the promise aspect is added to the object
48				promise: function( obj ) {
49					return obj != null ? jQuery.extend( obj, promise ) : promise;
50				}
51			},
52			deferred = {};
53
54		// Keep pipe for back-compat
55		promise.pipe = promise.then;
56
57		// Add list-specific methods
58		jQuery.each( tuples, function( i, tuple ) {
59			var list = tuple[ 2 ],
60				stateString = tuple[ 3 ];
61
62			// promise[ done | fail | progress ] = list.add
63			promise[ tuple[1] ] = list.add;
64
65			// Handle state
66			if ( stateString ) {
67				list.add(function() {
68					// state = [ resolved | rejected ]
69					state = stateString;
70
71				// [ reject_list | resolve_list ].disable; progress_list.lock
72				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
73			}
74
75			// deferred[ resolve | reject | notify ]
76			deferred[ tuple[0] ] = function() {
77				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
78				return this;
79			};
80			deferred[ tuple[0] + "With" ] = list.fireWith;
81		});
82
83		// Make the deferred a promise
84		promise.promise( deferred );
85
86		// Call given func if any
87		if ( func ) {
88			func.call( deferred, deferred );
89		}
90
91		// All done!
92		return deferred;
93	},
94
95	// Deferred helper
96	when: function( subordinate /* , ..., subordinateN */ ) {
97		var i = 0,
98			resolveValues = slice.call( arguments ),
99			length = resolveValues.length,
100
101			// the count of uncompleted subordinates
102			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
103
104			// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
105			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
106
107			// Update function for both resolve and progress values
108			updateFunc = function( i, contexts, values ) {
109				return function( value ) {
110					contexts[ i ] = this;
111					values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
112					if ( values === progressValues ) {
113						deferred.notifyWith( contexts, values );
114					} else if ( !( --remaining ) ) {
115						deferred.resolveWith( contexts, values );
116					}
117				};
118			},
119
120			progressValues, progressContexts, resolveContexts;
121
122		// add listeners to Deferred subordinates; treat others as resolved
123		if ( length > 1 ) {
124			progressValues = new Array( length );
125			progressContexts = new Array( length );
126			resolveContexts = new Array( length );
127			for ( ; i < length; i++ ) {
128				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
129					resolveValues[ i ].promise()
130						.done( updateFunc( i, resolveContexts, resolveValues ) )
131						.fail( deferred.reject )
132						.progress( updateFunc( i, progressContexts, progressValues ) );
133				} else {
134					--remaining;
135				}
136			}
137		}
138
139		// if we're not waiting on anything, resolve the master
140		if ( !remaining ) {
141			deferred.resolveWith( resolveContexts, resolveValues );
142		}
143
144		return deferred.promise();
145	}
146});
147
148return jQuery;
149});