@mieweb/ui 0.9.0 → 0.10.0-dev.0

package/dist/{chunk-FQBTGS3E.cjs → chunk-OFUKTVBN.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunk5BVFVXHN_cjs = require('./chunk-5BVFVXHN.cjs');
+var chunkOYQ7GYAA_cjs = require('./chunk-OYQ7GYAA.cjs');
 var chunkS5RVSXDV_cjs = require('./chunk-S5RVSXDV.cjs');
-var React5 = require('react');
+var React = require('react');
 var classVarianceAuthority = require('class-variance-authority');
 var jsxRuntime = require('react/jsx-runtime');
 
@@ -24,8 +24,287 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React5__namespace = /*#__PURE__*/_interopNamespace(React5);
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
+function useMessages(options) {
+  const {
+    initialMessages = [],
+    currentUser,
+    onSend,
+    onRetry,
+    onLoadMore
+  } = options;
+  const [messages, setMessages] = React__namespace.useState(initialMessages);
+  const [isSending, setIsSending] = React__namespace.useState(false);
+  const [isLoadingMore, setIsLoadingMore] = React__namespace.useState(false);
+  React__namespace.useEffect(() => {
+    setMessages(initialMessages);
+  }, [initialMessages]);
+  const addMessage = React__namespace.useCallback((message) => {
+    setMessages((prev) => {
+      if (prev.some((m) => m.id === message.id)) {
+        return prev;
+      }
+      return [...prev, message];
+    });
+  }, []);
+  const updateMessage = React__namespace.useCallback(
+    (messageId, updates) => {
+      setMessages(
+        (prev) => prev.map((m) => m.id === messageId ? { ...m, ...updates } : m)
+      );
+    },
+    []
+  );
+  const removeMessage = React__namespace.useCallback((messageId) => {
+    setMessages((prev) => prev.filter((m) => m.id !== messageId));
+  }, []);
+  const updateStatus = React__namespace.useCallback(
+    (messageId, status) => {
+      updateMessage(messageId, { status });
+    },
+    [updateMessage]
+  );
+  const markAsRead = React__namespace.useCallback(
+    (messageId) => {
+      updateStatus(messageId, "read");
+    },
+    [updateStatus]
+  );
+  const sendMessage = React__namespace.useCallback(
+    async (newMessage) => {
+      const optimisticId = `optimistic-${Date.now()}`;
+      const optimisticMessage = {
+        id: optimisticId,
+        type: "text",
+        content: newMessage.content,
+        sender: currentUser,
+        timestamp: /* @__PURE__ */ new Date(),
+        status: "sending",
+        attachments: []
+        // Would handle attachment uploads here
+      };
+      addMessage(optimisticMessage);
+      setIsSending(true);
+      try {
+        if (onSend) {
+          const sentMessage = await onSend(newMessage);
+          setMessages(
+            (prev) => prev.map((m) => m.id === optimisticId ? sentMessage : m)
+          );
+        } else {
+          updateStatus(optimisticId, "sent");
+        }
+      } catch {
+        updateStatus(optimisticId, "failed");
+      } finally {
+        setIsSending(false);
+      }
+    },
+    [currentUser, onSend, addMessage, updateStatus]
+  );
+  const retryMessage = React__namespace.useCallback(
+    async (messageId) => {
+      updateStatus(messageId, "sending");
+      try {
+        if (onRetry) {
+          await onRetry(messageId);
+          updateStatus(messageId, "sent");
+        }
+      } catch {
+        updateStatus(messageId, "failed");
+      }
+    },
+    [onRetry, updateStatus]
+  );
+  const loadMore = React__namespace.useCallback(async () => {
+    if (isLoadingMore || !onLoadMore) return;
+    setIsLoadingMore(true);
+    try {
+      const olderMessages = await onLoadMore();
+      setMessages((prev) => [...olderMessages, ...prev]);
+    } finally {
+      setIsLoadingMore(false);
+    }
+  }, [isLoadingMore, onLoadMore]);
+  return {
+    messages,
+    addMessage,
+    updateMessage,
+    removeMessage,
+    sendMessage,
+    retryMessage,
+    loadMore,
+    isSending,
+    isLoadingMore,
+    markAsRead,
+    updateStatus
+  };
+}
+function useTypingIndicator(options = {}) {
+  const {
+    typingParticipants: initialParticipants = [],
+    debounceTime = 2e3,
+    onTypingStart,
+    onTypingStop
+  } = options;
+  const [participants, setParticipants] = React__namespace.useState(initialParticipants);
+  const [isLocalTyping, setIsLocalTyping] = React__namespace.useState(false);
+  const typingTimeoutRef = React__namespace.useRef(null);
+  React__namespace.useEffect(() => {
+    setParticipants(initialParticipants);
+  }, [initialParticipants]);
+  const startTyping = React__namespace.useCallback(() => {
+    if (!isLocalTyping) {
+      setIsLocalTyping(true);
+      onTypingStart?.();
+    }
+    if (typingTimeoutRef.current) {
+      clearTimeout(typingTimeoutRef.current);
+    }
+    typingTimeoutRef.current = setTimeout(() => {
+      setIsLocalTyping(false);
+      onTypingStop?.();
+    }, debounceTime);
+  }, [isLocalTyping, debounceTime, onTypingStart, onTypingStop]);
+  const stopTyping = React__namespace.useCallback(() => {
+    if (typingTimeoutRef.current) {
+      clearTimeout(typingTimeoutRef.current);
+    }
+    setIsLocalTyping(false);
+    onTypingStop?.();
+  }, [onTypingStop]);
+  React__namespace.useEffect(() => {
+    return () => {
+      if (typingTimeoutRef.current) {
+        clearTimeout(typingTimeoutRef.current);
+      }
+    };
+  }, []);
+  const typingState = React__namespace.useMemo(
+    () => ({
+      participants,
+      lastUpdated: /* @__PURE__ */ new Date()
+    }),
+    [participants]
+  );
+  return {
+    typingState,
+    startTyping,
+    stopTyping,
+    setTypingParticipants: setParticipants
+  };
+}
+function useMessageScroll(options) {
+  const { messages, currentUserId, threshold = 100 } = options;
+  const scrollContainerRef = React__namespace.useRef(null);
+  const bottomRef = React__namespace.useRef(null);
+  const [isScrolledUp, setIsScrolledUp] = React__namespace.useState(false);
+  const prevMessageCountRef = React__namespace.useRef(messages.length);
+  React__namespace.useEffect(() => {
+    const container = scrollContainerRef.current;
+    if (!container) return;
+    const handleScroll = () => {
+      const { scrollTop, scrollHeight, clientHeight } = container;
+      const isAtBottom = scrollHeight - scrollTop - clientHeight < threshold;
+      setIsScrolledUp(!isAtBottom);
+    };
+    container.addEventListener("scroll", handleScroll);
+    return () => container.removeEventListener("scroll", handleScroll);
+  }, [threshold]);
+  const scrollToBottom = React__namespace.useCallback((smooth = true) => {
+    bottomRef.current?.scrollIntoView({
+      behavior: smooth ? "smooth" : "auto"
+    });
+  }, []);
+  React__namespace.useEffect(() => {
+    const messageCountChanged = messages.length !== prevMessageCountRef.current;
+    prevMessageCountRef.current = messages.length;
+    if (!messageCountChanged) return;
+    const lastMessage = messages[messages.length - 1];
+    const isOutgoing = lastMessage?.sender.id === currentUserId;
+    if (isOutgoing || !isScrolledUp) {
+      scrollToBottom(true);
+    }
+  }, [messages, currentUserId, isScrolledUp, scrollToBottom]);
+  return {
+    scrollContainerRef,
+    bottomRef,
+    isScrolledUp,
+    scrollToBottom
+  };
+}
+function useReadReceipts(options) {
+  const { currentUserId, onMarkRead, threshold = 0.5 } = options;
+  const observerRef = React__namespace.useRef(null);
+  const observedMessagesRef = React__namespace.useRef(/* @__PURE__ */ new Set());
+  React__namespace.useEffect(() => {
+    observerRef.current = new IntersectionObserver(
+      (entries) => {
+        entries.forEach((entry) => {
+          if (entry.isIntersecting) {
+            const messageId = entry.target.getAttribute("data-message-id");
+            if (messageId && !observedMessagesRef.current.has(messageId)) {
+              observedMessagesRef.current.add(messageId);
+              onMarkRead?.(messageId);
+            }
+          }
+        });
+      },
+      { threshold }
+    );
+    return () => {
+      observerRef.current?.disconnect();
+    };
+  }, [onMarkRead, threshold]);
+  const observeMessage = React__namespace.useCallback(
+    (element, message) => {
+      if (!element || !observerRef.current) return;
+      if (message.sender.id !== currentUserId && message.status !== "read" && !observedMessagesRef.current.has(message.id)) {
+        element.setAttribute("data-message-id", message.id);
+        observerRef.current.observe(element);
+      }
+    },
+    [currentUserId]
+  );
+  return { observeMessage };
+}
+function useTypingEmulation({
+  value,
+  onTypingStart,
+  onTypingStop
+}) {
+  const [isTyping, setIsTyping] = React__namespace.useState(false);
+  const typingTimeoutRef = React__namespace.useRef(
+    null
+  );
+  React__namespace.useEffect(() => {
+    if (!onTypingStart && !onTypingStop) return;
+    if (value.length > 0 && !isTyping) {
+      setIsTyping(true);
+      onTypingStart?.();
+    }
+    if (typingTimeoutRef.current) {
+      clearTimeout(typingTimeoutRef.current);
+    }
+    typingTimeoutRef.current = setTimeout(() => {
+      if (isTyping) {
+        setIsTyping(false);
+        onTypingStop?.();
+      }
+    }, 2e3);
+    return () => {
+      if (typingTimeoutRef.current) {
+        clearTimeout(typingTimeoutRef.current);
+      }
+    };
+  }, [value, isTyping, onTypingStart, onTypingStop]);
+  const stopTyping = React__namespace.useCallback(() => {
+    setIsTyping(false);
+    onTypingStop?.();
+  }, [onTypingStop]);
+  return { stopTyping };
+}
 var statusIconVariants = classVarianceAuthority.cva(
   "inline-flex items-center gap-0.5 text-current",
   {
@@ -406,7 +685,7 @@ function defaultFormatTimestamp(timestamp) {
     minute: "2-digit"
   });
 }
-var MessageBubble = React5__namespace.forwardRef(
+var MessageBubble = React__namespace.forwardRef(
   ({
     className,
     message,
@@ -881,7 +1160,7 @@ function LoadMoreButton({
   );
 }
 LoadMoreButton.displayName = "LoadMoreButton";
-var MessageList = React5__namespace.forwardRef(
+var MessageList = React__namespace.forwardRef(
   ({
     messages,
     currentUser,
@@ -900,19 +1179,19 @@ var MessageList = React5__namespace.forwardRef(
     className,
     autoScroll = "onNewMessage"
   }, ref) => {
-    const scrollContainerRef = React5__namespace.useRef(null);
-    const bottomRef = React5__namespace.useRef(null);
-    const [isUserScrolled, setIsUserScrolled] = React5__namespace.useState(false);
-    const prevMessageCountRef = React5__namespace.useRef(messages.length);
-    React5__namespace.useImperativeHandle(ref, () => scrollContainerRef.current);
-    const handleScroll = React5__namespace.useCallback(() => {
+    const scrollContainerRef = React__namespace.useRef(null);
+    const bottomRef = React__namespace.useRef(null);
+    const [isUserScrolled, setIsUserScrolled] = React__namespace.useState(false);
+    const prevMessageCountRef = React__namespace.useRef(messages.length);
+    React__namespace.useImperativeHandle(ref, () => scrollContainerRef.current);
+    const handleScroll = React__namespace.useCallback(() => {
       const container = scrollContainerRef.current;
       if (!container) return;
       const { scrollTop, scrollHeight, clientHeight } = container;
       const isAtBottom = scrollHeight - scrollTop - clientHeight < 100;
       setIsUserScrolled(!isAtBottom);
     }, []);
-    React5__namespace.useEffect(() => {
+    React__namespace.useEffect(() => {
       const container = scrollContainerRef.current;
       const bottom = bottomRef.current;
       if (!container || !bottom) return;
@@ -928,7 +1207,7 @@ var MessageList = React5__namespace.forwardRef(
         }
       }
     }, [messages, currentUser.id, autoScroll, isUserScrolled]);
-    React5__namespace.useEffect(() => {
+    React__namespace.useEffect(() => {
       const bottom = bottomRef.current;
       if (bottom && !isLoading) {
         bottom.scrollIntoView();
@@ -981,7 +1260,7 @@ var MessageList = React5__namespace.forwardRef(
             {
               "data-slot": "message-list-content",
               className: "flex flex-col gap-1 p-4",
-              children: messageGroups.map((group) => /* @__PURE__ */ jsxRuntime.jsxs(React5__namespace.Fragment, { children: [
+              children: messageGroups.map((group) => /* @__PURE__ */ jsxRuntime.jsxs(React__namespace.Fragment, { children: [
                 groupByDate && group.label && /* @__PURE__ */ jsxRuntime.jsx(DateSeparator, { label: group.label }),
                 group.messages.map((message, index) => {
                   const prevMessage = group.messages[index - 1];
@@ -1120,7 +1399,7 @@ function formatLastSeen(date) {
   if (diffDays < 7) return `${diffDays}d ago`;
   return date.toLocaleDateString();
 }
-var ConversationHeader = React5__namespace.forwardRef(
+var ConversationHeader = React__namespace.forwardRef(
   ({
     className,
     size,
@@ -1242,7 +1521,7 @@ var ConversationHeader = React5__namespace.forwardRef(
   }
 );
 ConversationHeader.displayName = "ConversationHeader";
-var ConversationListItem = React5__namespace.forwardRef(({ className, conversation, isSelected, onSelect, ...props }, ref) => {
+var ConversationListItem = React__namespace.forwardRef(({ className, conversation, isSelected, onSelect, ...props }, ref) => {
   const participant = conversation.participants.find((p) => !p.isCurrentUser);
   const title = getConversationTitle(conversation, participant);
   const avatarUrl = conversation.avatarUrl || participant?.avatarUrl;
@@ -1450,7 +1729,7 @@ function ConversationListSkeleton({
 }
 ConversationListSkeleton.displayName = "ConversationListSkeleton";
 function LightboxModal({ attachment, onClose }) {
-  React5__namespace.useEffect(() => {
+  React__namespace.useEffect(() => {
     const handleKeyDown = (event) => {
       if (event.key === "Escape") {
         onClose();
@@ -1547,7 +1826,7 @@ function LightboxModal({ attachment, onClose }) {
   );
 }
 LightboxModal.displayName = "LightboxModal";
-var MessageThread = React5__namespace.forwardRef(
+var MessageThread = React__namespace.forwardRef(
   ({
     conversation,
     messages,
@@ -1578,8 +1857,23 @@ var MessageThread = React5__namespace.forwardRef(
     onError,
     className
   }, ref) => {
-    const [lightboxAttachment, setLightboxAttachment] = React5__namespace.useState(null);
-    const [replyTo, setReplyTo] = React5__namespace.useState(null);
+    const [lightboxAttachment, setLightboxAttachment] = React__namespace.useState(null);
+    const [replyTo, setReplyTo] = React__namespace.useState(null);
+    const composerRef = React__namespace.useRef(null);
+    React__namespace.useEffect(() => {
+      chunkOYQ7GYAA_cjs.notifyComposerMigrationOnce("MessageThread");
+    }, []);
+    const [draft, setDraft] = React__namespace.useState("");
+    const draftEpochRef = React__namespace.useRef(0);
+    const handleDraftChange = React__namespace.useCallback((value) => {
+      draftEpochRef.current += 1;
+      setDraft(value);
+    }, []);
+    const { stopTyping } = useTypingEmulation({
+      value: draft,
+      onTypingStart: eventHandlers.onTypingStart,
+      onTypingStop: eventHandlers.onTypingStop
+    });
     const participant = conversation?.type === "direct" ? conversation.participants.find((p) => p.id !== currentUser.id) : void 0;
     const handleAttachmentClick = (attachment, message) => {
       if (attachment.type === "image" || attachment.type === "video") {
@@ -1588,12 +1882,21 @@ var MessageThread = React5__namespace.forwardRef(
       eventHandlers.onAttachmentClick?.(attachment, message);
     };
     const handleSendMessage = async (newMessage) => {
+      stopTyping();
       const messageWithReply = {
         ...newMessage,
         replyToId: replyTo?.id || newMessage.replyToId
       };
       setReplyTo(null);
-      await eventHandlers.onSendMessage?.(messageWithReply);
+      const epoch = draftEpochRef.current;
+      try {
+        await Promise.resolve(eventHandlers.onSendMessage?.(messageWithReply));
+      } catch (error) {
+        if (draftEpochRef.current === epoch) {
+          setDraft(newMessage.content);
+        }
+        throw error;
+      }
     };
     return /* @__PURE__ */ jsxRuntime.jsxs(
       "div",
@@ -1617,11 +1920,13 @@ var MessageThread = React5__namespace.forwardRef(
             }
           ),
           /* @__PURE__ */ jsxRuntime.jsx(
-            chunk5BVFVXHN_cjs.DragDropZone,
+            chunkOYQ7GYAA_cjs.DragDropZone,
             {
-              onFilesDropped: () => {
-                onError?.("Drop files on the composer to attach them");
+              onFilesDropped: (files) => {
+                composerRef.current?.addFiles(files);
               },
+              maxFiles: maxAttachments,
+              onError,
               disabled: !showAttachmentPicker,
               className: "flex-1 overflow-hidden",
               children: /* @__PURE__ */ jsxRuntime.jsx(
@@ -1647,23 +1952,38 @@ var MessageThread = React5__namespace.forwardRef(
             }
           ),
           /* @__PURE__ */ jsxRuntime.jsx(
-            chunk5BVFVXHN_cjs.MessageComposer,
+            "div",
             {
-              onSend: handleSendMessage,
-              onTypingStart: eventHandlers.onTypingStart,
-              onTypingStop: eventHandlers.onTypingStop,
-              placeholder,
-              maxLength: maxMessageLength,
-              showCharacterCount,
-              isSending,
-              showAttachmentPicker,
-              showCameraButton,
-              acceptedFileTypes,
-              maxFileSize,
-              maxAttachments,
-              onError,
-              replyTo,
-              onCancelReply: () => setReplyTo(null)
+              "data-slot": "message-thread-composer",
+              className: "shrink-0 border-t border-neutral-200 p-3 dark:border-neutral-700",
+              children: /* @__PURE__ */ jsxRuntime.jsx(
+                chunkOYQ7GYAA_cjs.ChatComposer,
+                {
+                  ref: composerRef,
+                  value: draft,
+                  onValueChange: handleDraftChange,
+                  onSend: handleSendMessage,
+                  placeholder,
+                  maxLength: maxMessageLength,
+                  showCharacterCount,
+                  isSending,
+                  allowAttachments: showAttachmentPicker,
+                  acceptedFileTypes: acceptedFileTypes ?? chunkOYQ7GYAA_cjs.DEFAULT_ACCEPTED_FILE_TYPES,
+                  maxFileSize: maxFileSize ?? chunkOYQ7GYAA_cjs.DEFAULT_MAX_FILE_SIZE,
+                  maxAttachments,
+                  onError,
+                  replyTo,
+                  onCancelReply: () => setReplyTo(null),
+                  inputLabel: "Message",
+                  micSlot: showCameraButton ? /* @__PURE__ */ jsxRuntime.jsx(
+                    chunkOYQ7GYAA_cjs.CameraButton,
+                    {
+                      onCapture: (file) => composerRef.current?.addFiles([file]),
+                      disabled: isSending
+                    }
+                  ) : void 0
+                }
+              )
             }
           ),
           /* @__PURE__ */ jsxRuntime.jsx(
@@ -1743,249 +2063,6 @@ function MessagingSplitView({
   );
 }
 MessagingSplitView.displayName = "MessagingSplitView";
-function useMessages(options) {
-  const {
-    initialMessages = [],
-    currentUser,
-    onSend,
-    onRetry,
-    onLoadMore
-  } = options;
-  const [messages, setMessages] = React5__namespace.useState(initialMessages);
-  const [isSending, setIsSending] = React5__namespace.useState(false);
-  const [isLoadingMore, setIsLoadingMore] = React5__namespace.useState(false);
-  React5__namespace.useEffect(() => {
-    setMessages(initialMessages);
-  }, [initialMessages]);
-  const addMessage = React5__namespace.useCallback((message) => {
-    setMessages((prev) => {
-      if (prev.some((m) => m.id === message.id)) {
-        return prev;
-      }
-      return [...prev, message];
-    });
-  }, []);
-  const updateMessage = React5__namespace.useCallback(
-    (messageId, updates) => {
-      setMessages(
-        (prev) => prev.map((m) => m.id === messageId ? { ...m, ...updates } : m)
-      );
-    },
-    []
-  );
-  const removeMessage = React5__namespace.useCallback((messageId) => {
-    setMessages((prev) => prev.filter((m) => m.id !== messageId));
-  }, []);
-  const updateStatus = React5__namespace.useCallback(
-    (messageId, status) => {
-      updateMessage(messageId, { status });
-    },
-    [updateMessage]
-  );
-  const markAsRead = React5__namespace.useCallback(
-    (messageId) => {
-      updateStatus(messageId, "read");
-    },
-    [updateStatus]
-  );
-  const sendMessage = React5__namespace.useCallback(
-    async (newMessage) => {
-      const optimisticId = `optimistic-${Date.now()}`;
-      const optimisticMessage = {
-        id: optimisticId,
-        type: "text",
-        content: newMessage.content,
-        sender: currentUser,
-        timestamp: /* @__PURE__ */ new Date(),
-        status: "sending",
-        attachments: []
-        // Would handle attachment uploads here
-      };
-      addMessage(optimisticMessage);
-      setIsSending(true);
-      try {
-        if (onSend) {
-          const sentMessage = await onSend(newMessage);
-          setMessages(
-            (prev) => prev.map((m) => m.id === optimisticId ? sentMessage : m)
-          );
-        } else {
-          updateStatus(optimisticId, "sent");
-        }
-      } catch {
-        updateStatus(optimisticId, "failed");
-      } finally {
-        setIsSending(false);
-      }
-    },
-    [currentUser, onSend, addMessage, updateStatus]
-  );
-  const retryMessage = React5__namespace.useCallback(
-    async (messageId) => {
-      updateStatus(messageId, "sending");
-      try {
-        if (onRetry) {
-          await onRetry(messageId);
-          updateStatus(messageId, "sent");
-        }
-      } catch {
-        updateStatus(messageId, "failed");
-      }
-    },
-    [onRetry, updateStatus]
-  );
-  const loadMore = React5__namespace.useCallback(async () => {
-    if (isLoadingMore || !onLoadMore) return;
-    setIsLoadingMore(true);
-    try {
-      const olderMessages = await onLoadMore();
-      setMessages((prev) => [...olderMessages, ...prev]);
-    } finally {
-      setIsLoadingMore(false);
-    }
-  }, [isLoadingMore, onLoadMore]);
-  return {
-    messages,
-    addMessage,
-    updateMessage,
-    removeMessage,
-    sendMessage,
-    retryMessage,
-    loadMore,
-    isSending,
-    isLoadingMore,
-    markAsRead,
-    updateStatus
-  };
-}
-function useTypingIndicator(options = {}) {
-  const {
-    typingParticipants: initialParticipants = [],
-    debounceTime = 2e3,
-    onTypingStart,
-    onTypingStop
-  } = options;
-  const [participants, setParticipants] = React5__namespace.useState(initialParticipants);
-  const [isLocalTyping, setIsLocalTyping] = React5__namespace.useState(false);
-  const typingTimeoutRef = React5__namespace.useRef(null);
-  React5__namespace.useEffect(() => {
-    setParticipants(initialParticipants);
-  }, [initialParticipants]);
-  const startTyping = React5__namespace.useCallback(() => {
-    if (!isLocalTyping) {
-      setIsLocalTyping(true);
-      onTypingStart?.();
-    }
-    if (typingTimeoutRef.current) {
-      clearTimeout(typingTimeoutRef.current);
-    }
-    typingTimeoutRef.current = setTimeout(() => {
-      setIsLocalTyping(false);
-      onTypingStop?.();
-    }, debounceTime);
-  }, [isLocalTyping, debounceTime, onTypingStart, onTypingStop]);
-  const stopTyping = React5__namespace.useCallback(() => {
-    if (typingTimeoutRef.current) {
-      clearTimeout(typingTimeoutRef.current);
-    }
-    setIsLocalTyping(false);
-    onTypingStop?.();
-  }, [onTypingStop]);
-  React5__namespace.useEffect(() => {
-    return () => {
-      if (typingTimeoutRef.current) {
-        clearTimeout(typingTimeoutRef.current);
-      }
-    };
-  }, []);
-  const typingState = React5__namespace.useMemo(
-    () => ({
-      participants,
-      lastUpdated: /* @__PURE__ */ new Date()
-    }),
-    [participants]
-  );
-  return {
-    typingState,
-    startTyping,
-    stopTyping,
-    setTypingParticipants: setParticipants
-  };
-}
-function useMessageScroll(options) {
-  const { messages, currentUserId, threshold = 100 } = options;
-  const scrollContainerRef = React5__namespace.useRef(null);
-  const bottomRef = React5__namespace.useRef(null);
-  const [isScrolledUp, setIsScrolledUp] = React5__namespace.useState(false);
-  const prevMessageCountRef = React5__namespace.useRef(messages.length);
-  React5__namespace.useEffect(() => {
-    const container = scrollContainerRef.current;
-    if (!container) return;
-    const handleScroll = () => {
-      const { scrollTop, scrollHeight, clientHeight } = container;
-      const isAtBottom = scrollHeight - scrollTop - clientHeight < threshold;
-      setIsScrolledUp(!isAtBottom);
-    };
-    container.addEventListener("scroll", handleScroll);
-    return () => container.removeEventListener("scroll", handleScroll);
-  }, [threshold]);
-  const scrollToBottom = React5__namespace.useCallback((smooth = true) => {
-    bottomRef.current?.scrollIntoView({
-      behavior: smooth ? "smooth" : "auto"
-    });
-  }, []);
-  React5__namespace.useEffect(() => {
-    const messageCountChanged = messages.length !== prevMessageCountRef.current;
-    prevMessageCountRef.current = messages.length;
-    if (!messageCountChanged) return;
-    const lastMessage = messages[messages.length - 1];
-    const isOutgoing = lastMessage?.sender.id === currentUserId;
-    if (isOutgoing || !isScrolledUp) {
-      scrollToBottom(true);
-    }
-  }, [messages, currentUserId, isScrolledUp, scrollToBottom]);
-  return {
-    scrollContainerRef,
-    bottomRef,
-    isScrolledUp,
-    scrollToBottom
-  };
-}
-function useReadReceipts(options) {
-  const { currentUserId, onMarkRead, threshold = 0.5 } = options;
-  const observerRef = React5__namespace.useRef(null);
-  const observedMessagesRef = React5__namespace.useRef(/* @__PURE__ */ new Set());
-  React5__namespace.useEffect(() => {
-    observerRef.current = new IntersectionObserver(
-      (entries) => {
-        entries.forEach((entry) => {
-          if (entry.isIntersecting) {
-            const messageId = entry.target.getAttribute("data-message-id");
-            if (messageId && !observedMessagesRef.current.has(messageId)) {
-              observedMessagesRef.current.add(messageId);
-              onMarkRead?.(messageId);
-            }
-          }
-        });
-      },
-      { threshold }
-    );
-    return () => {
-      observerRef.current?.disconnect();
-    };
-  }, [onMarkRead, threshold]);
-  const observeMessage = React5__namespace.useCallback(
-    (element, message) => {
-      if (!element || !observerRef.current) return;
-      if (message.sender.id !== currentUserId && message.status !== "read" && !observedMessagesRef.current.has(message.id)) {
-        element.setAttribute("data-message-id", message.id);
-        observerRef.current.observe(element);
-      }
-    },
-    [currentUserId]
-  );
-  return { observeMessage };
-}
 
 exports.AttachmentPreview = AttachmentPreview;
 exports.ConversationHeader = ConversationHeader;
@@ -2015,6 +2092,7 @@ exports.isSameSenderGroup = isSameSenderGroup;
 exports.useMessageScroll = useMessageScroll;
 exports.useMessages = useMessages;
 exports.useReadReceipts = useReadReceipts;
+exports.useTypingEmulation = useTypingEmulation;
 exports.useTypingIndicator = useTypingIndicator;
-//# sourceMappingURL=chunk-FQBTGS3E.cjs.map
-//# sourceMappingURL=chunk-FQBTGS3E.cjs.map
+//# sourceMappingURL=chunk-OFUKTVBN.cjs.map
+//# sourceMappingURL=chunk-OFUKTVBN.cjs.map