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

package/src/components/MessageList/__tests__/MessageList.test.tsx

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { useEffect } from 'react';
 
 import { FlatList, StyleSheet } from 'react-native';
 
@@ -8,6 +8,9 @@ import type { LocalMessage, StreamChat as StreamChatClient, UserResponse } from
 import { msToNs, Thread } from 'stream-chat';
 
 import { WithComponents } from '../../../contexts/componentsContext/ComponentsContext';
+import { useMessageComposerAPIContext } from '../../../contexts/messageComposerContext/MessageComposerAPIContext';
+import { useMessageComposer } from '../../../contexts/messageInputContext/hooks/useMessageComposer';
+import { useMessageInputContext } from '../../../contexts/messageInputContext/MessageInputContext';
 import { OverlayProvider } from '../../../contexts/overlayContext/OverlayProvider';
 import { getOrCreateChannelApi } from '../../../mock-builders/api/getOrCreateChannel';
 
@@ -22,6 +25,7 @@ import { getTestClientWithUser } from '../../../mock-builders/mock';
 import { primitives } from '../../../theme';
 import { Channel } from '../../Channel/Channel';
 import { Chat } from '../../Chat/Chat';
+import { MessageComposer } from '../../MessageInput/MessageComposer';
 
 import { Thread as ThreadComponent } from '../../Thread/Thread';
 import { SCROLL_TO_BOTTOM_ACCESSIBILITY_ACTION_NAME } from '../hooks/useScrollToBottomAccessibilityAction';
@@ -1290,12 +1294,12 @@ describe('MessageList in a thread', () => {
         generateMessage({ parent_id: parentMessage.id, text: `reply-${i}` }),
       ),
     ) as LocalMessage[];
+    // Seeded as the thread seeds `latest_replies`: one complete page, which is the newest one.
     act(() =>
-      threadInstance.messagePaginator.state.partialNext({
-        hasMoreHead: false,
-        hasMoreTail: false,
-        isLoading: false,
-        items: replies,
+      threadInstance.messagePaginator.setItems({
+        valueOrFactory: replies,
+        isFirstPage: true,
+        isLastPage: true,
       }),
     );
 
@@ -1412,4 +1416,246 @@ describe('MessageList in a thread', () => {
     });
     expect(queryAllByLabelText('Inline unread indicator')).toHaveLength(0);
   });
