")
// inject the contents of the document in, removing the scripts
// to avoid any 'Permission Denied' errors in IE
- .append(res.responseText.replace(rscript, ""))
+ .append(responseText.replace(rscript, ""))
// Locate the specified elements
.find(selector) :
// If not, just inject the full result
- res.responseText );
+ responseText );
}
if ( callback ) {
- self.each( callback, [res.responseText, status, res] );
+ self.each( callback, [responseText, status, jXHR] );
}
}
});
@@ -99,9 +116,9 @@ jQuery.fn.extend({
null :
jQuery.isArray(val) ?
jQuery.map( val, function(val, i){
- return {name: elem.name, value: val};
+ return { name: elem.name, value: val.replace(rCRLF, "\r\n") };
}) :
- {name: elem.name, value: val};
+ { name: elem.name, value: val.replace(rCRLF, "\r\n") };
}).get();
}
});
@@ -113,9 +130,8 @@ jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".sp
};
});
-jQuery.extend({
-
- get: function( url, data, callback, type ) {
+jQuery.each( [ "get", "post" ], function( i, method ) {
+ jQuery[ method ] = function( url, data, callback, type ) {
// shift arguments if data argument was omited
if ( jQuery.isFunction( data ) ) {
type = type || callback;
@@ -124,13 +140,16 @@ jQuery.extend({
}
return jQuery.ajax({
- type: "GET",
+ type: method,
url: url,
data: data,
success: callback,
dataType: type
});
- },
+ };
+});
+
+jQuery.extend({
getScript: function( url, callback ) {
return jQuery.get(url, null, callback, "script");
@@ -140,25 +159,9 @@ jQuery.extend({
return jQuery.get(url, data, callback, "json");
},
- post: function( url, data, callback, type ) {
- // shift arguments if data argument was omited
- if ( jQuery.isFunction( data ) ) {
- type = type || callback;
- callback = data;
- data = {};
- }
-
- return jQuery.ajax({
- type: "POST",
- url: url,
- data: data,
- success: callback,
- dataType: type
- });
- },
-
ajaxSetup: function( settings ) {
- jQuery.extend( jQuery.ajaxSettings, settings );
+ jQuery.extend( true, jQuery.ajaxSettings, settings );
+ return this;
},
ajaxSettings: {
@@ -181,12 +184,7 @@ jQuery.extend({
xhr: function() {
return new window.XMLHttpRequest();
},
- xhrResponseFields: {
- xml: "XML",
- text: "Text",
- json: "JSON"
- },
-
+
accepts: {
xml: "application/xml, text/xml",
html: "text/html",
@@ -194,97 +192,523 @@ jQuery.extend({
json: "application/json, text/javascript",
"*": "*/*"
},
-
- autoDataType: {
+
+ contents: {
xml: /xml/,
html: /html/,
json: /json/
},
-
+
// Prefilters
// 1) They are useful to introduce custom dataTypes (see transport/jsonp for an example)
// 2) These are called:
// * BEFORE asking for a transport
// * AFTER param serialization (s.data is a string if s.processData is true)
- // 3) They MUST be order agnostic
- prefilters: [],
-
+ // 3) key is the dataType
+ // 4) the catchall symbol "*" can be used
+ // 5) execution will start with transport dataType and THEN continue down to "*" if needed
+ prefilters: {},
+
// Transports bindings
// 1) key is the dataType
// 2) the catchall symbol "*" can be used
// 3) selection will start with transport dataType and THEN go to "*" if needed
- transports: {
- },
-
- // Checkers
- // 1) key is dataType
- // 2) they are called to control successful response
- // 3) error throws is used as error data
- dataCheckers: {
-
- // Check if data is a string
- "text": function(data) {
- if ( typeof data != "string" ) {
- jQuery.error("typeerror");
- }
- },
-
- // Check if xml has been properly parsed
- "xml": function(data) {
- var documentElement = data ? data.documentElement : data;
- if ( ! documentElement || ! documentElement.nodeName ) {
- jQuery.error("typeerror");
- }
- if ( documentElement.nodeName == "parsererror" ) {
- jQuery.error("parsererror");
- }
- }
- },
-
+ transports: {},
+
// List of data converters
- // 1) key format is "source_type => destination_type" (spaces required)
+ // 1) key format is "source_type destination_type" (a single space in-between)
// 2) the catchall symbol "*" can be used for source_type
- dataConverters: {
-
+ converters: {
+
// Convert anything to text
- "* => text": function(data) {
- return "" + data;
- },
-
- // Text to html (no transformation)
- "text => html": function(data) {
- return data;
- },
-
+ "* text": window.String,
+
+ // Text to html (true = no transformation)
+ "text html": true,
+
// Evaluate text as a json expression
- "text => json": jQuery.parseJSON,
-
+ "text json": jQuery.parseJSON,
+
// Parse text as xml
- "text => xml": function(data) {
- var xml, parser;
- if ( window.DOMParser ) { // Standard
- parser = new DOMParser();
- xml = parser.parseFromString(data,"text/xml");
- } else { // IE
- xml = new ActiveXObject("Microsoft.XMLDOM");
- xml.async="false";
- xml.loadXML(data);
- }
- return xml;
- }
+ "text xml": jQuery.parseXML
}
},
// Main method
- ajax: function( url , s ) {
-
+ // (s is used internally)
+ ajax: function( url , options , s ) {
+
+ // Handle varargs
if ( arguments.length === 1 ) {
- s = url;
- url = s ? s.url : undefined;
+ options = url;
+ url = options ? options.url : undefined;
}
-
- return jQuery.xhr().open( s ? s.type : undefined , url ).send( undefined , s );
-
+
+ // Force options to be an object
+ options = options || {};
+
+ // Get the url if provided separately
+ options.url = url || options.url;
+
+ // Create the final options object
+ s = jQuery.extend( true , {} , jQuery.ajaxSettings , options );
+
+ // We force the original context
+ // (plain objects used as context get extended)
+ s.context = options.context;
+
+ var // jQuery lists
+ jQuery_lastModified = jQuery.lastModified,
+ jQuery_etag = jQuery.etag,
+ // Callbacks contexts
+ callbackContext = s.context || s,
+ globalEventContext = s.context ? jQuery( s.context ) : jQuery.event,
+ // Deferreds
+ deferred = jQuery.Deferred(),
+ completeDeferred = jQuery._Deferred(),
+ // Status-dependent callbacks
+ statusCode = s.statusCode || {},
+ // Headers (they are sent all at once)
+ requestHeaders = {},
+ // Response headers
+ responseHeadersString,
+ responseHeaders,
+ // transport
+ transport,
+ // timeout handle
+ timeoutTimer,
+ // Cross-domain detection vars
+ loc = document.location,
+ parts,
+ // The jXHR state
+ state = 0,
+ // Loop variable
+ i,
+ // Fake xhr
+ jXHR = {
+
+ readyState: 0,
+
+ // Caches the header
+ setRequestHeader: function(name,value) {
+ if ( state === 0 ) {
+ requestHeaders[ name.toLowerCase() ] = value;
+ }
+ return this;
+ },
+
+ // Raw string
+ getAllResponseHeaders: function() {
+ return state === 2 ? responseHeadersString : null;
+ },
+
+ // Builds headers hashtable if needed
+ // (match is used internally)
+ getResponseHeader: function( key , match ) {
+
+ if ( state !== 2 ) {
+ return null;
+ }
+
+ if ( responseHeaders === undefined ) {
+
+ responseHeaders = {};
+
+ if ( typeof responseHeadersString === "string" ) {
+
+ while( ( match = rheaders.exec( responseHeadersString ) ) ) {
+ responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
+ }
+ }
+ }
+ return responseHeaders[ key.toLowerCase() ];
+ },
+
+ // Cancel the request
+ abort: function( statusText ) {
+ if ( transport && state !== 2 ) {
+ transport.abort( statusText || "abort" );
+ done( 0 , statusText );
+ }
+ return this;
+ }
+ };
+
+ // Callback for when everything is done
+ // It is defined here because jslint complains if it is declared
+ // at the end of the function (which would be more logical and readable)
+ function done( status , statusText , response , headers) {
+
+ // Called once
+ if ( state === 2 ) {
+ return;
+ }
+
+ // State is "done" now
+ state = 2;
+
+ // Set readyState
+ jXHR.readyState = status ? 4 : 0;
+
+ // Cache response headers
+ responseHeadersString = headers || "";
+
+ // Clear timeout if it exists
+ if ( timeoutTimer ) {
+ clearTimeout(timeoutTimer);
+ }
+
+ var // Reference url
+ url = s.url,
+ // and ifModified status
+ ifModified = s.ifModified,
+
+ // Is it a success?
+ isSuccess = 0,
+ // Stored success
+ success,
+ // Stored error
+ error;
+
+ // If successful, handle type chaining
+ if ( status >= 200 && status < 300 || status === 304 ) {
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+
+ var lastModified = jXHR.getResponseHeader("Last-Modified"),
+ etag = jXHR.getResponseHeader("Etag");
+
+ if (lastModified) {
+ jQuery_lastModified[ s.url ] = lastModified;
+ }
+ if (etag) {
+ jQuery_etag[ s.url ] = etag;
+ }
+ }
+
+ // If not modified
+ if ( status === 304 ) {
+
+ // Set the statusText accordingly
+ statusText = "notmodified";
+ // Mark as a success
+ isSuccess = 1;
+
+ // If we have data
+ } else {
+
+ // Set the statusText accordingly
+ statusText = "success";
+
+ // Chain data conversions and determine the final value
+ // (if an exception is thrown in the process, it'll be notified as an error)
+ try {
+
+ var i,
+ // Current dataType
+ current,
+ // Previous dataType
+ prev,
+ // Conversion function
+ conv,
+ // Conversion functions (when text is used in-between)
+ conv1,
+ conv2,
+ // Local references to dataTypes & converters
+ dataTypes = s.dataTypes,
+ converters = s.converters,
+ // DataType to responseXXX field mapping
+ responses = {
+ "xml": "XML",
+ "text": "Text"
+ };
+
+ // For each dataType in the chain
+ for( i = 0 ; i < dataTypes.length ; i++ ) {
+
+ current = dataTypes[ i ];
+
+ // If a responseXXX field for this dataType exists
+ // and if it hasn't been set yet
+ if ( responses[ current ] ) {
+ // Set it
+ jXHR[ "response" + responses[ current ] ] = response;
+ // Mark it as set
+ responses[ current ] = 0;
+ }
+
+ // If this is not the first element
+ if ( i ) {
+
+ // Get the dataType to convert from
+ prev = dataTypes[ i - 1 ];
+
+ // If no catch-all and dataTypes are actually different
+ if ( prev !== "*" && current !== "*" && prev !== current ) {
+
+ // Get the converter
+ conv = converters[ prev + " " + current ] ||
+ converters[ "* " + current ];
+
+ conv1 = conv2 = 0;
+
+ // If there is no direct converter and none of the dataTypes is text
+ if ( ! conv && prev !== "text" && current !== "text" ) {
+ // Try with text in-between
+ conv1 = converters[ prev + " text" ] || converters[ "* text" ];
+ conv2 = converters[ "text " + current ];
+ // Revert back to a single converter
+ // if one of the converter is an equivalence
+ if ( conv1 === true ) {
+ conv = conv2;
+ } else if ( conv2 === true ) {
+ conv = conv1;
+ }
+ }
+ // If we found no converter, dispatch an error
+ if ( ! ( conv || conv1 && conv2 ) ) {
+ throw conversion;
+ }
+ // If found converter is not an equivalence
+ if ( conv !== true ) {
+ // Convert with 1 or 2 converters accordingly
+ response = conv ? conv( response ) : conv2( conv1( response ) );
+ }
+ }
+ // If it is the first element of the chain
+ // and we have a dataFilter
+ } else if ( s.dataFilter ) {
+ // Apply the dataFilter
+ response = s.dataFilter( response , current );
+ // Get dataTypes again in case the filter changed them
+ dataTypes = s.dataTypes;
+ }
+ }
+ // End of loop
+
+ // We have a real success
+ success = response;
+ isSuccess = 1;
+
+ // If an exception was thrown
+ } catch(e) {
+
+ // We have a parsererror
+ statusText = "parsererror";
+ error = "" + e;
+
+ }
+ }
+
+ // if not success, mark it as an error
+ } else {
+
+ error = statusText = statusText || "error";
+
+ // Set responseText if needed
+ if ( response ) {
+ jXHR.responseText = response;
+ }
+ }
+
+ // Set data for the fake xhr object
+ jXHR.status = status;
+ jXHR.statusText = statusText;
+
+ // Success/Error
+ if ( isSuccess ) {
+ deferred.fire( callbackContext , [ success , statusText , jXHR ] );
+ } else {
+ deferred.fireReject( callbackContext , [ jXHR , statusText , error ] );
+ }
+
+ // Status-dependent callbacks
+ jXHR.statusCode( statusCode );
+
+ if ( s.global ) {
+ globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ) ,
+ [ jXHR , s , isSuccess ? success : error ] );
+ }
+
+ // Complete
+ completeDeferred.fire( callbackContext, [ jXHR , statusText ] );
+
+ if ( s.global ) {
+ globalEventContext.trigger( "ajaxComplete" , [ jXHR , s] );
+ // Handle the global AJAX counter
+ if ( ! --jQuery.active ) {
+ jQuery.event.trigger( "ajaxStop" );
+ }
+ }
+ }
+
+ // Attach deferreds
+ deferred.promise( jXHR );
+ jXHR.success = jXHR.done;
+ jXHR.error = jXHR.fail;
+ jXHR.complete = completeDeferred.done;
+
+ // Status-dependent callbacks
+ jXHR.statusCode = function( map ) {
+ if ( map ) {
+ var resolved = jXHR.isResolved(),
+ tmp;
+ if ( resolved || jXHR.isRejected() ) {
+ tmp = map[ jXHR.status ];
+ if ( tmp ) {
+ if ( map === statusCode ) {
+ delete statusCode[ jXHR.status ];
+ }
+ jXHR[ resolved ? "done" : "fail" ]( tmp );
+ }
+ } else {
+ for( tmp in map ) {
+ statusCode[ tmp ] = [ statusCode[ tmp ] , map[ tmp ] ];
+ }
+ }
+ }
+ return this;
+ };
+
+ // Remove hash character (#7531: and string promotion)
+ s.url = ( "" + s.url ).replace( rhash , "" );
+
+ // Uppercase the type
+ s.type = s.type.toUpperCase();
+
+ // Determine if request has content
+ s.hasContent = ! rnoContent.test( s.type );
+
+ // Extract dataTypes list
+ s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( /\s+/ );
+
+ // Determine if a cross-domain request is in order
+ if ( ! s.crossDomain ) {
+ parts = rurl.exec( s.url.toLowerCase() );
+ s.crossDomain = !!(
+ parts &&
+ ( parts[ 1 ] && parts[ 1 ] != loc.protocol ||
+ parts[ 2 ] != loc.hostname ||
+ ( parts[ 3 ] || 80 ) != ( loc.port || 80 ) )
+ );
+ }
+
+ // Convert data if not already a string
+ if ( s.data && s.processData && typeof s.data != "string" ) {
+ s.data = jQuery.param( s.data , s.traditional );
+ }
+
+ // Get transport
+ transport = jQuery.ajaxPrefilter( s , options ).ajaxTransport( s );
+
+ // Watch for a new set of requests
+ if ( s.global && jQuery.active++ === 0 ) {
+ jQuery.event.trigger( "ajaxStart" );
+ }
+
+ // If no transport, we auto-abort
+ if ( ! transport ) {
+
+ done( 0 , "transport not found" );
+ jXHR = false;
+
+ } else {
+
+ // More options handling for requests with no content
+ if ( ! s.hasContent ) {
+
+ // If data is available, append data to url
+ if ( s.data ) {
+ s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
+ }
+
+ // Add anti-cache in url if needed
+ if ( s.cache === false ) {
+
+ var ts = jQuery.now(),
+ // try replacing _= if it is there
+ ret = s.url.replace( rts , "$1_=" + ts );
+
+ // if nothing was replaced, add timestamp to the end
+ s.url = ret + ( (ret == s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "");
+ }
+ }
+
+ // Set the correct header, if data is being sent
+ if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
+ requestHeaders[ "content-type" ] = s.contentType;
+ }
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+ if ( jQuery_lastModified[ s.url ] ) {
+ requestHeaders[ "if-modified-since" ] = jQuery_lastModified[ s.url ];
+ }
+ if ( jQuery_etag[ s.url ] ) {
+ requestHeaders[ "if-none-match" ] = jQuery_etag[ s.url ];
+ }
+ }
+
+ // Set the Accepts header for the server, depending on the dataType
+ requestHeaders.accept = s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
+ s.accepts[ s.dataTypes[ 0 ] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) :
+ s.accepts[ "*" ];
+
+ // Check for headers option
+ for ( i in s.headers ) {
+ requestHeaders[ i.toLowerCase() ] = s.headers[ i ];
+ }
+
+ // Allow custom headers/mimetypes and early abort
+ if ( s.beforeSend && ( s.beforeSend.call( callbackContext , jXHR , s ) === false || state === 2 ) ) {
+
+ // Abort if not done already
+ done( 0 , "abort" );
+ jXHR = false;
+
+ } else {
+
+ // Set state as sending
+ state = 1;
+ jXHR.readyState = 1;
+
+ // Install callbacks on deferreds
+ for ( i in { success:1, error:1, complete:1 } ) {
+ jXHR[ i ]( s[ i ] );
+ }
+
+ // Send global event
+ if ( s.global ) {
+ globalEventContext.trigger( "ajaxSend" , [ jXHR , s ] );
+ }
+
+ // Timeout
+ if ( s.async && s.timeout > 0 ) {
+ timeoutTimer = setTimeout(function(){
+ jXHR.abort( "timeout" );
+ }, s.timeout);
+ }
+
+ // Try to send
+ try {
+ transport.send(requestHeaders, done);
+ } catch (e) {
+ // Propagate exception as error if not done
+ if ( status === 1 ) {
+
+ done(0, "error", "" + e);
+ jXHR = false;
+
+ // Simply rethrow otherwise
+ } else {
+ jQuery.error(e);
+ }
+ }
+ }
+ }
+
+ return jXHR;
},
// Serialize an array of form elements or a set of
@@ -296,19 +720,19 @@ jQuery.extend({
value = jQuery.isFunction(value) ? value() : value;
s[ s.length ] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
};
-
+
// Set traditional to true for jQuery <= 1.3.2 behavior.
if ( traditional === undefined ) {
traditional = jQuery.ajaxSettings.traditional;
}
-
+
// If an array was passed in, assume that it is an array of form elements.
if ( jQuery.isArray(a) || a.jquery ) {
// Serialize the form elements
jQuery.each( a, function() {
add( this.name, this.value );
});
-
+
} else {
// If traditional, encode the "old" way (the way 1.3.2 or older
// did it), otherwise encode params recursively.
@@ -341,9 +765,11 @@ function buildParams( prefix, obj, traditional, add ) {
buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
}
});
-
+
} else if ( !traditional && obj != null && typeof obj === "object" ) {
- if ( jQuery.isEmptyObject( obj ) ) {
+ // If we see an array here, it is empty and should be treated as an empty
+ // object
+ if ( jQuery.isArray( obj ) || jQuery.isEmptyObject( obj ) ) {
add( prefix, "" );
// Serialize object item.
@@ -352,7 +778,7 @@ function buildParams( prefix, obj, traditional, add ) {
buildParams( prefix + "[" + k + "]", v, traditional, add );
});
}
-
+
} else {
// Serialize scalar item.
add( prefix, obj );
@@ -372,6 +798,172 @@ jQuery.extend({
});
+//Execute or select from functions in a given structure of options
+function ajax_selectOrExecute( structure , s ) {
+
+ var dataTypes = s.dataTypes,
+ transportDataType,
+ list,
+ selected,
+ i,
+ length,
+ checked = {},
+ flag,
+ noSelect = structure !== "transports";
+
+ function initSearch( dataType ) {
+
+ flag = transportDataType !== dataType && ! checked[ dataType ];
+
+ if ( flag ) {
+
+ checked[ dataType ] = 1;
+ transportDataType = dataType;
+ list = s[ structure ][ dataType ];
+ i = -1;
+ length = list ? list.length : 0 ;
+ }
+
+ return flag;
+ }
+
+ initSearch( dataTypes[ 0 ] );
+
+ for ( i = 0 ; ( noSelect || ! selected ) && i <= length ; i++ ) {
+
+ if ( i === length ) {
+
+ initSearch( "*" );
+
+ } else {
+
+ selected = list[ i ]( s , determineDataType );
+
+ // If we got redirected to another dataType
+ // Search there (if not in progress or already tried)
+ if ( typeof( selected ) === "string" &&
+ initSearch( selected ) ) {
+
+ dataTypes.unshift( selected );
+ selected = 0;
+ }
+ }
+ }
+
+ return noSelect ? jQuery : selected;
+}
+
+// Add an element to one of the structures in ajaxSettings
+function ajax_addElement( structure , args ) {
+
+ var i,
+ start = 0,
+ length = args.length,
+ dataTypes = [ "*" ],
+ dLength = 1,
+ dataType,
+ functors = [],
+ first,
+ append,
+ list;
+
+ if ( length ) {
+
+ first = jQuery.type( args[ 0 ] );
+
+ if ( first === "object" ) {
+ return ajax_selectOrExecute( structure , args[ 0 ] );
+ }
+
+ structure = jQuery.ajaxSettings[ structure ];
+
+ if ( first !== "function" ) {
+
+ dataTypes = args[ 0 ].toLowerCase().split(/\s+/);
+ dLength = dataTypes.length;
+ start = 1;
+
+ }
+
+ if ( dLength && start < length ) {
+
+ functors = sliceFunc.call( args , start );
+
+ for( i = 0 ; i < dLength ; i++ ) {
+
+ dataType = dataTypes[ i ];
+
+ first = /^\+/.test( dataType );
+
+ if (first) {
+ dataType = dataType.substr(1);
+ }
+
+ if ( dataType !== "" ) {
+
+ append = Array.prototype[ first ? "unshift" : "push" ];
+ list = structure[ dataType ] = structure[ dataType ] || [];
+ append.apply( list , functors );
+ }
+ }
+ }
+ }
+
+ return jQuery;
+}
+
+// Install prefilter & transport methods
+jQuery.each( [ "Prefilter" , "Transport" ] , function( _ , name ) {
+ _ = name.toLowerCase() + "s";
+ jQuery[ "ajax" + name ] = function() {
+ return ajax_addElement( _ , arguments );
+ };
+} );
+
+// Utility function that handles dataType when response is received
+// (for those transports that can give text or xml responses)
+function determineDataType( s , ct , text , xml ) {
+
+ var contents = s.contents,
+ type,
+ regexp,
+ dataTypes = s.dataTypes,
+ transportDataType = dataTypes[0],
+ response;
+
+ // Auto (xml, json, script or text determined given headers)
+ if ( transportDataType === "*" ) {
+
+ for ( type in contents ) {
+ if ( ( regexp = contents[ type ] ) && regexp.test( ct ) ) {
+ transportDataType = dataTypes[0] = type;
+ break;
+ }
+ }
+ }
+
+ // xml and parsed as such
+ if ( transportDataType === "xml" &&
+ xml &&
+ xml.documentElement /* #4958 */ ) {
+
+ response = xml;
+
+ // Text response was provided
+ } else {
+
+ response = text;
+
+ // If it's not really text, defer to converters
+ if ( transportDataType !== "text" ) {
+ dataTypes.unshift( "text" );
+ }
+
+ }
+
+ return response;
+}
+
/*
* Create the request object; Microsoft failed to properly
* implement the XMLHttpRequest in IE7 (can't request local files),
@@ -386,7 +978,7 @@ if ( window.ActiveXObject ) {
return new window.XMLHttpRequest();
} catch( xhrError ) {}
}
-
+
try {
return new window.ActiveXObject("Microsoft.XMLHTTP");
} catch( activeError ) {}
diff --git a/src/ajax/jsonp.js b/src/ajax/jsonp.js
new file mode 100644
index 000000000..1df5dd427
--- /dev/null
+++ b/src/ajax/jsonp.js
@@ -0,0 +1,83 @@
+(function( jQuery ) {
+
+var jsc = jQuery.now(),
+ jsre = /(\=)(?:\?|%3F)(&|$)|()(?:\?\?|%3F%3F)()/i,
+ rquery_jsonp = /\?/;
+
+// Default jsonp settings
+jQuery.ajaxSetup({
+ jsonp: "callback",
+ jsonpCallback: function() {
+ return "jsonp" + jsc++;
+ }
+
+// Normalize jsonp queries
+// 1) put callback parameter in url or data
+// 2) sneakily ensure transportDataType is always jsonp for jsonp requests
+}).ajaxPrefilter("json jsonp", function(s, originalSettings) {
+
+ if ( s.dataTypes[ 0 ] === "jsonp" ||
+ originalSettings.jsonp ||
+ originalSettings.jsonpCallback ||
+ jsre.test(s.url) ||
+ typeof(s.data) === "string" && jsre.test(s.data) ) {
+
+ var jsonpCallback = s.jsonpCallback =
+ jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
+ url = s.url.replace(jsre, "$1" + jsonpCallback + "$2"),
+ data = s.url === url && typeof(s.data) === "string" ? s.data.replace(jsre, "$1" + jsonpCallback + "$2") : s.data;
+
+ if ( url === s.url && data === s.data ) {
+ url += (rquery_jsonp.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
+ }
+
+ s.url = url;
+ s.data = data;
+ s.dataTypes[ 0 ] = "jsonp";
+ }
+
+// Bind transport to jsonp dataType
+}).ajaxTransport("jsonp", function(s) {
+
+ // Put callback in place
+ var responseContainer,
+ jsonpCallback = s.jsonpCallback,
+ previous = window[ jsonpCallback ];
+
+ window [ jsonpCallback ] = function( response ) {
+ responseContainer = [response];
+ };
+
+ s.complete = [function() {
+
+ // Set callback back to previous value
+ window[ jsonpCallback ] = previous;
+
+ // Call if it was a function and we have a response
+ if ( previous) {
+ if ( responseContainer && jQuery.isFunction ( previous ) ) {
+ window[ jsonpCallback ] ( responseContainer[0] );
+ }
+ } else {
+ // else, more memory leak avoidance
+ try{ delete window[ jsonpCallback ]; } catch(e){}
+ }
+
+ }, s.complete ];
+
+ // Sneakily ensure this will be handled as json
+ s.dataTypes[ 0 ] = "json";
+
+ // Use data converter to retrieve json after script execution
+ s.converters["script json"] = function() {
+ if ( ! responseContainer ) {
+ jQuery.error( jsonpCallback + " was not called" );
+ }
+ return responseContainer[ 0 ];
+ };
+
+ // Delegate to script transport
+ return "script";
+});
+
+})( jQuery );
diff --git a/src/transports/script.js b/src/ajax/script.js
similarity index 65%
rename from src/transports/script.js
rename to src/ajax/script.js
index fe3873557..8e2e89ac5 100644
--- a/src/transports/script.js
+++ b/src/ajax/script.js
@@ -1,39 +1,38 @@
(function( jQuery ) {
-// Install text to script executor
-jQuery.extend( true, jQuery.ajaxSettings , {
+// Install script dataType
+jQuery.ajaxSetup({
accepts: {
script: "text/javascript, application/javascript"
},
-
- autoDataType: {
+
+ contents: {
script: /javascript/
},
-
- dataConverters: {
- "text => script": jQuery.globalEval
+
+ converters: {
+ "text script": jQuery.globalEval
}
-} );
// Bind script tag hack transport
-jQuery.xhr.bindTransport("script", function(s) {
-
+}).ajaxTransport("script", function(s) {
+
// Handle cache special case
if ( s.cache === undefined ) {
s.cache = false;
}
-
+
// This transport only deals with cross domain get requests
if ( s.crossDomain && s.async && ( s.type === "GET" || ! s.data ) ) {
-
+
s.global = false;
-
+
var script,
head = document.getElementsByTagName("head")[0] || document.documentElement;
-
+
return {
-
+
send: function(_, callback) {
script = document.createElement("script");
@@ -43,37 +42,39 @@ jQuery.xhr.bindTransport("script", function(s) {
if ( s.scriptCharset ) {
script.charset = s.scriptCharset;
}
-
+
script.src = s.url;
-
+
// Attach handlers for all browsers
- script.onload = script.onreadystatechange = function(statusText) {
-
- if ( (!script.readyState ||
- script.readyState === "loaded" || script.readyState === "complete") ) {
-
+ script.onload = script.onreadystatechange = function( _ , isAbort ) {
+
+ if ( ! script.readyState || /loaded|complete/.test( script.readyState ) ) {
+
// Handle memory leak in IE
script.onload = script.onreadystatechange = null;
-
+
// Remove the script
if ( head && script.parentNode ) {
head.removeChild( script );
}
-
- script = undefined;
-
- // Callback & dereference
- callback(statusText ? 0 : 200, statusText || "success");
+
+ // Dereference the script
+ script = 0;
+
+ // Callback if not abort
+ if ( ! isAbort ) {
+ callback( 200, "success" );
+ }
}
};
// Use insertBefore instead of appendChild to circumvent an IE6 bug.
// This arises when a base node is used (#2709 and #4378).
head.insertBefore( script, head.firstChild );
},
-
- abort: function(statusText) {
+
+ abort: function() {
if ( script ) {
- script.onload(statusText);
+ script.onload(0,1);
}
}
};
diff --git a/src/transports/xhr.js b/src/ajax/xhr.js
similarity index 58%
rename from src/transports/xhr.js
rename to src/ajax/xhr.js
index 783ee4604..34aa832fe 100644
--- a/src/transports/xhr.js
+++ b/src/ajax/xhr.js
@@ -1,29 +1,47 @@
(function( jQuery ) {
-var // Next fake timer id
- xhrPollingId = jQuery.now(),
-
- // Callbacks hashtable
+var // Next active xhr id
+ xhrId = jQuery.now(),
+
+ // active xhrs
xhrs = {},
- // #5280: see end of file
- xhrUnloadAbortMarker = [];
+ // #5280: see below
+ xhrUnloadAbortInstalled;
+
+
+jQuery.ajaxTransport( function( s , determineDataType ) {
-
-jQuery.xhr.bindTransport( function( s , determineDataType ) {
-
// Cross domain only allowed if supported through XMLHttpRequest
if ( ! s.crossDomain || jQuery.support.cors ) {
-
+
var callback;
-
+
return {
-
+
send: function(headers, complete) {
-
+
+ // #5280: we need to abort on unload or IE will keep connections alive
+ if ( ! xhrUnloadAbortInstalled ) {
+
+ xhrUnloadAbortInstalled = 1;
+
+ jQuery(window).bind( "unload" , function() {
+
+ // Abort all pending requests
+ jQuery.each(xhrs, function(_, xhr) {
+ if ( xhr.onreadystatechange ) {
+ xhr.onreadystatechange( 1 );
+ }
+ });
+
+ });
+ }
+
+ // Get a new xhr
var xhr = s.xhr(),
handle;
-
+
// Open the socket
// Passing null username, generates a login popup on Opera (#2865)
if ( s.username ) {
@@ -31,24 +49,24 @@ jQuery.xhr.bindTransport( function( s , determineDataType ) {
} else {
xhr.open(s.type, s.url, s.async);
}
-
+
// Requested-With header
// Not set for crossDomain requests with no content
// (see why at http://trac.dojotoolkit.org/ticket/9486)
- // Won't change header if already provided in beforeSend
+ // Won't change header if already provided
if ( ! ( s.crossDomain && ! s.hasContent ) && ! headers["x-requested-with"] ) {
headers["x-requested-with"] = "XMLHttpRequest";
}
-
+
// Need an extra try/catch for cross domain requests in Firefox 3
try {
-
+
jQuery.each(headers, function(key,value) {
xhr.setRequestHeader(key,value);
});
-
+
} catch(_) {}
-
+
// Do send the request
try {
xhr.send( ( s.hasContent && s.data ) || null );
@@ -56,55 +74,48 @@ jQuery.xhr.bindTransport( function( s , determineDataType ) {
complete(0, "error", "" + e);
return;
}
-
+
// Listener
- callback = function ( abortStatusText ) {
-
+ callback = function( _ , isAbort ) {
+
// Was never called and is aborted or complete
- if ( callback && ( abortStatusText || xhr.readyState === 4 ) ) {
-
- // Do not listen anymore
+ if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
+
+ // Only called once
+ callback = 0;
+
+ // Do not keep as active anymore
+ // and store back into pool
if (handle) {
xhr.onreadystatechange = jQuery.noop;
delete xhrs[ handle ];
- handle = undefined;
}
-
- callback = 0;
-
- // Get info
- var status, statusText, response, responseHeaders;
-
- if ( abortStatusText ) {
-
+
+ // If it's an abort
+ if ( isAbort ) {
+
+ // Abort it manually if needed
if ( xhr.readyState !== 4 ) {
xhr.abort();
}
-
- // Stop here if unloadAbort
- if ( abortStatusText === xhrUnloadAbortMarker ) {
- return;
- }
-
- status = 0;
- statusText = abortStatusText;
-
} else {
-
- status = xhr.status;
-
+
+ // Get info
+ var status = xhr.status,
+ statusText,
+ response,
+ responseHeaders = xhr.getAllResponseHeaders();
+
try { // Firefox throws an exception when accessing statusText for faulty cross-domain requests
-
+
statusText = xhr.statusText;
-
+
} catch( e ) {
-
+
statusText = ""; // We normalize with Webkit giving an empty statusText
-
+
}
-
- responseHeaders = xhr.getAllResponseHeaders();
-
+
// Filter status for non standard behaviours
// (so many they seem to be the actual "standard")
status =
@@ -129,63 +140,44 @@ jQuery.xhr.bindTransport( function( s , determineDataType ) {
:
status
);
-
- // Guess response if needed & update datatype accordingly
- if ( status >= 200 && status < 300 ) {
- response =
- determineDataType(
- s,
- xhr.getResponseHeader("content-type"),
- xhr.responseText,
- xhr.responseXML );
- }
+
+ // Guess response & update dataType accordingly
+ response =
+ determineDataType(
+ s,
+ xhr.getResponseHeader("content-type"),
+ xhr.responseText,
+ xhr.responseXML );
+
+ // Call complete
+ complete(status,statusText,response,responseHeaders);
}
-
- // Call complete
- complete(status,statusText,response,responseHeaders);
}
};
-
+
// if we're in sync mode
// or it's in cache and has been retrieved directly (IE6 & IE7)
// we need to manually fire the callback
if ( ! s.async || xhr.readyState === 4 ) {
-
+
callback();
-
+
} else {
-
- // Listener is externalized to handle abort on unload
- handle = xhrPollingId++;
+
+ // Add to list of active xhrs
+ handle = xhrId++;
xhrs[ handle ] = xhr;
- xhr.onreadystatechange = function() {
- callback();
- };
- }
+ xhr.onreadystatechange = callback;
+ }
},
-
- abort: function(statusText) {
+
+ abort: function() {
if ( callback ) {
- callback(statusText);
+ callback(0,1);
}
}
};
}
});
-// #5280: we need to abort on unload or IE will keep connections alive
-jQuery(window).bind( "unload" , function() {
-
- // Abort all pending requests
- jQuery.each(xhrs, function(_, xhr) {
- if ( xhr.onreadystatechange ) {
- xhr.onreadystatechange( xhrUnloadAbortMarker );
- }
- });
-
- // Resest polling structure to be safe
- xhrs = {};
-
-});
-
})( jQuery );
diff --git a/src/attributes.js b/src/attributes.js
index 78b1bfd20..fec132340 100644
--- a/src/attributes.js
+++ b/src/attributes.js
@@ -182,7 +182,7 @@ jQuery.fn.extend({
var option = options[ i ];
// Don't return options that are disabled or in a disabled optgroup
- if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
+ if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
// Get the specific value for the option
diff --git a/src/core.js b/src/core.js
index 346e52d70..4361577e2 100644
--- a/src/core.js
+++ b/src/core.js
@@ -56,12 +56,12 @@ var jQuery = function( selector, context ) {
// For matching the engine and version of the browser
browserMatch,
-
+
// Has the ready events already been bound?
readyBound = false,
-
- // The functions to execute on DOM ready
- readyList = [],
+
+ // The deferred used on DOM ready
+ readyList,
// The ready event handler
DOMContentLoaded,
@@ -73,7 +73,7 @@ var jQuery = function( selector, context ) {
slice = Array.prototype.slice,
trim = String.prototype.trim,
indexOf = Array.prototype.indexOf,
-
+
// [[Class]] -> type pairs
class2type = {};
@@ -92,7 +92,7 @@ jQuery.fn = jQuery.prototype = {
this.length = 1;
return this;
}
-
+
// The body element only exists once, optimize finding it
if ( selector === "body" && !context && document.body ) {
this.context = document;
@@ -129,11 +129,11 @@ jQuery.fn = jQuery.prototype = {
} else {
ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
- selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes;
+ selector = (ret.cacheable ? jQuery(ret.fragment).clone()[0] : ret.fragment).childNodes;
}
-
+
return jQuery.merge( this, selector );
-
+
// HANDLE: $("#id")
} else {
elem = document.getElementById( match[2] );
@@ -226,7 +226,7 @@ jQuery.fn = jQuery.prototype = {
if ( jQuery.isArray( elems ) ) {
push.apply( ret, elems );
-
+
} else {
jQuery.merge( ret, elems );
}
@@ -252,25 +252,15 @@ jQuery.fn = jQuery.prototype = {
each: function( callback, args ) {
return jQuery.each( this, callback, args );
},
-
- ready: function( fn ) {
+
+ ready: function() {
// Attach the listeners
jQuery.bindReady();
- // If the DOM is already ready
- if ( jQuery.isReady ) {
- // Execute the function immediately
- fn.call( document, jQuery );
-
- // Otherwise, remember the function for later
- } else if ( readyList ) {
- // Add the function to the wait list
- readyList.push( fn );
- }
-
- return this;
+ // Change ready & apply
+ return ( jQuery.fn.ready = readyList.done ).apply( this , arguments );
},
-
+
eq: function( i ) {
return i === -1 ?
this.slice( i ) :
@@ -295,7 +285,7 @@ jQuery.fn = jQuery.prototype = {
return callback.call( elem, i, elem );
}));
},
-
+
end: function() {
return this.prevObject || jQuery(null);
},
@@ -384,14 +374,14 @@ jQuery.extend({
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
@@ -415,27 +405,15 @@ jQuery.extend({
}
// If there are functions bound, to execute
- if ( readyList ) {
- // Execute all of them
- var fn,
- i = 0,
- ready = readyList;
+ readyList.fire( document , [ jQuery ] );
- // Reset the list of functions
- readyList = null;
-
- while ( (fn = ready[ i++ ]) ) {
- fn.call( document, jQuery );
- }
-
- // Trigger any bound ready events
- if ( jQuery.fn.trigger ) {
- jQuery( document ).trigger( "ready" ).unbind( "ready" );
- }
+ // Trigger any bound ready events
+ if ( jQuery.fn.trigger ) {
+ jQuery( document ).trigger( "ready" ).unbind( "ready" );
}
}
},
-
+
bindReady: function() {
if ( readyBound ) {
return;
@@ -454,7 +432,7 @@ jQuery.extend({
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 );
@@ -463,7 +441,7 @@ jQuery.extend({
// 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 );
@@ -514,20 +492,20 @@ jQuery.extend({
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 );
},
@@ -537,11 +515,11 @@ jQuery.extend({
}
return true;
},
-
+
error: function( msg ) {
throw msg;
},
-
+
parseJSON: function( data ) {
if ( typeof data !== "string" || !data ) {
return null;
@@ -549,7 +527,7 @@ jQuery.extend({
// 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, "@")
@@ -566,6 +544,28 @@ jQuery.extend({
}
},
+ // Cross-browser xml parsing
+ // (xml & tmp used internally)
+ parseXML: function( data , xml , tmp ) {
+
+ if ( window.DOMParser ) { // Standard
+ tmp = new DOMParser();
+ xml = tmp.parseFromString( data , "text/xml" );
+ } else { // IE
+ xml = new ActiveXObject( "Microsoft.XMLDOM" );
+ xml.async = "false";
+ xml.loadXML( data );
+ }
+
+ tmp = xml.documentElement;
+
+ if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
+ jQuery.error( "Invalid XML: " + data );
+ }
+
+ return xml;
+ },
+
noop: function() {},
// Evalulates a script in a global context
@@ -691,7 +691,7 @@ jQuery.extend({
for ( var l = second.length; j < l; j++ ) {
first[ i++ ] = second[ j ];
}
-
+
} else {
while ( second[j] !== undefined ) {
first[ i++ ] = second[ j++ ];
@@ -772,7 +772,7 @@ jQuery.extend({
// 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 ) {
@@ -780,19 +780,19 @@ jQuery.extend({
}
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;
},
@@ -801,6 +801,151 @@ jQuery.extend({
return (new Date()).getTime();
},
+ // Create a simple deferred (one callbacks list)
+ _Deferred: function() {
+
+ var // callbacks list
+ callbacks = [],
+ // stored [ context , args ]
+ fired,
+ // to avoid firing when already doing so
+ firing,
+ // flag to know if the deferred has been cancelled
+ cancelled,
+ // the deferred itself
+ deferred = {
+
+ // done( f1, f2, ...)
+ done: function () {
+
+ if ( ! cancelled ) {
+
+ var args = arguments,
+ i,
+ length,
+ elem,
+ type,
+ _fired;
+
+ if ( fired ) {
+ _fired = fired;
+ fired = 0;
+ }
+
+ for ( i = 0, length = args.length ; i < length ; i++ ) {
+ elem = args[ i ];
+ type = jQuery.type( elem );
+ if ( type === "array" ) {
+ deferred.done.apply( deferred , elem );
+ } else if ( type === "function" ) {
+ callbacks.push( elem );
+ }
+ }
+
+ if ( _fired ) {
+ deferred.fire( _fired[ 0 ] , _fired[ 1 ] );
+ }
+ }
+
+ return this;
+ },
+
+ // resolve with given context and args
+ fire: function( context , args ) {
+ if ( ! cancelled && ! fired && ! firing ) {
+
+ firing = 1;
+
+ try {
+ while( callbacks[ 0 ] ) {
+ callbacks.shift().apply( context , args );
+ }
+ }
+ finally {
+ fired = [ context , args ];
+ firing = 0;
+ }
+ }
+ return this;
+ },
+
+ // resolve with this as context and given arguments
+ resolve: function() {
+ deferred.fire( jQuery.isFunction( this.promise ) ? this.promise() : this , arguments );
+ return this;
+ },
+
+ // Has this deferred been resolved?
+ isResolved: function() {
+ return !!( firing || fired );
+ },
+
+ // Cancel
+ cancel: function() {
+ cancelled = 1;
+ callbacks = [];
+ return this;
+ }
+ };
+
+ return deferred;
+ },
+
+ // Full fledged deferred (two callbacks list)
+ // Typical success/error system
+ Deferred: function( func ) {
+
+ var deferred = jQuery._Deferred(),
+ failDeferred = jQuery._Deferred();
+
+ // Add errorDeferred methods and redefine cancel
+ jQuery.extend( deferred , {
+
+ then: function( doneCallbacks , failCallbacks ) {
+ deferred.done( doneCallbacks ).fail( failCallbacks );
+ return this;
+ },
+ fail: failDeferred.done,
+ 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 done fail isResolved isRejected".split( " " ) , function( _ , method ) {
+ obj[ method ] = deferred[ method ];
+ });
+ obj.promise = function() {
+ return obj;
+ };
+ return obj;
+ }
+
+ } );
+
+ // Make sure only one callback list will be used
+ deferred.then( failDeferred.cancel , deferred.cancel );
+
+ // Unexpose cancel
+ delete deferred.cancel;
+
+ // Call given func if any
+ if ( func ) {
+ func.call( deferred , deferred );
+ }
+
+ return deferred;
+ },
+
+ // Deferred helper
+ when: function( object ) {
+ object = object && jQuery.isFunction( object.promise ) ?
+ object :
+ jQuery.Deferred().resolve( object );
+ return object.promise();
+ },
+
// Use of jQuery.browser is frowned upon.
// More details: http://docs.jquery.com/Utilities/jQuery.browser
uaMatch: function( ua ) {
@@ -818,6 +963,9 @@ jQuery.extend({
browser: {}
});
+// Create readyList deferred
+readyList = jQuery._Deferred();
+
// Populate the class2type map
jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
class2type[ "[object " + name + "]" ] = name.toLowerCase();
diff --git a/src/css.js b/src/css.js
index 8a83c6072..a6e2bb614 100644
--- a/src/css.js
+++ b/src/css.js
@@ -12,9 +12,6 @@ var ralpha = /alpha\([^)]*\)/i,
cssHeight = [ "Top", "Bottom" ],
curCSS,
- getComputedStyle,
- currentStyle,
-
fcamelCase = function( all, letter ) {
return letter.toUpperCase();
};
@@ -172,10 +169,6 @@ jQuery.each(["height", "width"], function( i, name ) {
if ( val <= 0 ) {
val = curCSS( elem, name, name );
- if ( val === "0px" && currentStyle ) {
- val = currentStyle( elem, name, name );
- }
-
if ( val != null ) {
// Should return "auto" instead of 0, use 0 for
// temporary backwards-compat
@@ -241,7 +234,7 @@ if ( !jQuery.support.opacity ) {
}
if ( document.defaultView && document.defaultView.getComputedStyle ) {
- getComputedStyle = function( elem, newName, name ) {
+ curCSS = function( elem, newName, name ) {
var ret, defaultView, computedStyle;
name = name.replace( rupper, "-$1" ).toLowerCase();
@@ -259,10 +252,8 @@ if ( document.defaultView && document.defaultView.getComputedStyle ) {
return ret;
};
-}
-
-if ( document.documentElement.currentStyle ) {
- currentStyle = function( elem, name ) {
+} else if ( document.documentElement.currentStyle ) {
+ curCSS = function( elem, name ) {
var left, rsLeft,
ret = elem.currentStyle && elem.currentStyle[ name ],
style = elem.style;
@@ -291,8 +282,6 @@ if ( document.documentElement.currentStyle ) {
};
}
-curCSS = getComputedStyle || currentStyle;
-
function getWH( elem, name, extra ) {
var which = name === "width" ? cssWidth : cssHeight,
val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
diff --git a/src/data.js b/src/data.js
index f1e031fff..4d1d1bd55 100644
--- a/src/data.js
+++ b/src/data.js
@@ -9,8 +9,9 @@ jQuery.extend({
// Please use with caution
uuid: 0,
- // Unique for each copy of jQuery on the page
- expando: "jQuery" + jQuery.now(),
+ // Unique for each copy of jQuery on the page
+ // Non-digits removed to match rinlinejQuery
+ expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
// The following elements throw uncatchable exceptions if you
// attempt to add expando properties to them.
@@ -21,6 +22,14 @@ jQuery.extend({
"applet": true
},
+ hasData: function( elem ) {
+ if ( elem.nodeType ) {
+ elem = jQuery.cache[ elem[jQuery.expando] ];
+ }
+
+ return !!elem && !jQuery.isEmptyObject(elem);
+ },
+
data: function( elem, name, data ) {
if ( !jQuery.acceptData( elem ) ) {
return;
@@ -144,7 +153,7 @@ jQuery.fn.extend({
var attr = this[0].attributes, name;
for ( var i = 0, l = attr.length; i < l; i++ ) {
name = attr[i].name;
-
+
if ( name.indexOf( "data-" ) === 0 ) {
name = name.substr( 5 );
dataAttr( this[0], name, data[ name ] );
diff --git a/src/dimensions.js b/src/dimensions.js
index b4dae83c4..a292899b9 100644
--- a/src/dimensions.js
+++ b/src/dimensions.js
@@ -25,7 +25,7 @@ jQuery.each([ "Height", "Width" ], function( i, name ) {
if ( !elem ) {
return size == null ? null : this;
}
-
+
if ( jQuery.isFunction( size ) ) {
return this.each(function( i ) {
var self = jQuery( this );
diff --git a/src/effects.js b/src/effects.js
index 600707427..bd57ffc3d 100644
--- a/src/effects.js
+++ b/src/effects.js
@@ -61,7 +61,7 @@ jQuery.fn.extend({
} else {
for ( var i = 0, j = this.length; i < j; i++ ) {
var display = jQuery.css( this[i], "display" );
-
+
if ( display !== "none" && !jQuery.data( this[i], "olddisplay" ) ) {
jQuery.data( this[i], "olddisplay", display );
}
@@ -337,7 +337,7 @@ jQuery.fx.prototype = {
}
var r = parseFloat( jQuery.css( this.elem, this.prop ) );
- return r && r > -10000 ? r : 0;
+ return r || 0;
},
// Start an animation from one number to another
diff --git a/src/event.js b/src/event.js
index fd470e718..675e5fff3 100644
--- a/src/event.js
+++ b/src/event.js
@@ -63,7 +63,7 @@ jQuery.event = {
var eventKey = elem.nodeType ? "events" : "__events__",
events = elemData[ eventKey ],
eventHandle = elemData.handle;
-
+
if ( typeof events === "function" ) {
// On plain objects events is a fn that holds the the data
// which prevents this data from being JSON serialized
@@ -143,9 +143,9 @@ jQuery.event = {
}
}
}
-
- if ( special.add ) {
- special.add.call( elem, handleObj );
+
+ if ( special.add ) {
+ special.add.call( elem, handleObj );
if ( !handleObj.handler.guid ) {
handleObj.handler.guid = handler.guid;
@@ -184,7 +184,7 @@ jQuery.event = {
if ( !elemData || !events ) {
return;
}
-
+
if ( typeof events === "function" ) {
elemData = events;
events = events.events;
@@ -222,7 +222,7 @@ jQuery.event = {
namespaces = type.split(".");
type = namespaces.shift();
- namespace = new RegExp("(^|\\.)" +
+ namespace = new RegExp("(^|\\.)" +
jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
}
@@ -384,7 +384,7 @@ jQuery.event = {
isClick = jQuery.nodeName( target, "a" ) && targetType === "click",
special = jQuery.event.special[ targetType ] || {};
- if ( (!special._default || special._default.call( elem, event ) === false) &&
+ if ( (!special._default || special._default.call( elem, event ) === false) &&
!isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
try {
@@ -454,7 +454,7 @@ jQuery.event = {
event.handler = handleObj.handler;
event.data = handleObj.data;
event.handleObj = handleObj;
-
+
var ret = handleObj.handler.apply( this, args );
if ( ret !== undefined ) {
@@ -553,7 +553,7 @@ jQuery.event = {
add: function( handleObj ) {
jQuery.event.add( this,
liveConvert( handleObj.origType, handleObj.selector ),
- jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
+ jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
},
remove: function( handleObj ) {
@@ -583,7 +583,7 @@ jQuery.removeEvent = document.removeEventListener ?
if ( elem.removeEventListener ) {
elem.removeEventListener( type, handle, false );
}
- } :
+ } :
function( elem, type, handle ) {
if ( elem.detachEvent ) {
elem.detachEvent( "on" + type, handle );
@@ -600,6 +600,12 @@ jQuery.Event = function( src ) {
if ( src && src.type ) {
this.originalEvent = src;
this.type = src.type;
+
+ // Events bubbling up the document may have been marked as prevented
+ // by a handler lower down the tree; reflect the correct value.
+ this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
+ src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
+
// Event type
} else {
this.type = src;
@@ -630,7 +636,7 @@ jQuery.Event.prototype = {
if ( !e ) {
return;
}
-
+
// if preventDefault exists run it on the original event
if ( e.preventDefault ) {
e.preventDefault();
@@ -726,7 +732,7 @@ if ( !jQuery.support.submitBubbles ) {
return trigger( "submit", this, arguments );
}
});
-
+
jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
var elem = e.target,
type = elem.type;
@@ -788,7 +794,7 @@ if ( !jQuery.support.changeBubbles ) {
if ( e.type !== "focusout" || elem.type !== "radio" ) {
jQuery.data( elem, "_change_data", val );
}
-
+
if ( data === undefined || val === data ) {
return;
}
@@ -802,7 +808,7 @@ if ( !jQuery.support.changeBubbles ) {
jQuery.event.special.change = {
filters: {
- focusout: testChange,
+ focusout: testChange,
beforedeactivate: testChange,
@@ -873,15 +879,15 @@ if ( document.addEventListener ) {
if ( focusCounts[fix]++ === 0 ) {
document.addEventListener( orig, handler, true );
}
- },
- teardown: function() {
+ },
+ teardown: function() {
if ( --focusCounts[fix] === 0 ) {
document.removeEventListener( orig, handler, true );
}
}
};
- function handler( e ) {
+ function handler( e ) {
e = jQuery.event.fix( e );
e.type = fix;
return jQuery.event.trigger( e, null, e.target );
@@ -898,7 +904,7 @@ jQuery.each(["bind", "one"], function( i, name ) {
}
return this;
}
-
+
if ( jQuery.isFunction( data ) || data === false ) {
fn = data;
data = undefined;
@@ -938,20 +944,20 @@ jQuery.fn.extend({
return this;
},
-
+
delegate: function( selector, types, data, fn ) {
return this.live( types, data, fn, selector );
},
-
+
undelegate: function( selector, types, fn ) {
if ( arguments.length === 0 ) {
return this.unbind( "live" );
-
+
} else {
return this.die( types, null, fn, selector );
}
},
-
+
trigger: function( type, data ) {
return this.each(function() {
jQuery.event.trigger( type, data, this );
@@ -1008,12 +1014,12 @@ jQuery.each(["live", "die"], function( i, name ) {
var type, i = 0, match, namespaces, preType,
selector = origSelector || this.selector,
context = origSelector ? this : jQuery( this.context );
-
+
if ( typeof types === "object" && !types.preventDefault ) {
for ( var key in types ) {
context[ name ]( key, data, types[key], selector );
}
-
+
return this;
}
@@ -1060,7 +1066,7 @@ jQuery.each(["live", "die"], function( i, name ) {
context.unbind( "live." + liveConvert( type, selector ), fn );
}
}
-
+
return this;
};
});
@@ -1079,7 +1085,7 @@ function liveHandler( event ) {
if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
return;
}
-
+
if ( event.namespace ) {
namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
}
@@ -1177,21 +1183,4 @@ jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblcl
}
});
-// Prevent memory leaks in IE
-// Window isn't included so as not to unbind existing unload events
-// More info:
-// - http://isaacschlueter.com/2006/10/msie-memory-leaks/
-if ( window.attachEvent && !window.addEventListener ) {
- jQuery(window).bind("unload", function() {
- for ( var id in jQuery.cache ) {
- if ( jQuery.cache[ id ].handle ) {
- // Try/Catch is to handle iframes being unloaded, see #4280
- try {
- jQuery.event.remove( jQuery.cache[ id ].handle.elem );
- } catch(e) {}
- }
- }
- });
-}
-
})( jQuery );
diff --git a/src/intro.js b/src/intro.js
index cb15705a6..a75f3112f 100644
--- a/src/intro.js
+++ b/src/intro.js
@@ -11,7 +11,7 @@
* Copyright 2010, The Dojo Foundation
* Released under the MIT, BSD, and GPL Licenses.
*
- * Date:
+ * Date: @DATE
*/
(function( window, undefined ) {
diff --git a/src/manipulation.js b/src/manipulation.js
index 7dea3493c..cf533c818 100644
--- a/src/manipulation.js
+++ b/src/manipulation.js
@@ -370,14 +370,18 @@ function root( elem, cur ) {
}
function cloneCopyEvent(orig, ret) {
- var i = 0;
-
- ret.each(function() {
- if ( this.nodeType !== 1 || this.nodeName !== (orig[i] && orig[i].nodeName) ) {
+ ret.each(function (nodeIndex) {
+ if ( this.nodeType !== 1 || !jQuery.hasData(orig[nodeIndex]) ) {
return;
}
- var oldData = jQuery.data( orig[i++] ),
+ // XXX remove for 1.5 RC or merge back in if there is actually a reason for this check that has been
+ // unexposed by unit tests
+ if ( this.nodeName !== (orig[nodeIndex] && orig[nodeIndex].nodeName) ) {
+ throw "Cloned data mismatch";
+ }
+
+ var oldData = jQuery.data( orig[nodeIndex] ),
curData = jQuery.data( this, oldData ),
events = oldData && oldData.events;
@@ -386,8 +390,8 @@ function cloneCopyEvent(orig, ret) {
curData.events = {};
for ( var type in events ) {
- for ( var handler in events[ type ] ) {
- jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
+ for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
+ jQuery.event.add( this, type, events[ type ][ i ], events[ type ][ i ].data );
}
}
}
@@ -416,15 +420,29 @@ function cloneFixAttributes(src, dest) {
if ( nodeName === "object" ) {
dest.outerHTML = src.outerHTML;
- // IE6-8 fails to persist the checked state of a cloned checkbox
- // or radio button
- } else if ( nodeName === "input" && src.checked ) {
- dest.defaultChecked = dest.checked = src.checked;
+ } else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
+ // IE6-8 fails to persist the checked state of a cloned checkbox
+ // or radio button. Worse, IE6-7 fail to give the cloned element
+ // a checked appearance if the defaultChecked value isn't also set
+ if ( src.checked ) {
+ dest.defaultChecked = dest.checked = src.checked;
+ }
+
+ // IE6-7 get confused and end up setting the value of a cloned
+ // checkbox/radio button to an empty string instead of "on"
+ if ( dest.value !== src.value ) {
+ dest.value = src.value;
+ }
// IE6-8 fails to return the selected option to the default selected
// state when cloning options
} else if ( nodeName === "option" ) {
dest.selected = src.defaultSelected;
+
+ // IE6-8 fails to set the defaultValue to the correct value when
+ // cloning other types of input fields
+ } else if ( nodeName === "input" || nodeName === "textarea" ) {
+ dest.defaultValue = src.defaultValue;
}
// Event data gets referenced instead of copied if the expando
@@ -436,12 +454,12 @@ jQuery.buildFragment = function( args, nodes, scripts ) {
var fragment, cacheable, cacheresults,
doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
- // Only cache "small" (1/2 KB) strings that are associated with the main document
+ // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
// Cloning options loses the selected state, so don't cache them
// IE 6 doesn't like it when you put