indas-ui 0.0.1 → 0.1.1

package/dist/cjs/contexts/MessagingContext.js

@@ -0,0 +1,726 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagingProvider = MessagingProvider;
+exports.useMessaging = useMessaging;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const signalr_1 = require("@microsoft/signalr");
+const react_2 = require("next-auth/react");
+const messaging_1 = require("../lib/api/activity/messaging/messaging.js");
+const messaging_2 = require("../lib/api/activity/messaging/messaging.js");
+const config_1 = require("../lib/api/core/config.js");
+// ─── Initial State ──────────────────────────────────────────────────────────
+const initialState = {
+    conversations: [],
+    activeRoomId: null,
+    messages: {},
+    threadMessages: {},
+    contacts: [],
+    onlineUsers: new Set(),
+    typingUsers: {},
+    readReceipts: {},
+    unreadCounts: {},
+    totalUnreadCount: 0,
+    loadingConversations: false,
+    loadingMessages: false,
+    loadingThread: false,
+    sendingMessage: false,
+    messagePagination: {},
+    searchQuery: '',
+    searchResults: [],
+    searchLoading: false,
+    activeThreadId: null,
+    error: null
+};
+// ─── Reducer ────────────────────────────────────────────────────────────────
+function messagingReducer(state, action) {
+    switch (action.type) {
+        case 'SET_CONVERSATIONS':
+            return { ...state, conversations: action.payload };
+        case 'UPDATE_CONVERSATION': {
+            return {
+                ...state,
+                conversations: state.conversations.map(c => c.RoomID === action.payload.roomId ? { ...c, ...action.payload.updates } : c)
+            };
+        }
+        case 'ADD_CONVERSATION':
+            return {
+                ...state,
+                conversations: [action.payload, ...state.conversations.filter(c => c.RoomID !== action.payload.RoomID)]
+            };
+        case 'SET_ACTIVE_ROOM':
+            return { ...state, activeRoomId: action.payload };
+        case 'SET_MESSAGES':
+            return {
+                ...state,
+                messages: { ...state.messages, [action.payload.roomId]: action.payload.messages },
+                messagePagination: {
+                    ...state.messagePagination,
+                    [action.payload.roomId]: { page: action.payload.page, hasMore: action.payload.hasMore }
+                }
+            };
+        case 'APPEND_MESSAGES': {
+            const existing = state.messages[action.payload.roomId] || [];
+            const existingIds = new Set(existing.map(m => m.MessageID));
+            const newMsgs = action.payload.messages.filter(m => !existingIds.has(m.MessageID));
+            return {
+                ...state,
+                messages: { ...state.messages, [action.payload.roomId]: [...newMsgs, ...existing] },
+                messagePagination: {
+                    ...state.messagePagination,
+                    [action.payload.roomId]: { page: action.payload.page, hasMore: action.payload.hasMore }
+                }
+            };
+        }
+        case 'ADD_MESSAGE': {
+            const existing = state.messages[action.payload.roomId] || [];
+            // Avoid duplicates
+            if (existing.some(m => m.MessageID === action.payload.message.MessageID))
+                return state;
+            return {
+                ...state,
+                messages: {
+                    ...state.messages,
+                    [action.payload.roomId]: [...existing, action.payload.message]
+                }
+            };
+        }
+        case 'UPDATE_MESSAGE': {
+            const msgs = state.messages[action.payload.roomId];
+            if (!msgs)
+                return state;
+            return {
+                ...state,
+                messages: {
+                    ...state.messages,
+                    [action.payload.roomId]: msgs.map(m => m.MessageID === action.payload.messageId ? { ...m, ...action.payload.updates } : m)
+                }
+            };
+        }
+        case 'DELETE_MESSAGE': {
+            const msgs = state.messages[action.payload.roomId];
+            if (!msgs)
+                return state;
+            return {
+                ...state,
+                messages: {
+                    ...state.messages,
+                    [action.payload.roomId]: msgs.map(m => m.MessageID === action.payload.messageId ? { ...m, IsDeleted: true, Content: null } : m)
+                }
+            };
+        }
+        case 'SET_THREAD_MESSAGES':
+            return { ...state, threadMessages: { ...state.threadMessages, [action.payload.parentId]: action.payload.messages } };
+        case 'ADD_THREAD_MESSAGE': {
+            const existing = state.threadMessages[action.payload.parentId] || [];
+            if (existing.some(m => m.MessageID === action.payload.message.MessageID))
+                return state;
+            return {
+                ...state,
+                threadMessages: {
+                    ...state.threadMessages,
+                    [action.payload.parentId]: [...existing, action.payload.message]
+                }
+            };
+        }
+        case 'SET_CONTACTS':
+            return { ...state, contacts: action.payload };
+        case 'SET_ONLINE_USERS':
+            return { ...state, onlineUsers: action.payload };
+        case 'USER_ONLINE': {
+            const next = new Set(state.onlineUsers);
+            next.add(action.payload);
+            return { ...state, onlineUsers: next };
+        }
+        case 'USER_OFFLINE': {
+            const next = new Set(state.onlineUsers);
+            next.delete(action.payload);
+            return { ...state, onlineUsers: next };
+        }
+        case 'SET_TYPING': {
+            const { roomId, userId, isTyping } = action.payload;
+            const current = state.typingUsers[roomId] || [];
+            const next = isTyping
+                ? current.includes(userId) ? current : [...current, userId]
+                : current.filter(id => id !== userId);
+            return { ...state, typingUsers: { ...state.typingUsers, [roomId]: next } };
+        }
+        case 'SET_READ_RECEIPT': {
+            const { roomId, userId, lastReadMessageId } = action.payload;
+            const room = state.readReceipts[roomId] || {};
+            // Only advance — never move a read marker backwards.
+            if ((room[userId] || 0) >= lastReadMessageId)
+                return state;
+            return {
+                ...state,
+                readReceipts: { ...state.readReceipts, [roomId]: { ...room, [userId]: lastReadMessageId } }
+            };
+        }
+        case 'SET_UNREAD_COUNTS': {
+            const total = Object.values(action.payload).reduce((sum, c) => sum + c, 0);
+            return { ...state, unreadCounts: action.payload, totalUnreadCount: total };
+        }
+        case 'CLEAR_UNREAD': {
+            const prev = state.unreadCounts[action.payload] || 0;
+            const next = { ...state.unreadCounts, [action.payload]: 0 };
+            return { ...state, unreadCounts: next, totalUnreadCount: Math.max(0, state.totalUnreadCount - prev) };
+        }
+        case 'INCREMENT_UNREAD': {
+            const current = state.unreadCounts[action.payload] || 0;
+            const next = { ...state.unreadCounts, [action.payload]: current + 1 };
+            return { ...state, unreadCounts: next, totalUnreadCount: state.totalUnreadCount + 1 };
+        }
+        case 'SET_LOADING_CONVERSATIONS':
+            return { ...state, loadingConversations: action.payload };
+        case 'SET_LOADING_MESSAGES':
+            return { ...state, loadingMessages: action.payload };
+        case 'SET_LOADING_THREAD':
+            return { ...state, loadingThread: action.payload };
+        case 'SET_SENDING_MESSAGE':
+            return { ...state, sendingMessage: action.payload };
+        case 'SET_SEARCH_QUERY':
+            return { ...state, searchQuery: action.payload };
+        case 'SET_SEARCH_RESULTS':
+            return { ...state, searchResults: action.payload };
+        case 'SET_SEARCH_LOADING':
+            return { ...state, searchLoading: action.payload };
+        case 'SET_ACTIVE_THREAD':
+            return { ...state, activeThreadId: action.payload };
+        case 'SET_ERROR':
+            return { ...state, error: action.payload };
+        default:
+            return state;
+    }
+}
+const MessagingContext = (0, react_1.createContext)(undefined);
+// ─── Provider ───────────────────────────────────────────────────────────────
+function MessagingProvider({ children }) {
+    const { data: session } = (0, react_2.useSession)();
+    const [state, dispatch] = (0, react_1.useReducer)(messagingReducer, initialState);
+    const stateRef = (0, react_1.useRef)(state);
+    stateRef.current = state;
+    const currentUserId = String(session?.user?.UserID || session?.user?.userID || '');
+    // ─── SignalR Callbacks ──────────────────────────────────────────────────
+    const signalRCallbacks = {
+        onReceiveMessage: (0, react_1.useCallback)((data) => {
+            if (!data?.message)
+                return;
+            const msg = data.message;
+            const roomId = data.roomId;
+            // Add to room messages
+            dispatch({ type: 'ADD_MESSAGE', payload: { roomId, message: msg } });
+            // Update conversation preview
+            dispatch({
+                type: 'UPDATE_CONVERSATION',
+                payload: {
+                    roomId,
+                    updates: {
+                        LastMessageAt: msg.CreatedAt,
+                        LastMessagePreview: msg.Content?.substring(0, 100) || null,
+                        LastMessageBy: msg.UserID
+                    }
+                }
+            });
+            // If thread reply, add to thread messages
+            if (data.parentMessageId) {
+                dispatch({ type: 'ADD_THREAD_MESSAGE', payload: { parentId: data.parentMessageId, message: msg } });
+            }
+            // Increment unread if not the active room or sender is not current user
+            if (String(msg.UserID) !== currentUserId &&
+                stateRef.current.activeRoomId !== roomId) {
+                dispatch({ type: 'INCREMENT_UNREAD', payload: roomId });
+            }
+            // Clear typing indicator for sender
+            dispatch({ type: 'SET_TYPING', payload: { roomId, userId: String(msg.UserID), isTyping: false } });
+        }, [currentUserId]),
+        onMessageEdited: (0, react_1.useCallback)((data) => {
+            if (!data)
+                return;
+            // Find which room the message is in
+            const s = stateRef.current;
+            for (const [roomIdStr, msgs] of Object.entries(s.messages)) {
+                if (msgs.some(m => m.MessageID === data.messageId)) {
+                    dispatch({
+                        type: 'UPDATE_MESSAGE',
+                        payload: { messageId: data.messageId, roomId: Number(roomIdStr), updates: { Content: data.content, IsEdited: true, EditedAt: data.editedAt } }
+                    });
+                    break;
+                }
+            }
+        }, []),
+        onMessageDeleted: (0, react_1.useCallback)((data) => {
+            if (!data)
+                return;
+            dispatch({ type: 'DELETE_MESSAGE', payload: { messageId: data.messageId, roomId: data.roomId } });
+        }, []),
+        onReactionUpdated: (0, react_1.useCallback)((data) => {
+            if (!data)
+                return;
+            const s = stateRef.current;
+            for (const [roomIdStr, msgs] of Object.entries(s.messages)) {
+                if (msgs.some(m => m.MessageID === data.messageId)) {
+                    dispatch({
+                        type: 'UPDATE_MESSAGE',
+                        payload: { messageId: data.messageId, roomId: Number(roomIdStr), updates: { Reactions: data.reactions } }
+                    });
+                    break;
+                }
+            }
+        }, []),
+        onTypingIndicator: (0, react_1.useCallback)((data) => {
+            if (!data)
+                return;
+            dispatch({ type: 'SET_TYPING', payload: { roomId: data.conversationId, userId: data.userId, isTyping: data.isTyping } });
+            // Auto-clear typing after 5s
+            if (data.isTyping) {
+                setTimeout(() => {
+                    dispatch({ type: 'SET_TYPING', payload: { roomId: data.conversationId, userId: data.userId, isTyping: false } });
+                }, 5000);
+            }
+        }, []),
+        onPresenceChanged: (0, react_1.useCallback)((data) => {
+            if (!data)
+                return;
+            if (data.status === 'Online') {
+                dispatch({ type: 'USER_ONLINE', payload: data.userId });
+            }
+            else {
+                dispatch({ type: 'USER_OFFLINE', payload: data.userId });
+            }
+        }, []),
+        onReadReceipt: (0, react_1.useCallback)((data) => {
+            if (!data || data.roomId == null || data.userId == null)
+                return;
+            // Ignore our own receipts — we already cleared unread locally on markAsRead.
+            if (String(data.userId) === currentUserId)
+                return;
+            dispatch({
+                type: 'SET_READ_RECEIPT',
+                payload: {
+                    roomId: data.roomId,
+                    userId: String(data.userId),
+                    lastReadMessageId: Number(data.lastReadMessageId) || 0
+                }
+            });
+        }, [currentUserId])
+    };
+    // ─── Inline SignalR connection ────────────────────────────────────────────
+    const signalRConnectionRef = (0, react_1.useRef)(null);
+    const signalRCallbacksRef = (0, react_1.useRef)(signalRCallbacks);
+    signalRCallbacksRef.current = signalRCallbacks;
+    const hubJoin = (0, react_1.useCallback)(async (roomId) => {
+        const conn = signalRConnectionRef.current;
+        if (conn?.state === signalr_1.HubConnectionState.Connected) {
+            await conn.invoke('JoinConversation', roomId);
+        }
+    }, []);
+    const hubLeave = (0, react_1.useCallback)(async (roomId) => {
+        const conn = signalRConnectionRef.current;
+        if (conn?.state === signalr_1.HubConnectionState.Connected) {
+            await conn.invoke('LeaveConversation', roomId);
+        }
+    }, []);
+    const hubSendTyping = (0, react_1.useCallback)(async (roomId, isTyping) => {
+        const conn = signalRConnectionRef.current;
+        if (conn?.state === signalr_1.HubConnectionState.Connected) {
+            await conn.invoke('SendTyping', roomId, isTyping);
+        }
+    }, []);
+    // Extract stable session values to avoid re-evaluating casted expressions in deps
+    const sessionCompanyId = session?.user?.CompanyID || session?.user?.companyID || '';
+    const sessionUserId = session?.user?.UserID || session?.user?.userID || '';
+    const sessionCompanyUser = session?.user?.companyUsername || '';
+    const sessionCompanyPass = session?.user?.companyPassword || '';
+    // Called after a dropped connection is re-established: rejoin the active room's group
+    // (group membership is lost server-side on disconnect) and refetch to recover any
+    // messages/read-state missed while offline. Held in a ref so the connection effect
+    // doesn't depend on actions defined further down.
+    const onReconnectedRef = (0, react_1.useRef)(() => { });
+    (0, react_1.useEffect)(() => {
+        const API_BASE_URL = process.env.NEXT_PUBLIC_API_BASE_URL || '';
+        if (!sessionCompanyId || !sessionUserId || !API_BASE_URL)
+            return;
+        // WebSockets can't send custom headers, so the company Basic-Auth credentials travel
+        // as a base64 `auth` query param. Prefer the app-wide auth token (the exact value sent
+        // on REST calls); fall back to session creds when the global API config isn't set yet.
+        const basicHeader = (0, config_1.getBasicAuthHeader)(); // "Basic <base64>" or null
+        const authToken = basicHeader
+            ? basicHeader.replace(/^Basic\s+/i, '')
+            : (sessionCompanyUser && sessionCompanyPass ? btoa(`${sessionCompanyUser}:${sessionCompanyPass}`) : '');
+        if (!authToken)
+            return; // no credentials available yet — effect re-runs when they arrive
+        const hubUrl = `${API_BASE_URL}/hubs/messaging?companyId=${sessionCompanyId}&userId=${sessionUserId}&auth=${encodeURIComponent(authToken)}`;
+        const connection = new signalr_1.HubConnectionBuilder()
+            .withUrl(hubUrl)
+            .withAutomaticReconnect([0, 2000, 5000, 10000, 30000])
+            .configureLogging(signalr_1.LogLevel.None)
+            .build();
+        const cb = signalRCallbacksRef;
+        connection.on('ReceiveMessage', (data) => cb.current.onReceiveMessage?.(data));
+        connection.on('MessageEdited', (data) => cb.current.onMessageEdited?.(data));
+        connection.on('MessageDeleted', (data) => cb.current.onMessageDeleted?.(data));
+        connection.on('ReactionUpdated', (data) => cb.current.onReactionUpdated?.(data));
+        connection.on('TypingIndicator', (data) => cb.current.onTypingIndicator?.(data));
+        connection.on('PresenceChanged', (data) => cb.current.onPresenceChanged?.(data));
+        connection.on('ReadReceipt', (data) => cb.current.onReadReceipt?.(data));
+        connection.onreconnected(() => onReconnectedRef.current());
+        connection.start().catch(() => { });
+        signalRConnectionRef.current = connection;
+        return () => {
+            if (connection.state !== signalr_1.HubConnectionState.Disconnected) {
+                connection.stop();
+            }
+        };
+    }, [sessionCompanyId, sessionUserId, sessionCompanyUser, sessionCompanyPass]);
+    // ─── API Actions ────────────────────────────────────────────────────────
+    const fetchConversations = (0, react_1.useCallback)(async (type) => {
+        if (!session)
+            return;
+        dispatch({ type: 'SET_LOADING_CONVERSATIONS', payload: true });
+        try {
+            const res = await messaging_1.MessagingAPI.getConversations(session, type);
+            if (res.success && res.data) {
+                dispatch({ type: 'SET_CONVERSATIONS', payload: res.data });
+            }
+        }
+        finally {
+            dispatch({ type: 'SET_LOADING_CONVERSATIONS', payload: false });
+        }
+    }, [session]);
+    const createRoom = (0, react_1.useCallback)(async (request) => {
+        if (!session)
+            return null;
+        const res = await messaging_1.MessagingAPI.createRoom(request, session);
+        if (res.success && res.data) {
+            dispatch({ type: 'ADD_CONVERSATION', payload: res.data });
+            return res.data;
+        }
+        dispatch({ type: 'SET_ERROR', payload: res.error || null });
+        return null;
+    }, [session]);
+    const getOrCreateDM = (0, react_1.useCallback)(async (request) => {
+        if (!session)
+            return null;
+        const res = await messaging_1.MessagingAPI.getOrCreateDM(request, session);
+        if (res.success && res.data) {
+            dispatch({ type: 'ADD_CONVERSATION', payload: res.data });
+            return res.data;
+        }
+        dispatch({ type: 'SET_ERROR', payload: res.error || null });
+        return null;
+    }, [session]);
+    const updateRoom = (0, react_1.useCallback)(async (roomId, request) => {
+        if (!session)
+            return;
+        const res = await messaging_1.MessagingAPI.updateRoom(roomId, request, session);
+        if (res.success && res.data) {
+            dispatch({ type: 'UPDATE_CONVERSATION', payload: { roomId, updates: res.data } });
+        }
+    }, [session]);
+    const setActiveRoom = (0, react_1.useCallback)((roomId) => {
+        dispatch({ type: 'SET_ACTIVE_ROOM', payload: roomId });
+    }, []);
+    const fetchMessages = (0, react_1.useCallback)(async (roomId, page = 1) => {
+        if (!session)
+            return;
+        dispatch({ type: 'SET_LOADING_MESSAGES', payload: true });
+        try {
+            const pageSize = 50;
+            const res = await messaging_1.MessagingAPI.getMessages(roomId, session, page, pageSize);
+            if (res.success && res.data) {
+                const hasMore = res.data.length === pageSize;
+                // SP returns DESC (newest first) — reverse to chronological (oldest first)
+                const chronological = [...res.data].reverse();
+                if (page === 1) {
+                    dispatch({ type: 'SET_MESSAGES', payload: { roomId, messages: chronological, hasMore, page } });
+                }
+                else {
+                    // Older messages prepend to the start
+                    dispatch({ type: 'APPEND_MESSAGES', payload: { roomId, messages: chronological, hasMore, page } });
+                }
+            }
+        }
+        finally {
+            dispatch({ type: 'SET_LOADING_MESSAGES', payload: false });
+        }
+    }, [session]);
+    const fetchMoreMessages = (0, react_1.useCallback)(async (roomId) => {
+        const pagination = stateRef.current.messagePagination[roomId];
+        if (!pagination?.hasMore)
+            return;
+        await fetchMessages(roomId, pagination.page + 1);
+    }, [fetchMessages]);
+    const sendMessage = (0, react_1.useCallback)(async (roomId, request) => {
+        if (!session)
+            return null;
+        dispatch({ type: 'SET_SENDING_MESSAGE', payload: true });
+        try {
+            const res = await messaging_1.MessagingAPI.sendMessage(roomId, request, session);
+            if (res.success && res.data) {
+                // Add locally (SignalR will deduplicate via MessageID check)
+                dispatch({ type: 'ADD_MESSAGE', payload: { roomId, message: res.data } });
+                dispatch({
+                    type: 'UPDATE_CONVERSATION',
+                    payload: {
+                        roomId,
+                        updates: {
+                            LastMessageAt: res.data.CreatedAt,
+                            LastMessagePreview: res.data.Content?.substring(0, 100) || null,
+                            LastMessageBy: res.data.UserID
+                        }
+                    }
+                });
+                return res.data;
+            }
+            dispatch({ type: 'SET_ERROR', payload: res.error || null });
+            return null;
+        }
+        finally {
+            dispatch({ type: 'SET_SENDING_MESSAGE', payload: false });
+        }
+    }, [session]);
+    const editMessage = (0, react_1.useCallback)(async (messageId, content) => {
+        if (!session)
+            return;
+        await messaging_1.MessagingAPI.editMessage(messageId, content, session);
+        // Update will arrive via SignalR
+    }, [session]);
+    const deleteMessage = (0, react_1.useCallback)(async (messageId) => {
+        if (!session)
+            return;
+        await messaging_1.MessagingAPI.deleteMessage(messageId, session);
+        // Delete will arrive via SignalR
+    }, [session]);
+    const fetchThreadReplies = (0, react_1.useCallback)(async (messageId) => {
+        if (!session)
+            return;
+        dispatch({ type: 'SET_LOADING_THREAD', payload: true });
+        try {
+            const res = await messaging_1.MessagingAPI.getThreadReplies(messageId, session);
+            if (res.success && res.data) {
+                dispatch({ type: 'SET_THREAD_MESSAGES', payload: { parentId: messageId, messages: res.data } });
+            }
+        }
+        finally {
+            dispatch({ type: 'SET_LOADING_THREAD', payload: false });
+        }
+    }, [session]);
+    const replyToMessage = (0, react_1.useCallback)(async (parentMessageId, request) => {
+        if (!session)
+            return null;
+        dispatch({ type: 'SET_SENDING_MESSAGE', payload: true });
+        try {
+            const res = await messaging_1.MessagingAPI.replyToMessage(parentMessageId, request, session);
+            if (res.success && res.data) {
+                dispatch({ type: 'ADD_THREAD_MESSAGE', payload: { parentId: parentMessageId, message: res.data } });
+                return res.data;
+            }
+            dispatch({ type: 'SET_ERROR', payload: res.error || null });
+            return null;
+        }
+        finally {
+            dispatch({ type: 'SET_SENDING_MESSAGE', payload: false });
+        }
+    }, [session]);
+    const openThread = (0, react_1.useCallback)((messageId) => {
+        dispatch({ type: 'SET_ACTIVE_THREAD', payload: messageId });
+    }, []);
+    const closeThread = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'SET_ACTIVE_THREAD', payload: null });
+    }, []);
+    const toggleReaction = (0, react_1.useCallback)(async (messageId, emoji) => {
+        if (!session || !currentUserId)
+            return;
+        // Find the message in any room
+        const s = stateRef.current;
+        let foundRoomId = null;
+        let foundMsg = null;
+        for (const [roomIdStr, msgs] of Object.entries(s.messages)) {
+            const msg = msgs.find(m => m.MessageID === messageId);
+            if (msg) {
+                foundRoomId = Number(roomIdStr);
+                foundMsg = msg;
+                break;
+            }
+        }
+        if (!foundMsg || foundRoomId === null)
+            return;
+        // Parse existing reactions, toggle the user's reaction
+        const reactions = (0, messaging_2.parseReactions)(foundMsg.Reactions);
+        const userIdNum = Number(currentUserId);
+        const existing = reactions.find(r => r.emoji === emoji);
+        if (existing) {
+            if (existing.userIds.includes(userIdNum)) {
+                existing.userIds = existing.userIds.filter(id => id !== userIdNum);
+                if (existing.userIds.length === 0) {
+                    const idx = reactions.indexOf(existing);
+                    reactions.splice(idx, 1);
+                }
+            }
+            else {
+                existing.userIds.push(userIdNum);
+            }
+        }
+        else {
+            reactions.push({ emoji, userIds: [userIdNum] });
+        }
+        const reactionsJson = JSON.stringify(reactions);
+        // Optimistic update
+        dispatch({
+            type: 'UPDATE_MESSAGE',
+            payload: { messageId, roomId: foundRoomId, updates: { Reactions: reactionsJson } }
+        });
+        await messaging_1.MessagingAPI.updateReactions(messageId, reactionsJson, session);
+        // Server will broadcast via SignalR
+    }, [session, currentUserId]);
+    const markAsRead = (0, react_1.useCallback)(async (roomId, lastReadMessageId) => {
+        if (!session)
+            return;
+        dispatch({ type: 'CLEAR_UNREAD', payload: roomId });
+        await messaging_1.MessagingAPI.markAsRead(roomId, lastReadMessageId, session);
+    }, [session]);
+    const fetchUnreadCounts = (0, react_1.useCallback)(async () => {
+        if (!session)
+            return;
+        const res = await messaging_1.MessagingAPI.getUnreadCounts(session);
+        if (res.success && res.data) {
+            const counts = {};
+            for (const item of res.data) {
+                counts[item.RoomID] = item.UnreadCount;
+            }
+            dispatch({ type: 'SET_UNREAD_COUNTS', payload: counts });
+        }
+    }, [session]);
+    const searchMessages = (0, react_1.useCallback)(async (query) => {
+        if (!session || !query.trim())
+            return;
+        dispatch({ type: 'SET_SEARCH_QUERY', payload: query });
+        dispatch({ type: 'SET_SEARCH_LOADING', payload: true });
+        try {
+            const res = await messaging_1.MessagingAPI.searchMessages(query, session);
+            if (res.success && res.data) {
+                dispatch({ type: 'SET_SEARCH_RESULTS', payload: res.data });
+            }
+        }
+        finally {
+            dispatch({ type: 'SET_SEARCH_LOADING', payload: false });
+        }
+    }, [session]);
+    const clearSearch = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'SET_SEARCH_QUERY', payload: '' });
+        dispatch({ type: 'SET_SEARCH_RESULTS', payload: [] });
+    }, []);
+    const fetchContacts = (0, react_1.useCallback)(async () => {
+        if (!session)
+            return;
+        const res = await messaging_1.MessagingAPI.getContacts(session);
+        if (res.success && res.data) {
+            dispatch({ type: 'SET_CONTACTS', payload: res.data });
+        }
+    }, [session]);
+    const uploadFile = (0, react_1.useCallback)(async (file) => {
+        if (!session)
+            return null;
+        const res = await messaging_1.MessagingAPI.uploadFile(file, session);
+        if (res.success && res.data)
+            return res.data;
+        dispatch({ type: 'SET_ERROR', payload: res.error || null });
+        return null;
+    }, [session]);
+    const isUserOnline = (0, react_1.useCallback)((userId) => {
+        return stateRef.current.onlineUsers.has(String(userId));
+    }, []);
+    const getTypingUsers = (0, react_1.useCallback)((roomId) => {
+        return stateRef.current.typingUsers[roomId] || [];
+    }, []);
+    const getReadReceipts = (0, react_1.useCallback)((roomId) => {
+        return stateRef.current.readReceipts[roomId] || {};
+    }, []);
+    const fetchOnlineUsers = (0, react_1.useCallback)(async () => {
+        if (!session)
+            return;
+        const res = await messaging_1.MessagingAPI.getOnlineUsers(session);
+        if (res.success && res.data) {
+            dispatch({ type: 'SET_ONLINE_USERS', payload: new Set(res.data.map(String)) });
+        }
+    }, [session]);
+    const clearError = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'SET_ERROR', payload: null });
+    }, []);
+    // Keep the reconnect handler current. On reconnect, group membership is lost server-side,
+    // so rejoin the active room and refetch to recover anything missed while offline.
+    (0, react_1.useEffect)(() => {
+        onReconnectedRef.current = () => {
+            const activeRoomId = stateRef.current.activeRoomId;
+            if (activeRoomId != null) {
+                hubJoin(activeRoomId);
+                fetchMessages(activeRoomId, 1);
+            }
+            fetchUnreadCounts();
+            fetchOnlineUsers();
+        };
+    }, [hubJoin, fetchMessages, fetchUnreadCounts, fetchOnlineUsers]);
+    // ─── Initial data fetch ─────────────────────────────────────────────────
+    const initializedRef = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(() => {
+        if (!session || initializedRef.current)
+            return;
+        initializedRef.current = true;
+        fetchUnreadCounts();
+        fetchOnlineUsers();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [session]);
+    // ─── Context value ──────────────────────────────────────────────────────
+    const actions = (0, react_1.useMemo)(() => ({
+        fetchConversations,
+        createRoom,
+        getOrCreateDM,
+        updateRoom,
+        setActiveRoom,
+        fetchMessages,
+        fetchMoreMessages,
+        sendMessage,
+        editMessage,
+        deleteMessage,
+        fetchThreadReplies,
+        replyToMessage,
+        openThread,
+        closeThread,
+        toggleReaction,
+        markAsRead,
+        fetchUnreadCounts,
+        searchMessages,
+        clearSearch,
+        fetchContacts,
+        uploadFile,
+        joinConversation: hubJoin,
+        leaveConversation: hubLeave,
+        sendTyping: hubSendTyping,
+        isUserOnline,
+        getTypingUsers,
+        getReadReceipts,
+        fetchOnlineUsers,
+        clearError
+    }), [
+        fetchConversations, createRoom, getOrCreateDM, updateRoom, setActiveRoom,
+        fetchMessages, fetchMoreMessages, sendMessage, editMessage, deleteMessage,
+        fetchThreadReplies, replyToMessage, openThread, closeThread, toggleReaction,
+        markAsRead, fetchUnreadCounts, searchMessages, clearSearch, fetchContacts,
+        uploadFile, hubJoin, hubLeave, hubSendTyping, isUserOnline, getTypingUsers,
+        getReadReceipts, fetchOnlineUsers, clearError
+    ]);
+    const value = (0, react_1.useMemo)(() => ({
+        state,
+        actions
+    }), [state, actions]);
+    return ((0, jsx_runtime_1.jsx)(MessagingContext.Provider, { value: value, children: children }));
+}
+// ─── Hook ───────────────────────────────────────────────────────────────────
+function useMessaging() {
+    const context = (0, react_1.useContext)(MessagingContext);
+    if (!context) {
+        throw new Error('useMessaging must be used within a MessagingProvider');
+    }
+    return context;
+}