@enfin/chat 1.2.0

package/dist/esm/context/ChatContext.js

@@ -0,0 +1,647 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState, useCallback, useRef } from 'react';
+import { io } from 'socket.io-client';
+import { SDK_VERSION } from '@enfin/chat-shared';
+import { WebRTCManager } from '../call/WebRTCManager';
+import { attachSignaling } from '../call/signaling';
+import { startRingtone, stopRingtone } from '../utils/ringtone';
+function getApiUrl(baseUrl, path) {
+    const trimmedBase = baseUrl.replace(/\/+$/, '');
+    const normalizedPath = path.replace(/^\/+/, '');
+    const hasApi = /\/api$/.test(trimmedBase);
+    return hasApi ? `${trimmedBase}/${normalizedPath}` : `${trimmedBase}/api/${normalizedPath}`;
+}
+function getSocketUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, '').replace(/\/api$/, '');
+}
+const ChatContext = createContext(null);
+export function ChatProvider({ config, userId, userName, serverUrl, children }) {
+    const socketRef = useRef(null);
+    const refreshUsersRef = useRef(async () => { });
+    const [socket, setSocket] = useState(null);
+    const [connected, setConnected] = useState(false);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState();
+    const [tenantId, setTenantId] = useState();
+    const [validated, setValidated] = useState(false);
+    const [messages, setMessages] = useState([]);
+    const [rooms, setRooms] = useState([]);
+    const [users, setUsers] = useState([]);
+    const [currentRoom, setCurrentRoom] = useState();
+    const [activeCall, setActiveCall] = useState();
+    const [typingUsers, setTypingUsers] = useState([]);
+    const [isMuted, setIsMuted] = useState(false);
+    const [callState, setCallState] = useState('idle');
+    const [callError, setCallError] = useState();
+    const [remoteStream, setRemoteStream] = useState(null);
+    const [busyBanner, setBusyBanner] = useState();
+    const rtcManagerRef = useRef(null);
+    const detachSignalingRef = useRef(null);
+    useEffect(() => {
+        let mounted = true;
+        const validationUrl = config.validationUrl || getApiUrl(serverUrl, 'validation/validate');
+        async function validateApiKey() {
+            setLoading(true);
+            setError(undefined);
+            setValidated(false);
+            setTenantId(undefined);
+            if (!config?.apiKey) {
+                setError('Chat API key is required');
+                setLoading(false);
+                return;
+            }
+            try {
+                const response = await fetch(validationUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ apiKey: config.apiKey, clientVersion: config.version || SDK_VERSION }),
+                });
+                if (!response.ok) {
+                    throw new Error(`API key validation failed with status ${response.status}`);
+                }
+                const payload = await response.json();
+                if (!payload.valid) {
+                    setError(payload.error || 'Invalid API key');
+                    setLoading(false);
+                    return;
+                }
+                if (!payload.tenantId) {
+                    setError('API key validation did not return a tenantId');
+                    setLoading(false);
+                    return;
+                }
+                if (mounted) {
+                    setTenantId(payload.tenantId);
+                    setValidated(true);
+                    setLoading(false);
+                }
+            }
+            catch (err) {
+                if (!mounted)
+                    return;
+                setError(err?.message || 'API key validation failed');
+                setLoading(false);
+            }
+        }
+        validateApiKey();
+        return () => {
+            mounted = false;
+        };
+    }, [config.apiKey, config.version, config.validationUrl]);
+    useEffect(() => {
+        if (!validated || !tenantId)
+            return;
+        const socketUrl = `${getSocketUrl(serverUrl)}/chat`;
+        console.log('========================================');
+        console.log('[CLIENT] Connecting socket to:', socketUrl);
+        console.log('[CLIENT] Auth:', { apiKey: config.apiKey?.slice(0, 12) + '...', userId, userName, tenantId });
+        console.log('========================================');
+        const newSocket = io(socketUrl, {
+            auth: { apiKey: config.apiKey, userId, userName, tenantId },
+            transports: ['websocket'],
+        });
+        newSocket.on('connect', () => {
+            console.log('[CLIENT] socket CONNECTED — socket.id =', newSocket.id);
+            setConnected(true);
+            setLoading(false);
+            // Load users and rooms after connecting (with a small delay to ensure server handshake is fully done)
+            setTimeout(() => {
+                loadRooms(userId, newSocket);
+                refreshUsers();
+            }, 200);
+        });
+        newSocket.on('disconnect', (reason) => {
+            console.log('[CLIENT] socket DISCONNECTED — reason =', reason);
+            stopRingtone();
+            setConnected(false);
+        });
+        newSocket.on('connect_error', (err) => {
+            console.log('[CLIENT] socket CONNECT_ERROR —', err?.message || err);
+        });
+        newSocket.on('message:new', (message) => {
+            console.log('[CLIENT] message:new RECEIVED');
+            console.log('[CLIENT]   _id =', message?._id);
+            console.log('[CLIENT]   roomId =', message?.roomId, 'type =', typeof message?.roomId);
+            console.log('[CLIENT]   senderId =', message?.senderId);
+            console.log('[CLIENT]   content =', message?.content);
+            console.log('[CLIENT]   full message =', JSON.stringify(message));
+            setMessages(prev => {
+                if (message?._id && prev.some(m => m._id === message._id)) {
+                    console.log(`[CLIENT] message:new DEDUP — _id=${message._id} already in state, ignoring`);
+                    return prev;
+                }
+                const next = [...prev, message];
+                console.log(`[CLIENT] messages state now has ${next.length} entries`);
+                return next;
+            });
+        });
+        newSocket.on('message:typing', (data) => {
+            console.log('[CLIENT] message:typing RECEIVED —', JSON.stringify(data));
+            // Skip typing events from self
+            if (data.userId === userId) {
+                console.log(`[CLIENT] message:typing SKIPPED — from self (userId=${userId})`);
+                return;
+            }
+            setTypingUsers(prev => {
+                if (data.typing) {
+                    const existing = prev.find(u => u.userId === data.userId);
+                    if (existing) {
+                        const typingIn = existing.typingIn?.includes(data.roomId)
+                            ? existing.typingIn
+                            : [...(existing.typingIn || []), data.roomId];
+                        return prev.map(u => u.userId === data.userId ? { ...u, typingIn, lastSeen: new Date() } : u);
+                    }
+                    return [...prev, { userId: data.userId, status: 'online', lastSeen: new Date(), typingIn: [data.roomId] }];
+                }
+                // Stop typing — remove only this room from the user's typingIn list
+                return prev
+                    .map(u => {
+                    if (u.userId !== data.userId)
+                        return u;
+                    const typingIn = (u.typingIn || []).filter(r => r !== data.roomId);
+                    return { ...u, typingIn };
+                })
+                    .filter(u => !u.typingIn || u.typingIn.length === 0);
+            });
+        });
+        newSocket.on('call:incoming', (call) => {
+            console.log('[CLIENT] call:incoming RECEIVED —', JSON.stringify(call));
+            setActiveCall(call);
+            startRingtone(config.ringtoneUrl);
+            // Attach signaling NOW so we don't lose the offer/ICE candidates that
+            // the caller may already be sending. The manager buffers them internally
+            // until the user clicks Accept (which then requests mic + processes the offer).
+            if (!rtcManagerRef.current) {
+                const manager = new WebRTCManager({ iceServers: config.iceServers }, {
+                    sendSignal: () => { },
+                    onStateChange: (s) => setCallState(s),
+                    onRemoteStream: (s) => setRemoteStream(s),
+                    onError: (e) => setCallError(e?.message || 'WebRTC error')
+                });
+                // This is a CALLEE — we received the offer via call:incoming, not via startCall.
+                // Mark the manager so it buffers offers until the user clicks Accept.
+                manager.markAsCallee();
+                rtcManagerRef.current = manager;
+                if (detachSignalingRef.current)
+                    detachSignalingRef.current();
+                // CRITICAL: use newSocket (the live socket from this effect's closure),
+                // NOT the `socket` state variable which may be null in the stale closure.
+                detachSignalingRef.current = attachSignaling(newSocket, manager);
+            }
+        });
+        newSocket.on('call:accepted', (call) => {
+            console.log('[CLIENT] call:accepted RECEIVED —', JSON.stringify(call));
+            stopRingtone();
+            setActiveCall(call);
+        });
+        newSocket.on('call:rejected', () => {
+            console.log('[CLIENT] call:rejected RECEIVED');
+            stopRingtone();
+        });
+        newSocket.on('call:ended', () => {
+            console.log('[CLIENT] call:ended RECEIVED');
+            stopRingtone();
+            setActiveCall(undefined);
+            setIsMuted(false);
+        });
+        newSocket.on('presence:changed', () => {
+            console.log('[CLIENT] presence:changed RECEIVED — refreshing users');
+            refreshUsersRef.current();
+        });
+        // Polling fallback in case presence:changed is missed (every 8s while connected)
+        const pollInterval = setInterval(() => {
+            refreshUsersRef.current();
+        }, 8000);
+        newSocket.onAny((event, ...args) => {
+            console.log(`[CLIENT] socket.onAny — event='${event}' args.length=${args.length}`);
+            // Emit custom events for external listeners
+            window.dispatchEvent(new CustomEvent('chat:socket-event', { detail: { event, data: args[0] } }));
+        });
+        socketRef.current = newSocket;
+        setSocket(newSocket);
+        return () => {
+            console.log('[CLIENT] Cleaning up socket — id =', newSocket.id);
+            clearInterval(pollInterval);
+            newSocket.disconnect();
+            socketRef.current = null;
+            setSocket(null);
+        };
+    }, [serverUrl, userId, userName, tenantId, validated, config.ringtoneUrl]);
+    const mergeMessages = useCallback((incoming) => {
+        setMessages(prev => {
+            const seen = new Set(prev.map(m => m._id));
+            const merged = [...prev];
+            for (const msg of incoming) {
+                if (!seen.has(msg._id)) {
+                    merged.push(msg);
+                    seen.add(msg._id);
+                }
+            }
+            return merged.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+        });
+    }, []);
+    const loadRoomMessages = useCallback(async (roomId) => {
+        const url = getApiUrl(serverUrl, `rooms/${roomId}/messages`);
+        console.log('========================================');
+        console.log('[CLIENT] loadRoomMessages — roomId =', roomId);
+        console.log('[CLIENT] GET URL =', url);
+        console.log('========================================');
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': config.apiKey,
+                },
+            });
+            console.log(`[CLIENT] loadRoomMessages — response status=${response.status}`);
+            if (!response.ok) {
+                console.log(`[CLIENT] loadRoomMessages — non-OK response, returning`);
+                return;
+            }
+            const data = await response.json();
+            const count = Array.isArray(data.messages) ? data.messages.length : 0;
+            console.log(`[CLIENT] loadRoomMessages — count=${count}`);
+            if (count > 0) {
+                console.log('[CLIENT] loadRoomMessages — first message:', JSON.stringify(data.messages[0]));
+                console.log('[CLIENT] loadRoomMessages — first message roomId =', data.messages[0].roomId, 'type =', typeof data.messages[0].roomId);
+            }
+            if (Array.isArray(data.messages)) {
+                mergeMessages(data.messages);
+            }
+        }
+        catch (err) {
+            console.warn('[CLIENT] loadRooms — failed:', err);
+        }
+    }, [serverUrl, mergeMessages]);
+    const loadRooms = useCallback(async (forUserId, targetSocket) => {
+        const url = `${serverUrl.replace(/\/+$/, '').replace(/\/api$/, '')}/api/rooms?userId=${encodeURIComponent(forUserId)}`;
+        console.log('========================================');
+        console.log('[CLIENT] loadRooms — URL =', url);
+        console.log('========================================');
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': config.apiKey,
+                },
+            });
+            console.log(`[CLIENT] loadRooms — response status=${response.status}`);
+            if (!response.ok) {
+                console.log(`[CLIENT] loadRooms — non-OK response, skipping`);
+                return;
+            }
+            const data = await response.json();
+            const roomList = Array.isArray(data.rooms) ? data.rooms : [];
+            console.log(`[CLIENT] loadRooms — count=${roomList.length}`);
+            if (roomList.length > 0) {
+                console.log('[CLIENT] loadRooms — first room:', JSON.stringify(roomList[0]).slice(0, 200));
+                console.log('[CLIENT] loadRooms — first room _id =', roomList[0]._id, 'type =', typeof roomList[0]._id);
+                console.log('[CLIENT] loadRooms — first room id =', roomList[0].id, 'type =', typeof roomList[0].id);
+            }
+            setRooms(roomList);
+            // Join each room channel so we get live messages
+            const sock = targetSocket || socketRef.current;
+            for (const room of roomList) {
+                const roomId = room._id || room.id;
+                if (roomId && sock) {
+                    try {
+                        sock.emit('room:join', { roomId });
+                        console.log('[CLIENT] loadRooms — joined room:', roomId);
+                    }
+                    catch (e) {
+                        console.log('[CLIENT] loadRooms — join error:', e);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.warn('[CLIENT] loadRooms — fetch failed:', err);
+        }
+    }, [serverUrl, config.apiKey]);
+    const refreshUsers = useCallback(async () => {
+        const url = getApiUrl(serverUrl, 'users');
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': config.apiKey,
+                },
+            });
+            if (!response.ok)
+                return;
+            const data = await response.json();
+            const list = Array.isArray(data) ? data : [];
+            console.log('[CLIENT] refreshUsers — got', list.length, 'users. Online:', list.filter(u => u.isOnline).map(u => u.name));
+            setUsers(list);
+        }
+        catch (err) {
+            console.warn('[CLIENT] refreshUsers — failed:', err);
+        }
+    }, [serverUrl, config.apiKey]);
+    // Keep ref in sync so socket event handlers always use latest closure
+    refreshUsersRef.current = refreshUsers;
+    const sendMessage = useCallback(async (roomId, content, fileMetadata) => {
+        console.log('========================================');
+        console.log('[CLIENT] sendMessage — roomId =', roomId, 'content =', content, 'fileMetadata =', fileMetadata);
+        console.log('[CLIENT] socket connected =', socket?.connected);
+        console.log('========================================');
+        if (!socket) {
+            console.log('[CLIENT] sendMessage — no socket, returning');
+            return;
+        }
+        try {
+            const payload = { roomId, content, ...(fileMetadata || {}) };
+            const ack = await socket.emitWithAck('message:send', payload);
+            console.log('[CLIENT] sendMessage — ACK received:', JSON.stringify(ack));
+        }
+        catch (err) {
+            console.log('[CLIENT] sendMessage — ACK error:', err);
+        }
+    }, [socket]);
+    const selectRoom = useCallback((roomId) => {
+        console.log('========================================');
+        console.log('[CLIENT] selectRoom — roomId =', roomId);
+        console.log('========================================');
+        const room = rooms.find(r => r._id === roomId);
+        console.log('[CLIENT] selectRoom — found room:', room ? { _id: room._id, name: room.name } : null);
+        setCurrentRoom(room);
+        if (room) {
+            console.log('[CLIENT] selectRoom — calling loadRoomMessages and emitting room:select');
+            loadRoomMessages(room._id);
+            // Inform server which room the client selected so server can track active room
+            try {
+                socketRef.current?.emitWithAck('room:select', { roomId });
+                console.log('[CLIENT] selectRoom — emitted room:select');
+            }
+            catch (e) {
+                console.log('[CLIENT] selectRoom — emit error:', e);
+            }
+        }
+        else {
+            console.log('[CLIENT] selectRoom — room NOT found in rooms list, only setCurrentRoom(undefined-equivalent)');
+        }
+    }, [rooms, loadRoomMessages]);
+    const createRoom = useCallback(async (name, type, members) => {
+        if (type === 'direct' && members.length === 2) {
+            const response = await fetch(getApiUrl(serverUrl, 'rooms/direct'), {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': config.apiKey,
+                },
+                body: JSON.stringify({ userId, members, name, apiKey: config.apiKey }),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to open direct room: ${response.status}`);
+            }
+            const payload = await response.json();
+            console.log('createRoom response:', JSON.stringify(payload).slice(0, 500));
+            const room = payload.room;
+            if (room) {
+                console.log('createRoom: room._id=', room._id, 'typeRoomId=', typeof room._id, 'messages count=', Array.isArray(payload.messages) ? payload.messages.length : 'n/a');
+                // Log the first message to debug
+                if (Array.isArray(payload.messages) && payload.messages.length > 0) {
+                    console.log('createRoom firstmsg:', JSON.stringify(payload.messages[0]));
+                    console.log('createRoom firstmsg.roomId=', payload.messages[0].roomId, 'type=', typeof payload.messages[0].roomId);
+                }
+                setRooms(prev => {
+                    if (prev.some(r => r._id === room._id))
+                        return prev;
+                    return [...prev, room];
+                });
+                if (Array.isArray(payload.messages)) {
+                    mergeMessages(payload.messages);
+                }
+                setCurrentRoom(room);
+            }
+            return room;
+        }
+        if (!socket)
+            return {};
+        const room = await socket.emitWithAck('room:create', { name, type, members });
+        setRooms(prev => [...prev, room]);
+        return room;
+    }, [socket, serverUrl, userId, mergeMessages, config.apiKey]);
+    const ensureRtcManager = useCallback(() => {
+        if (rtcManagerRef.current || !socket)
+            return;
+        const manager = new WebRTCManager({ iceServers: config.iceServers }, {
+            sendSignal: () => { },
+            onStateChange: (s) => setCallState(s),
+            onRemoteStream: (s) => setRemoteStream(s),
+            onError: (e) => setCallError(e?.message || 'WebRTC error')
+        });
+        rtcManagerRef.current = manager;
+        if (detachSignalingRef.current)
+            detachSignalingRef.current();
+        // Use socketRef.current to get the live socket, not the stale closure value
+        const liveSocket = socketRef.current || socket;
+        if (liveSocket) {
+            detachSignalingRef.current = attachSignaling(liveSocket, manager);
+        }
+    }, [socket, config.iceServers]);
+    const startCall = useCallback(async (roomId, participantId) => {
+        stopRingtone();
+        if (!socket)
+            return;
+        // Cleanup existing manager FIRST
+        if (rtcManagerRef.current) {
+            rtcManagerRef.current.close();
+            rtcManagerRef.current = null;
+        }
+        if (detachSignalingRef.current) {
+            detachSignalingRef.current();
+            detachSignalingRef.current = null;
+        }
+        ensureRtcManager();
+        setCallError(undefined);
+        setRemoteStream(null);
+        setCallState('requesting-media');
+        // Acquire mic + create PC + buffer offer (no signal sent yet)
+        try {
+            await rtcManagerRef.current.startAsCaller(roomId);
+        }
+        catch (err) {
+            setCallError(err?.message || 'Failed to access microphone');
+            setCallState('failed');
+            return;
+        }
+        // Tell the server about the call. Only after server confirms does
+        // the callee exist in the DB, so any signals routed before now are dropped.
+        try {
+            const call = await socket.emitWithAck('call:initiate', { roomId, participantId });
+            setActiveCall(call);
+            // Server confirmed — flush buffered offer + ICE candidates to callee
+            await rtcManagerRef.current.sendOffer();
+        }
+        catch (err) {
+            // The server may reject with "user is busy on another call" — surface it
+            // as a transient banner the user can see even when no chat is open.
+            const msg = err?.message || 'Failed to initiate call';
+            setCallError(msg);
+            setCallState('failed');
+            setBusyBanner(msg);
+            if (rtcManagerRef.current) {
+                rtcManagerRef.current.close();
+                rtcManagerRef.current = null;
+            }
+            if (detachSignalingRef.current) {
+                detachSignalingRef.current();
+                detachSignalingRef.current = null;
+            }
+        }
+    }, [socket, ensureRtcManager]);
+    const endCall = useCallback(async () => {
+        stopRingtone();
+        if (rtcManagerRef.current) {
+            rtcManagerRef.current.close();
+            rtcManagerRef.current = null;
+        }
+        if (detachSignalingRef.current) {
+            detachSignalingRef.current();
+            detachSignalingRef.current = null;
+        }
+        setRemoteStream(null);
+        setCallState('closed');
+        if (!socket || !activeCall) {
+            setActiveCall(undefined);
+            setIsMuted(false);
+            return;
+        }
+        try {
+            await socket.emitWithAck('call:end', { callId: activeCall._id });
+        }
+        catch { /* ignore */ }
+        setActiveCall(undefined);
+        setIsMuted(false);
+    }, [socket, activeCall]);
+    const clearBusyBanner = useCallback(() => {
+        setBusyBanner(undefined);
+    }, []);
+    const acceptCall = useCallback(async () => {
+        stopRingtone();
+        if (!socket || !activeCall)
+            return;
+        const updated = await socket.emitWithAck('call:accept', { callId: activeCall._id });
+        setActiveCall(updated);
+        if (!rtcManagerRef.current) {
+            ensureRtcManager();
+        }
+        setCallError(undefined);
+        setRemoteStream(null);
+        // Mark the manager as accepted so handleOffer will process the buffered offer
+        // (request mic, open PC, send answer). This also flips the callee gate.
+        rtcManagerRef.current?.markAsAccepted();
+        // Process the buffered offer now (mic permission is requested inside handleOffer
+        // via acquireLocalStream, which uses this user gesture to unlock the prompt).
+        try {
+            await rtcManagerRef.current?.processPendingOffer();
+        }
+        catch (err) {
+            setCallError(err?.message || 'Failed to process call');
+        }
+    }, [socket, activeCall, ensureRtcManager]);
+    const rejectCall = useCallback(async () => {
+        stopRingtone();
+        if (!socket || !activeCall) {
+            setActiveCall(undefined);
+            setIsMuted(false);
+            return;
+        }
+        try {
+            await socket.emitWithAck('call:reject', { callId: activeCall._id });
+        }
+        catch { /* ignore */ }
+        if (rtcManagerRef.current) {
+            rtcManagerRef.current.close();
+            rtcManagerRef.current = null;
+        }
+        if (detachSignalingRef.current) {
+            detachSignalingRef.current();
+            detachSignalingRef.current = null;
+        }
+        setActiveCall(undefined);
+        setIsMuted(false);
+        setRemoteStream(null);
+        setCallState('closed');
+    }, [socket, activeCall]);
+    const mute = useCallback(() => {
+        setIsMuted(true);
+        rtcManagerRef.current?.setMuted(true);
+    }, []);
+    const unmute = useCallback(() => {
+        setIsMuted(false);
+        rtcManagerRef.current?.setMuted(false);
+    }, []);
+    // Typing indicator — debounced emit / stop
+    const emitTypingTimerRef = useRef(null);
+    const stopTypingTimerRef = useRef(null);
+    const emitTyping = useCallback((roomId, typing) => {
+        const sock = socketRef.current || socket;
+        if (!sock?.connected || !roomId)
+            return;
+        sock
+            .emitWithAck('message:typing', {
+            userId,
+            roomId,
+            typing,
+        })
+            .catch(() => { });
+    }, [socket, userId]);
+    const debouncedEmitTyping = useCallback((roomId, typing) => {
+        if (emitTypingTimerRef.current) {
+            clearTimeout(emitTypingTimerRef.current);
+        }
+        emitTypingTimerRef.current = setTimeout(() => emitTyping(roomId, typing), 300);
+    }, [emitTyping]);
+    const stopTypingSoon = useCallback((roomId) => {
+        if (stopTypingTimerRef.current) {
+            clearTimeout(stopTypingTimerRef.current);
+        }
+        stopTypingTimerRef.current = setTimeout(() => {
+            emitTyping(roomId, false);
+        }, 2000);
+    }, [emitTyping]);
+    const value = {
+        userId,
+        userName,
+        messages,
+        rooms,
+        users,
+        currentRoom,
+        activeCall,
+        typingUsers,
+        connected,
+        loading,
+        error,
+        sendMessage,
+        selectRoom,
+        createRoom,
+        startCall,
+        endCall,
+        acceptCall,
+        rejectCall,
+        mute,
+        unmute,
+        isMuted,
+        socket,
+        refreshUsers,
+        callState,
+        callError,
+        remoteStream,
+        busyBanner,
+        clearBusyBanner,
+        emitTyping,
+        debouncedEmitTyping,
+        stopTypingSoon,
+        loadRoomMessages,
+    };
+    return (_jsx(ChatContext.Provider, { value: value, children: children }));
+}
+export function useChatContext() {
+    const context = useContext(ChatContext);
+    if (!context) {
+        throw new Error('useChatContext must be used within ChatProvider');
+    }
+    return context;
+}

package/dist/esm/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export { useChat } from './useChat';
+export { useRooms } from './useRooms';
+export { useMessages } from './useMessages';
+export { useCall } from './useCall';
+export { useSocket } from './useSocket';
+export { usePresence } from './usePresence';

package/dist/esm/hooks/index.js

@@ -0,0 +1,6 @@
+export { useChat } from './useChat';
+export { useRooms } from './useRooms';
+export { useMessages } from './useMessages';
+export { useCall } from './useCall';
+export { useSocket } from './useSocket';
+export { usePresence } from './usePresence';

package/dist/esm/hooks/useCall.d.ts

@@ -0,0 +1,15 @@
+export declare function useCall(): {
+    activeCall: import("@enfin/chat-shared").AudioCall;
+    callState: import("../call/WebRTCManager").WebRTCManagerState;
+    callError: string;
+    remoteStream: MediaStream;
+    busyBanner: string;
+    clearBusyBanner: () => void;
+    startCall: (roomId: string, participantId: string) => Promise<void>;
+    endCall: () => Promise<void>;
+    acceptCall: () => Promise<void>;
+    rejectCall: () => Promise<void>;
+    mute: () => void;
+    unmute: () => void;
+    isMuted: boolean;
+};