@enfin/chat 1.2.0

package/dist/esm/hooks/useCall.js

@@ -0,0 +1,38 @@
+import { useCallback } from 'react';
+import { useChatContext } from '../context/ChatContext';
+export function useCall() {
+    const { activeCall, callState, callError, remoteStream, isMuted, busyBanner, clearBusyBanner, startCall, endCall, acceptCall, rejectCall, mute, unmute, } = useChatContext();
+    const handleStartCall = useCallback(async (roomId, participantId) => {
+        await startCall(roomId, participantId);
+    }, [startCall]);
+    const handleEndCall = useCallback(async () => {
+        await endCall();
+    }, [endCall]);
+    const handleAcceptCall = useCallback(async () => {
+        await acceptCall();
+    }, [acceptCall]);
+    const handleRejectCall = useCallback(async () => {
+        await rejectCall();
+    }, [rejectCall]);
+    const handleMute = useCallback(() => {
+        mute();
+    }, [mute]);
+    const handleUnmute = useCallback(() => {
+        unmute();
+    }, [unmute]);
+    return {
+        activeCall,
+        callState,
+        callError,
+        remoteStream,
+        busyBanner,
+        clearBusyBanner,
+        startCall: handleStartCall,
+        endCall: handleEndCall,
+        acceptCall: handleAcceptCall,
+        rejectCall: handleRejectCall,
+        mute: handleMute,
+        unmute: handleUnmute,
+        isMuted,
+    };
+}

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

@@ -0,0 +1,23 @@
+export declare function useChat(): {
+    userId: string;
+    userName: string;
+    messages: import("@enfin/chat-shared").Message[];
+    rooms: import("@enfin/chat-shared").Room[];
+    users: import("../context/ChatContext").ChatUser[];
+    currentRoom: import("@enfin/chat-shared").Room;
+    typingUsers: import("@enfin/chat-shared").PresenceStatus[];
+    connected: boolean;
+    loading: boolean;
+    sending: boolean;
+    error: string;
+    sendMessage: (roomId: string, content: string, fileMetadata?: {
+        fileUrl?: string;
+        fileType?: string;
+        fileName?: string;
+    }) => Promise<void>;
+    selectRoom: (roomId: string) => void;
+    refreshUsers: () => Promise<void>;
+    emitTyping: (roomId: string, typing: boolean) => void;
+    debouncedEmitTyping: (roomId: string, typing: boolean) => void;
+    stopTypingSoon: (roomId: string) => void;
+};

package/dist/esm/hooks/useChat.js

@@ -0,0 +1,40 @@
+import { useState, useCallback } from 'react';
+import { useChatContext } from '../context/ChatContext';
+export function useChat() {
+    const { userId, userName, messages, rooms, users, currentRoom, typingUsers, connected, loading, error, sendMessage, selectRoom, refreshUsers, emitTyping, debouncedEmitTyping, stopTypingSoon, } = useChatContext();
+    const [sending, setSending] = useState(false);
+    const handleSendMessage = useCallback(async (roomId, content, fileMetadata) => {
+        setSending(true);
+        try {
+            await sendMessage(roomId, content, fileMetadata);
+        }
+        finally {
+            setSending(false);
+        }
+    }, [sendMessage]);
+    const handleSelectRoom = useCallback((roomId) => {
+        selectRoom(roomId);
+    }, [selectRoom]);
+    const filteredMessages = currentRoom
+        ? messages.filter(m => m.roomId === currentRoom._id)
+        : [];
+    return {
+        userId,
+        userName,
+        messages: filteredMessages,
+        rooms,
+        users,
+        currentRoom,
+        typingUsers,
+        connected,
+        loading,
+        sending,
+        error,
+        sendMessage: handleSendMessage,
+        selectRoom: handleSelectRoom,
+        refreshUsers,
+        emitTyping,
+        debouncedEmitTyping,
+        stopTypingSoon,
+    };
+}

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

@@ -0,0 +1,17 @@
+import { Message } from '@enfin/chat-shared';
+interface UseMessagesOptions {
+    roomId: string;
+    limit?: number;
+    autoFetch?: boolean;
+}
+export declare function useMessages(options: UseMessagesOptions): {
+    messages: Message[];
+    loading: boolean;
+    currentRoom: import("@enfin/chat-shared").Room;
+    sendMessage: (content: string, fileMetadata?: {
+        fileUrl?: string;
+        fileType?: string;
+        fileName?: string;
+    }) => Promise<void>;
+};
+export {};

