@snapcall/stream-ui 1.2.0 → 1.3.0

package/dist/types.d.ts

@@ -33,13 +33,24 @@ interface JoinOptions {
     email?: string;
     displayName?: string;
 }
+interface PeerState {
+    peerId: string;
+    displayName: string | undefined;
+    deviceState: DevicesState;
+}
+interface StreamerState extends PeerState {
+    roomId: string;
+    callId: number | undefined;
+    peers: Array<PeerState>;
+}
 interface ProducerData {
     producerId: string;
     deviceType: DeviceType;
     paused: boolean;
 }
 interface PeerInfo {
-    id: PeerId;
+    id?: PeerId;
+    peerId: PeerId;
     displayName: string;
     producersData: Array<ProducerData>;
 }
@@ -97,6 +108,15 @@ declare class AudioLevel {
     release(): void;
     static isAPIAvailable(): boolean;
 }
+declare class AudioRenderer {
+    constructor({ consumerId }: {
+        consumerId: string;
+    });
+    destroy(): void;
+    setSource(srcObject: MediaStream): void;
+    setSink(sinkId: string): Promise<void>;
+    play(): Promise<void>;
+}
 interface DeviceRequest {
     requestId: string;
     deviceType: DeviceType;
@@ -113,7 +133,105 @@ interface CustomMessage {
     }>;
     totalChunks: number;
 }
