utils/test/testapi/3rd_party/static/testapi-ui/assets/lib/jquery/src/deferred.js

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