File Manager

✏️ omponents/jquery/src/deferred.js

define([
	"./core",
	"./var/slice",
	"./callbacks"
], function( jQuery, slice ) {

jQuery.extend({

Deferred: function( func ) {
		var tuples = [
				// action, add listener, listener list, final state
				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
				[ "notify", "progress", jQuery.Callbacks("memory") ]
			],
			state = "pending",
			promise = {
				state: function() {
					return state;
				},
				always: function() {
					deferred.done( arguments ).fail( arguments );
					return this;
				},
				then: function( /* fnDone, fnFail, fnProgress */ ) {
					var fns = arguments;
					return jQuery.Deferred(function( newDefer ) {
						jQuery.each( tuples, function( i, tuple ) {
							var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
							// deferred[ done | fail | progress ] for forwarding actions to newDefer
							deferred[ tuple[1] ](function() {
								var returned = fn && fn.apply( this, arguments );
								if ( returned && jQuery.isFunction( returned.promise ) ) {
									returned.promise()
										.done( newDefer.resolve )
										.fail( newDefer.reject )
										.progress( newDefer.notify );
								} else {
									newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
								}
							});
						});
						fns = null;
					}).promise();
				},
				// 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 = {};

// Keep pipe for back-compat
		promise.pipe = promise.then;

// Add list-specific methods
		jQuery.each( tuples, function( i, tuple ) {
			var list = tuple[ 2 ],
				stateString = tuple[ 3 ];

// promise[ done | fail | progress ] = list.add
			promise[ tuple[1] ] = list.add;

// Handle state
			if ( stateString ) {
				list.add(function() {
					// state = [ resolved | rejected ]
					state = stateString;

// [ reject_list | resolve_list ].disable; progress_list.lock
				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
			}

// deferred[ resolve | reject | notify ]
			deferred[ tuple[0] ] = function() {
				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
				return this;
			};
			deferred[ tuple[0] + "With" ] = list.fireWith;
		});

// Make the deferred a promise
		promise.promise( deferred );

// Call given func if any
		if ( func ) {
			func.call( deferred, deferred );
		}

// All done!
		return deferred;
	},

// Deferred helper
	when: function( subordinate /* , ..., subordinateN */ ) {
		var i = 0,
			resolveValues = slice.call( arguments ),
			length = resolveValues.length,

// the count of uncompleted subordinates
			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,

// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),

// Update function for both resolve and progress values
			updateFunc = function( i, contexts, values ) {
				return function( value ) {
					contexts[ i ] = this;
					values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
					if ( values === progressValues ) {
						deferred.notifyWith( contexts, values );
					} else if ( !( --remaining ) ) {
						deferred.resolveWith( contexts, values );
					}
				};
			},

progressValues, progressContexts, resolveContexts;

// Add listeners to Deferred subordinates; treat others as resolved
		if ( length > 1 ) {
			progressValues = new Array( length );
			progressContexts = new Array( length );
			resolveContexts = new Array( length );
			for ( ; i < length; i++ ) {
				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
					resolveValues[ i ].promise()
						.done( updateFunc( i, resolveContexts, resolveValues ) )
						.fail( deferred.reject )
						.progress( updateFunc( i, progressContexts, progressValues ) );
				} else {
					--remaining;
				}
			}
		}

// If we're not waiting on anything, resolve the master
		if ( !remaining ) {
			deferred.resolveWith( resolveContexts, resolveValues );
		}

return deferred.promise();
	}
});

return jQuery;
});

Batal

⬅ jquery 36 item

Nama	Tipe	Ukuran	Diubah	Aksi
📁ajax	dir	—	2026-03-18 12:47	📂 Buka
📁attributes	dir	—	2026-03-18 12:47	📂 Buka
📁core	dir	—	2026-03-18 12:47	📂 Buka
📁css	dir	—	2026-03-18 12:47	📂 Buka
📁data	dir	—	2026-03-18 12:47	📂 Buka
📁effects	dir	—	2026-03-18 12:47	📂 Buka
📁event	dir	—	2026-03-18 12:47	📂 Buka
📁exports	dir	—	2026-03-18 12:47	📂 Buka
📁manipulation	dir	—	2026-03-18 12:47	📂 Buka
📁queue	dir	—	2026-03-18 12:47	📂 Buka
📁sizzle	dir	—	2023-07-15 22:29	📂 Buka
📁traversing	dir	—	2026-03-18 12:47	📂 Buka
📁var	dir	—	2026-03-18 12:47	📂 Buka
📜ajax.js	js	20.7 KB	2023-07-15 22:29	✏️ 👁️
📜attributes.js	js	200 B	2023-07-15 22:29	✏️ 👁️
📜callbacks.js	js	5.4 KB	2023-07-15 22:29	✏️ 👁️
📜core.js	js	11.3 KB	2023-07-15 22:29	✏️ 👁️
📜css.js	js	12.1 KB	2023-07-15 22:29	✏️ 👁️
📜data.js	js	4.8 KB	2023-07-15 22:29	✏️ 👁️
📜deferred.js	js	4.3 KB	2023-07-15 22:29	✏️ 👁️
📜deprecated.js	js	223 B	2023-07-15 22:29	✏️ 👁️
📜dimensions.js	js	1.7 KB	2023-07-15 22:29	✏️ 👁️
📜effects.js	js	16.5 KB	2023-07-15 22:29	✏️ 👁️
📜event.js	js	23.9 KB	2023-07-15 22:29	✏️ 👁️
📜intro.js	js	1.4 KB	2023-07-15 22:29	✏️ 👁️
📜jquery.js	js	574 B	2023-07-15 22:29	✏️ 👁️
📜manipulation.js	js	14.7 KB	2023-07-15 22:29	✏️ 👁️
📜offset.js	js	5.5 KB	2023-07-15 22:29	✏️ 👁️
📜outro.js	js	5 B	2023-07-15 22:29	✏️ 👁️
📜queue.js	js	3 KB	2023-07-15 22:29	✏️ 👁️
📜selector-native.js	js	4.3 KB	2023-07-15 22:29	✏️ 👁️
📜selector-sizzle.js	js	294 B	2023-07-15 22:29	✏️ 👁️
📜selector.js	js	33 B	2023-07-15 22:29	✏️ 👁️
📜serialize.js	js	3.1 KB	2023-07-15 22:29	✏️ 👁️
📜traversing.js	js	4.4 KB	2023-07-15 22:29	✏️ 👁️
📜wrap.js	js	1.5 KB	2023-07-15 22:29	✏️ 👁️

✏️ Rename