mirror of
https://github.com/jquery/jquery.git
synced 2024-11-23 02:54:22 +00:00
405 lines
9.9 KiB
JavaScript
405 lines
9.9 KiB
JavaScript
(function( jQuery ) {
|
|
|
|
var rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
|
|
rselectTextarea = /^(?:select|textarea)/i,
|
|
rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
|
|
rbracket = /\[\]$/,
|
|
rquery = /\?/,
|
|
r20 = /%20/g,
|
|
|
|
// Keep a copy of the old load method
|
|
_load = jQuery.fn.load;
|
|
|
|
jQuery.fn.extend({
|
|
load: function( url, params, callback ) {
|
|
if ( typeof url !== "string" && _load ) {
|
|
return _load.apply( this, arguments );
|
|
|
|
// Don't do a request if no elements are being requested
|
|
} else if ( !this.length ) {
|
|
return this;
|
|
}
|
|
|
|
var off = url.indexOf(" ");
|
|
if ( off >= 0 ) {
|
|
var selector = url.slice(off, url.length);
|
|
url = url.slice(0, off);
|
|
}
|
|
|
|
// Default to a GET request
|
|
var type = "GET";
|
|
|
|
// If the second parameter was provided
|
|
if ( params ) {
|
|
// If it's a function
|
|
if ( jQuery.isFunction( params ) ) {
|
|
// We assume that it's the callback
|
|
callback = params;
|
|
params = null;
|
|
|
|
// Otherwise, build a param string
|
|
} else if ( typeof params === "object" ) {
|
|
params = jQuery.param( params, jQuery.ajaxSettings.traditional );
|
|
type = "POST";
|
|
}
|
|
}
|
|
|
|
var self = this;
|
|
|
|
// Request the remote document
|
|
jQuery.ajax({
|
|
url: url,
|
|
type: type,
|
|
dataType: "html",
|
|
data: params,
|
|
complete: function( res, status ) {
|
|
// If successful, inject the HTML into all the matched elements
|
|
if ( status === "success" || status === "notmodified" ) {
|
|
// See if a selector was specified
|
|
self.html( selector ?
|
|
// Create a dummy div to hold the results
|
|
jQuery("<div>")
|
|
// inject the contents of the document in, removing the scripts
|
|
// to avoid any 'Permission Denied' errors in IE
|
|
.append(res.responseText.replace(rscript, ""))
|
|
|
|
// Locate the specified elements
|
|
.find(selector) :
|
|
|
|
// If not, just inject the full result
|
|
res.responseText );
|
|
}
|
|
|
|
if ( callback ) {
|
|
self.each( callback, [res.responseText, status, res] );
|
|
}
|
|
}
|
|
});
|
|
|
|
return this;
|
|
},
|
|
|
|
serialize: function() {
|
|
return jQuery.param(this.serializeArray());
|
|
},
|
|
|
|
serializeArray: function() {
|
|
return this.map(function(){
|
|
return this.elements ? jQuery.makeArray(this.elements) : this;
|
|
})
|
|
.filter(function(){
|
|
return this.name && !this.disabled &&
|
|
(this.checked || rselectTextarea.test(this.nodeName) ||
|
|
rinput.test(this.type));
|
|
})
|
|
.map(function(i, elem){
|
|
var val = jQuery(this).val();
|
|
|
|
return val == null ?
|
|
null :
|
|
jQuery.isArray(val) ?
|
|
jQuery.map( val, function(val, i){
|
|
return {name: elem.name, value: val};
|
|
}) :
|
|
{name: elem.name, value: val};
|
|
}).get();
|
|
}
|
|
});
|
|
|
|
// Attach a bunch of functions for handling common AJAX events
|
|
jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function(i,o){
|
|
jQuery.fn[o] = function(f){
|
|
return this.bind(o, f);
|
|
};
|
|
});
|
|
|
|
jQuery.extend({
|
|
|
|
get: function( url, data, callback, type ) {
|
|
// shift arguments if data argument was omited
|
|
if ( jQuery.isFunction( data ) ) {
|
|
type = type || callback;
|
|
callback = data;
|
|
data = null;
|
|
}
|
|
|
|
return jQuery.ajax({
|
|
type: "GET",
|
|
url: url,
|
|
data: data,
|
|
success: callback,
|
|
dataType: type
|
|
});
|
|
},
|
|
|
|
getScript: function( url, callback ) {
|
|
return jQuery.get(url, null, callback, "script");
|
|
},
|
|
|
|
getJSON: function( url, data, callback ) {
|
|
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 );
|
|
},
|
|
|
|
ajaxSettings: {
|
|
url: location.href,
|
|
global: true,
|
|
type: "GET",
|
|
contentType: "application/x-www-form-urlencoded",
|
|
processData: true,
|
|
async: true,
|
|
/*
|
|
timeout: 0,
|
|
data: null,
|
|
dataType: null,
|
|
dataTypes: null,
|
|
username: null,
|
|
password: null,
|
|
cache: null,
|
|
traditional: false,
|
|
*/
|
|
xhr: function() {
|
|
return new window.XMLHttpRequest();
|
|
},
|
|
xhrResponseFields: {
|
|
xml: "XML",
|
|
text: "Text",
|
|
json: "JSON"
|
|
},
|
|
|
|
accepts: {
|
|
xml: "application/xml, text/xml",
|
|
html: "text/html",
|
|
text: "text/plain",
|
|
json: "application/json, text/javascript",
|
|
"*": "*/*"
|
|
},
|
|
|
|
autoDataType: {
|
|
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: [],
|
|
|
|
// 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");
|
|
}
|
|
}
|
|
},
|
|
|
|
// List of data converters
|
|
// 1) key format is "source_type => destination_type" (spaces required)
|
|
// 2) the catchall symbol "*" can be used for source_type
|
|
dataConverters: {
|
|
|
|
// Convert anything to text
|
|
"* => text": function(data) {
|
|
return "" + data;
|
|
},
|
|
|
|
// Text to html (no transformation)
|
|
"text => html": function(data) {
|
|
return data;
|
|
},
|
|
|
|
// Evaluate text as a json expression
|
|
"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;
|
|
}
|
|
}
|
|
},
|
|
|
|
// Main method
|
|
ajax: function( url , s ) {
|
|
|
|
if ( arguments.length === 1 ) {
|
|
s = url;
|
|
url = s ? s.url : undefined;
|
|
}
|
|
|
|
return jQuery.xhr().open( s ? s.type : undefined , url ).send( undefined , s );
|
|
|
|
},
|
|
|
|
// Serialize an array of form elements or a set of
|
|
// key/values into a query string
|
|
param: function( a, traditional ) {
|
|
var s = [],
|
|
add = function( key, value ) {
|
|
// If value is a function, invoke it and return its value
|
|
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.
|
|
for ( var prefix in a ) {
|
|
buildParams( prefix, a[prefix], traditional, add );
|
|
}
|
|
}
|
|
|
|
// Return the resulting serialization
|
|
return s.join("&").replace(r20, "+");
|
|
}
|
|
});
|
|
|
|
function buildParams( prefix, obj, traditional, add ) {
|
|
if ( jQuery.isArray(obj) && obj.length ) {
|
|
// Serialize array item.
|
|
jQuery.each( obj, function( i, v ) {
|
|
if ( traditional || rbracket.test( prefix ) ) {
|
|
// Treat each array item as a scalar.
|
|
add( prefix, v );
|
|
|
|
} else {
|
|
// If array item is non-scalar (array or object), encode its
|
|
// numeric index to resolve deserialization ambiguity issues.
|
|
// Note that rack (as of 1.0.0) can't currently deserialize
|
|
// nested arrays properly, and attempting to do so may cause
|
|
// a server error. Possible fixes are to modify rack's
|
|
// deserialization algorithm or to provide an option or flag
|
|
// to force array serialization to be shallow.
|
|
buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
|
|
}
|
|
});
|
|
|
|
} else if ( !traditional && obj != null && typeof obj === "object" ) {
|
|
if ( jQuery.isEmptyObject( obj ) ) {
|
|
add( prefix, "" );
|
|
|
|
// Serialize object item.
|
|
} else {
|
|
jQuery.each( obj, function( k, v ) {
|
|
buildParams( prefix + "[" + k + "]", v, traditional, add );
|
|
});
|
|
}
|
|
|
|
} else {
|
|
// Serialize scalar item.
|
|
add( prefix, obj );
|
|
}
|
|
}
|
|
|
|
// This is still on the jQuery object... for now
|
|
// Want to move this to jQuery.ajax some day
|
|
jQuery.extend({
|
|
|
|
// Counter for holding the number of active queries
|
|
active: 0,
|
|
|
|
// Last-Modified header cache for next request
|
|
lastModified: {},
|
|
etag: {}
|
|
|
|
});
|
|
|
|
/*
|
|
* Create the request object; Microsoft failed to properly
|
|
* implement the XMLHttpRequest in IE7 (can't request local files),
|
|
* so we use the ActiveXObject when it is available
|
|
* Additionally XMLHttpRequest can be disabled in IE7/IE8 so
|
|
* we need a fallback.
|
|
*/
|
|
if ( window.ActiveXObject ) {
|
|
jQuery.ajaxSettings.xhr = function() {
|
|
if ( window.location.protocol !== "file:" ) {
|
|
try {
|
|
return new window.XMLHttpRequest();
|
|
} catch( xhrError ) {}
|
|
}
|
|
|
|
try {
|
|
return new window.ActiveXObject("Microsoft.XMLHTTP");
|
|
} catch( activeError ) {}
|
|
};
|
|
}
|
|
|
|
var testXHR = jQuery.ajaxSettings.xhr();
|
|
|
|
// Does this browser support XHR requests?
|
|
jQuery.support.ajax = !!testXHR;
|
|
|
|
// Does this browser support crossDomain XHR requests
|
|
jQuery.support.cors = testXHR && "withCredentials" in testXHR;
|
|
|
|
})( jQuery );
|