stream-chat-react-native-core 5.30.1-beta.1 → 5.31.0

package/src/components/MessageInput/MessageInput.tsx

@@ -1,11 +1,5 @@
 import React, { useEffect, useMemo, useState } from 'react';
-import {
-  Alert,
-  NativeSyntheticEvent,
-  StyleSheet,
-  TextInputFocusEventData,
-  View,
-} from 'react-native';
+import { NativeSyntheticEvent, StyleSheet, TextInputFocusEventData, View } from 'react-native';
 
 import {
   GestureEvent,
@@ -231,7 +225,6 @@ const MessageInputWithContext = <
   } = props;
 
   const [height, setHeight] = useState(0);
-  const { t } = useTranslationContext();
 
   const {
     theme: {
@@ -323,9 +316,6 @@ const MessageInputWithContext = <
     }
   }, [imagesForInput]);
 
-  const MEGA_BYTES_TO_BYTES = 1024 * 1024;
-  const MAX_FILE_SIZE_TO_UPLOAD_IN_MB = 100;
-
   const uploadImagesHandler = () => {
     const imageToUpload = selectedImages.find((selectedImage) => {
       const uploadedImage = imageUploads.find(
@@ -334,23 +324,8 @@ const MessageInputWithContext = <
       );
       return !uploadedImage;
     });
-    // Check if the file size of the image exceeds the threshold of 100MB
-    if (
-      imageToUpload &&
-      Number(imageToUpload.size) / MEGA_BYTES_TO_BYTES > MAX_FILE_SIZE_TO_UPLOAD_IN_MB
-    ) {
-      Alert.alert(
-        t(
-          `Maximum file size upload limit reached. Please upload a file below {{MAX_FILE_SIZE_TO_UPLOAD_IN_MB}} MB.`,
-          { MAX_FILE_SIZE_TO_UPLOAD_IN_MB },
-        ),
-      );
-      setSelectedImages(
-        selectedImages.filter((selectedImage) => selectedImage.uri !== imageToUpload.uri),
-      );
-    } else {
-      if (imageToUpload) uploadNewImage(imageToUpload);
-    }
+
+    if (imageToUpload) uploadNewImage(imageToUpload);
   };
 
   const removeImagesHandler = () => {
@@ -386,23 +361,7 @@ const MessageInputWithContext = <
         );
         return !uploadedFile;
       });
