@defcomm/meetingsdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,543 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import react__default from 'react';
+
+type Events = {
+    onMicToggled?: (peerId: string, enabled: boolean) => void;
+    onError?: (err: SDKError) => void;
+    onCamToggled?: (peerId: string, enabled: boolean) => void;
+    onTrack?: (stream: MediaStream, peerId: string) => void;
+    onScreenTrack?: (stream: MediaStream, peerId: string) => void;
+    onUserJoined?: (p: Participant) => void;
+    onEntryRequested?: (req: EntryRequest) => void;
+    onEntryResponded?: (payload: {
+        participantId: string;
+        decision: EntryDecision;
+    } | string, decision?: EntryDecision) => void;
+    onJoinApproved?: (requestId: string) => void;
+    onJoinRejected?: (requestId: string) => void;
+    onConnectionStateChanged?: (state: string) => void;
+    onRoomUpdate?: (data: any) => void;
+    onUserLeft?: (id: string) => void;
+    onMeetingLeft?: () => void;
+    onChatMessage?: (msg: ChatMessage) => void;
+    onScreenShareStarted?: (peerId: string, stream: MediaStream) => void;
+    onScreenShareStopped?: (peerId: string) => void;
+    onMuteStateChanged?: (peerId: string, kind: "audio" | "video", muted: boolean) => void;
+    onTrackStateChanged?: (track: TrackDescriptor & {
+        participant_id: string;
+        kind: "audio" | "video";
+        muted: boolean;
+    }) => void;
+    onRecordingStarted?: (recording: {
+        recording_id: string;
+        started_at: string;
+    }) => void;
+    onRecordingStopped?: (recording: {
+        recording_id: string;
+        stopped_at: string;
+    }) => void;
+};
+type ChatMessage = {
+    id: string;
+    text: string;
+    sender_id: string;
+    sender_name?: string;
+    timestamp: number;
+    reply_to?: {
+        id: string;
+        name: string;
+    } | null;
+    target?: string | null;
+};
+type Participant = {
+    id: string;
+    name?: string;
+    isHost?: boolean;
+    isLocal?: boolean;
+    media?: ParticipantMedia;
+    isPresenter?: boolean;
+    connectionState?: "connected" | "reconnecting" | "disconnected";
+};
+type ParticipantMedia = {
+    stream?: MediaStream | null;
+    screenStream?: MediaStream | null;
+    cameraTrack?: MediaStreamTrack;
+    screenTrack?: MediaStreamTrack;
+    audioTrack?: MediaStreamTrack;
+    micEnabled: boolean;
+    camEnabled: boolean;
+    isScreenSharing: boolean;
+    remoteScreenStreamId?: string;
+    cameraStreamId?: string;
+};
+type Listener = () => void;
+type ChatInput = {
+    message: string;
+    reply_to?: {
+        id: string;
+        name: string;
+    } | null;
+    target?: string | null;
+};
+type MeetingConfig = {
+    roomId: string;
+    name: string;
+    audioMuted?: boolean;
+    videoMuted?: boolean;
+    token?: string;
+};
+type PubSubTopic = "SECURE_CHAT";
+type RecordingInfo = {
+    recording_id: string;
+    started_at?: string;
+    stopped_at?: string;
+    active?: boolean;
+};
+type StateScope = "participants" | "localParticipant" | "chat" | "presenter" | `participant:${string}`;
+type SDKError = {
+    code: string;
+    message: string;
+    roomId?: string | null;
+    userId?: string;
+    raw?: any;
+    recoverable?: boolean;
+};
+type EntryDecision = "approved" | "rejected";
+type EntryRequest = {
+    requestId: string;
+    userId: string;
+    name: string;
+};
+interface TrackDescriptor {
+    id: string;
+    publisher_id: string;
+    source: "camera" | "screen" | "audio";
+    mid?: string;
+}
+
+declare const useLocalParticipant: () => {
+    participant: Participant | null;
+    videoRef: (video: HTMLVideoElement | null) => void;
+};
+
+type LocalParticipantPatch = {
+    id?: string;
+    name?: string;
+    media?: Partial<ParticipantMedia>;
+};
+declare class MeetingState {
+    participants: Map<string, Participant>;
+    localParticipant: Participant | null;
+    localStream: MediaStream | null;
+    chatMessages: Map<string, ChatMessage>;
+    presenterId: string | null;
+    private listeners;
+    subscribe(scope: StateScope, fn: Listener): () => void;
+    notify(scope: StateScope): void;
+    setPresenterId(id: string | null): void;
+    addParticipant(p: Participant): boolean;
+    removeParticipant(id: string): void;
+    updateParticipantMedia(id: string, patch: Partial<NonNullable<Participant["media"]>>): void;
+    updateLocalParticipant(patch: LocalParticipantPatch): void;
+    addChatMessage(msg: ChatMessage): void;
+    getChatMessages(): ChatMessage[];
+    clearChat(): void;
+    getParticipants(): Participant[];
+    getParticipant(id: string): Participant | null;
+    resetRemoteState(): void;
+}
+
+declare class VideoSDKCore {
+    private events;
+    private apiBase;
+    private wsBase;
+    private sfuClient;
+    private myId;
+    private room;
+    private localStream;
+    private screenStream;
+    private isScreenSharing;
+    private participantName;
+    readonly state: MeetingState;
+    private intentionalDisconnect;
+    private remoteStreams;
+    private remoteScreenStreams;
+    private emitError;
+    constructor(events?: Events, apiBase?: string, wsBase?: string);
+    initLocal(video: HTMLVideoElement, name: string): Promise<void>;
+    private updateLocalMedia;
+    createRoom(input: {
+        name: string;
+        description?: string;
+        capacity?: number;
+        is_private?: boolean;
+    }): Promise<any>;
+    getRoom(roomCode: string): Promise<any>;
+    deleteRoom(roomCode: string): Promise<any>;
+    joinMeeting(config: MeetingConfig): Promise<void>;
+    private connect;
+    private handleSFUState;
+    private handleRemoteTrack;
+    getMeeting(): {
+        id: string | null;
+        name: string | null;
+    };
+    approveJoinRequest(requestId: string): Promise<void>;
+    rejectJoinRequest(requestId: string, reason?: string): Promise<void>;
+    toggleMic(): void;
+    toggleCam(): void;
+    startScreenShare(): Promise<MediaStream>;
+    stopScreenShare(): void;
+    startRecording(): Promise<void>;
+    stopRecording(): Promise<void>;
+    getRecordingStatus(): Promise<{
+        recording: RecordingInfo | null;
+    }>;
+    sendChatMessage(payload: ChatInput): void;
+    private cleanupRemoteParticipant;
+    disconnect(): Promise<void>;
+}
+
+/**
+ * DefComm SFU client.
+ *
+ * Signaling is authoritative for admission/session state.
+ * WebRTC peer connections are transport state and are recreated only after a
+ * successful join/resume. A transient WebSocket close therefore does NOT
+ * destroy the local MediaStream or immediately declare the participant gone.
+ */
+type SFUConnectionState = "idle" | "connecting" | "joining" | "waiting_approval" | "connected" | "reconnecting" | "leaving" | "disconnected";
+interface TrackInfo {
+    track_id: string;
+    participant_id: string;
+    kind: "audio" | "video";
+    source?: "camera" | "screen" | "audio" | string;
+    [key: string]: any;
+}
+interface ParticipantInfo {
+    participant_id: string;
+    user_metadata?: {
+        name?: string;
+        [key: string]: any;
+    };
+    display_name?: string;
+    [key: string]: any;
+}
+interface JoinPendingInfo {
+    request_id: string;
+    room_code?: string;
+    message?: string;
+}
+interface SFUClientOptions {
+    apiBase?: string;
+    wsBase?: string;
+    userId?: string;
+    onStateChange?: (state: SFUConnectionState) => void;
+    onParticipantJoined?: (participant: ParticipantInfo) => void;
+    onParticipantLeft?: (participant: string | ParticipantInfo) => void;
+    onParticipantPresence?: (participantId: string, presence: string) => void;
+    onTrackPublished?: (track: TrackInfo) => void;
+    onTrackUnpublished?: (track: TrackInfo) => void;
+    onRemoteTrack?: (track: MediaStreamTrack, stream: MediaStream, metadata: TrackInfo) => void;
+    onConnected?: (payload: any, resumed: boolean) => void;
+    onDisconnected?: () => void;
+    onReconnecting?: (attempt: number) => void;
+    onJoinPending?: (info: JoinPendingInfo) => void;
+    onJoinApproved?: (requestId: string) => void;
+    onJoinRejected?: (requestId: string, reason?: string) => void;
+    onJoinRequested?: (request: any) => void;
+    onScreenShareStarted?: (participantId: string, track?: TrackInfo) => void;
+    onScreenShareStopped?: (participantId: string, trackId?: string) => void;
+    onTrackStateChanged?: (track: TrackInfo) => void;
+    onRecordingStarted?: (recording: {
+        recording_id: string;
+        started_at: string;
+    }) => void;
+    onRecordingStopped?: (recording: {
+        recording_id: string;
+        stopped_at: string;
+    }) => void;
+    onError?: (error: any) => void;
+    autoSubscribe?: boolean;
+}
+declare class SFUClient {
+    private apiBase;
+    private wsBase;
+    private userId;
+    private ws;
+    private publisher;
+    private subscriber;
+    private localStream;
+    private screenStream;
+    private videoSender;
+    private audioSender;
+    private screenSender;
+    private iceServers;
+    private requestId;
+    private publisherRevision;
+    private currentParticipantId;
+    private token;
+    private room;
+    private resumeToken;
+    private pendingJoinRequestId;
+    private joinOptions;
+    private state;
+    private intentionalClose;
+    private leaveAcknowledged;
+    private joiningWithResume;
+    private reconnectTimer;
+    private reconnectAttempt;
+    private maxReconnectAttempts;
+    private reconnectBaseMs;
+    private joinWaiter;
+    private pendingIce;
+    private subscriberNegotiating;
+    private offerQueue;
+    private subscriptionQueue;
+    private subscriptionRunning;
+    private subscriptionWaiters;
+    private subscribedTracks;
+    private trackMetadata;
+    private participants;
+    private remoteStreams;
+    private trackToParticipant;
+    private trackToSource;
+    private localTrackIds;
+    private subscriberStatsTimer;
+    private onStateChange;
+    private onParticipantJoined;
+    private onParticipantLeft;
+    private onParticipantPresence;
+    private onTrackPublished;
+    private onTrackUnpublished;
+    private onRemoteTrack;
+    private onConnected;
+    private onDisconnected;
+    private onReconnecting;
+    private onJoinPending;
+    private onJoinApproved;
+    private onJoinRejected;
+    private onJoinRequested;
+    private onScreenShareStarted;
+    private onScreenShareStopped;
+    private onTrackStateChanged;
+    private onRecordingStarted;
+    private onRecordingStopped;
+    private onError;
+    private autoSubscribe;
+    constructor(options?: SFUClientOptions);
+    private createId;
+    private resumeStorageKey;
+    private loadResumeToken;
+    private saveResumeToken;
+    private clearResumeToken;
+    private setState;
+    getConnectionState(): SFUConnectionState;
+    getParticipantId(): string | null;
+    getResumeToken(): string | null;
+    getLocalStream(): MediaStream | null;
+    getScreenStream(): MediaStream | null;
+    setLocalStream(stream: MediaStream | null): void;
+    private nextRequestId;
+    private request;
+    createRoom(input: {
+        name: string;
+        description?: string;
+        capacity?: number;
+        is_private?: boolean;
+    }): Promise<any>;
+    getRoom(roomCode: string): Promise<any>;
+    deleteRoom(roomCode: string): Promise<any>;
+    getToken(roomCode: string, options?: {
+        displayName?: string;
+        avatarUrl?: string;
+        userId?: string;
+    }): Promise<void>;
+    private refreshAccessToken;
+    private connect;
+    private openWebSocket;
+    private scheduleReconnect;
+    private failJoin;
+    private resolveJoin;
+    private handleServerMessage;
+    private rememberTrack;
+    private handleJoined;
+    private initializePeerConnections;
+    private handleRemoteTrack;
+    private normalizeRemoteTrackId;
+    private resolveRemoteTrackMetadata;
+    private sendCandidate;
+    private handleIce;
+    private flushPendingIce;
+    private processOfferQueue;
+    private subscribe;
+    private subscribeMultiple;
+    private processSubscriptionQueue;
+    publish({ audio, video }?: {
+        audio?: boolean | undefined;
+        video?: boolean | undefined;
+    }): Promise<MediaStream>;
+    private publishExistingTracks;
+    shareScreen(): Promise<MediaStream>;
+    stopScreenShare(): Promise<void>;
+    muteAudio(muted: boolean): void;
+    muteVideo(muted: boolean): void;
+    startRecording(): Promise<void>;
+    stopRecording(): Promise<void>;
+    getRecordingStatus(): Promise<any>;
+    approveJoinRequest(requestId: string): Promise<void>;
+    rejectJoinRequest(requestId: string, reason?: string): Promise<void>;
+    private isSocketOpen;
+    private send;
+    private removeRemoteParticipant;
+    leave(): Promise<void>;
+    private closePeerConnectionsOnly;
+    private cleanupAll;
+    private logSubscriberVideoStats;
+}
+
+type PubSubHandle = {
+    messages: ChatMessage[];
+    publish: (input: ChatInput) => void;
+};
+type MeetingContextValue = {
+    sdk: VideoSDKCore;
+    join: (config?: MeetingConfig) => Promise<void>;
+    leave: () => void;
+    createRoom: (input: {
+        name: string;
+        description?: string;
+        capacity?: number;
+        is_private?: boolean;
+    }) => Promise<any>;
+    getRoom: (roomCode: string) => Promise<any>;
+    deleteRoom: (roomCode: string) => Promise<any>;
+    toggleMic: () => void;
+    toggleCam: () => void;
+    startScreenShare: () => Promise<MediaStream>;
+    stopScreenShare: () => void;
+    sendMessage: (input: ChatInput) => void;
+    room: {
+        id: string | null;
+        name: string | null;
+    };
+    localParticipant: Participant | null;
+    participants: Map<string, Participant>;
+    messages: ChatMessage[];
+    presenterId: string | null;
+    usePubSub: (topic: PubSubTopic) => PubSubHandle;
+    approveJoinRequest: (requestId: string) => void;
+    rejectJoinRequest: (requestId: string) => void;
+    startRecording: () => Promise<void>;
+    stopRecording: () => Promise<void>;
+    getRecordingStatus: () => Promise<any>;
+    onError: (cb: (err: any) => void) => () => void;
+    onEntryRequested: (cb: (req: any) => void) => () => void;
+    onEntryResponded: (cb: (payload: any, decision?: any) => void) => () => void;
+    onMeetingLeft: (cb: () => void) => () => void;
+    onTrackStateChanged: (cb: (track: any) => void) => () => void;
+    onRecordingStarted: (cb: (recording: any) => void) => () => void;
+    onRecordingStopped: (cb: (recording: any) => void) => () => void;
+};
+declare const MeetingProvider: ({ config, children, }: {
+    config: MeetingConfig;
+    children: react__default.ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+declare const useMeetingContext: () => MeetingContextValue;
+
+declare const useMeeting: (handlers?: {
+    onError?: (err: any) => void;
+    onEntryRequested?: (req: any) => void;
+    onEntryResponded?: (payload: any, decision?: any) => void;
+    onMeetingLeft?: () => void;
+    onTrackStateChanged?: (track: any) => void;
+    onRecordingStarted?: (recording: any) => void;
+    onRecordingStopped?: (recording: any) => void;
+}) => {
+    join: (config?: MeetingConfig) => Promise<void>;
+    leave: () => void;
+    createRoom: (input: {
+        name: string;
+        description?: string;
+        capacity?: number;
+        is_private?: boolean;
+    }) => Promise<any>;
+    getRoom: (roomCode: string) => Promise<any>;
+    deleteRoom: (roomCode: string) => Promise<any>;
+    toggleMic: () => void;
+    toggleCam: () => void;
+    startScreenShare: () => Promise<MediaStream>;
+    stopScreenShare: () => void;
+    sendMessage: (input: ChatInput) => void;
+    room: {
+        id: string | null;
+        name: string | null;
+    };
+    localParticipant: Participant | null;
+    participants: Map<string, Participant>;
+    messages: ChatMessage[];
+    presenterId: string | null;
+    usePubSub: (topic: PubSubTopic) => {
+        messages: ChatMessage[];
+        publish: (input: ChatInput) => void;
+    };
+    approveJoinRequest: (requestId: string) => void;
+    rejectJoinRequest: (requestId: string) => void;
+    startRecording: () => Promise<void>;
+    stopRecording: () => Promise<void>;
+    getRecordingStatus: () => Promise<any>;
+    onError: (cb: (err: any) => void) => () => void;
+    onEntryRequested: (cb: (req: any) => void) => () => void;
+    onEntryResponded: (cb: (payload: any, decision?: any) => void) => () => void;
+    onMeetingLeft: (cb: () => void) => () => void;
+    onTrackStateChanged: (cb: (track: any) => void) => () => void;
+    onRecordingStarted: (cb: (recording: any) => void) => () => void;
+    onRecordingStopped: (cb: (recording: any) => void) => () => void;
+};
+
+declare const useParticipants: () => Participant[];
+
+declare const useRemoteMedia: (participantId: string) => {
+    videoRef: react.RefObject<HTMLVideoElement | null>;
+    audioRef: react.RefObject<HTMLAudioElement | null>;
+    isCamActive: boolean;
+    isMicEnabled: boolean;
+};
+
+type LiveRoomState = {
+    active: boolean;
+    count: number;
+    canJoin: boolean;
+    approved: boolean;
+    isHost: boolean;
+    hasMoreParticipants: boolean;
+    participants: {
+        id: string;
+        name: string;
+        isHost: boolean;
+        isPresenter: boolean;
+        micEnabled: boolean;
+        camEnabled: boolean;
+    }[];
+    room?: {
+        id: string;
+        name: string;
+        room_code: string;
+        capacity: number;
+        is_private: boolean;
+    };
+};
+/**
+ * Current SFU does not expose the old `/watch/:room` mesh presence socket.
+ * Preview therefore uses the authoritative REST room endpoint and polls it.
+ * Live participant/media state begins after JOIN over the SFU WebSocket.
+ */
+declare function useMeetingPreview(roomId: string, userId: string): {
+    room: LiveRoomState | null;
+    isConnected: boolean;
+    isLoading: boolean;
+    error: string | null;
+};
+
+export { type ChatInput, type MeetingConfig, MeetingProvider, MeetingState, type Participant, type ParticipantInfo, type RecordingInfo, SFUClient, type SFUConnectionState, type TrackInfo, VideoSDKCore, useLocalParticipant, useMeeting, useMeetingContext, useMeetingPreview, useParticipants, useRemoteMedia };