/base/000_base/node_modules/jquery/src/ajax.js |
@@ -0,0 +1,855 @@ |
define( [ |
"./core", |
"./var/document", |
"./var/rnothtmlwhite", |
"./ajax/var/location", |
"./ajax/var/nonce", |
"./ajax/var/rquery", |
|
"./core/init", |
"./ajax/parseXML", |
"./event/trigger", |
"./deferred", |
"./serialize" // jQuery.param |
], function( jQuery, document, rnothtmlwhite, location, nonce, rquery ) { |
|
"use strict"; |
|
var |
r20 = /%20/g, |
rhash = /#.*$/, |
rantiCache = /([?&])_=[^&]*/, |
rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, |
|
// #7653, #8125, #8152: local protocol detection |
rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, |
rnoContent = /^(?:GET|HEAD)$/, |
rprotocol = /^\/\//, |
|
/* Prefilters |
* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js 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) 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 = {}, |
|
// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression |
allTypes = "*/".concat( "*" ), |
|
// Anchor tag for parsing the document origin |
originAnchor = document.createElement( "a" ); |
originAnchor.href = location.href; |
|
// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport |
function addToPrefiltersOrTransports( structure ) { |
|
// dataTypeExpression is optional and defaults to "*" |
return function( dataTypeExpression, func ) { |
|
if ( typeof dataTypeExpression !== "string" ) { |
func = dataTypeExpression; |
dataTypeExpression = "*"; |
} |
|
var dataType, |
i = 0, |
dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; |
|
if ( jQuery.isFunction( func ) ) { |
|
// For each dataType in the dataTypeExpression |
while ( ( dataType = dataTypes[ i++ ] ) ) { |
|
// Prepend if requested |
if ( dataType[ 0 ] === "+" ) { |
dataType = dataType.slice( 1 ) || "*"; |
( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); |
|
// Otherwise append |
} else { |
( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); |
} |
} |
} |
}; |
} |
|
// Base inspection function for prefilters and transports |
function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { |
|
var inspected = {}, |
seekingTransport = ( structure === transports ); |
|
function inspect( dataType ) { |
var selected; |
inspected[ dataType ] = true; |
jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { |
var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); |
if ( typeof dataTypeOrTransport === "string" && |
!seekingTransport && !inspected[ dataTypeOrTransport ] ) { |
|
options.dataTypes.unshift( dataTypeOrTransport ); |
inspect( dataTypeOrTransport ); |
return false; |
} else if ( seekingTransport ) { |
return !( selected = dataTypeOrTransport ); |
} |
} ); |
return selected; |
} |
|
return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); |
} |
|
// A special extend for ajax options |
// that takes "flat" options (not to be deep extended) |
// Fixes #9887 |
function ajaxExtend( target, src ) { |
var key, deep, |
flatOptions = jQuery.ajaxSettings.flatOptions || {}; |
|
for ( key in src ) { |
if ( src[ key ] !== undefined ) { |
( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; |
} |
} |
if ( deep ) { |
jQuery.extend( true, target, deep ); |
} |
|
return target; |
} |
|
/* Handles responses to an ajax request: |
* - finds the right dataType (mediates between content-type and expected dataType) |
* - returns the corresponding response |
*/ |
function ajaxHandleResponses( s, jqXHR, responses ) { |
|
var ct, type, finalDataType, firstDataType, |
contents = s.contents, |
dataTypes = s.dataTypes; |
|
// Remove auto dataType and get content-type in the process |
while ( dataTypes[ 0 ] === "*" ) { |
dataTypes.shift(); |
if ( ct === undefined ) { |
ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); |
} |
} |
|
// Check if we're dealing with a known content-type |
if ( ct ) { |
for ( type in contents ) { |
if ( contents[ type ] && contents[ type ].test( ct ) ) { |
dataTypes.unshift( type ); |
break; |
} |
} |
} |
|
// Check to see if we have a response for the expected dataType |
if ( dataTypes[ 0 ] in responses ) { |
finalDataType = dataTypes[ 0 ]; |
} else { |
|
// Try convertible dataTypes |
for ( type in responses ) { |
if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { |
finalDataType = type; |
break; |
} |
if ( !firstDataType ) { |
firstDataType = type; |
} |
} |
|
// Or just use first one |
finalDataType = finalDataType || firstDataType; |
} |
|
// If we found a dataType |
// We add the dataType to the list if needed |
// and return the corresponding response |
if ( finalDataType ) { |
if ( finalDataType !== dataTypes[ 0 ] ) { |
dataTypes.unshift( finalDataType ); |
} |
return responses[ finalDataType ]; |
} |
} |
|
/* Chain conversions given the request and the original response |
* Also sets the responseXXX fields on the jqXHR instance |
*/ |
function ajaxConvert( s, response, jqXHR, isSuccess ) { |
var conv2, current, conv, tmp, prev, |
converters = {}, |
|
// Work with a copy of dataTypes in case we need to modify it for conversion |
dataTypes = s.dataTypes.slice(); |
|
// Create converters map with lowercased keys |
if ( dataTypes[ 1 ] ) { |
for ( conv in s.converters ) { |
converters[ conv.toLowerCase() ] = s.converters[ conv ]; |
} |
} |
|
current = dataTypes.shift(); |
|
// Convert to each sequential dataType |
while ( current ) { |
|
if ( s.responseFields[ current ] ) { |
jqXHR[ s.responseFields[ current ] ] = response; |
} |
|
// Apply the dataFilter if provided |
if ( !prev && isSuccess && s.dataFilter ) { |
response = s.dataFilter( response, s.dataType ); |
} |
|
prev = current; |
current = dataTypes.shift(); |
|
if ( current ) { |
|
// There's only work to do if current dataType is non-auto |
if ( current === "*" ) { |
|
current = prev; |
|
// Convert response if prev dataType is non-auto and differs from current |
} else if ( prev !== "*" && prev !== current ) { |
|
// Seek a direct converter |
conv = converters[ prev + " " + current ] || converters[ "* " + current ]; |
|
// If none found, seek a pair |
if ( !conv ) { |
for ( conv2 in converters ) { |
|
// If conv2 outputs current |
tmp = conv2.split( " " ); |
if ( tmp[ 1 ] === current ) { |
|
// If prev can be converted to accepted input |
conv = converters[ prev + " " + tmp[ 0 ] ] || |
converters[ "* " + tmp[ 0 ] ]; |
if ( conv ) { |
|
// Condense equivalence converters |
if ( conv === true ) { |
conv = converters[ conv2 ]; |
|
// Otherwise, insert the intermediate dataType |
} else if ( converters[ conv2 ] !== true ) { |
current = tmp[ 0 ]; |
dataTypes.unshift( tmp[ 1 ] ); |
} |
break; |
} |
} |
} |
} |
|
// Apply converter (if not an equivalence) |
if ( conv !== true ) { |
|
// Unless errors are allowed to bubble, catch and return them |
if ( conv && s.throws ) { |
response = conv( response ); |
} else { |
try { |
response = conv( response ); |
} catch ( e ) { |
return { |
state: "parsererror", |
error: conv ? e : "No conversion from " + prev + " to " + current |
}; |
} |
} |
} |
} |
} |
} |
|
return { state: "success", data: response }; |
} |
|
jQuery.extend( { |
|
// Counter for holding the number of active queries |
active: 0, |
|
// Last-Modified header cache for next request |
lastModified: {}, |
etag: {}, |
|
ajaxSettings: { |
url: location.href, |
type: "GET", |
isLocal: rlocalProtocol.test( location.protocol ), |
global: true, |
processData: true, |
async: true, |
contentType: "application/x-www-form-urlencoded; charset=UTF-8", |
|
/* |
timeout: 0, |
data: null, |
dataType: null, |
username: null, |
password: null, |
cache: null, |
throws: false, |
traditional: false, |
headers: {}, |
*/ |
|
accepts: { |
"*": allTypes, |
text: "text/plain", |
html: "text/html", |
xml: "application/xml, text/xml", |
json: "application/json, text/javascript" |
}, |
|
contents: { |
xml: /\bxml\b/, |
html: /\bhtml/, |
json: /\bjson\b/ |
}, |
|
responseFields: { |
xml: "responseXML", |
text: "responseText", |
json: "responseJSON" |
}, |
|
// Data converters |
// Keys separate source (or catchall "*") and destination types with a single space |
converters: { |
|
// Convert anything to text |
"* text": String, |
|
// Text to html (true = no transformation) |
"text html": true, |
|
// Evaluate text as a json expression |
"text json": JSON.parse, |
|
// Parse text as xml |
"text xml": jQuery.parseXML |
}, |
|
// For options that shouldn't be deep extended: |
// you can add your own custom options here if |
// and when you create one that shouldn't be |
// deep extended (see ajaxExtend) |
flatOptions: { |
url: true, |
context: true |
} |
}, |
|
// Creates a full fledged settings object into target |
// with both ajaxSettings and settings fields. |
// If target is omitted, writes into ajaxSettings. |
ajaxSetup: function( target, settings ) { |
return settings ? |
|
// Building a settings object |
ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : |
|
// Extending ajaxSettings |
ajaxExtend( jQuery.ajaxSettings, target ); |
}, |
|
ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), |
ajaxTransport: addToPrefiltersOrTransports( transports ), |
|
// Main method |
ajax: function( url, options ) { |
|
// If url is an object, simulate pre-1.5 signature |
if ( typeof url === "object" ) { |
options = url; |
url = undefined; |
} |
|
// Force options to be an object |
options = options || {}; |
|
var transport, |
|
// URL without anti-cache param |
cacheURL, |
|
// Response headers |
responseHeadersString, |
responseHeaders, |
|
// timeout handle |
timeoutTimer, |
|
// Url cleanup var |
urlAnchor, |
|
// Request state (becomes false upon send and true upon completion) |
completed, |
|
// To know if global events are to be dispatched |
fireGlobals, |
|
// Loop variable |
i, |
|
// uncached part of the url |
uncached, |
|
// Create the final options object |
s = jQuery.ajaxSetup( {}, options ), |
|
// Callbacks context |
callbackContext = s.context || s, |
|
// Context for global events is callbackContext if it is a DOM node or jQuery collection |
globalEventContext = s.context && |
( callbackContext.nodeType || callbackContext.jquery ) ? |
jQuery( callbackContext ) : |
jQuery.event, |
|
// Deferreds |
deferred = jQuery.Deferred(), |
completeDeferred = jQuery.Callbacks( "once memory" ), |
|
// Status-dependent callbacks |
statusCode = s.statusCode || {}, |
|
// Headers (they are sent all at once) |
requestHeaders = {}, |
requestHeadersNames = {}, |
|
// Default abort message |
strAbort = "canceled", |
|
// Fake xhr |
jqXHR = { |
readyState: 0, |
|
// Builds headers hashtable if needed |
getResponseHeader: function( key ) { |
var match; |
if ( completed ) { |
if ( !responseHeaders ) { |
responseHeaders = {}; |
while ( ( match = rheaders.exec( responseHeadersString ) ) ) { |
responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ]; |
} |
} |
match = responseHeaders[ key.toLowerCase() ]; |
} |
return match == null ? null : match; |
}, |
|
// Raw string |
getAllResponseHeaders: function() { |
return completed ? responseHeadersString : null; |
}, |
|
// Caches the header |
setRequestHeader: function( name, value ) { |
if ( completed == null ) { |
name = requestHeadersNames[ name.toLowerCase() ] = |
requestHeadersNames[ name.toLowerCase() ] || name; |
requestHeaders[ name ] = value; |
} |
return this; |
}, |
|
// Overrides response content-type header |
overrideMimeType: function( type ) { |
if ( completed == null ) { |
s.mimeType = type; |
} |
return this; |
}, |
|
// Status-dependent callbacks |
statusCode: function( map ) { |
var code; |
if ( map ) { |
if ( completed ) { |
|
// Execute the appropriate callbacks |
jqXHR.always( map[ jqXHR.status ] ); |
} else { |
|
// Lazy-add the new callbacks in a way that preserves old ones |
for ( code in map ) { |
statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; |
} |
} |
} |
return this; |
}, |
|
// Cancel the request |
abort: function( statusText ) { |
var finalText = statusText || strAbort; |
if ( transport ) { |
transport.abort( finalText ); |
} |
done( 0, finalText ); |
return this; |
} |
}; |
|
// Attach deferreds |
deferred.promise( jqXHR ); |
|
// Add protocol if not provided (prefilters might expect it) |
// Handle falsy url in the settings object (#10093: consistency with old signature) |
// We also use the url parameter if available |
s.url = ( ( url || s.url || location.href ) + "" ) |
.replace( rprotocol, location.protocol + "//" ); |
|
// Alias method option to type as per ticket #12004 |
s.type = options.method || options.type || s.method || s.type; |
|
// Extract dataTypes list |
s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; |
|
// A cross-domain request is in order when the origin doesn't match the current origin. |
if ( s.crossDomain == null ) { |
urlAnchor = document.createElement( "a" ); |
|
// Support: IE <=8 - 11, Edge 12 - 13 |
// IE throws exception on accessing the href property if url is malformed, |
// e.g. http://example.com:80x/ |
try { |
urlAnchor.href = s.url; |
|
// Support: IE <=8 - 11 only |
// Anchor's host property isn't correctly set when s.url is relative |
urlAnchor.href = urlAnchor.href; |
s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== |
urlAnchor.protocol + "//" + urlAnchor.host; |
} catch ( e ) { |
|
// If there is an error parsing the URL, assume it is crossDomain, |
// it can be rejected by the transport if it is invalid |
s.crossDomain = true; |
} |
} |
|
// Convert data if not already a string |
if ( s.data && s.processData && typeof s.data !== "string" ) { |
s.data = jQuery.param( s.data, s.traditional ); |
} |
|
// Apply prefilters |
inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); |
|
// If request was aborted inside a prefilter, stop there |
if ( completed ) { |
return jqXHR; |
} |
|
// We can fire global events as of now if asked to |
// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) |
fireGlobals = jQuery.event && s.global; |
|
// Watch for a new set of requests |
if ( fireGlobals && jQuery.active++ === 0 ) { |
jQuery.event.trigger( "ajaxStart" ); |
} |
|
// Uppercase the type |
s.type = s.type.toUpperCase(); |
|
// Determine if request has content |
s.hasContent = !rnoContent.test( s.type ); |
|
// Save the URL in case we're toying with the If-Modified-Since |
// and/or If-None-Match header later on |
// Remove hash to simplify url manipulation |
cacheURL = s.url.replace( rhash, "" ); |
|
// More options handling for requests with no content |
if ( !s.hasContent ) { |
|
// Remember the hash so we can put it back |
uncached = s.url.slice( cacheURL.length ); |
|
// If data is available, append data to url |
if ( s.data ) { |
cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; |
|
// #9682: remove data so that it's not used in an eventual retry |
delete s.data; |
} |
|
// Add or update anti-cache param if needed |
if ( s.cache === false ) { |
cacheURL = cacheURL.replace( rantiCache, "$1" ); |
uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached; |
} |
|
// Put hash and anti-cache on the URL that will be requested (gh-1732) |
s.url = cacheURL + uncached; |
|
// Change '%20' to '+' if this is encoded form body content (gh-2658) |
} else if ( s.data && s.processData && |
( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { |
s.data = s.data.replace( r20, "+" ); |
} |
|
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. |
if ( s.ifModified ) { |
if ( jQuery.lastModified[ cacheURL ] ) { |
jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); |
} |
if ( jQuery.etag[ cacheURL ] ) { |
jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); |
} |
} |
|
// Set the correct header, if data is being sent |
if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { |
jqXHR.setRequestHeader( "Content-Type", s.contentType ); |
} |
|
// Set the Accepts header for the server, depending on the dataType |
jqXHR.setRequestHeader( |
"Accept", |
s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? |
s.accepts[ s.dataTypes[ 0 ] ] + |
( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : |
s.accepts[ "*" ] |
); |
|
// Check for headers option |
for ( i in s.headers ) { |
jqXHR.setRequestHeader( i, s.headers[ i ] ); |
} |
|
// Allow custom headers/mimetypes and early abort |
if ( s.beforeSend && |
( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { |
|
// Abort if not done already and return |
return jqXHR.abort(); |
} |
|
// Aborting is no longer a cancellation |
strAbort = "abort"; |
|
// Install callbacks on deferreds |
completeDeferred.add( s.complete ); |
jqXHR.done( s.success ); |
jqXHR.fail( s.error ); |
|
// Get transport |
transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); |
|
// If no transport, we auto-abort |
if ( !transport ) { |
done( -1, "No Transport" ); |
} else { |
jqXHR.readyState = 1; |
|
// Send global event |
if ( fireGlobals ) { |
globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); |
} |
|
// If request was aborted inside ajaxSend, stop there |
if ( completed ) { |
return jqXHR; |
} |
|
// Timeout |
if ( s.async && s.timeout > 0 ) { |
timeoutTimer = window.setTimeout( function() { |
jqXHR.abort( "timeout" ); |
}, s.timeout ); |
} |
|
try { |
completed = false; |
transport.send( requestHeaders, done ); |
} catch ( e ) { |
|
// Rethrow post-completion exceptions |
if ( completed ) { |
throw e; |
} |
|
// Propagate others as results |
done( -1, e ); |
} |
} |
|
// Callback for when everything is done |
function done( status, nativeStatusText, responses, headers ) { |
var isSuccess, success, error, response, modified, |
statusText = nativeStatusText; |
|
// Ignore repeat invocations |
if ( completed ) { |
return; |
} |
|
completed = true; |
|
// Clear timeout if it exists |
if ( timeoutTimer ) { |
window.clearTimeout( timeoutTimer ); |
} |
|
// Dereference transport for early garbage collection |
// (no matter how long the jqXHR object will be used) |
transport = undefined; |
|
// Cache response headers |
responseHeadersString = headers || ""; |
|
// Set readyState |
jqXHR.readyState = status > 0 ? 4 : 0; |
|
// Determine if successful |
isSuccess = status >= 200 && status < 300 || status === 304; |
|
// Get response data |
if ( responses ) { |
response = ajaxHandleResponses( s, jqXHR, responses ); |
} |
|
// Convert no matter what (that way responseXXX fields are always set) |
response = ajaxConvert( s, response, jqXHR, isSuccess ); |
|
// If successful, handle type chaining |
if ( isSuccess ) { |
|
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. |
if ( s.ifModified ) { |
modified = jqXHR.getResponseHeader( "Last-Modified" ); |
if ( modified ) { |
jQuery.lastModified[ cacheURL ] = modified; |
} |
modified = jqXHR.getResponseHeader( "etag" ); |
if ( modified ) { |
jQuery.etag[ cacheURL ] = modified; |
} |
} |
|
// if no content |
if ( status === 204 || s.type === "HEAD" ) { |
statusText = "nocontent"; |
|
// if not modified |
} else if ( status === 304 ) { |
statusText = "notmodified"; |
|
// If we have data, let's convert it |
} else { |
statusText = response.state; |
success = response.data; |
error = response.error; |
isSuccess = !error; |
} |
} else { |
|
// Extract error from statusText and normalize for non-aborts |
error = statusText; |
if ( status || !statusText ) { |
statusText = "error"; |
if ( status < 0 ) { |
status = 0; |
} |
} |
} |
|
// Set data for the fake xhr object |
jqXHR.status = status; |
jqXHR.statusText = ( nativeStatusText || statusText ) + ""; |
|
// Success/Error |
if ( isSuccess ) { |
deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); |
} else { |
deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); |
} |
|
// Status-dependent callbacks |
jqXHR.statusCode( statusCode ); |
statusCode = undefined; |
|
if ( fireGlobals ) { |
globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", |
[ jqXHR, s, isSuccess ? success : error ] ); |
} |
|
// Complete |
completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); |
|
if ( fireGlobals ) { |
globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); |
|
// Handle the global AJAX counter |
if ( !( --jQuery.active ) ) { |
jQuery.event.trigger( "ajaxStop" ); |
} |
} |
} |
|
return jqXHR; |
}, |
|
getJSON: function( url, data, callback ) { |
return jQuery.get( url, data, callback, "json" ); |
}, |
|
getScript: function( url, callback ) { |
return jQuery.get( url, undefined, callback, "script" ); |
} |
} ); |
|
jQuery.each( [ "get", "post" ], function( i, method ) { |
jQuery[ method ] = function( url, data, callback, type ) { |
|
// Shift arguments if data argument was omitted |
if ( jQuery.isFunction( data ) ) { |
type = type || callback; |
callback = data; |
data = undefined; |
} |
|
// The url can be an options object (which then must have .url) |
return jQuery.ajax( jQuery.extend( { |
url: url, |
type: method, |
dataType: type, |
data: data, |
success: callback |
}, jQuery.isPlainObject( url ) && url ) ); |
}; |
} ); |
|
return jQuery; |
} ); |