-      // Check if the file size exceeds the threshold of 100MB
-      if (
-        fileToUpload &&
-        Number(fileToUpload.size) / MEGA_BYTES_TO_BYTES > MAX_FILE_SIZE_TO_UPLOAD_IN_MB
-      ) {
-        Alert.alert(
-          t(
-            `Maximum file size upload limit reached. Please upload a file below {{MAX_FILE_SIZE_TO_UPLOAD_IN_MB}} MB.`,
-            { MAX_FILE_SIZE_TO_UPLOAD_IN_MB },
-          ),
-        );
-        setSelectedFiles(
-          selectedFiles.filter((selectedFile) => selectedFile.uri !== fileToUpload.uri),
-        );
-      } else {
-        if (fileToUpload) uploadNewFile(fileToUpload);
-      }
+      if (fileToUpload) uploadNewFile(fileToUpload);
     } else {
       /** User de-selected a video in bottom sheet attachment picker */
       const filesToRemove = fileUploads.filter(

package/src/contexts/messageInputContext/MessageInputContext.tsx

@@ -21,6 +21,8 @@ import {
 import { useCreateMessageInputContext } from './hooks/useCreateMessageInputContext';
 import { useMessageDetailsForState } from './hooks/useMessageDetailsForState';
 
+import { isUploadAllowed, MAX_FILE_SIZE_TO_UPLOAD, prettifyFileSize } from './utils/utils';
+
 import { AudioAttachmentProps } from '../../components/Attachment/AudioAttachment';
 import { parseLinksFromText } from '../../components/Message/MessageSimple/utils/parseLinks';
 import type { AttachButtonProps } from '../../components/MessageInput/AttachButton';
@@ -483,34 +485,36 @@ export const MessageInputProvider = <
 }: PropsWithChildren<{
   value: InputMessageInputContextValue<StreamChatGenerics>;
 }>) => {
-  const { closePicker, openPicker, selectedPicker, setSelectedPicker } =
-    useAttachmentPickerContext();
+  const {
+    closePicker,
+    openPicker,
+    selectedFiles,
+    selectedImages,
+    selectedPicker,
+    setSelectedFiles,
+    setSelectedImages,
+    setSelectedPicker,
+  } = useAttachmentPickerContext();
   const { appSettings, client, enableOfflineSupport } = useChatContext<StreamChatGenerics>();
   const { removeMessage } = useMessagesContext();
 
   const getFileUploadConfig = () => {
     const fileConfig = appSettings?.app?.file_upload_config;
-    if (fileConfig !== null || fileConfig !== undefined) {
+    if (fileConfig !== undefined) {
       return fileConfig;
     } else {
       return {};
     }
   };
 
-  const blockedFileExtensionTypes = getFileUploadConfig()?.blocked_file_extensions;
-  const blockedFileMimeTypes = getFileUploadConfig()?.blocked_mime_types;
-
   const getImageUploadConfig = () => {
     const imageConfig = appSettings?.app?.image_upload_config;
-    if (imageConfig !== null || imageConfig !== undefined) {
+    if (imageConfig !== undefined) {
       return imageConfig;
     }
     return {};
   };
 
-  const blockedImageExtensionTypes = getImageUploadConfig()?.blocked_file_extensions;
-  const blockedImageMimeTypes = getImageUploadConfig()?.blocked_mime_types;
-
   const channelCapabities = useOwnCapabilitiesContext();
 
   const { channel, giphyEnabled, uploadAbortControllerRef } =
@@ -663,30 +667,17 @@ export const MessageInputProvider = <
       maxNumberOfFiles: value.maxNumberOfFiles - numberOfUploads,
     });
 
-    const MEGA_BYTES_TO_BYTES = 1024 * 1024;
-    const MAX_FILE_SIZE_TO_UPLOAD_IN_MB = 100;
-
     if (!result.cancelled && result.assets) {
-      const totalFileSize = result.assets.reduce((acc, asset) => acc + Number(asset.size), 0);
-      if (totalFileSize / MEGA_BYTES_TO_BYTES > MAX_FILE_SIZE_TO_UPLOAD_IN_MB) {
-        Alert.alert(
-          t(
-            `Maximum file size upload limit reached. Please upload a file below {{MAX_FILE_SIZE_TO_UPLOAD_IN_MB}} MB.`,
-            { MAX_FILE_SIZE_TO_UPLOAD_IN_MB },
-          ),
-        );
-      } else {
-        result.assets.forEach((asset) => {
-          /**
-           * TODO: The current tight coupling of images to the image
-           * picker does not allow images picked from the file picker
-           * to be rendered in a preview via the uploadNewImage call.
-           * This should be updated alongside allowing image a file
-           * uploads together.
-           */
-          uploadNewFile(asset);
-        });
-      }
+      result.assets.forEach((asset) => {
+        /**
+         * TODO: The current tight coupling of images to the image
+         * picker does not allow images picked from the file picker
+         * to be rendered in a preview via the uploadNewImage call.
+         * This should be updated alongside allowing image a file
+         * uploads together.
+         */
+        uploadNewFile(asset);
+      });
     }
   };
 
@@ -1191,18 +1182,25 @@ export const MessageInputProvider = <
 
   const uploadNewFile = async (file: File) => {
     const id: string = generateRandomId();
+    const fileConfig = getFileUploadConfig();
+    const { size_limit } = fileConfig;
 
-    const isBlockedFileExtension: boolean | undefined = blockedFileExtensionTypes?.some(
-      (fileExtensionType: string) => file.name?.includes(fileExtensionType),
-    );
-    const isBlockedFileMimeType: boolean | undefined = blockedFileMimeTypes?.some(
-      (mimeType: string) => file.name?.includes(mimeType),
-    );
+    const isAllowed = isUploadAllowed({ config: fileConfig, file });
+
+    const sizeLimit = size_limit || MAX_FILE_SIZE_TO_UPLOAD;
+
+    if (file.size && file.size > sizeLimit) {
+      Alert.alert(
+        t('File is too large: {{ size }}, maximum upload size is {{ limit }}', {
+          limit: prettifyFileSize(sizeLimit),
+          size: prettifyFileSize(file.size),
+        }),
+      );
+      setSelectedFiles(selectedFiles.filter((selectedFile) => selectedFile.uri !== file.uri));
+      return;
+    }
 
-    const fileState =
-      isBlockedFileExtension || isBlockedFileMimeType
-        ? FileState.NOT_SUPPORTED
-        : FileState.UPLOADING;
+    const fileState = isAllowed ? FileState.UPLOADING : FileState.NOT_SUPPORTED;
 
     // If file type is explicitly provided while upload we use it, else we derive the file type.
     const fileType = file.type || file.mimeType?.split('/')[0];
@@ -1220,26 +1218,33 @@ export const MessageInputProvider = <
       setNumberOfUploads((prevNumberOfUploads) => prevNumberOfUploads + 1),
     ]);
 
