@stream-io/video-client 0.3.2 → 0.3.4

package/dist/src/Call.d.ts

@@ -217,8 +217,9 @@ export declare class Call {
      *
      *
      * @param trackType the track type to stop publishing.
+     * @param stopTrack if `true` the track will be stopped, else it will be just disabled
      */
-    stopPublish: (trackType: TrackType) => Promise<void>;
+    stopPublish: (trackType: TrackType, stopTrack?: boolean) => Promise<void>;
     /**
      * Update track subscription configuration for one or more participants.
      * You have to create a subscription for each participant for all the different kinds of tracks you want to receive.

package/dist/src/coordinator/connection/client.d.ts

@@ -4,8 +4,9 @@ import WebSocket from 'isomorphic-ws';
 import { StableWSConnection } from './connection';
 import { TokenManager } from './token_manager';
 import { WSConnectionFallback } from './connection_fallback';
-import { APIErrorResponse, ConnectAPIResponse, ErrorFromResponse, EventHandler, Logger, StreamClientOptions, StreamVideoEvent, TokenOrProvider, UserWithId } from './types';
+import { APIErrorResponse, ConnectAPIResponse, ErrorFromResponse, EventHandler, Logger, StreamClientOptions, StreamVideoEvent, TokenOrProvider, User, UserWithId } from './types';
 import { InsightMetrics } from './insights';
+import { CreateGuestResponse } from '../../gen/coordinator';
 export declare class StreamClient {
     _user?: UserWithId;
     anonymous: boolean;
@@ -38,6 +39,7 @@ export declare class StreamClient {
     resolveConnectionId?: Function;
     rejectConnectionId?: Function;
     connectionIdPromise?: Promise<string | undefined>;
+    guestUserCreatePromise?: Promise<CreateGuestResponse>;
     private nextRequestAbortController;
     /**
      * Initialize a client.
@@ -66,7 +68,7 @@ export declare class StreamClient {
      *
      * @return {ConnectAPIResponse} Returns a promise that resolves when the connection is setup
      */
-    connectUser: (user: UserWithId, userTokenOrProvider: TokenOrProvider) => Promise<void | import("../../..").ConnectedEvent>;
+    connectUser: (user: UserWithId, userTokenOrProvider: TokenOrProvider) => Promise<void | import("../../gen/coordinator").ConnectedEvent>;
     _setToken: (user: UserWithId, userTokenOrProvider: TokenOrProvider, isAnonymous: boolean) => Promise<void>;
     _setUser: (user: UserWithId) => void;
     /**
@@ -86,7 +88,7 @@ export declare class StreamClient {
     /**
      * Creates a new WebSocket connection with the current user. Returns empty promise, if there is an active connection
      */
-    openConnection: () => Promise<void | import("../../..").ConnectedEvent>;
+    openConnection: () => Promise<void | import("../../gen/coordinator").ConnectedEvent>;
     _normalizeDate: (before: Date | string | null) => string | null;
     /**
      * Disconnects the websocket and removes the user from client.
@@ -95,6 +97,9 @@ export declare class StreamClient {
      *                https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
      */
     disconnectUser: (timeout?: number) => Promise<void>;
+    connectGuestUser: (user: User & {
+        type: 'guest';
+    }) => Promise<void | import("../../gen/coordinator").ConnectedEvent>;
     /**
      * connectAnonymousUser - Set an anonymous user and open a WebSocket connection
      */
@@ -144,7 +149,7 @@ export declare class StreamClient {
     /**
      * @private
      */
-    connect: () => Promise<void | import("../../..").ConnectedEvent>;
+    connect: () => Promise<void | import("../../gen/coordinator").ConnectedEvent>;
     /**
      * Check the connectivity with server for warmup purpose.
      *

package/dist/src/devices/CameraManager.d.ts

@@ -19,13 +19,7 @@ export declare class CameraManager extends InputMediaDeviceManager<CameraManager
     protected getDevices(): Observable<MediaDeviceInfo[]>;
     protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
     protected publishStream(stream: MediaStream): Promise<void>;
-    protected stopPublishStream(): Promise<void>;
-    /**
-     * Disables the video tracks of the camera
-     */
-    pause(): void;
-    /**
-     * (Re)enables the video tracks of the camera
-     */
-    resume(): void;
+    protected stopPublishStream(stopTracks: boolean): Promise<void>;
+    protected muteTracks(): void;
+    protected unmuteTracks(): void;
 }

package/dist/src/devices/InputMediaDeviceManager.d.ts

@@ -19,11 +19,17 @@ export declare abstract class InputMediaDeviceManager<T extends InputMediaDevice
     enable(): Promise<void>;
     /**
      * Stops camera/microphone
+     *
      * @returns
      */
     disable(): Promise<void>;
+    /**
+     * If status was previously enabled, it will reenable the device.
+     */
+    resume(): Promise<void>;
     /**
      * If current device statis is disabled, it will enable the device, else it will disable it.
+     *
      * @returns
      */
     toggle(): Promise<void>;
@@ -36,12 +42,12 @@ export declare abstract class InputMediaDeviceManager<T extends InputMediaDevice
      */
     select(deviceId: string | undefined): Promise<void>;
     protected applySettingsToStream(): Promise<void>;
-    abstract pause(): void;
-    abstract resume(): void;
     protected abstract getDevices(): Observable<MediaDeviceInfo[]>;
     protected abstract getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
     protected abstract publishStream(stream: MediaStream): Promise<void>;
-    protected abstract stopPublishStream(): Promise<void>;
-    private stopStream;
-    private startStream;
+    protected abstract stopPublishStream(stopTracks: boolean): Promise<void>;
+    protected abstract muteTracks(): void;
+    protected abstract unmuteTracks(): void;
+    private muteStream;
+    private unmuteStream;
 }

