composer/iTop
6
0
Fork 0
mirror of https://github.com/Combodo/iTop.git synced 2026-02-13 07:24:13 +01:00
Code Issues Packages Projects Releases Wiki Activity

N°7331 - Remove unnecessary files from node_modules

Browse Source
This commit is contained in:
Molkobain
2024-03-11 16:01:03 +01:00
parent 8c1d986a03
commit 43a8152de1
242 changed files with 17 additions and 62111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
node_modules/jquery-migrate/test/.eslintrc.json generated vendored
View File

@@ -1,34 +0,0 @@
{
"extends": "../src/.eslintrc.json",
"root": true,
"env": {
"browser": true,
"node": false
},
// Support: IE <=9 only, Android <=4.0 only
// The above browsers are failing a lot of tests in the ES5
// test suite at http://test262.ecmascript.org.
"parserOptions": {
"ecmaVersion": 3
},
"globals": {
"expectWarning": true,
"expectNoWarning": true,
"TestManager": true,
"jQuery": true,
"QUnit": true,
"module": true,
"ok": true,
"equal": true,
"test": true,
"asyncTest": true,
"notEqual": true,
"deepEqual": true,
"strictEqual": true,
"notStrictEqual": true,
"start": true,
"stop": true,
"expect": true
}
}

24
node_modules/jquery-migrate/test/ajax.js generated vendored
View File

@@ -1,24 +0,0 @@
QUnit.module( "ajax" );
QUnit.test( "jQuery.ajax() deprecations on jqXHR", function( assert ) {
assert.expect( 3 );
var done = assert.async();
expectWarning( assert, ".success(), .error(), .compete() calls", 3, function() {
jQuery.ajax( "/not-found.404" )
.success( jQuery.noop )
.error( function( jQXHR ) {
// Local file errors returns 0, pretend it's a 404
assert.equal( jQXHR.status || 404, 404, "ajax error" );
} )
.complete( function() {
assert.ok( true, "ajax complete" );
// Wait for expectWarning to complete
setTimeout(done, 1);
} );
} );
} );

87
node_modules/jquery-migrate/test/attributes.js generated vendored
View File

@@ -1,87 +0,0 @@
QUnit.module( "attributes" );
QUnit.test( ".removeAttr( boolean attribute )", function( assert ) {
assert.expect( 8 );
expectNoWarning( assert, "non-boolean attr", function() {
var $div = jQuery( "<div />" )
.attr( "quack", "duck" )
.removeAttr( "quack" );
assert.equal( $div.attr( "quack" ), null, "non-boolean attribute was removed" );
assert.equal( $div.prop( "quack" ), undefined, "property was not set" );
} );
expectWarning( assert, "boolean attr", function() {
var $inp = jQuery( "<input type=checkbox/>" )
.attr( "checked", "checked" )
.prop( "checked", true )
.removeAttr( "checked" );
assert.equal( $inp.attr( "checked" ), null, "boolean attribute was removed" );
assert.equal( $inp.prop( "checked" ), false, "property was changed" );
} );
// One warning per attribute name
expectWarning( assert, "multiple boolean attr", 2, function() {
jQuery( "<input type=checkbox/>" )
.attr( "checked", "checked" )
.attr( "readonly", "readonly" )
.removeAttr( "checked readonly" );
} );
expectWarning( assert, "mixed attr, one boolean", function() {
jQuery( "<input />" )
.attr( "type", "text" )
.attr( "size", "15" )
.attr( "disabled", "disabled" )
.removeAttr( "disabled" )
.removeAttr( "size" );
} );
} );
QUnit.test( ".toggleClass( boolean )", function( assert ) {
assert.expect( 14 );
var e = jQuery( "<div />" ).appendTo( "#qunit-fixture" );
expectWarning( assert, "toggling initially empty class", function() {
e.toggleClass( true );
assert.equal( e[ 0 ].className, "", "Assert class is empty (data was empty)" );
} );
expectNoWarning( assert, ".toggleClass( string ) not full className", 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" );
} );
expectWarning( 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
} );
expectWarning( assert, ".toggleClass() restore", 1, function() {
e.toggleClass();
assert.ok( e.is( ".testD.testE" ), "Assert class present (restored from data)" );
} );
expectWarning( assert, ".toggleClass( boolean )", 1, 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)" );
} );
} );

23
node_modules/jquery-migrate/test/core-jquery2.html generated vendored
View File

@@ -1,23 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jQuery Migrate old-jQuery initialization test</title>
<!-- Load older jQuery, then jquery-migrate plugin file based on URL -->
<script src="./data/jquery-2.2.3.js"></script>
<script src="iframeTest.js"></script>
<script src="testinit.js"></script>
<script>
jQuery.noConflict();
TestManager.loadProject( "jquery-migrate", "dev", true );
</script>
<script>
// Should have logged during initialization
startIframeTest();
</script>
</head>
<body>
<p>jQuery Migrate old-jQuery initialization test</p>
</body>
</html>

328
node_modules/jquery-migrate/test/core.js generated vendored
View File

