UNPKG

jquery/src/deferred.js

Version:

11 kBJavaScriptView Raw

1define( [
"./core",
"./var/isFunction",
"./var/slice",
"./callbacks"
6], function( jQuery, isFunction, slice ) {
7
8"use strict";
9
10function Identity( v ) {
return v;
12}
13function Thrower( ex ) {
throw ex;
15}
16
17function adoptValue( value, resolve, reject, noValue ) {
var method;
19
try {
21
// Check for promise aspect first to privilege synchronous behavior
if ( value && isFunction( ( method = value.promise ) ) ) {
	method.call( value ).done( resolve ).fail( reject );
25
// Other thenables
} else if ( value && isFunction( ( method = value.then ) ) ) {
	method.call( value, resolve, reject );
29
// Other non-thenables
} else {
32
	// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
	// * false: [ value ].slice( 0 ) => resolve( value )
	// * true: [ value ].slice( 1 ) => resolve()
	resolve.apply( undefined, [ value ].slice( noValue ) );
}
38
// For Promises/A+, convert exceptions into rejections
// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
// Deferred#then to conditionally suppress rejection.
} catch ( value ) {
43
// Support: Android 4.0 only
// Strict mode functions invoked without .call/.apply get global-object context
reject.apply( undefined, [ value ] );
}
48}
49
50jQuery.extend( {
51
Deferred: function( func ) {
var tuples = [
54
		// action, add listener, callbacks,
		// ... .then handlers, argument index, [final state]
		[ "notify", "progress", jQuery.Callbacks( "memory" ),
			jQuery.Callbacks( "memory" ), 2 ],
		[ "resolve", "done", jQuery.Callbacks( "once memory" ),
			jQuery.Callbacks( "once memory" ), 0, "resolved" ],
		[ "reject", "fail", jQuery.Callbacks( "once memory" ),
			jQuery.Callbacks( "once memory" ), 1, "rejected" ]
	],
	state = "pending",
	promise = {
		state: function() {
			return state;
		},
		always: function() {
			deferred.done( arguments ).fail( arguments );
			return this;
		},
		"catch": function( fn ) {
			return promise.then( null, fn );
		},
76
		// Keep pipe for back-compat
		pipe: function( /* fnDone, fnFail, fnProgress */ ) {
			var fns = arguments;
80
			return jQuery.Deferred( function( newDefer ) {
				jQuery.each( tuples, function( _i, tuple ) {
83
					// Map tuples (progress, done, fail) to arguments (done, fail, progress)
					var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
86
					// deferred.progress(function() { bind to newDefer or newDefer.notify })
					// deferred.done(function() { bind to newDefer or newDefer.resolve })
					// deferred.fail(function() { bind to newDefer or newDefer.reject })
					deferred[ tuple[ 1 ] ]( function() {
						var returned = fn && fn.apply( this, arguments );
						if ( returned && isFunction( returned.promise ) ) {
							returned.promise()
								.progress( newDefer.notify )
								.done( newDefer.resolve )
								.fail( newDefer.reject );
						} else {
							newDefer[ tuple[ 0 ] + "With" ](
								this,
								fn ? [ returned ] : arguments
							);
						}
					} );
				} );
				fns = null;
			} ).promise();
		},
		then: function( onFulfilled, onRejected, onProgress ) {
			var maxDepth = 0;
			function resolve( depth, deferred, handler, special ) {
				return function() {
					var that = this,
						args = arguments,
						mightThrow = function() {
							var returned, then;
116
							// Support: Promises/A+ section 2.3.3.3.3
							// https://promisesaplus.com/#point-59
							// Ignore double-resolution attempts
							if ( depth < maxDepth ) {
								return;
							}
123
							returned = handler.apply( that, args );
125
							// Support: Promises/A+ section 2.3.1
							// https://promisesaplus.com/#point-48
							if ( returned === deferred.promise() ) {
								throw new TypeError( "Thenable self-resolution" );
							}
131
							// Support: Promises/A+ sections 2.3.3.1, 3.5
							// https://promisesaplus.com/#point-54
							// https://promisesaplus.com/#point-75
							// Retrieve `then` only once
							then = returned &&
137
								// Support: Promises/A+ section 2.3.4
								// https://promisesaplus.com/#point-64
								// Only check objects and functions for thenability
								( typeof returned === "object" ||
									typeof returned === "function" ) &&
								returned.then;
144
							// Handle a returned thenable
							if ( isFunction( then ) ) {
147
								// Special processors (notify) just wait for resolution
								if ( special ) {
									then.call(
										returned,
										resolve( maxDepth, deferred, Identity, special ),
										resolve( maxDepth, deferred, Thrower, special )
									);
155
								// Normal processors (resolve) also hook into progress
								} else {
158
									// ...and disregard older resolution values
									maxDepth++;
161
									then.call(
										returned,
										resolve( maxDepth, deferred, Identity, special ),
										resolve( maxDepth, deferred, Thrower, special ),
										resolve( maxDepth, deferred, Identity,
											deferred.notifyWith )
									);
								}
170
							// Handle all other returned values
							} else {
173
								// Only substitute handlers pass on context
								// and multiple values (non-spec behavior)
								if ( handler !== Identity ) {
									that = undefined;
									args = [ returned ];
								}
180
								// Process the value(s)
								// Default process is resolve
								( special || deferred.resolveWith )( that, args );
							}
						},
186
						// Only normal processors (resolve) catch and reject exceptions
						process = special ?
							mightThrow :
							function() {
								try {
									mightThrow();
								} catch ( e ) {
194
									if ( jQuery.Deferred.exceptionHook ) {
										jQuery.Deferred.exceptionHook( e,
											process.stackTrace );
									}
199
									// Support: Promises/A+ section 2.3.3.3.4.1
									// https://promisesaplus.com/#point-61
									// Ignore post-resolution exceptions
									if ( depth + 1 >= maxDepth ) {
204
										// Only substitute handlers pass on context
										// and multiple values (non-spec behavior)
										if ( handler !== Thrower ) {
											that = undefined;
											args = [ e ];
										}
211
										deferred.rejectWith( that, args );
									}
								}
							};
216
					// Support: Promises/A+ section 2.3.3.3.1
					// https://promisesaplus.com/#point-57
					// Re-resolve promises immediately to dodge false rejection from
					// subsequent errors
					if ( depth ) {
						process();
					} else {
224
						// Call an optional hook to record the stack, in case of exception
						// since it's otherwise lost when execution goes async
						if ( jQuery.Deferred.getStackHook ) {
							process.stackTrace = jQuery.Deferred.getStackHook();
						}
						window.setTimeout( process );
					}
				};
			}
234
			return jQuery.Deferred( function( newDefer ) {
236
				// progress_handlers.add( ... )
				tuples[ 0 ][ 3 ].add(
					resolve(
						0,
						newDefer,
						isFunction( onProgress ) ?
							onProgress :
							Identity,
						newDefer.notifyWith
					)
				);
248
				// fulfilled_handlers.add( ... )
				tuples[ 1 ][ 3 ].add(
					resolve(
						0,
						newDefer,
						isFunction( onFulfilled ) ?
							onFulfilled :
							Identity
					)
				);
259
				// rejected_handlers.add( ... )
				tuples[ 2 ][ 3 ].add(
					resolve(
						0,
						newDefer,
						isFunction( onRejected ) ?
							onRejected :
							Thrower
					)
				);
			} ).promise();
		},
272
		// 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 = {};
280
// Add list-specific methods
jQuery.each( tuples, function( i, tuple ) {
	var list = tuple[ 2 ],
		stateString = tuple[ 5 ];
285
	// promise.progress = list.add
	// promise.done = list.add
	// promise.fail = list.add
	promise[ tuple[ 1 ] ] = list.add;
290
	// Handle state
	if ( stateString ) {
		list.add(
			function() {
295
				// state = "resolved" (i.e., fulfilled)
				// state = "rejected"
				state = stateString;
			},
300
			// rejected_callbacks.disable
			// fulfilled_callbacks.disable
			tuples[ 3 - i ][ 2 ].disable,
304
			// rejected_handlers.disable
			// fulfilled_handlers.disable
			tuples[ 3 - i ][ 3 ].disable,
308
			// progress_callbacks.lock
			tuples[ 0 ][ 2 ].lock,
311
			// progress_handlers.lock
			tuples[ 0 ][ 3 ].lock
		);
	}
316
	// progress_handlers.fire
	// fulfilled_handlers.fire
	// rejected_handlers.fire
	list.add( tuple[ 3 ].fire );
321
	// deferred.notify = function() { deferred.notifyWith(...) }
	// deferred.resolve = function() { deferred.resolveWith(...) }
	// deferred.reject = function() { deferred.rejectWith(...) }
	deferred[ tuple[ 0 ] ] = function() {
		deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
		return this;
	};
329
	// deferred.notifyWith = list.fireWith
	// deferred.resolveWith = list.fireWith
	// deferred.rejectWith = list.fireWith
	deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
} );
335
// Make the deferred a promise
promise.promise( deferred );
338
// Call given func if any
if ( func ) {
	func.call( deferred, deferred );
}
343
// All done!
return deferred;
},
347
// Deferred helper
when: function( singleValue ) {
var
351
	// count of uncompleted subordinates
	remaining = arguments.length,
354
	// count of unprocessed arguments
	i = remaining,
357
	// subordinate fulfillment data
	resolveContexts = Array( i ),
	resolveValues = slice.call( arguments ),
361
	// the primary Deferred
	primary = jQuery.Deferred(),
364
	// subordinate callback factory
	updateFunc = function( i ) {
		return function( value ) {
			resolveContexts[ i ] = this;
			resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
			if ( !( --remaining ) ) {
				primary.resolveWith( resolveContexts, resolveValues );
			}
		};
	};
375
// Single- and empty arguments are adopted like Promise.resolve
if ( remaining <= 1 ) {
	adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,
		!remaining );
380
	// Use .then() to unwrap secondary thenables (cf. gh-3000)
	if ( primary.state() === "pending" ||
		isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
384
		return primary.then();
	}
}
388
// Multiple arguments are aggregated like Promise.all array elements
while ( i-- ) {
	adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );
}
393
return primary.promise();
}
396} );
397
398return jQuery;
399} );