package/dist/src/devices/InputMediaDeviceManagerState.d.ts

@@ -2,9 +2,14 @@ import { BehaviorSubject, Observable } from 'rxjs';
 import { RxUtils } from '../store';
 export type InputDeviceStatus = 'enabled' | 'disabled' | undefined;
 export declare abstract class InputMediaDeviceManagerState {
+    readonly disableMode: 'stop-tracks' | 'disable-tracks';
     protected statusSubject: BehaviorSubject<InputDeviceStatus>;
     protected mediaStreamSubject: BehaviorSubject<MediaStream | undefined>;
     protected selectedDeviceSubject: BehaviorSubject<string | undefined>;
+    /**
+     * @internal
+     */
+    prevStatus: InputDeviceStatus;
     /**
      * An Observable that emits the current media stream, or `undefined` if the device is currently disabled.
      *
@@ -18,7 +23,7 @@ export declare abstract class InputMediaDeviceManagerState {
      * An Observable that emits the device status
      */
     status$: Observable<InputDeviceStatus>;
-    constructor();
+    constructor(disableMode?: 'stop-tracks' | 'disable-tracks');
     /**
      * The device status
      */

package/dist/src/devices/MicrophoneManager.d.ts

@@ -7,13 +7,7 @@ export declare class MicrophoneManager extends InputMediaDeviceManager<Microphon
     protected getDevices(): Observable<MediaDeviceInfo[]>;
     protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
     protected publishStream(stream: MediaStream): Promise<void>;
-    protected stopPublishStream(): Promise<void>;
-    /**
-     * Disables the audio tracks of the microphone
-     */
-    pause(): void;
-    /**
-     * (Re)enables the audio tracks of the microphone
-     */
-    resume(): void;
+    protected stopPublishStream(stopTracks: boolean): Promise<void>;
+    protected muteTracks(): void;
+    protected unmuteTracks(): void;
 }

package/dist/src/devices/MicrophoneManagerState.d.ts

@@ -1,4 +1,5 @@
 import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
 export declare class MicrophoneManagerState extends InputMediaDeviceManagerState {
+    constructor();
     protected getDeviceIdFromStream(stream: MediaStream): string | undefined;
 }

package/dist/src/rtc/Publisher.d.ts

