scratch – Blame information for rev 125

Subversion Repositories:
Rev:
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 });