corrade-http-templates – Blame information for rev 57
?pathlinks?
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 57 | office | 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 | } ); |