Bundlers tests: @TITLE

Expected:	" + - expected + - "
Result:	" + - actual + "
Diff:	" + - QUnit.diff( expected, actual ) + "
Source:	" + - escapeText( details.source ) + "

Expected:

" +
-			expected +
-			"

Result:

" +
-				actual + "

Diff:

" +
-				QUnit.diff( expected, actual ) + "

Source:

" +
-				escapeText( details.source ) + "

Source:	" + - escapeText( details.source ) + "

" ) + .css( { position: "absolute", width: "500px", left: "-600px" } ) + .append( jQuery( " - -

- - - - -

- -

hi there

" ).appendTo( "#qunit-fixture" ); + + expectMessage( assert, "toggling initially empty class", 1, function() { + e.toggleClass( true ); + assert.equal( e[ 0 ].className, "", "Assert class is empty (data was empty)" ); + } ); + + expectNoMessage( assert, ".toggleClass( string ) not full className", 1, function() { + e.attr( "class", "" ); + e.toggleClass( "classy" ); + assert.equal( e.attr( "class" ), "classy", "class was toggle-set" ); + e.toggleClass( "classy", false ); + assert.equal( e.attr( "class" ), "", "class was toggle-removed" ); + } ); + + expectMessage( assert, ".toggleClass() save and clear", 1, function() { + e.addClass( "testD testE" ); + assert.ok( e.is( ".testD.testE" ), "Assert class present" ); + e.toggleClass(); + assert.ok( !e.is( ".testD.testE" ), "Assert class not present" ); + + // N.B.: Store should have "testD testE" now, next test will assert that + } ); + + expectMessage( assert, ".toggleClass() restore", 1, function() { + e.toggleClass(); + assert.ok( e.is( ".testD.testE" ), "Assert class present (restored from data)" ); + } ); + + expectMessage( assert, ".toggleClass( boolean )", 5, function() { + e.toggleClass( false ); + assert.ok( !e.is( ".testD.testE" ), "Assert class not present" ); + e.toggleClass( true ); + assert.ok( e.is( ".testD.testE" ), "Assert class present (restored from data)" ); + e.toggleClass(); + e.toggleClass( false ); + e.toggleClass(); + assert.ok( e.is( ".testD.testE" ), "Assert class present (restored from data)" ); + } ); +} ); diff --git a/test/unit/jquery/core.js b/test/unit/jquery/core.js new file mode 100644 index 00000000..a03e4deb --- /dev/null +++ b/test/unit/jquery/core.js @@ -0,0 +1,452 @@ + +QUnit.module( "core" ); + +function getTagNames( elem ) { + return elem.toArray().map( function( node ) { + return node.tagName.toLowerCase(); + } ); +} + +QUnit.test( "jQuery(html, props)", function( assert ) { + assert.expect( 2 ); + + var $el = jQuery( "", { name: "name", val: "value" } ); + + assert.equal( $el.attr( "name" ), "name", "Name attribute" ); + assert.equal( $el.val(), "value", "Call setter method" ); +} ); + +QUnit.test( "XSS injection (leading hash)", function( assert ) { + assert.expect( 1 ); + + var threw = false; + + try { + jQuery( "#yeah

RIGHT

" ); + } catch ( e ) { + threw = true; + } + + assert.equal( threw, true, "Throw on leading-hash HTML (treated as selector)" ); +} ); + +QUnit.test( "XSS injection (XSS via script tag)", function( assert ) { + assert.expect( 2 ); + + var threw = false; + window.XSS = false; + try { + jQuery( "#" ); + jQuery( "

" ).append( "" ); + jQuery( "" ); + } ); + + expectNoMessage( assert, "Elements not self-closable but tolerable", function() { + jQuery( "

" ); + jQuery( "

" ).append( "" ); + } ); + + expectNoMessage( assert, "Bare elements", function() { + jQuery( "

" ).append( "" ); + jQuery( "" ); + jQuery( "" ); + } ); + + window.alert = oldWindowAlert; +} ); diff --git a/test/unit/jquery/selector.js b/test/unit/jquery/selector.js new file mode 100644 index 00000000..886d6432 --- /dev/null +++ b/test/unit/jquery/selector.js @@ -0,0 +1,252 @@ +"use strict"; + +QUnit.module( "selector", { + beforeEach: function() { + + /* eslint-disable max-len */ + var template = "" + + "

See this blog entry for more information.

