Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

// app/page.tsx 'use client'; import { useState, useEffect, useRef } from 'react';…

  1. User

    // app/page.tsx 'use client';

    import { useState, useEffect, useRef } from 'react'; import { Avatar, AvatarFallback, AvatarImage } from '@/components/ui/avatar'; import { Button } from '@/components/ui/button'; import { Card } from '@/components/ui/card'; import { Dialog, DialogContent, DialogHeader, DialogTitle, } from '@/components/ui/dialog'; import { Input } from '@/components/ui/input'; import { Label } from '@/components/ui/label'; import { Separator } from '@/components/ui/separator'; import { Switch } from '@/components/ui/switch'; import { Hash, MessageCircle, Send, Settings, Users, Image as ImageIcon, Plus, Edit, Trash, Menu, } from 'lucide-react'; import EmojiPicker, { EmojiClickData } from 'emoji-picker-react'; import Image from 'next/image'; import { motion, AnimatePresence } from 'framer-motion';

    const defaultAvatarUrl = 'https://via.placeholder.com/40';

    // Array de emojis para reações const reactionEmojis = ['👍', '❤️', '😂', '😮', '😢', '👎'];

    type Config = { notifications: boolean; fontSize: number; username: string; avatarUrl: string; fontFamily: string; };

    type User = { username: string; avatarUrl: string; };

    type Reaction = { emoji: string; count: number; users: string[]; };

    type FileData = { name: string; type: string; data: string; };

    type Message = { id: string; content: string; timestamp: Date; user: User; file?: FileData; reactions: Reaction[]; };

    type Channel = { id: string; name: string; messages: Message[]; };

    const initialConfig: Config = { notifications: true, fontSize: 16, username: 'Anonymous', avatarUrl: '', fontFamily: 'sans-serif', };

    const initialChannels: Channel[] = [ { id: '1', name: 'general', messages: [] }, { id: '2', name: 'random', messages: [] }, { id: '3', name: 'announcements', messages: [] }, ];

    const initialUsers: User[] = [ { username: 'Alice', avatarUrl: defaultAvatarUrl }, { username: 'Bob', avatarUrl: defaultAvatarUrl }, // Adicione mais usuários conforme necessário ];

    export default function App() { const [config, setConfig] = useState(initialConfig); const [isSettingsOpen, setIsSettingsOpen] = useState(false); const [channels, setChannels] = useState<Channel[]>(initialChannels); const [activeChannelId, setActiveChannelId] = useState( channels[0].id ); const activeChannel = channels.find((channel) => channel.id === activeChannelId) || channels[0]; const [messageInput, setMessageInput] = useState(''); const [selectedFile, setSelectedFile] = useState<File | null>(null); const messagesEndRef = useRef(null); const fileInputRef = useRef(null); const [showEmojiPicker, setShowEmojiPicker] = useState(false); const [showReactionPicker, setShowReactionPicker] = useState<string | null>( null ); const [editingMessageId, setEditingMessageId] = useState<string | null>(null); const [users, setUsers] = useState<User[]>(initialUsers); const [mentionSuggestions, setMentionSuggestions] = useState<User[]>([]); const [caretPosition, setCaretPosition] = useState<number | null>(null); const [previewImage, setPreviewImage] = useState<string | null>(null); const [isSidebarOpen, setIsSidebarOpen] = useState(true);

    const handleConfigChange = ( key: keyof Config, value: boolean | number | string ) => { setConfig((prevConfig) => ({ ...prevConfig, [key]: value })); };

    const handleChannelSelect = (channel: Channel) => { setActiveChannelId(channel.id); };

    const handleSendMessage = async () => { if (messageInput.trim() === '' && !selectedFile) return;

    let content = messageInput;
    let fileData: FileData | undefined;
    
    if (selectedFile) {
      const reader = new FileReader();
      reader.readAsDataURL(selectedFile);
      await new Promise((resolve) => {
        reader.onload = () => {
          fileData = {
            name: selectedFile!.name,
            type: selectedFile!.type,
            data: reader.result as string,
          };
          resolve(null);
        };
      });
    }
    
    if (editingMessageId) {
      // Atualizar mensagem existente
      setChannels((prevChannels) =>
        prevChannels.map((channel) =>
          channel.id === activeChannelId
            ? {
                ...channel,
                messages: channel.messages.map((message) =>
                  message.id === editingMessageId
                    ? { ...message, content, file: fileData }
                    : message
                ),
              }
            : channel
        )
      );
      setEditingMessageId(null);
    } else {
      const newMessage: Message = {
        id: Date.now().toString(),
        content,
        timestamp: new Date(),
        user: {
          username: config.username,
          avatarUrl: config.avatarUrl || defaultAvatarUrl,
        },
        file: fileData,
        reactions: [],
      };
    
      setChannels((prevChannels) =>
        prevChannels.map((channel) =>
          channel.id === activeChannelId
            ? { ...channel, messages: [...channel.messages, newMessage] }
            : channel
        )
      );
    }
    
    setMessageInput('');
    setSelectedFile(null);
    setPreviewImage(null);
    setShowEmojiPicker(false);
    setMentionSuggestions([]);
    

    };

    const handleFileUpload = (event: React.ChangeEvent) => { const file = event.target.files?.[0]; if (file) { setSelectedFile(file); const reader = new FileReader(); reader.readAsDataURL(file); reader.onload = () => { setPreviewImage(reader.result as string); }; } };

    const handleAddReaction = (messageId: string, emoji: string) => { setChannels((prevChannels) => prevChannels.map((channel) => channel.id === activeChannelId ? { ...channel, messages: channel.messages.map((message) => { if (message.id === messageId) { const existingReactionIndex = message.reactions.findIndex( (r) => r.emoji === emoji );

                  if (existingReactionIndex > -1) {
                    const existingReaction = message.reactions[existingReactionIndex];
                    if (existingReaction.users.includes(config.username)) {
                      // Remove a reação se o usuário já reagiu
                      const updatedReaction = {
                        ...existingReaction,
                        count: existingReaction.count - 1,
                        users: existingReaction.users.filter((u) => u !== config.username),
                      };
                      
                      if (updatedReaction.count === 0) {
                        // Remove a reação se não houver mais usuários
                        return {
                          ...message,
                          reactions: message.reactions.filter((_, index) => index !== existingReactionIndex),
                        };
                      } else {
                        // Atualiza a reação existente
                        return {
                          ...message,
                          reactions: message.reactions.map((r, index) =>
                            index === existingReactionIndex ? updatedReaction : r
                          ),
                        };
                      }
                    } else {
                      // Adiciona o usuário à reação existente
                      return {
                        ...message,
                        reactions: message.reactions.map((r, index) =>
                          index === existingReactionIndex
                            ? {
                                ...r,
                                count: r.count + 1,
                                users: [...r.users, config.username],
                              }
                            : r
                        ),
                      };
                    }
                  } else {
                    // Adiciona uma nova reação
                    return {
                      ...message,
                      reactions: [
                        ...message.reactions,
                        { emoji, count: 1, users: [config.username] },
                      ],
                    };
                  }
                }
                return message;
              }),
            }
          : channel
      )
    );
    setShowReactionPicker(null);
    

    };

    const handleEditMessage = (messageId: string) => { const messageToEdit = activeChannel.messages.find( (m) => m.id === messageId ); if (messageToEdit) { setMessageInput(messageToEdit.content); setEditingMessageId(messageId); if (messageToEdit.file) { setSelectedFile(null); setPreviewImage(messageToEdit.file.data); } else { setSelectedFile(null); setPreviewImage(null); } } };

    const handleDeleteMessage = (messageId: string) => { setChannels((prevChannels) => prevChannels.map((channel) => channel.id === activeChannelId ? { ...channel, messages: channel.messages.filter( (message) => message.id !== messageId ), } : channel ) ); };

    useEffect(() => { messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' }); }, [activeChannel.messages]);

    const handleEmojiSelect = (emojiData: EmojiClickData) => { setMessageInput((prev) => prev + emojiData.emoji); setShowEmojiPicker(false); };

    const handleInputChange = (e: React.ChangeEvent) => { const value = e.target.value; setMessageInput(value);

    const caret = e.target.selectionStart || 0;
    setCaretPosition(caret);
    
    const lastAt = value.lastIndexOf('@', caret - 1);
    if (lastAt >= 0) {
      const query = value.substring(lastAt + 1, caret).toLowerCase();
      if (query.length > 0) {
        const suggestions = users.filter((user) =>
          user.username.toLowerCase().startsWith(query)
        );
        setMentionSuggestions(suggestions);
      } else {
        setMentionSuggestions([]);
      }
    } else {
      setMentionSuggestions([]);
    }
    

    };

    const handleSuggestionClick = (username: string) => { if (caretPosition !== null) { const lastAt = messageInput.lastIndexOf('@', caretPosition - 1); const beforeAt = messageInput.substring(0, lastAt + 1); const afterAt = messageInput.substring(caretPosition); setMessageInput(beforeAt + username + ' ' + afterAt); setMentionSuggestions([]); } };

    const SettingsModal = () => ( Configurações do Chat Notificações <Switch id="notifications" checked={config.notifications} onCheckedChange={(checked) => handleConfigChange('notifications', checked) } /> Tamanho da Fonte <Input id="fontSize" type="number" value={config.fontSize} onChange={(e) => handleConfigChange('fontSize', parseInt(e.target.value, 10)) } className="w-20" /> Nome de Usuário <Input id="username" value={config.username} onChange={(e) => handleConfigChange('username', e.target.value)} className="w-48" /> URL do Avatar <Input id="avatarUrl" value={config.avatarUrl} onChange={(e) => handleConfigChange('avatarUrl', e.target.value)} className="w-48" placeholder="https://example.com/avatar.png" /> Fonte <select id="fontFamily" value={config.fontFamily} onChange={(e) => handleConfigChange('fontFamily', e.target.value)} className="w-48 border rounded-md p-2" > Sans Serif Serif Monospace );

    return ( <div className={flex h-screen bg-background text-foreground} style={{ fontSize: ${config.fontSize}px, fontFamily: config.fontFamily, }} > {/* Sidebar */} {isSidebarOpen && ( Canais {channels.map((channel) => ( <Button key={channel.id} variant={ channel.id === activeChannelId ? 'secondary' : 'ghost' } className="w-full justify-start" onClick={() => handleChannelSelect(channel)} > {channel.name} ))} )}

      {/* Main Content */}
      <div className="flex-1 flex flex-col">
        <header className="bg-card border-b border-border p-4 flex items-center justify-between">
          <div className="flex items-center space-x-2">
            <Button
              variant="ghost"
              className="md:hidden"
              onClick={() => setIsSidebarOpen(!isSidebarOpen)}
            >
              <Menu className="h-6 w-6" />
            </Button>
            <h1 className="text-2xl font-bold">#{activeChannel.name}</h1>
          </div>
          <Button
            variant="ghost"
            className="rounded-full p-2"
            onClick={() => setIsSettingsOpen(true)}
          >
            <Settings className="h-6 w-6 text-muted-foreground" />
          </Button>
        </header>
        <div className="flex-1 p-6 overflow-auto">
          <div className="space-y-4">
            <AnimatePresence>
              {activeChannel.messages.map((message) => (
                <motion.div
                  key={message.id}
                  initial={{ opacity: 0, y: 10 }}
                  animate={{ opacity: 1, y: 0 }}
                  exit={{ opacity: 0, x: -100 }}
                >
                  <Card className="p-4 bg-popover text-popover-foreground relative">
                    <div className="flex items-start space-x-4">
                      <Avatar>
                        <AvatarImage
                          src={message.user.avatarUrl}
                          alt={message.user.username}
                        />
                        <AvatarFallback>
                          {message.user.username.charAt(0).toUpperCase()}
                        </AvatarFallback>
                      </Avatar>
                      <div>
                        <p className="font-semibold">{message.user.username}</p>
                        <p>{message.content}</p>
                        {message.file && (
                          <div className="mt-2">
                            {message.file.type.startsWith('image/') ? (
                              <Image
                                src={message.file.data}
                                alt={message.file.name}
                                width={200}
                                height={200}
                                style={{ objectFit: 'contain' }}
                                unoptimized
                              />
                            ) : (
                              <a
                                href={message.file.data}
                                download={message.file.name}
                                className="text-blue-500 underline"
                              >
                                {message.file.name}
                              </a>
                            )}
                          </div>
                        )}
                        <div className="flex items-center space-x-2 mt-2 relative">
                          {/* Reactions */}
                          {message.reactions.map((reaction) => (
                            <Button
                              key={reaction.emoji}
                              variant="ghost"
                              size="sm"
                              onClick={() =>
                                handleAddReaction(message.id, reaction.emoji)
                              }
                            >
                              {reaction.emoji} {reaction.count}
                            </Button>
                          ))}
                          {/* Reaction Picker */}
                          {showReactionPicker === message.id ? (
                            <div className="flex items-center space-x-2">
                              {reactionEmojis.map((emoji) => (
                                <button
                                  key={emoji}
                                  onClick={() => {
                                    handleAddReaction(message.id, emoji);
                                    setShowReactionPicker(null);
                                  }}
                                  className="text-xl"
                                >
                                  {emoji}
                                </button>
                              ))}
                            </div>
                          ) : (
                            <Button
                              variant="ghost"
                              size="sm"
                              onClick={() => setShowReactionPicker(message.id)}
                            >
                              <Plus className="h-4 w-4" />
                            </Button>
                          )}
                        </div>
                        <p className="text-xs text-muted-foreground mt-2">
                          {message.timestamp.toLocaleString()}
                        </p>
                      </div>
                    </div>
                    {message.user.username === config.username && (
                      <div className="absolute top-2 right-2 flex space-x-2">
                        <Button
                          variant="ghost"
                          size="sm"
                          onClick={() => handleEditMessage(message.id)}
                        >
                          <Edit className="h-4 w-4" />
                        </Button>
                        <Button
                          variant="ghost"
                          size="sm"
                          onClick={() => handleDeleteMessage(message.id)}
                        >
                          <Trash className="h-4 w-4" />
                        </Button>
                      </div>
                    )}
                  </Card>
                </motion.div>
              ))}
            </AnimatePresence>
            <div ref={messagesEndRef} />
          </div>
        </div>
        <div className="p-4 bg-card border-t border-border relative">
          <div className="flex space-x-2">
            <Input
              value={messageInput}
              onChange={handleInputChange}
              placeholder={
                editingMessageId ? 'Editar sua mensagem...' : 'Digite uma mensagem...'
              }
              onKeyPress={(e) => {
                if (e.key === 'Enter' && !e.shiftKey) {
                  e.preventDefault();
                  handleSendMessage();
                }
              }}
              className="flex-1"
            />
            <Button onClick={() => setShowEmojiPicker(!showEmojiPicker)}>
              😊
            </Button>
            {showEmojiPicker && (
              <div className="absolute bottom-16 z-10">
                <EmojiPicker
                  onEmojiClick={handleEmojiSelect}
                />
              </div>
            )}
            <Button onClick={() => fileInputRef.current?.click()}>
              <ImageIcon className="h-4 w-4" />
            </Button>
            <input
              type="file"
              ref={fileInputRef}
              style={{ display: 'none' }}
              onChange={handleFileUpload}
              accept="*/*"
            />
            <Button onClick={handleSendMessage}>
              <Send className="h-4 w-4" />
            </Button>
          </div>
          {mentionSuggestions.length > 0 && (
            <div className="absolute bg-card border border-border mt-1 w-64 max-h-40 overflow-auto z-10">
              {mentionSuggestions.map((user) => (
                <div
                  key={user.username}
                  className="p-2 hover:bg-secondary cursor-pointer"
                  onClick={() => handleSuggestionClick(user.username)}
                >
                  {user.username}
                </div>
              ))}
            </div>
          )}
          {selectedFile && previewImage && (
            <div className="mt-2">
              {selectedFile.type.startsWith('image/') ? (
                <div className="relative w-20 h-20">
                  <Image
                    src={previewImage}
                    alt="Pré-visualização da Imagem"
                    fill
                    style={{ objectFit: 'cover' }}
                    className="rounded-md"
                    unoptimized
                  />
                  <Button
                    variant="destructive"
                    size="sm"
                    className="absolute top-0 right-0"
                    onClick={() => {
                      setSelectedFile(null);
                      setPreviewImage(null);
                    }}
                  >
                    <Trash className="h-4 w-4" />
                  </Button>
                </div>
              ) : (
                <div className="flex items-center space-x-2">
                  <p className="text-sm text-muted-foreground">
                    Arquivo selecionado: {selectedFile.name}
                  </p>
                  <Button
                    variant="destructive"
                    size="sm"
                    onClick={() => {
                      setSelectedFile(null);
                      setPreviewImage(null);
                    }}
                  >
                    <Trash className="h-4 w-4" />
                  </Button>
                </div>
              )}
            </div>
          )}
        </div>
      </div>
      <SettingsModal />
    </div>
    

    ); }

    agr vc pode add mais reações usando emoji-picker-react na hora de add a reação, consegue add se uma mesma pessoa repitir o mesmo emoji muda o contador para 2 3 4 ...

  2. Assistant

    Olá! Entendi que você deseja atualizar o seu aplicativo de chat para permitir que os usuários possam adicionar mais reações usando o emoji-picker-react ao adicionar uma reação, e que quando a mesma pessoa repete o mesmo emoji, o contador aumenta para 2, 3, 4, etc.

    Vou te ajudar a fazer essas modificações passo a passo.

    1. Modificar o Tipo Reaction para Incluir Contagens por Usuário

    Atualmente, o tipo Reaction está definido assim:

    type Reaction = {
      emoji: string;
      count: number;
      users: string[];
    };
    

    Precisamos modificar esse tipo para manter um registro de quantas vezes cada usuário reagiu com um determinado emoji. Isso pode ser feito alterando a estrutura para armazenar contagens por usuário:

    type Reaction = {
      emoji: string;
      userCounts: { [username: string]: number };
    };
    

    Aqui, userCounts é um objeto onde a chave é o nome de usuário e o valor é o número de vezes que o usuário reagiu com aquele emoji.

    2. Atualizar a Função handleAddReaction

    Precisamos modificar a função handleAddReaction para que, quando um usuário adicionar uma reação, ela incremente a contagem, mesmo se o usuário já tiver reagido com aquele emoji anteriormente.

    Aqui está a versão atualizada da função:

    const handleAddReaction = (messageId: string, emoji: string) => {
      setChannels((prevChannels) =>
        prevChannels.map((channel) =>
          channel.id === activeChannelId
            ? {
                ...channel,
                messages: channel.messages.map((message) => {
                  if (message.id === messageId) {
                    const existingReactionIndex = message.reactions.findIndex(
                      (r) => r.emoji === emoji
                    );
    
                    if (existingReactionIndex > -1) {
                      const existingReaction = message.reactions[existingReactionIndex];
                      const userCount = existingReaction.userCounts[config.username] || 0;
    
                      const updatedReaction = {
                        ...existingReaction,
                        userCounts: {
                          ...existingReaction.userCounts,
                          [config.username]: userCount + 1,
                        },
                      };
    
                      const updatedReactions = [
                        ...message.reactions.slice(0, existingReactionIndex),
                        updatedReaction,
                        ...message.reactions.slice(existingReactionIndex + 1),
                      ];
    
                      return {
                        ...message,
                        reactions: updatedReactions,
                      };
                    } else {
                      // Adiciona uma nova reação
                      const newReaction: Reaction = {
                        emoji,
                        userCounts: { [config.username]: 1 },
                      };
    
                      return {
                        ...message,
                        reactions: [...message.reactions, newReaction],
                      };
                    }
                  }
                  return message;
                }),
              }
            : channel
        )
      );
      setShowReactionPicker(null);
    };
    

    Explicação:

    • Verifica se a reação já existe:
      • Se existir, incrementa a contagem do usuário para aquele emoji.
      • Se não existir, adiciona uma nova reação com a contagem inicial de 1 para o usuário atual.
    • Atualiza as reações da mensagem sem mutar o estado diretamente:
      • Cria novas cópias dos objetos para manter a imutabilidade, conforme recomendado no React.

    3. Atualizar a Renderização das Reações

    Como alteramos a estrutura das reações, precisamos também atualizar a forma como renderizamos as reações para exibir a contagem correta.

    Atualize a parte do código que renderiza as reações nas mensagens para calcular a contagem total:

    <div className="flex items-center space-x-2 mt-2 relative">
      {message.reactions.map((reaction) => (
        <Button
          key={reaction.emoji}
          variant="ghost"
          size="sm"
          onClick={() => handleAddReaction(message.id, reaction.emoji)}
        >
          {reaction.emoji}{' '}
          {Object.values(reaction.userCounts).reduce((a, b) => a + b, 0)}
        </Button>
      ))}
      {/* Reaction Picker */}
      {showReactionPicker === message.id ? (
        <div className="absolute z-10">
          <EmojiPicker
            onEmojiClick={(e) => {
              handleAddReaction(message.id, e.emoji);
              setShowReactionPicker(null);
            }}
          />
        </div>
      ) : (
        <Button
          variant="ghost"
          size="sm"
          onClick={() => setShowReactionPicker(message.id)}
        >
          <Plus className="h-4 w-4" />
        </Button>
      )}
    </div>
    

    Explicação:

    • Calcula a contagem total de reações:
      • Usa Object.values(reaction.userCounts).reduce((a, b) => a + b, 0) para somar todas as contagens de usuários.
    • Atualiza o onClick de cada reação:
      • Chama handleAddReaction para incrementar a reação quando clicada.

    4. Substituir o Picker de Reações pelo emoji-picker-react

    Agora, vamos substituir o picker de reações atual pelo EmojiPicker do emoji-picker-react, possibilitando que o usuário escolha qualquer emoji.

    Atualize o código do picker de reações:

    {/* Reaction Picker */}
    {showReactionPicker === message.id && (
      <div className="absolute z-10">
        <EmojiPicker
          onEmojiClick={(e) => {
            handleAddReaction(message.id, e.emoji);
            setShowReactionPicker(null);
          }}
          theme="dark"
        />
      </div>
    )}
    

    Certifique-se de ter importado corretamente o EmojiPicker:

    import EmojiPicker from 'emoji-picker-react';
    

    5. Ajustes de Estilo e Posicionamento

    Como o EmojiPicker é um componente baseado em pop-up, você pode precisar ajustar o posicionamento e o estilo para que ele apareça corretamente próximo à mensagem. Uma sugestão é envolver o picker em um div com position: absolute relativo ao botão que o acionou.

    Exemplo:

    .relative-container {
      position: relative;
    }
    
    .absolute-picker {
      position: absolute;
      top: 100%;
      left: 0;
      z-index: 10;
    }
    

    Aplicado no código:

    <div className="relative-container">
      <Button
        variant="ghost"
        size="sm"
        onClick={() => setShowReactionPicker(message.id)}
      >
        <Plus className="h-4 w-4" />
      </Button>
      {showReactionPicker === message.id && (
        <div className="absolute-picker">
          <EmojiPicker
            onEmojiClick={(e) => {
              handleAddReaction(message.id, e.emoji);
              setShowReactionPicker(null);
            }}
            theme="dark"
          />
        </div>
      )}
    </div>
    

    6. Testar as Modificações

    Após fazer essas alterações, teste o aplicativo para:

    • Verificar se o usuário pode adicionar reações com qualquer emoji.
    • Confirmar que, ao repetir a mesma reação, o contador aumenta (2, 3, 4...).
    • Garantir que as reações são mostradas corretamente com a contagem atualizada.

    Dica Adicional: Remover Reações (Opcional)

    Se você quiser permitir que o usuário também possa remover suas reações (diminuir o contador), pode modificar a função handleAddReaction para verificar se o usuário está pressionando alguma tecla modificadora, como Shift ou Alt, para diminuir o contador em vez de aumentar.

    Exemplo:

    const handleAddReaction = (messageId: string, emoji: string, decrement = false) => {
      // Código anterior
      // Dentro da lógica, verificar se 'decrement' é true para diminuir a contagem
    };
    
    // No onClick de cada reação
    <Button
      // ...
      onClick={(e) => {
        const decrement = e.shiftKey; // Se o usuário pressionar Shift ao clicar
        handleAddReaction(message.id, reaction.emoji, decrement);
      }}
    >
      {/* ... */}
    </Button>
    

    Resumo

    Com essas modificações, agora o seu aplicativo de chat permite:

    • Adicionar reações usando o emoji-picker-react.
    • Incrementar a contagem de reações quando o mesmo usuário adiciona a mesma reação várias vezes.

    Espero que isso ajude! Se você tiver alguma dúvida ou precisar de mais assistência, por favor, avise.