@droppii-org/chat-mobile 0.2.89 → 0.2.91

package/src/screens/chat-detail/ChatListLegend.tsx

@@ -76,12 +76,13 @@ import ChatImageDimens, {
 const ROW_MARGIN_CLUSTER_END = KSpacingValue['0.5rem'];
 const ROW_MARGIN_IN_CLUSTER = KSpacingValue['0.25rem'];
 
-// Tags every __DEV__ diagnostic log below with the platform, so logs from an
-// iOS and an Android run can be told apart when compared side by side.
-const LOG_TAG = `[ChatListLegend:${Platform.OS}]`;
-
 const BUTTON_FADE_CONFIG = { duration: 200, easing: Easing.out(Easing.ease) };
 
+// Long enough to swallow Android's willShow→willHide→willShow flapping
+// (~1.3s period, measured), short enough that a real keyboard close still
+// settles within one animation.
+const KEYBOARD_HIDE_DEBOUNCE_MS = 300;
+
 const getRowMarginBottom = (position: GroupPosition): number =>
   position === 'last' || position === 'solo'
     ? ROW_MARGIN_CLUSTER_END
@@ -142,31 +143,16 @@ export const ChatListLegend = memo(
       const last = messages[messages.length - 1];
       return last?.clientMsgID || last?.serverMsgID || null;
     }, [messages]);
-    // Stopgap for the keyboard-open blank-gap bug (unresolved upstream —
-    // see project_chatlistlegend_scroll_debugging memory): below this
-    // threshold, disable `alignItemsAtEnd` and let plain CSS `flex-end`
-    // anchor short content to the bottom instead. Known trade-off (same
-    // memory, bug #17/#19): disabling `alignItemsAtEnd` removes the extra
-    // scrollable room `clampScrollOffset` needs, so sending a message while
-    // the keyboard is open on one of these same short conversations can
-    // land the new message away from the composer instead of scrolling to
-    // it — verify that scenario specifically after any change here.
-    const isVeryShortConversation = messages.length < 15;
     const { mutate: runFlow } = useRunFlow();
     const { mutate: resetFlow } = useResetFlow();
 
     const buttonOpacity = useSharedValue(0);
     const isAtBottomRef = useRef(true);
     const scrollDebounceRef = useRef<NodeJS.Timeout | undefined>(undefined);
-    // Diagnostic only (__DEV__): the keyboard-open bottom inset `useChatKeyboard`
-    // computes internally (raw keyboard height minus `keyboardOffset`, matching
-    // how much the composer's KeyboardStickyView actually rises). Compared
-    // against the list's real, native-reported `contentInset.bottom` in
-    // `handleScroll` below to auto-detect the known issue where that native
-    // inset silently fails to apply (confirmed via manual trace: contentOffset
-    // scrolls correctly but contentInset stays {bottom:0} on this RN/Reanimated/
-    // Old-Architecture combo, leaving a blank gap past the real content end).
-    const expectedKeyboardInsetRef = useRef(0);
+    // Current keyboard height, and the trigger for the re-anchor effect
+    // below — see the keyboard listener for how each platform uses it.
+    const [keyboardInset, setKeyboardInset] = useState(0);
+    const hasSeenFirstKeyboardInsetRef = useRef(false);
     const rowRefsMap = useRef<Map<string, View | null>>(new Map());
     // Set on a real touch-drag (`onScrollBeginDrag`), before onStartReached/
     // onEndReached's threshold could fire. `onMomentumScrollBegin` was tried