-    if (!isBlockedFileExtension) {
+    if (isAllowed) {
       uploadFile({ newFile });
     }
   };
 
   const uploadNewImage = async (image: Partial<Asset>) => {
     const id = generateRandomId();
+    const imageUploadConfig = getImageUploadConfig();
 
-    const isBlockedImageMimeType = blockedImageMimeTypes?.some((mimeType: string) =>
-      image.uri?.includes(mimeType),
-    );
+    const { size_limit } = imageUploadConfig;
 
-    const isBlockedImageExtension = blockedImageExtensionTypes?.some((imageExtensionType: string) =>
-      image.uri?.includes(imageExtensionType),
-    );
+    const isAllowed = isUploadAllowed({ config: imageUploadConfig, file: image });
+
+    const sizeLimit = size_limit || MAX_FILE_SIZE_TO_UPLOAD;
+
+    if (image.size && image?.size > sizeLimit) {
+      Alert.alert(
+        t('File is too large: {{ size }}, maximum upload size is {{ limit }}', {
+          limit: prettifyFileSize(sizeLimit),
+          size: prettifyFileSize(image.size),
+        }),
+      );
+      setSelectedImages(selectedImages.filter((selectedImage) => selectedImage.uri !== image.uri));
+      return;
+    }
 
-    const imageState =
-      isBlockedImageExtension || isBlockedImageMimeType
-        ? FileState.NOT_SUPPORTED
-        : FileState.UPLOADING;
+    const imageState = isAllowed ? FileState.UPLOADING : FileState.NOT_SUPPORTED;
 
     const newImage: ImageUpload = {
       file: image,
@@ -1255,7 +1260,7 @@ export const MessageInputProvider = <
       setNumberOfUploads((prevNumberOfUploads) => prevNumberOfUploads + 1),
     ]);
 
-    if (!isBlockedImageExtension) {
+    if (isAllowed) {
       uploadImage({ newImage });
     }
   };

package/src/contexts/messageInputContext/__tests__/MessageInputContext.test.tsx

