livekit-client 0.18.6 → 1.0.0

package/src/room/RTCEngine.ts

@@ -48,6 +48,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   rtcConfig: RTCConfiguration = {};
 
+  get isClosed() {
+    return this._isClosed;
+  }
+
   private lossyDC?: RTCDataChannel;
 
   // @ts-ignore noUnusedLocals
@@ -64,7 +68,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private pcState: PCState = PCState.New;
 
-  private isClosed: boolean = true;
+  private _isClosed: boolean = true;
 
   private pendingTrackResolvers: { [key: string]: (info: TrackInfo) => void } = {};
 
@@ -94,13 +98,18 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.client = new SignalClient();
   }
 
-  async join(url: string, token: string, opts?: SignalOptions): Promise<JoinResponse> {
+  async join(
+    url: string,
+    token: string,
+    opts?: SignalOptions,
+    abortSignal?: AbortSignal,
+  ): Promise<JoinResponse> {
     this.url = url;
     this.token = token;
     this.signalOpts = opts;
 
-    const joinResponse = await this.client.join(url, token, opts);
-    this.isClosed = false;
+    const joinResponse = await this.client.join(url, token, opts, abortSignal);
+    this._isClosed = false;
 
     this.subscriberPrimary = joinResponse.subscriberPrimary;
     if (!this.publisher) {
@@ -117,7 +126,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   }
 
   close() {
-    this.isClosed = true;
+    this._isClosed = true;
 
     this.removeAllListeners();
     if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
@@ -403,7 +412,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   // continues to work, we can reconnect to websocket to continue the session
   // after a number of retries, we'll close and give up permanently
   private handleDisconnect = (connection: string) => {
-    if (this.isClosed) {
+    if (this._isClosed) {
       return;
     }
     log.debug(`${connection} disconnected`);
@@ -414,7 +423,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     const delay = this.reconnectAttempts * this.reconnectAttempts * 300;
     setTimeout(async () => {
-      if (this.isClosed) {
+      if (this._isClosed) {
         return;
       }
       if (

package/src/room/Room.ts

@@ -35,12 +35,16 @@ import { AdaptiveStreamSettings, RemoteTrack } from './track/types';
 import { getNewAudioContext } from './track/utils';
 import { isWeb, unpackStreamId } from './utils';
 
-export enum RoomState {
+export enum ConnectionState {
   Disconnected = 'disconnected',
+  Connecting = 'connecting',
   Connected = 'connected',
   Reconnecting = 'reconnecting',
 }
 
+/** @deprecated RoomState has been renamed to [[ConnectionState]] */
+export const RoomState = ConnectionState;
+
 /**
  * In LiveKit, a room is the logical grouping for a list of participants.
  * Participants in a room can publish tracks, and subscribe to others' tracks.
@@ -50,7 +54,7 @@ export enum RoomState {
  * @noInheritDoc
  */
 class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>) {
-  state: RoomState = RoomState.Disconnected;
+  state: ConnectionState = ConnectionState.Disconnected;
 
   /** map of sid: [[RemoteParticipant]] */
   participants: Map<string, RemoteParticipant>;
@@ -87,6 +91,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private audioContext?: AudioContext;
 
+  /** used for aborting pending connections to a LiveKit server */
+  private abortController?: AbortController;
+
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -150,18 +157,16 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(EngineEvent.ActiveSpeakersUpdate, this.handleActiveSpeakersUpdate)
       .on(EngineEvent.DataPacketReceived, this.handleDataPacket)
       .on(EngineEvent.Resuming, () => {
-        this.state = RoomState.Reconnecting;
+        this.setAndEmitConnectionState(ConnectionState.Reconnecting);
         this.emit(RoomEvent.Reconnecting);
-        this.emit(RoomEvent.StateChanged, this.state);
       })
       .on(EngineEvent.Resumed, () => {
-        this.state = RoomState.Connected;
+        this.setAndEmitConnectionState(ConnectionState.Connected);
         this.emit(RoomEvent.Reconnected);
-        this.emit(RoomEvent.StateChanged, this.state);
         this.updateSubscriptions();
       })
       .on(EngineEvent.SignalResumed, () => {
-        if (this.state === RoomState.Reconnecting) {
+        if (this.state === ConnectionState.Reconnecting) {
           this.sendSyncState();
         }
       })
@@ -186,11 +191,17 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   connect = async (url: string, token: string, opts?: RoomConnectOptions) => {
     // guard against calling connect
-    if (this.state !== RoomState.Disconnected) {
+    if (this.state !== ConnectionState.Disconnected) {
       log.warn(`already connected to room ${this.name}`);
       return;
     }
 
+    this.setAndEmitConnectionState(ConnectionState.Connecting);
+
+    if (!this.abortController || this.abortController.signal.aborted) {
+      this.abortController = new AbortController();
+    }
+
     // recreate engine if previously disconnected
     this.createEngine();
 
@@ -203,12 +214,17 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.connOptions = opts;
 
     try {
-      const joinResponse = await this.engine.join(url, token, {
-        autoSubscribe: opts?.autoSubscribe,
-        publishOnly: opts?.publishOnly,
-        adaptiveStream:
-          typeof this.options?.adaptiveStream === 'object' ? true : this.options?.adaptiveStream,
-      });
+      const joinResponse = await this.engine.join(
+        url,
+        token,
+        {
+          autoSubscribe: opts?.autoSubscribe,
+          publishOnly: opts?.publishOnly,
+          adaptiveStream:
+            typeof this.options?.adaptiveStream === 'object' ? true : this.options?.adaptiveStream,
+        },
+        this.abortController.signal,
+      );
       log.debug(
         `connected to Livekit Server version: ${joinResponse.serverVersion}, region: ${joinResponse.serverRegion}`,
       );
@@ -223,7 +239,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.options.dynacast = false;
       }
 
-      this.state = RoomState.Connected;
       const pi = joinResponse.participant!;
 
       this.localParticipant.sid = pi.sid;
@@ -232,9 +247,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.localParticipant.updateInfo(pi);
       // forward metadata changed for the local participant
       this.localParticipant
-        .on(ParticipantEvent.MetadataChanged, (metadata: string | undefined) => {
-          this.emit(RoomEvent.MetadataChanged, metadata, this.localParticipant);
-        })
         .on(ParticipantEvent.ParticipantMetadataChanged, (metadata: string | undefined) => {
           this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
         })
@@ -275,9 +287,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.name = joinResponse.room!.name;
       this.sid = joinResponse.room!.sid;
       this.metadata = joinResponse.room!.metadata;
-      this.emit(RoomEvent.StateChanged, this.state);
     } catch (err) {
       this.engine.close();
+      this.setAndEmitConnectionState(ConnectionState.Disconnected);
       throw err;
     }
 
@@ -286,18 +298,30 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       const connectTimeout = setTimeout(() => {
         // timeout
         this.engine.close();
+        this.setAndEmitConnectionState(ConnectionState.Disconnected);
         reject(new ConnectionError('could not connect after timeout'));
       }, maxICEConnectTimeout);
+      const abortHandler = () => {
+        log.warn('closing engine');
+        clearTimeout(connectTimeout);
+        this.engine.close();
+        this.setAndEmitConnectionState(ConnectionState.Disconnected);
+        reject(new ConnectionError('room connection has been cancelled'));
+      };
+      if (this.abortController?.signal.aborted) {
+        abortHandler();
+      }
+      this.abortController?.signal.addEventListener('abort', abortHandler);
 
       this.engine.once(EngineEvent.Connected, () => {
         clearTimeout(connectTimeout);
-
+        this.abortController?.signal.removeEventListener('abort', abortHandler);
         // also hook unload event
         if (isWeb()) {
           window.addEventListener('beforeunload', this.onBeforeUnload);
           navigator.mediaDevices?.addEventListener('devicechange', this.handleDeviceChange);
         }
-
+        this.setAndEmitConnectionState(ConnectionState.Connected);
         resolve(this);
       });
     });
@@ -307,6 +331,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    * disconnects the room, emits [[RoomEvent.Disconnected]]
    */
   disconnect = (stopTracks = true) => {
+    if (this.state === ConnectionState.Connecting) {
+      // try aborting pending connection attempt
+      log.warn('abort connection attempt');
+      this.abortController?.abort();
+      return;
+    }
     // send leave
     if (this.engine) {
       this.engine.client.sendLeave();
@@ -482,9 +512,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private handleRestarting = () => {
-    this.state = RoomState.Reconnecting;
+    this.setAndEmitConnectionState(ConnectionState.Reconnecting);
     this.emit(RoomEvent.Reconnecting);
-    this.emit(RoomEvent.StateChanged, this.state);
 
     // also unwind existing participants & existing subscriptions
     for (const p of this.participants.values()) {
@@ -494,9 +523,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private handleRestarted = async (joinResponse: JoinResponse) => {
     log.debug(`reconnected to server region ${joinResponse.serverRegion}`);
-    this.state = RoomState.Connected;
+    this.setAndEmitConnectionState(ConnectionState.Connected);
     this.emit(RoomEvent.Reconnected);
-    this.emit(RoomEvent.StateChanged, this.state);
 
     // rehydrate participants
     if (joinResponse.participant) {
@@ -524,9 +552,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private handleDisconnect(shouldStopTracks = true) {
-    if (this.state === RoomState.Disconnected) {
-      return;
-    }
     this.participants.forEach((p) => {
       p.tracks.forEach((pub) => {
         p.unpublishTrack(pub.trackSid);
@@ -553,9 +578,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       window.removeEventListener('beforeunload', this.onBeforeUnload);
       navigator.mediaDevices?.removeEventListener('devicechange', this.handleDeviceChange);
     }
-    this.state = RoomState.Disconnected;
+    this.setAndEmitConnectionState(ConnectionState.Disconnected);
     this.emit(RoomEvent.Disconnected);
-    this.emit(RoomEvent.StateChanged, this.state);
   }
 
   private handleParticipantUpdates = (participantInfos: ParticipantInfo[]) => {
@@ -821,9 +845,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(ParticipantEvent.TrackUnmuted, (pub: TrackPublication) => {
         this.emit(RoomEvent.TrackUnmuted, pub, participant);
       })
-      .on(ParticipantEvent.MetadataChanged, (metadata: string | undefined) => {
-        this.emit(RoomEvent.MetadataChanged, metadata, participant);
-      })
       .on(ParticipantEvent.ParticipantMetadataChanged, (metadata: string | undefined) => {
         this.emit(RoomEvent.ParticipantMetadataChanged, metadata, participant);
       })
@@ -892,6 +913,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   }
 
+  private setAndEmitConnectionState(state: ConnectionState) {
+    if (state === this.state) {
+      return;
+    }
+    this.state = state;
+    this.emit(RoomEvent.ConnectionStateChanged, this.state);
+  }
+
   // /** @internal */
   emit<E extends keyof RoomEventCallbacks>(
     event: E,
@@ -908,7 +937,9 @@ export type RoomEventCallbacks = {
   reconnecting: () => void;
   reconnected: () => void;
   disconnected: () => void;
-  stateChanged: (state: RoomState) => void;
+  /** @deprecated stateChanged has been renamed to connectionStateChanged */
+  stateChanged: (state: ConnectionState) => void;
+  connectionStateChanged: (state: ConnectionState) => void;
   mediaDevicesChanged: () => void;
   participantConnected: (participant: RemoteParticipant) => void;
   participantDisconnected: (participant: RemoteParticipant) => void;
@@ -932,13 +963,6 @@ export type RoomEventCallbacks = {
     publication: LocalTrackPublication,
     participant: LocalParticipant,
   ) => void;
-  /**
-   * @deprecated use [[participantMetadataChanged]] instead
-   */
-  metadataChanged: (
-    metadata: string | undefined,
-    participant?: RemoteParticipant | LocalParticipant,
-  ) => void;
   participantMetadataChanged: (
     metadata: string | undefined,
     participant: RemoteParticipant | LocalParticipant,

package/src/room/events.ts

@@ -29,9 +29,14 @@ export enum RoomEvent {
   /**
    * Whenever the connection state of the room changes
    *
-   * args: ([[RoomState]])
+   * args: ([[ConnectionState]])
    */
-  StateChanged = 'stateChanged',
+  ConnectionStateChanged = 'connectionStateChanged',
+
+  /**
+   * @deprecated StateChanged has been renamed to ConnectionStateChanged
+   */
+  StateChanged = 'connectionStateChanged',
 
   /**
    * When input or output devices on the machine have changed.
@@ -139,12 +144,6 @@ export enum RoomEvent {
    */
   ActiveSpeakersChanged = 'activeSpeakersChanged',
 
-  /**
-   * @deprecated Use ParticipantMetadataChanged instead
-   * @internal
-   */
-  MetadataChanged = 'metadataChanged',
-
   /**
    * Participant metadata is a simple way for app-specific state to be pushed to
    * all users.
@@ -308,12 +307,6 @@ export enum ParticipantEvent {
    */
   LocalTrackUnpublished = 'localTrackUnpublished',
 
-  /**
-   * @deprecated Use ParticipantMetadataChanged instead
-   * @internal
-   */
-  MetadataChanged = 'metadataChanged',
-
   /**
    * Participant metadata is a simple way for app-specific state to be pushed to
    * all users.

package/src/room/participant/LocalParticipant.ts

@@ -436,6 +436,10 @@ export default class LocalParticipant extends Participant {
       ];
     }
 
+    if (!this.engine || this.engine.isClosed) {
+      throw new UnexpectedConnectionState('cannot publish track when not connected');
+    }
+
     const ti = await this.engine.addTrack(req);
     const publication = new LocalTrackPublication(track.kind, ti, track);
     track.sid = ti.sid;

package/src/room/participant/Participant.ts

@@ -188,7 +188,6 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     this.metadata = md;
 
     if (changed) {
-      this.emit(ParticipantEvent.MetadataChanged, prevMetadata);
       this.emit(ParticipantEvent.ParticipantMetadataChanged, prevMetadata);
     }
   }
@@ -266,10 +265,6 @@ export type ParticipantEventCallbacks = {
   trackUnmuted: (publication: TrackPublication) => void;
   localTrackPublished: (publication: LocalTrackPublication) => void;
   localTrackUnpublished: (publication: LocalTrackPublication) => void;
-  /**
-   * @deprecated use [[participantMetadataChanged]] instead
-   */
-  metadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
   participantMetadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
   dataReceived: (payload: Uint8Array, kind: DataPacket_Kind) => void;
   isSpeakingChanged: (speaking: boolean) => void;

package/src/room/participant/RemoteParticipant.ts

@@ -19,6 +19,8 @@ export default class RemoteParticipant extends Participant {
 
   signalClient: SignalClient;
 
+  private volume?: number;
+
   /** @internal */
   static fromParticipantInfo(signalClient: SignalClient, pi: ParticipantInfo): RemoteParticipant {
     const rp = new RemoteParticipant(signalClient, pi.sid, pi.identity);
@@ -68,24 +70,26 @@ export default class RemoteParticipant extends Participant {
   }
 
   /**
-   * sets the volume on the participant's microphone track if it exists.
+   * sets the volume on the participant's microphone track
+   * if no track exists the volume will be applied when the microphone track is added
    */
   setVolume(volume: number) {
+    this.volume = volume;
     const audioPublication = this.getTrack(Track.Source.Microphone);
-    if (audioPublication) {
+    if (audioPublication && audioPublication.track) {
       (audioPublication.track as RemoteAudioTrack).setVolume(volume);
     }
   }
 
   /**
    * gets the volume on the participant's microphone track
-   * returns undefined if no microphone track exists
    */
   getVolume() {
     const audioPublication = this.getTrack(Track.Source.Microphone);
-    if (audioPublication) {
+    if (audioPublication && audioPublication.track) {
       return (audioPublication.track as RemoteAudioTrack).getVolume();
     }
+    return this.volume;
   }
 
   /** @internal */
@@ -153,7 +157,14 @@ export default class RemoteParticipant extends Participant {
     track.start();
 
     publication.setTrack(track);
-
+    // set participant volume on new microphone tracks
+    if (
+      this.volume !== undefined &&
+      track instanceof RemoteAudioTrack &&
+      track.source === Track.Source.Microphone
+    ) {
+      track.setVolume(this.volume);
+    }
     this.emit(ParticipantEvent.TrackSubscribed, track, publication);
 
     return publication;

package/src/room/participant/publishUtils.test.ts

@@ -28,11 +28,11 @@ describe('presetsForResolution', () => {
 
 describe('determineAppropriateEncoding', () => {
   it('uses higher encoding', () => {
-    expect(determineAppropriateEncoding(false, 600, 300)).toEqual(VideoPresets.vga.encoding);
+    expect(determineAppropriateEncoding(false, 600, 300)).toEqual(VideoPresets.h360.encoding);
   });
 
   it('handles portrait', () => {
-    expect(determineAppropriateEncoding(false, 300, 600)).toEqual(VideoPresets.vga.encoding);
+    expect(determineAppropriateEncoding(false, 300, 600)).toEqual(VideoPresets.h360.encoding);
   });
 });
 

package/src/room/track/create.ts

@@ -89,7 +89,7 @@ export async function createLocalScreenTracks(
     options = {};
   }
   if (options.resolution === undefined) {
-    options.resolution = VideoPresets.fhd.resolution;
+    options.resolution = VideoPresets.h1080.resolution;
   }
 
   let videoConstraints: MediaTrackConstraints | boolean = true;

package/src/room/track/options.ts

@@ -236,16 +236,6 @@ export const VideoPresets = {
   h1080: new VideoPreset(1920, 1080, 3_000_000, 30),
   h1440: new VideoPreset(2560, 1440, 5_000_000, 30),
   h2160: new VideoPreset(3840, 2160, 8_000_000, 30),
-  /** @deprecated */
-  qvga: new VideoPreset(320, 180, 120_000, 10),
-  /** @deprecated */
-  vga: new VideoPreset(640, 360, 300_000, 20),
-  /** @deprecated */
-  qhd: new VideoPreset(960, 540, 600_000, 25),
-  /** @deprecated */
-  hd: new VideoPreset(1280, 720, 1_700_000, 30),
-  /** @deprecated */
-  fhd: new VideoPreset(1920, 1080, 3_000_000, 30),
 } as const;
 
 /**
@@ -261,16 +251,6 @@ export const VideoPresets43 = {
   h720: new VideoPreset(960, 720, 1_500_000, 30),
   h1080: new VideoPreset(1440, 1080, 2_500_000, 30),
   h1440: new VideoPreset(1920, 1440, 3_500_000, 30),
-  /** @deprecated */
-  qvga: new VideoPreset(240, 180, 90_000, 10),
-  /** @deprecated */
-  vga: new VideoPreset(480, 360, 225_000, 20),
-  /** @deprecated */
-  qhd: new VideoPreset(720, 540, 450_000, 25),
-  /** @deprecated */
-  hd: new VideoPreset(960, 720, 1_500_000, 30),
-  /** @deprecated */
-  fhd: new VideoPreset(1440, 1080, 2_800_000, 30),
 } as const;
 
 export const ScreenSharePresets = {
@@ -279,14 +259,4 @@ export const ScreenSharePresets = {
   h720fps15: new VideoPreset(1280, 720, 1_000_000, 15),
   h1080fps15: new VideoPreset(1920, 1080, 1_500_000, 15),
   h1080fps30: new VideoPreset(1920, 1080, 3_000_000, 30),
-  /** @deprecated */
-  vga: new VideoPreset(640, 360, 200_000, 3),
-  /** @deprecated */
-  hd_8: new VideoPreset(1280, 720, 400_000, 5),
-  /** @deprecated */
-  hd_15: new VideoPreset(1280, 720, 1_000_000, 15),
-  /** @deprecated */
-  fhd_15: new VideoPreset(1920, 1080, 1_500_000, 15),
-  /** @deprecated */
-  fhd_30: new VideoPreset(1920, 1080, 3_000_000, 30),
 } as const;

package/src/room/track/utils.test.ts

@@ -8,7 +8,7 @@ describe('mergeDefaultOptions', () => {
   };
   const videoDefaults: VideoCaptureOptions = {
     deviceId: 'video123',
-    resolution: VideoPresets.fhd.resolution,
+    resolution: VideoPresets.h1080.resolution,
   };
 
   it('does not enable undefined options', () => {
@@ -88,7 +88,7 @@ describe('constraintsForOptions', () => {
   it('converts video options correctly', () => {
     const constraints = constraintsForOptions({
       video: {
-        resolution: VideoPresets.hd.resolution,
+        resolution: VideoPresets.h720.resolution,
         facingMode: 'user',
         deviceId: 'video123',
       },
@@ -102,9 +102,9 @@ describe('constraintsForOptions', () => {
       'facingMode',
       'deviceId',
     ]);
-    expect(videoOpts.width).toEqual(VideoPresets.hd.resolution.width);
-    expect(videoOpts.height).toEqual(VideoPresets.hd.resolution.height);
-    expect(videoOpts.frameRate).toEqual(VideoPresets.hd.resolution.frameRate);
-    expect(videoOpts.aspectRatio).toEqual(VideoPresets.hd.resolution.aspectRatio);
+    expect(videoOpts.width).toEqual(VideoPresets.h720.resolution.width);
+    expect(videoOpts.height).toEqual(VideoPresets.h720.resolution.height);
+    expect(videoOpts.frameRate).toEqual(VideoPresets.h720.resolution.frameRate);
+    expect(videoOpts.aspectRatio).toEqual(VideoPresets.h720.resolution.aspectRatio);
   });
 });

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.18.6';
+export const version = '1.0.0';
 export const protocolVersion = 7;

package/dist/connect.d.ts

@@ -1,24 +0,0 @@
-import { ConnectOptions } from './options';
-import Room from './room/Room';
-export { version } from './version';
-/**
- * @deprecated Use room.connect() instead
- *
- * Connects to a LiveKit room, shorthand for `new Room()` and [[Room.connect]]
- *
- * ```typescript
- * connect('wss://myhost.livekit.io', token, {
- *   // publish audio and video tracks on joining
- *   audio: true,
- *   video: true,
- *   captureDefaults: {
- *    facingMode: 'user',
- *   },
- * })
- * ```
- * @param url URL to LiveKit server
- * @param token AccessToken, a JWT token that includes authentication and room details
- * @param options
- */
-export declare function connect(url: string, token: string, options?: ConnectOptions): Promise<Room>;
-//# sourceMappingURL=connect.d.ts.map

package/dist/connect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../src/connect.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAG3C,OAAO,IAAI,MAAM,aAAa,CAAC;AAE/B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAsEjG"}