@@ -76,8 +76,9 @@ export declare class Publisher {
      * Stops publishing the given track type to the SFU, if it is currently being published.
      * Underlying track will be stopped and removed from the publisher.
      * @param trackType the track type to unpublish.
+     * @param stopTrack specifies whether track should be stopped or just disabled
      */
-    unpublishStream: (trackType: TrackType) => Promise<void>;
+    unpublishStream: (trackType: TrackType, stopTrack: boolean) => Promise<void>;
     /**
      * Returns true if the given track type is currently being published to the SFU.
      *

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.3.2";
+export declare const version = "0.3.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/src/Call.ts

@@ -1092,10 +1092,11 @@ export class Call {
    *
    *
    * @param trackType the track type to stop publishing.
+   * @param stopTrack if `true` the track will be stopped, else it will be just disabled
    */
-  stopPublish = async (trackType: TrackType) => {
+  stopPublish = async (trackType: TrackType, stopTrack: boolean = true) => {
     this.logger('info', `stopPublish ${TrackType[trackType]}`);
-    await this.publisher?.unpublishStream(trackType);
+    await this.publisher?.unpublishStream(trackType, stopTrack);
   };
 
   /**

package/src/StreamVideoClient.ts

@@ -152,16 +152,7 @@ export class StreamVideoClient {
     };
     if (user.type === 'guest') {
       connectUser = async () => {
-        const response = await this.createGuestUser({
-          user: {
-            ...user,
-            role: 'guest',
-          },
-        });
-        return this.streamClient.connectUser(
-          response.user,
-          response.access_token,
-        );
+        return this.streamClient.connectGuestUser(user);
       };
     }
     this.connectionPromise = this.disconnectionPromise

package/src/__tests__/StreamVideoClient.test.ts

@@ -3,6 +3,7 @@ import { StreamVideoClient } from '../StreamVideoClient';
 import 'dotenv/config';
 import { generateUUIDv4 } from '../coordinator/connection/utils';
 import { StreamVideoServerClient } from '../StreamVideoServerClient';
+import { User } from '../coordinator/connection/types';
 
 const apiKey = process.env.STREAM_API_KEY!;
 const secret = process.env.STREAM_SECRET!;
@@ -87,6 +88,18 @@ describe('StreamVideoClient', () => {
     );
   });
 
+  it('API calls should be hold until auth is done - guest user', async () => {
+    const user: User = {
+      id: 'jane-guest',
+      type: 'guest',
+    };
+
+    client.connectUser(user);
+    const response = await client.queryCalls({});
+
+    expect(response.calls).toBeDefined();
+  });
+
   afterEach(() => {
     client.disconnectUser();
   });

package/src/coordinator/connection/client.ts

@@ -30,11 +30,13 @@ import {
   StreamClientOptions,
   StreamVideoEvent,
   TokenOrProvider,
+  User,
   UserWithId,
 } from './types';
 import { InsightMetrics, postInsights } from './insights';
 import { version } from '../../../version';
 import { getLocationHint } from './location';
+import { CreateGuestRequest, CreateGuestResponse } from '../../gen/coordinator';
 
 export class StreamClient {
   _user?: UserWithId;
@@ -70,6 +72,7 @@ export class StreamClient {
   resolveConnectionId?: Function;
   rejectConnectionId?: Function;
   connectionIdPromise?: Promise<string | undefined>;
+  guestUserCreatePromise?: Promise<CreateGuestResponse>;
   private nextRequestAbortController: AbortController | null = null;
 
   /**
@@ -402,6 +405,30 @@ export class StreamClient {
     this.resolveConnectionId = undefined;
   };
 
+  connectGuestUser = async (user: User & { type: 'guest' }) => {
+    this.guestUserCreatePromise = this.doAxiosRequest<
+      CreateGuestResponse,
+      CreateGuestRequest
+    >(
+      'post',
+      '/guest',
+      {
+        user: {
+          ...user,
+          role: 'guest',
+        },
+      },
+      { publicEndpoint: true },
+    );
+
+    const response = await this.guestUserCreatePromise;
+    this.guestUserCreatePromise.finally(
+      () => (this.guestUserCreatePromise = undefined),
+    );
+
+    return this.connectUser(response.user, response.access_token);
+  };
+
   /**
    * connectAnonymousUser - Set an anonymous user and open a WebSocket connection
    */
@@ -524,6 +551,7 @@ export class StreamClient {
     if (!options.publicEndpoint) {
       await Promise.all([
         this.tokenManager.tokenReady(),
+        this.guestUserCreatePromise,
         this.connectionIdPromise,
       ]);
     }

package/src/devices/CameraManager.ts

@@ -49,25 +49,16 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
   protected publishStream(stream: MediaStream): Promise<void> {
     return this.call.publishVideoStream(stream);
   }
-  protected stopPublishStream(): Promise<void> {
-    return this.call.stopPublish(TrackType.VIDEO);
+  protected stopPublishStream(stopTracks: boolean): Promise<void> {
+    return this.call.stopPublish(TrackType.VIDEO, stopTracks);
   }
 
-  /**
-   * Disables the video tracks of the camera
-   */
-  pause() {
-    this.state.mediaStream?.getVideoTracks().forEach((track) => {
-      track.enabled = false;
-    });
+  protected muteTracks(): void {
+    this.state.mediaStream
+      ?.getVideoTracks()
+      .forEach((t) => (t.enabled = false));
   }
-
-  /**
-   * (Re)enables the video tracks of the camera
-   */
-  resume() {
-    this.state.mediaStream?.getVideoTracks().forEach((track) => {
-      track.enabled = true;
-    });
+  protected unmuteTracks(): void {
+    this.state.mediaStream?.getVideoTracks().forEach((t) => (t.enabled = true));
   }
 }

package/src/devices/CameraManagerState.ts

@@ -15,7 +15,7 @@ export class CameraManagerState extends InputMediaDeviceManagerState {
   direction$: Observable<CameraDirection>;
 
   constructor() {
-    super();
+    super('stop-tracks');
     this.direction$ = this.directionSubject
       .asObservable()
       .pipe(distinctUntilChanged());

package/src/devices/InputMediaDeviceManager.ts

@@ -28,24 +28,39 @@ export abstract class InputMediaDeviceManager<
     if (this.state.status === 'enabled') {
       return;
     }
-    await this.startStream();
+    await this.unmuteStream();
     this.state.setStatus('enabled');
   }
 
   /**
    * Stops camera/microphone
+   *
    * @returns
    */
   async disable() {
     if (this.state.status === 'disabled') {
       return;
     }
-    await this.stopStream();
+    this.state.prevStatus = this.state.status;
+    await this.muteStream(this.state.disableMode === 'stop-tracks');
     this.state.setStatus('disabled');
   }
 
+  /**
+   * If status was previously enabled, it will reenable the device.
+   */
+  async resume() {
+    if (
+      this.state.prevStatus === 'enabled' &&
+      this.state.status === 'disabled'
+    ) {
+      this.enable();
+    }
+  }
+
   /**
    * If current device statis is disabled, it will enable the device, else it will disable it.
+   *
    * @returns
    */
   async toggle() {
@@ -76,15 +91,11 @@ export abstract class InputMediaDeviceManager<
 
   protected async applySettingsToStream() {
     if (this.state.status === 'enabled') {
-      await this.stopStream();
-      await this.startStream();
+      await this.muteStream();
+      await this.unmuteStream();
     }
   }
 
-  abstract pause(): void;
-
-  abstract resume(): void;
-
   protected abstract getDevices(): Observable<MediaDeviceInfo[]>;
 
   protected abstract getStream(
@@ -93,26 +104,37 @@ export abstract class InputMediaDeviceManager<
 
   protected abstract publishStream(stream: MediaStream): Promise<void>;
 
-  protected abstract stopPublishStream(): Promise<void>;
+  protected abstract stopPublishStream(stopTracks: boolean): Promise<void>;
+
+  protected abstract muteTracks(): void;
+
+  protected abstract unmuteTracks(): void;
 
-  private async stopStream() {
+  private async muteStream(stopTracks: boolean = true) {
     if (!this.state.mediaStream) {
       return;
     }
     if (this.call.state.callingState === CallingState.JOINED) {
-      await this.stopPublishStream();
+      await this.stopPublishStream(stopTracks);
     } else if (this.state.mediaStream) {
-      disposeOfMediaStream(this.state.mediaStream);
+      stopTracks
+        ? disposeOfMediaStream(this.state.mediaStream)
+        : this.muteTracks();
+    }
+    if (stopTracks) {
+      this.state.setMediaStream(undefined);
     }
-    this.state.setMediaStream(undefined);
   }
 
-  private async startStream() {
+  private async unmuteStream() {
+    let stream: MediaStream;
     if (this.state.mediaStream) {
-      return;
+      stream = this.state.mediaStream;
+      this.unmuteTracks();
+    } else {
+      const constraints = { deviceId: this.state.selectedDevice };
+      stream = await this.getStream(constraints);
     }
-    const constraints = { deviceId: this.state.selectedDevice };
-    const stream = await this.getStream(constraints);
     if (this.call.state.callingState === CallingState.JOINED) {
       await this.publishStream(stream);
     }

package/src/devices/InputMediaDeviceManagerState.ts

@@ -11,6 +11,10 @@ export abstract class InputMediaDeviceManagerState {
   protected selectedDeviceSubject = new BehaviorSubject<string | undefined>(
     undefined,
   );
+  /**
+   * @internal
+   */
+  prevStatus: InputDeviceStatus;
 
   /**
    * An Observable that emits the current media stream, or `undefined` if the device is currently disabled.
@@ -28,12 +32,18 @@ export abstract class InputMediaDeviceManagerState {
    */
   status$: Observable<InputDeviceStatus>;
 
-  constructor() {
+  constructor(
+    public readonly disableMode:
+      | 'stop-tracks'
+      | 'disable-tracks' = 'stop-tracks',
+  ) {
     this.mediaStream$ = this.mediaStreamSubject.asObservable();
     this.selectedDevice$ = this.selectedDeviceSubject
       .asObservable()
       .pipe(distinctUntilChanged());
-    this.status$ = this.statusSubject.asObservable();
+    this.status$ = this.statusSubject
+      .asObservable()
+      .pipe(distinctUntilChanged());
   }
 
   /**

package/src/devices/MicrophoneManager.ts

@@ -21,25 +21,16 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
   protected publishStream(stream: MediaStream): Promise<void> {
     return this.call.publishAudioStream(stream);
   }
-  protected stopPublishStream(): Promise<void> {
-    return this.call.stopPublish(TrackType.AUDIO);
+  protected stopPublishStream(stopTracks: boolean): Promise<void> {
+    return this.call.stopPublish(TrackType.AUDIO, stopTracks);
   }
 
-  /**
-   * Disables the audio tracks of the microphone
-   */
-  pause() {
-    this.state.mediaStream?.getAudioTracks().forEach((track) => {
-      track.enabled = false;
-    });
+  protected muteTracks(): void {
+    this.state.mediaStream
+      ?.getAudioTracks()
+      .forEach((t) => (t.enabled = false));
   }
-
-  /**
-   * (Re)enables the audio tracks of the microphone
-   */
-  resume() {
-    this.state.mediaStream?.getAudioTracks().forEach((track) => {
-      track.enabled = true;
-    });
+  protected unmuteTracks(): void {
+    this.state.mediaStream?.getAudioTracks().forEach((t) => (t.enabled = true));
   }
 }

package/src/devices/MicrophoneManagerState.ts

@@ -1,6 +1,10 @@
 import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
 
 export class MicrophoneManagerState extends InputMediaDeviceManagerState {
+  constructor() {
+    super('disable-tracks');
+  }
+
   protected getDeviceIdFromStream(stream: MediaStream): string | undefined {
     return stream.getAudioTracks()[0]?.getSettings().deviceId as
       | string

package/src/devices/__tests__/CameraManager.test.ts

@@ -8,7 +8,6 @@ import { getVideoStream } from '../devices';
 import { TrackType } from '../../gen/video/sfu/models/models';
 import { CameraManager } from '../CameraManager';
 import { of } from 'rxjs';
-import { CallSettingsResponse } from '../../gen/coordinator';
 
 vi.mock('../devices.ts', () => {
   console.log('MOCKING devices API');
@@ -83,7 +82,10 @@ describe('CameraManager', () => {
 
     await manager.disable();
 
-    expect(manager['call'].stopPublish).toHaveBeenCalledWith(TrackType.VIDEO);
+    expect(manager['call'].stopPublish).toHaveBeenCalledWith(
+      TrackType.VIDEO,
+      true,
+    );
   });
 
   it('flip', async () => {
@@ -131,18 +133,6 @@ describe('CameraManager', () => {
     });
   });
 
-  it('should pause and resume tracks', async () => {
-    await manager.enable();
-
-    manager.pause();
-
-    expect(manager.state.mediaStream?.getVideoTracks()[0].enabled).toBe(false);
-
-    manager.resume();
-
-    expect(manager.state.mediaStream?.getVideoTracks()[0].enabled).toBe(true);
-  });
-
   afterEach(() => {
     vi.clearAllMocks();
     vi.resetModules();