@whereby.com/browser-sdk 2.0.0-alpha2 → 2.0.0-alpha21

package/dist/types.d.ts

@@ -1,4 +1,6 @@
 import React from 'react';
+import RtcManager from '@whereby/jslib-media/src/webrtc/RtcManager';
+import { ChatMessage as ChatMessage$1 } from '@whereby/jslib-media/src/utils/ServerSocket';
 
 interface WherebyEmbedAttributes {
     audio: string;
@@ -31,11 +33,97 @@ declare global {
     }
 }
 
-interface VideoElProps {
+interface VideoViewSelfProps {
     stream: MediaStream;
+    muted?: boolean;
     style?: React.CSSProperties;
+    onResize?: ({ width, height, stream }: {
+        width: number;
+        height: number;
+        stream: MediaStream;
+    }) => void;
 }
-declare const _default: ({ stream, style }: VideoElProps) => JSX.Element;
+type VideoViewProps = VideoViewSelfProps & React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>;
+declare const _default: ({ muted, stream, onResize, ...rest }: VideoViewProps) => JSX.Element;
+
+type CameraEnabledEvent = {
+    enabled: boolean;
+};
+type MicrophoneEnabledEvent = {
+    enabled: boolean;
+};
+type DeviceListUpdatedEvent = {
+    cameraDevices: MediaDeviceInfo[];
+    microphoneDevices: MediaDeviceInfo[];
+    speakerDevices: MediaDeviceInfo[];
+};
+type DeviceListUpdateErrorEvent = {
+    error: unknown;
+};
+type StreamUpdatedEvent = {
+    stream: MediaStream;
+};
+interface LocalMediaEventsMap {
+    camera_enabled: CustomEvent<CameraEnabledEvent>;
+    device_list_updated: CustomEvent<DeviceListUpdatedEvent>;
+    device_list_update_error: CustomEvent<DeviceListUpdateErrorEvent>;
+    microphone_enabled: CustomEvent<MicrophoneEnabledEvent>;
+    stream_updated: CustomEvent<StreamUpdatedEvent>;
+}
+interface LocalMediaEventTarget extends EventTarget {
+    addEventListener<K extends keyof LocalMediaEventsMap>(type: K, listener: (ev: LocalMediaEventsMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+}
+declare const TypedLocalMediaEventTarget: new () => LocalMediaEventTarget;
+declare class LocalMedia extends TypedLocalMediaEventTarget {
+    private _constraints;
+    _rtcManagers: RtcManager[];
+    stream: MediaStream;
+    screenshareStream?: MediaStream;
+    constructor(constraints: MediaStreamConstraints);
+    addRtcManager(rtcManager: RtcManager): void;
+    removeRtcManager(rtcManager: RtcManager): void;
+    getCameraDeviceId(): string | undefined;
+    getMicrophoneDeviceId(): string | undefined;
+    isCameraEnabled(): boolean;
+    isMicrophoneEnabled(): boolean;
+    toggleCameraEnabled(enabled?: boolean): void;
+    toggleMichrophoneEnabled(enabled?: boolean): void;
+    startScreenshare(): Promise<MediaStream>;
+    stopScreenshare(): void;
+    setCameraDevice(deviceId: string): Promise<void>;
+    setMicrophoneDevice(deviceId: string): Promise<void>;
+    private _updateDeviceList;
+    start(): Promise<MediaStream>;
+    stop(): void;
+}
+
+interface LocalMediaState {
+    currentCameraDeviceId?: string;
+    currentMicrophoneDeviceId?: string;
+    cameraDeviceError: unknown;
+    cameraDevices: MediaDeviceInfo[];
+    isSettingCameraDevice: boolean;
+    isSettingMicrophoneDevice: boolean;
+    isStarting: boolean;
+    localStream?: MediaStream;
+    microphoneDeviceError: unknown;
+    microphoneDevices: MediaDeviceInfo[];
+    speakerDevices: MediaDeviceInfo[];
+    startError: unknown;
+}
+interface LocalMediaActions {
+    setCameraDevice: InstanceType<typeof LocalMedia>["setCameraDevice"];
+    setMicrophoneDevice: InstanceType<typeof LocalMedia>["setMicrophoneDevice"];
+    toggleCameraEnabled: InstanceType<typeof LocalMedia>["toggleCameraEnabled"];
+    toggleMicrophoneEnabled: InstanceType<typeof LocalMedia>["toggleMichrophoneEnabled"];
+}
+type LocalMediaRef = {
+    state: LocalMediaState;
+    actions: LocalMediaActions;
+    _ref: LocalMedia;
+};
+declare function useLocalMedia(constraints?: MediaStreamConstraints): LocalMediaRef;
 
 interface RoomParticipantData {
     displayName: string;
@@ -66,39 +154,229 @@ declare class RemoteParticipant extends RoomParticipant {
     readonly newJoiner: boolean;
     readonly streams: Stream[];
     constructor({ displayName, id, newJoiner, streams, isAudioEnabled, isVideoEnabled, }: RoomParticipantData & RemoteParticipantData);
+    addStream(streamId: string, state: StreamState): void;
+    removeStream(streamId: string): void;
     updateStreamState(streamId: string, state: StreamState): void;
 }
 declare class LocalParticipant extends RoomParticipant {
     readonly isLocalParticipant = true;
     constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled }: RoomParticipantData);
+}
+interface WaitingParticipant {
+    id: string;
+    displayName: string | null;
+}
+declare class Screenshare {
+    readonly participantId: string;
+    readonly id: string;
+    readonly hasAudioTrack: boolean;
+    readonly stream?: MediaStream;
+    readonly isLocal: boolean;
+    constructor({ participantId, id, hasAudioTrack, stream, isLocal }: Screenshare);
 }
 
 type Logger = Pick<Console, "debug" | "error" | "log" | "warn">;
 interface RoomConnectionOptions {
     displayName?: string;
-    localStream?: MediaStream;
     localMediaConstraints?: MediaStreamConstraints;
     roomKey?: string;
     logger?: Logger;
+    localMedia?: LocalMedia;
+}
+type ChatMessage = Pick<ChatMessage$1, "senderId" | "timestamp" | "text">;
+type RoomConnectionStatus = "" | "connecting" | "connected" | "room_locked" | "knocking" | "disconnecting" | "disconnected" | "accepted" | "rejected";
+type CloudRecordingState = {
+    status: "" | "recording";
+    startedAt: number | null;
+};
+type StreamingState = {
+    status: "" | "streaming";
+    startedAt: number | null;
+};
+type RoomJoinedEvent = {
+    localParticipant: LocalParticipant;
+    remoteParticipants: RemoteParticipant[];
+    waitingParticipants: WaitingParticipant[];
+};
+type RoomConnectionStatusChangedEvent = {
+    roomConnectionStatus: RoomConnectionStatus;
+};
+type ParticipantJoinedEvent = {
+    remoteParticipant: RemoteParticipant;
+};
+type ParticipantLeftEvent = {
+    participantId: string;
+};
+type ParticipantStreamAddedEvent = {
+    participantId: string;
+    stream: MediaStream;
+};
+type ParticipantAudioEnabledEvent = {
+    participantId: string;
+    isAudioEnabled: boolean;
+};
+type ParticipantVideoEnabledEvent = {
+    participantId: string;
+    isVideoEnabled: boolean;
+};
+type ParticipantMetadataChangedEvent = {
+    participantId: string;
+    displayName: string;
+};
+type ScreenshareStartedEvent = {
+    participantId: string;
+    id: string;
+    hasAudioTrack: boolean;
+    stream: MediaStream;
+    isLocal: boolean;
+};
+type ScreenshareStoppedEvent = {
+    participantId: string;
+    id: string;
+};
+type WaitingParticipantJoinedEvent = {
+    participantId: string;
+    displayName: string | null;
+};
+type WaitingParticipantLeftEvent = {
+    participantId: string;
+};
+interface RoomEventsMap {
+    chat_message: (e: CustomEvent<ChatMessage>) => void;
+    cloud_recording_started: (e: CustomEvent<CloudRecordingState>) => void;
+    cloud_recording_stopped: (e: CustomEvent<CloudRecordingState>) => void;
+    participant_audio_enabled: (e: CustomEvent<ParticipantAudioEnabledEvent>) => void;
+    participant_joined: (e: CustomEvent<ParticipantJoinedEvent>) => void;
+    participant_left: (e: CustomEvent<ParticipantLeftEvent>) => void;
+    participant_metadata_changed: (e: CustomEvent<ParticipantMetadataChangedEvent>) => void;
+    participant_stream_added: (e: CustomEvent<ParticipantStreamAddedEvent>) => void;
+    participant_video_enabled: (e: CustomEvent<ParticipantVideoEnabledEvent>) => void;
+    room_connection_status_changed: (e: CustomEvent<RoomConnectionStatusChangedEvent>) => void;
+    room_joined: (e: CustomEvent<RoomJoinedEvent>) => void;
+    screenshare_started: (e: CustomEvent<ScreenshareStartedEvent>) => void;
+    screenshare_stopped: (e: CustomEvent<ScreenshareStoppedEvent>) => void;
+    streaming_started: (e: CustomEvent<StreamingState>) => void;
+    streaming_stopped: (e: CustomEvent<StreamingState>) => void;
+    waiting_participant_joined: (e: CustomEvent<WaitingParticipantJoinedEvent>) => void;
+    waiting_participant_left: (e: CustomEvent<WaitingParticipantLeftEvent>) => void;
+}
+interface RoomEventTarget extends EventTarget {
+    addEventListener<K extends keyof RoomEventsMap>(type: K, listener: RoomEventsMap[K], options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+    removeEventListener<K extends keyof RoomEventsMap>(type: K, listener: RoomEventsMap[K], options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+}
+declare const TypedEventTarget: new () => RoomEventTarget;
+declare class RoomConnection extends TypedEventTarget {
+    localMedia: LocalMedia;
+    localParticipant: LocalParticipant | null;
+    roomUrl: URL;
+    remoteParticipants: RemoteParticipant[];
+    screenshares: Screenshare[];
+    readonly localMediaConstraints?: MediaStreamConstraints;
+    readonly roomName: string;
+    private organizationId;
+    private credentialsService;
+    private apiClient;
+    private organizationService;
+    private organizationServiceCache;
+    private organizationApiClient;
+    private roomService;
+    private _deviceCredentials;
+    private signalSocket;
+    private signalSocketManager;
+    private rtcManagerDispatcher?;
+    private rtcManager?;
+    private roomConnectionStatus;
+    private selfId;
+    private logger;
+    private _ownsLocalMedia;
+    private displayName?;
+    private _roomKey;
+    constructor(roomUrl: string, { displayName, localMedia, localMediaConstraints, logger, roomKey }: RoomConnectionOptions);
+    get roomKey(): string | null;
+    private _handleNewChatMessage;
+    private _handleCloudRecordingStarted;
+    private _handleStreamingStarted;
+    private _handleNewClient;
+    private _handleClientLeft;
+    private _handleClientAudioEnabled;
+    private _handleClientVideoEnabled;
+    private _handleClientMetadataReceived;
+    private _handleKnockHandled;
+    private _handleKnockerLeft;
+    private _handleRoomJoined;
+    private _handleRoomKnocked;
+    private _handleReconnect;
+    private _handleDisconnect;
+    private _handleCloudRecordingStopped;
+    private _handleStreamingStopped;
+    private _handleScreenshareStarted;
+    private _handleScreenshareStopped;
+    private _handleRtcEvent;
+    private _handleRtcManagerCreated;
+    private _handleRtcManagerDestroyed;
+    private _handleAcceptStreams;
+    private _handleStreamAdded;
+    private _joinRoom;
+    join(): Promise<void>;
+    knock(): void;
+    leave(): void;
+    sendChatMessage(text: string): void;
+    setDisplayName(displayName: string): void;
+    acceptWaitingParticipant(participantId: string): void;
+    rejectWaitingParticipant(participantId: string): void;
+    updateStreamResolution({ streamId, width, height }: {
+        streamId?: string;
+        width: number;
+        height: number;
+    }): void;
+    startScreenshare(): Promise<void>;
+    stopScreenshare(): void;
 }
 
 type RemoteParticipantState = Omit<RemoteParticipant, "updateStreamState">;
-interface RoomState {
+interface RoomConnectionState {
+    chatMessages: ChatMessage[];
+    cloudRecording: CloudRecordingState;
+    isJoining: boolean;
+    isStartingScreenshare: boolean;
+    joinError: unknown;
+    startScreenshareError: unknown;
     localParticipant?: LocalParticipant;
-    roomConnectionStatus?: "connecting" | "connected" | "disconnected";
+    mostRecentChatMessage: ChatMessage | null;
     remoteParticipants: RemoteParticipantState[];
-}
-
+    screenshares: Screenshare[];
+    roomConnectionStatus: RoomConnectionStatus;
+    streaming: StreamingState;
+    waitingParticipants: WaitingParticipant[];
+}
+interface UseRoomConnectionOptions extends Omit<RoomConnectionOptions, "localMedia"> {
+    localMedia?: LocalMediaRef;
+}
 interface RoomConnectionActions {
+    sendChatMessage(text: string): void;
+    knock(): void;
+    setDisplayName(displayName: string): void;
     toggleCamera(enabled?: boolean): void;
     toggleMicrophone(enabled?: boolean): void;
-    setDisplayName(displayName: string): void;
+    acceptWaitingParticipant(participantId: string): void;
+    rejectWaitingParticipant(participantId: string): void;
+    startScreenshare(): void;
+    stopScreenshare(): void;
 }
+type VideoViewComponentProps = Omit<React.ComponentProps<typeof _default>, "onResize">;
 interface RoomConnectionComponents {
-    VideoView: typeof _default;
+    VideoView: (props: VideoViewComponentProps) => ReturnType<typeof _default>;
 }
-declare function useRoomConnection(roomUrl: string, roomConnectionOptions: RoomConnectionOptions): [state: RoomState, actions: RoomConnectionActions, components: RoomConnectionComponents];
+type RoomConnectionRef = {
+    state: RoomConnectionState;
+    actions: RoomConnectionActions;
+    components: RoomConnectionComponents;
+    _ref: RoomConnection;
+};
+declare function useRoomConnection(roomUrl: string, roomConnectionOptions: UseRoomConnectionOptions): RoomConnectionRef;
 
-declare const sdkVersion = "2.0.0-alpha2";
+declare const sdkVersion = "2.0.0-alpha21";
 
-export { sdkVersion, useRoomConnection };
+export { _default as VideoView, sdkVersion, useLocalMedia, useRoomConnection };