ajaxter-chat 3.0.17 → 3.1.0

package/src/components/ErrorBoundary/index.tsx

@@ -0,0 +1,62 @@
+import React, { Component, ErrorInfo, ReactNode } from 'react';
+
+interface Props {
+  children: ReactNode;
+  fallback?: ReactNode;
+  primaryColor?: string;
+  onError?: (error: Error, info: ErrorInfo) => void;
+}
+
+interface State {
+  hasError: boolean;
+  error: Error | null;
+}
+
+export class ErrorBoundary extends Component<Props, State> {
+  constructor(props: Props) {
+    super(props);
+    this.state = { hasError: false, error: null };
+  }
+
+  static getDerivedStateFromError(error: Error): State {
+    return { hasError: true, error };
+  }
+
+  componentDidCatch(error: Error, info: ErrorInfo) {
+    console.error('[ChatWidget] Uncaught error:', error, info.componentStack);
+    this.props.onError?.(error, info);
+  }
+
+  handleReset = () => {
+    this.setState({ hasError: false, error: null });
+  };
+
+  render() {
+    if (this.state.hasError) {
+      if (this.props.fallback) return this.props.fallback;
+      const color = this.props.primaryColor ?? '#2563EB';
+      return (
+        <div style={{
+          display: 'flex', flexDirection: 'column', alignItems: 'center',
+          justifyContent: 'center', height: '100%', padding: 32, textAlign: 'center', gap: 12,
+        }}>
+          <div style={{ fontSize: 40 }}>⚠️</div>
+          <p style={{ fontWeight: 700, color: '#1a2332', margin: 0 }}>Something went wrong</p>
+          <p style={{ fontSize: 13, color: '#7b8fa1', lineHeight: 1.6, margin: 0 }}>
+            {this.state.error?.message ?? 'An unexpected error occurred'}
+          </p>
+          <button
+            onClick={this.handleReset}
+            style={{
+              padding: '9px 20px', borderRadius: 10, border: 'none',
+              background: color, color: '#fff', cursor: 'pointer', fontWeight: 700, fontSize: 14,
+            }}
+          >
+            Try Again
+          </button>
+        </div>
+      );
+    }
+    return this.props.children;
+  }
+}

package/src/hooks/useChat.ts

@@ -1,19 +1,29 @@
-import { useState, useCallback } from 'react';
+import { useState, useCallback, useRef } from 'react';
 import { ChatMessage, ChatUser } from '../types';
 
