@myrjfa/state 1.1.1 → 2.0.0

package/dist/lib/context/ChatContext.js

@@ -1,338 +1,338 @@
-"use client";
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useEffect, useState, useCallback, useRef } from "react";
-import { getSocket } from "../actions/socket";
-import { chatApi } from "../actions/chat";
-import { useAtomValue } from "jotai";
-import { userAtom } from "../userAtom";
-const ChatContext = createContext({
-    socket: null,
-    isConnected: false,
-    conversations: [],
-    activeConversation: null,
-    setActiveConversation: () => { },
-    messages: [],
-    setMessages: () => { },
-    typingUsers: new Map(),
-    onlineUsers: new Set(),
-    refreshConversations: async () => { },
-    sendMessage: async () => { },
-    createPoll: () => { },
-    votePoll: () => { },
-    editMessage: () => { },
-    toggleMessageReaction: () => { },
-    deleteMessage: () => { },
-    markRead: () => { },
-    unreadNotificationCount: 0,
-    notifications: [],
-    clearNotifications: () => { },
-});
-export function useChatContext() {
-    return useContext(ChatContext);
-}
-export function ChatProvider({ children }) {
-    const user = useAtomValue(userAtom);
-    const [isConnected, setIsConnected] = useState(false);
-    const [conversations, setConversations] = useState([]);
-    const [activeConversation, _setActiveConversation] = useState(null);
-    const activeConversationRef = useRef(null);
-    const [messages, setMessages] = useState([]);
-    const [typingUsers, setTypingUsers] = useState(new Map());
-    const [onlineUsers, setOnlineUsers] = useState(new Set());
-    const [unreadNotificationCount, setUnreadNotificationCount] = useState(0);
-    const [notifications, setNotifications] = useState([]);
-    const socketRef = useRef(null);
-    const setActiveConversation = useCallback((conv) => {
-        _setActiveConversation(conv);
-        activeConversationRef.current = conv;
-    }, []);
-    useEffect(() => {
-        activeConversationRef.current = activeConversation;
-    }, [activeConversation]);
-    const refreshConversations = useCallback(async () => {
-        try {
-            const data = await chatApi.getConversations();
-            setConversations(data);
-        }
-        catch (err) {
-            console.error("Failed to fetch conversations:", err);
-        }
-    }, []);
-    const sendMessage = useCallback(async (conversationId, text, files, replyTo) => {
-        let actualId = conversationId;
-        // If it's a draft conversation, create it first
-        if (conversationId.startsWith("draft_")) {
-            const otherUserId = conversationId.replace("draft_", "");
-            try {
-                const res = await chatApi.createConversation({
-                    type: "individual",
-                    otherUserId
-                });
-                if (res._id) {
-                    actualId = res._id;
-                    // Update active conversation in state to point to the real one
-                    setActiveConversation(res);
-                    // Refresh to include in list
-                    await refreshConversations();
-                }
-                else {
-                    console.error("Failed to create conversation during lazy send");
-                    return;
-                }
-            }
-            catch (err) {
-                console.error("Failed to create conversation during lazy send:", err);
-                return;
-            }
-        }
-        if (!socketRef.current)
-            return;
-        let media = [];
-        if (files && files.length > 0) {
-            // Upload files first
-            const formData = new FormData();
-            files.forEach(f => formData.append("chatFiles", f));
-            try {
-                // We need a dedicated upload endpoint.
-                // For now, let's assume /api/v1/chat/upload
-                const response = await chatApi.uploadFiles(formData);
-                if (response.error) {
-                    console.error("File upload failed:", response.error);
-                    return;
-                }
-                media = response.data.files.map((f) => ({
-                    type: f.mimetype.startsWith("audio") ? "audio" : (f.mimetype.startsWith("image") ? "image" : "file"),
-                    url: f.location,
-                    name: f.originalname
-                }));
-            }
-            catch (err) {
-                console.error("File upload failed:", err);
-            }
-        }
-        socketRef.current.emit("message:send", {
-            conversationId: actualId,
-            content: { text, media },
-            type: media.length > 0 ? "media" : "text",
-            replyTo,
-        });
-    }, [refreshConversations, setActiveConversation]);
-    const editMessage = useCallback((messageId, text) => {
-        if (!socketRef.current)
-            return;
-        socketRef.current.emit("message:edit", { messageId, text });
-    }, []);
-    const toggleMessageReaction = useCallback((messageId, reaction) => {
-        if (!socketRef.current)
-            return;
-        socketRef.current.emit("message:react", { messageId, reaction });
-    }, []);
-    const deleteMessage = useCallback((messageId) => {
-        if (!socketRef.current)
-            return;
-        socketRef.current.emit("message:delete", { messageId });
-    }, []);
-    const createPoll = useCallback((conversationId, question, options, allowMultiple) => {
-        if (!socketRef.current)
-            return;
-        socketRef.current.emit("poll:create", { conversationId, question, options, allowMultiple });
-    }, []);
-    const votePoll = useCallback((pollId, optionIndex) => {
-        if (!socketRef.current)
-            return;
-        socketRef.current.emit("poll:vote", { pollId, optionIndex });
-    }, []);
-    const clearNotifications = useCallback(() => {
-        setNotifications([]);
-        setUnreadNotificationCount(0);
-    }, []);
-    const markRead = useCallback((conversationId, unreadIds) => {
-        if (!socketRef.current)
-            return;
-        socketRef.current.emit("message:read", { conversationId, unreadIds });
-    }, []);
-    useEffect(() => {
-        if (!user) {
-            setIsConnected(false);
-            setConversations([]);
-            return;
-        }
-        const socket = getSocket();
-        socketRef.current = socket;
-        function onConnect() {
-            setIsConnected(true);
-            refreshConversations();
-        }
-        function onDisconnect() {
-            setIsConnected(false);
-        }
-        socket.on("connect", onConnect);
-        socket.on("disconnect", onDisconnect);
-        if (!socket.connected) {
-            socket.connect();
-        }
-        else {
-            // Include logic for if already connected
-            onConnect();
-        }
-        // New message
-        socket.on("message:new", ({ conversationId, message }) => {
-            setMessages((prev) => {
-                const currentActiveId = activeConversationRef.current?._id;
-                // If this message belongs to the active conversation, add it
-                if (currentActiveId === conversationId) {
-                    // Deduplicate
-                    if (prev.some((m) => m._id === message._id))
-                        return prev;
-                    return [...prev, message];
-                }
-                return prev;
-            });
-            // Update conversations last message
-            setConversations((prev) => prev
-                .map((c) => c._id === conversationId
-                ? {
-                    ...c,
-                    lastMessage: {
-                        content: message.content?.text || `[${message.type}]`,
-                        senderId: message.senderId,
-                        sentAt: message.createdAt,
-                    },
-                    updatedAt: message.createdAt,
-                }
-                : c)
-                .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()));
-        });
-        // Message updated
-        socket.on("message:updated", ({ message }) => {
-            setMessages((prev) => prev.map((m) => (m._id === message._id ? message : m)));
-        });
-        socket.on("message:readed", ({ conversationId, userId, unreadIds }) => {
-            setMessages((prev) => prev.map((m) => {
-                if (m.conversationId === conversationId && unreadIds.includes(m._id)) {
-                    return {
-                        ...m,
-                        isRead: true,
-                    };
-                }
-                return m;
-            }));
-            setConversations((prev) => {
-                return prev.map((c) => {
-                    if (c._id === conversationId) {
-                        return {
-                            ...c,
-                            participants: c.participants.map((p) => {
-                                if (p.userId === userId) {
-                                    return {
-                                        ...p,
-                                        unreadCounts: {
-                                            messages: 0,
-                                            mentions: 0,
-                                            milestones: 0,
-                                            expenses: 0,
-                                        }
-                                    };
-                                }
-                                return p;
-                            }),
-                        };
-                    }
-                    return c;
-                });
-            });
-        });
-        // // Poll created/updated (we treat them as messages that might trigger UI updates)
-        // socket.on("poll:created", ({ pollMessage }: { pollMessage: Message }) => {
-        //     setMessages((prev) => [...prev, pollMessage]);
-        // });
-        socket.on("poll:updated", ({ pollMessage }) => {
-            // Re-fetch messages or update a specific one if referenceId matches
-            setMessages(prev => prev.map(m => (m.type === "poll" && m._id === pollMessage._id)
-                ? pollMessage // Store poll detail in message temporarily for UI
-                : m));
-        });
-        // Message deleted
-        socket.on("message:deleted", ({ messageId }) => {
-            setMessages((prev) => prev.filter((m) => m._id !== messageId));
-        });
-        // Typing indicators
-        socket.on("typing:start", ({ conversationId, userId }) => {
-            setTypingUsers((prev) => {
-                const next = new Map(prev);
-                const users = next.get(conversationId) || [];
-                if (!users.includes(userId)) {
-                    next.set(conversationId, [...users, userId]);
-                }
-                return next;
-            });
-        });
-        socket.on("typing:stop", ({ conversationId, userId }) => {
-            setTypingUsers((prev) => {
-                const next = new Map(prev);
-                const users = next.get(conversationId) || [];
-                next.set(conversationId, users.filter((u) => u !== userId));
-                return next;
-            });
-        });
-        // Online/offline
-        socket.on("presence:online", ({ userId }) => {
-            setOnlineUsers((prev) => new Set(prev).add(userId));
-        });
-        socket.on("presence:offline", ({ userId }) => {
-            setOnlineUsers((prev) => {
-                const next = new Set(prev);
-                next.delete(userId);
-                return next;
-            });
-        });
-        // Real-time notifications
-        socket.on("notification:new", (notification) => {
-            setNotifications((prev) => [notification, ...prev].slice(0, 50));
-            setUnreadNotificationCount((prev) => prev + 1);
-        });
-        return () => {
-            socket.off("connect", onConnect);
-            socket.off("disconnect", onDisconnect);
-            socket.off("message:new");
-            socket.off("message:updated");
-            socket.off("message:deleted");
-            socket.off("typing:start");
-            socket.off("typing:stop");
-            socket.off("presence:online");
-            socket.off("presence:offline");
-            socket.off("notification:new");
-            // Disconnect on unmount? Maybe not if shared across pages.
-            // But if specific to chat...
-            // For shared state lib, we might want to keep it open?
-            // If user navigates away from chat pages, maybe close it?
-            // The original logic disconnected on unmount.
-            // But if we want global notifications (unread count), we need it open.
-            // Let's keep it open but manage listeners.
-            // Actually, if we unmount the provider, we should disconnect or remove listeners.
-            // Assuming this Provider wraps only Chat pages.
-        };
-    }, [user, refreshConversations]);
-    return (_jsx(ChatContext.Provider, { value: {
-            socket: socketRef.current,
-            isConnected,
-            conversations,
-            activeConversation,
-            setActiveConversation,
-            messages,
-            setMessages,
-            typingUsers,
-            onlineUsers,
-            refreshConversations,
-            sendMessage,
-            editMessage,
-            toggleMessageReaction,
-            deleteMessage,
-            markRead,
-            createPoll,
-            votePoll,
-            unreadNotificationCount,
-            notifications,
-            clearNotifications,
-        }, children: children }));
-}
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState, useCallback, useRef } from "react";
+import { getSocket } from "../actions/socket";
+import { chatApi } from "../actions/chat";
+import { useAtomValue } from "jotai";
+import { userAtom } from "../userAtom";
+const ChatContext = createContext({
+    socket: null,
+    isConnected: false,
+    conversations: [],
+    activeConversation: null,
+    setActiveConversation: () => { },
+    messages: [],
+    setMessages: () => { },
+    typingUsers: new Map(),
+    onlineUsers: new Set(),
+    refreshConversations: async () => { },
+    sendMessage: async () => { },
+    createPoll: () => { },
+    votePoll: () => { },
+    editMessage: () => { },
+    toggleMessageReaction: () => { },
+    deleteMessage: () => { },
+    markRead: () => { },
+    unreadNotificationCount: 0,
+    notifications: [],
+    clearNotifications: () => { },
+});
+export function useChatContext() {
+    return useContext(ChatContext);
+}
+export function ChatProvider({ children }) {
+    const user = useAtomValue(userAtom);
+    const [isConnected, setIsConnected] = useState(false);
+    const [conversations, setConversations] = useState([]);
+    const [activeConversation, _setActiveConversation] = useState(null);
+    const activeConversationRef = useRef(null);
+    const [messages, setMessages] = useState([]);
+    const [typingUsers, setTypingUsers] = useState(new Map());
+    const [onlineUsers, setOnlineUsers] = useState(new Set());
+    const [unreadNotificationCount, setUnreadNotificationCount] = useState(0);
+    const [notifications, setNotifications] = useState([]);
+    const socketRef = useRef(null);
+    const setActiveConversation = useCallback((conv) => {
+        _setActiveConversation(conv);
+        activeConversationRef.current = conv;
+    }, []);
+    useEffect(() => {
+        activeConversationRef.current = activeConversation;
+    }, [activeConversation]);
+    const refreshConversations = useCallback(async () => {
+        try {
+            const data = await chatApi.getConversations();
+            setConversations(data);
+        }
+        catch (err) {
+            console.error("Failed to fetch conversations:", err);
+        }
+    }, []);
+    const sendMessage = useCallback(async (conversationId, text, files, replyTo) => {
+        let actualId = conversationId;
+        // If it's a draft conversation, create it first
+        if (conversationId.startsWith("draft_")) {
+            const otherUserId = conversationId.replace("draft_", "");
+            try {
+                const res = await chatApi.createConversation({
+                    type: "individual",
+                    otherUserId
+                });
+                if (res._id) {
+                    actualId = res._id;
+                    // Update active conversation in state to point to the real one
+                    setActiveConversation(res);
+                    // Refresh to include in list
+                    await refreshConversations();
+                }
+                else {
+                    console.error("Failed to create conversation during lazy send");
+                    return;
+                }
+            }
+            catch (err) {
+                console.error("Failed to create conversation during lazy send:", err);
+                return;
+            }
+        }
+        if (!socketRef.current)
+            return;
+        let media = [];
+        if (files && files.length > 0) {
+            // Upload files first
+            const formData = new FormData();
+            files.forEach(f => formData.append("chatFiles", f));
+            try {
+                // We need a dedicated upload endpoint.
+                // For now, let's assume /api/v1/chat/upload
+                const response = await chatApi.uploadFiles(formData);
+                if (response.error) {
+                    console.error("File upload failed:", response.error);
+                    return;
+                }
+                media = response.data.files.map((f) => ({
+                    type: f.mimetype.startsWith("audio") ? "audio" : (f.mimetype.startsWith("image") ? "image" : "file"),
+                    url: f.location,
+                    name: f.originalname
+                }));
+            }
+            catch (err) {
+                console.error("File upload failed:", err);
+            }
+        }
+        socketRef.current.emit("message:send", {
+            conversationId: actualId,
+            content: { text, media },
+            type: media.length > 0 ? "media" : "text",
+            replyTo,
+        });
+    }, [refreshConversations, setActiveConversation]);
+    const editMessage = useCallback((messageId, text) => {
+        if (!socketRef.current)
+            return;
+        socketRef.current.emit("message:edit", { messageId, text });
+    }, []);
+    const toggleMessageReaction = useCallback((messageId, reaction) => {
+        if (!socketRef.current)
+            return;
+        socketRef.current.emit("message:react", { messageId, reaction });
+    }, []);
+    const deleteMessage = useCallback((messageId) => {
+        if (!socketRef.current)
+            return;
+        socketRef.current.emit("message:delete", { messageId });
+    }, []);
+    const createPoll = useCallback((conversationId, question, options, allowMultiple) => {
+        if (!socketRef.current)
+            return;
+        socketRef.current.emit("poll:create", { conversationId, question, options, allowMultiple });
+    }, []);
+    const votePoll = useCallback((pollId, optionIndex) => {
+        if (!socketRef.current)
+            return;
+        socketRef.current.emit("poll:vote", { pollId, optionIndex });
+    }, []);
+    const clearNotifications = useCallback(() => {
+        setNotifications([]);
+        setUnreadNotificationCount(0);
+    }, []);
+    const markRead = useCallback((conversationId, unreadIds) => {
+        if (!socketRef.current)
+            return;
+        socketRef.current.emit("message:read", { conversationId, unreadIds });
+    }, []);
+    useEffect(() => {
+        if (!user) {
+            setIsConnected(false);
+            setConversations([]);
+            return;
+        }
+        const socket = getSocket();
+        socketRef.current = socket;
+        function onConnect() {
+            setIsConnected(true);
+            refreshConversations();
+        }
+        function onDisconnect() {
+            setIsConnected(false);
+        }
+        socket.on("connect", onConnect);
+        socket.on("disconnect", onDisconnect);
+        if (!socket.connected) {
+            socket.connect();
+        }
+        else {
+            // Include logic for if already connected
+            onConnect();
+        }
+        // New message
+        socket.on("message:new", ({ conversationId, message }) => {
+            setMessages((prev) => {
+                const currentActiveId = activeConversationRef.current?._id;
+                // If this message belongs to the active conversation, add it
+                if (currentActiveId === conversationId) {
+                    // Deduplicate
+                    if (prev.some((m) => m._id === message._id))
+                        return prev;
+                    return [...prev, message];
+                }
+                return prev;
+            });
+            // Update conversations last message
+            setConversations((prev) => prev
+                .map((c) => c._id === conversationId
+                ? {
+                    ...c,
+                    lastMessage: {
+                        content: message.content?.text || `[${message.type}]`,
+                        senderId: message.senderId,
+                        sentAt: message.createdAt,
+                    },
+                    updatedAt: message.createdAt,
+                }
+                : c)
+                .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()));
+        });
+        // Message updated
+        socket.on("message:updated", ({ message }) => {
+            setMessages((prev) => prev.map((m) => (m._id === message._id ? message : m)));
+        });
+        socket.on("message:readed", ({ conversationId, userId, unreadIds }) => {
+            setMessages((prev) => prev.map((m) => {
+                if (m.conversationId === conversationId && unreadIds.includes(m._id)) {
+                    return {
+                        ...m,
+                        isRead: true,
+                    };
+                }
+                return m;
+            }));
+            setConversations((prev) => {
+                return prev.map((c) => {
+                    if (c._id === conversationId) {
+                        return {
+                            ...c,
+                            participants: c.participants.map((p) => {
+                                if (p.userId === userId) {
+                                    return {
+                                        ...p,
+                                        unreadCounts: {
+                                            messages: 0,
+                                            mentions: 0,
+                                            milestones: 0,
+                                            expenses: 0,
+                                        }
+                                    };
+                                }
+                                return p;
+                            }),
+                        };
+                    }
+                    return c;
+                });
+            });
+        });
+        // // Poll created/updated (we treat them as messages that might trigger UI updates)
+        // socket.on("poll:created", ({ pollMessage }: { pollMessage: Message }) => {
+        //     setMessages((prev) => [...prev, pollMessage]);
+        // });
+        socket.on("poll:updated", ({ pollMessage }) => {
+            // Re-fetch messages or update a specific one if referenceId matches
+            setMessages(prev => prev.map(m => (m.type === "poll" && m._id === pollMessage._id)
+                ? pollMessage // Store poll detail in message temporarily for UI
+                : m));
+        });
+        // Message deleted
+        socket.on("message:deleted", ({ messageId }) => {
+            setMessages((prev) => prev.filter((m) => m._id !== messageId));
+        });
+        // Typing indicators
+        socket.on("typing:start", ({ conversationId, userId }) => {
+            setTypingUsers((prev) => {
+                const next = new Map(prev);
+                const users = next.get(conversationId) || [];
+                if (!users.includes(userId)) {
+                    next.set(conversationId, [...users, userId]);
+                }
+                return next;
+            });
+        });
+        socket.on("typing:stop", ({ conversationId, userId }) => {
+            setTypingUsers((prev) => {
+                const next = new Map(prev);
+                const users = next.get(conversationId) || [];
+                next.set(conversationId, users.filter((u) => u !== userId));
+                return next;
+            });
+        });
+        // Online/offline
+        socket.on("presence:online", ({ userId }) => {
+            setOnlineUsers((prev) => new Set(prev).add(userId));
+        });
+        socket.on("presence:offline", ({ userId }) => {
+            setOnlineUsers((prev) => {
+                const next = new Set(prev);
+                next.delete(userId);
+                return next;
+            });
+        });
+        // Real-time notifications
+        socket.on("notification:new", (notification) => {
+            setNotifications((prev) => [notification, ...prev].slice(0, 50));
+            setUnreadNotificationCount((prev) => prev + 1);
+        });
+        return () => {
+            socket.off("connect", onConnect);
+            socket.off("disconnect", onDisconnect);
+            socket.off("message:new");
+            socket.off("message:updated");
+            socket.off("message:deleted");
+            socket.off("typing:start");
+            socket.off("typing:stop");
+            socket.off("presence:online");
+            socket.off("presence:offline");
+            socket.off("notification:new");
+            // Disconnect on unmount? Maybe not if shared across pages.
+            // But if specific to chat...
+            // For shared state lib, we might want to keep it open?
+            // If user navigates away from chat pages, maybe close it?
+            // The original logic disconnected on unmount.
+            // But if we want global notifications (unread count), we need it open.
+            // Let's keep it open but manage listeners.
+            // Actually, if we unmount the provider, we should disconnect or remove listeners.
+            // Assuming this Provider wraps only Chat pages.
+        };
+    }, [user, refreshConversations]);
+    return (_jsx(ChatContext.Provider, { value: {
+            socket: socketRef.current,
+            isConnected,
+            conversations,
+            activeConversation,
+            setActiveConversation,
+            messages,
+            setMessages,
+            typingUsers,
+            onlineUsers,
+            refreshConversations,
+            sendMessage,
+            editMessage,
+            toggleMessageReaction,
+            deleteMessage,
+            markRead,
+            createPoll,
+            votePoll,
+            unreadNotificationCount,
+            notifications,
+            clearNotifications,
+        }, children: children }));
+}