@@ -1,328 +0,0 @@
QUnit.module( "core" );
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(html, props)", function( assert ) {
assert.expect( 3 );
var $el = jQuery( "<input/>", { name: "name", val: "value", size: 42 } );
assert.equal( $el.attr( "name" ), "name", "Name attribute" );
assert.equal( $el.attr( "size" ),
jQuery.isEmptyObject( jQuery.attrFn ) ? undefined : "42", "Size attribute" );
assert.equal( $el.val(), "value", "Call setter method" );
} );
QUnit.test( "jQuery( '#' )", function( assert ) {
assert.expect( 2 );
expectWarning( assert, "Selector, through the jQuery constructor, nothing but hash", function() {
var set = jQuery( "#" );
assert.equal( set.length, 0, "empty set" );
} );
} );
QUnit.test( "Attribute selectors with unquoted hashes", function( assert ) {
assert.expect( 31 );
var markup = jQuery(
"<div>" +
"<div data-selector='a[href=#main]'></div>" +
"<a href='space#junk'>test</a>" +
"<link rel='good#stuff' />" +
"<p class='space #junk'>" +
"<a href='#some-anchor'>anchor2</a>" +
"<input value='[strange*=#stuff]' />" +
"<a href='#' data-id='#junk'>anchor</a>" +
"</p>" +
"</div>" ).appendTo( "#qunit-fixture" ),
// No warning, no need to fix
okays = [
"a[href='#some-anchor']",
"[data-id=\"#junk\"]",
"div[data-selector='a[href=#main]']",
"input[value~= '[strange*=#stuff]']"
],
// Fixable, and gives warning
fixables = [
"a[href=#]",
"a[href*=#]:not([href=#]):first-child",
".space a[href=#]",
"a[href=#some-anchor]",
"link[rel*=#stuff]",
"p[class *= #junk]",
"a[href=space#junk]"
],
// False positives that still work
positives = [
"div[data-selector='a[href=#main]']:first",
"input[value= '[strange*=#stuff]']:eq(0)"
],
// Failures due to quotes and jQuery extensions combined
failures = [
"p[class ^= #junk]:first",
"a[href=space#junk]:eq(1)"
];
expectNoWarning( assert, "Perfectly cromulent selectors are unchanged", function() {
okays.forEach( function( okay ) {
assert.equal( jQuery( okay, markup ).length, 1, okay );
assert.equal( markup.find( okay ).length, 1, okay );
} );
} );
expectWarning( assert, "Values with unquoted hashes are quoted", fixables.length, function() {
fixables.forEach( function( fixable ) {
assert.equal( jQuery( fixable, markup ).length, 1, fixable );
assert.equal( markup.find( fixable ).length, 1, fixable );
} );
} );
expectWarning( assert, "False positives", positives.length, function() {
positives.forEach( function( positive ) {
assert.equal( jQuery( positive, markup ).length, 1, positive );
assert.equal( markup.find( positive ).length, 1, positive );
} );
} );
expectWarning( assert, "Unfixable cases", failures.length, function() {
failures.forEach( function( failure ) {
try {
jQuery( failure, markup );
assert.ok( false, "Expected jQuery() to die!" );
} catch ( err1 ) { }
try {
markup.find( failure );
assert.ok( false, "Expected .find() to die!" );
} catch ( err2 ) { }
} );
} );
// Ensure we don't process jQuery( x ) when x is a function
expectNoWarning( assert, "ready function with attribute selector", function() {
try {
jQuery( function() {
if ( jQuery.thisIsNeverTrue ) {
jQuery( "a[href=#]" );
}
} );
} catch ( e ) {}
} );
} );
QUnit.test( "XSS injection (leading hash)", function( assert ) {
assert.expect( 1 );
var threw = false;
try {
jQuery( "#yeah<p>RIGHT</p>" );
} 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( "#<script>window.XSS=true<" + "/script>" );
} catch ( e ) {
threw = true;
}
assert.equal( threw, true, "Throw on leading-hash HTML (treated as selector)" );
assert.equal( window.XSS, false, "XSS" );
} );
QUnit.test( "XSS injection (XSS with hash and leading space)", function( assert ) {
assert.expect( 2 );
var threw = false;
window.XSS = false;
try {
jQuery( " \n#<script>window.XSS=true<" + "/script>" );
} catch ( e ) {
threw = true;
}
assert.equal( threw, true, "Throw on leading-hash HTML and space (treated as selector)" );
assert.equal( window.XSS, false, "XSS" );
} );
QUnit.test( "XSS injection (XSS via onerror inline handler)", function( assert ) {
assert.expect( 2 );
var start,
threw = false;
window.XSS = false;
try {
jQuery( "#<img src=haha onerror='window.XSS=true' />" );
} catch ( e ) {
threw = true;
}
assert.equal( threw, true, "Throw on leading-hash HTML (treated as selector)" );
start = assert.async();
setTimeout( function() {
assert.equal( window.XSS, false, "XSS" );
start();
}, 1000 );
} );
QUnit.test( "jQuery( '<element>' ) usable on detached elements (#128)", function( assert ) {
assert.expect( 1 );
jQuery( "<a>" ).outerWidth();
assert.ok( true, "No crash when operating on detached elements with window" );
} );
QUnit.test( ".size", function( assert ) {
assert.expect( 1 );
expectWarning( assert, "size", function() {
jQuery( "<div />" ).size();
} );
} );
QUnit.test( "jQuery.parseJSON", function( assert ) {
assert.expect( 2 );
expectWarning( assert, "jQuery.parseJSON", function() {
assert.deepEqual(
jQuery.parseJSON( "{\"a\":1}" ),
{ a: 1 },
"jQuery.parseJSON output"
);
} );
} );
QUnit.test( "jQuery.isNumeric", function( assert ) {
assert.expect( 8 );
var ToString = function( value ) {
this.toString = function() {
return String( value );
};
};
expectWarning( assert, "changed cases", function() {
assert.equal( jQuery.isNumeric( new ToString( "42" ) ), true,
"Custom .toString returning number" );
} );
expectNoWarning( assert, "unchanged cases", function() {
assert.equal( jQuery.isNumeric( 42 ), true, "number" );
assert.equal( jQuery.isNumeric( "42" ), true, "number string" );
assert.equal( jQuery.isNumeric( "devo" ), false, "non-numeric string" );
assert.equal( jQuery.isNumeric( [ 2, 4 ] ), false, "array" );
assert.equal( jQuery.isNumeric( new ToString( "devo" ) ), false,
"Custom .toString returning non-number" );
} );
} );
QUnit[ jQueryVersionSince( "3.3.0" ) ? "test" : "skip" ]( "jQuery.isWindow", function( assert ) {
assert.expect( 3 );
expectWarning( assert, "isWindow", 1, function() {
assert.equal( jQuery.isWindow( [] ), false, "array" );
assert.equal( jQuery.isWindow( window ), true, "window" );
} );
} );
QUnit.test( "jQuery.unique", function( assert ) {
assert.expect( 2 );
expectWarning( assert, "jQuery.unique", function() {
var body = jQuery( "body" )[ 0 ],
head = jQuery( "head" )[ 0 ];
assert.deepEqual(
jQuery.unique( [ body, head, body ] ),
[ head, body ],
"unique sorted" );
} );
} );
QUnit.test( "jQuery.expr.pseudos aliases", function( assert ) {
assert.expect( 7 );
expectWarning( assert, "jQuery.expr.filters", function() {
jQuery.expr.filters.mazda = function( elem ) {
return elem.style.zoom === "3";
};
} );
expectWarning( assert, "jQuery.expr[':']", function() {
jQuery.expr[ ":" ].marginal = function( elem ) {
return parseInt( elem.style.marginLeftWidth ) > 20;
};
} );
expectNoWarning( assert, "jQuery.expr.pseudos", function() {
var fixture = jQuery( "#qunit-fixture" ).prepend( "<p>hello</p>" );
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( "jQuery.holdReady (warn only)", function( assert ) {
assert.expect( 1 );
expectWarning( assert, "jQuery.holdReady", 1, function() {
jQuery.holdReady( true );
jQuery.holdReady( false );
} );
} );
QUnit[ jQueryVersionSince( "3.2.0" ) ? "test" : "skip" ]( "jQuery.nodeName", function( assert ) {
assert.expect( 2 );
expectWarning( assert, "jQuery.nodeName", function() {
var div = document.createElement( "div" );
assert.equal( jQuery.nodeName( div, "div" ), true, "it's a div" );
})
});
TestManager.runIframeTest( "old pre-3.0 jQuery", "core-jquery2.html",
function( assert, jQuery, window, document, log ) {
assert.expect( 1 );
assert.ok( /jQuery 3/.test( log ), "logged: " + log );
} );

27
node_modules/jquery-migrate/test/css.js generated vendored
View File

@@ -1,27 +0,0 @@
QUnit.module( "css" );
QUnit.test( "jQuery.swap()", function( assert ) {
assert.expect( 6 );
var div = document.createElement( "div" );
div.style.borderWidth = "4px";
expectWarning( assert, "External swap() call", function() {
jQuery.swap( div, { borderRightWidth: "5px" }, function( arg ) {
assert.equal( this.style.borderRightWidth, "5px", "style was changed" );
assert.equal( arg, 42, "arg was passed" );
}, [ 42 ] );
} );
assert.equal( div.style.borderRightWidth, "4px", "style was restored" );
expectNoWarning( assert, "Internal swap() call", function() {
var $fp = jQuery( "#firstp" ).width( "10em" ),
width = $fp.width();
assert.equal( $fp.hide().width(), width, "correct width" );
} );
} );

104
node_modules/jquery-migrate/test/data.js generated vendored
View File

@@ -1,104 +0,0 @@
QUnit.module( "data" );
QUnit.test( "jQuery.data() camelCased names", function( assert ) {
var sames = [
"datum",
"ropeAdope",
"Олег\u0007Michał",
"already-Big",
"number-2",
"unidash-"
],
diffs = [
"dat-data",
"hangy-dasher-",
"-dashy-hanger"
];
assert.expect( 16 );
var curData,
div = document.createElement( "div" );
// = .hasData + noWarning
expectNoWarning( assert, "No existing data object", function() {
sames.concat( diffs ).forEach( function( name ) {
jQuery.data( div, name );
} );
assert.equal( jQuery.hasData( div ), false, "data probes did not fill a data object" );
} );
// = sames.length + diffs.length + noWarning
expectNoWarning( assert, "Data set/get without warning via API", function() {
sames.concat( diffs ).forEach( function( name, index ) {
jQuery.data( div, name, index );
assert.equal( jQuery.data( div, name ), index, name + "=" + index );
} );
} );
// Camelized values set for all names above, get the data object
curData = jQuery.data( div );
// = diffs.length + warning
expectWarning( assert, "Dashed name conflicts", diffs.length, function() {
diffs.forEach( function( name, index ) {
curData[ name ] = index;
assert.equal( jQuery.data( div, name ), curData[ name ],
name + " respects data object" );
} );
} );
} );
QUnit.test( "jQuery.data() camelCased names (mass setter)", function( assert ) {
var sames = [
"datum",
"ropeAdope",
"Олег\u0007Michał",
"already-Big",
"number-2",
"unidash-"
],
diffs = [
"dat-data",
"hangy-dasher-",
"-dashy-hanger"
];
assert.expect( 11 );
var div = document.createElement( "div" );
// = sames.length + noWarning
expectNoWarning( assert, "Data set as an object and get without warning via API", function() {
var testData = {};
sames.forEach( function( name, index ) {
testData[ name ] = index;
} );
jQuery.data( div, testData );
sames.forEach( function( name, index ) {
assert.equal( jQuery.data( div, name ), index, name + "=" + index );
} );
} );
// = diffs.length + warning
expectWarning( assert, "Data set as an object and get without warning via API", function() {
var testData = {};
diffs.forEach( function( name, index ) {
testData[ name ] = index;
} );
jQuery.data( div, testData );
diffs.forEach( function( name, index ) {
assert.equal( jQuery.data( div, name ), index, name + "=" + index );
} );
} );
} );

BIN
node_modules/jquery-migrate/test/data/1x1.jpg generated vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 693 B

0
node_modules/jquery-migrate/test/data/empty.json generated vendored
View File

9842
node_modules/jquery-migrate/test/data/jquery-2.2.3.js generated vendored
View File

File diff suppressed because it is too large Load Diff

1
node_modules/jquery-migrate/test/data/null.json generated vendored
View File

@@ -1 +0,0 @@
null

1
node_modules/jquery-migrate/test/data/simple.json generated vendored
View File

@@ -1 +0,0 @@
{"foo":"bar","gibson":42}

157
node_modules/jquery-migrate/test/deferred.js generated vendored
View File

@@ -1,157 +0,0 @@
QUnit.module( "deferred" );
QUnit.test( "jQuery.Deferred.exceptionHook", function( assert ) {
assert.expect( 1 );
// Make sure our shimming didn't clobber the default hook
assert.ok ( typeof jQuery.Deferred.exceptionHook === "function", "hook is present" );
} );
QUnit.test( ".pipe() warnings", function( assert ) {
assert.expect( 4 );
var d = jQuery.Deferred(),
p = d.promise();
function checkValue( v ) {
assert.equal( v, 1, "got correct value" );
}
// Deferred
expectWarning( assert, "pipe", function() {
d.pipe( checkValue );
} );
// Deferred's promise object
expectWarning( assert, "pipe", function() {
p.pipe( checkValue );
} );
// Should happen synchronously for .pipe()
d.resolve( 1 );
} );
QUnit.test( "[PIPE ONLY] jQuery.Deferred.pipe - filtering (fail)", function( assert ) {
assert.expect( 4 );
var value1, value2, value3,
defer = jQuery.Deferred(),
piped = defer.pipe( null, function( a, b ) {
return a * b;
} ),
done = jQuery.map( new Array( 3 ), function() {
return assert.async();
} );
piped.fail( function( result ) {
value3 = result;
} );
defer.fail( function( a, b ) {
value1 = a;
value2 = b;
} );
defer.reject( 2, 3 ).pipe( null, function() {
assert.strictEqual( value1, 2, "first reject value ok" );
assert.strictEqual( value2, 3, "second reject value ok" );
assert.strictEqual( value3, 6, "result of filter ok" );
done.pop().call();
} );
jQuery.Deferred().resolve().pipe( null, function() {
assert.ok( false, "then should not be called on resolve" );
} ).then( done.pop() );
jQuery.Deferred().reject().pipe( null, jQuery.noop ).fail( function( value ) {
assert.strictEqual( value, undefined, "then fail callback can return undefined/null" );
done.pop().call();
} );
} );
QUnit.test( "[PIPE ONLY] jQuery.Deferred.pipe - deferred (progress)", function( assert ) {
assert.expect( 3 );
var value1, value2, value3,
defer = jQuery.Deferred(),
piped = defer.pipe( null, null, function( a, b ) {
return jQuery.Deferred( function( defer ) {
defer.resolve( a * b );
} );
} ),
done = assert.async();
piped.done( function( result ) {
value3 = result;
} );
defer.progress( function( a, b ) {
value1 = a;
value2 = b;
} );
defer.notify( 2, 3 );
piped.done( function() {
assert.strictEqual( value1, 2, "first progress value ok" );
assert.strictEqual( value2, 3, "second progress value ok" );
assert.strictEqual( value3, 6, "result of filter ok" );
done();
} );
} );
QUnit.test( "[PIPE ONLY] jQuery.Deferred.pipe - context", function( assert ) {
assert.expect( 5 );
var defer, piped, defer2, piped2,
context = {},
done = jQuery.map( new Array( 4 ), function() {
return assert.async();
} );
jQuery.Deferred().resolveWith( context, [ 2 ] ).pipe( function( value ) {
return value * 3;
} ).done( function( value ) {
assert.strictEqual( this, context, "[PIPE ONLY] custom context correctly propagated" );
assert.strictEqual( value, 6, "proper value received" );
done.pop().call();
} );
jQuery.Deferred().resolve().pipe( function() {
return jQuery.Deferred().resolveWith( context );
} ).done( function() {
assert.strictEqual( this, context,
"custom context of returned deferred correctly propagated" );
done.pop().call();
} );
defer = jQuery.Deferred();
piped = defer.pipe( function( value ) {
return value * 3;
} );
defer.resolve( 2 );
piped.done( function( value ) {
// `this` result changed between 1.8 and 1.9, so don't check it
assert.strictEqual( value, 6, "proper value received" );
done.pop().call();
} );
defer2 = jQuery.Deferred();
piped2 = defer2.pipe();
defer2.resolve( 2 );
piped2.done( function( value ) {
// `this` result changed between 1.8 and 1.9, so don't check it
assert.strictEqual( value, 2, "proper value received (without passing function)" );
done.pop().call();
} );
} );

86
node_modules/jquery-migrate/test/effects.js generated vendored
View File

@@ -1,86 +0,0 @@
QUnit.module( "effects" );
QUnit.test( "jQuery.easing", function( assert ) {
var lastP = -0.1,
easingCallCount = 0,
animComplete = assert.async();
assert.expect( 4 );
jQuery.easing.testOld = function( p, n, firstNum, diff ) {
assert.ok( false, "should not have been called" );
};
jQuery.easing.testNew = function( p ) {
if ( ++easingCallCount < 3 ) {
if ( p === 0 && p === lastP ) {
assert.ok( true, "p===0 called twice before jQuery 3.2.0" );
} else {
assert.ok( p > lastP, "called, percentage is increasing" );
lastP = p;
}
}
// Linear
return p;
};
var div = jQuery( "<div>test</div>" )
.css( "width", "30px" )
.appendTo( "#qunit-fixture" );
// Can't use expectWarning since this is async
div;
jQuery.migrateReset();
div.animate( { width: "20px" }, {
duration: 50,
easing: "testOld",
complete: function() {
assert.equal( jQuery.migrateWarnings.length, 1, "warned" );
jQuery.migrateWarnings.length = 0;
div.animate( { width: "10px" }, {
duration: 50,
easing: "testNew",
complete: function() {
assert.equal( jQuery.migrateWarnings.length, 0, "did not warn" );
animComplete();
}
} );
}
} );
} );
// If the browser has requestAnimationFrame, jQuery won't touch fx.interval
QUnit.test( "jQuery.fx.interval - no warning on animations", function( assert ) {
assert.expect( 1 );
var start = assert.async();
// Can't use expectNoWarning since this is async
jQuery.migrateReset();
jQuery( "<div />" )
.appendTo( "#qunit-fixture" )
.animate( { opacity: 0.5 }, 50, function() {
assert.equal( jQuery.migrateWarnings.length, 0, "no warning" );
start();
} );
} );
// Only rAF browsers implement the interval warning
QUnit.test( "jQuery.fx.interval - user change", function( assert ) {
assert.expect( 3 );
var oldInterval,
warner = window.requestAnimationFrame ? expectWarning : expectNoWarning;
assert.ok( true, "requestAnimationFrame is " +
( window.requestAnimationFrame ? "present" : "absent" ) );
warner( assert, "read fx.interval", function() {
oldInterval = jQuery.fx.interval;
} );
warner( assert, "write fx.interval", function() {
jQuery.fx.interval = 13;
} );
jQuery.fx.interval = oldInterval;
} );

75
node_modules/jquery-migrate/test/event-fixHooks.html generated vendored
View File

@@ -1,75 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jQuery Migrate event fixHooks iframe test</title>
<!-- Load a jQuery and jquery-migrate plugin file based on URL -->
<script src="testinit.js"></script>
<script>
TestManager.loadProject( "jquery", "git" );
</script>
<script src="iframeTest.js"></script>
<script>
jQuery.noConflict();
TestManager.loadProject( "jquery-migrate", "dev", true );
</script>
<script>
function dispatchEvent( elem, type ) {
var e = document.createEvent( "HTMLEvents" );
e.initEvent( type, true, true );
elem.dispatchEvent( e );
}
function runTest() {
var div = document.createElement( "div" ),
$div = jQuery( div ).appendTo( document.body );
jQuery.event.fixHooks[ "excite" ] = {
props: [ "reallyHappy", "reallySad" ],
filter: function( event, original ) {
if ( "reallySad" in event ) {
event.gotSad = 1;
}
if ( "reallyHappy" in event ) {
event.gotHappy = 2;
}
return event;
}
};
jQuery.event.fixHooks[ "thrill" ] = {
filter: function( event, original ) {
event.thrilled = "MJ";
return event;
}
};
$div.on( "excite", function( event ) {
var test1 =
// Hooks were called
event.gotSad === 1 &&
event.gotHappy === 2 &&
jQuery.event.props.length === 0 &&
jQuery.event.fixHooks[ "excite" ].props.length === 0;
var test2 = $div.triggerHandler( "thrill" );
// Second thrill should not give another warning
$div.triggerHandler( "thrill" );
startIframeTest( test1, test2 );
} );
$div.on( "thrill", function( event ) {
return event.thrilled === "MJ";
} );
dispatchEvent( div, "excite" );
}
jQuery( runTest );
</script>
</head>
<body>
<p>jQuery Migrate</p>
</body>
</html>

37
node_modules/jquery-migrate/test/event-lateload.html generated vendored
View File

@@ -1,37 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jQuery Migrate late load event binding test</title>
<!-- Load a jQuery and jquery-migrate plugin file based on URL -->
<script src="testinit.js"></script>
<script>
TestManager.loadProject( "jquery", "git" );
</script>
<script src="iframeTest.js"></script>
<script>
jQuery.noConflict();
TestManager.loadProject( "jquery-migrate", "dev", true );
</script>
<script>
var loaded = jQuery.Deferred();
// No warning here, document isn't yet loaded
jQuery( window ).on( "load", function() {
loaded.resolve();
});
jQuery.when( jQuery.ready, loaded ).then( function() {
// This .on() call should warn
jQuery( window ).on( "load", jQuery.noop );
startIframeTest();
} );
</script>
</head>
<body>
<p>jQuery Migrate late load event binding test</p>
</body>
</html>

40
node_modules/jquery-migrate/test/event-props-concat.html generated vendored
View File

@@ -1,40 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jQuery Migrate test for event.props.concat() compat</title>
<!-- Load a jQuery and jquery-migrate plugin file based on URL -->
<script src="testinit.js"></script>
<script>
TestManager.loadProject( "jquery", "git" );
</script>
<script src="iframeTest.js"></script>
<script>
jQuery.noConflict();
TestManager.loadProject( "jquery-migrate", "dev", true );
</script>
<!-- Keep these two in separate script tags so Migrate loads first -->
<script>
startIframeTest( jQuery.event.props.concat([ "TESTING" ]) );
</script>
</head>
<body>
<div data-role="page">
<div data-role="header">
<h1>jQuery Migrate test for jQuery.event.props.concat() compat</h1>
</div><!-- /header -->
<div role="main" class="ui-content">
<p>Page content</p>
</div><!-- /content -->
<div data-role="footer">
<h4>Footer</h4>
</div><!-- /footer -->
</div><!-- /page -->
</body>
</html>

55
node_modules/jquery-migrate/test/event-props.html generated vendored
View File

@@ -1,55 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jQuery Migrate event props iframe test</title>
<!-- Load a jQuery and jquery-migrate plugin file based on URL -->
<script src="testinit.js"></script>
<script>
TestManager.loadProject( "jquery", "git" );
</script>
<script src="iframeTest.js"></script>
<script>
jQuery.noConflict();
TestManager.loadProject( "jquery-migrate", "dev", true );
</script>
<script>
function dispatchEvent( elem, type ) {
var e = document.createEvent( "HTMLEvents" );
e.initEvent( type, true, true );
elem.dispatchEvent( e );
}
function runTest() {
var test1, test2,
div = document.createElement( "div" ),
$div = jQuery( div ).appendTo( document.body );
$div.on( "blend", function( event ) {
test1 = ( "whip" in event ) && ( "chop" in event );
// Props added later are also processed
jQuery.event.props.push( "frappe" );
dispatchEvent( div, "puree" );
} );
$div.on( "puree", function( event ) {
test2 = ( "whip" in event ) && ( "frappe" in event );
// 2 prop warnings ( chop+whip and frappe )
startIframeTest( test1, test2 );
} );
// Multiple props, processed with a single warning
jQuery.event.props.push( "chop", "whip" );
dispatchEvent( div, "blend" );
}
jQuery( runTest );
</script>
</head>
<body>
<p>jQuery Migrate</p>
</body>
</html>

27
node_modules/jquery-migrate/test/event-ready.html generated vendored
View File

@@ -1,27 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jQuery Migrate `ready` event iframe test</title>
<!-- Load a jQuery and jquery-migrate plugin file based on URL -->
<script src="testinit.js"></script>
<script>
TestManager.loadProject( "jquery", "git" );
</script>
<script src="iframeTest.js"></script>
<script>
jQuery.noConflict();
TestManager.loadProject( "jquery-migrate", "dev", true );
</script>
<script>
// This should warn when the handler runs
jQuery( document ).on( "ready", function() {
startIframeTest();
} );
</script>
</head>
<body>
<p>jQuery Migrate `ready` event iframe test</p>
</body>
</html>

190
node_modules/jquery-migrate/test/event.js generated vendored
View File

@@ -1,190 +0,0 @@
QUnit.module( "event" );
QUnit.test( "error() event method", function( assert ) {
assert.expect( 2 );
expectWarning( assert, "jQuery.fn.error()", function() {
jQuery( "<img />" )
.error( function() {
assert.ok( true, "Triggered error event" );
} )
.error()
.off( "error" )
.error()
.remove();
} );
} );
QUnit.test( "load() and unload() event methods", function( assert ) {
assert.expect( 5 );
expectWarning( assert, "jQuery.fn.load()", function() {
jQuery( "<img />" )
.load( function() {
assert.ok( true, "Triggered load event" );
} )
.load()
.off( "load" )
.load()
.remove();
} );
expectWarning( assert, "jQuery.fn.unload()", function() {
jQuery( "<img />" )
.unload( function() {
assert.ok( true, "Triggered unload event" );
} )
.unload()
.off( "unload" )
.unload()
.remove();
} );
expectNoWarning( assert, "ajax load", function() {
var start = assert.async();
jQuery( "<div id=load138></div>" )
.appendTo( "#qunit-fixture" )
.load( "not-found.file", function() {
jQuery( "#load138" ).remove();
start();
} );
} );
} );
QUnit.test( ".bind() and .unbind()", function( assert ) {
assert.expect( 3 );
var $elem = jQuery( "<div />" ).appendTo( "#qunit-fixture" );
expectWarning( assert, ".bind()", 1, function() {
$elem
.bind( "click", function() {
assert.ok( true, "click fired" );
} )
.trigger( "click" );
} );
expectWarning( assert, ".unbind()", 1, function() {
$elem
.unbind( "click" )
.trigger( "click" );
} );
} );
QUnit.test( ".delegate() and .undelegate()", function( assert ) {
assert.expect( 3 );
var $div = jQuery( "<div />" ).appendTo( "#qunit-fixture" );
jQuery( "<p />" ).appendTo( $div );
expectWarning( assert, ".delegate()", 1, function() {
$div
.delegate( "p", "click", function() {
assert.ok( true, "delegated click fired" );
} )
.find( "p" ).trigger( "click" );
} );
expectWarning( assert, ".undelegate()", 1, function() {
$div
.undelegate( "p", "click" )
.find( "p" ).trigger( "click" );
} );
} );
QUnit.test( "Event aliases", function( assert ) {
assert.expect( 14 );
var $div = jQuery( "<div />" );
"scroll click submit keydown".split( " " ).forEach( function( name ) {
expectWarning( assert, "." + name + "()", 1, function() {
$div[ name ]( function( event ) {
assert.equal( event.type, name, name );
$div.off( event );
} )[ name ]();
} );
} );
expectWarning( assert, ".hover() one-arg", 1, function() {
$div.hover( function( event ) {
assert.ok( /mouseenter|mouseleave/.test( event.type ), event.type );
$div.off( event );
} ).trigger( "mouseenter" ).trigger( "mouseleave" );
} );
expectWarning( assert, ".hover() two-arg", 1, function() {
$div.hover(
function( event ) {
assert.equal( "mouseenter", event.type, event.type );
},
function( event ) {
assert.equal( "mouseleave", event.type, event.type );
}
).trigger( "mouseenter" ).trigger( "mouseleave" );
} );
} );
QUnit.test( "custom ready", function( assert ) {
assert.expect( 2 );
jQuery("#qunit-fixture").append("<div id='foo'>bar</div>");
expectNoWarning( assert, "Custom ready event not on document", 1, function() {
jQuery( "#foo" ).on( "ready", function() {
assert.ok( true, "custom ready event was triggered" );
} )
.trigger( "ready" )
.off( "ready" );
} );
} );
TestManager.runIframeTest( "document ready", "event-ready.html",
function( assert, jQuery ) {
assert.expect( 1 );
assert.equal( jQuery.migrateWarnings.length, 1, "warnings: " +
JSON.stringify( jQuery.migrateWarnings ) );
} );
TestManager.runIframeTest( "jQuery.event.props.concat", "event-props-concat.html",
function( assert, jQuery, window, document, log, props ) {
assert.expect( 3 );
var warns = JSON.stringify( jQuery.migrateWarnings );
assert.equal( jQuery.migrateWarnings.length, 1, "one warning" );
assert.ok( warns.indexOf( "props.concat" ) >= 0, "warnings: " + warns );
assert.equal( props[0], "TESTING", "used the empty props" )
} );
// Do this as iframe because there is no way to undo prop addition
TestManager.runIframeTest( "jQuery.event.props", "event-props.html",
function( assert, jQuery, window, document, log, test1, test2 ) {
assert.expect( 2 );
assert.ok( test1 && test2, "props were processed" );
assert.equal( jQuery.migrateWarnings.length, 2, "warnings: " +
JSON.stringify( jQuery.migrateWarnings ) );
} );
// Do this as iframe because there is no way to undo prop addition
TestManager.runIframeTest( "jQuery.event.fixHooks", "event-fixHooks.html",
function( assert, jQuery, window, document, log, test1, test2 ) {
assert.expect( 2 );
assert.ok( test1 && test2, "hooks were processed" );
assert.equal( jQuery.migrateWarnings.length, 2, "warnings: " +
JSON.stringify( jQuery.migrateWarnings ) );
} );
TestManager.runIframeTest( "Load within a ready handler", "event-lateload.html",
function( assert, jQuery, window, document, log ) {
assert.expect( 2 );
assert.equal( jQuery.migrateWarnings.length, 1, "warnings: " +
JSON.stringify( jQuery.migrateWarnings ) );
assert.ok( /load/.test( jQuery.migrateWarnings[ 0 ] ), "message ok" );
} );

32
node_modules/jquery-migrate/test/iframeTest.js generated vendored
View File

@@ -1,32 +0,0 @@
/*
* Iframe-based unit tests support
* Load this file immediately after jQuery, before jQuery Migrate
*/
// Don't spew on in the console window when we build
// Warning messages are available to parent test in jQuery.migrateWarnings
if ( navigator.userAgent.indexOf( "PhantomJS" ) >= 0 ) {
jQuery.migrateMute = true;
}
// Support: IE9 only (no console at times)
if ( !window.console ) {
window.console = {};
}
// Capture output so the test in the parent window can inspect it, and so the
// initialization for the iframe doesn't show another Migrate startup header.
var logOutput = "";
window.console.log = function() {
logOutput += Array.prototype.join.call( arguments, " " ) + "\n";
};
// Callback gets ( jQuery, window, document, log [, startIframe args ] )
window.startIframeTest = function() {
var args = Array.prototype.slice.call( arguments );
// Note: jQuery may be undefined if page did not load it
args.unshift( window.jQuery, window, document, logOutput );
window.parent.TestManager.iframeCallback.apply( null, args );
};

46
node_modules/jquery-migrate/test/index.html generated vendored
View File

@@ -1,46 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>jQuery Migrate Test Suite</title>
<!-- // Support: IE <= 10 only -->
<!-- Ensure IE doesn't fall back into oldIE modes -->
<meta http-equiv="X-UA-Compatible" content="IE=Edge" />
<!-- QUnit -->
<link rel="stylesheet" href="../node_modules/qunit/qunit/qunit.css" media="screen">
<script src="../node_modules/qunit/qunit/qunit.js"></script>
<!-- Load a jQuery and jquery-migrate plugin file based on URL -->
<script src="testinit.js"></script>
<script>
TestManager.loadProject( "jquery", "git" );
// Close this script tag so file will load
</script>
<script>
jQuery.noConflict();
TestManager.loadProject( "jquery-migrate", "min", true );
</script>
<!-- Version comparisons -->
<script src="../src/compareVersions.js"></script>
<!-- Unit test files -->
<script src="migrate.js"></script>
<script src="core.js"></script>
<script src="ajax.js"></script>
<script src="attributes.js"></script>
<script src="css.js"></script>
<script src="data.js"></script>
<script src="event.js"></script>
<script src="offset.js"></script>
<script src="serialize.js"></script>
<script src="traversing.js"></script>
<script src="deferred.js"></script>
<script src="effects.js"></script>
</head>
<body>
<div id="qunit"></div>
<div id="qunit-fixture"></div>
</body>
</html>

40
node_modules/jquery-migrate/test/migrate.js generated vendored
View File

@@ -1,40 +0,0 @@
/* exported expectWarning, expectNoWarning */
// Don't spew on in the console window when we build
if ( navigator.userAgent.indexOf( "PhantomJS" ) >= 0 ) {
jQuery.migrateMute = true;
}
function expectWarning( assert, name, expected, fn ) {
if ( !fn ) {
fn = expected;
expected = null;
}
jQuery.migrateReset();
fn();
// Special-case for 0 warnings expected
if ( expected === 0 ) {
assert.deepEqual( jQuery.migrateWarnings, [], name + ": did not warn" );
// Simple numeric equality assertion for warnings matching an explicit count
} else if ( expected && jQuery.migrateWarnings.length === expected ) {
assert.equal( jQuery.migrateWarnings.length, expected, name + ": warned" );
// Simple ok assertion when we saw at least one warning and weren't looking for an explict count
} else if ( !expected && jQuery.migrateWarnings.length ) {
assert.ok( true, name + ": warned" );
// Failure; use deepEqual to show the warnings that *were* generated and the expectation
} else {
assert.deepEqual( jQuery.migrateWarnings,
"<warnings: " + ( expected || "1+" ) + ">", name + ": warned"
);
}
}
function expectNoWarning( assert, name, expected, fn ) {
// Expected is present only for signature compatibility with expectWarning
return expectWarning( assert, name, 0, fn || expected );
}

47
node_modules/jquery-migrate/test/offset.js generated vendored
View File

@@ -1,47 +0,0 @@
QUnit.module( "offset" );
QUnit.test( ".offset()", function( assert ) {
assert.expect( 12 );
var bogus = { top: 0, left: 0 };
expectNoWarning( assert, ".offset() on body", function() {
var offset = jQuery( "body" ).offset();
assert.ok( offset.top > 1, "non-zero top offset" );
assert.ok( offset.left > 1, "non-zero left offset" );
} );
expectNoWarning( assert, ".offset() as setter", function() {
var $elem = jQuery( "<div />" )
.appendTo( "#qunit-fixture" )
.css( "position", "absolute" )
.offset( { top: 42, left: 99 } ),
offset = $elem.offset();
assert.equal( offset.top, 42, "non-zero top offset" );
assert.equal( offset.left, 99, "non-zero left offset" );
} );
expectWarning( assert, ".offset() on window", function() {
assert.deepEqual(
jQuery( window ).offset(),
bogus, "window bogus top/left 0"
);
} );
expectWarning( assert, ".offset() on disconnected node", function() {
assert.deepEqual(
jQuery( document.createElement( "div" ) ).offset(),
bogus, "disconnected bogus top/left 0"
);
} );
expectWarning( assert, ".offset() on plain object", function() {
assert.deepEqual(
jQuery( { space: "junk", zero: 0 } ).offset(),
bogus, "plain object bogus top/left 0"
);
} );
} );

51
node_modules/jquery-migrate/test/serialize.js generated vendored
View File

@@ -1,51 +0,0 @@
QUnit.module( "serialize" );
QUnit.test( "jQuery.param( x, traditional)", function( assert ) {
assert.expect( 12 );
var savedTraditional = jQuery.ajaxSettings.traditional,
data = { a: [ 1, 2 ] },
standardResult = "a%5B%5D=1&a%5B%5D=2",
traditionalResult = "a=1&a=2";
expectNoWarning( assert, "default, traditional default", function() {
assert.equal(
jQuery.param( data ), standardResult,
"default, traditional default" );
} );
expectNoWarning( assert, "explicit true, traditional default", function() {
assert.equal(
jQuery.param( data, true ), traditionalResult,
"explicit true, traditional default" );
} );
expectNoWarning( assert, "explicit false, traditional default", function() {
assert.equal(
jQuery.param( data, false ), standardResult,
"explicit false, traditional default" );
} );
jQuery.ajaxSettings.traditional = true;
expectWarning( assert, "default, traditional true", function() {
assert.equal(
jQuery.param( data ), traditionalResult,
"default, traditional true" );
} );
expectNoWarning( assert, "explicit true, traditional true", function() {
assert.equal(
jQuery.param( data, true ), traditionalResult,
"explicit true, traditional true" );
} );
expectNoWarning( assert, "explicit false, traditional true", function() {
assert.equal(
jQuery.param( data, false ), standardResult,
"explicit false, traditional true" );
} );
jQuery.ajaxSettings.traditional = savedTraditional;
} );

164
node_modules/jquery-migrate/test/testinit.js generated vendored
View File

@@ -1,164 +0,0 @@
TestManager = {
/*
* Load a version of a file based on URL parameters.
*
* dev Uncompressed development version: source files in the project /dist dir
* raw Non-combined dev version: source files from the project /src dir
* min Minified version in the project /dist dir
* VER Version from code.jquery.com, e.g.: git, 1.8.2.min or 1.7rc1
* else Full or relative path to be used for script src
*/
loadProject: function( projectName, defaultVersion, isSelf ) {
var file, i,
lines = "",
urlTag = this.projects[ projectName ].urlTag,
matcher = new RegExp( "\\b" + urlTag + "=([^&]+)" ),
projectRoot = this.baseURL + ( isSelf ? ".." : "../../" + projectName ),
version = ( matcher.exec( document.location.search ) || {} )[ 1 ] || defaultVersion;
if ( window.__karma__ && isSelf ) {
projectRoot = "/base";
}
if ( version === "raw" ) {
// Order is important
file = [
"version",
"migrate",
"core",
"ajax",
"attributes",
"css",
"data",
"effects",
"event",
"offset",
"serialize",
"traversing",
"deferred"
];
for ( i = 0; i < file.length; i++ ) {
file[ i ] = projectRoot + "/src/" + file[ i ] + ".js";
}
} else if ( version === "dev" ) {
file = projectRoot + "/dist/" + projectName + ".js";
} else if ( version === "min" ) {
file = projectRoot + "/dist/" + projectName + ".min.js";
} else if ( /^[\w\.\-]+$/.test( version ) ) {
file = "http://code.jquery.com/" + projectName + "-" + version + ".js";
} else {
file = version;
}
this.loaded.push( {
projectName: projectName,
tag: version,
file: file
} );
if ( typeof file === "string" ) {
document.write( "<script src='" + file + "'></script>" );
} else {
for ( i = 0; i < file.length; i++ ) {
lines += "<script src='" + file[ i ] + "'></script>";
}
document.write( lines );
}
},
/**
* Iframe tests that require setup not covered in the standard unit test
*
* Note that options passed into the standard unit tests will also be passed to
* the iframe, but the iframe html page is responsible for processing them
* as appropriate (for example by calling TestManager.loadProject)
*/
runIframeTest: function( title, url, func ) {
var self = this;
QUnit.test( title, function( assert ) {
var iframe,
query = window.location.search.slice( 1 ),
done = assert.async();
self.iframeCallback = function() {
var args = Array.prototype.slice.call( arguments );
args.unshift( assert );
setTimeout( function() {
self.iframeCallback = undefined;
func.apply( this, args );
func = function() {};
iframe.remove();
done();
} );
};
iframe = jQuery( "<div/>" )
.css( { position: "absolute", width: "500px", left: "-600px" } )
.append( jQuery( "<iframe/>" ).attr( "src", self.baseURL + url +
( query && ( /\?/.test( url ) ? "&" : "?" ) ) + query ) )
.appendTo( "#qunit-fixture" );
} );
},
iframeCallback: undefined,
baseURL: window.__karma__ ? "base/test/" : "./",
init: function( projects ) {
var p, project;
this.projects = projects;
this.loaded = [];
// Do QUnit setup if QUnit is loaded (could be an iframe page)
if ( !window.QUnit ) {
return;
}
// Max time for async tests until it aborts test
// and start()'s the next test.
QUnit.config.testTimeout = 20 * 1000; // 20 seconds
// Enforce an "expect" argument or expect() call in all test bodies.
QUnit.config.requireExpects = true;
// Set the list of projects, including the project version choices.
for ( p in projects ) {
project = projects[ p ];
QUnit.config.urlConfig.push( {
label: p,
id: project.urlTag,
value: project.choices.split( "," )
} );
}
}
};
TestManager.init( {
"jquery": {
urlTag: "jquery",
choices: "dev,min,git,3.x-git,3.4.1,3.3.1,3.2.1,3.1.1,3.0.0"
},
"jquery-migrate": {
urlTag: "plugin",
choices: "dev,min,raw,git,3.0.1,3.0.0"
}
} );
/**
* Load the TestSwarm listener if swarmURL is in the address.
*/
( function() {
var url = window.location.search;
url = decodeURIComponent( url.slice( url.indexOf( "swarmURL=" ) + "swarmURL=".length ) );
if ( !url || url.indexOf( "http" ) !== 0 ) {
return;
}
document.write( "<scr" + "ipt src='http://swarm.jquery.org/js/inject.js?" +
( new Date() ).getTime() + "'></scr" + "ipt>" );
} )();

10
node_modules/jquery-migrate/test/traversing.js generated vendored
View File

@@ -1,10 +0,0 @@
QUnit.module( "traversing" );
QUnit.test( ".andSelf", function( assert ) {
assert.expect( 1 );
expectWarning( assert, "andSelf", function() {
jQuery( "<div id='outer'><div id='inner'></div></div>" ).find( ".inner" ).andSelf();
} );
} );