-export function useChat(initialMessages: ChatMessage[] = []) {
+export interface UseChatOptions {
+  onEmitMessage?: (msg: ChatMessage) => void;
+  onEmitPause?: (roomId: string, targetUid: string, paused: boolean) => void;
+  onEmitReport?: (roomId: string) => void;
+}
+
+export function useChat(initialMessages: ChatMessage[] = [], opts: UseChatOptions = {}) {
   const [messages,   setMessages]   = useState<ChatMessage[]>(initialMessages);
   const [activeUser, setActiveUser] = useState<ChatUser | null>(null);
   const [isPaused,   setIsPaused]   = useState(false);
   const [isReported, setIsReported] = useState(false);
+  const activeUserRef = useRef<ChatUser | null>(null);
+  const isPausedRef   = useRef(false);
+
+  const { onEmitMessage, onEmitPause, onEmitReport } = opts;
 
   const selectUser = useCallback((user: ChatUser, history: ChatMessage[] = []) => {
     setActiveUser(user);
+    activeUserRef.current = user;
     setMessages(history);
     setIsPaused(false);
+    isPausedRef.current = false;
     setIsReported(false);
-    // TODO: socket.emit('join', { roomId: user.uid });
-    // TODO: socket.on('message', msg => setMessages(prev => [...prev, msg]));
   }, []);
 
   const sendMessage = useCallback((
@@ -21,11 +31,12 @@ export function useChat(initialMessages: ChatMessage[] = []) {
     type: ChatMessage['type'] = 'text',
     extra: Partial<ChatMessage> = {}
   ) => {
-    if (!activeUser || isPaused) return;
+    const user = activeUserRef.current;
+    if (!user || isPausedRef.current) return;
     const msg: ChatMessage = {
       id:         `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`,
       senderId:   'me',
-      receiverId: activeUser.uid,
+      receiverId: user.uid,
       text,
       timestamp:  new Date().toISOString(),
       type,
@@ -33,16 +44,52 @@ export function useChat(initialMessages: ChatMessage[] = []) {
       ...extra,
     };
     setMessages(prev => [...prev, msg]);
-    // TODO: socket.emit('message', msg);
-  }, [activeUser, isPaused]);
+    onEmitMessage?.(msg);
+  }, [onEmitMessage]);
+
+  const receiveMessage = useCallback((msg: ChatMessage) => {
+    setMessages(prev => {
+      if (prev.some(m => m.id === msg.id)) return prev;
+      return [...prev, msg];
+    });
+  }, []);
+
+  const updateMessageStatus = useCallback((messageId: string, status: ChatMessage['status']) => {
+    setMessages(prev => prev.map(m => m.id === messageId ? { ...m, status } : m));
+  }, []);
+
+  const togglePause = useCallback(() => {
+    const user = activeUserRef.current;
+    if (!user) return;
+    const next = !isPausedRef.current;
+    setIsPaused(next);
+    isPausedRef.current = next;
+    const roomId = [user.uid, 'me'].sort().join('_');
+    onEmitPause?.(roomId, user.uid, next);
+  }, [onEmitPause]);
+
+  const reportChat = useCallback(() => {
+    const user = activeUserRef.current;
+    setIsReported(true);
+    if (user) {
+      const roomId = [user.uid, 'me'].sort().join('_');
+      onEmitReport?.(roomId);
+    }
+  }, [onEmitReport]);
 
-  const togglePause   = useCallback(() => setIsPaused(p => !p), []);
-  const reportChat    = useCallback(() => { setIsReported(true); /* TODO: API call */ }, []);
-  const clearChat     = useCallback(() => { setMessages([]); setActiveUser(null); }, []);
+  const clearChat = useCallback(() => {
+    setMessages([]);
+    setActiveUser(null);
+    activeUserRef.current = null;
+    setIsPaused(false);
+    isPausedRef.current = false;
+    setIsReported(false);
+  }, []);
 
   return {
     messages, activeUser, isPaused, isReported,
-    selectUser, sendMessage, togglePause, reportChat, clearChat,
+    selectUser, sendMessage, receiveMessage, updateMessageStatus,
+    togglePause, reportChat, clearChat,
     setMessages,
   };
 }

package/src/hooks/useSocket.ts

@@ -0,0 +1,228 @@
+'use client';
+
+import { useEffect, useRef, useCallback, useState } from 'react';
+import { ChatMessage } from '../types';
+
+export type SocketStatus = 'connecting' | 'connected' | 'disconnected' | 'error';
+
+export interface SocketMessageAck {
+  messageId: string;
+  status: 'delivered' | 'read';
+}
+
+export interface UseSocketOptions {
+  widgetId: string;
+  viewerUid: string;
+  /** WebSocket server URL — defaults to http://localhost:3005 */
+  serverUrl?: string;
+  onMessage?: (msg: ChatMessage) => void;
+  onMessageAck?: (ack: SocketMessageAck) => void;
+  onChatPaused?: (roomId: string, paused: boolean) => void;
+  onCallOffer?: (offer: RTCSessionDescriptionInit, fromUid: string, callId: string) => void;
+  onCallAnswer?: (answer: RTCSessionDescriptionInit, fromUid: string, callId: string) => void;
+  onIceCandidate?: (candidate: RTCIceCandidateInit, fromUid: string) => void;
+  onCallEnd?: (callId: string) => void;
+  onError?: (code: string, message: string) => void;
+  onUserStatus?: (uid: string, status: 'online' | 'away' | 'offline') => void;
+}
+
+const SOCKET_URL = 'http://localhost:3005';
+const RECONNECT_DELAY = 3000;
+const MAX_RECONNECT = 5;
+
+export function useSocket(opts: UseSocketOptions) {
+  const {
+    widgetId, viewerUid, serverUrl = SOCKET_URL,
+    onMessage, onMessageAck, onChatPaused,
+    onCallOffer, onCallAnswer, onIceCandidate, onCallEnd,
+    onError, onUserStatus,
+  } = opts;
+
+  const [status, setStatus] = useState<SocketStatus>('disconnected');
+  const wsRef = useRef<WebSocket | null>(null);
+  const reconnectCount = useRef(0);
+  const reconnectTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const currentRoomRef = useRef<string | null>(null);
+  const mountedRef = useRef(true);
+
+  const send = useCallback((event: string, payload: unknown) => {
+    if (wsRef.current?.readyState === WebSocket.OPEN) {
+      wsRef.current.send(JSON.stringify({ event, payload }));
+    }
+  }, []);
+
+  const connect = useCallback(() => {
+    if (!mountedRef.current) return;
+    if (wsRef.current) {
+      wsRef.current.onclose = null;
+      wsRef.current.close();
+    }
+    setStatus('connecting');
+
+    const url = `${serverUrl}?widgetId=${encodeURIComponent(widgetId)}&uid=${encodeURIComponent(viewerUid)}`;
+    let ws: WebSocket;
+    try {
+      ws = new WebSocket(url);
+    } catch (e) {
+      setStatus('error');
+      return;
+    }
+    wsRef.current = ws;
+
+    ws.onopen = () => {
+      if (!mountedRef.current) { ws.close(); return; }
+      reconnectCount.current = 0;
+      setStatus('connected');
+      // Re-join current room if we were in one
+      if (currentRoomRef.current) {
+        send('join', { roomId: currentRoomRef.current, widgetId });
+      }
+    };
+
+    ws.onmessage = (event) => {
+      let parsed: { event: string; payload: unknown };
+      try { parsed = JSON.parse(event.data as string); }
+      catch { return; }
+      const { event: ev, payload } = parsed;
+      switch (ev) {
+        case 'message':
+          onMessage?.(payload as ChatMessage);
+          break;
+        case 'message:ack':
+          onMessageAck?.(payload as SocketMessageAck);
+          break;
+        case 'chat:paused': {
+          const p = payload as { roomId: string; paused: boolean };
+          onChatPaused?.(p.roomId, p.paused);
+          break;
+        }
+        case 'call-offer': {
+          const p = payload as { offer: RTCSessionDescriptionInit; from: string; callId: string };
+          onCallOffer?.(p.offer, p.from, p.callId);
+          break;
+        }
+        case 'call-answer': {
+          const p = payload as { answer: RTCSessionDescriptionInit; from: string; callId: string };
+          onCallAnswer?.(p.answer, p.from, p.callId);
+          break;
+        }
+        case 'ice-candidate': {
+          const p = payload as { candidate: RTCIceCandidateInit; from: string };
+          onIceCandidate?.(p.candidate, p.from);
+          break;
+        }
+        case 'call-end': {
+          const p = payload as { callId: string };
+          onCallEnd?.(p.callId);
+          break;
+        }
+        case 'user:status': {
+          const p = payload as { uid: string; status: 'online' | 'away' | 'offline' };
+          onUserStatus?.(p.uid, p.status);
+          break;
+        }
+        case 'error': {
+          const p = payload as { code: string; message: string };
+          onError?.(p.code, p.message);
+          break;
+        }
+      }
+    };
+
+    ws.onerror = () => {
+      if (!mountedRef.current) return;
+      setStatus('error');
+    };
+
+    ws.onclose = () => {
+      if (!mountedRef.current) return;
+      setStatus('disconnected');
+      if (reconnectCount.current < MAX_RECONNECT) {
+        reconnectCount.current++;
+        reconnectTimer.current = setTimeout(connect, RECONNECT_DELAY * reconnectCount.current);
+      }
+    };
+  }, [widgetId, viewerUid, serverUrl, send, onMessage, onMessageAck, onChatPaused, onCallOffer, onCallAnswer, onIceCandidate, onCallEnd, onError, onUserStatus]);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    if (widgetId && viewerUid) connect();
+    return () => {
+      mountedRef.current = false;
+      if (reconnectTimer.current) clearTimeout(reconnectTimer.current);
+      wsRef.current?.close();
+    };
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [widgetId, viewerUid, serverUrl]);
+
+  const joinRoom = useCallback((roomId: string) => {
+    currentRoomRef.current = roomId;
+    send('join', { roomId, widgetId });
+  }, [send, widgetId]);
+
+  const leaveRoom = useCallback((roomId: string) => {
+    currentRoomRef.current = null;
+    send('leave', { roomId });
+  }, [send]);
+
+  const emitMessage = useCallback((msg: ChatMessage) => {
+    send('message', msg);
+  }, [send]);
+
+  const emitTypingStart = useCallback((roomId: string) => {
+    send('typing_start', { roomId, userId: viewerUid });
+  }, [send, viewerUid]);
+
+  const emitTypingStop = useCallback((roomId: string) => {
+    send('typing_stop', { roomId, userId: viewerUid });
+  }, [send, viewerUid]);
+
+  const emitPauseToggle = useCallback((roomId: string, targetUserId: string, paused: boolean) => {
+    send('chat:pause', { roomId, targetUserId, paused });
+  }, [send]);
+
+  const emitReport = useCallback((roomId: string, reason?: string) => {
+    send('chat:report', { roomId, reporterId: viewerUid, reason });
+  }, [send, viewerUid]);
+
+  const emitBlock = useCallback((blockedUid: string) => {
+    send('user:block', { blockedUid });
+  }, [send]);
+
+  const emitUnblock = useCallback((blockedUid: string) => {
+    send('user:unblock', { blockedUid });
+  }, [send]);
+
+  const emitTransfer = useCallback((fromRoomId: string, toUserId: string, note?: string) => {
+    send('transfer', { fromRoomId, toUserId, note });
+  }, [send]);
+
+  const emitCallOffer = useCallback((offer: RTCSessionDescriptionInit, toUid: string, callId: string) => {
+    send('call-offer', { offer, to: toUid, from: viewerUid, callId });
+  }, [send, viewerUid]);
+
+  const emitCallAnswer = useCallback((answer: RTCSessionDescriptionInit, toUid: string, callId: string) => {
+    send('call-answer', { answer, to: toUid, callId });
+  }, [send]);
+
+  const emitIceCandidate = useCallback((candidate: RTCIceCandidateInit, toUid: string) => {
+    send('ice-candidate', { candidate, to: toUid });
+  }, [send]);
+
+  const emitCallEnd = useCallback((callId: string, toUid?: string) => {
+    send('call-end', { callId, to: toUid });
+  }, [send]);
+
+  const emitAddParticipant = useCallback((roomId: string, uid: string) => {
+    send('room:add-participant', { roomId, uid });
+  }, [send]);
+
+  return {
+    status,
+    joinRoom, leaveRoom,
+    emitMessage, emitTypingStart, emitTypingStop,
+    emitPauseToggle, emitReport, emitBlock, emitUnblock, emitTransfer,
+    emitCallOffer, emitCallAnswer, emitIceCandidate, emitCallEnd,
+    emitAddParticipant,
+  };
+}