+
+  // A thread opened without its replies shows only its parent message until the first page lands.
+  // Autoscroll has to be on by then, or the list keeps the parent in view and the replies render out
+  // of view below it.
+  it('autoscrolls to the replies that arrive after the thread opened empty', async () => {
+    const mockedChannel = generateChannelResponse();
+    const chatClient = await getTestClientWithUser({ id: 'testID' } as UserResponse);
+    useMockedApis(chatClient, [getOrCreateChannelApi(mockedChannel)]);
+    const channel = chatClient.channel('messaging', mockedChannel.channel.id);
+    await channel.watch();
+    const parentMessage = channel.state.formatMessage(generateMessage({ text: 'parent' }));
+    const threadInstance = new Thread({ channel, client: chatClient, parentMessage });
+    // The replies arrive from the test below, not from a query.
+    jest.spyOn(threadInstance, 'reload').mockResolvedValue(undefined);
+    jest.spyOn(threadInstance.messagePaginator, 'toTail').mockResolvedValue(undefined);
+    const { getByTestId, getByText } = render(
+      <OverlayProvider>
+        <Chat client={chatClient}>
+          <ThreadComponent thread={threadInstance}>
+            <MessageList />
+          </ThreadComponent>
+        </Chat>
+      </OverlayProvider>,
+    );
+    const autoscrollThreshold = () =>
+      getByTestId('message-flat-list').props.maintainVisibleContentPosition
+        ?.autoscrollToTopThreshold;
+    await waitFor(() => expect(autoscrollThreshold()).toBeDefined());
+
+    const replies = Array.from({ length: 3 }, (_, i) =>
+      channel.state.formatMessage(
+        generateMessage({ parent_id: parentMessage.id, text: `reply-${i}` }),
+      ),
+    ) as LocalMessage[];
+    act(() =>
+      threadInstance.messagePaginator.setItems({
+        valueOrFactory: replies,
+        isFirstPage: true,
+        isLastPage: true,
+      }),
+    );
+
+    await waitFor(() => expect(getByText('reply-2')).toBeTruthy());
+    expect(autoscrollThreshold()).toBeDefined();
+  });
+
+  it.each([
+    ['scrolls to', 'testID', 1],
+    ['does not scroll to', 'other-user', 0],
+  ])(
+    '%s the latest reply when a new reply is the user’s own (%s)',
+    async (_, userId, expectedScrolls) => {
+      const { channel, chatClient, getByText, threadInstance } = await setup();
+      const scrollToOffset = jest.spyOn(FlatList.prototype, 'scrollToOffset');
+
+      const reply = channel.state.formatMessage(
+        generateMessage({
+          cid: channel.cid,
+          parent_id: threadInstance.id,
+          text: 'new reply',
+          timestamp: new Date(),
+          user: generateUser({ id: userId }),
+        }),
+      ) as LocalMessage;
+      await act(async () => {
+        threadInstance.messagePaginator.ingestItem(reply);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      await waitFor(() => expect(getByText('new reply')).toBeTruthy());
+      expect(chatClient.userId).toBe('testID');
+      expect(scrollToOffset).toHaveBeenCalledTimes(expectedScrolls);
+      if (expectedScrolls) {
+        expect(scrollToOffset).toHaveBeenCalledWith({ animated: true, offset: 0 });
+      }
+    },
+  );
+});
+
+// Pressing a quote goes to the quoted message. A quoted reply that lives only in another thread is
+// not in this list, so its thread is opened at it instead.
+describe('MessageList quote press', () => {
+  afterEach(() => {
+    cleanup();
+    jest.restoreAllMocks();
+  });
+
+  const setup = async ({ quoteThreadOnlyReply }: { quoteThreadOnlyReply: boolean }) => {
+    const user = generateUser();
+    const base = new Date('2020-01-01T00:00:00.000Z').getTime();
+    const parentMessage = generateMessage({ timestamp: new Date(base), user });
+    const quotedMessage = generateMessage({
+      parent_id: quoteThreadOnlyReply ? parentMessage.id : undefined,
+      text: 'quoted text',
+      timestamp: new Date(base + 1000),
+      user,
+    });
+    const mockedChannel = generateChannelResponse({
+      members: [generateMember({ user })],
+      messages: [
+        parentMessage,
+        generateMessage({
+          quoted_message: quotedMessage,
+          quoted_message_id: quotedMessage.id,
+          timestamp: new Date(base + 2000),
+          user,
+        }),
+      ],
+    });
+    const chatClient = await getTestClientWithUser({ id: 'testID' } as UserResponse);
+    useMockedApis(chatClient, [getOrCreateChannelApi(mockedChannel)]);
+    const channel = chatClient.channel('messaging', mockedChannel.channel.id);
+    await channel.watch();
+    const thread = chatClient.threads.ensure({
+      channel,
+      parentMessage: channel.state.formatMessage(parentMessage),
+    });
+    const jumpToMessage = jest
+      .spyOn(channel.messagePaginator, 'jumpToMessage')
+      .mockResolvedValue(true);
+    const onAlsoSentToChannelHeaderPress = jest.fn();
+
+    const utils = render(
+      <OverlayProvider>
+        <Chat client={chatClient}>
+          <Channel
+            channel={channel}
+            onAlsoSentToChannelHeaderPress={onAlsoSentToChannelHeaderPress}
+          >
+            <MessageList />
+          </Channel>
+        </Chat>
+      </OverlayProvider>,
+    );
+    return { ...utils, jumpToMessage, onAlsoSentToChannelHeaderPress, quotedMessage, thread };
+  };
+
+  it('opens the thread of a quoted reply that lives only in that thread', async () => {
+    const { findByText, jumpToMessage, onAlsoSentToChannelHeaderPress, quotedMessage, thread } =
+      await setup({ quoteThreadOnlyReply: true });
+
+    fireEvent.press(await findByText('quoted text'));
+
+    await waitFor(() =>
+      expect(onAlsoSentToChannelHeaderPress).toHaveBeenCalledWith({
+        targetedMessageId: quotedMessage.id,
+        thread,
+      }),
+    );
+    expect(jumpToMessage).not.toHaveBeenCalled();
+  });
+
+  it('jumps to a quoted message that is in the channel', async () => {
+    const { findByText, jumpToMessage, onAlsoSentToChannelHeaderPress, quotedMessage } =
+      await setup({ quoteThreadOnlyReply: false });
+
+    fireEvent.press(await findByText('quoted text'));
+
+    await waitFor(() =>
+      expect(jumpToMessage).toHaveBeenCalledWith(quotedMessage.id, expect.anything()),
+    );
+    expect(onAlsoSentToChannelHeaderPress).not.toHaveBeenCalled();
+  });
+});
+
+describe('MessageList optimistic edit', () => {
+  afterEach(() => {
+    cleanup();
+    jest.restoreAllMocks();
+  });
+
+  // A UI renders `i18n.<language>_text` in place of `text`, so an optimistic edit that kept the
+  // translations of the old text showed the "Edited" label over the old message until the server
+  // responded (or, offline, until the edit was replayed).
+  it('shows an edit of an auto-translated message before the request resolves', async () => {
+    const me = generateUser({ id: 'testID' });
+    const mine = generateMessage({
+      i18n: { en_text: 'before edit', es_text: 'antes de editar', language: 'en' },
+      text: 'before edit',
+      user: me,
+    });
+    const mockedChannel = generateChannelResponse({
+      members: [generateMember({ user: me })],
+      messages: [mine],
+    });
+    mine.cid = mockedChannel.channel.cid;
+
+    const chatClient = await getTestClientWithUser(me);
+    useMockedApis(chatClient, [getOrCreateChannelApi(mockedChannel)]);
+    const channel = chatClient.channel('messaging', mockedChannel.channel.id);
+    await channel.watch();
+    // Never settles, so whatever is on screen is the optimistic state.
+    const updateMessage = jest
+      .spyOn(chatClient, 'updateMessage')
+      .mockImplementation(() => new Promise(() => undefined));
+
+    let startEditing: (message: LocalMessage) => void = () => undefined;
+    let submit: () => Promise<void> = () => Promise.resolve();
+    let composer: ReturnType<typeof useMessageComposer> | undefined;
+    const EditDriver = () => {
+      const { setEditingState } = useMessageComposerAPIContext();
+      const { sendMessage } = useMessageInputContext();
+      const messageComposer = useMessageComposer();
+      useEffect(() => {
+        startEditing = setEditingState;
+        submit = sendMessage;
+        composer = messageComposer;
+      });
+      return null;
+    };
+
+    const { getByTestId } = render(
+      <OverlayProvider>
+        <Chat client={chatClient}>
+          <Channel channel={channel}>
+            <MessageList />
+            <MessageComposer />
+            <EditDriver />
+          </Channel>
+        </Chat>
+      </OverlayProvider>,
+    );
+    await waitFor(() =>
+      expect(
+        within(getByTestId(`message-list-item-${mine.id}`)).getByText('before edit'),
+      ).toBeTruthy(),
+    );
+
+    act(() => startEditing(channel.messagePaginator.getItem(mine.id) as LocalMessage));
+    await waitFor(() => expect(composer?.editedMessage?.id).toBe(mine.id));
+    act(() => composer?.textComposer.setText('after edit'));
+    act(() => {
+      void submit();
+    });
+
+    await waitFor(() => expect(updateMessage).toHaveBeenCalled());
+    await waitFor(() => {
+      const row = within(getByTestId(`message-list-item-${mine.id}`));
+      expect(row.getByText('after edit')).toBeTruthy();
+      expect(row.queryByText('before edit')).toBeNull();
+    });
+  }, 15000);
 });