1	`define( [`
2	`"./core",`
3	`"./var/isFunction",`
4	`"./var/slice",`
5	`"./callbacks"`
6	`], function( jQuery, isFunction, slice ) {`
7
8	`"use strict";`
9
10	`function Identity( v ) {`
11	`return v;`
12	`}`
13	`function Thrower( ex ) {`
14	`throw ex;`
15	`}`
16
17	`function adoptValue( value, resolve, reject, noValue ) {`
18	`var method;`
19
20	`try {`
21
22	`// Check for promise aspect first to privilege synchronous behavior`
23	`if ( value && isFunction( ( method = value.promise ) ) ) {`
24	`method.call( value ).done( resolve ).fail( reject );`
25
26	`// Other thenables`
27	`} else if ( value && isFunction( ( method = value.then ) ) ) {`
28	`method.call( value, resolve, reject );`
29
30	`// Other non-thenables`
31	`} else {`
32
33	// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
34	`// * false: [ value ].slice( 0 ) => resolve( value )`
35	`// * true: [ value ].slice( 1 ) => resolve()`
36	`resolve.apply( undefined, [ value ].slice( noValue ) );`
37	`}`
38
39	`// For Promises/A+, convert exceptions into rejections`
40	`// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in`
41	`// Deferred#then to conditionally suppress rejection.`
42	`} catch ( value ) {`
43
44	`// Support: Android 4.0 only`
45	`// Strict mode functions invoked without .call/.apply get global-object context`
46	`reject.apply( undefined, [ value ] );`
47	`}`
48	`}`
49
50	`jQuery.extend( {`
51
52	`Deferred: function( func ) {`
53	`var tuples = [`
54
55	`// action, add listener, callbacks,`
56	`// ... .then handlers, argument index, [final state]`
57	`[ "notify", "progress", jQuery.Callbacks( "memory" ),`
58	`jQuery.Callbacks( "memory" ), 2 ],`
59	`[ "resolve", "done", jQuery.Callbacks( "once memory" ),`
60	`jQuery.Callbacks( "once memory" ), 0, "resolved" ],`
61	`[ "reject", "fail", jQuery.Callbacks( "once memory" ),`
62	`jQuery.Callbacks( "once memory" ), 1, "rejected" ]`
63	`],`
64	`state = "pending",`
65	`promise = {`
66	`state: function() {`
67	`return state;`
68	`},`
69	`always: function() {`
70	`deferred.done( arguments ).fail( arguments );`
71	`return this;`
72	`},`
73	`"catch": function( fn ) {`
74	`return promise.then( null, fn );`
75	`},`
76
77	`// Keep pipe for back-compat`
78	`pipe: function( /* fnDone, fnFail, fnProgress */ ) {`
79	`var fns = arguments;`
80
81	`return jQuery.Deferred( function( newDefer ) {`
82	`jQuery.each( tuples, function( _i, tuple ) {`
83
84	`// Map tuples (progress, done, fail) to arguments (done, fail, progress)`
85	`var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];`
86
87	`// deferred.progress(function() { bind to newDefer or newDefer.notify })`
88	`// deferred.done(function() { bind to newDefer or newDefer.resolve })`
89	`// deferred.fail(function() { bind to newDefer or newDefer.reject })`
90	`deferred[ tuple[ 1 ] ]( function() {`
91	`var returned = fn && fn.apply( this, arguments );`
92	`if ( returned && isFunction( returned.promise ) ) {`
93	`returned.promise()`
94	`.progress( newDefer.notify )`
95	`.done( newDefer.resolve )`
96	`.fail( newDefer.reject );`
97	`} else {`
98	`newDefer[ tuple[ 0 ] + "With" ](`
99	`this,`
100	`fn ? [ returned ] : arguments`
101	`);`
102	`}`
103	`} );`
104	`} );`
105	`fns = null;`
106	`} ).promise();`
107	`},`
108	`then: function( onFulfilled, onRejected, onProgress ) {`
109	`var maxDepth = 0;`
110	`function resolve( depth, deferred, handler, special ) {`
111	`return function() {`
112	`var that = this,`
113	`args = arguments,`
114	`mightThrow = function() {`
115	`var returned, then;`
116
117	`// Support: Promises/A+ section 2.3.3.3.3`
118	`// https://promisesaplus.com/#point-59`
119	`// Ignore double-resolution attempts`
120	`if ( depth < maxDepth ) {`
121	`return;`
122	`}`
123
124	`returned = handler.apply( that, args );`
125
126	`// Support: Promises/A+ section 2.3.1`
127	`// https://promisesaplus.com/#point-48`
128	`if ( returned === deferred.promise() ) {`
129	`throw new TypeError( "Thenable self-resolution" );`
130	`}`
131
132	`// Support: Promises/A+ sections 2.3.3.1, 3.5`
133	`// https://promisesaplus.com/#point-54`
134	`// https://promisesaplus.com/#point-75`
135	// Retrieve `then` only once
136	`then = returned &&`
137
138	`// Support: Promises/A+ section 2.3.4`
139	`// https://promisesaplus.com/#point-64`
140	`// Only check objects and functions for thenability`
141	`( typeof returned === "object" \|\|`
142	`typeof returned === "function" ) &&`
143	`returned.then;`
144
145	`// Handle a returned thenable`
146	`if ( isFunction( then ) ) {`
147
148	`// Special processors (notify) just wait for resolution`
149	`if ( special ) {`
150	`then.call(`
151	`returned,`
152	`resolve( maxDepth, deferred, Identity, special ),`
153	`resolve( maxDepth, deferred, Thrower, special )`
154	`);`
155
156	`// Normal processors (resolve) also hook into progress`
157	`} else {`
158
159	`// ...and disregard older resolution values`
160	`maxDepth++;`
161
162	`then.call(`
163	`returned,`
164	`resolve( maxDepth, deferred, Identity, special ),`
165	`resolve( maxDepth, deferred, Thrower, special ),`
166	`resolve( maxDepth, deferred, Identity,`
167	`deferred.notifyWith )`
168	`);`
169	`}`
170
171	`// Handle all other returned values`
172	`} else {`
173
174	`// Only substitute handlers pass on context`
175	`// and multiple values (non-spec behavior)`
176	`if ( handler !== Identity ) {`
177	`that = undefined;`
178	`args = [ returned ];`
179	`}`
180
181	`// Process the value(s)`
182	`// Default process is resolve`
183	`( special \|\| deferred.resolveWith )( that, args );`
184	`}`
185	`},`
186
187	`// Only normal processors (resolve) catch and reject exceptions`
188	`process = special ?`
189	`mightThrow :`
190	`function() {`
191	`try {`
192	`mightThrow();`
193	`} catch ( e ) {`
194
195	`if ( jQuery.Deferred.exceptionHook ) {`
196	`jQuery.Deferred.exceptionHook( e,`
197	`process.stackTrace );`
198	`}`
199
200	`// Support: Promises/A+ section 2.3.3.3.4.1`
201	`// https://promisesaplus.com/#point-61`
202	`// Ignore post-resolution exceptions`
203	`if ( depth + 1 >= maxDepth ) {`
204
205	`// Only substitute handlers pass on context`
206	`// and multiple values (non-spec behavior)`
207	`if ( handler !== Thrower ) {`
208	`that = undefined;`
209	`args = [ e ];`
210	`}`
211
212	`deferred.rejectWith( that, args );`
213	`}`
214	`}`
215	`};`
216
217	`// Support: Promises/A+ section 2.3.3.3.1`
218	`// https://promisesaplus.com/#point-57`
219	`// Re-resolve promises immediately to dodge false rejection from`
220	`// subsequent errors`
221	`if ( depth ) {`
222	`process();`
223	`} else {`
224
225	`// Call an optional hook to record the stack, in case of exception`
226	`// since it's otherwise lost when execution goes async`
227	`if ( jQuery.Deferred.getStackHook ) {`
228	`process.stackTrace = jQuery.Deferred.getStackHook();`
229	`}`
230	`window.setTimeout( process );`
231	`}`
232	`};`
233	`}`
234
235	`return jQuery.Deferred( function( newDefer ) {`
236
237	`// progress_handlers.add( ... )`
238	`tuples[ 0 ][ 3 ].add(`
239	`resolve(`
240	`0,`
241	`newDefer,`
242	`isFunction( onProgress ) ?`
243	`onProgress :`
244	`Identity,`
245	`newDefer.notifyWith`
246	`)`
247	`);`
248
249	`// fulfilled_handlers.add( ... )`
250	`tuples[ 1 ][ 3 ].add(`
251	`resolve(`
252	`0,`
253	`newDefer,`
254	`isFunction( onFulfilled ) ?`
255	`onFulfilled :`
256	`Identity`
257	`)`
258	`);`
259
260	`// rejected_handlers.add( ... )`
261	`tuples[ 2 ][ 3 ].add(`
262	`resolve(`
263	`0,`
264	`newDefer,`
265	`isFunction( onRejected ) ?`
266	`onRejected :`
267	`Thrower`
268	`)`
269	`);`
270	`} ).promise();`
271	`},`
272
273	`// Get a promise for this deferred`
274	`// If obj is provided, the promise aspect is added to the object`
275	`promise: function( obj ) {`
276	`return obj != null ? jQuery.extend( obj, promise ) : promise;`
277	`}`
278	`},`
279	`deferred = {};`
280
281	`// Add list-specific methods`
282	`jQuery.each( tuples, function( i, tuple ) {`
283	`var list = tuple[ 2 ],`
284	`stateString = tuple[ 5 ];`
285
286	`// promise.progress = list.add`
287	`// promise.done = list.add`
288	`// promise.fail = list.add`
289	`promise[ tuple[ 1 ] ] = list.add;`
290
291	`// Handle state`
292	`if ( stateString ) {`
293	`list.add(`
294	`function() {`
295
296	`// state = "resolved" (i.e., fulfilled)`
297	`// state = "rejected"`
298	`state = stateString;`
299	`},`
300
301	`// rejected_callbacks.disable`
302	`// fulfilled_callbacks.disable`
303	`tuples[ 3 - i ][ 2 ].disable,`
304
305	`// rejected_handlers.disable`
306	`// fulfilled_handlers.disable`
307	`tuples[ 3 - i ][ 3 ].disable,`
308
309	`// progress_callbacks.lock`
310	`tuples[ 0 ][ 2 ].lock,`
311
312	`// progress_handlers.lock`
313	`tuples[ 0 ][ 3 ].lock`
314	`);`
315	`}`
316
317	`// progress_handlers.fire`
318	`// fulfilled_handlers.fire`
319	`// rejected_handlers.fire`
320	`list.add( tuple[ 3 ].fire );`
321
322	`// deferred.notify = function() { deferred.notifyWith(...) }`
323	`// deferred.resolve = function() { deferred.resolveWith(...) }`
324	`// deferred.reject = function() { deferred.rejectWith(...) }`
325	`deferred[ tuple[ 0 ] ] = function() {`
326	`deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );`
327	`return this;`
328	`};`
329
330	`// deferred.notifyWith = list.fireWith`
331	`// deferred.resolveWith = list.fireWith`
332	`// deferred.rejectWith = list.fireWith`
333	`deferred[ tuple[ 0 ] + "With" ] = list.fireWith;`
334	`} );`
335
336	`// Make the deferred a promise`
337	`promise.promise( deferred );`
338
339	`// Call given func if any`
340	`if ( func ) {`
341	`func.call( deferred, deferred );`
342	`}`
343
344	`// All done!`
345	`return deferred;`
346	`},`
347
348	`// Deferred helper`
349	`when: function( singleValue ) {`
350	`var`
351
352	`// count of uncompleted subordinates`
353	`remaining = arguments.length,`
354
355	`// count of unprocessed arguments`
356	`i = remaining,`
357
358	`// subordinate fulfillment data`
359	`resolveContexts = Array( i ),`
360	`resolveValues = slice.call( arguments ),`
361
362	`// the primary Deferred`
363	`primary = jQuery.Deferred(),`
364
365	`// subordinate callback factory`
366	`updateFunc = function( i ) {`
367	`return function( value ) {`
368	`resolveContexts[ i ] = this;`
369	`resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;`
370	`if ( !( --remaining ) ) {`
371	`primary.resolveWith( resolveContexts, resolveValues );`
372	`}`
373	`};`
374	`};`
375
376	`// Single- and empty arguments are adopted like Promise.resolve`
377	`if ( remaining <= 1 ) {`
378	`adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,`
379	`!remaining );`
380
381	`// Use .then() to unwrap secondary thenables (cf. gh-3000)`
382	`if ( primary.state() === "pending" \|\|`
383	`isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {`
384
385	`return primary.then();`
386	`}`
387	`}`
388
389	`// Multiple arguments are aggregated like Promise.all array elements`
390	`while ( i-- ) {`
391	`adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );`
392	`}`
393
394	`return primary.promise();`
395	`}`
396	`} );`
397
398	`return jQuery;`
399	`} );`