package/src/hooks/useWebRTC.ts

@@ -1,130 +1,165 @@
 import { useState, useRef, useCallback, useEffect } from 'react';
 import { CallSession, CallState, ChatUser } from '../types';
 
+export interface UseWebRTCOptions {
+  onOfferReady?: (offer: RTCSessionDescriptionInit, toUid: string, callId: string) => void;
+  onAnswerReady?: (answer: RTCSessionDescriptionInit, toUid: string, callId: string) => void;
+  onIceCandidateReady?: (candidate: RTCIceCandidateInit, toUid: string) => void;
+  onCallEnded?: (callId: string, toUid?: string) => void;
+}
+
 const ICE_SERVERS: RTCIceServer[] = [
   { urls: 'stun:stun.l.google.com:19302' },
   { urls: 'stun:stun1.l.google.com:19302' },
 ];
 
-export function useWebRTC() {
+export function useWebRTC(opts: UseWebRTCOptions = {}) {
+  const { onOfferReady, onAnswerReady, onIceCandidateReady, onCallEnded } = opts;
+
   const [session, setSession] = useState<CallSession>({
-    state:     'idle',
-    peer:      null,
-    startedAt: null,
-    isMuted:   false,
+    state:      'idle',
+    peer:       null,
+    startedAt:  null,
+    isMuted:    false,
     isCameraOn: false,
   });
 
-  const pcRef         = useRef<RTCPeerConnection | null>(null);
-  const localStream   = useRef<MediaStream | null>(null);
-  const localVideoRef = useRef<HTMLVideoElement | null>(null);
+  const pcRef          = useRef<RTCPeerConnection | null>(null);
+  const localStream    = useRef<MediaStream | null>(null);
+  const localVideoRef  = useRef<HTMLVideoElement | null>(null);
   const remoteVideoRef = useRef<HTMLVideoElement | null>(null);
+  const currentCallId  = useRef<string | null>(null);
+  const peerUidRef     = useRef<string | null>(null);
 
-  const updateSession = (patch: Partial<CallSession>) =>
-    setSession(prev => ({ ...prev, ...patch }));
-
-  /** Start an outgoing call */
-  const startCall = useCallback(async (peer: ChatUser, withVideo = false) => {
-    updateSession({ state: 'calling', peer });
-
-    const stream = await navigator.mediaDevices.getUserMedia({
-      audio: true,
-      video: withVideo,
-    });
-    localStream.current = stream;
-    if (localVideoRef.current) localVideoRef.current.srcObject = stream;
+  const updateSession = useCallback((patch: Partial<CallSession>) =>
+    setSession(prev => ({ ...prev, ...patch })), []);
 
+  const buildPc = useCallback((peer: ChatUser) => {
     const pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
     pcRef.current = pc;
-
-    stream.getTracks().forEach(t => pc.addTrack(t, stream));
+    peerUidRef.current = peer.uid;
 
     pc.ontrack = e => {
       if (remoteVideoRef.current) remoteVideoRef.current.srcObject = e.streams[0];
-      updateSession({ state: 'connected', startedAt: new Date(), isCameraOn: withVideo });
+      updateSession({ state: 'connected', startedAt: new Date() });
     };
 
     pc.onicecandidate = e => {
-      if (e.candidate) {
-        // TODO: socket.emit('ice-candidate', { candidate: e.candidate, to: peer.uid });
-        console.log('[WebRTC] ICE candidate ready — send via signalling:', e.candidate);
+      if (e.candidate && peerUidRef.current) {
+        onIceCandidateReady?.(e.candidate.toJSON(), peerUidRef.current);
       }
     };
 
-    const offer = await pc.createOffer();
-    await pc.setLocalDescription(offer);
-    // TODO: socket.emit('call-offer', { offer, to: peer.uid, from: 'me' });
-    console.log('[WebRTC] Offer created — send via signalling server:', offer);
-  }, []);
+    pc.onconnectionstatechange = () => {
+      if (pc.connectionState === 'failed' || pc.connectionState === 'disconnected') {
+        updateSession({ state: 'ended' });
+        setTimeout(() => updateSession({ state: 'idle' }), 1800);
+      }
+    };
+
+    return pc;
+  }, [onIceCandidateReady, updateSession]);
+
+  const startCall = useCallback(async (peer: ChatUser, withVideo = false) => {
+    const callId = `call_${Date.now()}`;
+    currentCallId.current = callId;
+    updateSession({ state: 'calling', peer });
+
+    let stream: MediaStream;
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: withVideo });
+    } catch (err) {
+      console.error('[WebRTC] getUserMedia failed:', err);
+      updateSession({ state: 'idle' });
+      return;
+    }
+    localStream.current = stream;
+    if (localVideoRef.current) localVideoRef.current.srcObject = stream;
+
+    const pc = buildPc(peer);
+    stream.getTracks().forEach(t => pc.addTrack(t, stream));
+
+    try {
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      onOfferReady?.(offer, peer.uid, callId);
+      updateSession({ isCameraOn: withVideo });
+    } catch (err) {
+      console.error('[WebRTC] createOffer failed:', err);
+    }
+  }, [buildPc, onOfferReady, updateSession]);
 
