@sendbird/uikit-react-native 3.5.3 → 3.6.0

package/src/fragments/createGroupChannelThreadFragment.tsx

@@ -0,0 +1,280 @@
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+
+import { Box, useToast } from '@sendbird/uikit-react-native-foundation';
+import { useGroupChannelThreadMessages } from '@sendbird/uikit-tools';
+import {
+  SendbirdFileMessage,
+  SendbirdGroupChannel,
+  type SendbirdMessage,
+  SendbirdUserMessage,
+  getReadableFileSize,
+} from '@sendbird/uikit-utils';
+import {
+  NOOP,
+  PASS,
+  confirmAndMarkAsRead,
+  messageComparator,
+  useFreshCallback,
+  useRefTracker,
+} from '@sendbird/uikit-utils';
+
+import GroupChannelMessageRenderer from '../components/GroupChannelMessageRenderer';
+import StatusComposition from '../components/StatusComposition';
+import createGroupChannelThreadModule from '../domain/groupChannelThread/module/createGroupChannelThreadModule';
+import type {
+  GroupChannelThreadFragment,
+  GroupChannelThreadModule,
+  GroupChannelThreadProps,
+  GroupChannelThreadPubSubContextPayload,
+} from '../domain/groupChannelThread/types';
+import { useLocalization, usePlatformService, useSendbirdChat } from '../hooks/useContext';
+import pubsub from '../utils/pubsub';
+
+const createGroupChannelThreadFragment = (
+  initModule?: Partial<GroupChannelThreadModule>,
+): GroupChannelThreadFragment => {
+  const GroupChannelThreadModule = createGroupChannelThreadModule(initModule);
+
+  return ({
+    renderMessage,
+    enableMessageGrouping = true,
+    onPressHeaderLeft = NOOP,
+    onPressHeaderSubtitle = NOOP,
+    onPressMediaMessage = NOOP,
+    onParentMessageDeleted = NOOP,
+    onChannelDeleted = NOOP,
+    onBeforeSendUserMessage = PASS,
+    onBeforeSendFileMessage = PASS,
+    onBeforeUpdateUserMessage = PASS,
+    onBeforeUpdateFileMessage = PASS,
+    channel,
+    parentMessage,
+    startingPoint,
+    keyboardAvoidOffset,
+    sortComparator = threadMessageComparator,
+    flatListProps,
+  }) => {
+    const { playerService, recorderService } = usePlatformService();
+    const { sdk, currentUser, sbOptions, voiceMessageStatusManager, groupChannelFragmentOptions } = useSendbirdChat();
+
+    const [groupChannelThreadPubSub] = useState(() => pubsub<GroupChannelThreadPubSubContextPayload>());
+    const [scrolledAwayFromBottom, setScrolledAwayFromBottom] = useState(false);
+    const scrolledAwayFromBottomRef = useRefTracker(scrolledAwayFromBottom);
+
+    const toast = useToast();
+    const { STRINGS } = useLocalization();
+    const [_parentMessage, setParentMessage] = useState(parentMessage);
+
+    const {
+      loading,
+      messages,
+      newMessages,
+      resetNewMessages,
+      loadNext,
+      loadPrevious,
+      hasNext,
+      sendFileMessage,
+      sendUserMessage,
+      updateFileMessage,
+      updateUserMessage,
+      resendMessage,
+      deleteMessage,
+      resetWithStartingPoint,
+    } = useGroupChannelThreadMessages(sdk, channel, _parentMessage, {
+      shouldCountNewMessages: () => scrolledAwayFromBottomRef.current,
+      onMessagesReceived(messages) {
+        groupChannelThreadPubSub.publish({ type: 'MESSAGES_RECEIVED', data: { messages } });
+      },
+      onMessagesUpdated(messages) {
+        groupChannelThreadPubSub.publish({ type: 'MESSAGES_UPDATED', data: { messages } });
+      },
+      onParentMessageUpdated(parentMessage) {
+        setParentMessage(parentMessage);
+      },
+      onParentMessageDeleted: () => {
+        toast.show(STRINGS.TOAST.THREAD_PARENT_MESSAGE_DELETED_ERROR, 'error');
+        onParentMessageDeleted?.();
+      },
+      onChannelDeleted,
+      onCurrentUserBanned: onChannelDeleted,
+      sortComparator,
+      markAsRead: confirmAndMarkAsRead,
+      isReactionEnabled: sbOptions.uikit.groupChannel.channel.enableReactions,
+      startingPoint,
+    });
+
+    const onBlurFragment = () => {
+      return Promise.allSettled([playerService.reset(), recorderService.reset()]);
+    };
+    const _onPressHeaderLeft = useFreshCallback(async () => {
+      await onBlurFragment();
+      voiceMessageStatusManager.publishAll();
+      onPressHeaderLeft();
+    });
+    const _onPressHeaderSubtitle = useFreshCallback(async () => {
+      await onBlurFragment();
+      voiceMessageStatusManager.publishAll();
+      groupChannelFragmentOptions.pubsub.publish({
+        type: 'OVERRIDE_SEARCH_ITEM_STARTING_POINT',
+        data: { startingPoint: parentMessage.createdAt },
+      });
+      onPressHeaderSubtitle();
+    });
+    const _onPressMediaMessage: NonNullable<GroupChannelThreadProps['MessageList']['onPressMediaMessage']> =
+      useFreshCallback(async (message, deleteMessage, uri) => {
+        await onBlurFragment();
+        onPressMediaMessage(message, deleteMessage, uri);
+      });
+
+    useEffect(() => {
+      return () => {
+        onBlurFragment();
+      };
+    }, []);
+
+    const renderItem: GroupChannelThreadProps['MessageList']['renderMessage'] = useFreshCallback((props) => {
+      const content = renderMessage ? (
+        renderMessage(props)
+      ) : (
+        <GroupChannelMessageRenderer hideParentMessage {...props} />
+      );
+      return <Box>{content}</Box>;
+    });
+
+    const memoizedFlatListProps = useMemo(
+      () => ({
+        ListHeaderComponent: (
+          <GroupChannelThreadModule.ParentMessageInfo
+            channel={channel}
+            currentUserId={currentUser?.userId}
+            onDeleteMessage={deleteMessage}
+            onPressMediaMessage={_onPressMediaMessage}
+          />
+        ),
+        contentContainerStyle: { flexGrow: 1 },
+        ...flatListProps,
+      }),
+      [flatListProps],
+    );
+
+    const onResetMessageList = useCallback(async () => {
+      return await resetWithStartingPoint(Number.MAX_SAFE_INTEGER);
+    }, []);
+
+    const onResetMessageListWithStartingPoint = useCallback(async (startingPoint: number) => {
+      return await resetWithStartingPoint(startingPoint);
+    }, []);
+
+    const onPending = (message: SendbirdFileMessage | SendbirdUserMessage) => {
+      groupChannelThreadPubSub.publish({ type: 'MESSAGE_SENT_PENDING', data: { message } });
+    };
+
+    const onSent = (message: SendbirdFileMessage | SendbirdUserMessage) => {
+      groupChannelThreadPubSub.publish({ type: 'MESSAGE_SENT_SUCCESS', data: { message } });
+    };
+
+    const updateIfParentMessage = (message: SendbirdFileMessage | SendbirdUserMessage) => {
+      if (message.messageId === parentMessage.parentMessageId) {
+        setParentMessage(message);
+      }
+    };
+
+    const onPressSendUserMessage: GroupChannelThreadProps['Input']['onPressSendUserMessage'] = useFreshCallback(
+      async (params) => {
+        const processedParams = await onBeforeSendUserMessage(params);
+        const message = await sendUserMessage(processedParams, onPending);
+        onSent(message);
+      },
+    );
+    const onPressSendFileMessage: GroupChannelThreadProps['Input']['onPressSendFileMessage'] = useFreshCallback(
+      async (params) => {
+        const processedParams = await onBeforeSendFileMessage(params);
+        const fileSize = (processedParams.file as File)?.size ?? processedParams.fileSize;
+        const uploadSizeLimit = sbOptions.appInfo.uploadSizeLimit;
+
+        if (fileSize && uploadSizeLimit && fileSize > uploadSizeLimit) {
+          const sizeLimitString = `${getReadableFileSize(uploadSizeLimit)} MB`;
+          toast.show(STRINGS.TOAST.FILE_UPLOAD_SIZE_LIMIT_EXCEEDED_ERROR(sizeLimitString), 'error');
+          return;
+        } else {
+          const message = await sendFileMessage(processedParams, onPending);
+          onSent(message);
+        }
+      },
+    );
+    const onPressUpdateUserMessage: GroupChannelThreadProps['Input']['onPressUpdateUserMessage'] = useFreshCallback(
+      async (message, params) => {
+        const processedParams = await onBeforeUpdateUserMessage(params);
+        const updatedMessage = await updateUserMessage(message.messageId, processedParams);
+        updateIfParentMessage(updatedMessage);
+      },
+    );
+    const onPressUpdateFileMessage: GroupChannelThreadProps['Input']['onPressUpdateFileMessage'] = useFreshCallback(
+      async (message, params) => {
+        const processedParams = await onBeforeUpdateFileMessage(params);
+        const updatedMessage = await updateFileMessage(message.messageId, processedParams);
+        updateIfParentMessage(updatedMessage);
+      },
+    );
+    const onScrolledAwayFromBottom = useFreshCallback((value: boolean) => {
+      if (!value) resetNewMessages();
+      setScrolledAwayFromBottom(value);
+    });
+
+    return (
+      <GroupChannelThreadModule.Provider
+        channel={channel}
+        parentMessage={_parentMessage}
+        groupChannelThreadPubSub={groupChannelThreadPubSub}
+        keyboardAvoidOffset={keyboardAvoidOffset}
+        threadedMessages={messages}
+      >
+        <GroupChannelThreadModule.Header onPressLeft={_onPressHeaderLeft} onPressSubtitle={_onPressHeaderSubtitle} />
+        <StatusComposition loading={loading} LoadingComponent={<GroupChannelThreadModule.StatusLoading />}>
+          <GroupChannelThreadModule.MessageList
+            channel={channel}
+            onResetMessageList={onResetMessageList}
+            onResetMessageListWithStartingPoint={onResetMessageListWithStartingPoint}
+            enableMessageGrouping={enableMessageGrouping}
+            currentUserId={currentUser?.userId}
+            renderMessage={renderItem}
+            messages={messages}
+            newMessages={newMessages}
+            onTopReached={loadPrevious}
+            onBottomReached={loadNext}
+            hasNext={hasNext}
+            scrolledAwayFromBottom={scrolledAwayFromBottom}
+            onScrolledAwayFromBottom={onScrolledAwayFromBottom}
+            onResendFailedMessage={resendMessage}
+            onDeleteMessage={deleteMessage}
+            onPressMediaMessage={_onPressMediaMessage}
+            flatListProps={memoizedFlatListProps}
+            startingPoint={startingPoint}
+          />
+          <GroupChannelThreadModule.Input
+            SuggestedMentionList={GroupChannelThreadModule.SuggestedMentionList}
+            shouldRenderInput={shouldRenderInput(channel)}
+            onPressSendUserMessage={onPressSendUserMessage}
+            onPressSendFileMessage={onPressSendFileMessage}
+            onPressUpdateUserMessage={onPressUpdateUserMessage}
+            onPressUpdateFileMessage={onPressUpdateFileMessage}
+          />
+        </StatusComposition>
+      </GroupChannelThreadModule.Provider>
+    );
+  };
+};
+
+function shouldRenderInput(channel: SendbirdGroupChannel) {
+  if (channel.isBroadcast) {
+    return channel.myRole === 'operator';
+  }
+
+  return true;
+}
+
+export function threadMessageComparator(a: SendbirdMessage, b: SendbirdMessage) {
+  return messageComparator(a, b) * -1;
+}
+
+export default createGroupChannelThreadFragment;

