2020-05-19 09:25:54 -04:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								import  *  as  core  from  '@actions/core' ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								import  *  as  installer  from  './installer' ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								import  *  as  auth  from  './authutil' ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								import  *  as  path  from  'path' ; 
							 
						 
					
						
							
								
									
										
										
										
											2021-06-16 09:52:44 +03:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								import  { restoreCache }  from  './cache-restore' ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-19 09:25:54 -04:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								import  { URL }  from  'url' ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-09-03 07:40:40 -05:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								import  os  =  require ( 'os' ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-19 09:25:54 -04:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								export  async  function  run() { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								  try  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    //
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    // Version is optional.  If supplied, install / use from the tool cache
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    // If not supplied then task is still used to setup proxy, auth, etc...
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    //
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    let  version  =  core . getInput ( 'node-version' ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    if  ( ! version )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								      version  =  core . getInput ( 'version' ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-12-08 16:15:38 -06:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								    let  arch  =  core . getInput ( 'architecture' ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2021-06-16 09:52:44 +03:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								    const  cache  =  core . getInput ( 'cache' ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-09-06 11:09:41 -05:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-12-08 16:15:38 -06:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								    // if architecture supplied but node-version is not
 
							 
						 
					
						
							
								
									
										
										
										
											2020-09-06 11:09:41 -05:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								    // if we don't throw a warning, the already installed x64 node will be used which is not probably what user meant.
 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    if  ( arch  &&  ! version )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								      core . warning ( 
							 
						 
					
						
							
								
									
										
										
										
											2020-12-09 11:27:02 -06:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								        '`architecture` is provided but `node-version` is missing. In this configuration, the version/architecture of Node will not be changed. To fix this, provide `architecture` in combination with `node-version`' 
							 
						 
					
						
							
								
									
										
										
										
											2020-09-06 11:09:41 -05:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								      ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-09-03 07:40:40 -05:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								    if  ( ! arch )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								      arch  =  os . arch ( ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2020-05-19 09:25:54 -04:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								    if  ( version )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								      let  token  =  core . getInput ( 'token' ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								      let  auth  =  ! token  ||  isGhes ( )  ?  undefined  :  ` token  ${ token } ` ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								      let  stable  =  ( core . getInput ( 'stable' )  ||  'true' ) . toUpperCase ( )  ===  'TRUE' ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-06-29 21:56:37 +03:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								      const  checkLatest  = 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								        ( core . getInput ( 'check-latest' )  ||  'false' ) . toUpperCase ( )  ===  'TRUE' ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-09-03 07:40:40 -05:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								      await  installer . getNode ( version ,  stable ,  checkLatest ,  auth ,  arch ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-19 09:25:54 -04:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    const  registryUrl : string  =  core . getInput ( 'registry-url' ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    const  alwaysAuth : string  =  core . getInput ( 'always-auth' ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    if  ( registryUrl )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								      auth . configAuthentication ( registryUrl ,  alwaysAuth ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
									
										
										
										
											2021-06-16 09:52:44 +03:00 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								    if  ( cache )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								      if  ( isGhes ( ) )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								        throw  new  Error ( 'Caching is not supported on GHES' ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								      } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								      await  restoreCache ( cache ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    const  matchersPath  =  path . join ( __dirname ,  '../..' ,  '.github' ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2021-01-20 20:58:35 +05:30 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								    core . info ( ` ##[add-matcher] ${ path . join ( matchersPath ,  'tsc.json' ) } ` ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    core . info ( 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-19 09:25:54 -04:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								      ` ##[add-matcher] ${ path . join ( matchersPath ,  'eslint-stylish.json' ) } ` 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    ) ; 
							 
						 
					
						
							
								
									
										
										
										
											2021-01-20 20:58:35 +05:30 
										
									 
								 
							 
							
								
									
										 
									 
								
							 
							
								 
							 
							
							
								    core . info ( 
							 
						 
					
						
							
								
									
										
										
										
											2020-05-19 09:25:54 -04:00 
										
									 
								 
							 
							
								
							 
							
								 
							 
							
							
								      ` ##[add-matcher] ${ path . join ( matchersPath ,  'eslint-compact.json' ) } ` 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								  }  catch  ( error )  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    core . setFailed ( error . message ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								  } 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								} 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								function  isGhes ( ) :  boolean  { 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								  const  ghUrl  =  new  URL ( 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								    process . env [ 'GITHUB_SERVER_URL' ]  ||  'https://github.com' 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								  ) ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								  return  ghUrl . hostname . toUpperCase ( )  !==  'GITHUB.COM' ; 
							 
						 
					
						
							
								
							 
							
								
							 
							
								 
							 
							
							
								}