stream-chat-react-native-core 10.0.0-rc.2 → 10.0.0-rc.3

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

@@ -1,9 +1,8 @@
 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 { asTimestampNS } from 'stream-chat';
+import type { Channel, MsgRef } from 'stream-chat';
 
 import { Chat } from '../../../components/Chat/Chat';
 import { initiateClientWithChannels } from '../../../mock-builders/api/initiateClientWithChannels';
@@ -12,7 +11,16 @@ import { generateUser } from '../../../mock-builders/generator/user';
 import { MessageDeliveryStatus, useMessageDeliveryStatus } from '../useMessageDeliveryStatus';
 
 describe('useMessageDeliveryStatus', () => {
-  const ownMessage = generateMessage({ user: generateUser({ id: 'me' }) });
+  const ownMessage = generateMessage({
+    timestamp: new Date('2026-01-01T10:00:00Z'),
+    user: generateUser({ id: 'me' }),
+  });
+
+  // A cursor `offsetNs` after (or, negative, before) `ownMessage`, on a message of its own.
+  const cursorAt = (offsetNs: number, msgId = `cursor-${offsetNs}`): MsgRef => ({
+    msgId,
+    timestamp: asTimestampNS(ownMessage.created_at + offsetNs),
+  });
 
   const setup = async ({
     isReadEventsEnabled = true,
@@ -32,14 +40,11 @@ describe('useMessageDeliveryStatus', () => {
 
   const setReceipts = (
     channel: Channel,
-    {
-      delivered = {},
-      readers = {},
-    }: { delivered?: Record<string, UserResponse[]>; readers?: Record<string, UserResponse[]> },
+    { delivered = null, read = null }: { delivered?: MsgRef | null; read?: MsgRef | null },
   ) =>
     channel.messageReceiptsTracker.snapshotStore.partialNext({
-      deliveredByMessageId: delivered,
-      readersByMessageId: readers,
+      lastDeliveredRefByOthers: delivered,
+      lastReadRefByOthers: read,
     });
 
   it('returns NOT_SENT_BY_CURRENT_USER when read events are disabled', async () => {
@@ -58,22 +63,55 @@ describe('useMessageDeliveryStatus', () => {
     const { channel, result } = await setup();
     expect(result.current.status).toBe(MessageDeliveryStatus.SENT);
 
-    act(() =>
-      setReceipts(channel, {
-        delivered: { [ownMessage.id]: [fromPartial<UserResponse>({ id: 'other' })] },
-      }),
-    );
+    act(() => setReceipts(channel, { delivered: cursorAt(0, ownMessage.id) }));
     expect(result.current.status).toBe(MessageDeliveryStatus.DELIVERED);
 
     act(() =>
       setReceipts(channel, {
-        delivered: { [ownMessage.id]: [fromPartial<UserResponse>({ id: 'other' })] },
-        readers: { [ownMessage.id]: [fromPartial<UserResponse>({ id: 'other' })] },
+        delivered: cursorAt(0, ownMessage.id),
+        read: cursorAt(0, ownMessage.id),
       }),
     );
     expect(result.current.status).toBe(MessageDeliveryStatus.READ);
   });
 
+  it('returns READ when another member read past the message', async () => {
+    const { channel, result } = await setup();
+
+    act(() => setReceipts(channel, { delivered: cursorAt(1000), read: cursorAt(1000) }));
+
+    expect(result.current.status).toBe(MessageDeliveryStatus.READ);
+  });
+
+  it('returns DELIVERED when the message was delivered past it but not read', async () => {
+    const { channel, result } = await setup();
+
+    act(() => setReceipts(channel, { delivered: cursorAt(1000), read: cursorAt(-1000) }));
+
+    expect(result.current.status).toBe(MessageDeliveryStatus.DELIVERED);
+  });
+
+  it('returns SENT when every cursor is before the message', async () => {
+    const { channel, result } = await setup();
+
+    act(() => setReceipts(channel, { delivered: cursorAt(-1000), read: cursorAt(-1000) }));
+
+    expect(result.current.status).toBe(MessageDeliveryStatus.SENT);
+  });
+
+  it('returns READ for a thread reply read past by another member', async () => {
+    const reply = generateMessage({
+      parent_id: 'parent',
+      timestamp: new Date('2026-01-01T10:00:00Z'),
+      user: generateUser({ id: 'me' }),
+    });
+    const { channel, result } = await setup({ lastMessage: reply });
+
+    act(() => setReceipts(channel, { delivered: cursorAt(1000), read: cursorAt(1000) }));
+
+    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 () => {
@@ -95,24 +133,11 @@ describe('useMessageDeliveryStatus', () => {
       { wrapper },
     );
 
-    act(() =>
-      setReceipts(channel, {
-        delivered: { [ownMessage.id]: [fromPartial<UserResponse>({ id: 'other' })] },
-      }),
-    );
+    act(() => setReceipts(channel, { delivered: cursorAt(0, ownMessage.id) }));
     expect(result.current.status).toBe(MessageDeliveryStatus.DELIVERED);
     const rendersWhenDelivered = renders;
 
-    act(() =>
-      setReceipts(channel, {
-        delivered: {
-          [ownMessage.id]: [
-            fromPartial<UserResponse>({ id: 'other' }),
-            fromPartial<UserResponse>({ id: 'third' }),
-          ],
-        },
-      }),
-    );
+    act(() => setReceipts(channel, { delivered: cursorAt(1000) }));
     expect(result.current.status).toBe(MessageDeliveryStatus.DELIVERED);
     expect(renders).toBe(rendersWhenDelivered);
   });

package/src/hooks/messagePreview/useMessageDeliveryStatus.ts

@@ -5,7 +5,7 @@ import {
   LocalMessage,
   MessageReceiptsSnapshot,
   MessageResponse,
-  UserResponse,
+  MsgRef,
 } from 'stream-chat';
 
 import { useChatContext } from '../../contexts/chatContext/ChatContext';
@@ -25,13 +25,19 @@ type MessageDeliveryStatusProps = {
   isReadEventsEnabled: boolean;
 };
 
-const hasOtherUser = (users: UserResponse[] | undefined, currentUserId: string | undefined) =>
-  !!users && (users.length > 1 || (users.length === 1 && users[0].id !== currentUserId));
+/** Whether a cursor has reached a message created at `createdAt`, even from a later message. */
+const hasCursorReached = (createdAt: number | undefined, cursor: MsgRef | null) =>
+  !!cursor && typeof createdAt === 'number' && Number.isFinite(createdAt)
+    ? createdAt <= cursor.timestamp
+    : false;
 
 /**
  * Delivery and read status of the last message when it is the current user's, derived from the
  * channel's `messageReceiptsTracker.snapshotStore`, the same store the in-list receipt hooks use.
  *
+ * It compares the message against `lastReadRefByOthers` and `lastDeliveredRefByOthers`, the furthest
+ * points anyone else has reached, so a message stays read once another member reads past it.
+ *
  * @param params.channel The channel the message belongs to.
  * @param params.lastMessage The channel's last message.
  * @param params.isReadEventsEnabled When false, the status is `NOT_SENT_BY_CURRENT_USER`. Defaults
@@ -44,15 +50,15 @@ export const useMessageDeliveryStatus = ({
   isReadEventsEnabled = true,
 }: MessageDeliveryStatusProps) => {
   const { client } = useChatContext();
-  const messageId = lastMessage?.id ?? '';
   const currentUserId = client.user?.id;
+  const createdAt = lastMessage?.created_at;
 
   const selector = useCallback(
     (snapshot: MessageReceiptsSnapshot) => ({
-      isDelivered: hasOtherUser(snapshot.deliveredByMessageId[messageId], currentUserId),
-      isRead: hasOtherUser(snapshot.readersByMessageId[messageId], currentUserId),
+      isDelivered: hasCursorReached(createdAt, snapshot.lastDeliveredRefByOthers),
+      isRead: hasCursorReached(createdAt, snapshot.lastReadRefByOthers),
     }),
-    [currentUserId, messageId],
+    [createdAt],
   );
 
   const { isDelivered, isRead } = useStateStore(

package/src/hooks/useIsDirectChat.ts

@@ -9,7 +9,7 @@ const pickId = (member: ChannelMemberResponse) => ({ id: member.user?.id });
 
 export const useIsDirectChat = (channel?: Channel) => {
   const { client } = useChatContext();
-  const ownUserId = client.userID;
+  const ownUserId = client.userId;
   const members = useChannelMembersState(channel, pickId);
 
   const otherMembers = useMemo(

package/src/i18n/__tests__/catalog.fixture.json

@@ -158,6 +158,7 @@
   "channelPreview.deliveryStatus.read.accessibilityLabel": "Read, sent by you",
   "channelPreview.deliveryStatus.sent.accessibilityLabel": "Sent by you",
   "channelPreview.displayName.others.label": "and {{ count }} others",
+  "channelPreview.doubleTapToOpen.accessibilityLabel": "Double tap to open",
   "channelPreview.lastMessage.accessibilityLabel": "Last message {{date}}",
   "channelPreview.messageFailed.error": "Message failed to send",
   "channelPreview.muted.accessibilityLabel": "Muted",
@@ -208,6 +209,7 @@
   "indicators.loading.error": "Error loading",
   "indicators.loading.messages.error": "Error loading messages for this channel...",
   "indicators.loading.messages.text": "Loading messages...",
+  "indicators.loading.replies.error": "Error loading replies...",
   "message.banUser.label": "Ban User",
   "message.blockUser.label": "Block User",
   "message.blockUserConfirm.label": "Block",

package/src/i18n/keys.ts

@@ -169,6 +169,7 @@ export type TranslationCatalog = {
   'channelPreview.deliveryStatus.read.accessibilityLabel': 'Read, sent by you';
   'channelPreview.deliveryStatus.sent.accessibilityLabel': 'Sent by you';
   'channelPreview.displayName.others.label': 'and {{ count }} others';
+  'channelPreview.doubleTapToOpen.accessibilityLabel': 'Double tap to open';
   'channelPreview.lastMessage.accessibilityLabel': 'Last message {{date}}';
   'channelPreview.messageFailed.error': 'Message failed to send';
   'channelPreview.muted.accessibilityLabel': 'Muted';
@@ -219,6 +220,7 @@ export type TranslationCatalog = {
   'indicators.loading.error': 'Error loading';
   'indicators.loading.messages.error': 'Error loading messages for this channel...';
   'indicators.loading.messages.text': 'Loading messages...';
+  'indicators.loading.replies.error': 'Error loading replies...';
   'message.banUser.label': 'Ban User';
   'message.blockUser.label': 'Block User';
   'message.blockUserConfirm.label': 'Block';
@@ -468,6 +470,7 @@ export type BundledTranslationKey =
   | 'channelPreview.deliveryStatus.delivered.accessibilityLabel'
   | 'channelPreview.deliveryStatus.read.accessibilityLabel'
   | 'channelPreview.deliveryStatus.sent.accessibilityLabel'
+  | 'channelPreview.doubleTapToOpen.accessibilityLabel'
   | 'channelPreview.lastMessage.accessibilityLabel'
   | 'channelPreview.muted.accessibilityLabel'
   | 'channelPreview.pinned.accessibilityLabel'

package/src/i18n/runtimeDefaults.ts

@@ -82,6 +82,7 @@ export const runtimeDefaults = {
   'channelPreview.deliveryStatus.delivered.accessibilityLabel': 'Delivered, sent by you',
   'channelPreview.deliveryStatus.read.accessibilityLabel': 'Read, sent by you',
   'channelPreview.deliveryStatus.sent.accessibilityLabel': 'Sent by you',
+  'channelPreview.doubleTapToOpen.accessibilityLabel': 'Double tap to open',
   'channelPreview.lastMessage.accessibilityLabel': 'Last message {{date}}',
   'channelPreview.muted.accessibilityLabel': 'Muted',
   'channelPreview.pinned.accessibilityLabel': 'Pinned',

package/src/store/__tests__/selectMessagesForChannels.test.ts

@@ -1,29 +1,27 @@
 import { generateChannelResponse } from '../../mock-builders/generator/channel';
 import { generateMessage } from '../../mock-builders/generator/message';
 import { BetterSqlite } from '../../test-utils/BetterSqlite';
+import { getChannels } from '../apis/getChannels';
 import { selectMessagesForChannels } from '../apis/queries/selectMessagesForChannels';
 import { upsertChannels } from '../apis/upsertChannels';
 import { SqliteClient } from '../SqliteClient';
 
 /**
- * The client treats the cached page as a `queryChannels` page of 25 messages, so a shorter one reads
- * as the start of the channel and older messages never load from the server.
+ * The client reads the cached page as a channel list page of `message_limit` messages, so a page of
+ * a different size makes it guess wrongly whether older messages exist, for example that a channel
+ * with a long history starts at its cached messages.
  */
 describe('selectMessagesForChannels', () => {
+  let cid: string;
+  let messages: ReturnType<typeof generateMessage>[];
+
   beforeEach(async () => {
     await SqliteClient.initializeDatabase();
     await BetterSqlite.openDB();
-  });
-
-  afterEach(() => {
-    BetterSqlite.dropAllTables();
-    BetterSqlite.closeDB();
-  });
 
-  it("returns a channel's newest 25 messages, oldest first", async () => {
     const channelResponse = generateChannelResponse({ members: [], messages: [] });
-    const cid = channelResponse.channel.cid as string;
-    const messages = Array.from({ length: 30 }, (_, i) =>
+    cid = channelResponse.channel.cid as string;
+    messages = Array.from({ length: 30 }, (_, i) =>
       generateMessage({ cid, timestamp: Date.UTC(2020, 0, 1, 0, i) }),
     );
     channelResponse.messages = messages as unknown as typeof channelResponse.messages;
@@ -31,9 +29,33 @@ describe('selectMessagesForChannels', () => {
       channels: [channelResponse] as unknown as Parameters<typeof upsertChannels>[0]['channels'],
       isLatestMessagesSet: true,
     });
+  });
+
+  afterEach(() => {
+    BetterSqlite.dropAllTables();
+    BetterSqlite.closeDB();
+  });
 
+  const ids = (rows: { id: string }[]) => rows.map((row) => row.id);
+
+  it("returns a channel's newest 25 messages, oldest first, by default", async () => {
     const rows = await selectMessagesForChannels([cid]);
 
-    expect(rows.map((row) => row.id)).toEqual(messages.slice(-25).map((message) => message.id));
+    expect(ids(rows)).toEqual(ids(messages.slice(-25)));
+  });
+
+  it("returns a channel's newest `messageLimit` messages", async () => {
+    expect(ids(await selectMessagesForChannels([cid], 10))).toEqual(ids(messages.slice(-10)));
+    expect(ids(await selectMessagesForChannels([cid], 50))).toEqual(ids(messages));
+  });
+
+  it('applies the limit that getChannels is given', async () => {
+    const [channel] = await getChannels({
+      channelIds: [cid],
+      messageLimit: 10,
+      userId: 'some-user',
+    });
+
+    expect(ids(channel.messages)).toEqual(ids(messages.slice(-10)));
   });
 });

package/src/store/apis/getChannelMessages.ts

@@ -12,15 +12,18 @@ import type { TableRow, TableRowJoinedUser } from '../types';
 export const getChannelMessages = async ({
   channelIds,
   userId,
+  messageLimit,
 }: {
   channelIds: string[];
   userId: string;
+  messageLimit?: number;
 }) => {
   SqliteClient.logger?.('info', 'getChannelMessages', {
     channelIds,
     userId,
+    messageLimit,
   });
-  const messageRows = await selectMessagesForChannels(channelIds);
+  const messageRows = await selectMessagesForChannels(channelIds, messageLimit);
   const messageIds = messageRows.map(({ id }) => id);
 
   const reactionRows = await selectReactionsForMessages(messageIds, null);

package/src/store/apis/getChannels.ts

@@ -16,16 +16,19 @@ import { SqliteClient } from '../SqliteClient';
  *
  * @param params.channelIds The channel IDs to fetch.
  * @param params.userId The ID of the current user.
+ * @param params.messageLimit How many of each channel's newest messages to return, 25 by default.
  * @returns The channels with their state.
  */
 export const getChannels = async ({
   channelIds,
   userId,
+  messageLimit,
 }: {
   channelIds: string[];
   userId: string;
+  messageLimit?: number;
 }): Promise<Omit<ChannelStateResponseFields, 'duration'>[]> => {
-  SqliteClient.logger?.('info', 'getChannels', { channelIds, userId });
+  SqliteClient.logger?.('info', 'getChannels', { channelIds, userId, messageLimit });
 
   const [channels, cidVsDraft, cidVsMembers, cidVsReads, cidVsMessages, cidVsActiveLocations] =
     await Promise.all([
@@ -36,6 +39,7 @@ export const getChannels = async ({
       getChannelMessages({
         channelIds,
         userId,
+        messageLimit,
       }),
       getChannelActiveLocations({ channelIds }),
     ]);

package/src/store/apis/getChannelsForFilterSort.ts

@@ -56,6 +56,7 @@ export const getChannelsForFilterSort = async ({
     channels: await getChannels({
       channelIds: cids,
       userId,
+      messageLimit: options?.message_limit,
     }),
     predefinedFilter,
   };

package/src/store/apis/queries/selectMessagesForChannels.ts

@@ -2,8 +2,12 @@ import { tables } from '../../schema';
 import { SqliteClient } from '../../SqliteClient';
 import type { TableRowJoinedUser } from '../../types';
 
+/** The `message_limit` the client assumes for a channel list query that sets none. */
+export const DEFAULT_CHANNEL_LIST_MESSAGE_LIMIT = 25;
+
 export const selectMessagesForChannels = async (
   cids: string[],
+  messageLimit: number = DEFAULT_CHANNEL_LIST_MESSAGE_LIMIT,
 ): Promise<TableRowJoinedUser<'messages'>[]> => {
   const questionMarks = Array(cids.length).fill('?').join(',');
   const messagesColumnNames = Object.keys(tables.messages.columns)
@@ -15,6 +19,7 @@ export const selectMessagesForChannels = async (
 
   SqliteClient.logger?.('info', 'selectMessagesForChannels', {
     cids,
+    messageLimit,
   });
 
   const result = await SqliteClient.executeSql(
@@ -38,9 +43,9 @@ export const selectMessagesForChannels = async (
     LEFT JOIN
       users b
     ON b.id = a.userId
-    WHERE RowNum <= 25
+    WHERE RowNum <= ?
     ORDER BY a.createdAt ASC`,
-    cids,
+    [...cids, messageLimit],
   );
 
   return result.map((r) => JSON.parse(r.value));

package/src/utils/installNativeMultipartAdapter.ts

@@ -282,9 +282,11 @@ const createNativeMultipartAdapter =
  * Routes multipart file uploads through the native uploader by setting `adapter` on those requests
  * only. Does nothing when native multipart upload is unavailable or the client is already set up.
  *
- * The client's default adapter is left alone: replacing it would require importing axios here to
- * resolve the fallback, and a copy different from `stream-chat`'s would fail every request with an
- * `AxiosError` that `stream-chat` does not recognize.
+ * Uploads go native even when the app installed an axios adapter of its own, as they did in v9;
+ * every other request still goes through the app's adapter. `defaults.adapter` itself is not
+ * replaced: that would require importing axios here to resolve the fallback, and a copy different
+ * from `stream-chat`'s would fail every request with an `AxiosError` that `stream-chat` does not
+ * recognize.
  *
  * @param client The client to install the adapter on.
  */

package/src/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "10.0.0-rc.2"
+  "version": "10.0.0-rc.3"
 }