package/dist/esm/hooks/useMessages.js

@@ -0,0 +1,38 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { useChatContext } from '../context/ChatContext';
+export function useMessages(options) {
+    const { messages: allMessages, currentRoom, loading, sendMessage, loadRoomMessages, connected, } = useChatContext();
+    const { roomId: targetRoomId, autoFetch = true, } = options;
+    // Live updates: filter messages for the target room. Since the SDK keeps
+    // a single shared message state in context, any consumer of useMessages
+    // automatically receives new messages from socket `message:new` events.
+    const roomMessages = allMessages.filter(m => m.roomId === targetRoomId);
+    // Track whether we've already fetched the initial history for this room.
+    const fetchedForRoomRef = useRef(null);
+    useEffect(() => {
+        if (!autoFetch || !connected)
+            return;
+        if (fetchedForRoomRef.current === targetRoomId)
+            return;
+        fetchedForRoomRef.current = targetRoomId;
+        loadRoomMessages(targetRoomId);
+    }, [autoFetch, connected, targetRoomId, loadRoomMessages]);
+    // Reset the fetched-marker when the roomId changes so refetch happens.
+    useEffect(() => {
+        return () => {
+            fetchedForRoomRef.current = null;
+        };
+    }, [targetRoomId]);
+    const handleSend = useCallback(async (content, fileMetadata) => {
+        if (!currentRoom || currentRoom._id !== targetRoomId) {
+            throw new Error('Cannot send message to a different room');
+        }
+        await sendMessage(targetRoomId, content, fileMetadata);
+    }, [currentRoom, targetRoomId, sendMessage]);
+    return {
+        messages: roomMessages,
+        loading,
+        currentRoom: currentRoom?._id === targetRoomId ? currentRoom : undefined,
+        sendMessage: handleSend,
+    };
+}

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

@@ -0,0 +1,4 @@
+export declare function usePresence(): {
+    users: import("../context/ChatContext").ChatUser[];
+    refreshUsers: () => Promise<void>;
+};

package/dist/esm/hooks/usePresence.js

@@ -0,0 +1,12 @@
+import { useCallback } from 'react';
+import { useChatContext } from '../context/ChatContext';
+export function usePresence() {
+    const { users, refreshUsers } = useChatContext();
+    const handleRefreshUsers = useCallback(async () => {
+        await refreshUsers();
+    }, [refreshUsers]);
+    return {
+        users,
+        refreshUsers: handleRefreshUsers,
+    };
+}

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

@@ -0,0 +1,9 @@
+import { Room } from '@enfin/chat-shared';
+export declare function useRooms(): {
+    rooms: Room[];
+    currentRoom: Room;
+    loading: boolean;
+    connected: boolean;
+    createRoom: (name: string, type: "direct" | "group", members: string[]) => Promise<Room>;
+    selectRoom: (roomId: string) => void;
+};

package/dist/esm/hooks/useRooms.js

@@ -0,0 +1,19 @@
+import { useCallback } from 'react';
+import { useChatContext } from '../context/ChatContext';
+export function useRooms() {
+    const { rooms, currentRoom, loading, connected, createRoom, selectRoom, } = useChatContext();
+    const handleCreateRoom = useCallback(async (name, type, members) => {
+        return createRoom(name, type, members);
+    }, [createRoom]);
+    const handleSelectRoom = useCallback((roomId) => {
+        selectRoom(roomId);
+    }, [selectRoom]);
+    return {
+        rooms,
+        currentRoom,
+        loading,
+        connected,
+        createRoom: handleCreateRoom,
+        selectRoom: handleSelectRoom,
+    };
+}

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

@@ -0,0 +1,7 @@
+export declare function useSocket(): {
+    emit: <T = any>(event: string, data?: T) => Promise<unknown>;
+    on: (event: string, callback: (data: any) => void) => () => void;
+    off: (event: string, callback?: (data: any) => void) => void;
+    onAny: (callback: (event: string, ...args: any[]) => void) => () => void;
+    connected: any;
+};

package/dist/esm/hooks/useSocket.js

