ecomp-portal-FE/client/bower_components/jquery/src/deferred.js

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