" + + "\n" + + "
" + + " Here are some [links] in a normal paragraph: Google," + + " Google Groups (Link)." + + " This link has class='blog':" + + " mozilla" + + "\n" + + "
" + + "
" + + "
Everything inside the red border is inside a div with id='foo'.
" + + "
This is a normal link: Yahoo
" + + "
This link has class='blog': Timmy Willison's Weblog
" + + "
" + + "\n" + + "
" + + " Action:" + + " " + + " " + + " " + + " " + + "
"; + /* eslint-enable */ + + jQuery( "#qunit-fixture" ).append( template ); + } +} ); + +( function() { + +/** + * Asserts that a select matches the given IDs. + * The select is not bound by a context. + * @param {Function} assert - The assert function passed from the test + * @param {String} message - Assertion name + * @param {String} selector - jQuery selector + * @param {String} expectedIds - Array of ids to construct what is expected + * @example testSelector("Check for something", "p", ["foo", "bar"]); + */ +function testSelector( assert, message, selector, expectedIds ) { + var r = [], + i = 0; + + var elems = jQuery( selector ).get(); + + for ( ; i < expectedIds.length; i++ ) { + r.push( document.getElementById( expectedIds[ i ] ) ); + } + + assert.deepEqual( elems, r, message + " (" + selector + ")" ); +} + +QUnit.test( "jQuery.expr.pseudos aliases", function( assert ) { + assert.expect( 7 ); + + expectMessage( assert, "jQuery.expr.filters", function() { + jQuery.expr.filters.mazda = function( elem ) { + return elem.style.zoom === "3"; + }; + } ); + + expectMessage( assert, "jQuery.expr[':']", function() { + jQuery.expr[ ":" ].marginal = function( elem ) { + return parseInt( elem.style.marginLeftWidth ) > 20; + }; + } ); + + expectNoMessage( assert, "jQuery.expr.pseudos", function() { + var fixture = jQuery( "#qunit-fixture" ).prepend( "
hello
" ); + + assert.ok( jQuery.expr.pseudos.mazda, "filters assigned" ); + assert.ok( jQuery.expr.pseudos.marginal, "[':'] assigned" ); + fixture.find( "p" ).first().css( "marginLeftWidth", "40px" ); + assert.equal( fixture.find( "p:marginal" ).length, 1, "One marginal element" ); + assert.equal( fixture.find( "div:mazda" ).length, 0, "No mazda elements" ); + delete jQuery.expr.pseudos.mazda; + delete jQuery.expr.pseudos.marginal; + } ); +} ); + +QUnit.test( "custom pseudos", function( assert ) { + assert.expect( 7 ); + + expectNoMessage( assert, "custom pseudos", function() { + try { + jQuery.expr.pseudos.foundation = jQuery.expr.pseudos.root; + assert.deepEqual( + jQuery.find( ":foundation" ), + [ document.documentElement ], + "Copy element filter with new name" + ); + } finally { + delete jQuery.expr.pseudos.foundation; + } + + try { + jQuery.expr.setFilters.primary = jQuery.expr.setFilters.first; + testSelector( + assert, + "Copy set filter with new name", + "div#qunit-fixture :primary", + [ "firstp" ] + ); + } finally { + delete jQuery.expr.setFilters.primary; + } + + try { + jQuery.expr.pseudos.aristotlean = jQuery.expr.createPseudo( function() { + return function( elem ) { + return !!elem.id; + }; + } ); + testSelector( + assert, + "Custom element filter", + "#foo :aristotlean", + [ "sndp", "en", "yahoo", "sap", "anchor2", "timmy" ] + ); + } finally { + delete jQuery.expr.pseudos.aristotlean; + } + + try { + jQuery.expr.pseudos.endswith = jQuery.expr.createPseudo( function( text ) { + return function( elem ) { + return jQuery.text( elem ).slice( -text.length ) === text; + }; + } ); + testSelector( + assert, + "Custom element filter with argument", + "a:endswith(ogle)", + [ "google" ] + ); + } finally { + delete jQuery.expr.pseudos.endswith; + } + + try { + jQuery.expr.setFilters.second = jQuery.expr.createPseudo( function() { + return jQuery.expr.createPseudo( function( seed, matches ) { + if ( seed[ 1 ] ) { + matches[ 1 ] = seed[ 1 ]; + seed[ 1 ] = false; + } + } ); + } ); + testSelector( assert, + "Custom set filter", + "#qunit-fixture p:second", + [ "ap" ] + ); + } finally { + delete jQuery.expr.pseudos.second; + } + + try { + jQuery.expr.setFilters.slice = jQuery.expr.createPseudo( function( argument ) { + var bounds = argument.split( ":" ); + return jQuery.expr.createPseudo( function( seed, matches ) { + var i = bounds[ 1 ]; + + // Match elements found at the specified indexes + while ( --i >= bounds[ 0 ] ) { + if ( seed[ i ] ) { + matches[ i ] = seed[ i ]; + seed[ i ] = false; + } + } + } ); + } ); + testSelector( + assert, + "Custom set filter with argument", + "#qunit-fixture p:slice(1:3)", + [ "ap", "sndp" ] + ); + } finally { + delete jQuery.expr.pseudos.slice; + } + } ); +} ); + +QUnit.test( "backwards-compatible custom pseudos", function( assert ) { + assert.expect( 7 ); + + var expectWarningWithProxy = typeof Proxy !== "undefined" ? + expectMessage : + function( _assert, _title, fn ) { + fn(); + assert.ok( true, "No Proxy => warnings not expected" ); + }; + + try { + expectWarningWithProxy( assert, "Custom element filter with argument - setter", function() { + jQuery.expr.pseudos.icontains = function( elem, i, match ) { + return jQuery + .text( elem ) + .toLowerCase() + .indexOf( ( match[ 3 ] || "" ).toLowerCase() ) > -1; + }; + } ); + expectMessage( assert, "Custom element filter with argument - getter", function() { + testSelector( + assert, + "Custom element filter with argument", + "a:icontains(THIS BLOG ENTRY)", + [ "john1" ] + ); + } ); + } finally { + delete jQuery.expr.pseudos.icontains; + } + + try { + expectWarningWithProxy( assert, "Custom setFilter pseudo - setter", function() { + jQuery.expr.setFilters.podium = function( elements, argument ) { + var count = argument == null || argument === "" ? 3 : +argument; + return elements.slice( 0, count ); + }; + } ); + expectMessage( assert, "Custom setFilter pseudo - getter", function() { + + // Using TAG as the first token here forces this setMatcher into a fail state + // Where the descendent combinator was lost + testSelector( + assert, + "Custom setFilter", + "form#form :PODIUM", + [ "label-for", "text1", "text2" ] + ); + testSelector( + assert, + "Custom setFilter with argument", + "#form input:Podium(1)", + [ "text1" ] + ); + } ); + } finally { + delete jQuery.expr.setFilters.podium; + } +} ); + +} )(); diff --git a/test/unit/migrate.js b/test/unit/migrate.js new file mode 100644 index 00000000..27a4865d --- /dev/null +++ b/test/unit/migrate.js @@ -0,0 +1,150 @@ + +QUnit.module( "migrate" ); + +QUnit.test( "jQuery.migrateVersion", function( assert ) { + assert.expect( 1 ); + + assert.ok( /^\d+\.\d+\.[\w\-]+/.test( jQuery.migrateVersion ), "Version property" ); +} ); + +QUnit.test( "compareVersions and jQueryVersionSince", function( assert ) { + assert.expect( 9 ); + + assert.equal( compareVersions( "3.0.1", "3.0.0" ), 1, "greater than 1" ); + assert.equal( compareVersions( "3.0.1", "2.10.0" ), 1, "greater than 2" ); + assert.equal( compareVersions( "3.2.1", "3.3.0" ), -1, "less than 1" ); + assert.equal( compareVersions( "3.2.1", "4.1.3" ), -1, "less than 2" ); + assert.equal( compareVersions( "3.2.2", "3.11.1" ), -1, "less than 3" ); + assert.equal( compareVersions( "3.4.1", "3.4.1" ), 0, "equal" ); + + + // Test against live jQuery version with suitably generous comparisons + assert.equal( jQueryVersionSince( "1.4.2" ), true, "since - past version" ); + assert.equal( jQueryVersionSince( "8.0.3" ), false, "since - future version" ); + assert.equal( jQueryVersionSince( jQuery.fn.jquery ), true, "since - equal" ); +} ); + +QUnit.test( "jQuery.migrateDeduplicateMessages", function( assert ) { + assert.expect( 3 ); + + var origValue = jQuery.migrateDeduplicateMessages; + assert.strictEqual( origValue, true, "true by default" ); + + jQuery.migrateDeduplicateMessages = true; + expectMessage( assert, "jQuery.migrateDeduplicateMessages === true", 1, function() { + jQuery.trim( " a " ); + jQuery.trim( "a" ); + } ); + + jQuery.migrateDeduplicateMessages = false; + expectMessage( assert, "jQuery.migrateDeduplicateMessages === false", 2, function() { + jQuery.trim( " a " ); + jQuery.trim( "a" ); + } ); + + jQuery.migrateDeduplicateMessages = origValue; +} ); + +QUnit.test( "disabling/enabling patches", function( assert ) { + assert.expect( 32 ); + + var elem = jQuery( "
" ); + + elem.appendTo( "#qunit-fixture" ); + + // We can't register new warnings in tests so we need to use + // existing warnings. If the ones we rely on here get removed, + // replace them with ones that still exist. + + // A few APIs that are not slated for removal to make these tests more stable: + assert.strictEqual( jQuery.migrateIsPatchEnabled( "pre-on-methods" ), + true, "patch enabled by default (pre-on-methods)" ); + assert.strictEqual( jQuery.migrateIsPatchEnabled( "proxy" ), + true, "patch enabled by default (proxy)" ); + assert.strictEqual( jQuery.migrateIsPatchEnabled( "shorthand-deprecated-v3" ), + true, "patch enabled by default (shorthand-deprecated-v3)" ); + + // APIs patched via `migratePatchAndWarnFunc` or `migratePatchAndInfoFunc`; + // we're testing that: + // * they don't warn on access but only when called + // * they don't exist (access evaluates to `undefined`) if patch is disabled + assert.strictEqual( jQuery.migrateIsPatchEnabled( "push" ), + true, "patch enabled by default (push)" ); + assert.strictEqual( jQuery.migrateIsPatchEnabled( "isArray" ), + true, "patch enabled by default (isArray)" ); + + // APIs patched via `migrateWarnProp` or `migrateInfoProp`; we're testing that: + // * they don't exist (access evaluates to `undefined`) if patch is disabled + assert.strictEqual( jQuery.migrateIsPatchEnabled( "event-global" ), + true, "patch enabled by default (event-global)" ); + + expectMessage( assert, "pre-on-methods (default)", function() { + jQuery().bind(); + } ); + expectMessage( assert, "proxy (default)", function() { + jQuery.proxy( jQuery.noop ); + } ); + expectMessage( assert, "shorthand-deprecated-v3 (default)", function() { + jQuery().click(); + } ); + expectMessage( assert, "push (default)", function() { + jQuery().push(); + } ); + expectMessage( assert, "isArray (default)", function() { + jQuery.isArray(); + } ); + expectMessage( assert, "event-global (default)", function() { + + // eslint-disable-next-line no-unused-expressions + jQuery.event.global; + } ); + + expectNoMessage( assert, "push access without calling (default)", function() { + assert.strictEqual( typeof jQuery().push, "function", + "access check doesn't trigger a message (push)" ); + } ); + expectNoMessage( assert, "isArray access without calling (default)", function() { + assert.strictEqual( typeof jQuery.isArray, "function", + "access check doesn't trigger a message (isArray)" ); + } ); + + jQuery.migrateDisablePatches( "pre-on-methods", "proxy", "push", "isArray", "event-global" ); + assert.strictEqual( jQuery.migrateIsPatchEnabled( "pre-on-methods" ), + false, "patch disabled (pre-on-methods)" ); + assert.strictEqual( jQuery.migrateIsPatchEnabled( "proxy" ), + false, "patch disabled (proxy)" ); + assert.strictEqual( jQuery.migrateIsPatchEnabled( "shorthand-deprecated-v3" ), + true, "patch still enabled (shorthand-deprecated-v3)" ); + assert.strictEqual( jQuery.migrateIsPatchEnabled( "push" ), + false, "patch disabled (push)" ); + assert.strictEqual( jQuery.migrateIsPatchEnabled( "event-global" ), + false, "patch disabled (event-global)" ); + + expectNoMessage( assert, "pre-on-methods (disabled)", function() { + jQuery().bind(); + } ); + expectNoMessage( assert, "proxy (disabled)", function() { + jQuery.proxy( jQuery.noop ); + } ); + expectMessage( assert, "shorthand-deprecated-v3 (not disabled)", function() { + jQuery().click(); + } ); + expectNoMessage( assert, "push (disabled)", function() { + assert.strictEqual( jQuery().push, undefined, "`jQuery.fn.push` no longer defined" ); + } ); + expectNoMessage( assert, "isArray (disabled)", function() { + assert.strictEqual( jQuery.isArray, undefined, "`jQuery.isArray` no longer defined" ); + } ); + expectNoMessage( assert, "event-global (disabled)", function() { + assert.strictEqual( jQuery.event.global, undefined, + "`jQuery.event.global` no longer defined" ); + } ); + + jQuery.migrateDisablePatches( "shorthand-deprecated-v3" ); + assert.strictEqual( jQuery.migrateIsPatchEnabled( "shorthand-deprecated-v3" ), + false, "patch disabled (shorthand-deprecated-v3)" ); + + expectNoMessage( assert, "shorthand-deprecated-v3 (disabled)", function() { + jQuery().click(); + } ); +} ); diff --git a/warnings.md b/warnings.md index ff64d8a7..8f9edfe7 100644 --- a/warnings.md +++ b/warnings.md @@ -1,198 +1,239 @@ # jQuery Migrate Plugin - Warning Messages -To allow developers to identify and fix compatibility issues when migrating older jQuery code, the development (uncompressed) version of the plugin generates console warning messages whenever any of its functionality is called. The messages only appear once on the console for each unique message. +**NOTE: This page lists the messages for jQuery Migrate 4.x. If you are using an earlier version, see the documentation on [the 1.x-stable branch](https://github.com/jquery/jquery-migrate/blob/1.x-stable/warnings.md) or [the 3.x-stable branch](https://github.com/jquery/jquery-migrate/blob/3.x-stable/warnings.md).** + +To allow developers to identify and fix compatibility issues when migrating older jQuery code, the development (uncompressed) version of the plugin generates console warning messages whenever any of its functionality is called. The messages only appear once on the console for each unique message. **In most cases these messages are simply _warnings_; code should continue to work properly with later versions of jQuery as long as the jQuery Migrate plugin is used, but we recommend changing the code where possible to eliminate warnings so that the plugin does not need to be used.** -The production (compressed) version of the plugin does not generate these warnings. To continue using jQuery code that has compatibility issues without making any changes and without console messages, simply include the production version in the file rather than the development version. See the [README](README.md) for download instructions. +The production (compressed) version of the plugin does not generate warnings. To continue using jQuery code that has compatibility issues without making any changes and without console messages, simply include the production version in the file rather than the development version. See the [README](README.md) for download instructions. -All warnings generated by this plugin start with the text "JQMIGRATE" for easy identification. The warning messages, causes, and remediation instructions are listed below. +All messages generated by this plugin start with the text "JQMIGRATE" for easy identification. The warning messages, causes, and remediation instructions are listed below. Items listed as **removed** - printed by `console.warn` must be changed before the code will work properly without the Migrate plugin. Items listed as only **deprecated** - printed by `console.info` - are still supported by the current version but no longer considered a good practice, and may be removed in the future. -### JQMIGRATE: Logging is active -This is _not_ a warning, but a console log message the plugin shows when it first loads to indicate that warnings will be shown when appropriate. If the minified version of the plugin is being used or `jQuery.migrateMute` was set to `true` before the plugin was loaded, the plugin will not show this message or any warnings. +## General logs & warnings -### JQMIGRATE: jQuery.attrFn is deprecated +### JQMIGRATE: Migrate is installed, version X +### JQMIGRATE: Migrate is installed with logging active, version X -**Cause:** Prior to jQuery 1.8, the undocumented `jQuery.attrFn` object provided a list of properties supported by the `$(html, props)` method. It is no longer required as of jQuery 1.8, but some developers "discovered" it by reading the source and began to use it. Their code still expects `jQuery.attrFn` to be present, attempts to assign values to it, and will throw errors if it is not present. +This is _not_ a warning, but a console log message the plugin shows when it first loads to indicate whether warnings will be shown on the console when appropriate. As of version 1.4.0 this message is also shown with production builds. The use jQuery Migrate in production has performance impacts and can complicate debugging as it modifies the normal behavior of the version of jQuery being used. -**Solution:** Ensure that you are using the latest version of jQuery UI (1.8.21 or later) and jQuery Mobile (1.2.1 or later); they no longer use `jQuery.attrFn`. Examine any third-party plugins for the string `attrFn` and report its use to the plugin authors (not to jQuery team). +### JQMIGRATE: jQuery 4.x REQUIRED -### JQMIGRATE: $(html) HTML strings must start with '<' character +**Cause:** The page does not have a version of jQuery installed, or is using a version of jQuery 5.0.0 or newer or older than 4.0.0. The jQuery Migrate plugin is not intended to be used for those cases. Any messages that follow this one may not be accurate, or the page may not run properly at all. -**Cause:** In jQuery 1.9, HTML strings passed to `$()` must start with a tag; in other words the first character of the string must be a `<` character. There _cannot_ be any preceding characters, including whitespace. This is done to reduce the chances of inadvertent execution of scripts that may be present in HTML that is obtained from the URL, AJAX, or other sources. Use of simple literal HTML strings like `$("
")` or `$("
hello
")` are unaffected since they should not have leading spaces or text. +**Solution:** See the [README](https://github.com/jquery/jquery-migrate/#readme) for more information on usage and upgrading from older versions. -**Solution**: Use the `$.parseHTML()` method to parse arbitrary HTML, especially HTML from external sources. To obtain a jQuery object that has the parsed HTML without running scripts, use `$($.parseHTML("string"))`. To run scripts in the HTML as well, use `$($.parseHTML("string", document, true))` instead. We do not recommend running `$.trim()` on the string to circumvent this check. +### JQMIGRATE: Migrate plugin loaded multiple times -### JQMIGRATE: $(html) text after last tag is ignored +**Cause:** The plugin detected that some version of jQuery Migrate is already loaded. Loading multiple versions can cause unpredictable behavior. -**Cause:** HTML strings passed to `$()` should begin and end with tags. Any text following the last tag is ignored. When upgrading to jQuery 1.9 and using `$.parseHTML()`, note that leading or trailing text is _not_ ignored, and those text nodes will be part of the data returned. +**Solution:** Remove all but the latest version of the jQuery Migrate plugin. See the [README](https://github.com/jquery/jquery-migrate/#readme) for more information on usage and upgrading from older versions. -**Solution**: Usually this warning is due to an error in the HTML string, where text is present when it should not be there. Remove the leading or trailing text before passing the string to `$.parseHTML()` if it should not be part of the collection. Alternatively you can use `$($.parseHTML(html)).filter("*")` to remove all top-level text nodes from the set and leave only elements. +### \[quirks\] JQMIGRATE: jQuery is not compatible with Quirks Mode -### JQMIGRATE: Can't change the 'type' of an input or button in IE 6/7/8 +**Cause:** A browser runs in "quirks mode" when the HTML document does not have a `` as its first non-blank line, or when the doctype in the file is invalid. This mode causes the browser to emulate 1990s-era (HTML3) behavior. In Internet Explorer, it also causes many high-performance APIs to be hidden in order to better emulate ancient browsers. jQuery has never been compatible with, or tested in, quirks mode. -**Cause:** IE 6, 7, and 8 throw an error if you attempt to change the type attribute of an input or button element, for example to change a radio button to a checkbox. Prior to 1.9, jQuery threw an error for every browser to create consistent behavior. As of jQuery 1.9 setting the type is allowed, but will still throw an error in oldIE. +**Solution:** Put a [valid doctype](http://www.w3.org/QA/2002/04/valid-dtd-list.html) in the document and ensure that the document is rendering in standards mode. The simplest valid doctype is the HTML5 one, which we highly recommend: `` . The jQuery Migrate plugin does not attempt to fix issues related to quirks mode. -**Solution:** For compatibility with oldIE, do not attempt to change the type of an input element. Instead, create a new element in your code and replace the old one. +### \[load-after-event\] JQMIGRATE: jQuery(window).on('load'...) called after load event occurred -### JQMIGRATE: jQuery is not compatible with Quirks Mode +**Cause:** The calling code has attempted to attach a `load` event to `window` after the page has already loaded. That means the handler will never run and so is probably not what the caller intended. This can occur when the event attachment is made too late, for example, in a jQuery ready handler. It can also occur when a file is loaded dynamically with jQuery after the page has loaded, for example using the `$.getScript()` method. -**Cause:** A browser runs in "quirks mode" when the HTML document does not have a `` as its first non-blank line, or when the doctype in the file is invalid. This mode causes the browser to emulate 1990s-era (HTML3) behavior. In Internet Explorer, it also causes many high-performance APIs to be hidden in order to better emulate ancient browsers. jQuery has never been compatible with, or tested in, quirks mode. +**Solution:** If a function `fn` does not actually depend on all page assets being fully loaded, switch to a ready handler `$( fn )` which runs earlier and will always run `fn` even if the script that contains the code loads long after the page has fully loaded. If `fn` actually does depend on the script being fully loaded, check `document.readyState`. If the value is `"complete"` run the function immediately, otherwise use `$(window).on( "load", fn )`. -**Solution:** Put a [valid doctype](http://www.w3.org/QA/2002/04/valid-dtd-list.html) in the document and ensure that the document is rendering in standards mode. The simplest valid doctype is the HTML5 one, which we highly recommend: `` . The jQuery Migrate plugin does not attempt to fix issues related to quirks mode. -### JQMIGRATE: jQuery.boxModel is deprecated -### JQMIGRATE: jQuery.support.boxModel is deprecated +## Removed APIs -**Cause:** These two deprecated properties are `false` when the page is using Quirks mode, and `true` when the page is in standards mode. Quirks mode was never supported in jQuery so these properties were removed. +### \[fx-interval\] JQMIGRATE: jQuery.fx.interval is removed -**Solution:** Do not use jQuery in Quirks mode, it has never been supported. See the previous item for solutions. +**Cause**: As of jQuery 4.0, the `jQuery.fx.interval` property is no longer consulted, and it's no longer possible to change the animation interval on browsers that do not support the `window.requestAnimationFrame()` method. -### JQMIGRATE: jQuery.parseJSON requires a valid JSON string +**Solution**: Find and remove code that changes or uses `jQuery.fx.interval`. If the value is being used by code in your page or a plugin, the code may be making assumptions that are no longer valid. The default value of `jQuery.fx.interval` is `13` (milliseconds), which could be used instead of accessing this property. -**Cause**: Before jQuery 1.9.0, the `$.parseJSON()` method allowed some invalid JSON strings and returned `null` as a result without throwing an error. This put it at odds with the `JSON.parse()` method. The two methods are aligned as of 1.9.0 and values such as an empty string are properly not considered valid by `$.parseJSON()`. +## \[boolean-attributes\] JQMIGRATE: Boolean attribute 'NAME' value is different from its lowercased name +### \[boolean-attributes\] JQMIGRATE: Boolean attribute 'NAME' value is not set to its lowercased name -**Solution:** If you want to consider values such as `""` or `false` successful and treat them as `null`, check for them before calling `$.parseJSON()`. Since falsy values such as an empty string were previously returned as a `null` without complaint, this code will suffice in most cases: -```js -var json = $.parseJSON(jsonString || "null"); -``` -If your own code is not calling `$.parseJSON()` directly, it is probably using AJAX to retrieve a JSON value from a server that is returning an empty string in the content body rather than a valid JSON response such as `null` or `{}`. If it isn't possible to correct the invalid JSON in the server response, you can retrieve the response as text: -```js -$.ajax({ - url: "...", - dataType: "text", - success: function( text ) { - var json = text? $.parseJSON(text) : null; - ... - } -}); -``` +**Cause**: Prior to jQuery 4.0, when calling `.attr( name, value )` with any non-`false` non-`null` `value`, jQuery would actually set it to `name`. Similarly, regardless of the actual value, `.attr( name )` used to return `name` lowercased. jQuery 4.0 removes this special behavior. -### JQMIGRATE: jQuery.browser is deprecated +**Solution**: Always set boolean attributes to their names, whether when using jQuery (`.attr( name, name )`), native APIs (`.setAttribute( name, name )`) or directly in HTML (``). Avoid using the `.attr( name )` getter on boolean attributes, `.prop( name )` is preferred. -**Cause:** `jQuery.browser` was deprecated in version 1.3, and finally removed in 1.9. Browser sniffing is notoriously unreliable as means of detecting whether to implement particular features. +### \[attr-false\] JQMIGRATE: Setting the non-ARIA non-boolean attribute 'NAME' to false -**Solution:** Where possible, use feature detection to make code decisions rather than trying to detect a specific browser. The [Modernizr](http://modernizr.com) library provides a wide variety of feature detections. As a last resort, you can directly look at the `navigator.userAgent` string to detect specific strings returned by the browser. +**Cause**: Prior to jQuery 4.0, calling `.attr( name, false )` was only removing the attribute when `name` was a boolean attribute; otherwise, it was setting the attribute value to `"false"`. In jQuery 4.x, it will remove any non-ARIA attribute. -### JQMIGRATE: jQuery.sub() is deprecated +**Solution**: If you want to set the value of an attribute to `"false"`, wrap it in quotes: `.attr( name, "false" )`. -**Cause:** The `jQuery.sub()` method provided an imperfect way for a plugin to isolate itself from changes to the `jQuery` object. Due to its shortcomings, it was deprecated in version 1.8 and removed in 1.9. +### \[parseJSON\] jQuery.parseJSON is removed; use JSON.parse -**Solution:** Rewrite the code that depends on `jQuery.sub()`, use the minified production version of the jQuery Migrate plugin to provide the functionality, or extract the `jQuery.sub()` method from the plugin's source and use it in the application. +**Cause**: The `jQuery.parseJSON` method in recent jQuery is identical to the native `JSON.parse`. As of jQuery 4.0 `jQuery.parseJSON` is removed. -### JQMIGRATE: 'hover' pseudo-event is deprecated, use 'mouseenter mouseleave' +**Solution**: Replace any use of `jQuery.parseJSON` with `JSON.parse`. -**Cause:** Until jQuery 1.9, the string "hover" was allowed as an alias for the string "mouseenter mouseleave" when attaching an event handler. This unusual exception provided no real benefit and prevented the use of the name "hover" as a triggered event. _Note: This is not related to the `.hover()` method, which has not been deprecated._ +### \[isNumeric\] JQMIGRATE: jQuery.isNumeric() is removed -**Solution:** Replace use of the string "hover" with "mouseenter mouseleave" within any `.on()`, `.bind()`, `.delegate()`, or `.live()` event binding method. +**Cause**: This method was used by jQuery to determine if certain string arguments could be converted to numbers, but the name led people to apply their own interpretations to what the method means. As a result, it often doesn't meet the needs of specific cases. For example, a 25-character string of only digits is technically a valid number, but JavaScript cannot represent it accurately. The string `"0x251D"` is a valid hexadecimal number but may not be acceptable numeric input to a web form. -### JQMIGRATE: jQuery.fn.error() is deprecated +**Solution**: Use a test for being numeric that makes sense for the specific situation. For example, instead of `jQuery.isNumeric(string)`, use `isNan(parseFloat(string))` if a floating point number is expected, or `string.test(/^[0-9]{1,8}$/)` if a sequence of 1 to 8 digits is expected. -**Cause:** The `$().error()` method was used to attach an "error" event to an element but has been removed in 1.9 to reduce confusion with the `$.error()` method which is unrelated and has not been deprecated. It also serves to discourage the temptation to use `$(window).error()` which does not work because `window.onerror` does not follow standard event handler conventions. +### \[type\] JQMIGRATE: jQuery.type() is removed -**Solution:** Change any use of `$().error(fn)` to `$().on("error", fn)`. +**Cause**: This method returns a string that indicates the type of the argument, for example `"number"` or `"function"`. However, as the JavaScript language evolves this method has become problematic because new language constructs might require this function to either return a new string (potentially breaking existing code) or somehow map new constructs into existing strings (again, potentially breaking existing code). Examples of new recent JavaScript features include asynchronous functions, class constructors, `Symbol`s, or functions that act as iterators. -### JQMIGRATE: jQuery.fn.toggle(handler, handler...) is deprecated +**Solution**: Review code that uses `jQuery.type()` and use a type check that is appropriate for the situation. For example. if the code expects a plain function, check for `typeof arg === "function"`. -**Cause:** There are two completely different meanings for the `.toggle()` method. The use of `.toggle()` to show or hide elements is _not_ affected. The use of `.toggle()` as a specialized click handler was deprecated in 1.8 and removed in 1.9. +### \[push\] JQMIGRATE: jQuery.fn.push() is removed; use .add or convert to an array +### \[sort\] JQMIGRATE: jQuery.fn.sort() is removed; convert to an array before sorting +### \[splice\] JQMIGRATE: jQuery.fn.splice() is removed; use .slice() or .not() with .eq() -**Solution:** Rewrite the code that depends on `$().toggle()`, use the minified production version of the jQuery Migrate plugin to provide the functionality, or extract the `$().toggle()` method from the plugin's source and use it in the application. +**Cause**: jQuery used to add the Array `push`, `sort` & `splice` methods to the jQuery prototype. They behaved differently to other jQuery APIs - they modify the jQuery collections in place, they don't play nice with APIs like `.end()`, they were also never documented. -### JQMIGRATE: jQuery.fn.live() is deprecated; jQuery.fn.die() is deprecated +**Solution**: Replace `.push( node )` with `.add( node )`, `.splice( index )` with `.not( elem.eq( index ) )`. In more complex cases, call `.toArray()` first, manipulate the resulting array and convert back to the jQuery object by passing the resulting array to `$()`. -**Cause:** The `.live()` and `.die()` methods were deprecated in 1.7 due to their [performance and usability drawbacks](http://api.jquery.com/live), and are no longer supported. +### \[unique\] JQMIGRATE: jQuery.unique() is removed; use jQuery.uniqueSort() -**Solution:** Rewrite calls to `.live()` using `.on()` or `.delegate()`. Instructions for doing so are provided in the [`.live()` API documentation](http://api.jquery.com/live). +**Cause**: The fact that `jQuery.unique` sorted its results in DOM order was surprising to many who did not read the documentation carefully. The function was renamed in jQuery 3.0 to make it clear. As of jQuery 4.0, the old alias no longer exists. -### JQMIGRATE: AJAX events should be attached to document +**Solution**: Replace all uses of `jQuery.unique` with `jQuery.uniqueSort` which is the same function with a better name. -**Cause:** As of jQuery 1.9, the global AJAX events (ajaxStart, ajaxStop, ajaxSend, ajaxComplete, ajaxError, and ajaxSuccess) are only triggered on the `document` element. +### \[toggleClass-bool\] JQMIGRATE: `jQuery.fn.toggleClass( \[ boolean \] ) is removed` -**Solution:** Change the program to listen for the AJAX events on the document. For example, if the code currently looks like this: -```javascript -$("#status").ajaxStart(function(){ $(this).text("Ajax started"); }); -``` -Change it to this: -```javascript -$(document).ajaxStart(function(){ $("#status").text("Ajax started"); }); -``` +**Cause:** Calling `.toggleClass()` with no arguments, or with a single Boolean `true` or `false` argument, has been deprecated. Its behavior was poorly documented, but essentially the method saved away the current `class` value in a data item when the class was removed and restored the saved value when it was toggled back. If you do not believe you are specifically trying to use this form of the method, it is possible you are accidentally doing so via an inadvertent undefined value, as `.toggleClass( undefined )` toggles all classes. -### JQMIGRATE: Global events are undocumented and deprecated +**Solution:** If this functionality is still needed, save the current full `.attr( "class" )` value in a data item and restore it when required. -**Cause:** jQuery 1.9 does not support globally triggered events. The only documented global events were the AJAX events and they are now triggered only on `document` as discussed above. jQuery never provided a documented interface for outside code to trigger global events. +### \[isFunction\] JQMIGRATE: jQuery.isFunction() is removed -**Solution:** Change the program to avoid the use of global events. The jQuery Migrate plugin warns about this case but does _not_ restore the previous behavior since it was undocumented. +**Cause:** This method returns `true` if its argument is thought to be a function. It was created to work around bugs in `typeof` implementations in legacy browsers. -### JQMIGRATE: jQuery.event.handle is undocumented and deprecated +**Solution:** Replace any use of `jQuery.isFunction( x )` with `typeof x === "function"`. -**Cause:** `jQuery.event.handle` was never documented, and deprecated with jQuery 1.7 (see http://forum.jquery.com/topic/deprecated-event-properties-used-in-jquery). As of jQuery 1.9, it has been removed. +### \[isWindow\] jQuery.isWindow() is removed -**Solution:** Use documented jQuery APIs, such as [`.trigger`](http://api.jquery.com/trigger/). +**Cause:** This method returns `true` if its argument is thought to be a `window` element. It was created for internal use and is not a reliable way of detecting `window` for public needs. -### JQMIGRATE: jQuery.fn.attr('value') no longer gets properties +**Solution:** Remove any use of `jQuery.isWindow()` from code. If it is truly needed it can be replaced with a check for `obj != null && obj === obj.window` which was the test used inside this method. -**Cause**: Prior to jQuery 1.9, `$().attr("value")` retrieved the value *property* instead of the value *attribute* (which generally reflects the value that was read from HTML markup). This caused inconsistent behavior with selectors referencing the value attribute. +### \[nodeName\] JQMIGRATE: jQuery.nodeName() is removed -**Solution**: Use `$().val()` (for form controls) or `$().prop("value")` (for other elements) to get the *current* value, and try to explicitly limit the use of `[value=…]` in selectors to `input` and/or `option` elements wherever possible. +**Cause:** This public but never-documented method has been deprecated as of jQuery 3.2.0 and removed as of jQuery 4.0.0. -### JQMIGRATE: jQuery.fn.attr('value', val) no longer sets properties +**Solution:** Replace calls such as `jQuery.nodeName( elem, "div" )` with a test such as `elem.nodeName.toLowerCase() === "div"`. -**Cause**: Prior to jQuery 1.9, `$().attr( "value", val )` set the value *property* instead of the value *attribute*. This caused inconsistent behavior with selectors referencing the value attribute. +### \[cssProps\] JQMIGRATE: jQuery.cssProps is removed -**Solution**: Use `$().val( val )` (for form controls) or `$().prop( "value", val )` (for other elements) to set the *current* value. +**Cause:** The `jQuery.cssProps` property is a public but undocumented object that allows CSS properties with one name to be mapped into another name. It was used for legacy browsers like IE8 that used non-standard names. This object is no longer used inside jQuery since all supported browsers now use the standard CSS property names. -### JQMIGRATE: jQuery.fn.attr('selected') may use property instead of attribute +**Solution:** Remove any uses of `jQuery.cssProps` in application code. -**Cause**: Prior to jQuery 1.9, `$().attr("checked")` etc. would sometimes use the checked|selected *property* instead of the *attribute* when interacting with non-XML elements, despite the fact that browsers and the HTML specifications allow the properties (current state) to differ from the attributes (initial/default state). This was a holdover from earlier versions of jQuery that did not offer `$().prop`. +### \[isArray\] JQMIGRATE: jQuery.isArray() is removed; use Array.isArray() -**Solution**: Boolean properties should generally not be passed to `$().attr` at all; replace with `$().prop` unless you truly intend to update the underlying HTML *attribute*. +**Cause:** Older versions of JavaScript made it difficult to determine if a particular object was a true Array, so jQuery provided a cross-browser function to do the work. The browsers supported by jQuery 3.0 all provide a standard method for this purpose. -### JQMIGRATE: deferred.pipe() is deprecated +**Solution:** Replace any calls to `jQuery.isArray` with `Array.isArray`. -**Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function. +### \[trim\] JQMIGRATE: jQuery.trim() is removed; use String.prototype.trim -**Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0. +**Cause:** Older versions of IE & Android Browser didn't implement a method to `trim` strings so jQuery provided a cross-browser implementation. The browsers supported by jQuery 4.x all provide a standard method for this purpose. + +**Solution:** Replace any calls to `jQuery.trim( text )` with `text.trim()` if you know `text` is a string; otherwise, you can replace it with `String.prototype.trim.call( text == null ? "" : text )`. + +### \[now\] JQMIGRATE: jQuery.now() is removed; use Date.now + +**Cause:** The `jQuery.now()` method was a simple alias for `Date.now()`, which is now supported in all browsers supported by jQuery 4.0. + +**Solution:** Replace any calls to `jQuery.now()` with `Date.now()`. + +### \[camelCase\] JQMIGRATE: jQuery.camelCase() is removed + +**Cause:** The `jQuery.camelCase()` method was a utility to convert dashed strings like `"background-color"` into camel-cased strings like `"backgroundColor"`. This method was never documented and is removed as of jQuery 4.0. + +**Solution:** Use a custom utility. + +### \[css-number\] JQMIGRATE: Auto-appending 'px' to number-typed values for jQuery.fn.css( _(property name)_, value ) is removed + +**Cause:** In past versions, when a number-typed value was passed to `.css()` jQuery converted it to a string and added `"px"` to the end. As the CSS standard has evolved, an increasingly large set of CSS properties now accept values that are unitless numbers, where this behavior is incorrect. It has become impractical to manage these exceptions in the `jQuery.cssNumber` object. In addition, some CSS properties like `line-height` can accept both a bare number `2` or a pixel value `2px`. jQuery cannot know the correct way to interpret `$.css("line-height", 2)` and currently treats it as `"2px"`. + +**Solution:** Always pass string values to `.css()`, and explicitly add units where required. For example, use `$.css("line-height", "2")` to specify 200% of the current line height or `$.css("line-height", "2px")` to specify pixels. When the numeric value is in a variable, ensure the value is converted to string, e.g. `$.css("line-height", String(height))` and `$.css("line-height", height+"px")`. + +### \[data-null-proto\] Accessing properties from jQuery.data() inherited from Object.prototype is removed +### \[data-null-proto\] Setting properties from jQuery.data() inherited from Object.prototype is removed +### \[data-null-proto\] Accessing properties from jQuery.fn.data() inherited from Object.prototype is removed +### \[data-null-proto\] Setting properties from jQuery.fn.data() inherited from Object.prototype is removed -### JQMIGRATE: deferred.isResolved() is deprecated -### JQMIGRATE: deferred.isRejected() is deprecated +**Cause:** As of jQuery 4.0.0, data objects no longer inherit from `Object.prototype`. This includes properties like `__proto__` or `hasOwnProperty`. -**Cause**: As of jQuery 1.7, the `isResolved()` and `isRejected` methods of the `jQuery.Deferred` object have been deprecated. They were removed in jQuery 1.8 and are no longer available in later versions. +**Solution:** Don't use properties inherited from `Object.prototype` on data objects. Instead of `jQuery.data( node ).hasOwnProperty( "foo" )` use `Object.hasOwn( jQuery.data( node ), "foo" )` or, if you need to support older browsers like IE 11, use `Object.prototype.hasOwnProperty.call( jQuery.data( node ), "foo" )`. -**Solution**: To determine the state of a Deferred object, call `deferred.state()` and check for a `"resolved"` or `"rejected"` string values. +### \[self-closed-tags\] JQMIGRATE: HTML tags must be properly nested and closed: _(HTML string)_ + +**Cause:** jQuery 3.5.0 changed the way it processes HTML strings. Previously, jQuery would attempt to fix self-closed tags like `` that the HTML5 specification says are not self-closed, turning it into ``. This processing can create a [security problem](https://nvd.nist.gov/vuln/detail/CVE-2020-11022) with malicious strings, so the functionality had to be removed. + +**Solution:** Search for the reported HTML strings and edit the tags to close them explicitly. In some cases the strings passed to jQuery may be created inside the program and thus not searchable. Migrate warning messages include a stack trace that can be used to find the location of the usage in the code. + +### \[jsonp-promotion\] JQMIGRATE: JSON-to-JSONP auto-promotion is removed + +**Cause:** `jQuery.ajax` calls with `dataType: 'json'` with a provided callback are automatically converted by jQuery to JSONP requests unless the options also specify `jsonp: false`. Auto-promoting JSON requests to JSONP introduces a security risk as the developer may be unaware they're not just downloading data but executing code from a remote domain. This auto-promoting behavior has been removed in jQuery 4.0.0. + +**Solution:** To trigger a JSONP request, specify the `dataType: "jsonp"` option. + +### \[deferred-getStackHook\] JQMIGRATE: jQuery.Deferred.getStackHook is removed; use jQuery.Deferred.getErrorHook + +**Cause:** `jQuery.Deferred.getStackHook` was originally created to pass the stack trace from before an async barrier to report when a user error (like calling a non-existing function) causes a promise to be rejected. However, passing a stack trace doesn't take source maps into account, so we started advising to pass the whole error object. To make it clearer, we also renamed the API to `jQuery.Deferred.getErrorHook`. The legacy alias has been removed in jQuery 4.0.0. + +**Solution:** Rename all usage of `jQuery.Deferred.getStackHook` to `jQuery.Deferred.getErrorHook`. If you previously assigned a function returning an error stack to `jQuery.Deferred.getStackHook` or `jQuery.Deferred.getErrorHook`, change it to return a full error object. If you aim to still support jQuery <3.7, assign the hook to `jQuery.Deferred.getErrorHook` first and only later to `jQuery.Deferred.getStackHook` to avoid a Migrate warning. + +### \[event-global\] JQMIGRATE: jQuery.event.global is removed + +**Cause:** `jQuery.event.global` was an object with keys being event names for which event listeners have ever been added. Originally, it was needed for performance reasons and to fix memory leaks in old IE, but since jQuery 1.9.0, the library has only been recording the events, but it was not using that information anywhere. jQuery 4.0.0 removes the API. + +**Solution:** Remove all usage of `jQuery.event.global`; it's unlikely any existing usage is needed. + + +## Deprecated APIs + +### \[deferred-pipe\] JQMIGRATE: deferred.pipe() is deprecated + +**Cause**: The `.pipe()` method on a `jQuery.Deferred` object was deprecated as of jQuery 1.8, when the `.then()` method was changed to perform the same function. + +**Solution**: In most cases it is sufficient to change all occurrences of `.pipe()` to `.then()`. Ensure that you aren't relying on context/state propagation (e.g., using `this`) or synchronous callback invocation, which were dropped from `.then()` for Promises/A+ interoperability as of jQuery 3.0. -### JQMIGRATE: jQuery.clean() is deprecated +### \[pre-on-methods\] JQMIGRATE: jQuery.fn.bind() is deprecated +### \[pre-on-methods\] JQMIGRATE: jQuery.fn.unbind() is deprecated +### \[pre-on-methods\] JQMIGRATE: jQuery.fn.delegate() is deprecated +### \[pre-on-methods\] JQMIGRATE: jQuery.fn.undelegate() is deprecated -**Cause**: `jQuery.buildFragment()` and `jQuery.clean()` are undocumented internal methods. The signature of `jQuery.buildFragment()` was changed in jQuery 1.8 and 1.9, and `jQuery.clean()` was removed in 1.9. However, we are aware of some plugins or other code that may be using them. +**Cause:**: These event binding methods have been deprecated in favor of the `.on()` and `.off()` methods which can handle both delegated and direct event binding. Although the older methods are still present in jQuery 4.x, they may be removed as early as the next major-version update. -**Solution**: Rewrite any code that makes use of these or any other undocumented methods. For example the `jQuery.parseHTML()` method, introduced in jQuery 1.8, can convert HTML to an array of DOM elements that you can append to a document fragment. +**Solution**: Change the method call to use `.on()` or `.off()`, the documentation for the old methods include specific instructions. In general, the `.bind()` and `.unbind()` methods can be renamed directly to `.on()` and `.off()` respectively since the argument orders are identical. -### JQMIGRATE: Use of jQuery.fn.data('events') is deprecated +### \[expr-pre-pseudos\] JQMIGRATE: jQuery.expr\[':'\] is deprecated; use jQuery.expr.pseudos +### \[expr-pre-pseudos\] JQMIGRATE: jQuery.expr.filters is deprecated; use jQuery.expr.pseudos -**Cause**: Prior to 1.9, `.data("events")` could be used to retrieve jQuery's undocumented internal event data structure for an element if no other code had defined a data element with the name "events". This special case has been removed in 1.9. +**Cause:** The standard way to add new custom selectors through jQuery is `jQuery.expr.pseudos`. These two other aliases are deprecated, although they still work as of jQuery 4.0. -**Solution**: There is no public interface to retrieve this internal data structure, and it remains undocumented. The only useful applications might be for debugging. The data is available via `jQuery._data("events")` but this is not a documented interface. +**Solution:** Rename any of the older usage to `jQuery.expr.pseudos`. The functionality is identical. -### JQMIGRATE: HTML string cannot start with a '#' character +### \[holdReady\] JQMIGRATE: jQuery.holdReady() is deprecated -**Cause**: Some pages unwisely use code similar to `$(location.hash)` in order to select what they think is going to be an ID value encoded on the page. However, an attacker can create a cross-site scripting (XSS) injection by using a string similar to `#` and run code to steal user data. The Migrate plugin does not allow a string of this form to be used. +**Cause:** The `jQuery.holdReady()` method has been deprecated due to its detrimental effect on the global performance of the page. This method can prevent all the code on the page from initializing for extended lengths of time. -**Solution**: If you are creating HTML that absolutely requires leading text, use `$.parseHTML` and pass the results to `$()`. +**Solution:** Rewrite the page so that it does not require all jQuery ready handlers to be delayed. This might be accomplished, for example, by late-loading only the code that requires the delay when it is safe to run. Due to the complexity of this method, jQuery Migrate does not attempt to fill the functionality. If the underlying version of jQuery used with jQuery Migrate no longer contains `jQuery.holdReady()` the code will fail shortly after this warning appears. -### JQMIGRATE: jQuery.fn.andSelf() replaced by jQuery.fn.addBack() +### \[proxy\] JQMIGRATE: jQuery.proxy() is deprecated -**Cause**: The `.andSelf()` method has been renamed to `.addBack()` as of jQuery 1.9 to better reflect its purpose of adding back the previous set of results. +**Cause:** This method, while having some differences, is similar to native `Function.prototype.bind` so it got deprecated to promote usage of native `bind`. -**Solution**: Replace any use of `.andSelf()` with `.addBack()`. +**Solution:** Replace any calls to `jQuery.proxy(fn, context, param1, param2)` with `fn.bind(context, param1, param2)`. Be careful if you use a proxied function for event handling as jQuery matches a proxied function to its original when removing event handlers which is not the case when native `bind` is used. -### JQMIGRATE: jQuery.fn.size() is deprecated; use the .length property +### \[shorthand-deprecated-v3\] JQMIGRATE: jQuery.fn.click() event shorthand is deprecated -**Cause**: The `.size()` method returns the number of elements in the current jQuery object, but duplicates the more-efficient `.length` property which provides the same functionality. As of jQuery 1.9 the `.length` property is the preferred way to retrieve this value. +**Cause:** The `.on()` and `.trigger()` methods can set an event handler or generate an event for any event type, and should be used instead of the shortcut methods. This message also applies to the other event shorthands, including: blur, focus, focusin, focusout, resize, scroll, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, and contextmenu. -**Solution**: Replace any use of `.size()` with `.length`. +**Solution:** Instead of `.click(fn)` use `.on("click", fn)`. Instead of `.click()` use `.trigger("click")`. -### JQMIGRATE: jQuery.swap() is undocumented and deprecated +### \[hover\] JQMIGRATE: jQuery.fn.hover() is deprecated -**Cause**: The `jQuery.swap()` method temporarily exchanges a set of CSS properties. It was never documented as part of jQuery's public API and should not be used because it can cause performance problems due to forced layout. +**Cause:** The `.hover()` method is a shorthand for the use of the `mouseover`/`mouseout` events. It is often a poor user interface choice because it does not allow for any small amounts of delay between when the mouse enters or exits an area and when the event fires. This can make it quite difficult to use with UI widgets such as drop-down menus. For more information on the problems of hovering, see the [hoverIntent plugin](http://cherne.net/brian/resources/jquery.hoverIntent.html). -**Solution**: Rework the code to avoid calling `jQuery.swap()`, or explicitly set and restore the properties you need to change. +**Solution:** Review uses of `.hover()` to determine if they are appropriate, and consider use of plugins such as `hoverIntent` as an alternative. The direct replacement for `.hover(fn1, fn2)`, is `.on("mouseenter", fn1).on("mouseleave", fn2)`.

" + escapeText( document.title ) + "

" + escapeText( document.title ) + "