stream-chat-react-native-core 9.10.2-beta.1 → 10.0.0-rc.2

package/src/hooks/actions/useChannelActions.ts

@@ -71,14 +71,14 @@ export const useChannelActions = (channel: Channel) => {
       }
       await channel.pin();
       addNotification({
-        message: t('Channel pinned'),
+        message: t('channel.pinned.text', 'Channel pinned'),
         options: { severity: 'success', type: 'api:channel:pin:success' },
         origin: { context: { channel }, emitter: 'ChannelActions' },
       });
       options?.onSuccess?.();
     } catch (error) {
       addNotification({
-        message: t('Failed to update channel pinned status'),
+        message: t('channel.pinUpdateFailed.error', 'Failed to update channel pinned status'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -97,14 +97,14 @@ export const useChannelActions = (channel: Channel) => {
       }
       await channel.unpin();
       addNotification({
-        message: t('Channel unpinned'),
+        message: t('channel.unpinned.text', 'Channel unpinned'),
         options: { severity: 'success', type: 'api:channel:unpin:success' },
         origin: { context: { channel }, emitter: 'ChannelActions' },
       });
       options?.onSuccess?.();
     } catch (error) {
       addNotification({
-        message: t('Failed to update channel pinned status'),
+        message: t('channel.pinUpdateFailed.error', 'Failed to update channel pinned status'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -123,14 +123,14 @@ export const useChannelActions = (channel: Channel) => {
       }
       await channel.archive();
       addNotification({
-        message: t('Channel archived'),
+        message: t('channel.archived.text', 'Channel archived'),
         options: { severity: 'success', type: 'api:channel:archive:success' },
         origin: { context: { channel }, emitter: 'ChannelActions' },
       });
       options?.onSuccess?.();
     } catch (error) {
       addNotification({
-        message: t('Failed to update channel archive status'),
+        message: t('channel.archiveUpdateFailed.error', 'Failed to update channel archive status'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -149,14 +149,14 @@ export const useChannelActions = (channel: Channel) => {
       }
       await channel.unarchive();
       addNotification({
-        message: t('Channel unarchived'),
+        message: t('channel.unarchived.text', 'Channel unarchived'),
         options: { severity: 'success', type: 'api:channel:unarchive:success' },
         origin: { context: { channel }, emitter: 'ChannelActions' },
       });
       options?.onSuccess?.();
     } catch (error) {
       addNotification({
-        message: t('Failed to update channel archive status'),
+        message: t('channel.archiveUpdateFailed.error', 'Failed to update channel archive status'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -174,16 +174,16 @@ export const useChannelActions = (channel: Channel) => {
     }
     if (ownUserId) {
       try {
-        await channel.removeMembers([ownUserId]);
+        await channel.removeMembers({ members: [ownUserId] });
         addNotification({
-          message: t('Left channel'),
+          message: t('channel.left.text', 'Left channel'),
           options: { severity: 'success', type: 'api:channel:leave:success' },
           origin: { context: { channel }, emitter: 'ChannelActions' },
         });
         options?.onSuccess?.();
       } catch (error) {
         addNotification({
-          message: t('Failed to leave channel'),
+          message: t('channel.leaveFailed.error', 'Failed to leave channel'),
           options: {
             ...getNotificationErrorOptions(error),
             severity: 'error',
@@ -202,16 +202,20 @@ export const useChannelActions = (channel: Channel) => {
         return;
       }
       try {
-        await channel.removeMembers(memberIds);
+        await channel.removeMembers({ members: memberIds });
         addNotification({
-          message: t('{{count}} members removed', { count: memberIds.length }),
+          message: t('channel.membersRemoved.text', {
+            count: memberIds.length,
+            defaultValue_one: '{{count}} member removed',
+            defaultValue_other: '{{count}} members removed',
+          }),
           options: { severity: 'success', type: 'api:channel:remove-members:success' },
           origin: { context: { channel }, emitter: 'ChannelActions' },
         });
         options?.onSuccess?.();
       } catch (error) {
         addNotification({
-          message: t('Failed to remove members'),
+          message: t('channel.removeMembersFailed.error', 'Failed to remove members'),
           options: {
             ...getNotificationErrorOptions(error),
             severity: 'error',
@@ -230,16 +234,20 @@ export const useChannelActions = (channel: Channel) => {
         return;
       }
       try {
-        await channel.addMembers(memberIds);
+        await channel.addMembers({ members: memberIds });
         addNotification({
-          message: t('{{count}} members added', { count: memberIds.length }),
+          message: t('channel.membersAdded.text', {
+            count: memberIds.length,
+            defaultValue_one: '{{count}} member added',
+            defaultValue_other: '{{count}} members added',
+          }),
           options: { severity: 'success', type: 'api:channel:add-members:success' },
           origin: { context: { channel }, emitter: 'ChannelActions' },
         });
         options?.onSuccess?.();
       } catch (error) {
         addNotification({
-          message: t('Failed to add members'),
+          message: t('channel.addMembersFailed.error', 'Failed to add members'),
           options: {
             ...getNotificationErrorOptions(error),
             severity: 'error',
@@ -260,14 +268,14 @@ export const useChannelActions = (channel: Channel) => {
     try {
       await channel.delete();
       addNotification({
-        message: t('Channel deleted'),
+        message: t('channel.deleted.text', 'Channel deleted'),
         options: { severity: 'success', type: 'api:channel:delete:success' },
         origin: { context: { channel }, emitter: 'ChannelActions' },
       });
       options?.onSuccess?.();
     } catch (error) {
       addNotification({
-        message: t('Failed to delete channel'),
+        message: t('channel.deleteFailed.error', 'Failed to delete channel'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -288,9 +296,9 @@ export const useChannelActions = (channel: Channel) => {
 
     try {
       if (otherUser?.user?.id) {
-        await client.muteUser(otherUser.user.id);
+        await client.moderation.mute({ target_ids: [otherUser.user.id] });
         addNotification({
-          message: t('{{ user }} has been muted', {
+          message: t('message.userMuted.text', '{{ user }} has been muted', {
             user: otherUser.user.name || otherUser.user.id,
           }),
           options: { severity: 'success', type: 'api:user:mute:success' },
@@ -300,7 +308,7 @@ export const useChannelActions = (channel: Channel) => {
       }
     } catch (error) {
       addNotification({
-        message: t('Error muting a user ...'),
+        message: t('message.muteUser.error', 'Error muting a user ...'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -321,9 +329,9 @@ export const useChannelActions = (channel: Channel) => {
 
     try {
       if (otherUser?.user?.id) {
-        await client.unmuteUser(otherUser.user.id);
+        await client.moderation.unmute({ target_ids: [otherUser.user.id] });
         addNotification({
-          message: t('{{ user }} has been unmuted', {
+          message: t('message.userUnmuted.text', '{{ user }} has been unmuted', {
             user: otherUser.user.name || otherUser.user.id,
           }),
           options: { severity: 'success', type: 'api:user:unmute:success' },
@@ -333,7 +341,7 @@ export const useChannelActions = (channel: Channel) => {
       }
     } catch (error) {
       addNotification({
-        message: t('Error unmuting a user ...'),
+        message: t('message.unmuteUser.error', 'Error unmuting a user ...'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -353,14 +361,14 @@ export const useChannelActions = (channel: Channel) => {
     try {
       await channel.mute();
       addNotification({
-        message: t('Channel muted'),
+        message: t('channel.muted.text', 'Channel muted'),
         options: { severity: 'success', type: 'api:channel:mute:success' },
         origin: { context: { channel }, emitter: 'ChannelActions' },
       });
       options?.onSuccess?.();
     } catch (error) {
       addNotification({
-        message: t('Failed to update channel mute status'),
+        message: t('channel.muteUpdateFailed.error', 'Failed to update channel mute status'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -380,14 +388,14 @@ export const useChannelActions = (channel: Channel) => {
     try {
       await channel.unmute();
       addNotification({
-        message: t('Channel unmuted'),
+        message: t('channel.unmuted.text', 'Channel unmuted'),
         options: { severity: 'success', type: 'api:channel:unmute:success' },
         origin: { context: { channel }, emitter: 'ChannelActions' },
       });
       options?.onSuccess?.();
     } catch (error) {
       addNotification({
-        message: t('Failed to update channel mute status'),
+        message: t('channel.muteUpdateFailed.error', 'Failed to update channel mute status'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -410,7 +418,7 @@ export const useChannelActions = (channel: Channel) => {
       if (otherUser?.user?.id) {
         await client.blockUser(otherUser.user.id);
         addNotification({
-          message: t('User blocked'),
+          message: t('channel.userBlocked.text', 'User blocked'),
           options: { severity: 'success', type: 'api:user:block:success' },
           origin: { context: { channel }, emitter: 'ChannelActions' },
         });
@@ -418,7 +426,7 @@ export const useChannelActions = (channel: Channel) => {
       }
     } catch (error) {
       addNotification({
-        message: t('Failed to block user'),
+        message: t('channel.blockUserFailed.error', 'Failed to block user'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -442,14 +450,14 @@ export const useChannelActions = (channel: Channel) => {
         await channel.updatePartial({ set: { name } });
       }
       addNotification({
-        message: t('Channel name updated'),
+        message: t('channel.nameUpdated.text', 'Channel name updated'),
         options: { severity: 'success', type: 'api:channel:update-name:success' },
         origin: { context: { channel }, emitter: 'ChannelActions' },
       });
       options?.onSuccess?.();
     } catch (error) {
       addNotification({
-        message: t('Failed to update channel name'),
+        message: t('channel.nameUpdateFailed.error', 'Failed to update channel name'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -477,18 +485,20 @@ export const useChannelActions = (channel: Channel) => {
         } else {
           const { file } = doFileUploadRequest
             ? await doFileUploadRequest(image)
-            : await client.uploadImage(image.uri, image.name, image.type);
+            : await client.uploadImage({
+                file: { name: image.name, type: image.type, uri: image.uri },
+              });
           await channel.updatePartial({ set: { image: file } });
         }
         addNotification({
-          message: t('Channel image updated'),
+          message: t('channel.imageUpdated.text', 'Channel image updated'),
           options: { severity: 'success', type: 'api:channel:update-image:success' },
           origin: { context: { channel }, emitter: 'ChannelActions' },
         });
         options?.onSuccess?.();
       } catch (error) {
         addNotification({
-          message: t('Failed to update channel image'),
+          message: t('channel.imageUpdateFailed.error', 'Failed to update channel image'),
           options: {
             ...getNotificationErrorOptions(error),
             severity: 'error',
@@ -510,9 +520,9 @@ export const useChannelActions = (channel: Channel) => {
 
     try {
       if (otherUser?.user?.id) {
-        await client.unBlockUser(otherUser.user.id);
+        await client.unblockUser(otherUser.user.id);
         addNotification({
-          message: t('User unblocked'),
+          message: t('channel.userUnblocked.text', 'User unblocked'),
           options: { severity: 'success', type: 'api:user:unblock:success' },
           origin: { context: { channel }, emitter: 'ChannelActions' },
         });
@@ -520,7 +530,7 @@ export const useChannelActions = (channel: Channel) => {
       }
     } catch (error) {
       addNotification({
-        message: t('Failed to block user'),
+        message: t('channel.blockUserFailed.error', 'Failed to block user'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',

package/src/hooks/actions/useChannelMemberActionItems.tsx

@@ -16,10 +16,8 @@ import { IconProps } from '../../icons';
 import { useChannelOwnCapabilities } from '../useChannelOwnCapabilities';
 import { useStateStore } from '../useStateStore';
 
-// Lazily resolved to avoid a static import cycle with defaultComponents.ts
-// (defaultComponents → ChannelDetails*/ChannelPreview* → this file). Statically
-// importing defaultIcons corrupts module-init order; require it at call time
-// instead. Same pattern as ComponentsContext's getDefaults().
+// Required lazily: a static import of defaultComponents.ts would form a cycle
+// (defaultComponents -> ChannelDetails*/ChannelPreview* -> this file) and corrupt init order.
 let cachedDefaultIcons: IconsMap | undefined;
 const getDefaultIcons = (): IconsMap => {
   if (!cachedDefaultIcons) {
@@ -81,8 +79,7 @@ export const buildDefaultChannelMemberActionItems: BuildDefaultChannelMemberActi
 
   const actionItems: ChannelMemberActionItem[] = [];
 
-  // Muting or blocking yourself is meaningless, so these actions are only
-  // added for other members.
+  // Muting or blocking yourself is meaningless, so these actions are only for other members.
   if (!isCurrentUser) {
     actionItems.push(
       {
@@ -99,7 +96,9 @@ export const buildDefaultChannelMemberActionItems: BuildDefaultChannelMemberActi
             />
           ),
         id: 'muteUser',
-        label: userMuteActive ? t('Unmute User') : t('Mute User'),
+        label: userMuteActive
+          ? t('message.unmuteUser.label', 'Unmute User')
+          : t('message.muteUser.label', 'Mute User'),
         type: 'standard',
       },
       {
@@ -109,26 +108,31 @@ export const buildDefaultChannelMemberActionItems: BuildDefaultChannelMemberActi
               const name = member.user?.name || member.user?.id || '';
 
               Alert.alert(
-                t('Block {{ name }}', { name }),
-                t("They won't be able to message or call you. You can unblock them later."),
+                t('message.blockUserConfirm.title', 'Block {{ name }}', { name }),
+                t(
+                  'message.blockUserConfirm.text',
+                  "They won't be able to message or call you. You can unblock them later.",
+                ),
                 [
                   {
                     style: 'cancel',
-                    text: t('Cancel'),
+                    text: t('common.cancel.label', 'Cancel'),
                   },
                   {
                     onPress: async () => {
                       await blockUser(...args);
                     },
                     style: 'destructive',
-                    text: t('Block'),
+                    text: t('message.blockUserConfirm.label', 'Block'),
                   },
                 ],
               );
             },
         Icon: (props) => <ChannelMemberActionsIcon Icon={icons.BlockUser} {...props} />,
         id: 'block',
-        label: isBlocked ? t('Unblock User') : t('Block User'),
+        label: isBlocked
+          ? t('message.unblockUser.label', 'Unblock User')
+          : t('message.blockUser.label', 'Block User'),
         type: isBlocked ? 'standard' : 'destructive',
       },
     );
@@ -141,23 +145,26 @@ export const buildDefaultChannelMemberActionItems: BuildDefaultChannelMemberActi
             return;
           }
           Alert.alert(
-            t('Remove User'),
-            t('Are you sure you want to remove this member from the channel?'),
+            t('channel.removeUser.label', 'Remove User'),
+            t(
+              'channel.removeUser.confirm.text',
+              'Are you sure you want to remove this member from the channel?',
+            ),
             [
-              { style: 'cancel', text: t('Cancel') },
+              { style: 'cancel', text: t('common.cancel.label', 'Cancel') },
               {
                 onPress: async () => {
                   await removeMembers([memberId]);
                 },
                 style: 'destructive',
-                text: t('Remove'),
+                text: t('channel.removeUser.confirm.label', 'Remove'),
               },
             ],
           );
         },
         Icon: (props) => <ChannelMemberActionsIcon Icon={icons.UserDelete} {...props} />,
         id: 'removeMember',
-        label: t('Remove User'),
+        label: t('channel.removeUser.label', 'Remove User'),
         type: 'destructive',
       });
     }

package/src/hooks/actions/useUserActions.ts

@@ -31,16 +31,18 @@ export const useUserActions = (user: UserResponse | undefined): UserActions => {
     }
 
     try {
-      await client.muteUser(user.id);
+      await client.moderation.mute({ target_ids: [user.id] });
       addNotification({
-        message: t('{{ user }} has been muted', { user: user.name || user.id }),
+        message: t('message.userMuted.text', '{{ user }} has been muted', {
+          user: user.name || user.id,
+        }),
         options: { severity: 'success', type: 'api:user:mute:success' },
         origin: { context: { user }, emitter: 'UserActions' },
       });
       await options?.onSuccess?.();
     } catch (error) {
       addNotification({
-        message: t('Error muting a user ...'),
+        message: t('message.muteUser.error', 'Error muting a user ...'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -57,16 +59,18 @@ export const useUserActions = (user: UserResponse | undefined): UserActions => {
     }
 
     try {
-      await client.unmuteUser(user.id);
+      await client.moderation.unmute({ target_ids: [user.id] });
       addNotification({
-        message: t('{{ user }} has been unmuted', { user: user.name || user.id }),
+        message: t('message.userUnmuted.text', '{{ user }} has been unmuted', {
+          user: user.name || user.id,
+        }),
         options: { severity: 'success', type: 'api:user:unmute:success' },
         origin: { context: { user }, emitter: 'UserActions' },
       });
       await options?.onSuccess?.();
     } catch (error) {
       addNotification({
-        message: t('Error unmuting a user ...'),
+        message: t('message.unmuteUser.error', 'Error unmuting a user ...'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -85,14 +89,14 @@ export const useUserActions = (user: UserResponse | undefined): UserActions => {
     try {
       await client.blockUser(user.id);
       addNotification({
-        message: t('User blocked'),
+        message: t('channel.userBlocked.text', 'User blocked'),
         options: { severity: 'success', type: 'api:user:block:success' },
         origin: { context: { user }, emitter: 'UserActions' },
       });
       await options?.onSuccess?.();
     } catch (error) {
       addNotification({
-        message: t('Failed to block user'),
+        message: t('channel.blockUserFailed.error', 'Failed to block user'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',
@@ -109,16 +113,16 @@ export const useUserActions = (user: UserResponse | undefined): UserActions => {
     }
 
     try {
-      await client.unBlockUser(user.id);
+      await client.unblockUser(user.id);
       addNotification({
-        message: t('User unblocked'),
+        message: t('channel.userUnblocked.text', 'User unblocked'),
         options: { severity: 'success', type: 'api:user:unblock:success' },
         origin: { context: { user }, emitter: 'UserActions' },
       });
       await options?.onSuccess?.();
     } catch (error) {
       addNotification({
-        message: t('Failed to block user'),
+        message: t('channel.blockUserFailed.error', 'Failed to block user'),
         options: {
           ...getNotificationErrorOptions(error),
           severity: 'error',

package/src/hooks/index.ts

@@ -1,3 +1,4 @@
+export * from './useIsTargetedMessage';
 export * from '../a11y';
 export * from './actions';
 export * from './useAppStateListener';
@@ -11,12 +12,13 @@ export * from './useCanAddMembersToChannel';
 export * from './useChannelMuteActive';
 export * from './useIsDirectChat';
 export * from './useIsChannelMember';
-export * from './useSelectedChannelState';
 export * from './useStreami18n';
 export * from './useViewport';
 export * from './useScreenDimensions';
 export * from './useScreenOrientation';
 export * from './useStateStore';
+export * from './useChannel';
+export * from './useMessagePaginator';
 export * from './usePendingAttachmentUpload';
 export * from './useStableCallback';
 export * from './useLoadingImage';

package/src/hooks/messagePreview/__tests__/useMessageDeliveryStatus.test.tsx

@@ -0,0 +1,119 @@
+import React, { PropsWithChildren } from 'react';
+
+import { act, renderHook } from '@testing-library/react-native';
+import { fromPartial } from '@total-typescript/shoehorn';
+
+import type { Channel, UserResponse } from 'stream-chat';
+
+import { Chat } from '../../../components/Chat/Chat';
+import { initiateClientWithChannels } from '../../../mock-builders/api/initiateClientWithChannels';
+import { generateMessage } from '../../../mock-builders/generator/message';
+import { generateUser } from '../../../mock-builders/generator/user';
+import { MessageDeliveryStatus, useMessageDeliveryStatus } from '../useMessageDeliveryStatus';
+
+describe('useMessageDeliveryStatus', () => {
+  const ownMessage = generateMessage({ user: generateUser({ id: 'me' }) });
+
+  const setup = async ({
+    isReadEventsEnabled = true,
+    lastMessage = ownMessage,
+  }: { isReadEventsEnabled?: boolean; lastMessage?: ReturnType<typeof generateMessage> } = {}) => {
+    const {
+      channels: [channel],
+      client,
+    } = await initiateClientWithChannels({ customUser: generateUser({ id: 'me' }) });
+    const wrapper = ({ children }: PropsWithChildren) => <Chat client={client}>{children}</Chat>;
+    const { result } = renderHook(
+      () => useMessageDeliveryStatus({ channel, isReadEventsEnabled, lastMessage }),
+      { wrapper },
+    );
+    return { channel, result };
+  };
+
+  const setReceipts = (
+    channel: Channel,
+    {
+      delivered = {},
+      readers = {},
+    }: { delivered?: Record<string, UserResponse[]>; readers?: Record<string, UserResponse[]> },
+  ) =>
+    channel.messageReceiptsTracker.snapshotStore.partialNext({
+      deliveredByMessageId: delivered,
+      readersByMessageId: readers,
+    });
+
+  it('returns NOT_SENT_BY_CURRENT_USER when read events are disabled', async () => {
+    const { result } = await setup({ isReadEventsEnabled: false });
+    expect(result.current.status).toBe(MessageDeliveryStatus.NOT_SENT_BY_CURRENT_USER);
+  });
+
+  it("returns undefined when the last message is not the current user's", async () => {
+    const { result } = await setup({
+      lastMessage: generateMessage({ user: generateUser({ id: 'other' }) }),
+    });
+    expect(result.current.status).toBeUndefined();
+  });
+
+  it('progresses SENT → DELIVERED → READ reactively as receipts arrive', async () => {
+    const { channel, result } = await setup();
+    expect(result.current.status).toBe(MessageDeliveryStatus.SENT);
+
+    act(() =>
+      setReceipts(channel, {
+        delivered: { [ownMessage.id]: [fromPartial<UserResponse>({ id: 'other' })] },
+      }),
+    );
+    expect(result.current.status).toBe(MessageDeliveryStatus.DELIVERED);
+
+    act(() =>
+      setReceipts(channel, {
+        delivered: { [ownMessage.id]: [fromPartial<UserResponse>({ id: 'other' })] },
+        readers: { [ownMessage.id]: [fromPartial<UserResponse>({ id: 'other' })] },
+      }),
+    );
+    expect(result.current.status).toBe(MessageDeliveryStatus.READ);
+  });
+
+  // The receipts tracker rebuilds its reader arrays on every snapshot, presence and user updates
+  // included, so a preview row must only re-render when the status itself changes.
+  it('does not re-render when the receipts change without changing the status', async () => {
+    const {
+      channels: [channel],
+      client,
+    } = await initiateClientWithChannels({ customUser: generateUser({ id: 'me' }) });
+    const wrapper = ({ children }: PropsWithChildren) => <Chat client={client}>{children}</Chat>;
+    let renders = 0;
+    const { result } = renderHook(
+      () => {
+        renders++;
+        return useMessageDeliveryStatus({
+          channel,
+          isReadEventsEnabled: true,
+          lastMessage: ownMessage,
+        });
+      },
+      { wrapper },
+    );
+
+    act(() =>
+      setReceipts(channel, {
+        delivered: { [ownMessage.id]: [fromPartial<UserResponse>({ id: 'other' })] },
+      }),
+    );
+    expect(result.current.status).toBe(MessageDeliveryStatus.DELIVERED);
+    const rendersWhenDelivered = renders;
+
+    act(() =>
+      setReceipts(channel, {
+        delivered: {
+          [ownMessage.id]: [
+            fromPartial<UserResponse>({ id: 'other' }),
+            fromPartial<UserResponse>({ id: 'third' }),
+          ],
+        },
+      }),
+    );
+    expect(result.current.status).toBe(MessageDeliveryStatus.DELIVERED);
+    expect(renders).toBe(rendersWhenDelivered);
+  });
+});

package/src/hooks/messagePreview/__tests__/useMessagePreviewText.test.tsx

@@ -1,6 +1,6 @@
 import React, { PropsWithChildren } from 'react';
 
-import { renderHook, waitFor } from '@testing-library/react-native';
+import { renderHook } from '@testing-library/react-native';
 
 import type { Attachment } from 'stream-chat';
 
@@ -25,7 +25,7 @@ describe('useMessagePreviewText', () => {
   const withAttachments = (attachments?: Attachment[]) =>
     generateMessage({ attachments, text: '' });
 
-  // Drafts can have no text and no attachments; they rendered "{{count}} Files" / "0 Audios".
+  // Drafts can have no text and nothing attached; they used to render "0 Files" / "0 Audios".
   it.each([
     ['absent', undefined],
     ['empty', []],
@@ -38,16 +38,14 @@ describe('useMessagePreviewText', () => {
     const result = await render(
       withAttachments([generateImageAttachment(), generateFileAttachment()]),
     );
-    // Counted copy comes from the translations, which load asynchronously.
-    await waitFor(() => expect(result.current).toBe('2 Files'));
+    expect(result.current).toBe('2 Files');
   });
 
   it('counts audio-only attachments as audios', async () => {
     const result = await render(
       withAttachments([generateAudioAttachment(), generateAudioAttachment()]),
     );
-    // Counted copy comes from the translations, which load asynchronously.
-    await waitFor(() => expect(result.current).toBe('2 Audios'));
+    expect(result.current).toBe('2 Audios');
   });
 
   it('prefers the message text over its attachments', async () => {