package/src/hooks/useMentionSuggestion.ts

@@ -88,15 +88,19 @@ const useMentionSuggestion = (params: {
         .then((members) => members.filter((member) => member.userId !== currentUser?.userId))
         .then((members) => members.slice(0, mentionManager.config.suggestionLimit));
     } else {
-      return freshChannel.members
-        .sort((a, b) => a.nickname?.localeCompare(b.nickname))
-        .filter(
-          (member) =>
-            member.nickname?.toLowerCase().startsWith(searchString.toLowerCase()) &&
-            member.userId !== currentUser?.userId &&
-            member.isActive,
-        )
-        .slice(0, mentionManager.config.suggestionLimit);
+      return (
+        freshChannel.members
+          // NOTE: When using 'org.webkit:android-jsc', there is a problem with sorting lists that include words starting with uppercase and lowercase letters.
+          // To ensure consistent sorting regardless of the JSC, we compare the words in lowercase.
+          .sort((a, b) => a.nickname?.toLowerCase().localeCompare(b.nickname.toLowerCase()))
+          .filter(
+            (member) =>
+              member.nickname?.toLowerCase().startsWith(searchString.toLowerCase()) &&
+              member.userId !== currentUser?.userId &&
+              member.isActive,
+          )
+          .slice(0, mentionManager.config.suggestionLimit)
+      );
     }
   };
 