-  /** Accept an incoming call offer */
   const acceptCall = useCallback(async (
     offer: RTCSessionDescriptionInit,
     peer: ChatUser,
+    callId: string,
     withVideo = false
   ) => {
+    currentCallId.current = callId;
     updateSession({ state: 'connected', peer, startedAt: new Date(), isCameraOn: withVideo });
 
-    const stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: withVideo });
+    let stream: MediaStream;
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: withVideo });
+    } catch (err) {
+      console.error('[WebRTC] getUserMedia failed:', err);
+      return;
+    }
     localStream.current = stream;
     if (localVideoRef.current) localVideoRef.current.srcObject = stream;
 
-    const pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
-    pcRef.current = pc;
+    const pc = buildPc(peer);
     stream.getTracks().forEach(t => pc.addTrack(t, stream));
-    pc.ontrack = e => {
-      if (remoteVideoRef.current) remoteVideoRef.current.srcObject = e.streams[0];
-    };
-    pc.onicecandidate = e => {
-      if (e.candidate) {
-        // TODO: socket.emit('ice-candidate', { candidate: e.candidate, to: peer.uid });
-      }
-    };
 
     await pc.setRemoteDescription(offer);
     const answer = await pc.createAnswer();
     await pc.setLocalDescription(answer);
-    // TODO: socket.emit('call-answer', { answer, to: peer.uid });
+    onAnswerReady?.(answer, peer.uid, callId);
+  }, [buildPc, onAnswerReady, updateSession]);
+
+  const addIceCandidate = useCallback(async (candidate: RTCIceCandidateInit) => {
+    try {
+      await pcRef.current?.addIceCandidate(new RTCIceCandidate(candidate));
+    } catch (err) {
+      console.warn('[WebRTC] addIceCandidate failed:', err);
+    }
   }, []);
 
