@enfin/chat 1.2.0

package/dist/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/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/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/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/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/hooks/usePresence.d.ts

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

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