@@ -0,0 +1,92 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useChatContext } from '../context/ChatContext';
+export function useSocket() {
+    const { socket } = useChatContext();
+    const [socketState, setSocketState] = useState(socket);
+    const cleanupRefs = useRef(new Map());
+    const callbackIdRef = useRef(0);
+    // Keep the live socket ref in sync
+    useEffect(() => {
+        setSocketState(socket);
+        return () => {
+            // Cleanup any listeners when socket changes
+            cleanupRefs.current.forEach(cleanup => cleanup());
+            cleanupRefs.current.clear();
+        };
+    }, [socket]);
+    const emit = useCallback((event, data) => {
+        if (!socketState?.connected) {
+            console.warn(`[useSocket] Cannot emit '${event}' — socket not connected`);
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            socketState.emit(event, data, (err, ...args) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(args[0]);
+            });
+        });
+    }, [socketState]);
+    const on = useCallback((event, callback) => {
+        if (!socketState?.connected) {
+            console.warn(`[useSocket] Cannot listen on '${event}' — socket not connected`);
+            return () => { };
+        }
+        // Generate a unique ID for this listener
+        const listenerId = `${event}-${callbackIdRef.current++}`;
+        const wrappedCallback = (data) => {
+            callback(data);
+        };
+        // Add the listener
+        socketState.on(event, wrappedCallback);
+        // Store cleanup function
+        const cleanup = () => {
+            socketState.off(event, wrappedCallback);
+            cleanupRefs.current.delete(listenerId);
+        };
+        cleanupRefs.current.set(listenerId, cleanup);
+        // Return cleanup function
+        return cleanup;
+    }, [socketState]);
+    const off = useCallback((event, callback) => {
+        if (!socketState?.connected) {
+            console.warn(`[useSocket] Cannot unlisten from '${event}' — socket not connected`);
+            return;
+        }
+        if (callback) {
+            // If callback is provided, remove it specifically
+            socketState.off(event, callback);
+            // Also remove any related cleanup refs
+            cleanupRefs.current.forEach((cleanup, key) => {
+                if (key.startsWith(`${event}-`))
+                    cleanup();
+            });
+        }
+        else {
+            // Remove all listeners for this event
+            socketState.removeAllListeners(event);
+            cleanupRefs.current.forEach((cleanup, key) => {
+                if (key.startsWith(`${event}-`))
+                    cleanup();
+            });
+        }
+    }, [socketState]);
+    // Helper for listening to all socket events via window events
+    const onAny = useCallback((callback) => {
+        const handler = (e) => {
+            callback(e.detail.event, e.detail.data);
+        };
+        window.addEventListener('chat:socket-event', handler);
+        return () => {
+            window.removeEventListener('chat:socket-event', handler);
+        };
+    }, []);
+    return {
+        emit,
+        on,
+        off,
+        onAny,
+        connected: socketState?.connected || false,
+    };
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,11 @@
+export * from '@enfin/chat-shared';
+export { ChatProvider, useChatContext } from './context/ChatContext';
+export type { ChatUser } from './context/ChatContext';
+export { useChat, useRooms, useMessages, useCall, useSocket, usePresence } from './hooks';
+import { Chat } from './components';
+export { Chat };
+export type { ChatProps } from './components';
+export default Chat;
+export * from './utils';
+export type { Message, Room, PresenceStatus, AudioCall, ChatConfig, } from '@enfin/chat-shared';
+export declare const SDK_VERSION = "1.0.0";

package/dist/esm/index.js

@@ -0,0 +1,15 @@
+// @enfin/chat - React Frontend SDK
+// ============================================
+export * from '@enfin/chat-shared';
+// Context & Provider
+export { ChatProvider, useChatContext } from './context/ChatContext';
+// Hooks
+export { useChat, useRooms, useMessages, useCall, useSocket, usePresence } from './hooks';
+// Default UI Components
+import { Chat } from './components';
+export { Chat };
+export default Chat;
+// Utilities (including test utilities)
+export * from './utils';
+// SDK Version
+export const SDK_VERSION = '1.0.0';

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

@@ -0,0 +1,2 @@
+export * from './testUtils';
+export * from './ringtone';

package/dist/esm/utils/index.js

@@ -0,0 +1,2 @@
+export * from './testUtils';
+export * from './ringtone';

package/dist/esm/utils/ringtone.d.ts

@@ -0,0 +1,2 @@
+export declare function startRingtone(url?: string): void;
+export declare function stopRingtone(): void;

package/dist/esm/utils/ringtone.js

