@100mslive/hms-video-store 0.6.1-alpha.0 → 0.6.1-alpha.2

package/dist/test/fakeStore/fakeHMSStore.d.ts

@@ -1,13 +1,13 @@
 import { HMSPeer, HMSSpeaker, HMSStore, HMSTrack } from '../../core';
-import { HMSPlaylist, HMSRole } from '../../core/schema';
+import { HMSAudioTrack, HMSPlaylist, HMSRole, HMSScreenVideoTrack, HMSVideoTrack } from '../../core/schema';
 export declare let localPeer: HMSPeer;
 export declare let remotePeerOne: HMSPeer;
 export declare let remotePeerTwo: HMSPeer;
 export declare let peerScreenSharing: HMSPeer;
-export declare let localVideo: HMSTrack;
-export declare let localAudio: HMSTrack;
-export declare let remoteVideo: HMSTrack;
-export declare let screenShare: HMSTrack;
+export declare let localVideo: HMSVideoTrack;
+export declare let localAudio: HMSAudioTrack;
+export declare let remoteVideo: HMSVideoTrack;
+export declare let screenShare: HMSScreenVideoTrack;
 export declare let auxiliaryAudio: HMSTrack;
 export declare let localSpeaker: HMSSpeaker;
 export declare let screenshareAudio: HMSTrack;

package/dist/test/fixtures.d.ts

@@ -1,3 +1,5 @@
-import { HMSPeer, HMSTrack, HMSTrackType } from '../core';
-export declare const makeFakeTrack: (type?: HMSTrackType) => HMSTrack;
+import { HMSAudioTrack, HMSPeer, HMSVideoTrack, HMSTrackType } from '../core';
+declare type HMSObjectType<T> = T extends 'audio' ? HMSAudioTrack : T extends 'video' ? HMSVideoTrack : HMSVideoTrack;
+export declare const makeFakeTrack: <T extends HMSTrackType>(type?: T | undefined) => HMSObjectType<T>;
 export declare const makeFakePeer: () => HMSPeer;
+export {};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.6.1-alpha.0",
+  "version": "0.6.1-alpha.2",
   "license": "MIT",
   "main": "dist/index.cjs.js",
   "module": "dist/index.js",
@@ -41,7 +41,7 @@
   "author": "100ms",
   "sideEffects": false,
   "dependencies": {
-    "@100mslive/hms-video": "0.5.1-alpha.0",
+    "@100mslive/hms-video": "0.5.1-alpha.2",
     "eventemitter2": "^6.4.7",
     "immer": "^9.0.6",
     "reselect": "4.0.0",
@@ -66,5 +66,5 @@
     "url": "https://github.com/100mslive/hms-video-store/issues"
   },
   "homepage": "https://github.com/100mslive/hms-video-store#readme",
-  "gitHead": "1a0835104005a471d7b813a1f1d14268a77379ca"
+  "gitHead": "7450dfa08f3ccf63a603a62c70eafbbeea26ab1e"
 }

package/src/core/IHMSActions.ts

