@afosecure/meetingsdk 1.0.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ADELAJA OLUWATOBA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,253 @@
+# 📹 @afosecure/meetingsdk — React Video Meeting SDK
+
+A modern, lightweight React SDK for building peer-to-peer video communication applications using WebRTC. Designed with a clean, composable API and reactive state management.
+
+---
+
+## Features
+
+- WebRTC peer-to-peer video (no central media server required)
+- React Hooks API for seamless integration
+- Reactive state system for participants & streams
+- Lightweight core optimized for performance
+- Flexible WebSocket signaling backend support
+- Full TypeScript support
+
+---
+
+## 📦 Installation
+
+```bash
+npm install @afosecure/meetingsdk
+# or
+yarn add @afosecure/meetingsdk
+# or
+pnpm add @afosecure/meetingsdk
+```
+
+---
+
+## Quick Start
+
+### 1. Initialize SDK
+
+```tsx
+import { useState } from "react";
+import {
+  MeetingProvider,
+  MeetingState,
+  VideoSDKCore,
+} from "@afosecure/meetingsdk";
+
+function App() {
+  const [core] = useState(
+    () =>
+      new VideoSDKCore({
+        onTrack: (_, peerId) => {
+          console.log("📹 Received stream from:", peerId);
+        },
+        onUserJoined: (participant) => {
+          console.log("👤 User joined:", participant.name);
+        },
+        onUserLeft: (userId) => {
+          console.log("👤 User left:", userId);
+        },
+      }),
+  );
+
+  return (
+    <MeetingProvider core={core}>
+      <VideoCall />
+    </MeetingProvider>
+  );
+}
+
+export default App;
+```
+
+---
+
+### 2. Basic Video Call
+
+```tsx
+import { useRef, useState } from "react";
+import { useMeeting, useParticipants } from "@afosecure/meetingsdk";
+
+function VideoCall() {
+  const { join, startLocalStream, leave, localParticipant } = useMeeting();
+  const participants = useParticipants();
+  const localVideoRef = useRef<HTMLVideoElement>(null);
+
+  const [roomId, setRoomId] = useState("");
+  const [name, setName] = useState("");
+
+  const handleJoin = async () => {
+    if (!localVideoRef.current) return;
+
+    await startLocalStream(localVideoRef.current, name);
+    await join(roomId, name);
+  };
+
+  return (
+    <div>
+      {!localParticipant ? (
+        <>
+          <input value={name} onChange={(e) => setName(e.target.value)} />
+          <input value={roomId} onChange={(e) => setRoomId(e.target.value)} />
+          <button onClick={handleJoin}>Join Meeting</button>
+        </>
+      ) : (
+        <>
+          <video ref={localVideoRef} autoPlay muted />
+          <button onClick={leave}>Leave</button>
+
+          {participants.map((p) => (
+            <div key={p.id}>{p.name}</div>
+          ))}
+        </>
+      )}
+    </div>
+  );
+}
+```
+
+---
+
+## Core Concepts
+
+### MeetingState
+
+```ts
+const state = new MeetingState();
+
+state.getParticipants();
+
+state.subscribe(() => {
+  console.log("updated");
+});
+```
+
+---
+
+### VideoSDKCore
+
+```ts
+const core = new VideoSDKCore(state, {
+  onTrack: (stream, peerId) => {},
+  onUserJoined: (p) => {},
+  onUserLeft: (id) => {},
+});
+```
+
+---
+
+## Hooks API
+
+### useMeeting()
+
+```ts
+const { join, startLocalStream, leave, localParticipant, meetingId } =
+  useMeeting();
+```
+
+---
+
+### useParticipants()
+
+```ts
+const participants = useParticipants();
+```
+
+---
+
+### useRemoteVideo()
+
+```tsx
+const ref = useRemoteVideo(participantId);
+
+return <video ref={ref} autoPlay />;
+```
+
+---
+
+### useLocalStream()
+
+```ts
+const stream = useLocalStream();
+```
+
+---
+
+### useStreams()
+
+```ts
+const streams = useStreams();
+```
+
+---
+
+## Complete Example
+
+```tsx
+export default function App() {
+  const [state] = useState(() => new MeetingState());
+
+  const [core] = useState(
+    () =>
+      new VideoSDKCore(state, {
+        onTrack: () => {},
+        onUserJoined: () => {},
+        onUserLeft: () => {},
+      }),
+  );
+
+  return (
+    <MeetingProvider core={core}>
+      <VideoCallContent />
+    </MeetingProvider>
+  );
+}
+```
+
+---
+
+## Server Requirements
+
+Your WebSocket server must support:
+
+### Client → Server
+
+- JOIN
+- OFFER
+- ANSWER
+- ICE
+
+### Server → Client
+
+- EXISTING_USERS
+- USER_JOINED
+- USER_LEFT
+
+---
+
+## Performance Tips
+
+- Stop media tracks on leave
+- Memoize participant components
+- Use multiple STUN servers
+- Avoid re-rendering video elements
+
+---
+
+## Browser Support
+
+- Chrome 54+
+- Firefox 55+
+- Safari 11+
+- Edge 79+
+
+---
+
+## 📄 License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,210 @@
+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;
+    onUserLeft?: (id: string) => void;
+    onChatMessage?: (msg: ChatMessage) => void;
+    onScreenShareStarted?: (peerId: string, stream: MediaStream) => void;
+    onScreenShareStopped?: (peerId: string) => void;
+    onMuteStateChanged?: (peerId: string, kind: "audio" | "video", muted: boolean) => 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;
+    media?: ParticipantMedia;
+};
+type ParticipantMedia = {
+    stream?: MediaStream | null;
+    screenStream?: MediaStream | null;
+    cameraTrack?: MediaStreamTrack;
+    screenTrack?: MediaStreamTrack;
+    audioTrack?: MediaStreamTrack;
+    micEnabled: boolean;
+    camEnabled: boolean;
+    isScreenSharing: boolean;
+    remoteScreenStreamId?: 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 StateScope = "participants" | "localParticipant" | "chat" | "presenter" | `participant:${string}`;
+type SDKError = {
+    code: string;
+    message: string;
+    roomId?: string | null;
+    userId?: string;
+    raw?: any;
+    recoverable?: boolean;
+};
+
+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 url;
+    private ws;
+    private peers;
+    private initiators;
+    private myId;
+    private roomId;
+    private localStream;
+    private screenStream;
+    private isScreenSharing;
+    private screenSenders;
+    private pingInterval;
+    private pendingIceCandidates;
+    private reconnectAttempts;
+    private reconnectTimer?;
+    private participantName;
+    readonly state: MeetingState;
+    private joinResolver?;
+    private joinRejecter?;
+    private emitError;
+    constructor(events?: Events, url?: string);
+    initLocal(video: HTMLVideoElement, name: string): Promise<void>;
+    connect(roomId: string, name: string): Promise<void>;
+    joinMeeting(config: MeetingConfig): Promise<void>;
+    /** Expose the roomId without making it fully public */
+    getMeetingId(): string | null;
+    toggleMic(): void;
+    toggleCam(): void;
+    private scheduleReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private reset;
+    private handle;
+    private createPeer;
+    private createOffer;
+    private handleOffer;
+    private closePeer;
+    startScreenShare(): Promise<MediaStream>;
+    stopScreenShare(): void;
+    sendChatMessage(payload: ChatInput): void;
+    disconnect(): void;
+    private flushIce;
+    private send;
+}
+
+type PubSubHandle = {
+    messages: ChatMessage[];
+    publish: (input: ChatInput) => void;
+};
+type MeetingContextValue = {
+    sdk: VideoSDKCore;
+    join: (config: MeetingConfig) => Promise<void>;
+    leave: () => void;
+    toggleMic: () => void;
+    toggleCam: () => void;
+    startScreenShare: () => Promise<MediaStream>;
+    stopScreenShare: () => void;
+    sendMessage: (input: ChatInput) => void;
+    meetingId: string | null;
+    localParticipant: Participant | null;
+    participants: Map<string, Participant>;
+    messages: ChatMessage[];
+    presenterId: string | null;
+    usePubSub: (topic: PubSubTopic) => PubSubHandle;
+    onError: (cb: (err: 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;
+}) => {
+    sdk: VideoSDKCore;
+    join: (config: MeetingConfig) => Promise<void>;
+    leave: () => void;
+    toggleMic: () => void;
+    toggleCam: () => void;
+    startScreenShare: () => Promise<MediaStream>;
+    stopScreenShare: () => void;
+    sendMessage: (input: ChatInput) => void;
+    meetingId: string | null;
+    localParticipant: Participant | null;
+    participants: Map<string, Participant>;
+    messages: ChatMessage[];
+    presenterId: string | null;
+    usePubSub: (topic: PubSubTopic) => {
+        messages: ChatMessage[];
+        publish: (input: ChatInput) => void;
+    };
+    onError: (cb: (err: 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;
+};
+
+export { type ChatInput, MeetingProvider, MeetingState, type Participant, VideoSDKCore, useLocalParticipant, useMeeting, useMeetingContext, useParticipants, useRemoteMedia };

package/dist/index.d.ts

@@ -0,0 +1,210 @@
+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;
+    onUserLeft?: (id: string) => void;
+    onChatMessage?: (msg: ChatMessage) => void;
+    onScreenShareStarted?: (peerId: string, stream: MediaStream) => void;
+    onScreenShareStopped?: (peerId: string) => void;
+    onMuteStateChanged?: (peerId: string, kind: "audio" | "video", muted: boolean) => 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;
+    media?: ParticipantMedia;
+};
+type ParticipantMedia = {
+    stream?: MediaStream | null;
+    screenStream?: MediaStream | null;
+    cameraTrack?: MediaStreamTrack;
+    screenTrack?: MediaStreamTrack;
+    audioTrack?: MediaStreamTrack;
+    micEnabled: boolean;
+    camEnabled: boolean;
+    isScreenSharing: boolean;
+    remoteScreenStreamId?: 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 StateScope = "participants" | "localParticipant" | "chat" | "presenter" | `participant:${string}`;
+type SDKError = {
+    code: string;
+    message: string;
+    roomId?: string | null;
+    userId?: string;
+    raw?: any;
+    recoverable?: boolean;
+};
+
+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 url;
+    private ws;
+    private peers;
+    private initiators;
+    private myId;
+    private roomId;
+    private localStream;
+    private screenStream;
+    private isScreenSharing;
+    private screenSenders;
+    private pingInterval;
+    private pendingIceCandidates;
+    private reconnectAttempts;
+    private reconnectTimer?;
+    private participantName;
+    readonly state: MeetingState;
+    private joinResolver?;
+    private joinRejecter?;
+    private emitError;
+    constructor(events?: Events, url?: string);
+    initLocal(video: HTMLVideoElement, name: string): Promise<void>;
+    connect(roomId: string, name: string): Promise<void>;
+    joinMeeting(config: MeetingConfig): Promise<void>;
+    /** Expose the roomId without making it fully public */
+    getMeetingId(): string | null;
+    toggleMic(): void;
+    toggleCam(): void;
+    private scheduleReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private reset;
+    private handle;
+    private createPeer;
+    private createOffer;
+    private handleOffer;
+    private closePeer;
+    startScreenShare(): Promise<MediaStream>;
+    stopScreenShare(): void;
+    sendChatMessage(payload: ChatInput): void;
+    disconnect(): void;
+    private flushIce;
+    private send;
+}
+
+type PubSubHandle = {
+    messages: ChatMessage[];
+    publish: (input: ChatInput) => void;
+};
+type MeetingContextValue = {
+    sdk: VideoSDKCore;
+    join: (config: MeetingConfig) => Promise<void>;
+    leave: () => void;
+    toggleMic: () => void;
+    toggleCam: () => void;
+    startScreenShare: () => Promise<MediaStream>;
+    stopScreenShare: () => void;
+    sendMessage: (input: ChatInput) => void;
+    meetingId: string | null;
+    localParticipant: Participant | null;
+    participants: Map<string, Participant>;
+    messages: ChatMessage[];
+    presenterId: string | null;
+    usePubSub: (topic: PubSubTopic) => PubSubHandle;
+    onError: (cb: (err: 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;
+}) => {
+    sdk: VideoSDKCore;
+    join: (config: MeetingConfig) => Promise<void>;
+    leave: () => void;
+    toggleMic: () => void;
+    toggleCam: () => void;
+    startScreenShare: () => Promise<MediaStream>;
+    stopScreenShare: () => void;
+    sendMessage: (input: ChatInput) => void;
+    meetingId: string | null;
+    localParticipant: Participant | null;
+    participants: Map<string, Participant>;
+    messages: ChatMessage[];
+    presenterId: string | null;
+    usePubSub: (topic: PubSubTopic) => {
+        messages: ChatMessage[];
+        publish: (input: ChatInput) => void;
+    };
+    onError: (cb: (err: 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;
+};
+
+export { type ChatInput, MeetingProvider, MeetingState, type Participant, VideoSDKCore, useLocalParticipant, useMeeting, useMeetingContext, useParticipants, useRemoteMedia };