-declare class StreamerClient implements AudioLevelListener {
+declare global {
+    export namespace SnapCall {
+        type SnapcallEvent<T> = CustomEvent<T>;
+        type PeersInfoEvent = SnapcallEvent<{
+            peerId: string;
+            peers: {
+                peerId: string;
+                displayName: string;
+            }[];
+        }>;
+        type PeerInfoEvent = SnapcallEvent<{
+            peerId: string;
+            displayName: string;
+        }>;
+        type RequestDeviceEvent = SnapcallEvent<{
+            peerId: string;
+            deviceType: DeviceType;
+        }>;
+        type RequestDeviceResultEvent = SnapcallEvent<{
+            result: {
+                peerId: string;
+                result: boolean;
+            };
+        }>;
+        type BaseEvent = SnapcallEvent<{}>;
+        type StreamEvent = SnapcallEvent<{
+            peerId: string;
+        }>;
+        type RequestResultEvent = SnapcallEvent<{
+            success: Boolean;
+        }>;
+        type ConsumerEvent = SnapcallEvent<{
+            peerId: string;
+            consumerId: string;
+            deviceType: DeviceType;
+            paused: boolean;
+        }>;
+        type AudioDeviceEvent = SnapcallEvent<MediaDeviceInfo>;
+        type ProducerEvent = SnapcallEvent<{
+            peerId: string;
+            producerId: string;
+            deviceType: DeviceType;
+        }>;
+        type WebcamUpdateEvent = SnapcallEvent<{
+            numberOfAvailableWebcams: number;
+        }>;
+        type CriticalErrorEvent = SnapcallEvent<{
+            code: string;
+        }>;
+        type CustomMessageEvent = SnapcallEvent<{
+            peerId: string;
+            event: {
+                type: string;
+            } & Record<string, any>;
+        }>;
+    }
+}
+interface StreamerEventMap {
+    leaveRoom: SnapCall.BaseEvent;
+    terminateRoom: SnapCall.BaseEvent;
+    invalidRoom: SnapCall.BaseEvent;
+    localVideoUnavailable: SnapCall.BaseEvent;
+    localVideoAvailable: SnapCall.BaseEvent;
+    microphoneEnabled: SnapCall.BaseEvent;
+    agentIdentity: SnapCall.RequestResultEvent;
+    peerClosed: SnapCall.StreamEvent;
+    newPeer: SnapCall.PeerInfoEvent;
+    selfDisplayName: SnapCall.PeerInfoEvent;
+    webcamsUpdate: SnapCall.WebcamUpdateEvent;
+    customMessage: SnapCall.CustomMessageEvent;
+    newConsumer: SnapCall.ConsumerEvent;
+    consumerClose: SnapCall.ConsumerEvent;
+    producerPaused: SnapCall.ProducerEvent;
+    producerResumed: SnapCall.ProducerEvent;
+    microphoneMute: SnapCall.BaseEvent;
+    microphoneUnmute: SnapCall.BaseEvent;
+    defaultAudioDeviceChange: SnapCall.AudioDeviceEvent;
+    screenshareEnabled: SnapCall.BaseEvent;
+    screenshareDisabled: SnapCall.BaseEvent;
+    localVideoRotate: SnapCall.BaseEvent;
+    enterRoom: SnapCall.PeersInfoEvent;
+    displayName: SnapCall.PeerInfoEvent;
+    peerStartSpeak: SnapCall.StreamEvent;
+    peerStopSpeak: SnapCall.StreamEvent;
+    criticalError: SnapCall.CriticalErrorEvent;
+    requestDevice: SnapCall.RequestDeviceEvent;
+    requestDeviceResult: SnapCall.RequestDeviceResultEvent;
+}
+interface StreamerEventTarget extends EventTarget {
+    addEventListener<T extends keyof StreamerEventMap>(type: T, listener: (event: StreamerEventMap[T]) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+    removeEventListener<T extends keyof StreamerEventMap>(type: T, listener: (event: StreamerEventMap[T]) => void): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null): void;
+}
+declare const StreamerEventTargetType: {
+    new (): StreamerEventTarget;
+    prototype: StreamerEventTarget;
+};
+declare class StreamerClient extends StreamerEventTargetType implements AudioLevelListener {
     iceServers: Array<RTCIceServer>;
     peers: Map<PeerId, PeerInfo>;
     consumers: Map<ConsumerId, ConsumerData>;
@@ -149,7 +267,9 @@ declare class StreamerClient implements AudioLevelListener {
     audioInputDefaultDevice?: MediaDeviceInfo;
     devicesList: Array<MediaDeviceInfo>;
     customMessages: Map<string, CustomMessage>;
+    audioRenderers: Record<string, AudioRenderer>;
     constructor();
+    getState(): StreamerState;
     onStartSpeak(): void;
     onStopSpeak(): void;
     generateToken(bid: string): Promise<string>;
@@ -164,13 +284,22 @@ declare class StreamerClient implements AudioLevelListener {
     toggleMute(): Promise<{
         muted: boolean;
     }>;
+    release(): void;
     endCall(): void;
     terminateRoom(): void;
     updateWebcams(): Promise<void>;
     isVideoZoomAvailable(): boolean;
     handleGetUserMediaError(deviceType: DeviceType, getUserMediaPromise: Promise<MediaStream>): Promise<MediaStream>;
     restartIce(transport: Transport): Promise<void>;
-    enableVideo(): Promise<void>;
+    switchWebcam({ device, resolution, rotate, }: {
+        device?: MediaDeviceInfo;
+        resolution?: VideoResolution;
+        rotate?: boolean;
+    }): Promise<void>;
+    enableVideo(config?: {
+        device?: MediaDeviceInfo;
+        resolution?: VideoResolution;
+    }): Promise<void>;
     rotateVideo(): Promise<void>;
     zoomVideo(): Promise<void>;
     unzoomVideo(): Promise<void>;
@@ -180,10 +309,6 @@ declare class StreamerClient implements AudioLevelListener {
     onConsumerClose({ consumerId }: {
         consumerId: ConsumerId;
     }): void;
-    requestVoice({ consumerId, element }: {
-        consumerId: string;
-        element: HTMLAudioElement;
-    }): void;
     requestVideo({ consumerId, element }: {
         consumerId: string;
         element: HTMLVideoElement;
@@ -211,6 +336,21 @@ declare class StreamerClient implements AudioLevelListener {
     getDevicesState(): DevicesState;
     sendCustomMessageToAll(event: any): Promise<void>;
     sendCustomMessage(peerId: string, event: any): Promise<void>;
+    listAudioDevices(): Promise<MediaDeviceInfo[]>;
+    listVideoDevices(): Promise<MediaDeviceInfo[]>;
+    isListDevicesSupported(): boolean;
+    getCurrentWebcam(): {
+        device: MediaDeviceInfo | null;
+        resolution: VideoResolution;
+    };
+    getWebcamsList(): Map<string, MediaDeviceInfo>;
+    setWebcamResolution(resolution: VideoResolution): Promise<void>;
+    createAudioRenderer(consumerId: string): AudioRenderer;
+    deleteAudioRenderer(consumerId: string): void;
+    playAudioRenderer(consumerId: string): Promise<void>;
+    setAudioSink(sinkId: string): Promise<void>;
+    dispatchEvent(event: Event): boolean;
+    getShareLinkData(url: string): Promise<any>;
 }
 declare const streamerClient: StreamerClient;
 interface NotificationOptions {
@@ -220,6 +360,7 @@ interface NotificationOptions {
         icon?: JSX.Element | string;
         text: string;
         action: () => void;
+        style?: CSSProperties;
     };
     status?: {
         icon?: JSX.Element | string;
@@ -250,6 +391,9 @@ interface StreamUIMethods {
     leaveRoom: typeof streamerClient.endCall;
     terminateRoom: typeof streamerClient.terminateRoom;
     generateToken: typeof streamerClient.generateToken;
+    addEventListener: typeof streamerClient.addEventListener;
+    dispatchEvent: typeof streamerClient.dispatchEvent;
+    getState: typeof streamerClient.getState;
 }
 interface ControlSettings {
     available?: boolean;
@@ -290,31 +434,11 @@ declare global {
         setMicrophoneActive?: (active: boolean) => void;
         setCameraActive?: (active: boolean) => void;
     }
+    interface HTMLAudioElement {
+        setSinkId?: (sinkId: string) => Promise<undefined>;
+    }
     interface WindowEventMap {
         streamUISetExtraSettingsOptions: CustomEvent;
-        enterRoom: CustomEvent;
-        newPeer: CustomEvent;
-        peerClosed: CustomEvent;
-        newConsumer: CustomEvent;
-        consumerClose: CustomEvent;
-        screenshareEnabled: CustomEvent;
-        screenshareDisabled: CustomEvent;
-        producerPaused: CustomEvent;
-        producerResumed: CustomEvent;
-        displayName: CustomEvent;
-        selfDisplayName: CustomEvent;
-        requestDevice: CustomEvent;
-        requestDeviceResult: CustomEvent;
-        webcamsUpdate: CustomEvent;
-        microphoneEnabled: CustomEvent;
-        microphoneMute: CustomEvent;
-        microphoneUnmute: CustomEvent;
-        defaultAudioDeviceChange: CustomEvent;
-        peerStartSpeak: CustomEvent;
-        peerStopSpeak: CustomEvent;
-        agentIdentity: CustomEvent;
-        criticalError: CustomEvent;
-        customMessage: CustomEvent;
     }
 }
 declare global {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snapcall/stream-ui",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "",
   "source": "src/index.tsx",
   "main": "dist/stream-ui.js",
@@ -49,8 +49,8 @@
     "styled-components": "^5.3.3"
   },
   "devDependencies": {
-    "@parcel/packager-ts": "^2.6.0",
-    "@parcel/transformer-typescript-types": "^2.6.0",
+    "@parcel/packager-ts": "^2.6.2",
+    "@parcel/transformer-typescript-types": "^2.6.2",
     "@types/protoo-client": "^4.0.1",
     "@types/qrcode": "^1.4.2",
     "@types/react": "^17.0.43",
@@ -60,14 +60,14 @@
     "eslint": "^8.16.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-config-react-app": "^7.0.1",
-    "parcel": "^2.6.0",
+    "parcel": "^2.6.2",
     "prettier": "2.7.1",
     "process": "^0.11.10",
     "typescript": "^4.7.2"
   },
   "dependencies": {
     "@sentry/browser": "^7.0.0",
-    "@types/youtube": "^0.0.46",
+    "@types/youtube": "^0.0.47",
     "bowser": "^2.11.0",
     "inobounce": "^0.2.1",
     "mediasoup-client": "^3.6.52",