953 lines
25 KiB
JavaScript
953 lines
25 KiB
JavaScript
/*!
|
|
* jQuery Migrate - v3.3.2 - 2020-11-17T23:22Z
|
|
* Copyright OpenJS Foundation and other contributors
|
|
*/
|
|
(function (factory) {
|
|
'use strict';
|
|
|
|
if (typeof define === 'function' && define.amd) {
|
|
// AMD. Register as an anonymous module.
|
|
define(['jquery'], function (jQuery) {
|
|
return factory(jQuery, window);
|
|
});
|
|
} else if (typeof module === 'object' && module.exports) {
|
|
// Node/CommonJS
|
|
// eslint-disable-next-line no-undef
|
|
module.exports = factory(require('jquery'), window);
|
|
} else {
|
|
// Browser globals
|
|
factory(jQuery, window);
|
|
}
|
|
})(function (jQuery, window) {
|
|
'use strict';
|
|
|
|
jQuery.migrateVersion = '3.3.2';
|
|
|
|
// Returns 0 if v1 == v2, -1 if v1 < v2, 1 if v1 > v2
|
|
function compareVersions(v1, v2) {
|
|
var i,
|
|
rVersionParts = /^(\d+)\.(\d+)\.(\d+)/,
|
|
v1p = rVersionParts.exec(v1) || [],
|
|
v2p = rVersionParts.exec(v2) || [];
|
|
|
|
for (i = 1; i <= 3; i++) {
|
|
if (+v1p[i] > +v2p[i]) {
|
|
return 1;
|
|
}
|
|
if (+v1p[i] < +v2p[i]) {
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
function jQueryVersionSince(version) {
|
|
return compareVersions(jQuery.fn.jquery, version) >= 0;
|
|
}
|
|
|
|
(function () {
|
|
// Support: IE9 only
|
|
// IE9 only creates console object when dev tools are first opened
|
|
// IE9 console is a host object, callable but doesn't have .apply()
|
|
if (!window.console || !window.console.log) {
|
|
return;
|
|
}
|
|
|
|
// Need jQuery 3.0.0+ and no older Migrate loaded
|
|
if (!jQuery || !jQueryVersionSince('3.0.0')) {
|
|
window.console.log('JQMIGRATE: jQuery 3.0.0+ REQUIRED');
|
|
}
|
|
if (jQuery.migrateWarnings) {
|
|
window.console.log('JQMIGRATE: Migrate plugin loaded multiple times');
|
|
}
|
|
|
|
// Show a message on the console so devs know we're active
|
|
window.console.log(
|
|
'JQMIGRATE: Migrate is installed' +
|
|
(jQuery.migrateMute ? '' : ' with logging active') +
|
|
', version ' +
|
|
jQuery.migrateVersion
|
|
);
|
|
})();
|
|
|
|
var warnedAbout = {};
|
|
|
|
// By default each warning is only reported once.
|
|
jQuery.migrateDeduplicateWarnings = true;
|
|
|
|
// List of warnings already given; public read only
|
|
jQuery.migrateWarnings = [];
|
|
|
|
// Set to false to disable traces that appear with warnings
|
|
if (jQuery.migrateTrace === undefined) {
|
|
jQuery.migrateTrace = true;
|
|
}
|
|
|
|
// Forget any warnings we've already given; public
|
|
jQuery.migrateReset = function () {
|
|
warnedAbout = {};
|
|
jQuery.migrateWarnings.length = 0;
|
|
};
|
|
|
|
function migrateWarn(msg) {
|
|
var console = window.console;
|
|
if (!jQuery.migrateDeduplicateWarnings || !warnedAbout[msg]) {
|
|
warnedAbout[msg] = true;
|
|
jQuery.migrateWarnings.push(msg);
|
|
if (console && console.warn && !jQuery.migrateMute) {
|
|
console.warn('JQMIGRATE: ' + msg);
|
|
if (jQuery.migrateTrace && console.trace) {
|
|
console.trace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function migrateWarnProp(obj, prop, value, msg) {
|
|
Object.defineProperty(obj, prop, {
|
|
configurable: true,
|
|
enumerable: true,
|
|
get: function () {
|
|
migrateWarn(msg);
|
|
return value;
|
|
},
|
|
set: function (newValue) {
|
|
migrateWarn(msg);
|
|
value = newValue;
|
|
},
|
|
});
|
|
}
|
|
|
|
function migrateWarnFunc(obj, prop, newFunc, msg) {
|
|
obj[prop] = function () {
|
|
migrateWarn(msg);
|
|
return newFunc.apply(this, arguments);
|
|
};
|
|
}
|
|
|
|
if (window.document.compatMode === 'BackCompat') {
|
|
// JQuery has never supported or tested Quirks Mode
|
|
migrateWarn('jQuery is not compatible with Quirks Mode');
|
|
}
|
|
|
|
var findProp,
|
|
class2type = {},
|
|
oldInit = jQuery.fn.init,
|
|
oldFind = jQuery.find,
|
|
rattrHashTest = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/,
|
|
rattrHashGlob = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/g,
|
|
// Support: Android <=4.0 only
|
|
// Make sure we trim BOM and NBSP
|
|
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
|
|
|
|
jQuery.fn.init = function (arg1) {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
|
|
if (typeof arg1 === 'string' && arg1 === '#') {
|
|
// JQuery( "#" ) is a bogus ID selector, but it returned an empty set before jQuery 3.0
|
|
migrateWarn("jQuery( '#' ) is not a valid selector");
|
|
args[0] = [];
|
|
}
|
|
|
|
return oldInit.apply(this, args);
|
|
};
|
|
jQuery.fn.init.prototype = jQuery.fn;
|
|
|
|
jQuery.find = function (selector) {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
|
|
// Support: PhantomJS 1.x
|
|
// String#match fails to match when used with a //g RegExp, only on some strings
|
|
if (typeof selector === 'string' && rattrHashTest.test(selector)) {
|
|
// The nonstandard and undocumented unquoted-hash was removed in jQuery 1.12.0
|
|
// First see if qS thinks it's a valid selector, if so avoid a false positive
|
|
try {
|
|
window.document.querySelector(selector);
|
|
} catch (err1) {
|
|
// Didn't *look* valid to qSA, warn and try quoting what we think is the value
|
|
selector = selector.replace(
|
|
rattrHashGlob,
|
|
function (_, attr, op, value) {
|
|
return '[' + attr + op + '"' + value + '"]';
|
|
}
|
|
);
|
|
|
|
// If the regexp *may* have created an invalid selector, don't update it
|
|
// Note that there may be false alarms if selector uses jQuery extensions
|
|
try {
|
|
window.document.querySelector(selector);
|
|
migrateWarn("Attribute selector with '#' must be quoted: " + args[0]);
|
|
args[0] = selector;
|
|
} catch (err2) {
|
|
migrateWarn("Attribute selector with '#' was not fixed: " + args[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return oldFind.apply(this, args);
|
|
};
|
|
|
|
// Copy properties attached to original jQuery.find method (e.g. .attr, .isXML)
|
|
for (findProp in oldFind) {
|
|
if (Object.prototype.hasOwnProperty.call(oldFind, findProp)) {
|
|
jQuery.find[findProp] = oldFind[findProp];
|
|
}
|
|
}
|
|
|
|
// The number of elements contained in the matched element set
|
|
migrateWarnFunc(
|
|
jQuery.fn,
|
|
'size',
|
|
function () {
|
|
return this.length;
|
|
},
|
|
'jQuery.fn.size() is deprecated and removed; use the .length property'
|
|
);
|
|
|
|
migrateWarnFunc(
|
|
jQuery,
|
|
'parseJSON',
|
|
function () {
|
|
return JSON.parse.apply(null, arguments);
|
|
},
|
|
'jQuery.parseJSON is deprecated; use JSON.parse'
|
|
);
|
|
|
|
migrateWarnFunc(
|
|
jQuery,
|
|
'holdReady',
|
|
jQuery.holdReady,
|
|
'jQuery.holdReady is deprecated'
|
|
);
|
|
|
|
migrateWarnFunc(
|
|
jQuery,
|
|
'unique',
|
|
jQuery.uniqueSort,
|
|
'jQuery.unique is deprecated; use jQuery.uniqueSort'
|
|
);
|
|
|
|
// Now jQuery.expr.pseudos is the standard incantation
|
|
migrateWarnProp(
|
|
jQuery.expr,
|
|
'filters',
|
|
jQuery.expr.pseudos,
|
|
'jQuery.expr.filters is deprecated; use jQuery.expr.pseudos'
|
|
);
|
|
migrateWarnProp(
|
|
jQuery.expr,
|
|
':',
|
|
jQuery.expr.pseudos,
|
|
"jQuery.expr[':'] is deprecated; use jQuery.expr.pseudos"
|
|
);
|
|
|
|
// Prior to jQuery 3.1.1 there were internal refs so we don't warn there
|
|
if (jQueryVersionSince('3.1.1')) {
|
|
migrateWarnFunc(
|
|
jQuery,
|
|
'trim',
|
|
function (text) {
|
|
return text == null ? '' : (text + '').replace(rtrim, '');
|
|
},
|
|
'jQuery.trim is deprecated; use String.prototype.trim'
|
|
);
|
|
}
|
|
|
|
// Prior to jQuery 3.2 there were internal refs so we don't warn there
|
|
if (jQueryVersionSince('3.2.0')) {
|
|
migrateWarnFunc(
|
|
jQuery,
|
|
'nodeName',
|
|
function (elem, name) {
|
|
return (
|
|
elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase()
|
|
);
|
|
},
|
|
'jQuery.nodeName is deprecated'
|
|
);
|
|
|
|
migrateWarnFunc(
|
|
jQuery,
|
|
'isArray',
|
|
Array.isArray,
|
|
'jQuery.isArray is deprecated; use Array.isArray'
|
|
);
|
|
}
|
|
|
|
if (jQueryVersionSince('3.3.0')) {
|
|
migrateWarnFunc(
|
|
jQuery,
|
|
'isNumeric',
|
|
function (obj) {
|
|
// As of jQuery 3.0, isNumeric is limited to
|
|
// strings and numbers (primitives or objects)
|
|
// that can be coerced to finite numbers (gh-2662)
|
|
var type = typeof obj;
|
|
return (
|
|
(type === 'number' || type === 'string') &&
|
|
// parseFloat NaNs numeric-cast false positives ("")
|
|
// ...but misinterprets leading-number strings, e.g. hex literals ("0x...")
|
|
// subtraction forces infinities to NaN
|
|
!isNaN(obj - parseFloat(obj))
|
|
);
|
|
},
|
|
'jQuery.isNumeric() is deprecated'
|
|
);
|
|
|
|
// Populate the class2type map
|
|
jQuery.each(
|
|
'Boolean Number String Function Array Date RegExp Object Error Symbol'.split(
|
|
' '
|
|
),
|
|
function (_, name) {
|
|
class2type['[object ' + name + ']'] = name.toLowerCase();
|
|
}
|
|
);
|
|
|
|
migrateWarnFunc(
|
|
jQuery,
|
|
'type',
|
|
function (obj) {
|
|
if (obj == null) {
|
|
return obj + '';
|
|
}
|
|
|
|
// Support: Android <=2.3 only (functionish RegExp)
|
|
return typeof obj === 'object' || typeof obj === 'function'
|
|
? class2type[Object.prototype.toString.call(obj)] || 'object'
|
|
: typeof obj;
|
|
},
|
|
'jQuery.type is deprecated'
|
|
);
|
|
|
|
migrateWarnFunc(
|
|
jQuery,
|
|
'isFunction',
|
|
function (obj) {
|
|
return typeof obj === 'function';
|
|
},
|
|
'jQuery.isFunction() is deprecated'
|
|
);
|
|
|
|
migrateWarnFunc(
|
|
jQuery,
|
|
'isWindow',
|
|
function (obj) {
|
|
return obj != null && obj === obj.window;
|
|
},
|
|
'jQuery.isWindow() is deprecated'
|
|
);
|
|
}
|
|
|
|
// Support jQuery slim which excludes the ajax module
|
|
if (jQuery.ajax) {
|
|
var oldAjax = jQuery.ajax,
|
|
rjsonp = /(=)\?(?=&|$)|\?\?/;
|
|
|
|
jQuery.ajax = function () {
|
|
var jQXHR = oldAjax.apply(this, arguments);
|
|
|
|
// Be sure we got a jQXHR (e.g., not sync)
|
|
if (jQXHR.promise) {
|
|
migrateWarnFunc(
|
|
jQXHR,
|
|
'success',
|
|
jQXHR.done,
|
|
'jQXHR.success is deprecated and removed'
|
|
);
|
|
migrateWarnFunc(
|
|
jQXHR,
|
|
'error',
|
|
jQXHR.fail,
|
|
'jQXHR.error is deprecated and removed'
|
|
);
|
|
migrateWarnFunc(
|
|
jQXHR,
|
|
'complete',
|
|
jQXHR.always,
|
|
'jQXHR.complete is deprecated and removed'
|
|
);
|
|
}
|
|
|
|
return jQXHR;
|
|
};
|
|
|
|
// Only trigger the logic in jQuery <4 as the JSON-to-JSONP auto-promotion
|
|
// behavior is gone in jQuery 4.0 and as it has security implications, we don't
|
|
// want to restore the legacy behavior.
|
|
if (!jQueryVersionSince('4.0.0')) {
|
|
// Register this prefilter before the jQuery one. Otherwise, a promoted
|
|
// request is transformed into one with the script dataType and we can't
|
|
// catch it anymore.
|
|
jQuery.ajaxPrefilter('+json', function (s) {
|
|
// Warn if JSON-to-JSONP auto-promotion happens.
|
|
if (
|
|
s.jsonp !== false &&
|
|
(rjsonp.test(s.url) ||
|
|
(typeof s.data === 'string' &&
|
|
(s.contentType || '').indexOf(
|
|
'application/x-www-form-urlencoded'
|
|
) === 0 &&
|
|
rjsonp.test(s.data)))
|
|
) {
|
|
migrateWarn('JSON-to-JSONP auto-promotion is deprecated');
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
var oldRemoveAttr = jQuery.fn.removeAttr,
|
|
oldToggleClass = jQuery.fn.toggleClass,
|
|
rmatchNonSpace = /\S+/g;
|
|
|
|
jQuery.fn.removeAttr = function (name) {
|
|
var self = this;
|
|
|
|
jQuery.each(name.match(rmatchNonSpace), function (_i, attr) {
|
|
if (jQuery.expr.match.bool.test(attr)) {
|
|
migrateWarn(
|
|
'jQuery.fn.removeAttr no longer sets boolean properties: ' + attr
|
|
);
|
|
self.prop(attr, false);
|
|
}
|
|
});
|
|
|
|
return oldRemoveAttr.apply(this, arguments);
|
|
};
|
|
|
|
jQuery.fn.toggleClass = function (state) {
|
|
// Only deprecating no-args or single boolean arg
|
|
if (state !== undefined && typeof state !== 'boolean') {
|
|
return oldToggleClass.apply(this, arguments);
|
|
}
|
|
|
|
migrateWarn('jQuery.fn.toggleClass( boolean ) is deprecated');
|
|
|
|
// Toggle entire class name of each element
|
|
return this.each(function () {
|
|
var className = (this.getAttribute && this.getAttribute('class')) || '';
|
|
|
|
if (className) {
|
|
jQuery.data(this, '__className__', className);
|
|
}
|
|
|
|
// If the element has a class name or if we're passed `false`,
|
|
// then remove the whole classname (if there was one, the above saved it).
|
|
// Otherwise bring back whatever was previously saved (if anything),
|
|
// falling back to the empty string if nothing was stored.
|
|
if (this.setAttribute) {
|
|
this.setAttribute(
|
|
'class',
|
|
className || state === false
|
|
? ''
|
|
: jQuery.data(this, '__className__') || ''
|
|
);
|
|
}
|
|
});
|
|
};
|
|
|
|
function camelCase(string) {
|
|
return string.replace(/-([a-z])/g, function (_, letter) {
|
|
return letter.toUpperCase();
|
|
});
|
|
}
|
|
|
|
var oldFnCss,
|
|
internalSwapCall = false,
|
|
ralphaStart = /^[a-z]/,
|
|
// The regex visualized:
|
|
//
|
|
// /----------\
|
|
// | | /-------\
|
|
// | / Top \ | | |
|
|
// /--- Border ---+-| Right |-+---+- Width -+---\
|
|
// | | Bottom | |
|
|
// | \ Left / |
|
|
// | |
|
|
// | /----------\ |
|
|
// | /-------------\ | | |- END
|
|
// | | | | / Top \ | |
|
|
// | | / Margin \ | | | Right | | |
|
|
// |---------+-| |-+---+-| Bottom |-+----|
|
|
// | \ Padding / \ Left / |
|
|
// BEGIN -| |
|
|
// | /---------\ |
|
|
// | | | |
|
|
// | | / Min \ | / Width \ |
|
|
// \--------------+-| |-+---| |---/
|
|
// \ Max / \ Height /
|
|
rautoPx =
|
|
/^(?:Border(?:Top|Right|Bottom|Left)?(?:Width|)|(?:Margin|Padding)?(?:Top|Right|Bottom|Left)?|(?:Min|Max)?(?:Width|Height))$/;
|
|
|
|
// If this version of jQuery has .swap(), don't false-alarm on internal uses
|
|
if (jQuery.swap) {
|
|
jQuery.each(['height', 'width', 'reliableMarginLeft'], function (_, name) {
|
|
var oldHook = jQuery.cssHooks[name] && jQuery.cssHooks[name].get;
|
|
|
|
if (oldHook) {
|
|
jQuery.cssHooks[name].get = function () {
|
|
var ret;
|
|
|
|
internalSwapCall = true;
|
|
ret = oldHook.apply(this, arguments);
|
|
internalSwapCall = false;
|
|
return ret;
|
|
};
|
|
}
|
|
});
|
|
}
|
|
|
|
jQuery.swap = function (elem, options, callback, args) {
|
|
var ret,
|
|
name,
|
|
old = {};
|
|
|
|
if (!internalSwapCall) {
|
|
migrateWarn('jQuery.swap() is undocumented and deprecated');
|
|
}
|
|
|
|
// Remember the old values, and insert the new ones
|
|
for (name in options) {
|
|
old[name] = elem.style[name];
|
|
elem.style[name] = options[name];
|
|
}
|
|
|
|
ret = callback.apply(elem, args || []);
|
|
|
|
// Revert the old values
|
|
for (name in options) {
|
|
elem.style[name] = old[name];
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
|
|
if (jQueryVersionSince('3.4.0') && typeof Proxy !== 'undefined') {
|
|
jQuery.cssProps = new Proxy(jQuery.cssProps || {}, {
|
|
set: function () {
|
|
migrateWarn('JQMIGRATE: jQuery.cssProps is deprecated');
|
|
return Reflect.set.apply(this, arguments);
|
|
},
|
|
});
|
|
}
|
|
|
|
// Create a dummy jQuery.cssNumber if missing. It won't be used by jQuery but
|
|
// it will prevent code adding new keys to it unconditionally from crashing.
|
|
if (!jQuery.cssNumber) {
|
|
jQuery.cssNumber = {};
|
|
}
|
|
|
|
function isAutoPx(prop) {
|
|
// The first test is used to ensure that:
|
|
// 1. The prop starts with a lowercase letter (as we uppercase it for the second regex).
|
|
// 2. The prop is not empty.
|
|
return (
|
|
ralphaStart.test(prop) &&
|
|
rautoPx.test(prop[0].toUpperCase() + prop.slice(1))
|
|
);
|
|
}
|
|
|
|
oldFnCss = jQuery.fn.css;
|
|
|
|
jQuery.fn.css = function (name, value) {
|
|
var camelName,
|
|
origThis = this;
|
|
if (name && typeof name === 'object' && !Array.isArray(name)) {
|
|
jQuery.each(name, function (n, v) {
|
|
jQuery.fn.css.call(origThis, n, v);
|
|
});
|
|
return this;
|
|
}
|
|
if (typeof value === 'number') {
|
|
camelName = camelCase(name);
|
|
if (!isAutoPx(camelName) && !jQuery.cssNumber[camelName]) {
|
|
migrateWarn(
|
|
'Number-typed values are deprecated for jQuery.fn.css( "' +
|
|
name +
|
|
'", value )'
|
|
);
|
|
}
|
|
}
|
|
|
|
return oldFnCss.apply(this, arguments);
|
|
};
|
|
|
|
var oldData = jQuery.data;
|
|
|
|
jQuery.data = function (elem, name, value) {
|
|
var curData, sameKeys, key;
|
|
|
|
// Name can be an object, and each entry in the object is meant to be set as data
|
|
if (name && typeof name === 'object' && arguments.length === 2) {
|
|
curData = jQuery.hasData(elem) && oldData.call(this, elem);
|
|
sameKeys = {};
|
|
for (key in name) {
|
|
if (key !== camelCase(key)) {
|
|
migrateWarn(
|
|
'jQuery.data() always sets/gets camelCased names: ' + key
|
|
);
|
|
curData[key] = name[key];
|
|
} else {
|
|
sameKeys[key] = name[key];
|
|
}
|
|
}
|
|
|
|
oldData.call(this, elem, sameKeys);
|
|
|
|
return name;
|
|
}
|
|
|
|
// If the name is transformed, look for the un-transformed name in the data object
|
|
if (name && typeof name === 'string' && name !== camelCase(name)) {
|
|
curData = jQuery.hasData(elem) && oldData.call(this, elem);
|
|
if (curData && name in curData) {
|
|
migrateWarn('jQuery.data() always sets/gets camelCased names: ' + name);
|
|
if (arguments.length > 2) {
|
|
curData[name] = value;
|
|
}
|
|
return curData[name];
|
|
}
|
|
}
|
|
|
|
return oldData.apply(this, arguments);
|
|
};
|
|
|
|
// Support jQuery slim which excludes the effects module
|
|
if (jQuery.fx) {
|
|
var intervalValue,
|
|
intervalMsg,
|
|
oldTweenRun = jQuery.Tween.prototype.run,
|
|
linearEasing = function (pct) {
|
|
return pct;
|
|
};
|
|
|
|
jQuery.Tween.prototype.run = function () {
|
|
if (jQuery.easing[this.easing].length > 1) {
|
|
migrateWarn(
|
|
"'jQuery.easing." +
|
|
this.easing.toString() +
|
|
"' should use only one argument"
|
|
);
|
|
|
|
jQuery.easing[this.easing] = linearEasing;
|
|
}
|
|
|
|
oldTweenRun.apply(this, arguments);
|
|
};
|
|
|
|
intervalValue = jQuery.fx.interval || 13;
|
|
intervalMsg = 'jQuery.fx.interval is deprecated';
|
|
|
|
// Support: IE9, Android <=4.4
|
|
// Avoid false positives on browsers that lack rAF
|
|
// Don't warn if document is hidden, jQuery uses setTimeout (#292)
|
|
if (window.requestAnimationFrame) {
|
|
Object.defineProperty(jQuery.fx, 'interval', {
|
|
configurable: true,
|
|
enumerable: true,
|
|
get: function () {
|
|
if (!window.document.hidden) {
|
|
migrateWarn(intervalMsg);
|
|
}
|
|
return intervalValue;
|
|
},
|
|
set: function (newValue) {
|
|
migrateWarn(intervalMsg);
|
|
intervalValue = newValue;
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
var oldLoad = jQuery.fn.load,
|
|
oldEventAdd = jQuery.event.add,
|
|
originalFix = jQuery.event.fix;
|
|
|
|
jQuery.event.props = [];
|
|
jQuery.event.fixHooks = {};
|
|
|
|
migrateWarnProp(
|
|
jQuery.event.props,
|
|
'concat',
|
|
jQuery.event.props.concat,
|
|
'jQuery.event.props.concat() is deprecated and removed'
|
|
);
|
|
|
|
jQuery.event.fix = function (originalEvent) {
|
|
var event,
|
|
type = originalEvent.type,
|
|
fixHook = this.fixHooks[type],
|
|
props = jQuery.event.props;
|
|
|
|
if (props.length) {
|
|
migrateWarn(
|
|
'jQuery.event.props are deprecated and removed: ' + props.join()
|
|
);
|
|
while (props.length) {
|
|
jQuery.event.addProp(props.pop());
|
|
}
|
|
}
|
|
|
|
if (fixHook && !fixHook._migrated_) {
|
|
fixHook._migrated_ = true;
|
|
migrateWarn('jQuery.event.fixHooks are deprecated and removed: ' + type);
|
|
if ((props = fixHook.props) && props.length) {
|
|
while (props.length) {
|
|
jQuery.event.addProp(props.pop());
|
|
}
|
|
}
|
|
}
|
|
|
|
event = originalFix.call(this, originalEvent);
|
|
|
|
return fixHook && fixHook.filter
|
|
? fixHook.filter(event, originalEvent)
|
|
: event;
|
|
};
|
|
|
|
jQuery.event.add = function (elem, types) {
|
|
// This misses the multiple-types case but that seems awfully rare
|
|
if (
|
|
elem === window &&
|
|
types === 'load' &&
|
|
window.document.readyState === 'complete'
|
|
) {
|
|
migrateWarn(
|
|
"jQuery(window).on('load'...) called after load event occurred"
|
|
);
|
|
}
|
|
return oldEventAdd.apply(this, arguments);
|
|
};
|
|
|
|
jQuery.each(['load', 'unload', 'error'], function (_, name) {
|
|
jQuery.fn[name] = function () {
|
|
var args = Array.prototype.slice.call(arguments, 0);
|
|
|
|
// If this is an ajax load() the first arg should be the string URL;
|
|
// technically this could also be the "Anything" arg of the event .load()
|
|
// which just goes to show why this dumb signature has been deprecated!
|
|
// jQuery custom builds that exclude the Ajax module justifiably die here.
|
|
if (name === 'load' && typeof args[0] === 'string') {
|
|
return oldLoad.apply(this, args);
|
|
}
|
|
|
|
migrateWarn('jQuery.fn.' + name + '() is deprecated');
|
|
|
|
args.splice(0, 0, name);
|
|
if (arguments.length) {
|
|
return this.on.apply(this, args);
|
|
}
|
|
|
|
// Use .triggerHandler here because:
|
|
// - load and unload events don't need to bubble, only applied to window or image
|
|
// - error event should not bubble to window, although it does pre-1.7
|
|
// See http://bugs.jquery.com/ticket/11820
|
|
this.triggerHandler.apply(this, args);
|
|
return this;
|
|
};
|
|
});
|
|
|
|
jQuery.each(
|
|
(
|
|
'blur focus focusin focusout resize scroll click dblclick ' +
|
|
'mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave ' +
|
|
'change select submit keydown keypress keyup contextmenu'
|
|
).split(' '),
|
|
function (_i, name) {
|
|
// Handle event binding
|
|
jQuery.fn[name] = function (data, fn) {
|
|
migrateWarn('jQuery.fn.' + name + '() event shorthand is deprecated');
|
|
return arguments.length > 0
|
|
? this.on(name, null, data, fn)
|
|
: this.trigger(name);
|
|
};
|
|
}
|
|
);
|
|
|
|
// Trigger "ready" event only once, on document ready
|
|
jQuery(function () {
|
|
jQuery(window.document).triggerHandler('ready');
|
|
});
|
|
|
|
jQuery.event.special.ready = {
|
|
setup: function () {
|
|
if (this === window.document) {
|
|
migrateWarn("'ready' event is deprecated");
|
|
}
|
|
},
|
|
};
|
|
|
|
jQuery.fn.extend({
|
|
bind: function (types, data, fn) {
|
|
migrateWarn('jQuery.fn.bind() is deprecated');
|
|
return this.on(types, null, data, fn);
|
|
},
|
|
unbind: function (types, fn) {
|
|
migrateWarn('jQuery.fn.off() is deprecated');
|
|
return this.off(types, null, fn);
|
|
},
|
|
delegate: function (selector, types, data, fn) {
|
|
migrateWarn('jQuery.fn.delegate() is deprecated');
|
|
return this.on(types, selector, data, fn);
|
|
},
|
|
undelegate: function (selector, types, fn) {
|
|
migrateWarn('jQuery.fn.undelegate() is deprecated');
|
|
return arguments.length === 1
|
|
? this.off(selector, '**')
|
|
: this.off(types, selector || '**', fn);
|
|
},
|
|
hover: function (fnOver, fnOut) {
|
|
migrateWarn("jQuery.fn.on( 'hover',) is deprecated");
|
|
return this.on('mouseenter', fnOver).on('mouseleave', fnOut || fnOver);
|
|
},
|
|
});
|
|
|
|
var rxhtmlTag =
|
|
/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
|
|
origHtmlPrefilter = jQuery.htmlPrefilter,
|
|
makeMarkup = function (html) {
|
|
var doc = window.document.implementation.createHTMLDocument('');
|
|
doc.body.innerHTML = html;
|
|
return doc.body && doc.body.innerHTML;
|
|
},
|
|
warnIfChanged = function (html) {
|
|
var changed = html.replace(rxhtmlTag, '<$1></$2>');
|
|
if (changed !== html && makeMarkup(html) !== makeMarkup(changed)) {
|
|
migrateWarn('HTML tags must be properly nested and closed: ' + html);
|
|
}
|
|
};
|
|
|
|
jQuery.UNSAFE_restoreLegacyHtmlPrefilter = function () {
|
|
jQuery.htmlPrefilter = function (html) {
|
|
warnIfChanged(html);
|
|
return html.replace(rxhtmlTag, '<$1></$2>');
|
|
};
|
|
};
|
|
|
|
jQuery.htmlPrefilter = function (html) {
|
|
warnIfChanged(html);
|
|
return origHtmlPrefilter(html);
|
|
};
|
|
|
|
var oldOffset = jQuery.fn.offset;
|
|
|
|
jQuery.fn.offset = function () {
|
|
var elem = this[0];
|
|
|
|
if (elem && (!elem.nodeType || !elem.getBoundingClientRect)) {
|
|
migrateWarn('jQuery.fn.offset() requires a valid DOM element');
|
|
return arguments.length ? this : undefined;
|
|
}
|
|
|
|
return oldOffset.apply(this, arguments);
|
|
};
|
|
|
|
// Support jQuery slim which excludes the ajax module
|
|
// The jQuery.param patch is about respecting `jQuery.ajaxSettings.traditional`
|
|
// so it doesn't make sense for the slim build.
|
|
if (jQuery.ajax) {
|
|
var oldParam = jQuery.param;
|
|
|
|
jQuery.param = function (data, traditional) {
|
|
var ajaxTraditional =
|
|
jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
|
|
|
|
if (traditional === undefined && ajaxTraditional) {
|
|
migrateWarn(
|
|
'jQuery.param() no longer uses jQuery.ajaxSettings.traditional'
|
|
);
|
|
traditional = ajaxTraditional;
|
|
}
|
|
|
|
return oldParam.call(this, data, traditional);
|
|
};
|
|
}
|
|
|
|
var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack;
|
|
|
|
jQuery.fn.andSelf = function () {
|
|
migrateWarn(
|
|
'jQuery.fn.andSelf() is deprecated and removed, use jQuery.fn.addBack()'
|
|
);
|
|
return oldSelf.apply(this, arguments);
|
|
};
|
|
|
|
// Support jQuery slim which excludes the deferred module in jQuery 4.0+
|
|
if (jQuery.Deferred) {
|
|
var oldDeferred = jQuery.Deferred,
|
|
tuples = [
|
|
// Action, add listener, callbacks, .then handlers, final state
|
|
[
|
|
'resolve',
|
|
'done',
|
|
jQuery.Callbacks('once memory'),
|
|
jQuery.Callbacks('once memory'),
|
|
'resolved',
|
|
],
|
|
[
|
|
'reject',
|
|
'fail',
|
|
jQuery.Callbacks('once memory'),
|
|
jQuery.Callbacks('once memory'),
|
|
'rejected',
|
|
],
|
|
[
|
|
'notify',
|
|
'progress',
|
|
jQuery.Callbacks('memory'),
|
|
jQuery.Callbacks('memory'),
|
|
],
|
|
];
|
|
|
|
jQuery.Deferred = function (func) {
|
|
var deferred = oldDeferred(),
|
|
promise = deferred.promise();
|
|
|
|
deferred.pipe = promise.pipe =
|
|
function (/* fnDone, fnFail, fnProgress */) {
|
|
var fns = arguments;
|
|
|
|
migrateWarn('deferred.pipe() is deprecated');
|
|
|
|
return jQuery
|
|
.Deferred(function (newDefer) {
|
|
jQuery.each(tuples, function (i, tuple) {
|
|
var fn = typeof fns[i] === 'function' && fns[i];
|
|
|
|
// Deferred.done(function() { bind to newDefer or newDefer.resolve })
|
|
// deferred.fail(function() { bind to newDefer or newDefer.reject })
|
|
// deferred.progress(function() { bind to newDefer or newDefer.notify })
|
|
deferred[tuple[1]](function () {
|
|
var returned = fn && fn.apply(this, arguments);
|
|
if (returned && typeof returned.promise === 'function') {
|
|
returned
|
|
.promise()
|
|
.done(newDefer.resolve)
|
|
.fail(newDefer.reject)
|
|
.progress(newDefer.notify);
|
|
} else {
|
|
newDefer[tuple[0] + 'With'](
|
|
this === promise ? newDefer.promise() : this,
|
|
fn ? [returned] : arguments
|
|
);
|
|
}
|
|
});
|
|
});
|
|
fns = null;
|
|
})
|
|
.promise();
|
|
};
|
|
|
|
if (func) {
|
|
func.call(deferred, deferred);
|
|
}
|
|
|
|
return deferred;
|
|
};
|
|
|
|
// Preserve handler of uncaught exceptions in promise chains
|
|
jQuery.Deferred.exceptionHook = oldDeferred.exceptionHook;
|
|
}
|
|
|
|
return jQuery;
|
|
}); |