@@ -348,6 +348,24 @@ export interface IHMSActions {
    */
   changeMetadata(metadata: string | any): Promise<void>;
 
+  /**
+   * If you want to update the metadata of the session. If an object is passed, it should be serializable using
+   * JSON.stringify.
+   *
+   * Session metadata is available to every peer in the room and is persisted throughout a session
+   * till the last peer leaves a room
+   *
+   * @alpha - the API is not stable and might have breaking changes later
+   */
+  setSessionMetadata(metadata: any, options?: { localOnly: boolean }): Promise<void>;
+
+  /**
+   * Fetch the current room metadata from the server and populate it in store
+   *
+   * @alpha - the API is not stable and might have breaking changes later
+   */
+  populateSessionMetadata(): Promise<void>;
+
   /**
    * Set the type of logs from the SDK you want to be logged in the browser console.
    *

package/src/core/hmsSDKStore/HMSNotifications.ts

@@ -34,7 +34,7 @@ export class HMSNotifications implements IHMSNotifications {
 
   constructor(store: IHMSStore) {
     this.store = store;
-    this.eventEmitter = new EventEmitter();
+    this.eventEmitter = new EventEmitter({ maxListeners: Object.keys(HMSNotificationTypes).length });
   }
   onNotification = <T extends HMSNotificationTypeParam>(cb: HMSNotificationCallback<T>, type?: T) => {
     const eventCallback = (notification: HMSNotificationInCallback<T>) => {

package/src/core/hmsSDKStore/HMSSDKActions.ts

@@ -12,6 +12,7 @@ import {
   HMSTrack,
   HMSTrackID,
   HMSTrackSource,
+  HMSVideoTrack,
   IHMSPlaylistActions,
 } from '../schema';
 import { IHMSActions } from '../IHMSActions';
@@ -34,6 +35,7 @@ import {
   selectRoomStarted,
   selectRoomState,
   selectTrackByID,
+  selectVideoTrackByID,
   selectTracksMap,
 } from '../selectors';
 import { HMSLogger } from '../../common/ui-logger';
@@ -573,6 +575,22 @@ export class HMSSDKActions implements IHMSActions {
     await this.sdk.changeMetadata(metadata);
   }
 
+  async setSessionMetadata(metadata: any, options = { localOnly: false }) {
+    if (!options.localOnly) {
+      await this.sdk.setSessionMetadata(metadata);
+    }
+    this.setState(draftStore => {
+      draftStore.sessionMetadata = metadata;
+    }, `setSessionMetadata${options.localOnly ? 'LocalOnly' : ''}`);
+  }
+
+  async populateSessionMetadata(): Promise<void> {
+    const metadata = await this.sdk.getSessionMetadata();
+    this.setState(draftStore => {
+      draftStore.sessionMetadata = metadata;
+    }, 'populateSessionMetadata');
+  }
+
   async setRemoteTrackEnabled(trackID: HMSTrackID | HMSTrackID[], enabled: boolean) {
     if (typeof trackID === 'string') {
       const track = this.hmsSDKTracks[trackID];
@@ -1071,13 +1089,14 @@ export class HMSSDKActions implements IHMSActions {
   private updateVideoLayer(trackID: string, action: string) {
     const sdkTrack = this.hmsSDKTracks[trackID];
     if (sdkTrack && sdkTrack instanceof SDKHMSRemoteVideoTrack) {
-      const storeTrack = this.store.getState(selectTrackByID(trackID));
+      const storeTrack = this.store.getState(selectVideoTrackByID(trackID));
       const hasFieldChanged =
         storeTrack?.layer !== sdkTrack.getSimulcastLayer() || storeTrack?.degraded !== sdkTrack.degraded;
       if (hasFieldChanged) {
         this.setState(draft => {
-          draft.tracks[trackID].layer = sdkTrack.getSimulcastLayer();
-          draft.tracks[trackID].degraded = sdkTrack.degraded;
+          const track = draft.tracks[trackID] as HMSVideoTrack;
+          track.layer = sdkTrack.getSimulcastLayer();
+          track.degraded = sdkTrack.degraded;
         }, action);
       }
     }
@@ -1149,7 +1168,7 @@ export class HMSSDKActions implements IHMSActions {
         track.setVolume(value);
         this.setState(draftStore => {
           const track = draftStore.tracks[trackId];
-          if (track) {
+          if (track && track.type === 'audio') {
             track.volume = value;
           }
         }, 'trackVolume');

package/src/core/hmsSDKStore/adapter.ts

@@ -7,6 +7,7 @@ import {
   HMSTrack as SDKHMSTrack,
 } from '@100mslive/hms-video';
 import {
+  HMSAudioTrack,
   HMSDeviceChangeEvent,
   HMSException,
   HMSMessage,
@@ -20,6 +21,7 @@ import {
   HMSRoom,
   HMSTrack,
   HMSTrackFacingMode,
+  HMSVideoTrack,
 } from '../schema';
 
 import * as sdkTypes from './sdkTypes';
@@ -58,27 +60,29 @@ export class SDKToHMS {
       enabled: sdkTrack.enabled,
       displayEnabled: sdkTrack.enabled,
       peerId: sdkTrack.peerId || peerId,
-    };
+    } as HMSTrack;
     this.enrichTrack(track, sdkTrack);
     return track;
   }
 
   static enrichTrack(track: HMSTrack, sdkTrack: SDKHMSTrack) {
     const mediaSettings = sdkTrack.getMediaTrackSettings();
-    if (track.source === 'screen' && track.type === 'video') {
-      // @ts-ignore
-      track.displaySurface = mediaSettings.displaySurface;
-    }
-    if (track.type === 'video') {
-      track.facingMode = mediaSettings.facingMode as HMSTrackFacingMode;
-    }
-    track.height = mediaSettings.height;
-    track.width = mediaSettings.width;
+
     if (sdkTrack instanceof SDKHMSRemoteAudioTrack) {
-      track.volume = sdkTrack.getVolume() || 0;
+      (track as HMSAudioTrack).volume = sdkTrack.getVolume() || 0;
     }
     SDKToHMS.updateDeviceID(track, sdkTrack);
-    SDKToHMS.enrichVideoTrack(track, sdkTrack);
+    if (track.type === 'video') {
+      if (track.source === 'screen') {
+        // @ts-ignore
+        track.displaySurface = mediaSettings.displaySurface;
+      } else if (track.source === 'regular') {
+        (track as HMSVideoTrack).facingMode = mediaSettings.facingMode as HMSTrackFacingMode;
+      }
+      track.height = mediaSettings.height;
+      track.width = mediaSettings.width;
+      SDKToHMS.enrichVideoTrack(track as HMSVideoTrack, sdkTrack);
+    }
     SDKToHMS.enrichPluginsDetails(track, sdkTrack);
   }
 
@@ -90,7 +94,7 @@ export class SDKToHMS {
     }
   }
 
-  static enrichVideoTrack(track: HMSTrack, sdkTrack: SDKHMSTrack) {
+  static enrichVideoTrack(track: HMSVideoTrack, sdkTrack: SDKHMSTrack) {
     if (sdkTrack instanceof SDKHMSRemoteVideoTrack) {
       track.layer = sdkTrack.getSimulcastLayer();
       track.degraded = sdkTrack.degraded;

package/src/core/hmsSDKStore/sdkUtils/storeMergeUtils.ts

@@ -1,4 +1,4 @@
-import { HMSPeer, HMSPeerID, HMSTrack, HMSTrackID } from '../../schema';
+import { HMSPeer, HMSPeerID, HMSScreenVideoTrack, HMSTrack, HMSTrackID, HMSVideoTrack } from '../../schema';
 import { HMSPeerStats, HMSTrackStats } from '../sdkTypes';
 
 /**
@@ -76,8 +76,12 @@ const mergeTrackArrayFields = (oldTrack: HMSTrack, newTrack: Partial<HMSTrack>)
   if (oldTrack.plugins && areArraysEqual(oldTrack.plugins, newTrack.plugins)) {
     newTrack.plugins = oldTrack.plugins;
   }
-  if (oldTrack.layerDefinitions && areArraysEqual(oldTrack.layerDefinitions, newTrack.layerDefinitions)) {
-    newTrack.layerDefinitions = oldTrack.layerDefinitions;
+  if (
+    oldTrack.type === 'video' &&
+    oldTrack.layerDefinitions &&
+    areArraysEqual(oldTrack.layerDefinitions, (newTrack as HMSVideoTrack | HMSScreenVideoTrack).layerDefinitions)
+  ) {
+    (newTrack as HMSVideoTrack | HMSScreenVideoTrack).layerDefinitions = oldTrack.layerDefinitions;
   }
 };
 

package/src/core/schema/notification.ts

@@ -81,6 +81,7 @@ export type HMSNotification =
   | HMSChangeMultiTrackStateRequestNotification
   | HMSLeaveRoomRequestNotification
   | HMSDeviceChangeEventNotification
+  | HMSReconnectionNotification
   | HMSPlaylistItemNotification<any>;
 
 export enum HMSNotificationSeverity {
@@ -133,7 +134,7 @@ export type HMSNotificationMapping<T extends HMSNotificationTypes, C = any> = {
   [HMSNotificationTypes.ROOM_ENDED]: HMSLeaveRoomRequestNotification;
   [HMSNotificationTypes.REMOVED_FROM_ROOM]: HMSLeaveRoomRequestNotification;
   [HMSNotificationTypes.DEVICE_CHANGE_UPDATE]: HMSDeviceChangeEventNotification;
-  [HMSNotificationTypes.PLAYLIST_TRACK_ENDED]: HMSPlaylistItem<C>;
+  [HMSNotificationTypes.PLAYLIST_TRACK_ENDED]: HMSPlaylistItemNotification<C>;
   [HMSNotificationTypes.ERROR]: HMSExceptionNotification;
   [HMSNotificationTypes.CHANGE_TRACK_STATE_REQUEST]: HMSChangeTrackStateRequestNotification;
   [HMSNotificationTypes.CHANGE_MULTI_TRACK_STATE_REQUEST]: HMSChangeMultiTrackStateRequestNotification;

package/src/core/schema/peer.ts

@@ -40,25 +40,45 @@ export interface HMSPeer {
  * deviceID - this is the ID of the source device for the track. This can be a dummy ID when track is on mute.
  * degraded - tells whether the track has been degraded(receiving lower video quality/no video) due to bad network locally
  */
-export interface HMSTrack {
+
+interface BaseTrack {
   id: HMSTrackID;
   source?: HMSTrackSource;
   type: HMSTrackType;
   enabled: boolean;
-  height?: number;
-  width?: number;
+  displayEnabled?: boolean;
   peerId?: string;
   deviceID?: string;
   plugins?: string[];
-  displayEnabled?: boolean;
+}
+
+export interface HMSAudioTrack extends BaseTrack {
+  source: 'regular' | 'audioplaylist' | string;
+  type: 'audio';
   volume?: number;
+}
+export interface HMSScreenAudioTrack extends HMSAudioTrack {
+  source: 'screen';
+  type: 'audio';
+}
+export interface HMSVideoTrack extends BaseTrack {
+  source: 'regular' | 'videoplaylist' | string;
+  type: 'video';
+  facingMode?: HMSTrackFacingMode;
   layer?: HMSSimulcastLayer;
   layerDefinitions?: SimulcastLayerDefinition[];
+  height?: number;
+  width?: number;
   degraded?: boolean;
+}
+
+export interface HMSScreenVideoTrack extends Omit<HMSVideoTrack, 'facingMode'> {
+  source: 'screen';
   displaySurface?: HMSTrackDisplaySurface;
-  facingMode?: HMSTrackFacingMode;
 }
 
+export type HMSTrack = HMSVideoTrack | HMSAudioTrack | HMSScreenVideoTrack | HMSScreenAudioTrack;
+
 /**
  * HMS Speaker stores the details of peers speaking at any point of time along with
  * their audio levels. This can be used to current speakers or highlight videotiles.

package/src/core/schema/schema.ts

@@ -28,6 +28,7 @@ export interface HMSStore {
   roles: Record<string, HMSRole>;
   appData?: Record<string, any>;
   roleChangeRequests: HMSRoleChangeStoreRequest[];
+  sessionMetadata?: any;
   errors: HMSException[]; // for the convenience of debugging and seeing any error in devtools
 }
 

package/src/core/selectors/selectorUtils.ts

@@ -1,4 +1,4 @@
-import { HMSPeer, HMSStore, HMSTrack, HMSTrackID } from '../schema';
+import { HMSPeer, HMSStore, HMSTrack, HMSTrackID, HMSVideoTrack } from '../schema';
 
 type trackCheck = (track: HMSTrack | undefined) => boolean | undefined;
 
@@ -41,8 +41,11 @@ export function isVideoPlaylist(track: HMSTrack | undefined) {
   return track && track.source === 'videoplaylist';
 }
 
-export function isDegraded(track: HMSTrack | undefined) {
-  return Boolean(track?.degraded);
+export function isDegraded(track: HMSVideoTrack) {
+  if (track) {
+    return Boolean(track?.degraded);
+  }
+  return false;
 }
 
 export function isTrackEnabled(store: HMSStore, trackID?: string) {

package/src/core/selectors/selectors.ts

@@ -1,4 +1,4 @@
-import { HMSMessage, HMSPeer, HMSPeerID, HMSRoom, HMSRoomState, HMSStore } from '../schema';
+import { HMSMessage, HMSPeer, HMSPeerID, HMSRoom, HMSRoomState, HMSStore, HMSVideoTrack } from '../schema';
 import { createSelector } from 'reselect';
 // noinspection ES6PreferShortImport
 import { HMSRole } from '../hmsSDKStore/sdkTypes';
@@ -317,7 +317,9 @@ export const selectPeerSharingAudioPlaylist = createSelector(selectPeersMap, sel
 /**
  * Select an array of tracks that have been degraded(receiving lower video quality/no video) due to bad network locally.
  */
-export const selectDegradedTracks = createSelector(selectTracks, tracks => tracks.filter(isDegraded));
+export const selectDegradedTracks = createSelector(selectTracks, tracks =>
+  (tracks as HMSVideoTrack[]).filter(isDegraded),
+);
 
 /**
  * Select the number of messages(sent and received).
@@ -392,3 +394,5 @@ export const selectRTMPState = createSelector(selectRoom, room => room.rtmp);
 export const selectHLSState = createSelector(selectRoom, room => room.hls);
 export const selectSessionId = createSelector(selectRoom, room => room.sessionId);
 export const selectRoomStartTime = createSelector(selectRoom, room => room.startedAt);
+/** @alpha */
+export const selectSessionMetadata = (store: HMSStore) => store.sessionMetadata;

package/src/core/selectors/selectorsByID.ts

@@ -7,7 +7,16 @@ import {
   selectPeersMap,
   selectTracksMap,
 } from './selectors';
-import { HMSPeerID, HMSRoleName, HMSStore, HMSTrack, HMSTrackID } from '../schema';
+import {
+  HMSPeerID,
+  HMSRoleName,
+  HMSStore,
+  HMSTrack,
+  HMSTrackID,
+  HMSAudioTrack,
+  HMSVideoTrack,
+  HMSScreenVideoTrack,
+} from '../schema';
 import {
   getPeerTracksByCondition,
   isAudio,
@@ -32,6 +41,49 @@ const selectTrackByIDBare = createSelector([selectTracksMap, selectTrackID], (st
   trackID ? storeTracks[trackID] : null,
 );
 
+const selectVideoTrackByIDBare = createSelector([selectTracksMap, selectTrackID], (storeTracks, trackID) => {
+  if (!trackID) {
+    return null;
+  }
+  const track = storeTracks[trackID] as HMSVideoTrack;
+  if (track.type === 'video') {
+    return track;
+  }
+  return null;
+});
+
+const selectAudioTrackByIDBare = createSelector([selectTracksMap, selectTrackID], (storeTracks, trackID) => {
+  if (!trackID) {
+    return null;
+  }
+  const track = storeTracks[trackID] as HMSAudioTrack;
+  if (track.type === 'audio') {
+    return track;
+  }
+  return null;
+});
+
+const selectScreenAudioTrackByIDBare = createSelector([selectTracksMap, selectTrackID], (storeTracks, trackID) => {
+  if (!trackID) {
+    return null;
+  }
+  const track = storeTracks[trackID] as HMSAudioTrack;
+  if (track.type === 'audio' && track.source === 'screen') {
+    return track;
+  }
+  return null;
+});
+const selectScreenVideoTrackByIDBare = createSelector([selectTracksMap, selectTrackID], (storeTracks, trackID) => {
+  if (!trackID) {
+    return null;
+  }
+  const track = storeTracks[trackID] as HMSScreenVideoTrack;
+  if (track.type === 'video' && track.source === 'screen') {
+    return track;
+  }
+  return null;
+});
+
 /**
  * Select the {@link HMSPeer} object given a peer ID.
  */
@@ -81,13 +133,33 @@ export const selectPeerNameByID = byIDCurry(createSelector(selectPeerByIDBare, p
  */
 export const selectTrackByID = byIDCurry(selectTrackByIDBare);
 
+/**
+ * Select the {@link HMSVideoTrack} object given a track ID.
+ */
+export const selectVideoTrackByID = byIDCurry(selectVideoTrackByIDBare);
+
+/**
+ * Select the {@link HMSAudioTrack} object given a track ID.
+ */
+export const selectAudioTrackByID = byIDCurry(selectAudioTrackByIDBare);
+
+/**
+ * Select the {@link HMSScreenAudioTrack} object given a track ID.
+ */
+export const selectScreenAudioTrackByID = byIDCurry(selectScreenAudioTrackByIDBare);
+
+/**
+ * Select the {@link HMSScreenVideoTrack} object given a track ID.
+ */
+export const selectScreenVideoTrackByID = byIDCurry(selectScreenVideoTrackByIDBare);
+
 /**
  * Select the primary video track of a peer given a peer ID.
  */
-export const selectVideoTrackByPeerID = byIDCurry((store: HMSStore, peerID?: HMSPeerID): HMSTrack | undefined => {
+export const selectVideoTrackByPeerID = byIDCurry((store: HMSStore, peerID?: HMSPeerID): HMSVideoTrack | undefined => {
   const peer = selectPeerByIDBare(store, peerID);
   if (peer && peer.videoTrack && peer.videoTrack !== '') {
-    return store.tracks[peer.videoTrack];
+    return store.tracks[peer.videoTrack] as HMSVideoTrack;
   }
   return undefined;
 });
@@ -95,10 +167,10 @@ export const selectVideoTrackByPeerID = byIDCurry((store: HMSStore, peerID?: HMS
 /**
  * Select the primary audio track of a peer given a peer ID.
  */
-export const selectAudioTrackByPeerID = byIDCurry((store: HMSStore, peerID?: HMSPeerID): HMSTrack | undefined => {
+export const selectAudioTrackByPeerID = byIDCurry((store: HMSStore, peerID?: HMSPeerID): HMSAudioTrack | undefined => {
   const peer = selectPeerByIDBare(store, peerID);
   if (peer && peer.audioTrack && peer.audioTrack !== '') {
-    return store.tracks[peer.audioTrack];
+    return store.tracks[peer.audioTrack] as HMSAudioTrack;
   }
   return undefined;
 });
@@ -235,7 +307,7 @@ export const selectIsPeerVideoEnabled = byIDCurry((store: HMSStore, peerID?: str
  */
 export const selectIsAudioLocallyMuted = byIDCurry((store: HMSStore, trackID?: string) => {
   if (trackID && store.tracks[trackID]) {
-    return store.tracks[trackID].volume === 0;
+    return (store.tracks[trackID] as HMSAudioTrack).volume === 0;
   }
   return undefined;
 });

package/src/test/fakeStore/fakeHMSStore.ts

@@ -10,7 +10,14 @@ import {
   HMSTrackType,
 } from '../../core';
 import { HMSSimulcastLayer } from '../../core/hmsSDKStore/sdkTypes';
-import { HMSPlaylist, HMSPlaylistType, HMSRole } from '../../core/schema';
+import {
+  HMSAudioTrack,
+  HMSPlaylist,
+  HMSPlaylistType,
+  HMSRole,
+  HMSScreenVideoTrack,
+  HMSVideoTrack,
+} from '../../core/schema';
 
 function makeTrack(
   id: HMSTrackID,
@@ -35,10 +42,10 @@ export let localPeer: HMSPeer;
 export let remotePeerOne: HMSPeer;
 export let remotePeerTwo: HMSPeer;
 export let peerScreenSharing: HMSPeer;
-export let localVideo: HMSTrack;
-export let localAudio: HMSTrack;
-export let remoteVideo: HMSTrack;
-export let screenShare: HMSTrack;
+export let localVideo: HMSVideoTrack;
+export let localAudio: HMSAudioTrack;
+export let remoteVideo: HMSVideoTrack;
+export let screenShare: HMSScreenVideoTrack;
 export let auxiliaryAudio: HMSTrack;
 export let localSpeaker: HMSSpeaker;
 export let screenshareAudio: HMSTrack;
@@ -282,10 +289,10 @@ export const makeFakeStore = (): HMSStore => {
   remotePeerOne = fakeStore.peers['2'];
   remotePeerTwo = fakeStore.peers['3'];
   peerScreenSharing = fakeStore.peers['2'];
-  localVideo = fakeStore.tracks['101'];
-  localAudio = fakeStore.tracks['102'];
-  remoteVideo = fakeStore.tracks['103'];
-  screenShare = fakeStore.tracks['105'];
+  localVideo = fakeStore.tracks['101'] as HMSVideoTrack;
+  localAudio = fakeStore.tracks['102'] as HMSAudioTrack;
+  remoteVideo = fakeStore.tracks['103'] as HMSVideoTrack;
+  screenShare = fakeStore.tracks['105'] as HMSScreenVideoTrack;
   auxiliaryAudio = fakeStore.tracks['106'];
   screenshareAudio = fakeStore.tracks['107'];
   localSpeaker = fakeStore.speakers[localPeer.audioTrack!];

package/src/test/fixtures.ts

@@ -1,13 +1,13 @@
-import { HMSPeer, HMSTrack, HMSTrackType } from '../core';
+import { HMSAudioTrack, HMSPeer, HMSVideoTrack, HMSTrackType } from '../core';
 
 let counter = 100;
-
-export const makeFakeTrack = (type?: HMSTrackType): HMSTrack => {
+type HMSObjectType<T> = T extends 'audio' ? HMSAudioTrack : T extends 'video' ? HMSVideoTrack : HMSVideoTrack;
+export const makeFakeTrack = <T extends HMSTrackType>(type?: T): HMSObjectType<T> => {
   return {
     enabled: false,
     id: String(counter++),
     type: type || 'video',
-  };
+  } as HMSObjectType<T>;
 };
 
 export const makeFakePeer = (): HMSPeer => {

package/src/test/unit/storeMergeUtils.test.ts

@@ -1,5 +1,5 @@
 import { HMSTrack as SDKTrack } from '@100mslive/hms-video';
-import { HMSPeer, HMSPeerID, HMSTrack, HMSTrackID } from '../../core';
+import { HMSPeer, HMSPeerID, HMSTrack, HMSTrackID, HMSVideoTrack } from '../../core';
 import { mergeNewPeersInDraft, mergeNewTracksInDraft } from '../../core/hmsSDKStore/sdkUtils/storeMergeUtils';
 import { makeFakePeer, makeFakeTrack } from '../fixtures';
 
@@ -8,14 +8,14 @@ type peerMap = Record<HMSTrackID, HMSPeer>;
 let newTracks: Record<HMSTrackID, Partial<HMSTrack>>;
 
 describe('tracks merge is happening properly', () => {
-  let fakeTrack: HMSTrack;
+  let fakeTrack: HMSVideoTrack;
   let draftTracksCopy: Record<HMSTrackID, Partial<HMSTrack>>;
   let draftTracks: Record<HMSTrackID, Partial<HMSTrack>>;
   beforeEach(() => {
     draftTracks = {};
     newTracks = {};
     draftTracksCopy = draftTracks;
-    fakeTrack = makeFakeTrack();
+    fakeTrack = makeFakeTrack('video');
   });
 
   const expectNoReferenceChange = () => {