1- 'use strict'
2-
3- const net = require ( 'net' )
4- const mafmt = require ( 'mafmt' )
5- // Missing Type
6- // @ts -ignore
7- const withIs = require ( 'class-is' )
8- const errCode = require ( 'err-code' )
9- const log = require ( 'debug' ) ( 'libp2p:tcp' )
10- const toConnection = require ( './socket-to-conn' )
11- const createListener = require ( './listener' )
12- const { multiaddrToNetConfig } = require ( './utils' )
13- const { AbortError } = require ( 'abortable-iterator' )
14- const { CODE_CIRCUIT , CODE_P2P } = require ( './constants' )
1+ import net from 'net'
2+ import mafmt from 'mafmt'
3+ import errCode from 'err-code'
4+ import debug from 'debug'
5+ import { toConnection } from './socket-to-conn.js'
6+ import { createListener } from './listener.js'
7+ import { multiaddrToNetConfig } from './utils.js'
8+ import { AbortError } from 'abortable-iterator'
9+ import { CODE_CIRCUIT , CODE_P2P } from './constants.js'
10+ import type { Transport , Upgrader } from 'libp2p-interfaces/transport'
11+ import type { Connection } from 'libp2p-interfaces/connection'
12+ import type { Multiaddr } from 'multiaddr'
13+ import type { Socket } from 'net'
14+
15+ const log = debug ( 'libp2p:tcp' )
1516
1617/**
1718 * @typedef {import('multiaddr').Multiaddr } Multiaddr
@@ -21,28 +22,28 @@ const { CODE_CIRCUIT, CODE_P2P } = require('./constants')
2122 * @typedef {import('net').Socket } Socket
2223 */
2324
24- class TCP {
25- /**
26- * @class
27- * @param {object } options
28- * @param {Upgrader } options.upgrader
29- */
30- constructor ( { upgrader } ) {
31- if ( ! upgrader ) {
25+ interface TCPOptions {
26+ upgrader : Upgrader
27+ }
28+
29+ interface DialOptions {
30+ signal ?: AbortSignal
31+ }
32+
33+ export default class TCP implements Transport < DialOptions , { } > {
34+ private readonly _upgrader : Upgrader
35+
36+ constructor ( options : TCPOptions ) {
37+ const { upgrader } = options
38+
39+ if ( upgrader == null ) {
3240 throw new Error ( 'An upgrader must be provided. See https://github.com/libp2p/interface-transport#upgrader.' )
3341 }
42+
3443 this . _upgrader = upgrader
3544 }
3645
37- /**
38- * @async
39- * @param {Multiaddr } ma
40- * @param {object } options
41- * @param {AbortSignal } [options.signal] - Used to abort dial requests
42- * @returns {Promise<Connection> } An upgraded Connection
43- */
44- async dial ( ma , options ) {
45- options = options || { }
46+ async dial ( ma : Multiaddr , options : DialOptions = { } ) {
4647 const socket = await this . _connect ( ma , options )
4748 const maConn = toConnection ( socket , { remoteAddr : ma , signal : options . signal } )
4849 log ( 'new outbound connection %s' , maConn . remoteAddr )
@@ -51,32 +52,27 @@ class TCP {
5152 return conn
5253 }
5354
54- /**
55- * @private
56- * @param {Multiaddr } ma
57- * @param {object } options
58- * @param {AbortSignal } [options.signal] - Used to abort dial requests
59- * @returns {Promise<Socket> } Resolves a TCP Socket
60- */
61- _connect ( ma , options = { } ) {
62- if ( options . signal && options . signal . aborted ) {
55+ async _connect ( ma : Multiaddr , options : DialOptions = { } ) {
56+ if ( options . signal ?. aborted === true ) {
6357 throw new AbortError ( )
6458 }
6559
66- return new Promise ( ( resolve , reject ) => {
60+ return await new Promise < Socket > ( ( resolve , reject ) => {
6761 const start = Date . now ( )
6862 const cOpts = multiaddrToNetConfig ( ma )
6963
7064 log ( 'dialing %j' , cOpts )
7165 const rawSocket = net . connect ( cOpts )
7266
73- const onError = /** @param { Error } err */ err => {
67+ const onError = ( err : Error ) => {
7468 err . message = `connection error ${ cOpts . host } ${ cOpts . port } ${ err . message }
69+
7570 done ( err )
7671 }
7772
7873 const onTimeout = ( ) => {
7974 log ( 'connection timeout %s:%s' , cOpts . host , cOpts . port )
75+
8076 const err = errCode ( new Error ( `connection timeout after ${ Date . now ( ) - start } ) , 'ERR_CONNECT_TIMEOUT' )
8177 // Note: this will result in onError() being called
8278 rawSocket . emit ( 'error' , err )
@@ -93,52 +89,45 @@ class TCP {
9389 done ( new AbortError ( ) )
9490 }
9591
96- const done = /** @param { Error } [ err] */ err => {
92+ const done = ( err ?: any ) => {
9793 rawSocket . removeListener ( 'error' , onError )
9894 rawSocket . removeListener ( 'timeout' , onTimeout )
9995 rawSocket . removeListener ( 'connect' , onConnect )
100- options . signal && options . signal . removeEventListener ( 'abort' , onAbort )
10196
102- if ( err ) return reject ( err )
97+ if ( options . signal != null ) {
98+ options . signal . removeEventListener ( 'abort' , onAbort )
99+ }
100+
101+ if ( err != null ) {
102+ return reject ( err )
103+ }
104+
103105 resolve ( rawSocket )
104106 }
105107
106108 rawSocket . on ( 'error' , onError )
107109 rawSocket . on ( 'timeout' , onTimeout )
108110 rawSocket . on ( 'connect' , onConnect )
109- options . signal && options . signal . addEventListener ( 'abort' , onAbort )
111+
112+ if ( options . signal != null ) {
113+ options . signal . addEventListener ( 'abort' , onAbort )
114+ }
110115 } )
111116 }
112117
113118 /**
114119 * Creates a TCP listener. The provided `handler` function will be called
115120 * anytime a new incoming Connection has been successfully upgraded via
116121 * `upgrader.upgradeInbound`.
117- *
118- * @param {* | function(Connection):void } options
119- * @param {function(Connection):void } [handler]
120- * @returns {Listener } A TCP listener
121122 */
122- createListener ( options , handler ) {
123- let listenerHandler
124-
125- if ( typeof options === 'function' ) {
126- listenerHandler = options
127- options = { }
128- } else {
129- listenerHandler = handler
130- }
131- options = options || { }
132- return createListener ( { handler : listenerHandler , upgrader : this . _upgrader } , options )
123+ createListener ( options : { } , handler ?: ( connection : Connection ) => void ) {
124+ return createListener ( { handler : handler , upgrader : this . _upgrader } )
133125 }
134126
135127 /**
136128 * Takes a list of `Multiaddr`s and returns only valid TCP addresses
137- *
138- * @param {Multiaddr[] } multiaddrs
139- * @returns {Multiaddr[] } Valid TCP multiaddrs
140129 */
141- filter ( multiaddrs ) {
130+ filter ( multiaddrs : Multiaddr [ ] ) {
142131 multiaddrs = Array . isArray ( multiaddrs ) ? multiaddrs : [ multiaddrs ]
143132
144133 return multiaddrs . filter ( ma => {
@@ -150,7 +139,3 @@ class TCP {
150139 } )
151140 }
152141}
153-
154- const TCPWithIs = withIs ( TCP , { className : 'TCP' , symbolName : '@libp2p/js-libp2p-tcp/tcp' } )
155-
156- exports = module . exports = TCPWithIs
0 commit comments