@@ -292,17 +278,14 @@ export const ChatListLegend = memo(
               >
                 <LegendChatMessage
                   message={message}
+                  messageId={messageId}
                   isOutgoing={isOutgoing}
                   createdAtTime={createdAt}
                   onMediaPress={onMediaPress}
                   onPressUrl={onPressUrl}
                   onRetry={retryMessage}
-                  onPress={() => handleMessagePress(messageId)}
-                  onLongPress={
-                    onLongPress
-                      ? () => handleMessageLongPress(messageId, message)
-                      : undefined
-                  }
+                  onPress={handleMessagePress}
+                  onLongPress={onLongPress ? handleMessageLongPress : undefined}
                   customMessageItemFactory={customMessageItemFactory}
                   isHighlighted={highlightedId === messageId}
                   isTimeRevealed={revealedMessageId === messageId}
@@ -485,47 +468,21 @@ export const ChatListLegend = memo(
     );
 
     const handleStartReached = useCallback(() => {
-      if (__DEV__) {
-        console.log(`${LOG_TAG} onStartReached fired`, {
-          conversationId,
-          hasUserScrolled: hasUserScrolledRef.current,
-          hasMoreOld,
-          moreOldLoading: useMessageStore.getState().moreOldLoading,
-        });
-      }
-      if (!hasUserScrolledRef.current) {
-        const wouldHaveLoaded =
-          __DEV__ && hasMoreOld && !useMessageStore.getState().moreOldLoading;
-        if (wouldHaveLoaded) {
-          console.warn(
-            `${LOG_TAG} onStartReached fired before user scroll — suppressed`,
-            { conversationId, hasMoreOld }
-          );
-        }
-        return;
-      }
+      // Both thresholds are checked continuously, including at mount before
+      // any gesture — `hasUserScrolledRef` is what keeps that from firing a
+      // load-more the user never asked for.
+      if (!hasUserScrolledRef.current) return;
       if (hasMoreOld && !useMessageStore.getState().moreOldLoading) {
         onLoadMoreOld?.(true);
       }
-    }, [conversationId, hasMoreOld, onLoadMoreOld]);
+    }, [hasMoreOld, onLoadMoreOld]);
 
     const handleEndReached = useCallback(() => {
-      if (!hasUserScrolledRef.current) {
-        const wouldHaveLoaded =
-          __DEV__ && hasMoreNew && !useMessageStore.getState().moreNewLoading;
-        if (wouldHaveLoaded) {
-          console.warn(
-            `${LOG_TAG} onEndReached fired before user scroll — suppressed`,
-            { conversationId, hasMoreNew }
-          );
-        }
-        return;
-      }
+      if (!hasUserScrolledRef.current) return;
       if (hasMoreNew && !useMessageStore.getState().moreNewLoading) {
-        if (__DEV__) console.log(`${LOG_TAG} handleEndReached`);
         onLoadMoreNew?.(true);
       }
-    }, [conversationId, hasMoreNew, onLoadMoreNew]);
+    }, [hasMoreNew, onLoadMoreNew]);
 
     const handleScrollBeginDrag = useCallback(() => {
       hasUserScrolledRef.current = true;
@@ -533,41 +490,11 @@ export const ChatListLegend = memo(
 
     const handleScroll = useCallback(
       (e: any) => {
-        const { contentOffset, contentSize, layoutMeasurement, contentInset } =
-          e.nativeEvent;
+        const { contentOffset, contentSize, layoutMeasurement } = e.nativeEvent;
         const isAtBottom =
           contentOffset.y + layoutMeasurement.height >=
           contentSize.height - 100;
 
-        if (__DEV__) {
-          const expected = expectedKeyboardInsetRef.current;
-          const actual = contentInset?.bottom ?? 0;
-          // `contentInset` failing to apply is a constant, systemic mismatch
-          // (present regardless of conversation length) — but it only shows
-          // up as a visible gap once the scroll position has actually moved
-          // past the real end of content. Gate on that so the warning fires
-          // only when the bug is actually visible, not on every keyboard
-          // open in every conversation.
-          const scrolledPastRealContentEnd =
-            contentOffset.y + layoutMeasurement.height > contentSize.height;
-          if (
-            expected > 0 &&
-            Math.abs(actual - expected) > 5 &&
-            scrolledPastRealContentEnd
-          ) {
-            console.warn(
-              `${LOG_TAG} keyboard contentInset mismatch — expected bottom inset ~${expected} (keyboard open) but native reports ${actual}, and scroll position is past the real content end. This reproduces the known "blank gap" issue: contentOffset scrolls correctly but contentInset silently fails to apply.`,
-              {
-                expected,
-                actual,
-                contentOffsetY: contentOffset.y,
-                contentSizeHeight: contentSize.height,
-                layoutHeight: layoutMeasurement.height,
-              }
-            );
-          }
-        }
-
         // Debounce animation updates
         if (scrollDebounceRef.current) {
           clearTimeout(scrollDebounceRef.current);
@@ -619,26 +546,72 @@ export const ChatListLegend = memo(
       };
     }, []);
 
-    // Diagnostic only (__DEV__) — keeps `expectedKeyboardInsetRef` in sync so
-    // `handleScroll` can detect the known contentInset-not-applying issue.
-    // JS-thread only (no worklet involved), so this carries none of the
-    // reentrant-lock crash risk `useKeyboardHandler`'s own worklet hit.
+    // Tracks the keyboard's height as the trigger for the re-anchor below.
+    // The `willHide` side is debounced because Android's event stream flaps
+    // willShow→willHide→willShow roughly every 1.3s for as long as the
+    // keyboard stays open (measured on device) — without this, every flap
+    // would fire another scroll. A real close still lands, just one tick
+    // later. Setting the same height twice is a no-op for the effect below,
+    // so a stable open only ever re-anchors once.
+    //
+    // JS-thread only (no worklet), so none of the reentrant-lock crash risk
+    // that reaching into `useKeyboardHandler`'s worklets carries.
     useEffect(() => {
-      if (!__DEV__) return;
+      let pendingHide: ReturnType<typeof setTimeout> | undefined;
+      const clearPendingHide = () => {
+        if (pendingHide) {
+          clearTimeout(pendingHide);
+          pendingHide = undefined;
+        }
+      };
+      const applyInset = (nextInset: number) => {
+        // Android only: the bottom inset the library applies there is a
+        // synthetic prop that `onScroll` does not report (its own
+        // `ScrollViewWithBottomPadding` says as much), so LegendList never
+        // learns about it, `alignItemsAtEndPadding` never shrinks, and the
+        // re-anchor below has no room to scroll into. Reporting it closes
+        // that gap. iOS needs none of this — there the inset is real and
+        // arrives through `onScroll` on its own, and overriding it here
+        // would double-count.
+        if (Platform.OS === 'android') {
+          listRef.current?.reportContentInset(
+            nextInset > 0 ? { bottom: nextInset } : null
+          );
+        }
+        setKeyboardInset(nextInset);
+      };
+
       const willShow = KeyboardEvents.addListener('keyboardWillShow', (e) => {
-        expectedKeyboardInsetRef.current = Math.max(
-          e.height - keyboardOffset,
-          0
-        );
+        clearPendingHide();
+        applyInset(Math.max(e.height - keyboardOffset, 0));
       });
       const willHide = KeyboardEvents.addListener('keyboardWillHide', () => {
-        expectedKeyboardInsetRef.current = 0;
+        clearPendingHide();
+        pendingHide = setTimeout(
+          () => applyInset(0),
+          KEYBOARD_HIDE_DEBOUNCE_MS
+        );
       });
       return () => {
+        clearPendingHide();
         willShow.remove();
         willHide.remove();
       };
-    }, [keyboardOffset]);
+    }, [keyboardOffset, listRef]);
+
+    // Re-anchors to the end once the keyboard's inset has landed, which puts
+    // the last message at exactly the spacing the closed-keyboard layout has
+    // (verified on device against both a 7-message and a long conversation).
+    // Skipped when the user has scrolled away from the bottom — opening the
+    // keyboard shouldn't yank them back down.
+    useEffect(() => {
+      if (!hasSeenFirstKeyboardInsetRef.current) {
+        hasSeenFirstKeyboardInsetRef.current = true;
+        return;
+      }
+      if (!isAtBottomRef.current) return;
+      scrollMessageToEnd({ animated: true, closeKeyboard: false });
+    }, [keyboardInset, scrollMessageToEnd]);
 
     // This component can stay mounted across a conversationId change (e.g.
     // navigation.replace reusing the same screen instance), so this ref must
@@ -668,54 +641,17 @@ export const ChatListLegend = memo(
         !moreOldLoadingRef.current &&
         isAtBottomRef.current;
 
-      if (__DEV__) {
-        console.log(
-          `${LOG_TAG} lastMessageId effect — ${shouldFire ? 'firing animated scroll' : 'skipped'}`,
-          {
-            conversationId,
-            lastMessageId,
-            initialPopulation: previousLastMessageId === null,
-            moreOldLoading: moreOldLoadingRef.current,
-            isAtBottom: isAtBottomRef.current,
-          }
-        );
-      }
-
       if (!shouldFire) return;
 
       scrollMessageToEnd({ animated: true, closeKeyboard: false });
-    }, [lastMessageId, scrollMessageToEnd, conversationId]);
+    }, [lastMessageId, scrollMessageToEnd]);
 