package/src/index.ts

@@ -36,6 +36,7 @@ export { default as createGroupChannelRegisterOperatorFragment } from './fragmen
 export { default as createGroupChannelMutedMembersFragment } from './fragments/createGroupChannelMutedMembersFragment';
 export { default as createGroupChannelBannedUsersFragment } from './fragments/createGroupChannelBannedUsersFragment';
 export { default as createGroupChannelNotificationsFragment } from './fragments/createGroupChannelNotificationsFragment';
+export { default as createGroupChannelThreadFragment } from './fragments/createGroupChannelThreadFragment';
 export { default as createMessageSearchFragment } from './fragments/createMessageSearchFragment';
 
 /** Fragments - open channels **/
@@ -102,6 +103,9 @@ export * from './domain/groupChannelUserList/types';
 
 export * from './domain/messageSearch/types';
 
+export * from './domain/groupChannelThread';
+export * from './domain/groupChannelThread/types';
+
 /** Feature - open channels **/
 export * from './domain/openChannel';
 export * from './domain/openChannel/types';

package/src/libs/VoiceMessageStatusManager.ts

@@ -0,0 +1,56 @@
+interface VoiceMessageStatus {
+  currentTime: number;
+  subscribers?: Set<(currentTime: number) => void>;
+}
+
+class VoiceMessageStatusManager {
+  private statusMap: Map<string, VoiceMessageStatus> = new Map();
+
+  private generateKey = (channelUrl: string, messageId: number): string => {
+    return `${channelUrl}-${messageId}`;
+  };
+
+  subscribe = (channelUrl: string, messageId: number, subscriber: (currentTime: number) => void) => {
+    const key = this.generateKey(channelUrl, messageId);
+    if (!this.statusMap.has(key)) {
+      this.statusMap.set(key, { currentTime: 0, subscribers: new Set() });
+    }
+    this.statusMap.get(key)!.subscribers?.add(subscriber);
+  };
+
+  unsubscribe = (channelUrl: string, messageId: number, subscriber: (currentTime: number) => void) => {
+    const key = this.generateKey(channelUrl, messageId);
+    this.statusMap.get(key)?.subscribers?.delete(subscriber);
+  };
+
+  publishAll = (): void => {
+    this.statusMap.forEach((status) => {
+      status.subscribers?.forEach((subscriber) => {
+        subscriber(status.currentTime);
+      });
+    });
+  };
+
+  getCurrentTime = (channelUrl: string, messageId: number): number => {
+    const key = this.generateKey(channelUrl, messageId);
+    return this.statusMap.get(key)?.currentTime || 0;
+  };
+
+  setCurrentTime = (channelUrl: string, messageId: number, currentTime: number): void => {
+    const key = this.generateKey(channelUrl, messageId);
+    if (!this.statusMap.has(key)) {
+      this.statusMap.set(key, { currentTime });
+    } else {
+      this.statusMap.get(key)!.currentTime = currentTime;
+    }
+  };
+
+  clear = (): void => {
+    this.statusMap.forEach((status) => {
+      status.subscribers?.clear();
+    });
+    this.statusMap.clear();
+  };
+}
+
+export default VoiceMessageStatusManager;

