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