-    const handleListLoad = useCallback(
-      (info: { elapsedTimeInMs: number }) => {
-        if (hasCorrectedInitialPaddingRef.current) return;
-        hasCorrectedInitialPaddingRef.current = true;
+    const handleListLoad = useCallback(() => {
+      if (hasCorrectedInitialPaddingRef.current) return;
+      hasCorrectedInitialPaddingRef.current = true;
 
-        // Diagnostic: how long bootstrap + the flush below each take.
-        if (__DEV__) {
-          console.log(`${LOG_TAG} onLoad (bootstrap settle done)`, {
-            conversationId,
-            messagesLength: messages.length,
-            elapsedTimeInMs: info.elapsedTimeInMs,
-          });
-        }
-
-        const startedAt = __DEV__ ? Date.now() : 0;
-        const flushPromise = scrollMessageToEnd({
-          animated: false,
-          closeKeyboard: false,
-        });
-        if (__DEV__) {
-          flushPromise.then(() => {
-            console.log(`${LOG_TAG} handleListLoad flush resolved`, {
-              conversationId,
-              tookMs: Date.now() - startedAt,
-            });
-          });
-        }
-      },
-      [scrollMessageToEnd, conversationId, messages.length]
-    );
+      scrollMessageToEnd({ animated: false, closeKeyboard: false });
+    }, [scrollMessageToEnd]);
 
     useEffect(() => {
       const bottomSubscription = DeviceEventEmitter.addListener(
@@ -801,7 +737,7 @@ export const ChatListLegend = memo(
           keyExtractor={(item) => String(item.clientMsgID || item.serverMsgID)}
           recycleItems
           extraData={listExtraData}
-          alignItemsAtEnd={!isVeryShortConversation}
+          alignItemsAtEnd
           alwaysRender={{
             top: 10,
           }}
@@ -813,15 +749,20 @@ export const ChatListLegend = memo(
           drawDistance={800}
           freeze={freeze}
           keyboardOffset={keyboardOffset}
+          // The list's own keyboard compensation is off on both platforms —
+          // measured, it overshoots badly either way. On iOS it scrolls on
+          // top of React Native's `automaticallyAdjustContentInsets` (which
+          // already insets the scroll view by the full keyboard height), and
+          // that double lift is the blank gap. On Android it overshot by
+          // ~690px against a 128px target. What both platforms do keep from
+          // the library is the bottom inset it sets, which is the room the
+          // re-anchor above scrolls into.
+          keyboardLiftBehavior="never"
           scrollEventThrottle={16}
           onScroll={handleScroll}
           onScrollBeginDrag={handleScrollBeginDrag}
           onLoad={handleListLoad}
-          contentContainerStyle={
-            isVeryShortConversation
-              ? [styles.content, styles.contentBottomAnchored]
-              : styles.content
-          }
+          contentContainerStyle={styles.content}
           scrollIndicatorInsets={{ right: 1 }}
           ListHeaderComponent={
             <LegendChatLoadEarlier isLoading={moreOldLoading} />
@@ -872,9 +813,6 @@ const styles = StyleSheet.create({
     paddingVertical: KSpacingValue['0.75rem'],
     flexGrow: 1,
   },
-  contentBottomAnchored: {
-    justifyContent: 'flex-end',
-  },
   scrollToBottomButton: {
     position: 'absolute',
     bottom: 20,

package/src/screens/chat-detail/PinnedMessagesSheet.tsx

@@ -52,7 +52,11 @@ const PinnedMessagesSheetContent = memo(
     );
 
     const handlePressMessage = useCallback(
-      (message: MessageItem) => {
+      (messageId: string) => {
+        const message = usePinnedMessageStore
+          .getState()
+          .messages.find((m) => (m.clientMsgID || m.serverMsgID) === messageId);
+        if (!message) return;
         UIUtils.bottomSheet.dismiss();
         onPressMessage?.(message);
       },
@@ -117,6 +121,7 @@ const PinnedMessagesSheetContent = memo(
 
                 <LegendChatMessage
                   message={message}
+                  messageId={messageId}
                   isOutgoing={isOutgoing}
                   createdAtTime={createdAtTime}
                   onPress={handlePressMessage}

package/src/screens/chat-detail/PinnedMessagesSheetBackup.tsx

@@ -90,6 +90,7 @@ const PinnedMessageToolboxOverlay = memo(
             message={
               <LegendChatMessage
                 message={message}
+                messageId={message.clientMsgID || message.serverMsgID || ''}
                 isOutgoing={isOutgoing}
                 createdAtTime={message.sendTime || message.createTime}
                 customMessageItemFactory={customMessageItemFactory}
@@ -191,9 +192,10 @@ const PinnedMessagesSheetContent = memo(
             >
               <LegendChatMessage
                 message={message}
+                messageId={messageId}
                 isOutgoing={isOutgoing}
                 createdAtTime={createdAtTime}
-                onLongPress={() => handleLongPress(messageId, message)}
+                onLongPress={handleLongPress}
                 customMessageItemFactory={customMessageItemFactory}
               />
               {!!timeLabel && (

package/src/screens/chat-detail/legend/LegendChatMessage.tsx

@@ -38,13 +38,15 @@ type MessageProps = BaseLegendMessageProps & {
 
 interface LegendChatMessageProps {
   message: MessageItem;
+  /** Stable per-row id (see getMessageRenderId) — bound into onPress/onLongPress locally so those callbacks stay referentially stable across unrelated list re-renders. */
+  messageId: string;
   isOutgoing: boolean;
   createdAtTime: number;
   onMediaPress?: (items: MediaItem[], index?: number) => void;
   onPressUrl?: (url: string) => void;
   onRetry?: (message: MessageItem) => void;
-  onPress?: (message: MessageItem) => void;
-  onLongPress?: () => void;
+  onPress?: (messageId: string) => void;
+  onLongPress?: (messageId: string, message: MessageItem) => void;
   customMessageItemFactory?: (m: MessageItem) => ReactNode;
   isHighlighted?: boolean;
   isTimeRevealed?: boolean;
@@ -99,6 +101,7 @@ const TIME_REVEAL_EXCLUDED_TYPES: number[] = [
 export const LegendChatMessage = memo(
   ({
     message,
+    messageId,
     isOutgoing,
     createdAtTime,
     onMediaPress,
@@ -115,12 +118,12 @@ export const LegendChatMessage = memo(
     groupPosition,
   }: LegendChatMessageProps) => {
     const handlePress = useCallback(() => {
-      onPress?.(message);
-    }, [onPress, message]);
+      onPress?.(messageId);
+    }, [onPress, messageId]);
 
     const handleLongPress = useCallback(() => {
-      onLongPress?.();
-    }, [onLongPress]);
+      onLongPress?.(messageId, message);
+    }, [onLongPress, messageId, message]);
 
     const customNode = customMessageItemFactory?.(message);
 

package/src/screens/chat-detail/messageToolbox/MessageToolboxOverlay.tsx

@@ -22,7 +22,7 @@ import { MessageToolboxWrapper } from './MessageToolboxWrapper';
 import type { ReactNode } from 'react';
 import type { SharedValue } from 'react-native-reanimated';
 import { useSendMessage } from '../../../hooks/message/useSendMessage';
-import { useChatDetailContext } from '../../../context';
+import { useChatContext, useChatDetailContext } from '../../../context';
 import {
   GroupPermission,
   type MessageItem,
@@ -64,7 +64,8 @@ export const MessageToolboxOverlay = forwardRef<
     },
     ref
   ) => {
-    const { setQuotedMessage } = useChatDetailContext();
+    const { setQuotedMessage, conversation } = useChatDetailContext();
+    const { generateChatDetailLink } = useChatContext();
     const [visible, setVisible] = useState(false);
     const [message, setMessage] = useState<MessageItem | undefined>(undefined);
     const [rect, setRect] = useState<MeasuredRect | null>(null);
@@ -139,16 +140,24 @@ export const MessageToolboxOverlay = forwardRef<
     }, [message, hide]);
 
     const handleCopyMessageLink = useCallback(() => {
-      if (!message) return;
-      // UI-only for now: real shareable deeplink format (BR-001) is not decided yet.
-      const placeholderLink = `${message.recvID || message.groupID}:${message.clientMsgID ?? message.serverMsgID ?? ''}`;
-      Clipboard.setString(placeholderLink);
+      if (!message || !generateChatDetailLink) return;
+
+      const link = generateChatDetailLink({
+        targetConversationId: conversation?.conversationID,
+        targetMessageId: message.clientMsgID,
+        targetGroupId: conversation?.groupID,
+        targetUserId: conversation?.userID,
+        // targetBotId: '',
+      });
+      Clipboard.setString(link);
+
       UIUtils.toast.open({
         title: trans('chat:copy_message_link_success'),
         theme: 'success',
       });
+
       hide();
-    }, [message, hide]);
+    }, [message, hide, generateChatDetailLink, conversation]);
 
     const handleRetryMessage = useCallback(() => {
       if (!message) return;
@@ -214,6 +223,7 @@ export const MessageToolboxOverlay = forwardRef<
           message={
             <LegendChatMessage
               message={message}
+              messageId={message.clientMsgID || message.serverMsgID || ''}
               isOutgoing={isOutgoing}
               createdAtTime={message.sendTime || message.createTime}
               customMessageItemFactory={customMessageItemFactory}
@@ -222,6 +232,9 @@ export const MessageToolboxOverlay = forwardRef<
           toolbox={
             <MessageToolboxMenu
               {...toolboxItems}
+              showCopyMessageLink={
+                toolboxItems.showCopyMessageLink && !!generateChatDetailLink
+              }
               showPinMessage={toolboxItems.showPinMessage && isPinAllowed}
               showUnpinMessage={toolboxItems.showUnpinMessage && isPinAllowed}
               onCopyMessage={handleCopyMessage}

package/src/screens/chat-detail/messageToolbox/messageToolbox.utils.ts

@@ -38,8 +38,8 @@ const isCopyMessageSupported = (message: MessageItem): boolean =>
   COPYABLE_TEXT_TYPES.includes(message.contentType);
 
 // All message types are supported, as long as the message is eligible.
-// const isCopyMessageLinkSupported = (message: MessageItem): boolean =>
-//   isEligibleForToolbox(message);
+const isCopyMessageLinkSupported = (message: MessageItem): boolean =>
+  isEligibleForToolbox(message);
 
 const isRetrySupported = (message: MessageItem): boolean =>
   message.status === MessageStatus.Failed;
@@ -92,7 +92,7 @@ export const getMessageToolboxItems = (
   }
 
   const showCopyMessage = isCopyMessageSupported(message);
-  // const showCopyMessageLink = isCopyMessageLinkSupported(message);
+  const showCopyMessageLink = isCopyMessageLinkSupported(message);
   const showRetryMessage = isRetrySupported(message);
   const showRevokeMessage = isRevokeMessageSupported(message, currentUserId);
   const showQuoteMessage = isQuoteMessageSupported(message);
@@ -103,7 +103,7 @@ export const getMessageToolboxItems = (
 
   return {
     showCopyMessage,
-    // showCopyMessageLink,
+    showCopyMessageLink,
     showRetryMessage,
     showRevokeMessage,
     showPinMessage,

package/src/services/apis.ts

@@ -1,6 +1,6 @@
 import { type AxiosInstance } from 'axios';
 import OpenIMSDK, { LoginStatus } from '@droppii/openim-rn-client-sdk';
-import { useConversationStore } from '../store';
+import { useConversationStore, useUserStore } from '../store';
 
 export let apiInstance: AxiosInstance | null = null;
 
@@ -15,6 +15,7 @@ export namespace ChatAPI {
 
   export const logout = async (operationID?: string) => {
     useConversationStore.getState().reset();
+    useUserStore.getState().reset();
     return OpenIMSDK.logout(operationID);
   };
 }

package/src/store/message.ts

@@ -191,7 +191,7 @@ export const useMessageStore = create<MessageStore>()((set, get) => ({
           hasMoreNew: !searchNextRes.isEnd,
           initLoading: false,
         });
-        if (currentMessages?.length > 0) {
+        if (newMessages?.length > 0) {
           await new Promise((resolve) => setTimeout(resolve, 300));
           DeviceEventEmitter.emit(ChatEvent.ScrollToMessage, {
             clientMessageId: startClientMsgId,

package/src/store/user.ts

@@ -11,6 +11,7 @@ export interface UserStore {
   updateConnectStatus: (status: ConnectStatus) => void;
   syncStatus: SyncStatus;
   updateSyncStatus: (status: SyncStatus) => void;
+  reset: () => void;
 }
 
 export const useUserStore = create<UserStore>()((set) => ({
@@ -28,4 +29,10 @@ export const useUserStore = create<UserStore>()((set) => ({
   updateSyncStatus(syncStatus) {
     set({ syncStatus });
   },
+  reset() {
+    set({
+      user: undefined,
+      token: undefined,
+    });
+  },
 }));

package/src/translation/resources/i18n.ts

@@ -35,6 +35,8 @@ const i18nKey: Record<string, string> = {
   'chat:copy_message_link': 'Sao chép đường dẫn tin nhắn',
   'chat:copy_message_success': 'Sao chép tin nhắn thành công',
   'chat:copy_message_link_success': 'Sao chép đường dẫn tin nhắn thành công',
+  'chat:target_message_unavailable':
+    'Tin nhắn có thể đã bị xoá và không còn tồn tại',
   'chat:retry_message': 'Gửi lại',
   'chat:revoke_message': 'Thu hồi',
   'chat:pin_message': 'Ghim',

package/src/types/chat.ts

@@ -15,6 +15,7 @@ import type {
   IRunConversationFlowPayload,
 } from './flows';
 import type { GetOpenIMTokenResponse } from './auth';
+import type { ChatDetailProps } from '../screens/chat-detail';
 
 export const EventProvider = {
   ga: 'ga',
@@ -35,6 +36,17 @@ export interface ChatUIAdapter {
   bottomSheet?: { open: (params: any) => void; dismiss: () => void };
 }
 
+export type GenerateChatDetailLinkFn = (
+  params: Pick<
+    ChatDetailProps,
+    | 'targetConversationId'
+    | 'targetUserId'
+    | 'targetGroupId'
+    | 'targetBotId'
+    | 'targetMessageId'
+  >
+) => string;
+
 export interface ChatContextType {
   logGA?: LogGA;
   applicationType: DChatApplicationType;
@@ -42,6 +54,7 @@ export interface ChatContextType {
   isShowFLashMessage: boolean;
   setIsShowFLashMessage: (value: boolean) => void;
   handleLoginSdk: () => void;
+  generateChatDetailLink?: GenerateChatDetailLinkFn;
 }
 
 export type ChatProviderProps = PropsWithChildren<{
@@ -49,6 +62,7 @@ export type ChatProviderProps = PropsWithChildren<{
   applicationType: DChatApplicationType;
   getChatToken: () => Promise<GetOpenIMTokenResponse | null>;
   onFlashMessagePress?: (c: ConversationItem) => void;
+  generateChatDetailLink?: GenerateChatDetailLinkFn;
   enabled?: boolean;
 }>;