package/src/components/MessageList/hooks/useMessageListFocus.ts

@@ -2,7 +2,11 @@ import { useEffect } from 'react';
 
 import type { MessagePaginator } from 'stream-chat';
 
+import type { GoToMessage } from '../../../contexts/messageListItemContext/MessageListItemContext';
+import { useMessagesContext } from '../../../contexts/messagesContext/MessagesContext';
+import { useThreadContext } from '../../../contexts/threadContext/ThreadContext';
 import { useStableCallback, useStateStore } from '../../../hooks';
+import { useOpenThreadAtMessage } from '../../Message/hooks/useOpenThreadAtMessage';
 
 /** How long, in milliseconds, a message the list jumped to stays highlighted. */
 export const DEFAULT_HIGHLIGHT_DURATION = 3000;
@@ -23,7 +27,9 @@ const messageFocusSelector = (state: {
  * still running when the user navigates away would scroll and highlight again on return.
  *
  * @param paginator The channel's or the open thread's paginator.
- * @returns `focusedMessageId`, `focusToken` and `goToMessage`, which jumps to a message by ID.
+ * @returns `focusedMessageId`, `focusToken` and `goToMessage`, which jumps to a message by ID. A
+ * message passed along that is a reply living only in another thread is not in this list, so its
+ * thread is opened at it instead (through `onAlsoSentToChannelHeaderPress`, when set).
  */
 export const useMessageListFocus = (paginator?: MessagePaginator) => {
   const { focusedMessageId, focusToken } =
@@ -31,7 +37,21 @@ export const useMessageListFocus = (paginator?: MessagePaginator) => {
 
   useEffect(() => () => paginator?.clearMessageFocusSignal(), [paginator]);
 
-  const goToMessage = useStableCallback(async (messageId: string) => {
+  const { onAlsoSentToChannelHeaderPress } = useMessagesContext();
+  const { thread } = useThreadContext();
+  const openThreadAtMessage = useOpenThreadAtMessage();
+
+  const goToMessage: GoToMessage = useStableCallback(async (messageId, message) => {
+    const parentId = message?.parent_id;
+    if (
+      onAlsoSentToChannelHeaderPress &&
+      parentId &&
+      parentId !== thread?.id &&
+      !message.show_in_channel
+    ) {
+      await openThreadAtMessage({ parentId, targetedMessageId: messageId });
+      return;
+    }
     await paginator?.jumpToMessage(messageId, {
       focusReason: 'jump-to-message',
       focusSignalTtlMs: DEFAULT_HIGHLIGHT_DURATION,

package/src/components/Thread/__tests__/Thread.test.tsx

@@ -1,6 +1,14 @@
 import React from 'react';
 
-import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react-native';
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+  within,
+} from '@testing-library/react-native';
 import type {
   Channel as ChannelType,
   MessageResponse,
@@ -212,6 +220,43 @@ describe('Thread', () => {
   // already has its data doesn't.
   // An activation that is never released keeps the thread active for the session, so recovery
   // keeps reloading it and it keeps being read automatically.
+  it.each([
+    ['shows', true],
+    ['does not show', false],
+  ])(
+    '%s the delivery status of the parent message when it is the current user’s',
+    async (_, isOwn) => {
+      const parentMessage = generateMessage({
+        cid: channel.cid,
+        status: 'received',
+        text: 'Parent Message Text',
+        ...(isOwn ? { user: generateUser({ id: chatClient.userId }) } : {}),
+      });
+      const threadInstance = new ThreadClass({ channel, client: chatClient, parentMessage });
+      // A thread with its replies loaded is not reloaded on open (see "metadata reload on open").
+      threadInstance.messagePaginator.setItems({
+        valueOrFactory: [
+          channel.state.formatMessage(
+            generateMessage({
+              cid: channel.cid,
+              parent_id: parentMessage.id,
+            }) as unknown as MessageResponse,
+          ),
+        ],
+        isFirstPage: true,
+        isLastPage: true,
+      });
+
+      renderComponent({ chatClient, thread: threadInstance });
+
+      const header = await screen.findByTestId('thread-footer-component');
+      expect(within(header).getByText('Parent Message Text')).toBeTruthy();
+      expect(within(header).queryByTestId('message-status-sent')).toBe(
+        isOwn ? within(header).getByTestId('message-status-sent') : null,
+      );
+    },
+  );
+
   it('releases its activation of the thread on unmount', async () => {
     const parentMessage = generateMessage({ cid: 'messaging:test-channel', text: 'Parent' });
     const threadInstance = chatClient.threads.ensure({ channel, parentMessage });
@@ -586,4 +631,89 @@ describe('Thread lifecycle', () => {
       expect(markRead.mock.calls.every(([options]) => options?.thread_id)).toBe(true);
     });
   });
+
+  describe('reopening a thread left on an older page', () => {
+    const OLDER_PAGE_START = new Date('2020-01-01T00:00:00.000Z').getTime();
+
+    // A thread whose newest replies are loaded, but whose list shows an older page, as it does
+    // after a jump to a quoted or searched reply.
+    const setUpThreadOnOlderPage = async () => {
+      const testChannel = await watchChannel();
+      const parentMessage = testChannel.state.formatMessage(generateMessage({ user }));
+      const threadInstance = new ThreadClass({
+        channel: testChannel,
+        client: chatClient,
+        parentMessage,
+      });
+      jest.spyOn(threadInstance, 'reload').mockResolvedValue(undefined);
+      jest.spyOn(threadInstance.messagePaginator, 'toTail').mockResolvedValue(undefined);
+
+      threadInstance.messagePaginator.setItems({
+        valueOrFactory: Array.from({ length: 10 }, (_, i) =>
+          generateMessage({ id: `newest-${i}`, parent_id: parentMessage.id }),
+        ),
+        isFirstPage: true,
+        isLastPage: true,
+      });
+      threadInstance.messagePaginator.ingestPage({
+        page: Array.from({ length: 5 }, (_, i) =>
+          generateMessage({
+            id: `older-${i}`,
+            parent_id: parentMessage.id,
+            timestamp: OLDER_PAGE_START + i * 1000,
+          }),
+        ),
+        policy: 'strict-overlap-only',
+        setActive: true,
+      });
+      expect(threadInstance.messagePaginator.isActiveIntervalAtHead).toBe(false);
+
+      return threadInstance;
+    };
+
+    it('shows the newest replies again', async () => {
+      const threadInstance = await setUpThreadOnOlderPage();
+
+      openThread(threadInstance);
+
+      await waitFor(() =>
+        expect(threadInstance.messagePaginator.isActiveIntervalAtHead).toBe(true),
+      );
+      expect(threadInstance.messagePaginator.items?.map((reply) => reply.id)).toContain('newest-9');
+    });
+
+    it('keeps a jump the integrator already made to a loaded reply', async () => {
+      const threadInstance = await setUpThreadOnOlderPage();
+      // A deep link from the screen: the target is loaded, so the jump lands at once.
+      await threadInstance.messagePaginator.jumpToMessage('older-2', {
+        focusReason: 'jump-to-message',
+      });
+      const jumpToTheLatestMessageSpy = jest.spyOn(
+        threadInstance.messagePaginator,
+        'jumpToTheLatestMessage',
+      );
+
+      openThread(threadInstance);
+
+      expect(jumpToTheLatestMessageSpy).not.toHaveBeenCalled();
+      expect(threadInstance.messagePaginator.isActiveIntervalAtHead).toBe(false);
+      expect(
+        threadInstance.messagePaginator.messageFocusSignal.getLatestValue().signal?.messageId,
+      ).toBe('older-2');
+    });
+
+    it('leaves a jump that is still in flight alone', async () => {
+      const threadInstance = await setUpThreadOnOlderPage();
+      // A deep link to a reply that is not loaded: its query is in flight.
+      jest.spyOn(threadInstance.messagePaginator, 'isLoading', 'get').mockReturnValue(true);
+      const jumpToTheLatestMessageSpy = jest.spyOn(
+        threadInstance.messagePaginator,
+        'jumpToTheLatestMessage',
+      );
+
+      openThread(threadInstance);
+
+      expect(jumpToTheLatestMessageSpy).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/components/Thread/components/ThreadFooterComponent.tsx

@@ -67,7 +67,6 @@ const ThreadFooterComponentWithContext = (props: ThreadFooterComponentPropsWithC
         groupStyles={['single']}
         message={parentMessage}
         preventPress={parentMessagePreventPress}
-        showMessageStatus={false}
       />
       <View style={styles.newThread}>
         <Text style={styles.text}>

package/src/components/index.ts

@@ -34,6 +34,7 @@ export * from './Channel/hooks/useCreateChannelContext';
 export * from './Channel/hooks/useCreateInputMessageInputContext';
 export * from './Channel/hooks/useCreateMessagesContext';
 export * from './Channel/hooks/useCreateThreadContext';
+export * from './Channel/hooks/useJumpToLatestOnOpen';
 
 export * from './ChannelList/ChannelList';
 export * from './ChannelList/ChannelListFooterLoadingIndicator';

package/src/contexts/channelPinnedMessageListContext/ChannelPinnedMessageListContext.tsx

@@ -21,20 +21,11 @@ export const ChannelPinnedMessageListProvider = ({
 }: PropsWithChildren<{ channel: Channel; searchSource?: MessageSearchSource }>) => {
   const { client } = useChatContext();
   const [defaultSearchSource] = useState(() => {
-    const source = new MessageSearchSource(
-      client,
-      { pageSize: 25, allowEmptySearchString: true, resetOnNewSearchQuery: false },
-      {
-        messageSearch: {
-          initialFilterConfig: {
-            $or: {
-              enabled: true,
-              generate: ({ searchQuery }) => (searchQuery ? { text: { $q: searchQuery } } : {}),
-            },
-          },
-        },
-      },
-    );
+    const source = new MessageSearchSource(client, {
+      pageSize: 25,
+      allowEmptySearchString: true,
+      resetOnNewSearchQuery: false,
+    });
     source.messageSearchChannelFilters = { cid: channel.cid, members: undefined };
     source.messageSearchFilters = { pinned: true, type: undefined };
     source.activate();

package/src/contexts/messageContext/MessageContext.tsx

@@ -19,6 +19,7 @@ import type { Rect } from '../../state-store/message-overlay-store';
 import type { ViewRef } from '../../types/react-native-compat';
 
 import type { MessageComposerAPIContextValue } from '../messageComposerContext/MessageComposerAPIContext';
+import type { GoToMessage } from '../messageListItemContext/MessageListItemContext';
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
 export type Alignment = 'right' | 'left';
@@ -113,7 +114,7 @@ export type MessageContextValue = {
   showMessageStatus: boolean;
   /** The video attachments of the message. */
   videos: Attachment[];
-  goToMessage?: (messageId: string) => void;
+  goToMessage?: GoToMessage;
   /**
    * Handles a reaction on the message.
    *

package/src/contexts/messageListItemContext/MessageListItemContext.tsx

@@ -1,18 +1,27 @@
 import React, { createContext, PropsWithChildren, useContext } from 'react';
 
+import type { LocalMessage } from 'stream-chat';
+
 import { MessageListProps } from '../../components/MessageList/MessageList';
 
 import { Theme } from '../themeContext/utils/theme';
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 import { isTestEnvironment } from '../utils/isTestEnvironment';
 
+/**
+ * Goes to a message, used when a quoted message is pressed.
+ *
+ * @param messageId The ID of the message to go to.
+ * @param message The message, when the caller has it (the pressed quote passes its quoted message).
+ */
+export type GoToMessage = (
+  messageId: string,
+  message?: NonNullable<LocalMessage['quoted_message']>,
+) => void;
+
 export type MessageListItemContextValue = {
-  /**
-   * Goes to a message, used when a quoted message is pressed.
-   *
-   * @param messageId The ID of the message to go to.
-   */
-  goToMessage: (messageId: string) => void;
+  /** Goes to a message, used when a quoted message is pressed. */
+  goToMessage: GoToMessage;
   /** The theme of the list items, with `myMessageTheme` merged in. */
   modifiedTheme: Theme;
   /** Turns off grouping of consecutive messages by user. */

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

@@ -295,8 +295,8 @@
   "messageInput.sendMessage.accessibilityLabel": "Send message",
   "messageInput.sendMessageDisallowed.text": "You can't send messages in this channel",
   "messageList.dismissUnread.accessibilityLabel": "Dismiss unread messages",
-  "messageList.newMessages.text_one": "{{count}} new message",
-  "messageList.newMessages.text_other": "{{count}} new messages",
+  "messageList.newMessages.text_one": "{{count}} unread message",
+  "messageList.newMessages.text_other": "{{count}} unread messages",
   "messageList.scrollToBottom.accessibilityLabel": "Scroll to bottom",
   "messageList.scrollToBottom.withCount.accessibilityLabel_one": "Scroll to bottom, {{count}} new message",
   "messageList.scrollToBottom.withCount.accessibilityLabel_other": "Scroll to bottom, {{count}} new messages",

package/src/i18n/keys.ts

@@ -306,8 +306,8 @@ export type TranslationCatalog = {
   'messageInput.sendMessage.accessibilityLabel': 'Send message';
   'messageInput.sendMessageDisallowed.text': "You can't send messages in this channel";
   'messageList.dismissUnread.accessibilityLabel': 'Dismiss unread messages';
-  'messageList.newMessages.text_one': '{{count}} new message';
-  'messageList.newMessages.text_other': '{{count}} new messages';
+  'messageList.newMessages.text_one': '{{count}} unread message';
+  'messageList.newMessages.text_other': '{{count}} unread messages';
   'messageList.scrollToBottom.accessibilityLabel': 'Scroll to bottom';
   'messageList.scrollToBottom.withCount.accessibilityLabel_one': 'Scroll to bottom, {{count}} new message';
   'messageList.scrollToBottom.withCount.accessibilityLabel_other': 'Scroll to bottom, {{count}} new messages';

package/src/index.ts

@@ -23,7 +23,6 @@ export * from './types/types';
 export * from './utils/attachmentUrls';
 export * from './utils/i18n/Streami18n';
 export * from './i18n';
-export * from './utils/setupCommandUIMiddlewares';
 export * from './utils/createGenerateVideoThumbnails';
 export * from './utils/utils';
 export * from './nativeMultipartUpload';

package/src/types/stream-chat-common-custom-data.d.ts

@@ -3,7 +3,6 @@ import 'stream-chat';
 import {
   DefaultAttachmentData,
   DefaultChannelData,
-  DefaultCommandData,
   DefaultEventData,
   DefaultMemberData,
   DefaultMessageData,
@@ -21,8 +20,6 @@ declare module 'stream-chat' {
 
   interface CustomChannelData extends DefaultChannelData {}
 
-  interface CustomCommandData extends DefaultCommandData {}
-
   interface CustomEventData extends DefaultEventData {}
 
   interface CustomMemberData extends DefaultMemberData {}

package/src/types/types.ts

@@ -60,11 +60,6 @@ export interface DefaultChannelData {
   name?: string;
 }
 
-export interface DefaultCommandData {
-  flag: unknown;
-  imgur: unknown;
-}
-
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 
 export interface DefaultEventData {}

package/src/version.json

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