-  /** Hang up */
   const endCall = useCallback(() => {
+    const callId = currentCallId.current;
+    const peerUid = peerUidRef.current ?? undefined;
     localStream.current?.getTracks().forEach(t => t.stop());
     pcRef.current?.close();
     pcRef.current = null;
     localStream.current = null;
+    currentCallId.current = null;
+    if (callId) onCallEnded?.(callId, peerUid);
     updateSession({ state: 'ended', peer: null, startedAt: null });
     setTimeout(() => updateSession({ state: 'idle' }), 1800);
-  }, []);
+  }, [onCallEnded, updateSession]);
 
   const toggleMute = useCallback(() => {
     if (!localStream.current) return;
-    const enabled = !session.isMuted;
-    localStream.current.getAudioTracks().forEach(t => { t.enabled = enabled; });
-    updateSession({ isMuted: !session.isMuted });
-  }, [session.isMuted]);
+    const muted = !session.isMuted;
+    localStream.current.getAudioTracks().forEach(t => { t.enabled = !muted; });
+    updateSession({ isMuted: muted });
+  }, [session.isMuted, updateSession]);
 
   const toggleCamera = useCallback(() => {
     if (!localStream.current) return;
-    const enabled = !session.isCameraOn;
-    localStream.current.getVideoTracks().forEach(t => { t.enabled = enabled; });
-    updateSession({ isCameraOn: enabled });
-  }, [session.isCameraOn]);
+    const on = !session.isCameraOn;
+    localStream.current.getVideoTracks().forEach(t => { t.enabled = on; });
+    updateSession({ isCameraOn: on });
+  }, [session.isCameraOn, updateSession]);
 
