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 |
|
23 | if ( value && isFunction( ( method = value.promise ) ) ) {
|
24 | method.call( value ).done( resolve ).fail( reject );
|
25 |
|
26 |
|
27 | } else if ( value && isFunction( ( method = value.then ) ) ) {
|
28 | method.call( value, resolve, reject );
|
29 |
|
30 |
|
31 | } else {
|
32 |
|
33 |
|
34 |
|
35 |
|
36 | resolve.apply( undefined, [ value ].slice( noValue ) );
|
37 | }
|
38 |
|
39 |
|
40 |
|
41 |
|
42 | } catch ( value ) {
|
43 |
|
44 |
|
45 |
|
46 | reject.apply( undefined, [ value ] );
|
47 | }
|
48 | }
|
49 |
|
50 | jQuery.extend( {
|
51 |
|
52 | Deferred: function( func ) {
|
53 | var tuples = [
|
54 |
|
55 |
|
56 |
|
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 |
|
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 |
|
85 | var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
|
86 |
|
87 |
|
88 |
|
89 |
|
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 |
|
118 |
|
119 |
|
120 | if ( depth < maxDepth ) {
|
121 | return;
|
122 | }
|
123 |
|
124 | returned = handler.apply( that, args );
|
125 |
|
126 |
|
127 |
|
128 | if ( returned === deferred.promise() ) {
|
129 | throw new TypeError( "Thenable self-resolution" );
|
130 | }
|
131 |
|
132 |
|
133 |
|
134 |
|
135 |
|
136 | then = returned &&
|
137 |
|
138 |
|
139 |
|
140 |
|
141 | ( typeof returned === "object" ||
|
142 | typeof returned === "function" ) &&
|
143 | returned.then;
|
144 |
|
145 |
|
146 | if ( isFunction( then ) ) {
|
147 |
|
148 |
|
149 | if ( special ) {
|
150 | then.call(
|
151 | returned,
|
152 | resolve( maxDepth, deferred, Identity, special ),
|
153 | resolve( maxDepth, deferred, Thrower, special )
|
154 | );
|
155 |
|
156 |
|
157 | } else {
|
158 |
|
159 |
|
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 |
|
172 | } else {
|
173 |
|
174 |
|
175 |
|
176 | if ( handler !== Identity ) {
|
177 | that = undefined;
|
178 | args = [ returned ];
|
179 | }
|
180 |
|
181 |
|
182 |
|
183 | ( special || deferred.resolveWith )( that, args );
|
184 | }
|
185 | },
|
186 |
|
187 |
|
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 |
|
201 |
|
202 |
|
203 | if ( depth + 1 >= maxDepth ) {
|
204 |
|
205 |
|
206 |
|
207 | if ( handler !== Thrower ) {
|
208 | that = undefined;
|
209 | args = [ e ];
|
210 | }
|
211 |
|
212 | deferred.rejectWith( that, args );
|
213 | }
|
214 | }
|
215 | };
|
216 |
|
217 |
|
218 |
|
219 |
|
220 |
|
221 | if ( depth ) {
|
222 | process();
|
223 | } else {
|
224 |
|
225 |
|
226 |
|
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 |
|
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 |
|
250 | tuples[ 1 ][ 3 ].add(
|
251 | resolve(
|
252 | 0,
|
253 | newDefer,
|
254 | isFunction( onFulfilled ) ?
|
255 | onFulfilled :
|
256 | Identity
|
257 | )
|
258 | );
|
259 |
|
260 |
|
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 |
|
274 |
|
275 | promise: function( obj ) {
|
276 | return obj != null ? jQuery.extend( obj, promise ) : promise;
|
277 | }
|
278 | },
|
279 | deferred = {};
|
280 |
|
281 |
|
282 | jQuery.each( tuples, function( i, tuple ) {
|
283 | var list = tuple[ 2 ],
|
284 | stateString = tuple[ 5 ];
|
285 |
|
286 |
|
287 |
|
288 |
|
289 | promise[ tuple[ 1 ] ] = list.add;
|
290 |
|
291 |
|
292 | if ( stateString ) {
|
293 | list.add(
|
294 | function() {
|
295 |
|
296 |
|
297 |
|
298 | state = stateString;
|
299 | },
|
300 |
|
301 |
|
302 |
|
303 | tuples[ 3 - i ][ 2 ].disable,
|
304 |
|
305 |
|
306 |
|
307 | tuples[ 3 - i ][ 3 ].disable,
|
308 |
|
309 |
|
310 | tuples[ 0 ][ 2 ].lock,
|
311 |
|
312 |
|
313 | tuples[ 0 ][ 3 ].lock
|
314 | );
|
315 | }
|
316 |
|
317 |
|
318 |
|
319 |
|
320 | list.add( tuple[ 3 ].fire );
|
321 |
|
322 |
|
323 |
|
324 |
|
325 | deferred[ tuple[ 0 ] ] = function() {
|
326 | deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
|
327 | return this;
|
328 | };
|
329 |
|
330 |
|
331 |
|
332 |
|
333 | deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
|
334 | } );
|
335 |
|
336 |
|
337 | promise.promise( deferred );
|
338 |
|
339 |
|
340 | if ( func ) {
|
341 | func.call( deferred, deferred );
|
342 | }
|
343 |
|
344 |
|
345 | return deferred;
|
346 | },
|
347 |
|
348 |
|
349 | when: function( singleValue ) {
|
350 | var
|
351 |
|
352 |
|
353 | remaining = arguments.length,
|
354 |
|
355 |
|
356 | i = remaining,
|
357 |
|
358 |
|
359 | resolveContexts = Array( i ),
|
360 | resolveValues = slice.call( arguments ),
|
361 |
|
362 |
|
363 | master = jQuery.Deferred(),
|
364 |
|
365 |
|
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 | master.resolveWith( resolveContexts, resolveValues );
|
372 | }
|
373 | };
|
374 | };
|
375 |
|
376 |
|
377 | if ( remaining <= 1 ) {
|
378 | adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,
|
379 | !remaining );
|
380 |
|
381 |
|
382 | if ( master.state() === "pending" ||
|
383 | isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
|
384 |
|
385 | return master.then();
|
386 | }
|
387 | }
|
388 |
|
389 |
|
390 | while ( i-- ) {
|
391 | adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
|
392 | }
|
393 |
|
394 | return master.promise();
|
395 | }
|
396 | } );
|
397 |
|
398 | return jQuery;
|
399 | } );
|