@thrillee/aegischat 0.1.14 → 0.1.16

package/src/hooks/useAutoRead.ts

@@ -2,11 +2,9 @@
 // AegisChat React SDK - useAutoRead Hook
 // ============================================================================
 
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useRef } from 'react';
 import { channelsApi } from '../services/api';
 
-const SESSION_STORAGE_KEY = '@aegischat/activeChannel';
-
 export interface UseAutoReadOptions {
   onMarkAsRead?: (channelId: string) => void;
 }
@@ -14,17 +12,24 @@ export interface UseAutoReadOptions {
 export interface UseAutoReadReturn {
   markAsRead: (channelId: string) => Promise<void>;
   markAllAsRead: () => Promise<void>;
+  /** Returns current focus state - use this getter to avoid stale closures */
+  getIsFocused: () => boolean;
+  /** @deprecated Use getIsFocused() instead to avoid stale closures in callbacks */
   isFocused: boolean;
 }
 
 export function useAutoRead(options: UseAutoReadOptions = {}): UseAutoReadReturn {
-  const [isFocused, setIsFocused] = useState(false);
+  const isFocusedRef = useRef(typeof document !== 'undefined' && document.hasFocus());
+  const onMarkAsReadRef = useRef(options.onMarkAsRead);
 
+  // Keep the callback ref updated
   useEffect(() => {
-    setIsFocused(typeof document !== 'undefined' && document.hasFocus());
+    onMarkAsReadRef.current = options.onMarkAsRead;
+  }, [options.onMarkAsRead]);
 
-    const handleFocus = () => setIsFocused(true);
-    const handleBlur = () => setIsFocused(false);
+  useEffect(() => {
+    const handleFocus = () => { isFocusedRef.current = true; };
+    const handleBlur = () => { isFocusedRef.current = false; };
 
     window.addEventListener('focus', handleFocus);
     window.addEventListener('blur', handleBlur);
@@ -35,18 +40,22 @@ export function useAutoRead(options: UseAutoReadOptions = {}): UseAutoReadReturn
     };
   }, []);
 
+  const getIsFocused = useCallback(() => {
+    return isFocusedRef.current;
+  }, []);
+
   const markAsRead = useCallback(async (channelId: string) => {
-    if (!isFocused) return;
+    if (!isFocusedRef.current) return;
     try {
       await channelsApi.markAsRead(channelId);
-      options.onMarkAsRead?.(channelId);
+      onMarkAsReadRef.current?.(channelId);
     } catch (error) {
       console.error('[AegisChat] useAutoRead: Failed to mark as read:', error);
     }
-  }, [isFocused, options.onMarkAsRead]);
+  }, []);
 
   const markAllAsRead = useCallback(async () => {
-    if (!isFocused) return;
+    if (!isFocusedRef.current) return;
     try {
       const response = await channelsApi.list({});
       const channels = response.channels || [];
@@ -56,9 +65,15 @@ export function useAutoRead(options: UseAutoReadOptions = {}): UseAutoReadReturn
     } catch (error) {
       console.error('[AegisChat] useAutoRead: Failed to mark all as read:', error);
     }
-  }, [isFocused]);
+  }, []);
 
-  return { markAsRead, markAllAsRead, isFocused };
+  return { 
+    markAsRead, 
+    markAllAsRead, 
+    getIsFocused,
+    // Keep for backwards compatibility but warn it is deprecated
+    isFocused: isFocusedRef.current 
+  };
 }
 
 export default useAutoRead;

package/src/hooks/useChat.ts

@@ -37,7 +37,7 @@ export interface UseChatOptions {
 
   initialSession?: ChatSession | null;
   autoConnect?: boolean;
-  onMessage?: (message: Message) => void;
+  onMessage?: (message: Message, context: { activeChannelId: string | null }) => void;
   onTyping?: (channelId: string, user: TypingUser) => void;
   onConnectionChange?: (connected: boolean) => void;
 }
@@ -102,8 +102,12 @@ export function useChat(options: Partial<UseChatOptions> = {}): UseChatReturn {
   const [session, setSession] = useState<ChatSession | null>(null);
   const [isConnected, setIsConnected] = useState(false);
   const [isConnecting, setIsConnecting] = useState(false);
+  const getStoredActiveChannel = (): string | null => {
+    if (typeof window === "undefined") return null;
+    return sessionStorage.getItem(SESSION_STORAGE_KEY);
+  };
   const [activeChannelId, setActiveChannelIdState] = useState<string | null>(
-    null,
+    getStoredActiveChannel,
   );
   const [channels, setChannels] = useState<ChannelListItem[]>([]);
   const [messages, setMessages] = useState<Message[]>([]);
@@ -128,7 +132,7 @@ export function useChat(options: Partial<UseChatOptions> = {}): UseChatReturn {
   const clientIdRef = useRef<string | undefined>(undefined);
   const autoConnectRef = useRef(true);
   const onMessageRef =
-    useRef<(message: Message) => void | undefined>(undefined);
+    useRef<((message: Message, context: { activeChannelId: string | null }) => void) | undefined>(undefined);
   const onTypingRef = useRef<
     ((channelId: string, user: TypingUser) => void) | undefined
   >(undefined);
@@ -146,6 +150,7 @@ export function useChat(options: Partial<UseChatOptions> = {}): UseChatReturn {
   }, []);
 
   const setActiveChannelId = useCallback((id: string | null) => {
+    activeChannelIdRef.current = id;
     setActiveChannelIdState(id);
     if (typeof window !== "undefined") {
       if (id) {
@@ -218,7 +223,7 @@ export function useChat(options: Partial<UseChatOptions> = {}): UseChatReturn {
               if (prev.some((m) => m.id === newMessage.id)) return prev;
               return [...prev, { ...newMessage, status: "delivered" }];
             });
-            onMessageRef.current?.(newMessage);
+            onMessageRef.current?.(newMessage, { activeChannelId: currentActiveChannelId });
           }
           setChannels((prev) => {
             const updated = prev.map((ch) =>