|
0
|
1 define( [
|
|
|
2 "./core",
|
|
|
3 "./var/document",
|
|
|
4 "./var/isFunction",
|
|
|
5 "./var/rnothtmlwhite",
|
|
|
6 "./ajax/var/location",
|
|
|
7 "./ajax/var/nonce",
|
|
|
8 "./ajax/var/rquery",
|
|
|
9
|
|
|
10 "./core/init",
|
|
|
11 "./ajax/parseXML",
|
|
|
12 "./event/trigger",
|
|
|
13 "./deferred",
|
|
|
14 "./serialize" // jQuery.param
|
|
|
15 ], function( jQuery, document, isFunction, rnothtmlwhite, location, nonce, rquery ) {
|
|
|
16
|
|
|
17 "use strict";
|
|
|
18
|
|
|
19 var
|
|
|
20 r20 = /%20/g,
|
|
|
21 rhash = /#.*$/,
|
|
|
22 rantiCache = /([?&])_=[^&]*/,
|
|
|
23 rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
|
|
|
24
|
|
|
25 // #7653, #8125, #8152: local protocol detection
|
|
|
26 rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
|
|
|
27 rnoContent = /^(?:GET|HEAD)$/,
|
|
|
28 rprotocol = /^\/\//,
|
|
|
29
|
|
|
30 /* Prefilters
|
|
|
31 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
|
|
|
32 * 2) These are called:
|
|
|
33 * - BEFORE asking for a transport
|
|
|
34 * - AFTER param serialization (s.data is a string if s.processData is true)
|
|
|
35 * 3) key is the dataType
|
|
|
36 * 4) the catchall symbol "*" can be used
|
|
|
37 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
|
|
|
38 */
|
|
|
39 prefilters = {},
|
|
|
40
|
|
|
41 /* Transports bindings
|
|
|
42 * 1) key is the dataType
|
|
|
43 * 2) the catchall symbol "*" can be used
|
|
|
44 * 3) selection will start with transport dataType and THEN go to "*" if needed
|
|
|
45 */
|
|
|
46 transports = {},
|
|
|
47
|
|
|
48 // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
|
|
|
49 allTypes = "*/".concat( "*" ),
|
|
|
50
|
|
|
51 // Anchor tag for parsing the document origin
|
|
|
52 originAnchor = document.createElement( "a" );
|
|
|
53 originAnchor.href = location.href;
|
|
|
54
|
|
|
55 // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
|
|
|
56 function addToPrefiltersOrTransports( structure ) {
|
|
|
57
|
|
|
58 // dataTypeExpression is optional and defaults to "*"
|
|
|
59 return function( dataTypeExpression, func ) {
|
|
|
60
|
|
|
61 if ( typeof dataTypeExpression !== "string" ) {
|
|
|
62 func = dataTypeExpression;
|
|
|
63 dataTypeExpression = "*";
|
|
|
64 }
|
|
|
65
|
|
|
66 var dataType,
|
|
|
67 i = 0,
|
|
|
68 dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
|
|
|
69
|
|
|
70 if ( isFunction( func ) ) {
|
|
|
71
|
|
|
72 // For each dataType in the dataTypeExpression
|
|
|
73 while ( ( dataType = dataTypes[ i++ ] ) ) {
|
|
|
74
|
|
|
75 // Prepend if requested
|
|
|
76 if ( dataType[ 0 ] === "+" ) {
|
|
|
77 dataType = dataType.slice( 1 ) || "*";
|
|
|
78 ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
|
|
|
79
|
|
|
80 // Otherwise append
|
|
|
81 } else {
|
|
|
82 ( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
|
|
|
83 }
|
|
|
84 }
|
|
|
85 }
|
|
|
86 };
|
|
|
87 }
|
|
|
88
|
|
|
89 // Base inspection function for prefilters and transports
|
|
|
90 function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
|
|
|
91
|
|
|
92 var inspected = {},
|
|
|
93 seekingTransport = ( structure === transports );
|
|
|
94
|
|
|
95 function inspect( dataType ) {
|
|
|
96 var selected;
|
|
|
97 inspected[ dataType ] = true;
|
|
|
98 jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
|
|
|
99 var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
|
|
|
100 if ( typeof dataTypeOrTransport === "string" &&
|
|
|
101 !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
|
|
|
102
|
|
|
103 options.dataTypes.unshift( dataTypeOrTransport );
|
|
|
104 inspect( dataTypeOrTransport );
|
|
|
105 return false;
|
|
|
106 } else if ( seekingTransport ) {
|
|
|
107 return !( selected = dataTypeOrTransport );
|
|
|
108 }
|
|
|
109 } );
|
|
|
110 return selected;
|
|
|
111 }
|
|
|
112
|
|
|
113 return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
|
|
|
114 }
|
|
|
115
|
|
|
116 // A special extend for ajax options
|
|
|
117 // that takes "flat" options (not to be deep extended)
|
|
|
118 // Fixes #9887
|
|
|
119 function ajaxExtend( target, src ) {
|
|
|
120 var key, deep,
|
|
|
121 flatOptions = jQuery.ajaxSettings.flatOptions || {};
|
|
|
122
|
|
|
123 for ( key in src ) {
|
|
|
124 if ( src[ key ] !== undefined ) {
|
|
|
125 ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
|
|
|
126 }
|
|
|
127 }
|
|
|
128 if ( deep ) {
|
|
|
129 jQuery.extend( true, target, deep );
|
|
|
130 }
|
|
|
131
|
|
|
132 return target;
|
|
|
133 }
|
|
|
134
|
|
|
135 /* Handles responses to an ajax request:
|
|
|
136 * - finds the right dataType (mediates between content-type and expected dataType)
|
|
|
137 * - returns the corresponding response
|
|
|
138 */
|
|
|
139 function ajaxHandleResponses( s, jqXHR, responses ) {
|
|
|
140
|
|
|
141 var ct, type, finalDataType, firstDataType,
|
|
|
142 contents = s.contents,
|
|
|
143 dataTypes = s.dataTypes;
|
|
|
144
|
|
|
145 // Remove auto dataType and get content-type in the process
|
|
|
146 while ( dataTypes[ 0 ] === "*" ) {
|
|
|
147 dataTypes.shift();
|
|
|
148 if ( ct === undefined ) {
|
|
|
149 ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
|
|
|
150 }
|
|
|
151 }
|
|
|
152
|
|
|
153 // Check if we're dealing with a known content-type
|
|
|
154 if ( ct ) {
|
|
|
155 for ( type in contents ) {
|
|
|
156 if ( contents[ type ] && contents[ type ].test( ct ) ) {
|
|
|
157 dataTypes.unshift( type );
|
|
|
158 break;
|
|
|
159 }
|
|
|
160 }
|
|
|
161 }
|
|
|
162
|
|
|
163 // Check to see if we have a response for the expected dataType
|
|
|
164 if ( dataTypes[ 0 ] in responses ) {
|
|
|
165 finalDataType = dataTypes[ 0 ];
|
|
|
166 } else {
|
|
|
167
|
|
|
168 // Try convertible dataTypes
|
|
|
169 for ( type in responses ) {
|
|
|
170 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
|
|
|
171 finalDataType = type;
|
|
|
172 break;
|
|
|
173 }
|
|
|
174 if ( !firstDataType ) {
|
|
|
175 firstDataType = type;
|
|
|
176 }
|
|
|
177 }
|
|
|
178
|
|
|
179 // Or just use first one
|
|
|
180 finalDataType = finalDataType || firstDataType;
|
|
|
181 }
|
|
|
182
|
|
|
183 // If we found a dataType
|
|
|
184 // We add the dataType to the list if needed
|
|
|
185 // and return the corresponding response
|
|
|
186 if ( finalDataType ) {
|
|
|
187 if ( finalDataType !== dataTypes[ 0 ] ) {
|
|
|
188 dataTypes.unshift( finalDataType );
|
|
|
189 }
|
|
|
190 return responses[ finalDataType ];
|
|
|
191 }
|
|
|
192 }
|
|
|
193
|
|
|
194 /* Chain conversions given the request and the original response
|
|
|
195 * Also sets the responseXXX fields on the jqXHR instance
|
|
|
196 */
|
|
|
197 function ajaxConvert( s, response, jqXHR, isSuccess ) {
|
|
|
198 var conv2, current, conv, tmp, prev,
|
|
|
199 converters = {},
|
|
|
200
|
|
|
201 // Work with a copy of dataTypes in case we need to modify it for conversion
|
|
|
202 dataTypes = s.dataTypes.slice();
|
|
|
203
|
|
|
204 // Create converters map with lowercased keys
|
|
|
205 if ( dataTypes[ 1 ] ) {
|
|
|
206 for ( conv in s.converters ) {
|
|
|
207 converters[ conv.toLowerCase() ] = s.converters[ conv ];
|
|
|
208 }
|
|
|
209 }
|
|
|
210
|
|
|
211 current = dataTypes.shift();
|
|
|
212
|
|
|
213 // Convert to each sequential dataType
|
|
|
214 while ( current ) {
|
|
|
215
|
|
|
216 if ( s.responseFields[ current ] ) {
|
|
|
217 jqXHR[ s.responseFields[ current ] ] = response;
|
|
|
218 }
|
|
|
219
|
|
|
220 // Apply the dataFilter if provided
|
|
|
221 if ( !prev && isSuccess && s.dataFilter ) {
|
|
|
222 response = s.dataFilter( response, s.dataType );
|
|
|
223 }
|
|
|
224
|
|
|
225 prev = current;
|
|
|
226 current = dataTypes.shift();
|
|
|
227
|
|
|
228 if ( current ) {
|
|
|
229
|
|
|
230 // There's only work to do if current dataType is non-auto
|
|
|
231 if ( current === "*" ) {
|
|
|
232
|
|
|
233 current = prev;
|
|
|
234
|
|
|
235 // Convert response if prev dataType is non-auto and differs from current
|
|
|
236 } else if ( prev !== "*" && prev !== current ) {
|
|
|
237
|
|
|
238 // Seek a direct converter
|
|
|
239 conv = converters[ prev + " " + current ] || converters[ "* " + current ];
|
|
|
240
|
|
|
241 // If none found, seek a pair
|
|
|
242 if ( !conv ) {
|
|
|
243 for ( conv2 in converters ) {
|
|
|
244
|
|
|
245 // If conv2 outputs current
|
|
|
246 tmp = conv2.split( " " );
|
|
|
247 if ( tmp[ 1 ] === current ) {
|
|
|
248
|
|
|
249 // If prev can be converted to accepted input
|
|
|
250 conv = converters[ prev + " " + tmp[ 0 ] ] ||
|
|
|
251 converters[ "* " + tmp[ 0 ] ];
|
|
|
252 if ( conv ) {
|
|
|
253
|
|
|
254 // Condense equivalence converters
|
|
|
255 if ( conv === true ) {
|
|
|
256 conv = converters[ conv2 ];
|
|
|
257
|
|
|
258 // Otherwise, insert the intermediate dataType
|
|
|
259 } else if ( converters[ conv2 ] !== true ) {
|
|
|
260 current = tmp[ 0 ];
|
|
|
261 dataTypes.unshift( tmp[ 1 ] );
|
|
|
262 }
|
|
|
263 break;
|
|
|
264 }
|
|
|
265 }
|
|
|
266 }
|
|
|
267 }
|
|
|
268
|
|
|
269 // Apply converter (if not an equivalence)
|
|
|
270 if ( conv !== true ) {
|
|
|
271
|
|
|
272 // Unless errors are allowed to bubble, catch and return them
|
|
|
273 if ( conv && s.throws ) {
|
|
|
274 response = conv( response );
|
|
|
275 } else {
|
|
|
276 try {
|
|
|
277 response = conv( response );
|
|
|
278 } catch ( e ) {
|
|
|
279 return {
|
|
|
280 state: "parsererror",
|
|
|
281 error: conv ? e : "No conversion from " + prev + " to " + current
|
|
|
282 };
|
|
|
283 }
|
|
|
284 }
|
|
|
285 }
|
|
|
286 }
|
|
|
287 }
|
|
|
288 }
|
|
|
289
|
|
|
290 return { state: "success", data: response };
|
|
|
291 }
|
|
|
292
|
|
|
293 jQuery.extend( {
|
|
|
294
|
|
|
295 // Counter for holding the number of active queries
|
|
|
296 active: 0,
|
|
|
297
|
|
|
298 // Last-Modified header cache for next request
|
|
|
299 lastModified: {},
|
|
|
300 etag: {},
|
|
|
301
|
|
|
302 ajaxSettings: {
|
|
|
303 url: location.href,
|
|
|
304 type: "GET",
|
|
|
305 isLocal: rlocalProtocol.test( location.protocol ),
|
|
|
306 global: true,
|
|
|
307 processData: true,
|
|
|
308 async: true,
|
|
|
309 contentType: "application/x-www-form-urlencoded; charset=UTF-8",
|
|
|
310
|
|
|
311 /*
|
|
|
312 timeout: 0,
|
|
|
313 data: null,
|
|
|
314 dataType: null,
|
|
|
315 username: null,
|
|
|
316 password: null,
|
|
|
317 cache: null,
|
|
|
318 throws: false,
|
|
|
319 traditional: false,
|
|
|
320 headers: {},
|
|
|
321 */
|
|
|
322
|
|
|
323 accepts: {
|
|
|
324 "*": allTypes,
|
|
|
325 text: "text/plain",
|
|
|
326 html: "text/html",
|
|
|
327 xml: "application/xml, text/xml",
|
|
|
328 json: "application/json, text/javascript"
|
|
|
329 },
|
|
|
330
|
|
|
331 contents: {
|
|
|
332 xml: /\bxml\b/,
|
|
|
333 html: /\bhtml/,
|
|
|
334 json: /\bjson\b/
|
|
|
335 },
|
|
|
336
|
|
|
337 responseFields: {
|
|
|
338 xml: "responseXML",
|
|
|
339 text: "responseText",
|
|
|
340 json: "responseJSON"
|
|
|
341 },
|
|
|
342
|
|
|
343 // Data converters
|
|
|
344 // Keys separate source (or catchall "*") and destination types with a single space
|
|
|
345 converters: {
|
|
|
346
|
|
|
347 // Convert anything to text
|
|
|
348 "* text": String,
|
|
|
349
|
|
|
350 // Text to html (true = no transformation)
|
|
|
351 "text html": true,
|
|
|
352
|
|
|
353 // Evaluate text as a json expression
|
|
|
354 "text json": JSON.parse,
|
|
|
355
|
|
|
356 // Parse text as xml
|
|
|
357 "text xml": jQuery.parseXML
|
|
|
358 },
|
|
|
359
|
|
|
360 // For options that shouldn't be deep extended:
|
|
|
361 // you can add your own custom options here if
|
|
|
362 // and when you create one that shouldn't be
|
|
|
363 // deep extended (see ajaxExtend)
|
|
|
364 flatOptions: {
|
|
|
365 url: true,
|
|
|
366 context: true
|
|
|
367 }
|
|
|
368 },
|
|
|
369
|
|
|
370 // Creates a full fledged settings object into target
|
|
|
371 // with both ajaxSettings and settings fields.
|
|
|
372 // If target is omitted, writes into ajaxSettings.
|
|
|
373 ajaxSetup: function( target, settings ) {
|
|
|
374 return settings ?
|
|
|
375
|
|
|
376 // Building a settings object
|
|
|
377 ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
|
|
|
378
|
|
|
379 // Extending ajaxSettings
|
|
|
380 ajaxExtend( jQuery.ajaxSettings, target );
|
|
|
381 },
|
|
|
382
|
|
|
383 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
|
|
|
384 ajaxTransport: addToPrefiltersOrTransports( transports ),
|
|
|
385
|
|
|
386 // Main method
|
|
|
387 ajax: function( url, options ) {
|
|
|
388
|
|
|
389 // If url is an object, simulate pre-1.5 signature
|
|
|
390 if ( typeof url === "object" ) {
|
|
|
391 options = url;
|
|
|
392 url = undefined;
|
|
|
393 }
|
|
|
394
|
|
|
395 // Force options to be an object
|
|
|
396 options = options || {};
|
|
|
397
|
|
|
398 var transport,
|
|
|
399
|
|
|
400 // URL without anti-cache param
|
|
|
401 cacheURL,
|
|
|
402
|
|
|
403 // Response headers
|
|
|
404 responseHeadersString,
|
|
|
405 responseHeaders,
|
|
|
406
|
|
|
407 // timeout handle
|
|
|
408 timeoutTimer,
|
|
|
409
|
|
|
410 // Url cleanup var
|
|
|
411 urlAnchor,
|
|
|
412
|
|
|
413 // Request state (becomes false upon send and true upon completion)
|
|
|
414 completed,
|
|
|
415
|
|
|
416 // To know if global events are to be dispatched
|
|
|
417 fireGlobals,
|
|
|
418
|
|
|
419 // Loop variable
|
|
|
420 i,
|
|
|
421
|
|
|
422 // uncached part of the url
|
|
|
423 uncached,
|
|
|
424
|
|
|
425 // Create the final options object
|
|
|
426 s = jQuery.ajaxSetup( {}, options ),
|
|
|
427
|
|
|
428 // Callbacks context
|
|
|
429 callbackContext = s.context || s,
|
|
|
430
|
|
|
431 // Context for global events is callbackContext if it is a DOM node or jQuery collection
|
|
|
432 globalEventContext = s.context &&
|
|
|
433 ( callbackContext.nodeType || callbackContext.jquery ) ?
|
|
|
434 jQuery( callbackContext ) :
|
|
|
435 jQuery.event,
|
|
|
436
|
|
|
437 // Deferreds
|
|
|
438 deferred = jQuery.Deferred(),
|
|
|
439 completeDeferred = jQuery.Callbacks( "once memory" ),
|
|
|
440
|
|
|
441 // Status-dependent callbacks
|
|
|
442 statusCode = s.statusCode || {},
|
|
|
443
|
|
|
444 // Headers (they are sent all at once)
|
|
|
445 requestHeaders = {},
|
|
|
446 requestHeadersNames = {},
|
|
|
447
|
|
|
448 // Default abort message
|
|
|
449 strAbort = "canceled",
|
|
|
450
|
|
|
451 // Fake xhr
|
|
|
452 jqXHR = {
|
|
|
453 readyState: 0,
|
|
|
454
|
|
|
455 // Builds headers hashtable if needed
|
|
|
456 getResponseHeader: function( key ) {
|
|
|
457 var match;
|
|
|
458 if ( completed ) {
|
|
|
459 if ( !responseHeaders ) {
|
|
|
460 responseHeaders = {};
|
|
|
461 while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
|
|
|
462 responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
|
|
|
463 }
|
|
|
464 }
|
|
|
465 match = responseHeaders[ key.toLowerCase() ];
|
|
|
466 }
|
|
|
467 return match == null ? null : match;
|
|
|
468 },
|
|
|
469
|
|
|
470 // Raw string
|
|
|
471 getAllResponseHeaders: function() {
|
|
|
472 return completed ? responseHeadersString : null;
|
|
|
473 },
|
|
|
474
|
|
|
475 // Caches the header
|
|
|
476 setRequestHeader: function( name, value ) {
|
|
|
477 if ( completed == null ) {
|
|
|
478 name = requestHeadersNames[ name.toLowerCase() ] =
|
|
|
479 requestHeadersNames[ name.toLowerCase() ] || name;
|
|
|
480 requestHeaders[ name ] = value;
|
|
|
481 }
|
|
|
482 return this;
|
|
|
483 },
|
|
|
484
|
|
|
485 // Overrides response content-type header
|
|
|
486 overrideMimeType: function( type ) {
|
|
|
487 if ( completed == null ) {
|
|
|
488 s.mimeType = type;
|
|
|
489 }
|
|
|
490 return this;
|
|
|
491 },
|
|
|
492
|
|
|
493 // Status-dependent callbacks
|
|
|
494 statusCode: function( map ) {
|
|
|
495 var code;
|
|
|
496 if ( map ) {
|
|
|
497 if ( completed ) {
|
|
|
498
|
|
|
499 // Execute the appropriate callbacks
|
|
|
500 jqXHR.always( map[ jqXHR.status ] );
|
|
|
501 } else {
|
|
|
502
|
|
|
503 // Lazy-add the new callbacks in a way that preserves old ones
|
|
|
504 for ( code in map ) {
|
|
|
505 statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
|
|
|
506 }
|
|
|
507 }
|
|
|
508 }
|
|
|
509 return this;
|
|
|
510 },
|
|
|
511
|
|
|
512 // Cancel the request
|
|
|
513 abort: function( statusText ) {
|
|
|
514 var finalText = statusText || strAbort;
|
|
|
515 if ( transport ) {
|
|
|
516 transport.abort( finalText );
|
|
|
517 }
|
|
|
518 done( 0, finalText );
|
|
|
519 return this;
|
|
|
520 }
|
|
|
521 };
|
|
|
522
|
|
|
523 // Attach deferreds
|
|
|
524 deferred.promise( jqXHR );
|
|
|
525
|
|
|
526 // Add protocol if not provided (prefilters might expect it)
|
|
|
527 // Handle falsy url in the settings object (#10093: consistency with old signature)
|
|
|
528 // We also use the url parameter if available
|
|
|
529 s.url = ( ( url || s.url || location.href ) + "" )
|
|
|
530 .replace( rprotocol, location.protocol + "//" );
|
|
|
531
|
|
|
532 // Alias method option to type as per ticket #12004
|
|
|
533 s.type = options.method || options.type || s.method || s.type;
|
|
|
534
|
|
|
535 // Extract dataTypes list
|
|
|
536 s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
|
|
|
537
|
|
|
538 // A cross-domain request is in order when the origin doesn't match the current origin.
|
|
|
539 if ( s.crossDomain == null ) {
|
|
|
540 urlAnchor = document.createElement( "a" );
|
|
|
541
|
|
|
542 // Support: IE <=8 - 11, Edge 12 - 15
|
|
|
543 // IE throws exception on accessing the href property if url is malformed,
|
|
|
544 // e.g. http://example.com:80x/
|
|
|
545 try {
|
|
|
546 urlAnchor.href = s.url;
|
|
|
547
|
|
|
548 // Support: IE <=8 - 11 only
|
|
|
549 // Anchor's host property isn't correctly set when s.url is relative
|
|
|
550 urlAnchor.href = urlAnchor.href;
|
|
|
551 s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
|
|
|
552 urlAnchor.protocol + "//" + urlAnchor.host;
|
|
|
553 } catch ( e ) {
|
|
|
554
|
|
|
555 // If there is an error parsing the URL, assume it is crossDomain,
|
|
|
556 // it can be rejected by the transport if it is invalid
|
|
|
557 s.crossDomain = true;
|
|
|
558 }
|
|
|
559 }
|
|
|
560
|
|
|
561 // Convert data if not already a string
|
|
|
562 if ( s.data && s.processData && typeof s.data !== "string" ) {
|
|
|
563 s.data = jQuery.param( s.data, s.traditional );
|
|
|
564 }
|
|
|
565
|
|
|
566 // Apply prefilters
|
|
|
567 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
|
|
|
568
|
|
|
569 // If request was aborted inside a prefilter, stop there
|
|
|
570 if ( completed ) {
|
|
|
571 return jqXHR;
|
|
|
572 }
|
|
|
573
|
|
|
574 // We can fire global events as of now if asked to
|
|
|
575 // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
|
|
|
576 fireGlobals = jQuery.event && s.global;
|
|
|
577
|
|
|
578 // Watch for a new set of requests
|
|
|
579 if ( fireGlobals && jQuery.active++ === 0 ) {
|
|
|
580 jQuery.event.trigger( "ajaxStart" );
|
|
|
581 }
|
|
|
582
|
|
|
583 // Uppercase the type
|
|
|
584 s.type = s.type.toUpperCase();
|
|
|
585
|
|
|
586 // Determine if request has content
|
|
|
587 s.hasContent = !rnoContent.test( s.type );
|
|
|
588
|
|
|
589 // Save the URL in case we're toying with the If-Modified-Since
|
|
|
590 // and/or If-None-Match header later on
|
|
|
591 // Remove hash to simplify url manipulation
|
|
|
592 cacheURL = s.url.replace( rhash, "" );
|
|
|
593
|
|
|
594 // More options handling for requests with no content
|
|
|
595 if ( !s.hasContent ) {
|
|
|
596
|
|
|
597 // Remember the hash so we can put it back
|
|
|
598 uncached = s.url.slice( cacheURL.length );
|
|
|
599
|
|
|
600 // If data is available and should be processed, append data to url
|
|
|
601 if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
|
|
|
602 cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
|
|
|
603
|
|
|
604 // #9682: remove data so that it's not used in an eventual retry
|
|
|
605 delete s.data;
|
|
|
606 }
|
|
|
607
|
|
|
608 // Add or update anti-cache param if needed
|
|
|
609 if ( s.cache === false ) {
|
|
|
610 cacheURL = cacheURL.replace( rantiCache, "$1" );
|
|
|
611 uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
|
|
|
612 }
|
|
|
613
|
|
|
614 // Put hash and anti-cache on the URL that will be requested (gh-1732)
|
|
|
615 s.url = cacheURL + uncached;
|
|
|
616
|
|
|
617 // Change '%20' to '+' if this is encoded form body content (gh-2658)
|
|
|
618 } else if ( s.data && s.processData &&
|
|
|
619 ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
|
|
|
620 s.data = s.data.replace( r20, "+" );
|
|
|
621 }
|
|
|
622
|
|
|
623 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
|
|
|
624 if ( s.ifModified ) {
|
|
|
625 if ( jQuery.lastModified[ cacheURL ] ) {
|
|
|
626 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
|
|
|
627 }
|
|
|
628 if ( jQuery.etag[ cacheURL ] ) {
|
|
|
629 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
|
|
|
630 }
|
|
|
631 }
|
|
|
632
|
|
|
633 // Set the correct header, if data is being sent
|
|
|
634 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
|
|
|
635 jqXHR.setRequestHeader( "Content-Type", s.contentType );
|
|
|
636 }
|
|
|
637
|
|
|
638 // Set the Accepts header for the server, depending on the dataType
|
|
|
639 jqXHR.setRequestHeader(
|
|
|
640 "Accept",
|
|
|
641 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
|
|
|
642 s.accepts[ s.dataTypes[ 0 ] ] +
|
|
|
643 ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
|
|
|
644 s.accepts[ "*" ]
|
|
|
645 );
|
|
|
646
|
|
|
647 // Check for headers option
|
|
|
648 for ( i in s.headers ) {
|
|
|
649 jqXHR.setRequestHeader( i, s.headers[ i ] );
|
|
|
650 }
|
|
|
651
|
|
|
652 // Allow custom headers/mimetypes and early abort
|
|
|
653 if ( s.beforeSend &&
|
|
|
654 ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
|
|
|
655
|
|
|
656 // Abort if not done already and return
|
|
|
657 return jqXHR.abort();
|
|
|
658 }
|
|
|
659
|
|
|
660 // Aborting is no longer a cancellation
|
|
|
661 strAbort = "abort";
|
|
|
662
|
|
|
663 // Install callbacks on deferreds
|
|
|
664 completeDeferred.add( s.complete );
|
|
|
665 jqXHR.done( s.success );
|
|
|
666 jqXHR.fail( s.error );
|
|
|
667
|
|
|
668 // Get transport
|
|
|
669 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
|
|
|
670
|
|
|
671 // If no transport, we auto-abort
|
|
|
672 if ( !transport ) {
|
|
|
673 done( -1, "No Transport" );
|
|
|
674 } else {
|
|
|
675 jqXHR.readyState = 1;
|
|
|
676
|
|
|
677 // Send global event
|
|
|
678 if ( fireGlobals ) {
|
|
|
679 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
|
|
|
680 }
|
|
|
681
|
|
|
682 // If request was aborted inside ajaxSend, stop there
|
|
|
683 if ( completed ) {
|
|
|
684 return jqXHR;
|
|
|
685 }
|
|
|
686
|
|
|
687 // Timeout
|
|
|
688 if ( s.async && s.timeout > 0 ) {
|
|
|
689 timeoutTimer = window.setTimeout( function() {
|
|
|
690 jqXHR.abort( "timeout" );
|
|
|
691 }, s.timeout );
|
|
|
692 }
|
|
|
693
|
|
|
694 try {
|
|
|
695 completed = false;
|
|
|
696 transport.send( requestHeaders, done );
|
|
|
697 } catch ( e ) {
|
|
|
698
|
|
|
699 // Rethrow post-completion exceptions
|
|
|
700 if ( completed ) {
|
|
|
701 throw e;
|
|
|
702 }
|
|
|
703
|
|
|
704 // Propagate others as results
|
|
|
705 done( -1, e );
|
|
|
706 }
|
|
|
707 }
|
|
|
708
|
|
|
709 // Callback for when everything is done
|
|
|
710 function done( status, nativeStatusText, responses, headers ) {
|
|
|
711 var isSuccess, success, error, response, modified,
|
|
|
712 statusText = nativeStatusText;
|
|
|
713
|
|
|
714 // Ignore repeat invocations
|
|
|
715 if ( completed ) {
|
|
|
716 return;
|
|
|
717 }
|
|
|
718
|
|
|
719 completed = true;
|
|
|
720
|
|
|
721 // Clear timeout if it exists
|
|
|
722 if ( timeoutTimer ) {
|
|
|
723 window.clearTimeout( timeoutTimer );
|
|
|
724 }
|
|
|
725
|
|
|
726 // Dereference transport for early garbage collection
|
|
|
727 // (no matter how long the jqXHR object will be used)
|
|
|
728 transport = undefined;
|
|
|
729
|
|
|
730 // Cache response headers
|
|
|
731 responseHeadersString = headers || "";
|
|
|
732
|
|
|
733 // Set readyState
|
|
|
734 jqXHR.readyState = status > 0 ? 4 : 0;
|
|
|
735
|
|
|
736 // Determine if successful
|
|
|
737 isSuccess = status >= 200 && status < 300 || status === 304;
|
|
|
738
|
|
|
739 // Get response data
|
|
|
740 if ( responses ) {
|
|
|
741 response = ajaxHandleResponses( s, jqXHR, responses );
|
|
|
742 }
|
|
|
743
|
|
|
744 // Convert no matter what (that way responseXXX fields are always set)
|
|
|
745 response = ajaxConvert( s, response, jqXHR, isSuccess );
|
|
|
746
|
|
|
747 // If successful, handle type chaining
|
|
|
748 if ( isSuccess ) {
|
|
|
749
|
|
|
750 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
|
|
|
751 if ( s.ifModified ) {
|
|
|
752 modified = jqXHR.getResponseHeader( "Last-Modified" );
|
|
|
753 if ( modified ) {
|
|
|
754 jQuery.lastModified[ cacheURL ] = modified;
|
|
|
755 }
|
|
|
756 modified = jqXHR.getResponseHeader( "etag" );
|
|
|
757 if ( modified ) {
|
|
|
758 jQuery.etag[ cacheURL ] = modified;
|
|
|
759 }
|
|
|
760 }
|
|
|
761
|
|
|
762 // if no content
|
|
|
763 if ( status === 204 || s.type === "HEAD" ) {
|
|
|
764 statusText = "nocontent";
|
|
|
765
|
|
|
766 // if not modified
|
|
|
767 } else if ( status === 304 ) {
|
|
|
768 statusText = "notmodified";
|
|
|
769
|
|
|
770 // If we have data, let's convert it
|
|
|
771 } else {
|
|
|
772 statusText = response.state;
|
|
|
773 success = response.data;
|
|
|
774 error = response.error;
|
|
|
775 isSuccess = !error;
|
|
|
776 }
|
|
|
777 } else {
|
|
|
778
|
|
|
779 // Extract error from statusText and normalize for non-aborts
|
|
|
780 error = statusText;
|
|
|
781 if ( status || !statusText ) {
|
|
|
782 statusText = "error";
|
|
|
783 if ( status < 0 ) {
|
|
|
784 status = 0;
|
|
|
785 }
|
|
|
786 }
|
|
|
787 }
|
|
|
788
|
|
|
789 // Set data for the fake xhr object
|
|
|
790 jqXHR.status = status;
|
|
|
791 jqXHR.statusText = ( nativeStatusText || statusText ) + "";
|
|
|
792
|
|
|
793 // Success/Error
|
|
|
794 if ( isSuccess ) {
|
|
|
795 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
|
|
|
796 } else {
|
|
|
797 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
|
|
|
798 }
|
|
|
799
|
|
|
800 // Status-dependent callbacks
|
|
|
801 jqXHR.statusCode( statusCode );
|
|
|
802 statusCode = undefined;
|
|
|
803
|
|
|
804 if ( fireGlobals ) {
|
|
|
805 globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
|
|
|
806 [ jqXHR, s, isSuccess ? success : error ] );
|
|
|
807 }
|
|
|
808
|
|
|
809 // Complete
|
|
|
810 completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
|
|
|
811
|
|
|
812 if ( fireGlobals ) {
|
|
|
813 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
|
|
|
814
|
|
|
815 // Handle the global AJAX counter
|
|
|
816 if ( !( --jQuery.active ) ) {
|
|
|
817 jQuery.event.trigger( "ajaxStop" );
|
|
|
818 }
|
|
|
819 }
|
|
|
820 }
|
|
|
821
|
|
|
822 return jqXHR;
|
|
|
823 },
|
|
|
824
|
|
|
825 getJSON: function( url, data, callback ) {
|
|
|
826 return jQuery.get( url, data, callback, "json" );
|
|
|
827 },
|
|
|
828
|
|
|
829 getScript: function( url, callback ) {
|
|
|
830 return jQuery.get( url, undefined, callback, "script" );
|
|
|
831 }
|
|
|
832 } );
|
|
|
833
|
|
|
834 jQuery.each( [ "get", "post" ], function( i, method ) {
|
|
|
835 jQuery[ method ] = function( url, data, callback, type ) {
|
|
|
836
|
|
|
837 // Shift arguments if data argument was omitted
|
|
|
838 if ( isFunction( data ) ) {
|
|
|
839 type = type || callback;
|
|
|
840 callback = data;
|
|
|
841 data = undefined;
|
|
|
842 }
|
|
|
843
|
|
|
844 // The url can be an options object (which then must have .url)
|
|
|
845 return jQuery.ajax( jQuery.extend( {
|
|
|
846 url: url,
|
|
|
847 type: method,
|
|
|
848 dataType: type,
|
|
|
849 data: data,
|
|
|
850 success: callback
|
|
|
851 }, jQuery.isPlainObject( url ) && url ) );
|
|
|
852 };
|
|
|
853 } );
|
|
|
854
|
|
|
855 return jQuery;
|
|
|
856 } );
|