@@ -0,0 +1,39 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+import defaultRingtoneUrl from '../assets/music/i_phone_message.mp3';
+let audioEl = null;
+let currentUrl = null;
+function getAudio(url) {
+    const target = url || defaultRingtoneUrl;
+    if (!audioEl || currentUrl !== target) {
+        if (audioEl) {
+            audioEl.pause();
+            audioEl.src = '';
+        }
+        audioEl = new Audio(target);
+        audioEl.loop = true;
+        audioEl.preload = 'auto';
+        currentUrl = target;
+    }
+    return audioEl;
+}
+export function startRingtone(url) {
+    try {
+        const audio = getAudio(url);
+        audio.currentTime = 0;
+        const playPromise = audio.play();
+        if (playPromise && typeof playPromise.catch === 'function') {
+            playPromise.catch((err) => {
+                console.log('[RINGTONE] play() rejected:', err?.message || err);
+            });
+        }
+    }
+    catch (err) {
+        console.log('[RINGTONE] start failed:', err?.message || err);
+    }
+}
+export function stopRingtone() {
+    if (!audioEl)
+        return;
+    audioEl.pause();
+    audioEl.currentTime = 0;
+}

package/dist/esm/utils/testUtils.d.ts

@@ -0,0 +1,102 @@
+import { Socket } from 'socket.io-client';
+/**
+ * Test utilities for developers to create test users and simulate interactions
+ *
+ * This utility allows developers to:
+ * 1. Create multiple test users that can chat with each other
+ * 2. Send messages between test users
+ * 3. Make audio calls between test users
+ * 4. Test custom socket events
+ */
+export interface TestUser {
+    id: string;
+    name: string;
+    socket: Socket;
+    rooms: string[];
+}
+/**
+ * Create a test user with automatic socket connection
+ *
+ * @param serverUrl - Chat server URL
+ * @param userId - User ID (optional, generated if not provided)
+ * @param userName - User name
+ * @returns Test user object with socket connection
+ */
+export declare function createTestUser(serverUrl: string, userName: string, userId?: string): TestUser;
+/**
+ * Create multiple test users for testing
+ *
+ * @param serverUrl - Chat server URL
+ * @param userNames - Array of user names
+ * @returns Array of test users
+ */
+export declare function createTestUsers(serverUrl: string, userNames: string[]): TestUser[];
+/**
+ * Create a test room between users
+ *
+ * @param users - Users to add to the room
+ * @param roomName - Room name
+ * @param isDirect - Whether this is a direct chat
+ * @returns Promise resolving to the created room
+ */
+export declare function createTestRoom(users: TestUser[], roomName: string, isDirect?: boolean): Promise<any>;
+/**
+ * Send a message from one user to another
+ *
+ * @param from - Sending user
+ * @param roomId - Room ID
+ * @param content - Message content
+ * @returns Promise resolving when message is sent
+ */
+export declare function sendMessage(from: TestUser, roomId: string, content: string): Promise<any>;
+/**
+ * Start an audio call
+ *
+ * @param from - Initiating user
+ * @param to - Target user
+ * @param roomId - Room ID
+ * @returns Promise resolving when call is initiated
+ */
+export declare function startCall(from: TestUser, to: TestUser, roomId: string): Promise<any>;
+/**
+ * Accept an incoming call
+ *
+ * @param to - User accepting call
+ * @param callId - Call ID
+ * @returns Promise resolving when call is accepted
+ */
+export declare function acceptCall(to: TestUser, callId: string): Promise<any>;
+/**
+ * End a call
+ *
+ * @param by - User ending call
+ * @param callId - Call ID
+ * @returns Promise resolving when call is ended
+ */
+export declare function endCall(by: TestUser, callId: string): Promise<any>;
+/**
+ * Listen for socket events (useful for testing)
+ *
+ * @param socket - Socket to listen on
+ * @param event - Event name
+ * @param callback - Callback function
+ * @returns Cleanup function to remove listener
+ */
+export declare function onSocketEvent(socket: Socket, event: string, callback: (data: any) => void): () => void;
+/**
+ * Listen to custom socket events (exposed by ChatProvider)
+ *
+ * @param eventName - Event name to listen to
+ * @param callback - Callback function
+ * @returns Cleanup function
+ */
+export declare function onCustomSocketEvent(eventName: string, callback: (data: any) => void): () => void;
+/**
+ * Emit custom event through the socket
+ *
+ * @param user - User to emit from
+ * @param event - Event name
+ * @param data - Event data
+ * @returns Promise resolving when event is sent
+ */
+export declare function emitCustomEvent(user: TestUser, event: string, data?: any): Promise<any>;

package/dist/esm/utils/testUtils.js

