@ethora/chat-component-rn 26.7.5 → 26.7.6

package/src/helpers/pickImageAsset.ts

@@ -0,0 +1,68 @@
+import { Alert, Linking } from 'react-native';
+import * as ImagePicker from 'expo-image-picker';
+
+/**
+ * A picked image in the shape React Native's FormData understands.
+ *
+ * NOT a web `File`: RN streams a multipart part straight from a `file://`
+ * uri and has no usable Blob/File/atob path. Screens ported from the web
+ * client used to carry base64 -> Blob -> File helpers that could never
+ * have run here.
+ */
+export interface PickedImage {
+  uri: string;
+  type: string;
+  name: string;
+}
+
+/**
+ * Ask for library permission, open the picker, and normalise the result.
+ *
+ * Returns `null` for every non-error outcome — permission refused, user
+ * cancelled — so call sites can simply keep their current value.
+ *
+ * Exists because the avatar pickers are wired to `onPress`, which hands
+ * the callback a SyntheticEvent. Storing that event as "the image" (what
+ * two screens used to do) rendered a pooled event as an <Image source>
+ * and then crashed with "Property is not configurable" when React tried
+ * to release it — on top of never letting the user pick anything.
+ */
+export const pickImageAsset = async (): Promise<PickedImage | null> => {
+  try {
+    // expo-image-picker owns the permission prompt internally and
+    // returns a `granted` flag.
+    const perm = await ImagePicker.requestMediaLibraryPermissionsAsync();
+    if (!perm.granted) {
+      Alert.alert(
+        'Permission required',
+        'Photo library permission is needed to select images.',
+        [
+          { text: 'Cancel', style: 'cancel' },
+          { text: 'Open Settings', onPress: () => Linking.openSettings() },
+        ]
+      );
+      return null;
+    }
+
+    const result = await ImagePicker.launchImageLibraryAsync({
+      mediaTypes: ['images'],
+      allowsEditing: true,
+      aspect: [1, 1],
+      quality: 0.8,
+    });
+    if (result.canceled || !result.assets?.[0]) {
+      return null;
+    }
+
+    const asset = result.assets[0];
+    const originalName = asset.fileName || asset.uri.split('/').pop();
+    return {
+      uri: asset.uri,
+      type: asset.mimeType || 'image/jpeg',
+      name: originalName || `image_${Date.now()}.jpg`,
+    };
+  } catch (error) {
+    console.error('Failed to pick an image:', error);
+    return null;
+  }
+};

package/src/helpers/sheetGestures.ts

@@ -0,0 +1,25 @@
+/** @format */
+
+/**
+ * Shared thresholds for the drag-to-dismiss gesture on bottom sheets (the
+ * attach sheet, the profile headers, the room-list menu). Kept in one
+ * place so a pull feels identical wherever the user does it — and so the
+ * numbers are unit-testable without a touch event.
+ */
+
+/** Drag past this many points and letting go dismisses the sheet. */
+export const DISMISS_DISTANCE = 90;
+/** …or flick faster than this, however short the drag. */
+export const DISMISS_VELOCITY = 0.8;
+
+/**
+ * Claim a drag only once it is clearly a downward pull, so a tap on a row
+ * still registers and a horizontal swipe stays with whatever scrolls
+ * sideways inside the sheet.
+ */
+export const shouldClaimVerticalDrag = (dy: number, dx: number) =>
+  dy > 6 && Math.abs(dy) > Math.abs(dx) * 1.5;
+
+/** Far enough / fast enough to let go of the sheet. */
+export const shouldDismissOnDrag = (dy: number, vy: number) =>
+  dy > DISMISS_DISTANCE || vy > DISMISS_VELOCITY;

package/src/helpers/updateMessagesTillLast.tsx

@@ -1,6 +1,6 @@
 import XmppClient from '../networking/xmppClient';
 import { store } from '../roomStore';
-import { applyRoomsPreloadBatch } from '../roomStore/roomsSlice';
+import { setRoomMessages } from '../roomStore/roomsSlice';
 import { IMessage, IRoom } from '../types/types';
 import { checkUniqueUsers } from './checkUniqueUsers';
 
@@ -76,47 +76,22 @@ export const updateMessagesTillLast = async (
                   Number(message.id) === Number(lastCachedMessagesTimeStamp)
               );
 
