@dxos/network-manager 0.8.2-main.fbd8ed0 → 0.8.2-staging.4d6ad0f

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

@@ -241,7 +241,7 @@ export class RtcPeerConnection {
     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 async _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);
     }