// For matching the engine and version of the browser
browserMatch,
-
+
// Has the ready events already been bound?
readyBound = false,
slice = Array.prototype.slice,
trim = String.prototype.trim,
indexOf = Array.prototype.indexOf,
-
+
// [[Class]] -> type pairs
- class2type = {},
-
- // Marker for deferred
- promiseMarker = [];
+ class2type = {};
jQuery.fn = jQuery.prototype = {
init: function( selector, context ) {
this.length = 1;
return this;
}
-
+
// The body element only exists once, optimize finding it
if ( selector === "body" && !context && document.body ) {
this.context = document;
ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes;
}
-
+
return jQuery.merge( this, selector );
-
+
// HANDLE: $("#id")
} else {
elem = document.getElementById( match[2] );
if ( jQuery.isArray( elems ) ) {
push.apply( ret, elems );
-
+
} else {
jQuery.merge( ret, elems );
}
jQuery.bindReady();
// Change ready & apply
- return ( jQuery.fn.ready = readyList.then ).apply( this , arguments );
+ return ( jQuery.fn.ready = readyList.complete ).apply( this , arguments );
},
-
+
eq: function( i ) {
return i === -1 ?
this.slice( i ) :
return callback.call( elem, i, elem );
}));
},
-
+
end: function() {
return this.prevObject || jQuery(null);
},
return jQuery;
},
-
+
// Is the DOM ready to be used? Set to true once it occurs.
isReady: false,
// A counter to track how many items to wait for before
// the ready event fires. See #6781
readyWait: 1,
-
+
// Handle when the DOM is ready
ready: function( wait ) {
// A third-party is pushing the ready event forwards
}
}
},
-
+
bindReady: function() {
if ( readyBound ) {
return;
if ( document.addEventListener ) {
// Use the handy event callback
document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
-
+
// A fallback to window.onload, that will always work
window.addEventListener( "load", jQuery.ready, false );
// ensure firing before onload,
// maybe late but safe also for iframes
document.attachEvent("onreadystatechange", DOMContentLoaded);
-
+
// A fallback to window.onload, that will always work
window.attachEvent( "onload", jQuery.ready );
if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
return false;
}
-
+
// Not own constructor property must be Object
if ( obj.constructor &&
!hasOwn.call(obj, "constructor") &&
!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
return false;
}
-
+
// Own properties are enumerated firstly, so to speed up,
// if last one is own, then all properties are own.
-
+
var key;
for ( key in obj ) {}
-
+
return key === undefined || hasOwn.call( obj, key );
},
}
return true;
},
-
+
error: function( msg ) {
throw msg;
},
-
+
parseJSON: function( data ) {
if ( typeof data !== "string" || !data ) {
return null;
// Make sure leading/trailing whitespace is removed (IE can't handle it)
data = jQuery.trim( data );
-
+
// Make sure the incoming data is actual JSON
// Logic borrowed from http://json.org/json2.js
if ( rvalidchars.test(data.replace(rvalidescape, "@")
for ( var l = second.length; j < l; j++ ) {
first[ i++ ] = second[ j ];
}
-
+
} else {
while ( second[j] !== undefined ) {
first[ i++ ] = second[ j++ ];
// The value/s can be optionally by executed if its a function
access: function( elems, key, value, exec, fn, pass ) {
var length = elems.length;
-
+
// Setting many attributes
if ( typeof key === "object" ) {
for ( var k in key ) {
}
return elems;
}
-
+
// Setting one attribute
if ( value !== undefined ) {
// Optionally, function values get executed if exec is true
exec = !pass && exec && jQuery.isFunction(value);
-
+
for ( var i = 0; i < length; i++ ) {
fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
}
-
+
return elems;
}
-
+
// Getting an attribute
return length ? fn( elems[0], key ) : undefined;
},
// the deferred itself
deferred = {
- // then( f1, f2, ...)
- then: function () {
+ // complete( f1, f2, ...)
+ complete: function () {
if ( ! cancelled ) {
elem = args[ i ];
type = jQuery.type( elem );
if ( type === "array" ) {
- deferred.then.apply( deferred , elem );
+ deferred.complete.apply( deferred , elem );
} else if ( type === "function" ) {
callbacks.push( elem );
}
// resolve with this as context and given arguments
resolve: function() {
- deferred.fire( this , arguments );
+ deferred.fire( jQuery.isFunction( this.promise ) ? this.promise() : this , arguments );
return this;
},
cancelled = 1;
callbacks = [];
return this;
- },
-
- // Has this deferred been cancelled?
- isCancelled: function() {
- return !!cancelled;
}
};
// Typical success/error system
Deferred: function( func ) {
- var errorDeferred = jQuery._Deferred(),
- deferred = jQuery._Deferred(),
- successCancel = deferred.cancel;
+ var deferred = jQuery._Deferred(),
+ failDeferred = jQuery._Deferred();
// Add errorDeferred methods and redefine cancel
jQuery.extend( deferred , {
- fail: errorDeferred.then,
- fireReject: errorDeferred.fire,
- reject: errorDeferred.resolve,
- isRejected: errorDeferred.isResolved,
- // Get a promise for this deferred
- // If obj is provided, the promise aspect is added to the object
- promise: function( obj ) {
- obj = obj || {};
- for ( var i in { then:1 , fail:1 , isResolved:1 , isRejected:1 , promise:1 } ) {
- obj[ i ] = deferred[ i ];
- }
+ then: function( completeCallbacks , failCallbacks ) {
+ deferred.complete( completeCallbacks ).fail( failCallbacks );
+ return this;
+ },
+ fail: failDeferred.complete,
+ fireReject: failDeferred.fire,
+ reject: failDeferred.resolve,
+ isRejected: failDeferred.isResolved,
+ // Get a promise for this deferred
+ // If obj is provided, the promise aspect is added to the object
+ promise: function( obj ) {
+ obj = obj || {};
+ jQuery.each( "then complete fail isResolved isRejected".split( " " ) , function( _ , method ) {
+ obj[ method ] = deferred[ method ];
+ });
+ obj.promise = function() {
return obj;
- }
+ };
+ return obj;
+ }
} );
- // Remove cancel related
- delete deferred.cancel;
- delete deferred.isCancelled;
-
- // Add promise marker
- deferred.promise._ = promiseMarker;
-
// Make sure only one callback list will be used
- deferred.then( errorDeferred.cancel ).fail( successCancel );
+ deferred.then( failDeferred.cancel , deferred.cancel );
+
+ // Unexpose cancel
+ delete deferred.cancel;
// Call given func if any
if ( func ) {
// Deferred helper
when: function( object ) {
- object = object && object.promise && object.promise._ === promiseMarker ?
+ object = object && jQuery.isFunction( object.promise ) ?
object :
jQuery.Deferred().resolve( object );
return object.promise();
jQuery.ready();
}
-// Expose jQuery as an Asynchronous Module
-if ( typeof define !== "undefined" ) {
- define( "jquery", [], function () { return jQuery; } );
-}
-
// Expose jQuery to the global object
return (window.jQuery = window.$ = jQuery);
git.asbjorn.biz / jquery.git / blobdiff