-            }
-
-            // Publish whatever the catch-up actually retrieved.
-            //
-            // This used to sit INSIDE the loop behind
-            // `!isMessageFound && !(counter <= maxFetchAttempts - 1)`,
-            // i.e. it only ran when the walk-back gave up. In the common
-            // case — the gap is small and the anchor is found on the first
-            // fetch — `isMessageFound` flips true immediately and NOTHING
-            // was ever dispatched, so the reconnect catch-up silently
-            // dropped its own result. The messages still appeared, but only
-            // as a side effect of the always-on `onMessageHistory` stanza
-            // handler, which parses the same stanza a different way
-            // (positional form, no explicit `user` object) and inserts via
-            // addRoomMessage. That copy could carry a wrong sender identity
-            // and, being treated as an own-message, was excluded from the
-            // unread count — the "wrong sender + no unread after reconnect,
-            // both correct after restart" symptom, because only a fresh
-            // start re-runs the preload scheduler that overwrites it.
-            //
-            // Dispatching through `applyRoomsPreloadBatch` (rather than the
-            // previous `setRoomMessages` array-replace) reuses
-            // mergeHistoryIntoCache: it dedupes by id with "fetched wins",
-            // preserves locally-pending sends and older cached history, and
-            // is already a trigger for the unread middleware — exactly what
-            // the startup path does, so reconnect and cold start now agree.
-            // Customer-reported #32.
-            if (currentJidNewMessages.length > 0) {
-              // Fire-and-forget — checkUniqueUsers resolves to an
-              // updated RoomMember list, but there's no slice
-              // action wired to receive it on RN yet (the web SDK
-              // has one; the port left a TODO). Keep the call so
-              // the API request goes out (it warms the cache for
-              // later renders) but stop short of dispatching.
-              await checkUniqueUsers(currentJidNewMessages);
-
-              store.dispatch(
-                applyRoomsPreloadBatch({
-                  rooms: [{ jid, messages: currentJidNewMessages }],
-                })
-              );
+              if (!isMessageFound && !(counter <= maxFetchAttempts - 1)) {
+                // Fire-and-forget — checkUniqueUsers resolves to an
+                // updated RoomMember list, but there's no slice
+                // action wired to receive it on RN yet (the web SDK
+                // has one; the port left a TODO). Keep the call so
+                // the API request goes out (it warms the cache for
+                // later renders) but stop short of dispatching.
+                await checkUniqueUsers(currentJidNewMessages);
+
+                store.dispatch(
+                  setRoomMessages({
+                    roomJID: jid,
+                    messages: currentJidNewMessages,
+                  })
+                );
+              }
             }
           } catch (error) {
             console.error(`Error processing room ${jid}:`, error);

package/src/hooks/useChatRoomFocus.ts

@@ -59,20 +59,12 @@ export const useChatRoomFocus = ({
   });
 
   const leaveRoom = (jid: string) => {
-    const rooms = store.getState().rooms?.rooms;
-    // Only mark read as far as the user actually scrolled. Blindly
-    // stamping `Date.now()` here clears messages they never reached, and
-    // the server flush below makes that permanent across a restart.
-    // Customer-reported #33.
-    const boundaryTs = rooms?.[jid]?.readBoundaryTs ?? null;
-    const timestamp = boundaryTs ?? Date.now();
+    const timestamp = Date.now();
     dispatch(setLastViewedTimestamp({ chatJID: jid, timestamp }));
     dispatch(clearVisibleRoom());
+    const rooms = store.getState().rooms?.rooms;
     (store.getState().chatSettingStore as any)?.client
-      ?.flushLastViewedToPrivateStoreStanza(rooms, {
-        visibleRoomJID: jid,
-        visibleRoomTs: boundaryTs,
-      })
+      ?.flushLastViewedToPrivateStoreStanza(rooms, { visibleRoomJID: jid })
       .catch(() => {});
   };
 

package/src/hooks/useLogout.tsx

@@ -63,13 +63,6 @@ const logoutService = {
         await Promise.race([
           client.flushLastViewedToPrivateStoreStanza(rooms, {
             visibleRoomJID,
-            // `onlyIfNoUnread` deliberately exempts the visible room, so
-            // without this the open-but-scrolled-up room would still be
-            // stamped "read up to now" on logout and come back read on
-            // the next login. Customer-reported #33.
-            visibleRoomTs: visibleRoomJID
-              ? rooms?.[visibleRoomJID]?.readBoundaryTs ?? null
-              : null,
             onlyIfNoUnread: true,
           }),
           new Promise((res) => setTimeout(res, 2000)),

package/src/hooks/useSendMessage.tsx

@@ -10,11 +10,7 @@ import {
   markMessageFailed,
 } from '../roomStore/roomHeapSlice';
 import { uploadFileV2 } from '../networking/api-requests/auth.api';
-import {
-  enqueueOutboundSend,
-  markOutboundSentLive,
-  removeOutboundSend,
-} from '../networking/outboundQueue';
+import { enqueueOutboundSend, removeOutboundSend } from '../networking/outboundQueue';
 import { RootState, store } from '../roomStore';
 import { getGlobalXmppClient } from '../utils/clientRegistry';
 import { useEventHandlers } from './useEventHandlers';
@@ -308,36 +304,15 @@ export const useSendMessage = (_configOverride?: IConfig) => {
         }
 
         replaySend(effectiveClient);
-        // The stanza is on the wire from here on. Mark the buffered copy
-        // so a later reconnect flush won't blind-replay it — see
-        // markOutboundSentLive / flushOutboundSends. Customer-reported #31.
-        markOutboundSentLive(optimisticId);
         try {
-          // Throttled + config-gated: a burst of sends starts at most one
-          // probe, and a single missed probe no longer tears the stream
-          // down. See ensureStreamAliveAfterSend / ensureStreamAlive.
-          effectiveClient.ensureStreamAliveAfterSend?.();
+          effectiveClient.ensureStreamAlive?.();
         } catch {}
-        // Post-send notification ONLY. Deliberately outside the try below:
-        // `handleMessageSent` re-throws whatever the host app's
-        // `eventHandlers.onMessageSent` callback throws, and this runs
-        // AFTER the stanza was already delivered — letting that reach the
-        // catch marked a delivered message "Failed → tap to retry" purely
-        // because a consumer's analytics/webhook hook was slow or errored.
-        // Customer-reported #31 ("delivered but shows as failed").
-        try {
-          await handleMessageSent({
-            message,
-            roomJID: activeRoomJID,
-            user,
-            messageType: 'text',
-          });
-        } catch (notifyError) {
-          console.warn(
-            'onMessageSent handler threw after a successful send; not failing the message',
-            notifyError
-          );
-        }
+        await handleMessageSent({
+          message,
+          roomJID: activeRoomJID,
+          user,
+          messageType: 'text',
+        });
       } catch (error) {
         clearTimeout(watchdogTimer);
         // Same reasoning as the watchdog: once the bubble shows failed,
@@ -605,7 +580,7 @@ export const useSendMessage = (_configOverride?: IConfig) => {
               id
             );
             try {
-              effectiveMediaClient.ensureStreamAliveAfterSend?.();
+              effectiveMediaClient.ensureStreamAlive?.();
             } catch {}
           } else {
             const anyMediaClient: any =
@@ -628,32 +603,21 @@ export const useSendMessage = (_configOverride?: IConfig) => {
           }
         }
 
-        // Post-send notification ONLY — see the text path: the upload and
-        // stanza send have already succeeded here, so a throw from the
-        // host's `onMessageSent` callback must not flip this to "Failed".
-        // Customer-reported #31.
-        try {
-          await handleMessageSent({
-            message: 'media',
-            roomJID: activeRoomJID,
-            user,
-            messageType: 'media',
-            metadata: {
-              isReply,
-              isChecked,
-              mainMessage,
-              fileData: data,
-              fileType: type,
-              messageId: id,
-              uploadResults: response.data.results,
-            },
-          });
-        } catch (notifyError) {
-          console.warn(
-            'onMessageSent handler threw after a successful media send; not failing the message',
-            notifyError
-          );
-        }
+        await handleMessageSent({
+          message: 'media',
+          roomJID: activeRoomJID,
+          user,
+          messageType: 'media',
+          metadata: {
+            isReply,
+            isChecked,
+            mainMessage,
+            fileData: data,
+            fileType: type,
+            messageId: id,
+            uploadResults: response.data.results,
+          },
+        });
       } catch (error: any) {
         // Upload (or stanza send) threw an explicit error. Clear the
         // watchdog so it doesn't double-fire `markMessageFailed`.