-  // Cleanup on unmount
   useEffect(() => () => {
     localStream.current?.getTracks().forEach(t => t.stop());
     pcRef.current?.close();
   }, []);
 
   return {
-    session,
-    localVideoRef,
-    remoteVideoRef,
-    startCall,
-    acceptCall,
-    endCall,
-    toggleMute,
-    toggleCamera,
+    session, localVideoRef, remoteVideoRef,
+    startCall, acceptCall, addIceCandidate, endCall,
+    toggleMute, toggleCamera,
   };
 }

package/src/index.ts

@@ -10,10 +10,12 @@ export { MaintenanceView }    from './components/MaintenanceView';
 export { BottomTabs }         from './components/Tabs/BottomTabs';
 export { EmojiPicker }        from './components/EmojiPicker';
 export { SlideNavMenu }       from './components/SlideNavMenu';
+export { ErrorBoundary }      from './components/ErrorBoundary';
 
 export { useChat }            from './hooks/useChat';
 export { useWebRTC }          from './hooks/useWebRTC';
 export { useRemoteConfig }    from './hooks/useRemoteConfig';
+export { useSocket }          from './hooks/useSocket';
 
 export { shouldShowPrivacyNotice, dismissPrivacyNotice, getPrivacyDismissedAt } from './utils/privacyConsent';
 export { submitReenableRequest } from './utils/reenableRequest';
@@ -31,6 +33,9 @@ export type {
   CallSession, CallState,
   ChatStatus, ChatType, UserType, OnlineStatus,
   Screen, BottomTab, UserListContext, MessageType,
-  LocalEnvConfig,
-  PresenceStatus,
+  LocalEnvConfig, PresenceStatus,
 } from './types';
+
+export type { UseSocketOptions, SocketStatus, SocketMessageAck } from './hooks/useSocket';
+export type { UseChatOptions } from './hooks/useChat';
+export type { UseWebRTCOptions } from './hooks/useWebRTC';