@siran/chat-react-hooks 0.1.0 → 0.1.1

package/README.md

@@ -1,4 +1,4 @@
-# @package/chat/react-hooks
+# @siran/chat-react-hooks
 
 Hooks et contextes React réutilisables pour intégrer le système de chat dans des applications React.
 
@@ -13,7 +13,7 @@ Ce package fait partie du monorepo Sekoliko. Les dépendances sont gérées auto
 Enveloppez votre application avec le `ChatProvider` :
 
 ```tsx
-import { ChatProvider } from "@package/chat/react-hooks";
+import { ChatProvider } from "@siran/chat-react-hooks";
 import { createChatClient } from "@siran/chat-client";
 
 function App() {
@@ -37,7 +37,7 @@ function App() {
 Récupère un message spécifique par son ID depuis le store.
 
 ```tsx
-import { useMessage } from "@package/chat/react-hooks";
+import { useMessage } from "@siran/chat-react-hooks";
 
 function MessageView({ messageId }: { messageId: string }) {
   const message = useMessage(messageId);
@@ -61,7 +61,7 @@ Charge et suit les conversations. Modèle: **subscribe → engine pushes updates
 **Important**: Utilisez `useSubscribeToUser()` pour recevoir les mises à jour en temps réel.
 
 ```tsx
-import { useConversations, useSubscribeToUser } from "@package/chat/react-hooks";
+import { useConversations, useSubscribeToUser } from "@siran/chat-react-hooks";
 
 function ConversationsList({ userId }: { userId: string }) {
   // S'abonner aux événements de l'utilisateur pour recevoir les mises à jour
@@ -96,7 +96,7 @@ Charge et suit les messages d'une conversation. Modèle: **subscribe → engine
 **Important**: Utilisez `useSubscribeToConversation()` pour recevoir les mises à jour en temps réel.
 
 ```tsx
-import { useMessages, useSubscribeToConversation } from "@package/chat/react-hooks";
+import { useMessages, useSubscribeToConversation } from "@siran/chat-react-hooks";
 
 function MessagesList({ conversationId, userId }: { conversationId: string; userId: string }) {
   // S'abonner aux événements de la conversation pour recevoir les mises à jour
@@ -127,7 +127,7 @@ function MessagesList({ conversationId, userId }: { conversationId: string; user
 Obtient les utilisateurs en train de taper dans une conversation.
 
 ```tsx
-import { useTyping } from "@package/chat/react-hooks";
+import { useTyping } from "@siran/chat-react-hooks";
 
 function TypingIndicator({ conversationId }: { conversationId: string }) {
   const typingUsers = useTyping(conversationId);
@@ -149,7 +149,7 @@ function TypingIndicator({ conversationId }: { conversationId: string }) {
 Obtient la présence d'un utilisateur.
 
 ```tsx
-import { usePresence } from "@package/chat/react-hooks";
+import { usePresence } from "@siran/chat-react-hooks";
 
 function UserStatus({ userId }: { userId: string }) {
   const presence = usePresence(userId);
@@ -174,7 +174,7 @@ function UserStatus({ userId }: { userId: string }) {
 Envoie un message dans une conversation.
 
 ```tsx
-import { useSendMessage } from "@package/chat/react-hooks";
+import { useSendMessage } from "@siran/chat-react-hooks";
 
 function MessageInput({ conversationId, senderId }: Props) {
   const [content, setContent] = useState("");
@@ -215,7 +215,7 @@ function MessageInput({ conversationId, senderId }: Props) {
 Crée une nouvelle conversation.
 
 ```tsx
-import { useCreateConversation } from "@package/chat/react-hooks";
+import { useCreateConversation } from "@siran/chat-react-hooks";
 
 function CreateConversationButton({ participantIds }: Props) {
   const { createConversation, loading, error } = useCreateConversation();
@@ -245,7 +245,7 @@ function CreateConversationButton({ participantIds }: Props) {
 Édite un message existant.
 
 ```tsx
-import { useEditMessage } from "@package/chat/react-hooks";
+import { useEditMessage } from "@siran/chat-react-hooks";
 
 function EditMessageButton({ messageId }: { messageId: string }) {
   const [newContent, setNewContent] = useState("");
@@ -282,7 +282,7 @@ function EditMessageButton({ messageId }: { messageId: string }) {
 Supprime un message.
 
 ```tsx
-import { useDeleteMessage } from "@package/chat/react-hooks";
+import { useDeleteMessage } from "@siran/chat-react-hooks";
 
 function DeleteMessageButton({ messageId }: { messageId: string }) {
   const { deleteMessage, loading, error } = useDeleteMessage();
@@ -310,7 +310,7 @@ function DeleteMessageButton({ messageId }: { messageId: string }) {
 Marque un message comme lu.
 
 ```tsx
-import { useMarkMessageAsRead } from "@package/chat/react-hooks";
+import { useMarkMessageAsRead } from "@siran/chat-react-hooks";
 
 function MessageItem({ messageId }: { messageId: string }) {
   const { markAsRead, loading } = useMarkMessageAsRead();
@@ -331,7 +331,7 @@ function MessageItem({ messageId }: { messageId: string }) {
 S'abonne automatiquement aux événements d'une conversation. Se désabonne automatiquement lors du démontage.
 
 ```tsx
-import { useSubscribeToConversation } from "@package/chat/react-hooks";
+import { useSubscribeToConversation } from "@siran/chat-react-hooks";
 
 function ConversationView({ conversationId }: { conversationId: string }) {
   // S'abonner automatiquement aux événements de la conversation
@@ -348,7 +348,7 @@ function ConversationView({ conversationId }: { conversationId: string }) {
 S'abonne automatiquement aux événements d'un utilisateur. Se désabonne automatiquement lors du démontage.
 
 ```tsx
-import { useSubscribeToUser } from "@package/chat/react-hooks";
+import { useSubscribeToUser } from "@siran/chat-react-hooks";
 
 function UserPresence({ userId }: { userId: string }) {
   // S'abonner automatiquement aux événements de l'utilisateur
@@ -367,7 +367,7 @@ function UserPresence({ userId }: { userId: string }) {
 Accède directement au ChatClient. Utile pour des cas d'usage avancés.
 
 ```tsx
-import { useChat } from "@package/chat/react-hooks";
+import { useChat } from "@siran/chat-react-hooks";
 
 function AdvancedComponent() {
   const chat = useChat();

package/dist/ChatContext.d.ts

@@ -0,0 +1,55 @@
+/**
+ * ChatContext - Context React pour fournir le ChatClient à l'application.
+ */
+import { type ReactNode } from "react";
+import type { IChatClient } from "@siran/chat-client";
+/**
+ * Props pour le ChatProvider.
+ */
+export interface ChatProviderProps {
+    /**
+     * Instance du ChatClient à fournir à l'application.
+     */
+    client: IChatClient;
+    /**
+     * Composants enfants qui auront accès au ChatClient.
+     */
+    children: ReactNode;
+}
+/**
+ * Provider React pour le ChatClient.
+ *
+ * @example
+ * ```tsx
+ * import { ChatProvider } from "@siran/chat-react-hooks";
+ *
+ * function App() {
+ *   const chatClient = createChatClient({ engine, eventSubscriber });
+ *
+ *   return (
+ *     <ChatProvider client={chatClient}>
+ *       <YourApp />
+ *     </ChatProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function ChatProvider({ client, children }: ChatProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook pour accéder au ChatClient depuis le context.
+ *
+ * @throws {Error} Si utilisé en dehors d'un ChatProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const chat = useChat();
+ *
+ *   const handleSend = async () => {
+ *     await chat.sendMessage({ ... });
+ *   };
+ * }
+ * ```
+ */
+export declare function useChat(): IChatClient;
+//# sourceMappingURL=ChatContext.d.ts.map

package/dist/ChatContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatContext.d.ts","sourceRoot":"","sources":["../src/ChatContext.tsx"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAQtD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,MAAM,EAAE,WAAW,CAAC;IAEpB;;OAEG;IACH,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,iBAAiB,2CAEnE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,IAAI,WAAW,CAQrC"}

package/dist/hooks/useChatStore.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Hook pour s'abonner au store du ChatClient.
+ * Utilise useSyncExternalStore pour une intégration optimale avec React.
+ */
+import type { ChatStoreSnapshot } from "@siran/chat-client";
+/**
+ * Hook pour accéder au snapshot actuel du store.
+ * Se met automatiquement à jour lorsque le store change.
+ *
+ * @returns Le snapshot actuel du store contenant toutes les données mises en cache
+ *
+ * @example
+ * ```tsx
+ * function ChatData() {
+ *   const snapshot = useChatStore();
+ *
+ *   return (
+ *     <div>
+ *       <p>Conversations: {snapshot.conversations.length}</p>
+ *       <p>Messages dans conv-1: {snapshot.messages["conv-1"]?.length || 0}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useChatStore(): ChatStoreSnapshot;
+//# sourceMappingURL=useChatStore.d.ts.map

package/dist/hooks/useChatStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChatStore.d.ts","sourceRoot":"","sources":["../../src/hooks/useChatStore.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,IAAI,iBAAiB,CAahD"}

package/dist/hooks/useConversation.d.ts

@@ -0,0 +1,30 @@
+import type { Conversation } from '@siran/chat-core';
+/**
+ * Hook pour récupérer une conversation spécifique depuis le store du client.
+ *
+ * La conversation doit être déjà chargée dans le store (via useConversations ou subscription).
+ * Si la conversation n'est pas dans le store, elle sera undefined.
+ *
+ * Le hook s'abonne automatiquement aux changements du store via le client.
+ * Optimisé pour ne se re-rendre que lorsque la conversation spécifique change.
+ *
+ * @param conversationId - ID de la conversation à récupérer
+ *
+ * @returns La conversation trouvée ou undefined
+ *
+ * @example
+ * ```tsx
+ * function ChatHeader() {
+ *   const { conversationId } = useChatContext();
+ *   const conversation = useConversation(conversationId);
+ *
+ *   return (
+ *     <View>
+ *       <Text>{conversation?.name || 'Conversation'}</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+export declare function useConversation(conversationId: string | undefined): Conversation | undefined;
+//# sourceMappingURL=useConversation.d.ts.map

package/dist/hooks/useConversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConversation.d.ts","sourceRoot":"","sources":["../../src/hooks/useConversation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAiD5F"}

package/dist/hooks/useConversations.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Hook pour gérer les conversations.
+ */
+import type { GetConversationsInput } from "@siran/chat-core";
+/**
+ * Hook pour charger et suivre les conversations.
+ *
+ * Modèle: subscribe → engine pushes updates
+ * - Charge les conversations une fois au montage (si autoLoad est true)
+ * - Les mises à jour arrivent automatiquement via les événements temps réel du store
+ * - Pas de polling, tout passe par les événements temps réel
+ *
+ * @param input - Paramètres pour charger les conversations (optionnel)
+ * @param options - Options supplémentaires
+ * @param options.autoLoad - Si true, charge les conversations automatiquement au montage (défaut: true)
+ *
+ * @returns État des conversations et fonction pour recharger
+ *
+ * @example
+ * ```tsx
+ * function ConversationsList() {
+ *   // S'abonner aux événements de l'utilisateur pour recevoir les mises à jour
+ *   useSubscribeToUser("user-123");
+ *
+ *   const { conversations, loading, error, refetch } = useConversations({
+ *     userId: "user-123",
+ *     status: "active",
+ *   });
+ *
+ *   if (loading) return <div>Chargement...</div>;
+ *   if (error) return <div>Erreur: {error.message}</div>;
+ *
+ *   return (
+ *     <ul>
+ *       {conversations.map(conv => (
+ *         <li key={conv.id}>{conv.name || conv.id}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+export declare function useConversations(input?: GetConversationsInput, options?: {
+    autoLoad?: boolean;
+}): {
+    conversations: Conversation[];
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+//# sourceMappingURL=useConversations.d.ts.map

package/dist/hooks/useConversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConversations.d.ts","sourceRoot":"","sources":["../../src/hooks/useConversations.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAEV,qBAAqB,EAEtB,MAAM,kBAAkB,CAAC;AAW1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,CAAC,EAAE,qBAAqB,EAC7B,OAAO,CAAC,EAAE;IACR,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;;;;;EAkGF"}

package/dist/hooks/useConversationsWithLastMessages.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Hook pour récupérer les conversations avec leurs derniers messages.
+ */
+import type { Conversation, ChatMessage, GetConversationsInput } from "@siran/chat-core";
+/**
+ * Représente une conversation avec son dernier message.
+ */
+export interface ConversationWithLastMessage {
+    conversation: Conversation;
+    lastMessage: ChatMessage | undefined;
+}
+/**
+ * Hook optimisé pour charger les conversations avec leurs derniers messages.
+ *
+ * Utilise la requête optimisée qui charge tout en une seule requête.
+ * Les derniers messages sont automatiquement associés à leurs conversations.
+ *
+ * @param input - Paramètres pour charger les conversations
+ * @param options - Options supplémentaires
+ * @param options.autoLoad - Si true, charge automatiquement au montage (défaut: true)
+ *
+ * @returns État des conversations avec derniers messages et fonction pour recharger
+ *
+ * @example
+ * ```tsx
+ * function ConversationsList() {
+ *   useSubscribeToUser("user-123");
+ *
+ *   const { conversationsWithLastMessages, loading, error, refetch } = useConversationsWithLastMessages({
+ *     userId: "user-123",
+ *   });
+ *
+ *   if (loading) return <div>Chargement...</div>;
+ *   if (error) return <div>Erreur: {error.message}</div>;
+ *
+ *   return (
+ *     <ul>
+ *       {conversationsWithLastMessages.map(({ conversation, lastMessage }) => (
+ *         <li key={conversation.id}>
+ *           <span>{conversation.name || conversation.id}</span>
+ *           {lastMessage && <p>{lastMessage.content}</p>}
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+export declare function useConversationsWithLastMessages(input?: GetConversationsInput, options?: {
+    autoLoad?: boolean;
+}): {
+    conversationsWithLastMessages: ConversationWithLastMessage[];
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+//# sourceMappingURL=useConversationsWithLastMessages.d.ts.map

package/dist/hooks/useConversationsWithLastMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConversationsWithLastMessages.d.ts","sourceRoot":"","sources":["../../src/hooks/useConversationsWithLastMessages.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EACV,YAAY,EACZ,WAAW,EACX,qBAAqB,EACtB,MAAM,kBAAkB,CAAC;AAW1B;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,YAAY,EAAE,YAAY,CAAC;IAC3B,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,CAAC,EAAE,qBAAqB,EAC7B,OAAO,CAAC,EAAE;IACR,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;;;;;EAyGF"}

package/dist/hooks/useCreateConversation.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Hook pour créer une conversation.
+ */
+import type { CreateConversationInput, CreateConversationResult } from "@siran/chat-core";
+/**
+ * Hook pour créer une nouvelle conversation.
+ *
+ * @returns Fonction pour créer une conversation et état de la mutation
+ *
+ * @example
+ * ```tsx
+ * function CreateConversationButton({ participantIds }: Props) {
+ *   const { createConversation, loading, error } = useCreateConversation();
+ *
+ *   const handleCreate = async () => {
+ *     const result = await createConversation({
+ *       type: "direct",
+ *       participantIds,
+ *       createdBy: "user-123",
+ *     });
+ *
+ *     if (result.ok) {
+ *       console.log("Conversation créée:", result.conversation.id);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={loading}>
+ *       {loading ? "Création..." : "Créer une conversation"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useCreateConversation(): {
+    createConversation: (input: CreateConversationInput) => Promise<CreateConversationResult>;
+    loading: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=useCreateConversation.d.ts.map

package/dist/hooks/useCreateConversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCreateConversation.d.ts","sourceRoot":"","sources":["../../src/hooks/useCreateConversation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EACV,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,kBAAkB,CAAC;AAU1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,qBAAqB;gCAQnB,uBAAuB,KAAG,OAAO,CAAC,wBAAwB,CAAC;;;EAgC5E"}

package/dist/hooks/useDeleteMessage.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Hook pour supprimer un message.
+ */
+import type { DeleteMessageInput, DeleteMessageResult } from "@siran/chat-core";
+/**
+ * Hook pour supprimer un message.
+ *
+ * @returns Fonction pour supprimer un message et état de la mutation
+ *
+ * @example
+ * ```tsx
+ * function DeleteMessageButton({ messageId }: { messageId: string }) {
+ *   const { deleteMessage, loading, error } = useDeleteMessage();
+ *
+ *   const handleDelete = async () => {
+ *     if (confirm("Êtes-vous sûr de vouloir supprimer ce message ?")) {
+ *       const result = await deleteMessage({ messageId });
+ *
+ *       if (result.ok) {
+ *         console.log("Message supprimé");
+ *       }
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleDelete} disabled={loading}>
+ *       {loading ? "Suppression..." : "Supprimer"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useDeleteMessage(): {
+    deleteMessage: (input: DeleteMessageInput) => Promise<DeleteMessageResult>;
+    loading: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=useDeleteMessage.d.ts.map

package/dist/hooks/useDeleteMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDeleteMessage.d.ts","sourceRoot":"","sources":["../../src/hooks/useDeleteMessage.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,kBAAkB,CAAC;AAU1B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,gBAAgB;2BAQd,kBAAkB,KAAG,OAAO,CAAC,mBAAmB,CAAC;;;EAgClE"}

package/dist/hooks/useEditMessage.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Hook pour éditer un message.
+ */
+import type { EditMessageInput, EditMessageResult } from "@siran/chat-core";
+/**
+ * Hook pour éditer un message existant.
+ *
+ * @returns Fonction pour éditer un message et état de la mutation
+ *
+ * @example
+ * ```tsx
+ * function EditMessageButton({ messageId }: { messageId: string }) {
+ *   const [newContent, setNewContent] = useState("");
+ *   const { editMessage, loading, error } = useEditMessage();
+ *
+ *   const handleEdit = async () => {
+ *     const result = await editMessage({
+ *       messageId,
+ *       content: newContent,
+ *     });
+ *
+ *     if (result.ok) {
+ *       console.log("Message édité");
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <input
+ *         value={newContent}
+ *         onChange={(e) => setNewContent(e.target.value)}
+ *       />
+ *       <button onClick={handleEdit} disabled={loading}>
+ *         {loading ? "Édition..." : "Éditer"}
+ *       </button>
+ *       {error && <div>Erreur: {error.message}</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useEditMessage(): {
+    editMessage: (input: EditMessageInput) => Promise<EditMessageResult>;
+    loading: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=useEditMessage.d.ts.map

package/dist/hooks/useEditMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEditMessage.d.ts","sourceRoot":"","sources":["../../src/hooks/useEditMessage.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AAU1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,cAAc;yBAQZ,gBAAgB,KAAG,OAAO,CAAC,iBAAiB,CAAC;;;EAgC9D"}

package/dist/hooks/useLastMessage.d.ts

@@ -0,0 +1,8 @@
+import type { ChatMessage } from "@siran/chat-core";
+/**
+ * Hook pour récupérer le dernier message d'une conversation depuis le store.
+ *
+ * Optimisé pour ne se re-render que lorsque le dernier message de cette conversation change.
+ */
+export declare function useLastMessage(conversationId: string | undefined): ChatMessage | undefined;
+//# sourceMappingURL=useLastMessage.d.ts.map

package/dist/hooks/useLastMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLastMessage.d.ts","sourceRoot":"","sources":["../../src/hooks/useLastMessage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,CAqD1F"}

package/dist/hooks/useMarkMessageAsRead.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Hook pour marquer un message comme lu.
+ */
+import type { MarkMessageAsReadInput, MarkMessageAsReadResult } from "@siran/chat-core";
+/**
+ * Hook pour marquer un message comme lu.
+ *
+ * @returns Fonction pour marquer un message comme lu et état de la mutation
+ *
+ * @example
+ * ```tsx
+ * function MessageItem({ messageId }: { messageId: string }) {
+ *   const { markAsRead, loading } = useMarkMessageAsRead();
+ *
+ *   useEffect(() => {
+ *     // Marquer comme lu quand le message devient visible
+ *     markAsRead({ messageId });
+ *   }, [messageId, markAsRead]);
+ *
+ *   return <div>Message...</div>;
+ * }
+ * ```
+ */
+export declare function useMarkMessageAsRead(): {
+    markAsRead: (input: MarkMessageAsReadInput) => Promise<MarkMessageAsReadResult>;
+    loading: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=useMarkMessageAsRead.d.ts.map

package/dist/hooks/useMarkMessageAsRead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMarkMessageAsRead.d.ts","sourceRoot":"","sources":["../../src/hooks/useMarkMessageAsRead.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EACV,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,kBAAkB,CAAC;AAU1B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB;wBAQlB,sBAAsB,KAAG,OAAO,CAAC,uBAAuB,CAAC;;;EAgC1E"}

package/dist/hooks/useMessage.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Hook pour récupérer un message spécifique par son ID.
+ */
+import type { ChatMessage } from "@siran/chat-core";
+/**
+ * Hook pour récupérer un message spécifique depuis le store.
+ *
+ * Modèle: subscribe → engine pushes updates
+ * - Le message est récupéré depuis le store (mis à jour via les événements temps réel)
+ * - Retourne undefined si le message n'est pas trouvé dans le store
+ *
+ * @param messageId - ID du message à récupérer
+ *
+ * @returns Le message trouvé ou undefined
+ *
+ * @example
+ * ```tsx
+ * function MessageView({ messageId }: { messageId: string }) {
+ *   const message = useMessage(messageId);
+ *
+ *   if (!message) {
+ *     return <div>Message non trouvé</div>;
+ *   }
+ *
+ *   return <div>{message.content}</div>;
+ * }
+ * ```
+ */
+export declare function useMessage(messageId: string | undefined): ChatMessage | undefined;
+//# sourceMappingURL=useMessage.d.ts.map

package/dist/hooks/useMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMessage.d.ts","sourceRoot":"","sources":["../../src/hooks/useMessage.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,CAiBjF"}

package/dist/hooks/useMessages.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Hook pour gérer les messages d'une conversation.
+ */
+import type { GetMessagesInput } from "@siran/chat-core";
+/**
+ * Hook pour charger et suivre les messages d'une conversation.
+ *
+ * Modèle: subscribe → engine pushes updates
+ * - Charge les messages une fois au montage (si autoLoad est true)
+ * - Les mises à jour arrivent automatiquement via les événements temps réel du store
+ * - Pas de polling, tout passe par les événements temps réel
+ *
+ * @param conversationId - ID de la conversation
+ * @param userId - ID de l'utilisateur (requis pour vérifier les permissions)
+ * @param input - Paramètres supplémentaires pour charger les messages (optionnel)
+ * @param options - Options supplémentaires
+ * @param options.autoLoad - Si true, charge les messages automatiquement au montage (défaut: true)
+ *
+ * @returns État des messages et fonction pour recharger
+ *
+ * @example
+ * ```tsx
+ * function MessagesList({ conversationId, userId }: { conversationId: string; userId: string }) {
+ *   // S'abonner aux événements de la conversation pour recevoir les mises à jour
+ *   useSubscribeToConversation(conversationId);
+ *
+ *   const { messages, loading, error, refetch } = useMessages(conversationId, userId, {
+ *     options: { limit: 50 },
+ *   });
+ *
+ *   if (loading) return <div>Chargement...</div>;
+ *   if (error) return <div>Erreur: {error.message}</div>;
+ *
+ *   return (
+ *     <ul>
+ *       {messages.map(msg => (
+ *         <li key={msg.id}>{msg.content}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+export declare function useMessages(conversationId: string, userId: string, input?: {
+    options?: GetMessagesInput["options"];
+}, options?: {
+    autoLoad?: boolean;
+}): {
+    messages: ChatMessage[];
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+//# sourceMappingURL=useMessages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMessages.d.ts","sourceRoot":"","sources":["../../src/hooks/useMessages.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EAEV,gBAAgB,EAEjB,MAAM,kBAAkB,CAAC;AAW1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,WAAW,CACzB,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE;IACN,OAAO,CAAC,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC;CACvC,EACD,OAAO,CAAC,EAAE;IACR,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;;;;;EAiEF"}

package/dist/hooks/useMessagesPagination.d.ts

@@ -0,0 +1,27 @@
+import type { ChatMessage } from '@siran/chat-core';
+export interface UseMessagesPaginationOptions {
+    conversationId: string;
+    userId: string;
+    autoLoad?: boolean;
+}
+export interface UseMessagesPaginationResult {
+    messages: ChatMessage[];
+    loading: boolean;
+    error: Error | null;
+    loadingMore: boolean;
+    hasMoreMessages: boolean;
+    loadMoreMessages: () => void;
+}
+/**
+ * Hook sélecteur pour récupérer les messages paginés depuis le store.
+ * Le store est la seule source de vérité.
+ *
+ * @param options - Options de configuration
+ * @param options.conversationId - ID de la conversation
+ * @param options.userId - ID de l'utilisateur (requis pour vérifier les permissions)
+ * @param options.autoLoad - Si true, charge les messages automatiquement au montage (défaut: true)
+ *
+ * @returns État des messages et fonction pour charger plus
+ */
+export declare function useMessagesPagination({ conversationId, userId, autoLoad, }: UseMessagesPaginationOptions): UseMessagesPaginationResult;
+//# sourceMappingURL=useMessagesPagination.d.ts.map

package/dist/hooks/useMessagesPagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMessagesPagination.d.ts","sourceRoot":"","sources":["../../src/hooks/useMessagesPagination.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAgBpD,MAAM,WAAW,4BAA4B;IAC3C,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,EAAE,OAAO,CAAC;IACzB,gBAAgB,EAAE,MAAM,IAAI,CAAC;CAC9B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,cAAc,EACd,MAAM,EACN,QAAe,GAChB,EAAE,4BAA4B,GAAG,2BAA2B,CAwJ5D"}

package/dist/hooks/usePresence.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Hook pour gérer la présence des utilisateurs.
+ */
+/**
+ * Type pour le statut de présence d'un utilisateur.
+ */
+export type PresenceStatus = "online" | "offline" | "away" | "busy";
+/**
+ * Informations de présence d'un utilisateur.
+ */
+export interface Presence {
+    status: PresenceStatus;
+    lastSeenAt?: Date;
+}
+/**
+ * Hook pour obtenir la présence d'un utilisateur.
+ *
+ * @param userId - ID de l'utilisateur
+ *
+ * @returns Informations de présence de l'utilisateur, ou undefined si non disponible
+ *
+ * @example
+ * ```tsx
+ * function UserStatus({ userId }: { userId: string }) {
+ *   const presence = usePresence(userId);
+ *
+ *   if (!presence) return <span>Statut inconnu</span>;
+ *
+ *   return (
+ *     <div>
+ *       <span>Statut: {presence.status}</span>
+ *       {presence.lastSeenAt && (
+ *         <span>Vu pour la dernière fois: {presence.lastSeenAt.toLocaleString()}</span>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function usePresence(userId: string): Presence | undefined;
+//# sourceMappingURL=usePresence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usePresence.d.ts","sourceRoot":"","sources":["../../src/hooks/usePresence.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,cAAc,CAAC;IACvB,UAAU,CAAC,EAAE,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAGhE"}

package/dist/hooks/useSendMessage.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Hook pour envoyer un message.
+ */
+import type { SendMessageInput, SendMessageResult } from "@siran/chat-core";
+/**
+ * Hook pour envoyer un message dans une conversation.
+ *
+ * @returns Fonction pour envoyer un message et état de la mutation
+ *
+ * @example
+ * ```tsx
+ * function MessageInput({ conversationId, senderId }: Props) {
+ *   const [content, setContent] = useState("");
+ *   const { sendMessage, loading, error } = useSendMessage();
+ *
+ *   const handleSubmit = async (e: FormEvent) => {
+ *     e.preventDefault();
+ *
+ *     const result = await sendMessage({
+ *       conversationId,
+ *       senderId,
+ *       content,
+ *     });
+ *
+ *     if (result.ok) {
+ *       setContent("");
+ *     }
+ *   };
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit}>
+ *       <input
+ *         value={content}
+ *         onChange={(e) => setContent(e.target.value)}
+ *         disabled={loading}
+ *       />
+ *       <button type="submit" disabled={loading}>
+ *         {loading ? "Envoi..." : "Envoyer"}
+ *       </button>
+ *       {error && <div>Erreur: {error.message}</div>}
+ *     </form>
+ *   );
+ * }
+ * ```
+ */
+export declare function useSendMessage(): {
+    sendMessage: (input: SendMessageInput) => Promise<SendMessageResult>;
+    loading: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=useSendMessage.d.ts.map

package/dist/hooks/useSendMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSendMessage.d.ts","sourceRoot":"","sources":["../../src/hooks/useSendMessage.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AAU1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,cAAc;yBAQZ,gBAAgB,KAAG,OAAO,CAAC,iBAAiB,CAAC;;;EAgC9D"}

package/dist/hooks/useSubscribeToAllConversations.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Hook pour s'abonner automatiquement à toutes les conversations de l'utilisateur
+ * après le login.
+ *
+ * Cela permet de recevoir les messages en temps réel dans toutes les conversations,
+ * pas seulement celle qui est actuellement ouverte.
+ */
+export interface UseSubscribeToAllConversationsOptions {
+    userId: string;
+    enabled?: boolean;
+}
+/**
+ * Hook pour s'abonner automatiquement à toutes les conversations de l'utilisateur.
+ *
+ * @param options - Options de configuration
+ * @param options.userId - ID de l'utilisateur
+ * @param options.enabled - Active/désactive le hook (défaut: true)
+ * @returns { isReady } - isReady est true quand toutes les subscriptions sont établies
+ */
+export declare function useSubscribeToAllConversations({ userId, enabled, }: UseSubscribeToAllConversationsOptions): void;
+//# sourceMappingURL=useSubscribeToAllConversations.d.ts.map

package/dist/hooks/useSubscribeToAllConversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSubscribeToAllConversations.d.ts","sourceRoot":"","sources":["../../src/hooks/useSubscribeToAllConversations.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,MAAM,WAAW,qCAAqC;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAAC,EAC7C,MAAM,EACN,OAAc,GACf,EAAE,qCAAqC,GAAG,IAAI,CA2C9C"}

package/dist/hooks/useSubscribeToConversation.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Hook pour s'abonner aux événements d'une conversation.
+ */
+/**
+ * Hook pour s'abonner automatiquement aux événements d'une conversation.
+ * Se désabonne automatiquement lors du démontage du composant.
+ *
+ * @param conversationId - ID de la conversation à laquelle s'abonner
+ * @param options - Options de configuration
+ * @param options.enabled - Si false, ne s'abonne pas (défaut: true)
+ * @param options.userId - ID de l'utilisateur courant. Si fourni, marque automatiquement
+ *                         les messages comme "livrés" lors de l'abonnement
+ *
+ * @example
+ * ```tsx
+ * function ConversationView({ conversationId }: { conversationId: string }) {
+ *   const currentUser = useCurrentUser();
+ *
+ *   // S'abonner et marquer les messages comme livrés
+ *   useSubscribeToConversation(conversationId, {
+ *     userId: currentUser?.id,
+ *   });
+ *
+ *   const messages = useMessages(conversationId);
+ *
+ *   return <div>Messages...</div>;
+ * }
+ * ```
+ */
+export declare function useSubscribeToConversation(conversationId: string, options?: {
+    enabled?: boolean;
+    userId?: string;
+}): void;
+//# sourceMappingURL=useSubscribeToConversation.d.ts.map

package/dist/hooks/useSubscribeToConversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSubscribeToConversation.d.ts","sourceRoot":"","sources":["../../src/hooks/useSubscribeToConversation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,0BAA0B,CACxC,cAAc,EAAE,MAAM,EACtB,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GACnD,IAAI,CAgBN"}

package/dist/hooks/useSubscribeToUser.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Hook pour s'abonner aux événements d'un utilisateur.
+ */
+/**
+ * Hook pour s'abonner automatiquement aux événements d'un utilisateur.
+ * Se désabonne automatiquement lors du démontage du composant.
+ *
+ * @param userId - ID de l'utilisateur auquel s'abonner
+ * @param enabled - Si false, ne s'abonne pas (défaut: true)
+ *
+ * @example
+ * ```tsx
+ * function UserPresence({ userId }: { userId: string }) {
+ *   // S'abonner automatiquement aux événements de l'utilisateur
+ *   useSubscribeToUser(userId);
+ *
+ *   const presence = usePresence(userId);
+ *
+ *   return <div>Statut: {presence?.status}</div>;
+ * }
+ * ```
+ */
+export declare function useSubscribeToUser(userId: string, enabled?: boolean): void;
+//# sourceMappingURL=useSubscribeToUser.d.ts.map

package/dist/hooks/useSubscribeToUser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSubscribeToUser.d.ts","sourceRoot":"","sources":["../../src/hooks/useSubscribeToUser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,OAAc,GACtB,IAAI,CAcN"}

package/dist/hooks/useTrackPresence.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Hook pour tracker la présence de l'utilisateur courant.
+ */
+/**
+ * Hook pour tracker automatiquement la présence de l'utilisateur courant.
+ * Quand ce hook est actif, les autres utilisateurs verront cet utilisateur comme "en ligne".
+ * Se désactive automatiquement lors du démontage du composant.
+ *
+ * @param userId - ID de l'utilisateur dont on veut tracker la présence
+ * @param enabled - Si false, ne track pas la présence (défaut: true)
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const currentUser = useCurrentUser();
+ *
+ *   // Track la présence de l'utilisateur connecté
+ *   useTrackPresence(currentUser?.id || '', !!currentUser);
+ *
+ *   return <MainApp />;
+ * }
+ * ```
+ */
+export declare function useTrackPresence(userId: string, enabled?: boolean): void;
+//# sourceMappingURL=useTrackPresence.d.ts.map

package/dist/hooks/useTrackPresence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTrackPresence.d.ts","sourceRoot":"","sources":["../../src/hooks/useTrackPresence.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,OAAc,GAAG,IAAI,CAc9E"}

package/dist/hooks/useTyping.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Hook pour gérer l'état de frappe (typing) dans une conversation.
+ */
+/**
+ * Hook pour obtenir les utilisateurs en train de taper dans une conversation.
+ *
+ * @param conversationId - ID de la conversation
+ *
+ * @returns Liste des IDs des utilisateurs en train de taper
+ *
+ * @example
+ * ```tsx
+ * function TypingIndicator({ conversationId }: { conversationId: string }) {
+ *   const typingUsers = useTyping(conversationId);
+ *
+ *   if (typingUsers.length === 0) return null;
+ *
+ *   return (
+ *     <div>
+ *       {typingUsers.length === 1
+ *         ? `Utilisateur ${typingUsers[0]} est en train de taper...`
+ *         : `${typingUsers.length} utilisateurs sont en train de taper...`}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useTyping(conversationId: string): string[];
+//# sourceMappingURL=useTyping.d.ts.map

package/dist/hooks/useTyping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTyping.d.ts","sourceRoot":"","sources":["../../src/hooks/useTyping.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE,CAG1D"}

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @siran/chat-react-hooks
+ *
+ * Hooks et contextes React réutilisables pour intégrer le système de chat
+ * dans des applications React.
+ *
+ * @example
+ * ```tsx
+ * import { ChatProvider, useConversations, useMessages, useSendMessage } from "@siran/chat-react-hooks";
+ *
+ * function App() {
+ *   const chatClient = createChatClient({ engine, eventSubscriber });
+ *
+ *   return (
+ *     <ChatProvider client={chatClient}>
+ *       <ChatApp />
+ *     </ChatProvider>
+ *   );
+ * }
+ *
+ * function ChatApp() {
+ *   const { conversations } = useConversations({ userId: "user-123" });
+ *   const { messages } = useMessages("conv-456");
+ *   const { sendMessage } = useSendMessage();
+ *
+ *   return <div>...</div>;
+ * }
+ * ```
+ */
+export { ChatProvider, useChat, type ChatProviderProps, } from "./ChatContext";
+export { useConversations, } from "./hooks/useConversations";
+export { useConversationsWithLastMessages, type ConversationWithLastMessage, } from "./hooks/useConversationsWithLastMessages";
+export { useConversation, } from "./hooks/useConversation";
+export { useMessages, } from "./hooks/useMessages";
+export { useMessage, } from "./hooks/useMessage";
+export { useLastMessage, } from "./hooks/useLastMessage";
+export { useTyping, } from "./hooks/useTyping";
+export { usePresence, type Presence, type PresenceStatus, } from "./hooks/usePresence";
+export { useMessagesPagination, } from "./hooks/useMessagesPagination";
+export { useSendMessage, } from "./hooks/useSendMessage";
+export { useCreateConversation, } from "./hooks/useCreateConversation";
+export { useEditMessage, } from "./hooks/useEditMessage";
+export { useDeleteMessage, } from "./hooks/useDeleteMessage";
+export { useMarkMessageAsRead, } from "./hooks/useMarkMessageAsRead";
+export { useSubscribeToConversation, } from "./hooks/useSubscribeToConversation";
+export { useSubscribeToUser, } from "./hooks/useSubscribeToUser";
+export { useTrackPresence, } from "./hooks/useTrackPresence";
+export { useSubscribeToAllConversations, type UseSubscribeToAllConversationsOptions, } from "./hooks/useSubscribeToAllConversations";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,EACL,YAAY,EACZ,OAAO,EACP,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,gBAAgB,GACjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,gCAAgC,EAChC,KAAK,2BAA2B,GACjC,MAAM,0CAA0C,CAAC;AAClD,OAAO,EACL,eAAe,GAChB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,WAAW,GACZ,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,UAAU,GACX,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,cAAc,GACf,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,WAAW,EACX,KAAK,QAAQ,EACb,KAAK,cAAc,GACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,qBAAqB,GACtB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EACL,cAAc,GACf,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,qBAAqB,GACtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,cAAc,GACf,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,gBAAgB,GACjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,oBAAoB,GACrB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,0BAA0B,GAC3B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,kBAAkB,GACnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,gBAAgB,GACjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,8BAA8B,EAC9B,KAAK,qCAAqC,GAC3C,MAAM,wCAAwC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siran/chat-react-hooks",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "exports": {
     ".": {
@@ -10,17 +10,17 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build:js": "bun build src/index.ts --outdir dist --target=node",
     "build:types": "tsc --emitDeclarationOnly",
     "build": "bun run build:js && bun run build:types"
   },
   "dependencies": {
-    "react": "^19",
-    "react-dom": "^19",
-    "@siran/chat-client": "workspace:*",
-    "@siran/chat-core": "workspace:*"
+    "@siran/chat-client": "0.1.1",
+    "@siran/chat-core": "0.1.0"
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.3.4",
@@ -29,5 +29,9 @@
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "happy-dom": "^17.4.4"
+  },
+  "peerDependencies": {
+    "react": "^19",
+    "react-dom": "^19"
   }
 }