@@ -118,12 +118,21 @@ describe('MessageInputContext', () => {
     act(() => {
       result.current.uploadNewImage(
         generateImageAttachment({
+          name: 'dummy.png',
           uri: 'https://www.bastiaanmulder.nl/wp-content/uploads/2013/11/dummy-image-square.png',
         }),
       );
     });
 
     expect(result.current.imageUploads[0].state).toBe(FileState.NOT_SUPPORTED);
+
+    act(() => {
+      result.current.uploadNewFile({
+        name: 'dummy.mp3',
+        uri: 'https://www.bastiaanmulder.nl/wp-content/uploads/2013/11/dummy.mp3',
+      });
+    });
+    expect(result.current.imageUploads[0].state).toBe(FileState.NOT_SUPPORTED);
   });
 
   it('onSelectItem works', () => {

package/src/contexts/messageInputContext/__tests__/pickFile.test.tsx

@@ -9,8 +9,9 @@ import { generateFileAttachment } from '../../../mock-builders/generator/attachm
 import { generateMessage } from '../../../mock-builders/generator/message';
 import { generateUser } from '../../../mock-builders/generator/user';
 import * as NativeUtils from '../../../native';
-
 import type { DefaultStreamChatGenerics } from '../../../types/types';
+import * as AttachmentPickerContext from '../../attachmentPickerContext/AttachmentPickerContext';
+
 import {
   InputMessageInputContextValue,
   MessageInputContextValue,
@@ -51,13 +52,17 @@ describe("MessageInputContext's pickFile", () => {
       cancelled: false,
     }),
   );
+  jest.spyOn(AttachmentPickerContext, 'useAttachmentPickerContext').mockImplementation(() => ({
+    selectedFiles: [],
+    setSelectedFiles: jest.fn(),
+  }));
 
   const initialProps = {
     editing: message,
     maxNumberOfFiles: 2,
   };
 
-  it.each([[3, 1]])(
+  it.each([[3, 2]])(
     'run pickFile when numberOfUploads is %d and alert is triggered %d number of times',
     async (numberOfUploads, numberOfTimesCalled) => {
       const { rerender, result } = renderHook(() => useMessageInputContext(), {
@@ -103,6 +108,6 @@ describe("MessageInputContext's pickFile", () => {
       result.current.pickFile();
     });
 
-    expect(Alert.alert).toHaveBeenCalledTimes(1);
+    expect(Alert.alert).toHaveBeenCalledTimes(2);
   });
 });

package/src/contexts/messageInputContext/utils/utils.ts

@@ -0,0 +1,86 @@
+import { lookup } from 'mime-types';
+import type { FileUploadConfig } from 'stream-chat';
+
+import { Asset, File } from '../../../types/types';
+
+export const MAX_FILE_SIZE_TO_UPLOAD = 100 * 1024 * 1024; // 100 MB
+
+type CheckUploadPermissionsParams = {
+  config: FileUploadConfig;
+  file: File | Partial<Asset>;
+};
+
+/**
+ * This utility function checks if the file upload is allowed based on the file upload config.
+ * @param Object File upload config and file to check
+ * @returns
+ */
+export const isUploadAllowed = ({ config, file }: CheckUploadPermissionsParams) => {
+  const {
+    allowed_file_extensions,
+    allowed_mime_types,
+    blocked_file_extensions,
+    blocked_mime_types,
+  } = config;
+
+  if (allowed_file_extensions?.length) {
+    const allowed = allowed_file_extensions.some((fileExtension: string) =>
+      file.name?.toLowerCase().endsWith(fileExtension.toLowerCase()),
+    );
+
+    if (!allowed) {
+      return false;
+    }
+  }
+
+  if (blocked_file_extensions?.length) {
+    const blocked = blocked_file_extensions.some((fileExtension: string) =>
+      file.name?.toLowerCase().endsWith(fileExtension.toLowerCase()),
+    );
+
+    if (blocked) {
+      return false;
+    }
+  }
+
+  if (allowed_mime_types?.length) {
+    if (file.name) {
+      const fileMimeType = lookup(file.name) as string;
+      const allowed = allowed_mime_types.some(
+        (mimeType: string) => fileMimeType.toLowerCase() === mimeType.toLowerCase(),
+      );
+
+      if (!allowed) {
+        return false;
+      }
+    }
+  }
+
+  if (blocked_mime_types?.length) {
+    if (file.name) {
+      const fileMimeType = lookup(file.name) as string;
+      const blocked = blocked_mime_types.some(
+        (mimeType: string) => fileMimeType.toLowerCase() === mimeType.toLowerCase(),
+      );
+
+      if (blocked) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+};
+
+/**
+ * This utility function prettifies the file size.
+ * @param bytes The bytes of the file
+ * @param precision The precision to which the file size should be rounded
+ * @returns
+ */
+export function prettifyFileSize(bytes: number, precision = 3) {
+  const units = ['B', 'kB', 'MB', 'GB'];
+  const exponent = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
+  const mantissa = bytes / 1024 ** exponent;
+  return `${mantissa.toPrecision(precision)} ${units[exponent]}`;
+}

package/src/i18n/en.json

@@ -24,10 +24,11 @@
   "Error loading channel list...": "Error loading channel list...",
   "Error loading messages for this channel...": "Error loading messages for this channel...",
   "Error while loading, please reload/refresh": "Error while loading, please reload/refresh",
+  "File is too large: {{ size }}, maximum upload size is {{ limit }}": "File is too large: {{ size }}, maximum upload size is {{ limit }}",
   "File type not supported": "File type not supported",
   "Flag": "Flag",
   "Flag Message": "Flag Message",
-  "Flag action failed either due to a network issue or the message is already flagged": "Flag action failed either due to a network issue or the message is already flagged",
+  "Flag action failed either due to a network issue or the message is already flagged": "Flag action failed either due to a network issue or the message is already flagged.",
   "Hold to start recording.": "Hold to start recording.",
   "How about sending your first message to a friend?": "How about sending your first message to a friend?",
   "Instant Commands": "Instant Commands",
@@ -36,7 +37,6 @@
   "Loading channels...": "Loading channels...",
   "Loading messages...": "Loading messages...",
   "Loading...": "Loading...",
-  "Maximum file size upload limit reached. Please upload a file below {{MAX_FILE_SIZE_TO_UPLOAD_IN_MB}} MB.": "Maximum file size upload limit reached. Please upload a file below {{MAX_FILE_SIZE_TO_UPLOAD_IN_MB}} MB.",
   "Message Reactions": "Message Reactions",
   "Message deleted": "Message deleted",
   "Message flagged": "Message flagged",

package/src/i18n/es.json

@@ -1,83 +1,83 @@
 {
-  "1 Reply": "",
-  "1 Thread Reply": "",
-  "Allow access to your Gallery": "",
-  "Allow camera access in device settings": "",
-  "Also send to channel": "",
-  "Are you sure you want to permanently delete this message?": "",
+  "1 Reply": "1 respuesta",
+  "1 Thread Reply": "1 respuesta de hilo",
+  "Allow access to your Gallery": "Permitir acceso a tu galería",
+  "Allow camera access in device settings": "Permitir el acceso a la cámara en la configuración del dispositivo",
+  "Also send to channel": "También enviar al canal",
+  "Are you sure you want to permanently delete this message?": "¿Estás seguro de que deseas eliminar permanentemente este mensaje?",
   "Are you sure?": "¿Estás seguro?",
-  "Block User": "",
-  "Cancel": "",
-  "Cannot Flag Message": "",
+  "Block User": "Bloquear usuario",
+  "Cancel": "Cancelar",
+  "Cannot Flag Message": "No se puede reportar el mensaje",
   "Consider how your comment might make others feel and be sure to follow our Community Guidelines": "Considera cómo tu comentario podría hacer sentir a los demás y asegúrate de seguir nuestras Normas de la Comunidad",
-  "Copy Message": "",
-  "Delete": "",
-  "Delete Message": "",
-  "Device camera is used to take photos or videos.": "",
-  "Do you want to send a copy of this message to a moderator for further investigation?": "",
-  "Edit Message": "",
-  "Edited": "",
-  "Editing Message": "",
-  "Emoji matching": "",
-  "Empty message...": "",
-  "Error loading": "",
-  "Error loading channel list...": "",
-  "Error loading messages for this channel...": "",
-  "Error while loading, please reload/refresh": "",
-  "File type not supported": "",
-  "Flag": "",
-  "Flag Message": "",
-  "Flag action failed either due to a network issue or the message is already flagged": "",
+  "Copy Message": "Copiar mensaje",
+  "Delete": "Eliminar",
+  "Delete Message": "Eliminar mensaje",
+  "Device camera is used to take photos or videos.": "La cámara del dispositivo se utiliza para tomar fotografías o vídeos.",
+  "Do you want to send a copy of this message to a moderator for further investigation?": "¿Deseas enviar una copia de este mensaje a un moderador para una investigación adicional?",
+  "Edit Message": "Editar mensaje",
+  "Edited": "Editado",
+  "Editing Message": "Editando mensaje",
+  "Emoji matching": "Coincidencia de emoji",
+  "Empty message...": "Mensaje vacío...",
+  "Error loading": "Error al cargar",
+  "Error loading channel list...": "Error al cargar la lista de canales...",
+  "Error loading messages for this channel...": "Error al cargar los mensajes de este canal...",
+  "Error while loading, please reload/refresh": "Error al cargar, por favor recarga/actualiza",
+  "File is too large: {{ size }}, maximum upload size is {{ limit }}": "El archivo es demasiado grande: {{ size }}, el tamaño máximo de carga es de {{ limit }}",
+  "File type not supported": "Tipo de archivo no admitido",
+  "Flag": "Reportar",
+  "Flag Message": "Reportar mensaje",
+  "Flag action failed either due to a network issue or the message is already flagged": "El reporte falló debido a un problema de red o el mensaje ya fue reportado.",
   "Hold to start recording.": "Mantén presionado para comenzar a grabar.",
-  "How about sending your first message to a friend?": "",
-  "Instant Commands": "",
-  "Let's start chatting!": "",
-  "Links are disabled": "",
-  "Loading channels...": "",
-  "Loading messages...": "",
-  "Loading...": "",
-  "Maximum file size upload limit reached. Please upload a file below {{MAX_FILE_SIZE_TO_UPLOAD_IN_MB}} MB.": "",
-  "Message Reactions": "",
+  "How about sending your first message to a friend?": "¿Qué tal enviar tu primer mensaje a un amigo?",
+  "Instant Commands": "Comandos instantáneos",
+  "Let's start chatting!": "¡Empecemos a charlar!",
+  "Links are disabled": "Los enlaces están desactivados",
+  "Loading channels...": "Cargando canales...",
+  "Loading messages...": "Cargando mensajes...",
+  "Loading...": "Cargando...",
+  "Message Reactions": "Reacciones al mensaje",
   "Message deleted": "Mensaje eliminado",
-  "Message flagged": "",
-  "Mute User": "",
-  "No chats here yet…": "",
+  "Message flagged": "Mensaje reportado",
+  "Mute User": "Silenciar usuario",
+  "No chats here yet…": "No hay chats aquí todavía...",
   "Not supported": "No admitido",
-  "Nothing yet...": "",
-  "Ok": "",
-  "Only visible to you": "",
-  "Open Settings": "",
-  "Photo": "",
-  "Photos and Videos": "",
-  "Pin to Conversation": "",
-  "Pinned by": "",
+  "Nothing yet...": "Aún no hay nada...",
+  "Ok": "Aceptar",
+  "Only visible to you": "Solo visible para ti",
+  "Open Settings": "Configuración abierta",
+  "Photo": "Foto",
+  "Photos and Videos": "Fotos y videos",
+  "Pin to Conversation": "Fijar a la conversación",
+  "Pinned by": "Fijado por",
   "Please allow Audio permissions in settings.": "Por favor, permita los permisos de audio en la configuración.",
-  "Please enable access to your photos and videos so you can share them.": "",
-  "Please select a channel first": "",
+  "Please enable access to your photos and videos so you can share them.": "Por favor, habilita el acceso a tus fotos y videos para poder compartirlos.",
+  "Please select a channel first": "Por favor, selecciona primero un canal",
   "Reconnecting...": "Reconectando...",
-  "Reply": "",
-  "Reply to Message": "",
-  "Resend": "",
-  "Search GIFs": "",
-  "Select More Photos": "",
+  "Reply": "Responder",
+  "Reply to Message": "Responder al mensaje",
+  "Resend": "Reenviar",
+  "Search GIFs": "Buscar GIFs",
+  "Select More Photos": "Seleccionar más fotos",
   "Send Anyway": "Enviar de todos modos",
-  "Send a message": "",
-  "Sending links is not allowed in this conversation": "",
-  "Slow mode ON": "",
-  "The message has been reported to a moderator.": "",
-  "Thread Reply": "",
-  "Unblock User": "",
-  "Unknown User": "",
-  "Unmute User": "",
-  "Unpin from Conversation": "",
-  "Unread Messages": "",
-  "Video": "",
+  "Send a message": "Enviar un mensaje",
+  "Sending links is not allowed in this conversation": "No está permitido enviar enlaces en esta conversación",
+  "Slow mode ON": "Modo lento ACTIVADO",
+  "The message has been reported to a moderator.": "El mensaje ha sido reportado a un moderador.",
+  "Thread Reply": "Respuesta de hilo",
+  "Unblock User": "Desbloquear usuario",
+  "Unknown User": "Usuario desconocido",
+  "Unmute User": "Activar sonido del usuario",
+  "Unpin from Conversation": "Desmarcar de la conversación",
+  "Unread Messages": "Mensajes no leídos",
+  "Video": "Video",
   "You": "Tú",
-  "You can't send messages in this channel": "",
-  "{{ firstUser }} and {{ nonSelfUserLength }} more are typing": "",
-  "{{ index }} of {{ photoLength }}": "",
-  "{{ replyCount }} Replies": "",
-  "{{ replyCount }} Thread Replies": "",
-  "{{ user }} is typing": "",
-  "🏙 Attachment...": ""
+  "You can't send messages in this channel": "No puedes enviar mensajes en este canal",
+  "{{ firstUser }} and {{ nonSelfUserLength }} more are typing": "{{ firstUser }} y {{ nonSelfUserLength }} más están escribiendo",
+  "{{ index }} of {{ photoLength }}": "{{ index }} de {{ photoLength }}",
+  "{{ replyCount }} Replies": "{{ replyCount }} Respuestas",
+  "{{ replyCount }} Thread Replies": "{{ replyCount }} respuestas de hilo",
+  "{{ user }} is typing": "{{ user }} está escribiendo",
+  "🏙 Attachment...": "🏙 Adjunto..."
 }