fr_b02 / petri / doc / jquery / jquery-migrate-3.0.1.js @ 5
Historique | Voir | Annoter | Télécharger (17,423 ko)
1 |
/*!
|
---|---|
2 |
* jQuery Migrate - v3.0.1 - 2017-09-26
|
3 |
* Copyright jQuery Foundation and other contributors
|
4 |
*/
|
5 |
;( function( factory ) {
|
6 |
if ( typeof define === "function" && define.amd ) { |
7 |
|
8 |
// AMD. Register as an anonymous module.
|
9 |
define( [ "jquery" ], window, factory );
|
10 |
} else if ( typeof module === "object" && module.exports ) { |
11 |
|
12 |
// Node/CommonJS
|
13 |
// eslint-disable-next-line no-undef
|
14 |
module.exports = factory( require( "jquery" ), window );
|
15 |
} else {
|
16 |
|
17 |
// Browser globals
|
18 |
factory( jQuery, window ); |
19 |
} |
20 |
} )( function( jQuery, window ) {
|
21 |
"use strict";
|
22 |
|
23 |
|
24 |
jQuery.migrateVersion = "3.0.1";
|
25 |
|
26 |
jQuery.migrateMute = true;
|
27 |
|
28 |
/* exported migrateWarn, migrateWarnFunc, migrateWarnProp */
|
29 |
|
30 |
( function() {
|
31 |
|
32 |
var rbadVersions = /^[12]\./; |
33 |
|
34 |
// Support: IE9 only
|
35 |
// IE9 only creates console object when dev tools are first opened
|
36 |
// IE9 console is a host object, callable but doesn't have .apply()
|
37 |
if ( !window.console || !window.console.log ) {
|
38 |
return;
|
39 |
} |
40 |
|
41 |
// Need jQuery 3.0.0+ and no older Migrate loaded
|
42 |
if ( !jQuery || rbadVersions.test( jQuery.fn.jquery ) ) {
|
43 |
window.console.log( "JQMIGRATE: jQuery 3.0.0+ REQUIRED" );
|
44 |
} |
45 |
if ( jQuery.migrateWarnings ) {
|
46 |
window.console.log( "JQMIGRATE: Migrate plugin loaded multiple times" );
|
47 |
} |
48 |
|
49 |
// Show a message on the console so devs know we're active
|
50 |
window.console.log( "JQMIGRATE: Migrate is installed" +
|
51 |
( jQuery.migrateMute ? "" : " with logging active" ) + |
52 |
", version " + jQuery.migrateVersion );
|
53 |
|
54 |
} )(); |
55 |
|
56 |
var warnedAbout = {};
|
57 |
|
58 |
// List of warnings already given; public read only
|
59 |
jQuery.migrateWarnings = []; |
60 |
|
61 |
// Set to false to disable traces that appear with warnings
|
62 |
if ( jQuery.migrateTrace === undefined ) { |
63 |
jQuery.migrateTrace = true;
|
64 |
} |
65 |
|
66 |
// Forget any warnings we've already given; public
|
67 |
jQuery.migrateReset = function() { |
68 |
warnedAbout = {}; |
69 |
jQuery.migrateWarnings.length = 0;
|
70 |
}; |
71 |
|
72 |
function migrateWarn( msg ) { |
73 |
var console = window.console;
|
74 |
if ( !warnedAbout[ msg ] ) {
|
75 |
warnedAbout[ msg ] = true;
|
76 |
jQuery.migrateWarnings.push( msg ); |
77 |
if ( console && console.warn && !jQuery.migrateMute ) {
|
78 |
console.warn( "JQMIGRATE: " + msg );
|
79 |
if ( jQuery.migrateTrace && console.trace ) {
|
80 |
console.trace(); |
81 |
} |
82 |
} |
83 |
} |
84 |
} |
85 |
|
86 |
function migrateWarnProp( obj, prop, value, msg ) { |
87 |
Object.defineProperty( obj, prop, { |
88 |
configurable: true, |
89 |
enumerable: true, |
90 |
get: function() { |
91 |
migrateWarn( msg ); |
92 |
return value;
|
93 |
}, |
94 |
set: function( newValue ) { |
95 |
migrateWarn( msg ); |
96 |
value = newValue; |
97 |
} |
98 |
} ); |
99 |
} |
100 |
|
101 |
function migrateWarnFunc( obj, prop, newFunc, msg ) { |
102 |
obj[ prop ] = function() {
|
103 |
migrateWarn( msg ); |
104 |
return newFunc.apply( this, arguments ); |
105 |
}; |
106 |
} |
107 |
|
108 |
if ( window.document.compatMode === "BackCompat" ) { |
109 |
|
110 |
// JQuery has never supported or tested Quirks Mode
|
111 |
migrateWarn( "jQuery is not compatible with Quirks Mode" );
|
112 |
} |
113 |
|
114 |
|
115 |
var oldInit = jQuery.fn.init,
|
116 |
oldIsNumeric = jQuery.isNumeric, |
117 |
oldFind = jQuery.find, |
118 |
rattrHashTest = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/,
|
119 |
rattrHashGlob = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/g;
|
120 |
|
121 |
jQuery.fn.init = function( arg1 ) { |
122 |
var args = Array.prototype.slice.call( arguments ); |
123 |
|
124 |
if ( typeof arg1 === "string" && arg1 === "#" ) { |
125 |
|
126 |
// JQuery( "#" ) is a bogus ID selector, but it returned an empty set before jQuery 3.0
|
127 |
migrateWarn( "jQuery( '#' ) is not a valid selector" );
|
128 |
args[ 0 ] = [];
|
129 |
} |
130 |
|
131 |
return oldInit.apply( this, args ); |
132 |
}; |
133 |
jQuery.fn.init.prototype = jQuery.fn; |
134 |
|
135 |
jQuery.find = function( selector ) { |
136 |
var args = Array.prototype.slice.call( arguments ); |
137 |
|
138 |
// Support: PhantomJS 1.x
|
139 |
// String#match fails to match when used with a //g RegExp, only on some strings
|
140 |
if ( typeof selector === "string" && rattrHashTest.test( selector ) ) { |
141 |
|
142 |
// The nonstandard and undocumented unquoted-hash was removed in jQuery 1.12.0
|
143 |
// First see if qS thinks it's a valid selector, if so avoid a false positive
|
144 |
try {
|
145 |
window.document.querySelector( selector ); |
146 |
} catch ( err1 ) {
|
147 |
|
148 |
// Didn't *look* valid to qSA, warn and try quoting what we think is the value
|
149 |
selector = selector.replace( rattrHashGlob, function( _, attr, op, value ) {
|
150 |
return "[" + attr + op + "\"" + value + "\"]"; |
151 |
} ); |
152 |
|
153 |
// If the regexp *may* have created an invalid selector, don't update it
|
154 |
// Note that there may be false alarms if selector uses jQuery extensions
|
155 |
try {
|
156 |
window.document.querySelector( selector ); |
157 |
migrateWarn( "Attribute selector with '#' must be quoted: " + args[ 0 ] ); |
158 |
args[ 0 ] = selector;
|
159 |
} catch ( err2 ) {
|
160 |
migrateWarn( "Attribute selector with '#' was not fixed: " + args[ 0 ] ); |
161 |
} |
162 |
} |
163 |
} |
164 |
|
165 |
return oldFind.apply( this, args ); |
166 |
}; |
167 |
|
168 |
// Copy properties attached to original jQuery.find method (e.g. .attr, .isXML)
|
169 |
var findProp;
|
170 |
for ( findProp in oldFind ) { |
171 |
if ( Object.prototype.hasOwnProperty.call( oldFind, findProp ) ) {
|
172 |
jQuery.find[ findProp ] = oldFind[ findProp ]; |
173 |
} |
174 |
} |
175 |
|
176 |
// The number of elements contained in the matched element set
|
177 |
jQuery.fn.size = function() { |
178 |
migrateWarn( "jQuery.fn.size() is deprecated and removed; use the .length property" );
|
179 |
return this.length; |
180 |
}; |
181 |
|
182 |
jQuery.parseJSON = function() { |
183 |
migrateWarn( "jQuery.parseJSON is deprecated; use JSON.parse" );
|
184 |
return JSON.parse.apply( null, arguments ); |
185 |
}; |
186 |
|
187 |
jQuery.isNumeric = function( val ) { |
188 |
|
189 |
// The jQuery 2.2.3 implementation of isNumeric
|
190 |
function isNumeric2( obj ) { |
191 |
var realStringObj = obj && obj.toString();
|
192 |
return !jQuery.isArray( obj ) && ( realStringObj - parseFloat( realStringObj ) + 1 ) >= 0; |
193 |
} |
194 |
|
195 |
var newValue = oldIsNumeric( val ),
|
196 |
oldValue = isNumeric2( val ); |
197 |
|
198 |
if ( newValue !== oldValue ) {
|
199 |
migrateWarn( "jQuery.isNumeric() should not be called on constructed objects" );
|
200 |
} |
201 |
|
202 |
return oldValue;
|
203 |
}; |
204 |
|
205 |
migrateWarnFunc( jQuery, "holdReady", jQuery.holdReady,
|
206 |
"jQuery.holdReady is deprecated" );
|
207 |
|
208 |
migrateWarnFunc( jQuery, "unique", jQuery.uniqueSort,
|
209 |
"jQuery.unique is deprecated; use jQuery.uniqueSort" );
|
210 |
|
211 |
// Now jQuery.expr.pseudos is the standard incantation
|
212 |
migrateWarnProp( jQuery.expr, "filters", jQuery.expr.pseudos,
|
213 |
"jQuery.expr.filters is deprecated; use jQuery.expr.pseudos" );
|
214 |
migrateWarnProp( jQuery.expr, ":", jQuery.expr.pseudos,
|
215 |
"jQuery.expr[':'] is deprecated; use jQuery.expr.pseudos" );
|
216 |
|
217 |
|
218 |
var oldAjax = jQuery.ajax;
|
219 |
|
220 |
jQuery.ajax = function( ) { |
221 |
var jQXHR = oldAjax.apply( this, arguments ); |
222 |
|
223 |
// Be sure we got a jQXHR (e.g., not sync)
|
224 |
if ( jQXHR.promise ) {
|
225 |
migrateWarnFunc( jQXHR, "success", jQXHR.done,
|
226 |
"jQXHR.success is deprecated and removed" );
|
227 |
migrateWarnFunc( jQXHR, "error", jQXHR.fail,
|
228 |
"jQXHR.error is deprecated and removed" );
|
229 |
migrateWarnFunc( jQXHR, "complete", jQXHR.always,
|
230 |
"jQXHR.complete is deprecated and removed" );
|
231 |
} |
232 |
|
233 |
return jQXHR;
|
234 |
}; |
235 |
|
236 |
|
237 |
var oldRemoveAttr = jQuery.fn.removeAttr,
|
238 |
oldToggleClass = jQuery.fn.toggleClass, |
239 |
rmatchNonSpace = /\S+/g;
|
240 |
|
241 |
jQuery.fn.removeAttr = function( name ) { |
242 |
var self = this; |
243 |
|
244 |
jQuery.each( name.match( rmatchNonSpace ), function( i, attr ) {
|
245 |
if ( jQuery.expr.match.bool.test( attr ) ) {
|
246 |
migrateWarn( "jQuery.fn.removeAttr no longer sets boolean properties: " + attr );
|
247 |
self.prop( attr, false );
|
248 |
} |
249 |
} ); |
250 |
|
251 |
return oldRemoveAttr.apply( this, arguments ); |
252 |
}; |
253 |
|
254 |
jQuery.fn.toggleClass = function( state ) { |
255 |
|
256 |
// Only deprecating no-args or single boolean arg
|
257 |
if ( state !== undefined && typeof state !== "boolean" ) { |
258 |
return oldToggleClass.apply( this, arguments ); |
259 |
} |
260 |
|
261 |
migrateWarn( "jQuery.fn.toggleClass( boolean ) is deprecated" );
|
262 |
|
263 |
// Toggle entire class name of each element
|
264 |
return this.each( function() { |
265 |
var className = this.getAttribute && this.getAttribute( "class" ) || ""; |
266 |
|
267 |
if ( className ) {
|
268 |
jQuery.data( this, "__className__", className ); |
269 |
} |
270 |
|
271 |
// If the element has a class name or if we're passed `false`,
|
272 |
// then remove the whole classname (if there was one, the above saved it).
|
273 |
// Otherwise bring back whatever was previously saved (if anything),
|
274 |
// falling back to the empty string if nothing was stored.
|
275 |
if ( this.setAttribute ) { |
276 |
this.setAttribute( "class", |
277 |
className || state === false ?
|
278 |
"" :
|
279 |
jQuery.data( this, "__className__" ) || "" |
280 |
); |
281 |
} |
282 |
} ); |
283 |
}; |
284 |
|
285 |
|
286 |
var internalSwapCall = false; |
287 |
|
288 |
// If this version of jQuery has .swap(), don't false-alarm on internal uses
|
289 |
if ( jQuery.swap ) {
|
290 |
jQuery.each( [ "height", "width", "reliableMarginRight" ], function( _, name ) { |
291 |
var oldHook = jQuery.cssHooks[ name ] && jQuery.cssHooks[ name ].get;
|
292 |
|
293 |
if ( oldHook ) {
|
294 |
jQuery.cssHooks[ name ].get = function() { |
295 |
var ret;
|
296 |
|
297 |
internalSwapCall = true;
|
298 |
ret = oldHook.apply( this, arguments ); |
299 |
internalSwapCall = false;
|
300 |
return ret;
|
301 |
}; |
302 |
} |
303 |
} ); |
304 |
} |
305 |
|
306 |
jQuery.swap = function( elem, options, callback, args ) { |
307 |
var ret, name,
|
308 |
old = {}; |
309 |
|
310 |
if ( !internalSwapCall ) {
|
311 |
migrateWarn( "jQuery.swap() is undocumented and deprecated" );
|
312 |
} |
313 |
|
314 |
// Remember the old values, and insert the new ones
|
315 |
for ( name in options ) { |
316 |
old[ name ] = elem.style[ name ]; |
317 |
elem.style[ name ] = options[ name ]; |
318 |
} |
319 |
|
320 |
ret = callback.apply( elem, args || [] ); |
321 |
|
322 |
// Revert the old values
|
323 |
for ( name in options ) { |
324 |
elem.style[ name ] = old[ name ]; |
325 |
} |
326 |
|
327 |
return ret;
|
328 |
}; |
329 |
|
330 |
var oldData = jQuery.data;
|
331 |
|
332 |
jQuery.data = function( elem, name, value ) { |
333 |
var curData;
|
334 |
|
335 |
// Name can be an object, and each entry in the object is meant to be set as data
|
336 |
if ( name && typeof name === "object" && arguments.length === 2 ) { |
337 |
curData = jQuery.hasData( elem ) && oldData.call( this, elem );
|
338 |
var sameKeys = {};
|
339 |
for ( var key in name ) { |
340 |
if ( key !== jQuery.camelCase( key ) ) {
|
341 |
migrateWarn( "jQuery.data() always sets/gets camelCased names: " + key );
|
342 |
curData[ key ] = name[ key ]; |
343 |
} else {
|
344 |
sameKeys[ key ] = name[ key ]; |
345 |
} |
346 |
} |
347 |
|
348 |
oldData.call( this, elem, sameKeys );
|
349 |
|
350 |
return name;
|
351 |
} |
352 |
|
353 |
// If the name is transformed, look for the un-transformed name in the data object
|
354 |
if ( name && typeof name === "string" && name !== jQuery.camelCase( name ) ) { |
355 |
curData = jQuery.hasData( elem ) && oldData.call( this, elem );
|
356 |
if ( curData && name in curData ) { |
357 |
migrateWarn( "jQuery.data() always sets/gets camelCased names: " + name );
|
358 |
if ( arguments.length > 2 ) { |
359 |
curData[ name ] = value; |
360 |
} |
361 |
return curData[ name ];
|
362 |
} |
363 |
} |
364 |
|
365 |
return oldData.apply( this, arguments ); |
366 |
}; |
367 |
|
368 |
var oldTweenRun = jQuery.Tween.prototype.run;
|
369 |
var linearEasing = function( pct ) { |
370 |
return pct;
|
371 |
}; |
372 |
|
373 |
jQuery.Tween.prototype.run = function( ) { |
374 |
if ( jQuery.easing[ this.easing ].length > 1 ) { |
375 |
migrateWarn( |
376 |
"'jQuery.easing." + this.easing.toString() + "' should use only one argument" |
377 |
); |
378 |
|
379 |
jQuery.easing[ this.easing ] = linearEasing;
|
380 |
} |
381 |
|
382 |
oldTweenRun.apply( this, arguments ); |
383 |
}; |
384 |
|
385 |
jQuery.fx.interval = jQuery.fx.interval || 13;
|
386 |
|
387 |
// Support: IE9, Android <=4.4
|
388 |
// Avoid false positives on browsers that lack rAF
|
389 |
if ( window.requestAnimationFrame ) {
|
390 |
migrateWarnProp( jQuery.fx, "interval", jQuery.fx.interval,
|
391 |
"jQuery.fx.interval is deprecated" );
|
392 |
} |
393 |
|
394 |
var oldLoad = jQuery.fn.load,
|
395 |
oldEventAdd = jQuery.event.add, |
396 |
originalFix = jQuery.event.fix; |
397 |
|
398 |
jQuery.event.props = []; |
399 |
jQuery.event.fixHooks = {}; |
400 |
|
401 |
migrateWarnProp( jQuery.event.props, "concat", jQuery.event.props.concat,
|
402 |
"jQuery.event.props.concat() is deprecated and removed" );
|
403 |
|
404 |
jQuery.event.fix = function( originalEvent ) { |
405 |
var event,
|
406 |
type = originalEvent.type, |
407 |
fixHook = this.fixHooks[ type ],
|
408 |
props = jQuery.event.props; |
409 |
|
410 |
if ( props.length ) {
|
411 |
migrateWarn( "jQuery.event.props are deprecated and removed: " + props.join() );
|
412 |
while ( props.length ) {
|
413 |
jQuery.event.addProp( props.pop() ); |
414 |
} |
415 |
} |
416 |
|
417 |
if ( fixHook && !fixHook._migrated_ ) {
|
418 |
fixHook._migrated_ = true;
|
419 |
migrateWarn( "jQuery.event.fixHooks are deprecated and removed: " + type );
|
420 |
if ( ( props = fixHook.props ) && props.length ) {
|
421 |
while ( props.length ) {
|
422 |
jQuery.event.addProp( props.pop() ); |
423 |
} |
424 |
} |
425 |
} |
426 |
|
427 |
event = originalFix.call( this, originalEvent );
|
428 |
|
429 |
return fixHook && fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
|
430 |
}; |
431 |
|
432 |
jQuery.event.add = function( elem, types ) { |
433 |
|
434 |
// This misses the multiple-types case but that seems awfully rare
|
435 |
if ( elem === window && types === "load" && window.document.readyState === "complete" ) { |
436 |
migrateWarn( "jQuery(window).on('load'...) called after load event occurred" );
|
437 |
} |
438 |
return oldEventAdd.apply( this, arguments ); |
439 |
}; |
440 |
|
441 |
jQuery.each( [ "load", "unload", "error" ], function( _, name ) { |
442 |
|
443 |
jQuery.fn[ name ] = function() {
|
444 |
var args = Array.prototype.slice.call( arguments, 0 ); |
445 |
|
446 |
// If this is an ajax load() the first arg should be the string URL;
|
447 |
// technically this could also be the "Anything" arg of the event .load()
|
448 |
// which just goes to show why this dumb signature has been deprecated!
|
449 |
// jQuery custom builds that exclude the Ajax module justifiably die here.
|
450 |
if ( name === "load" && typeof args[ 0 ] === "string" ) { |
451 |
return oldLoad.apply( this, args ); |
452 |
} |
453 |
|
454 |
migrateWarn( "jQuery.fn." + name + "() is deprecated" ); |
455 |
|
456 |
args.splice( 0, 0, name ); |
457 |
if ( arguments.length ) { |
458 |
return this.on.apply( this, args ); |
459 |
} |
460 |
|
461 |
// Use .triggerHandler here because:
|
462 |
// - load and unload events don't need to bubble, only applied to window or image
|
463 |
// - error event should not bubble to window, although it does pre-1.7
|
464 |
// See http://bugs.jquery.com/ticket/11820
|
465 |
this.triggerHandler.apply( this, args ); |
466 |
return this; |
467 |
}; |
468 |
|
469 |
} ); |
470 |
|
471 |
jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
|
472 |
"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
|
473 |
"change select submit keydown keypress keyup contextmenu" ).split( " " ), |
474 |
function( i, name ) {
|
475 |
|
476 |
// Handle event binding
|
477 |
jQuery.fn[ name ] = function( data, fn ) {
|
478 |
migrateWarn( "jQuery.fn." + name + "() event shorthand is deprecated" ); |
479 |
return arguments.length > 0 ? |
480 |
this.on( name, null, data, fn ) : |
481 |
this.trigger( name );
|
482 |
}; |
483 |
} ); |
484 |
|
485 |
// Trigger "ready" event only once, on document ready
|
486 |
jQuery( function() {
|
487 |
jQuery( window.document ).triggerHandler( "ready" );
|
488 |
} ); |
489 |
|
490 |
jQuery.event.special.ready = { |
491 |
setup: function() { |
492 |
if ( this === window.document ) { |
493 |
migrateWarn( "'ready' event is deprecated" );
|
494 |
} |
495 |
} |
496 |
}; |
497 |
|
498 |
jQuery.fn.extend( { |
499 |
|
500 |
bind: function( types, data, fn ) { |
501 |
migrateWarn( "jQuery.fn.bind() is deprecated" );
|
502 |
return this.on( types, null, data, fn ); |
503 |
}, |
504 |
unbind: function( types, fn ) { |
505 |
migrateWarn( "jQuery.fn.unbind() is deprecated" );
|
506 |
return this.off( types, null, fn ); |
507 |
}, |
508 |
delegate: function( selector, types, data, fn ) { |
509 |
migrateWarn( "jQuery.fn.delegate() is deprecated" );
|
510 |
return this.on( types, selector, data, fn ); |
511 |
}, |
512 |
undelegate: function( selector, types, fn ) { |
513 |
migrateWarn( "jQuery.fn.undelegate() is deprecated" );
|
514 |
return arguments.length === 1 ? |
515 |
this.off( selector, "**" ) : |
516 |
this.off( types, selector || "**", fn ); |
517 |
}, |
518 |
hover: function( fnOver, fnOut ) { |
519 |
migrateWarn( "jQuery.fn.hover() is deprecated" );
|
520 |
return this.on( "mouseenter", fnOver ).on( "mouseleave", fnOut || fnOver ); |
521 |
} |
522 |
} ); |
523 |
|
524 |
|
525 |
var oldOffset = jQuery.fn.offset;
|
526 |
|
527 |
jQuery.fn.offset = function() { |
528 |
var docElem,
|
529 |
elem = this[ 0 ], |
530 |
origin = { top: 0, left: 0 }; |
531 |
|
532 |
if ( !elem || !elem.nodeType ) {
|
533 |
migrateWarn( "jQuery.fn.offset() requires a valid DOM element" );
|
534 |
return origin;
|
535 |
} |
536 |
|
537 |
docElem = ( elem.ownerDocument || window.document ).documentElement; |
538 |
if ( !jQuery.contains( docElem, elem ) ) {
|
539 |
migrateWarn( "jQuery.fn.offset() requires an element connected to a document" );
|
540 |
return origin;
|
541 |
} |
542 |
|
543 |
return oldOffset.apply( this, arguments ); |
544 |
}; |
545 |
|
546 |
|
547 |
var oldParam = jQuery.param;
|
548 |
|
549 |
jQuery.param = function( data, traditional ) { |
550 |
var ajaxTraditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
|
551 |
|
552 |
if ( traditional === undefined && ajaxTraditional ) { |
553 |
|
554 |
migrateWarn( "jQuery.param() no longer uses jQuery.ajaxSettings.traditional" );
|
555 |
traditional = ajaxTraditional; |
556 |
} |
557 |
|
558 |
return oldParam.call( this, data, traditional ); |
559 |
}; |
560 |
|
561 |
var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack;
|
562 |
|
563 |
jQuery.fn.andSelf = function() { |
564 |
migrateWarn( "jQuery.fn.andSelf() is deprecated and removed, use jQuery.fn.addBack()" );
|
565 |
return oldSelf.apply( this, arguments ); |
566 |
}; |
567 |
|
568 |
|
569 |
var oldDeferred = jQuery.Deferred,
|
570 |
tuples = [ |
571 |
|
572 |
// Action, add listener, callbacks, .then handlers, final state
|
573 |
[ "resolve", "done", jQuery.Callbacks( "once memory" ), |
574 |
jQuery.Callbacks( "once memory" ), "resolved" ], |
575 |
[ "reject", "fail", jQuery.Callbacks( "once memory" ), |
576 |
jQuery.Callbacks( "once memory" ), "rejected" ], |
577 |
[ "notify", "progress", jQuery.Callbacks( "memory" ), |
578 |
jQuery.Callbacks( "memory" ) ]
|
579 |
]; |
580 |
|
581 |
jQuery.Deferred = function( func ) { |
582 |
var deferred = oldDeferred(),
|
583 |
promise = deferred.promise(); |
584 |
|
585 |
deferred.pipe = promise.pipe = function( /* fnDone, fnFail, fnProgress */ ) { |
586 |
var fns = arguments; |
587 |
|
588 |
migrateWarn( "deferred.pipe() is deprecated" );
|
589 |
|
590 |
return jQuery.Deferred( function( newDefer ) { |
591 |
jQuery.each( tuples, function( i, tuple ) {
|
592 |
var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
|
593 |
|
594 |
// Deferred.done(function() { bind to newDefer or newDefer.resolve })
|
595 |
// deferred.fail(function() { bind to newDefer or newDefer.reject })
|
596 |
// deferred.progress(function() { bind to newDefer or newDefer.notify })
|
597 |
deferred[ tuple[ 1 ] ]( function() { |
598 |
var returned = fn && fn.apply( this, arguments ); |
599 |
if ( returned && jQuery.isFunction( returned.promise ) ) {
|
600 |
returned.promise() |
601 |
.done( newDefer.resolve ) |
602 |
.fail( newDefer.reject ) |
603 |
.progress( newDefer.notify ); |
604 |
} else {
|
605 |
newDefer[ tuple[ 0 ] + "With" ]( |
606 |
this === promise ? newDefer.promise() : this, |
607 |
fn ? [ returned ] : arguments
|
608 |
); |
609 |
} |
610 |
} ); |
611 |
} ); |
612 |
fns = null;
|
613 |
} ).promise(); |
614 |
|
615 |
}; |
616 |
|
617 |
if ( func ) {
|
618 |
func.call( deferred, deferred ); |
619 |
} |
620 |
|
621 |
return deferred;
|
622 |
}; |
623 |
|
624 |
// Preserve handler of uncaught exceptions in promise chains
|
625 |
jQuery.Deferred.exceptionHook = oldDeferred.exceptionHook; |
626 |
|
627 |
return jQuery;
|
628 |
} ); |