@dxos/network-manager 0.8.1 → 0.8.2-main.10c050d

package/src/transport/memory-transport.ts

@@ -70,7 +70,7 @@ export class MemoryTransport implements Transport {
     return !this._closed;
   }
 
-  async open() {
+  async open(): Promise<this> {
     log('opening...');
 
     // Initiator will send a signal, the receiver will receive the unique ID and connect the streams.
@@ -126,7 +126,7 @@ export class MemoryTransport implements Transport {
     return this;
   }
 
-  async close() {
+  async close(): Promise<this> {
     log('closing...');
     this._closed = true;
 
@@ -159,7 +159,7 @@ export class MemoryTransport implements Transport {
     return this;
   }
 
-  async onSignal({ payload }: Signal) {
+  async onSignal({ payload }: Signal): Promise<void> {
     log('received signal', { payload });
     if (!payload?.transportId) {
       return;
@@ -173,11 +173,16 @@ export class MemoryTransport implements Transport {
     }
   }
 
-  async getDetails() {
+  async getDetails(): Promise<string> {
     return this._instanceId.toHex();
   }
 
-  async getStats() {
+  async getStats(): Promise<{
+    bytesSent: number;
+    bytesReceived: number;
+    packetsSent: number;
+    packetsReceived: number;
+  }> {
     return {
       bytesSent: 0,
       bytesReceived: 0,

package/src/transport/tcp/tcp-transport.browser.ts

@@ -23,15 +23,15 @@ export class TcpTransport implements Transport {
     return true;
   }
 
-  async open() {
+  async open(): Promise<this> {
     return this;
   }
 
-  async close() {
+  async close(): Promise<this> {
     return this;
   }
 
-  async onSignal() {
+  async onSignal(): Promise<void> {
     throw new Error('Method not implemented.');
   }
 

package/src/transport/tcp/tcp-transport.ts

@@ -35,7 +35,7 @@ export class TcpTransport implements Transport {
     return this._connected && !this._closed;
   }
 
-  async open() {
+  async open(): Promise<this> {
     log('opening');
 
     // Initiator will send a signal, the receiver will receive the unique ID and connect the streams.
@@ -75,7 +75,7 @@ export class TcpTransport implements Transport {
     return this;
   }
 
-  async close() {
+  async close(): Promise<this> {
     log('closing');
     this._socket?.destroy();
     this._server?.close();
@@ -83,7 +83,7 @@ export class TcpTransport implements Transport {
     return this;
   }
 
-  async onSignal({ payload }: Signal) {
+  async onSignal({ payload }: Signal): Promise<void> {
     log('received signal', { payload });
     if (this.options.initiator || this._connected) {
       return;
@@ -113,7 +113,7 @@ export class TcpTransport implements Transport {
     };
   }
 
-  private _handleSocket(socket: Socket) {
+  private _handleSocket(socket: Socket): void {
     log('handling socket', { remotePort: socket.remotePort, localPort: socket.localPort });
     this._socket = socket;
 

package/src/transport/webrtc/rtc-connection-factory.ts

@@ -19,10 +19,10 @@ export interface RtcConnectionFactory {
  * Use built-in browser RTCPeerConnection.
  */
 class BrowserRtcConnectionFactory implements RtcConnectionFactory {
-  async initialize() {}
-  async onConnectionDestroyed() {}
+  async initialize(): Promise<void> {}
+  async onConnectionDestroyed(): Promise<void> {}
 
-  async createConnection(config: RTCConfiguration) {
+  async createConnection(config: RTCConfiguration): Promise<RTCPeerConnection> {
     return new RTCPeerConnection(config);
   }
 
@@ -41,8 +41,8 @@ class NodeRtcConnectionFactory implements RtcConnectionFactory {
   // eslint-disable-next-line no-new-func
 
   // TODO(burdon): Do imports here?
-  async initialize() {}
-  async onConnectionDestroyed() {
+  async initialize(): Promise<void> {}
+  async onConnectionDestroyed(): Promise<void> {
     return NodeRtcConnectionFactory._cleanupMutex.executeSynchronized(async () => {
       if (--NodeRtcConnectionFactory._createdConnections === 0) {
         (await import('#node-datachannel')).cleanup();

package/src/transport/webrtc/rtc-peer-connection.ts

@@ -79,7 +79,7 @@ export class RtcPeerConnection {
     const connection = await this._openConnection();
     if (!this._transportChannels.has(topic)) {
       if (!this._transportChannels.size) {
-        this._lockAndCloseConnection();
+        void this._lockAndCloseConnection();
       }
       throw new Error('Transport closed while connection was being open');
     }
@@ -105,7 +105,7 @@ export class RtcPeerConnection {
     channel.closed.on(() => {
       this._transportChannels.delete(options.topic);
       if (this._transportChannels.size === 0) {
-        this._lockAndCloseConnection();
+        void this._lockAndCloseConnection();
       }
     });
     return channel;
@@ -145,7 +145,7 @@ export class RtcPeerConnection {
           await connection.setLocalDescription(offer);
           await this._sendDescription(connection, offer);
         } catch (err: any) {
-          this._lockAndAbort(connection, err);
+          void this._lockAndAbort(connection, err);
         }
       },
 
@@ -183,7 +183,7 @@ export class RtcPeerConnection {
 
         log('oniceconnectionstatechange', { state: connection.iceConnectionState });
         if (connection.iceConnectionState === 'failed') {
-          this._lockAndAbort(connection, createIceFailureError(iceCandidateErrors));
+          void this._lockAndAbort(connection, createIceFailureError(iceCandidateErrors));
         }
       },
 
@@ -200,7 +200,7 @@ export class RtcPeerConnection {
 
         log('onconnectionstatechange', { state: connection.connectionState });
         if (connection.connectionState === 'failed') {
-          this._lockAndAbort(connection, new Error('Connection failed.'));
+          void this._lockAndAbort(connection, new Error('Connection failed.'));
         }
       },
 
@@ -237,11 +237,11 @@ export class RtcPeerConnection {
   }
 
   @synchronized
-  private _lockAndAbort(connection: RTCPeerConnection, error: Error) {
+  private async _lockAndAbort(connection: RTCPeerConnection, error: Error): Promise<void> {
     this._abortConnection(connection, error);
   }
 
-  private _abortConnection(connection: RTCPeerConnection, error: Error) {
+  private _abortConnection(connection: RTCPeerConnection, error: Error): void {
     if (connection !== this._connection) {
       log.error('attempted to abort an inactive connection', { error });
       this._safeCloseConnection(connection);
@@ -261,7 +261,7 @@ export class RtcPeerConnection {
   }
 
   @synchronized
-  private _lockAndCloseConnection() {
+  private async _lockAndCloseConnection(): Promise<void> {
     invariant(this._transportChannels.size === 0);
     if (this._connection) {
       this._safeCloseConnection();
@@ -270,7 +270,7 @@ export class RtcPeerConnection {
   }
 
   @synchronized
-  public async onSignal(signal: Signal) {
+  public async onSignal(signal: Signal): Promise<void> {
     const connection = this._connection;
     if (!connection) {
       log.warn('a signal ignored because the connection was closed', { type: signal.payload.data.type });
@@ -335,7 +335,7 @@ export class RtcPeerConnection {
     log('signal processed', { type: data.type });
   }
 
-  private async _processIceCandidate(connection: RTCPeerConnection, candidate: RTCIceCandidate) {
+  private async _processIceCandidate(connection: RTCPeerConnection, candidate: RTCIceCandidate): Promise<void> {
     try {
       // ICE candidates are associated with a session, so we need to wait for the remote description to be set.
       await this._readyForCandidates.wait();
@@ -348,7 +348,7 @@ export class RtcPeerConnection {
     }
   }
 
-  private _onSessionNegotiated(connection: RTCPeerConnection) {
+  private _onSessionNegotiated(connection: RTCPeerConnection): void {
     if (connection === this._connection) {
       log('ready to process ice candidates');
       this._readyForCandidates.wake();
@@ -357,7 +357,7 @@ export class RtcPeerConnection {
     }
   }
 
-  private _onConnectionCallbackAfterClose(callback: string, connection: RTCPeerConnection) {
+  private _onConnectionCallbackAfterClose(callback: string, connection: RTCPeerConnection): void {
     log.warn('callback invoked after a connection was destroyed, this is probably a bug', {
       callback,
       state: connection.connectionState,
@@ -365,7 +365,7 @@ export class RtcPeerConnection {
     this._safeCloseConnection(connection);
   }
 
-  private _safeCloseConnection(connection: RTCPeerConnection | undefined = this._connection) {
+  private _safeCloseConnection(connection: RTCPeerConnection | undefined = this._connection): void {
     const resetFields = this._connection && connection === this._connection;
     try {
       connection?.close();
@@ -397,7 +397,7 @@ export class RtcPeerConnection {
     return config;
   }
 
-  private async _sendIceCandidate(candidate: RTCIceCandidate) {
+  private async _sendIceCandidate(candidate: RTCIceCandidate): Promise<void> {
     try {
       await this._options.sendSignal({
         payload: {
@@ -417,7 +417,7 @@ export class RtcPeerConnection {
     }
   }
 
-  private async _sendDescription(connection: RTCPeerConnection, description: RTCSessionDescriptionInit) {
+  private async _sendDescription(connection: RTCPeerConnection, description: RTCSessionDescriptionInit): Promise<void> {
     if (connection !== this._connection) {
       // Connection was closed while description was being created.
       return;

package/src/transport/webrtc/rtc-transport-channel.ts

@@ -46,13 +46,13 @@ export class RtcTransportChannel extends Resource implements Transport {
     return this._isChannelCreationInProgress;
   }
 
-  public onConnectionError(error: Error) {
+  public onConnectionError(error: Error): void {
     if (this.isOpen) {
       this.errors.raise(error);
     }
   }
 
-  protected override async _open() {
+  protected override async _open(): Promise<void> {
     invariant(!this._isChannelCreationInProgress);
     this._isChannelCreationInProgress = true;
     this._connection
@@ -81,7 +81,7 @@ export class RtcTransportChannel extends Resource implements Transport {
       });
   }
 
-  protected override async _close() {
+  protected override async _close(): Promise<void> {
     if (this._channel) {
       this._safeCloseChannel(this._channel);
       this._channel = undefined;
@@ -92,7 +92,7 @@ export class RtcTransportChannel extends Resource implements Transport {
     log('closed');
   }
 
-  private _initChannel(channel: RTCDataChannel) {
+  private _initChannel(channel: RTCDataChannel): void {
     Object.assign<RTCDataChannel, Partial<RTCDataChannel>>(channel, {
       onopen: () => {
         if (!this.isOpen) {
@@ -148,7 +148,7 @@ export class RtcTransportChannel extends Resource implements Transport {
     });
   }
 
-  private async _handleChannelWrite(chunk: any, callback: PendingStreamFlushedCallback) {
+  private async _handleChannelWrite(chunk: any, callback: PendingStreamFlushedCallback): Promise<void> {
     if (!this._channel) {
       log.warn('writing to a channel after a connection was closed');
       return;
@@ -179,7 +179,7 @@ export class RtcTransportChannel extends Resource implements Transport {
     }
   }
 
-  private _safeCloseChannel(channel: RTCDataChannel) {
+  private _safeCloseChannel(channel: RTCDataChannel): void {
     try {
       channel.close();
     } catch (error: any) {

package/src/transport/webrtc/rtc-transport-proxy.ts

@@ -39,7 +39,7 @@ export class RtcTransportProxy extends Resource implements Transport {
     super();
   }
 
-  protected override async _open() {
+  protected override async _open(): Promise<void> {
     let stream: Stream<BridgeEvent>;
     try {
       stream = this._options.bridgeService.open(
@@ -120,7 +120,7 @@ export class RtcTransportProxy extends Resource implements Transport {
     );
   }
 
-  protected override async _close() {
+  protected override async _close(): Promise<void> {
     try {
       await this._serviceStream?.close();
       this._serviceStream = undefined;
@@ -137,7 +137,7 @@ export class RtcTransportProxy extends Resource implements Transport {
     this.closed.emit();
   }
 
-  async onSignal(signal: Signal) {
+  async onSignal(signal: Signal): Promise<void> {
     this._options.bridgeService
       .sendSignal({ proxyId: this._proxyId, signal }, { timeout: RPC_TIMEOUT })
       .catch((err) => this._raiseIfOpen(decodeError(err)));
@@ -161,7 +161,7 @@ export class RtcTransportProxy extends Resource implements Transport {
     }
   }
 
-  private _handleData(dataEvent: BridgeEvent.DataEvent) {
+  private _handleData(dataEvent: BridgeEvent.DataEvent): void {
     try {
       // NOTE: This must be a Buffer otherwise hypercore-protocol breaks.
       this._options.stream.write(arrayToBuffer(dataEvent.payload));
@@ -170,7 +170,7 @@ export class RtcTransportProxy extends Resource implements Transport {
     }
   }
 
-  private async _handleSignal(signalEvent: BridgeEvent.SignalEvent) {
+  private async _handleSignal(signalEvent: BridgeEvent.SignalEvent): Promise<void> {
     try {
       await this._options.sendSignal(signalEvent.payload);
     } catch (error) {
@@ -208,7 +208,7 @@ export class RtcTransportProxy extends Resource implements Transport {
     }
   }
 
-  private _raiseIfOpen(error: any) {
+  private _raiseIfOpen(error: any): void {
     if (this.isOpen) {
       this.errors.raise(error);
     } else {
@@ -219,7 +219,7 @@ export class RtcTransportProxy extends Resource implements Transport {
   /**
    * Called when underlying proxy service becomes unavailable.
    */
-  forceClose() {
+  forceClose(): void {
     void this._serviceStream?.close();
     this.closed.emit();
   }

package/src/transport/webrtc/rtc-transport-service.ts

@@ -43,7 +43,7 @@ export class RtcTransportService implements BridgeService {
     private readonly _transportFactory: TransportFactory = createRtcTransportFactory(webrtcConfig, iceProvider),
   ) {}
 
-  public hasOpenTransports() {
+  public hasOpenTransports(): boolean {
     return this._openTransports.size > 0;
   }
 
@@ -151,7 +151,7 @@ export class RtcTransportService implements BridgeService {
     }
   }
 
-  async close({ proxyId }: CloseRequest) {
+  async close({ proxyId }: CloseRequest): Promise<void> {
     const transport = this._openTransports.get(proxyId);
     if (!transport) {
       return;
@@ -161,7 +161,7 @@ export class RtcTransportService implements BridgeService {
     await this._safeCloseTransport(transport);
   }
 
-  private async _safeCloseTransport(transport: TransportState) {
+  private async _safeCloseTransport(transport: TransportState): Promise<void> {
     if (this._openTransports.get(transport.proxyId) === transport) {
       this._openTransports.delete(transport.proxyId);
     }