@@ -0,0 +1,153 @@
+import io from 'socket.io-client';
+/**
+ * Create a test user with automatic socket connection
+ *
+ * @param serverUrl - Chat server URL
+ * @param userId - User ID (optional, generated if not provided)
+ * @param userName - User name
+ * @returns Test user object with socket connection
+ */
+export function createTestUser(serverUrl, userName, userId) {
+    const id = userId || `user_${Math.random().toString(36).substr(2, 9)}`;
+    const socket = io(`${serverUrl}/chat`, {
+        auth: { userId: id, userName, tenantId: id },
+        transports: ['websocket'],
+    });
+    return {
+        id,
+        name: userName,
+        socket,
+        rooms: [],
+    };
+}
+/**
+ * Create multiple test users for testing
+ *
+ * @param serverUrl - Chat server URL
+ * @param userNames - Array of user names
+ * @returns Array of test users
+ */
+export function createTestUsers(serverUrl, userNames) {
+    return userNames.map((name, index) => {
+        const userId = `test_user_${String(index + 1).padStart(2, '0')}`;
+        return createTestUser(serverUrl, name, userId);
+    });
+}
+/**
+ * Create a test room between users
+ *
+ * @param users - Users to add to the room
+ * @param roomName - Room name
+ * @param isDirect - Whether this is a direct chat
+ * @returns Promise resolving to the created room
+ */
+export async function createTestRoom(users, roomName, isDirect = false) {
+    const roomId = `room_${Date.now()}`;
+    if (isDirect && users.length !== 2) {
+        throw new Error('Direct rooms require exactly 2 users');
+    }
+    // Create room (first user creates it)
+    await users[0].socket.emitWithAck('room:create', {
+        name: roomName,
+        type: isDirect ? 'direct' : 'group',
+        members: users.map(u => u.id),
+    });
+    // Wait a bit for room to propagate
+    await new Promise(resolve => setTimeout(resolve, 100));
+    // Join all users to the room
+    for (const user of users) {
+        await user.socket.emitWithAck('join', { roomId: roomId });
+        user.rooms.push(roomId);
+    }
+    return { id: roomId, name: roomName, type: isDirect ? 'direct' : 'group' };
+}
+/**
+ * Send a message from one user to another
+ *
+ * @param from - Sending user
+ * @param roomId - Room ID
+ * @param content - Message content
+ * @returns Promise resolving when message is sent
+ */
+export async function sendMessage(from, roomId, content) {
+    return from.socket.emitWithAck('message:send', {
+        roomId,
+        content,
+    });
+}
+/**
+ * Start an audio call
+ *
+ * @param from - Initiating user
+ * @param to - Target user
+ * @param roomId - Room ID
+ * @returns Promise resolving when call is initiated
+ */
+export async function startCall(from, to, roomId) {
+    return from.socket.emitWithAck('call:initiate', {
+        roomId,
+        participantId: to.id,
+    });
+}
+/**
+ * Accept an incoming call
+ *
+ * @param to - User accepting call
+ * @param callId - Call ID
+ * @returns Promise resolving when call is accepted
+ */
+export async function acceptCall(to, callId) {
+    return to.socket.emitWithAck('call:accept', { callId });
+}
+/**
+ * End a call
+ *
+ * @param by - User ending call
+ * @param callId - Call ID
+ * @returns Promise resolving when call is ended
+ */
+export async function endCall(by, callId) {
+    return by.socket.emitWithAck('call:end', { callId });
+}
+/**
+ * Listen for socket events (useful for testing)
+ *
+ * @param socket - Socket to listen on
+ * @param event - Event name
+ * @param callback - Callback function
+ * @returns Cleanup function to remove listener
+ */
+export function onSocketEvent(socket, event, callback) {
+    socket.on(event, callback);
+    return () => socket.off(event, callback);
+}
+/**
+ * Listen to custom socket events (exposed by ChatProvider)
+ *
+ * @param eventName - Event name to listen to
+ * @param callback - Callback function
+ * @returns Cleanup function
+ */
+export function onCustomSocketEvent(eventName, callback) {
+    const handler = (event) => {
+        if (event.detail.event === eventName) {
+            callback(event.detail.data);
+        }
+    };
+    window.addEventListener('chat:socket-event', handler);
+    return () => window.removeEventListener('chat:socket-event', handler);
+}
+/**
+ * Emit custom event through the socket
+ *
+ * @param user - User to emit from
+ * @param event - Event name
+ * @param data - Event data
+ * @returns Promise resolving when event is sent
+ */
+export function emitCustomEvent(user, event, data) {
+    if (user.socket.connected) {
+        return user.socket.emitWithAck(event, data);
+    }
+    return Promise.reject('Socket not connected');
+}

package/dist/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/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/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;
+};