package/src/localization/StringSet.type.ts

@@ -127,6 +127,28 @@ export interface StringSet {
     /** GroupChannel > Suggested mention list */
     MENTION_LIMITED: (mentionLimit: number) => string;
   };
+  GROUP_CHANNEL_THREAD: {
+    /** GroupChannelThread > Header */
+    HEADER_TITLE: string;
+    HEADER_SUBTITLE: (currentUserId: string, channel: SendbirdGroupChannel) => string;
+
+    /** GroupChannelThread > List */
+    LIST_DATE_SEPARATOR: (date: Date, locale?: Locale) => string;
+    LIST_BUTTON_NEW_MSG: (newMessages: SendbirdMessage[]) => string;
+
+    /** GroupChannelThread > Message bubble */
+    MESSAGE_BUBBLE_TIME: (message: SendbirdMessage, locale?: Locale) => string;
+    MESSAGE_BUBBLE_FILE_TITLE: (message: SendbirdFileMessage) => string;
+    MESSAGE_BUBBLE_EDITED_POSTFIX: string;
+    MESSAGE_BUBBLE_UNKNOWN_TITLE: (message: SendbirdMessage) => string;
+    MESSAGE_BUBBLE_UNKNOWN_DESC: (message: SendbirdMessage) => string;
+
+    PARENT_MESSAGE_TIME: (message: SendbirdMessage, locale?: Locale) => string;
+    REPLY_COUNT: (replyCount: number, maxReplyCount?: number) => string;
+
+    /** GroupChannelThread > Suggested mention list */
+    MENTION_LIMITED: (mentionLimit: number) => string;
+  };
   GROUP_CHANNEL_SETTINGS: {
     /** GroupChannelSettings > Header */
     HEADER_TITLE: string;
@@ -270,6 +292,8 @@ export interface StringSet {
     CHANNEL_INPUT_PLACEHOLDER_DISABLED: string;
     CHANNEL_INPUT_PLACEHOLDER_MUTED: string;
     CHANNEL_INPUT_PLACEHOLDER_REPLY: string;
+    CHANNEL_INPUT_PLACEHOLDER_REPLY_IN_THREAD: string;
+    CHANNEL_INPUT_PLACEHOLDER_REPLY_TO_THREAD: string;
     CHANNEL_INPUT_EDIT_OK: string;
     CHANNEL_INPUT_EDIT_CANCEL: string;
     /** ChannelInput > Attachments **/
@@ -286,6 +310,7 @@ export interface StringSet {
     CHANNEL_MESSAGE_SAVE: string;
     CHANNEL_MESSAGE_DELETE: string;
     CHANNEL_MESSAGE_REPLY: string;
+    CHANNEL_MESSAGE_THREAD: string;
     /** Channel > Message > Delete confirm **/
     CHANNEL_MESSAGE_DELETE_CONFIRM_TITLE: string;
     CHANNEL_MESSAGE_DELETE_CONFIRM_OK: string;
@@ -346,6 +371,8 @@ export interface StringSet {
     UNKNOWN_ERROR: string;
     GET_CHANNEL_ERROR: string;
     FIND_PARENT_MSG_ERROR: string;
+    THREAD_PARENT_MESSAGE_DELETED_ERROR: string;
+    FILE_UPLOAD_SIZE_LIMIT_EXCEEDED_ERROR: (uploadSizeLimit: string) => string;
   };
   PROFILE_CARD: {
     BUTTON_MESSAGE: string;

package/src/localization/createBaseStringSet.ts

@@ -1,6 +1,6 @@
 import type { Locale } from 'date-fns';
 
-import type { PartialDeep } from '@sendbird/uikit-utils';
+import { PartialDeep, SendbirdMessage, getThreadParentMessageTimeFormat } from '@sendbird/uikit-utils';
 import {
   getDateSeparatorFormat,
   getGroupChannelPreviewTime,
@@ -12,6 +12,7 @@ import {
   getMessageType,
   getOpenChannelParticipants,
   getOpenChannelTitle,
+  getReplyCountFormat,
   isVoiceMessage,
 } from '@sendbird/uikit-utils';
 
@@ -127,6 +128,25 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
       MENTION_LIMITED: (mentionLimit) => `You can have up to ${mentionLimit} mentions per message.`,
       ...overrides?.GROUP_CHANNEL,
     },
+    GROUP_CHANNEL_THREAD: {
+      HEADER_TITLE: 'Thread',
+      HEADER_SUBTITLE: (uid, channel) => getGroupChannelTitle(uid, channel, USER_NO_NAME, CHANNEL_NO_MEMBERS),
+      LIST_DATE_SEPARATOR: (date, locale) => getDateSeparatorFormat(date, locale ?? dateLocale),
+      LIST_BUTTON_NEW_MSG: (newMessages) => `${newMessages.length} new messages`,
+
+      MESSAGE_BUBBLE_TIME: (message, locale) => getMessageTimeFormat(new Date(message.createdAt), locale ?? dateLocale),
+      MESSAGE_BUBBLE_FILE_TITLE: (message) => message.name,
+      MESSAGE_BUBBLE_EDITED_POSTFIX: ' (edited)',
+      MESSAGE_BUBBLE_UNKNOWN_TITLE: () => '(Unknown message type)',
+      MESSAGE_BUBBLE_UNKNOWN_DESC: () => 'Cannot read this message.',
+
+      PARENT_MESSAGE_TIME: (message: SendbirdMessage, locale?: Locale) =>
+        getThreadParentMessageTimeFormat(new Date(message.createdAt), locale ?? dateLocale),
+      REPLY_COUNT: (replyCount: number, maxReplyCount?: number) => getReplyCountFormat(replyCount, maxReplyCount),
+
+      MENTION_LIMITED: (mentionLimit) => `You can have up to ${mentionLimit} mentions per message.`,
+      ...overrides?.GROUP_CHANNEL_THREAD,
+    },
     GROUP_CHANNEL_SETTINGS: {
       HEADER_TITLE: 'Channel information',
       HEADER_RIGHT: 'Edit',
@@ -260,9 +280,11 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
         return 'Several people are typing...';
       },
       REPLY_FROM_SENDER_TO_RECEIVER: (reply, parent, currentUserId = UNKNOWN_USER_ID) => {
-        const senderNickname = reply.sender.nickname || USER_NO_NAME;
-        const receiverNickname = parent.sender.nickname || USER_NO_NAME;
-        return `${reply.sender.userId !== currentUserId ? senderNickname : 'You'} replied to ${receiverNickname}`;
+        const replySenderNickname =
+          reply.sender.userId === currentUserId ? 'You' : reply.sender.nickname || USER_NO_NAME;
+        const parentSenderNickname =
+          parent.sender.userId === currentUserId ? 'You' : parent.sender.nickname || USER_NO_NAME;
+        return `${replySenderNickname} replied to ${parentSenderNickname}`;
       },
       MESSAGE_UNAVAILABLE: 'Message unavailable',
 
@@ -280,6 +302,7 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
       CHANNEL_MESSAGE_SAVE: 'Save',
       CHANNEL_MESSAGE_DELETE: 'Delete',
       CHANNEL_MESSAGE_REPLY: 'Reply',
+      CHANNEL_MESSAGE_THREAD: 'Reply in thread',
       CHANNEL_MESSAGE_DELETE_CONFIRM_TITLE: 'Delete message?',
       CHANNEL_MESSAGE_DELETE_CONFIRM_OK: 'Delete',
       CHANNEL_MESSAGE_DELETE_CONFIRM_CANCEL: 'Cancel',
@@ -293,6 +316,8 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
       CHANNEL_INPUT_PLACEHOLDER_DISABLED: 'Chat not available in this channel.',
       CHANNEL_INPUT_PLACEHOLDER_MUTED: "You're muted by the operator.",
       CHANNEL_INPUT_PLACEHOLDER_REPLY: 'Reply to message',
+      CHANNEL_INPUT_PLACEHOLDER_REPLY_IN_THREAD: 'Reply in thread',
+      CHANNEL_INPUT_PLACEHOLDER_REPLY_TO_THREAD: 'Reply to thread',
       CHANNEL_INPUT_EDIT_OK: 'Save',
       CHANNEL_INPUT_EDIT_CANCEL: 'Cancel',
       CHANNEL_INPUT_REPLY_PREVIEW_TITLE: (user) => `Reply to ${user.nickname || USER_NO_NAME}`,
@@ -371,6 +396,10 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
       UNKNOWN_ERROR: 'Something went wrong.',
       GET_CHANNEL_ERROR: "Couldn't retrieve channel.",
       FIND_PARENT_MSG_ERROR: "Couldn't find the original message for this reply.",
+      THREAD_PARENT_MESSAGE_DELETED_ERROR: "The thread doesn't exist because the parent message was deleted.",
+      FILE_UPLOAD_SIZE_LIMIT_EXCEEDED_ERROR: (uploadSizeLimit: string) => {
+        return `The maximum size per file is ${uploadSizeLimit}.`;
+      },
       ...overrides?.TOAST,
     },
     PROFILE_CARD: {

package/src/version.ts

@@ -1,2 +1,2 @@
-const VERSION = '3.5.3';
+const VERSION = '3.6.0';
 export default VERSION;