I'm having major performance issues with my AI assistant interface website, as if…
- User
User: I'm having major performance issues with my AI assistant interface website, as if I get a long message response and then try and type something in my input area, it is almost impossible to type anything as it is very slow. How can I fix this?Code: // src/components/ChatInterface.js import React, { useState, useContext, useRef, useEffect, useCallback } from "react"; import { ChatContext } from "../context/ChatContext"; import Message from "./Message"; import CodeModal from "./CodeModal"; import InlineCodeEditor from "./InlineCodeEditor"; import { escapeHtml } from "../utils/escapeHtml";
function ChatInterface() { const { chats, currentChatId, addMessage, updateChat, selectedModelId, models, } = useContext(ChatContext); const currentChat = chats.find((chat) => chat.id === currentChatId); const [message, setMessage] = useState(""); const [isTyping, setIsTyping] = useState(false); const messagesEndRef = useRef(null); const [isCodeModalOpen, setIsCodeModalOpen] = useState(false); const [currentEditingCode, setCurrentEditingCode] = useState(null); const [isSystemPromptOpen, setIsSystemPromptOpen] = useState(false);
const addCodeAttachment = ({ codeContent, fileName, notes }) => { const escapedCode = escapeHtml(codeContent); const escapedFileName = escapeHtml(fileName || "untitled"); const escapedNotes = escapeHtml(notes || ""); const codeTag =
<code fileName="${escapedFileName}" notes="${escapedNotes}">${escapedCode}</code>; setMessage((prev) => prev + codeTag); };const handleAttachCode = useCallback((codeSegment = null) => { setCurrentEditingCode(codeSegment); setIsCodeModalOpen(true); }, []);
const handleCodeSave = (updatedCode) => { if (currentEditingCode) { // Update existing code const escapedCode = escapeHtml(updatedCode.codeContent); const escapedFileName = escapeHtml(updatedCode.fileName || "untitled"); const escapedNotes = escapeHtml(updatedCode.notes || "");
// Improved regex to handle multi-line and special characters const regex = new RegExp( `<code\\s+fileName="${currentEditingCode.fileName}"\\s+notes="${currentEditingCode.notes}">([\\s\\S]*?)<\\/code>` ); const updatedMessage = message.replace( regex, `<code fileName="${escapedFileName}" notes="${escapedNotes}">${escapedCode}</code>` ); setMessage(updatedMessage); } else { // Add new code addCodeAttachment(updatedCode); } setIsCodeModalOpen(false); setCurrentEditingCode(null);};
const handleSend = useCallback(async () => { if (!message.trim() || !currentChatId || !selectedModelId) return;
// Retrieve the system prompt from the current chat const systemPrompt = currentChat.systemPrompt || ""; // Combine the system prompt with the user message // Ensure there's a separator (like a newline) for clarity const fullMessage = systemPrompt ? `${systemPrompt}\n${message}` : message; const userMessage = { sender: "user", text: message }; addMessage(currentChatId, userMessage); setMessage(""); scrollToBottom(); // Set typing indicator setIsTyping(true); try { const response = await fetch("http://localhost:8000/api/chat", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ session_id: currentChatId, text: fullMessage, model_id: selectedModelId, // Ensure this is correctly set }), }); if (!response.ok) { const errorData = await response.json(); throw new Error( errorData.detail || "Failed to get response from the server." ); } const data = await response.json(); const responseText = data.response; const responseModelId = data.model_id; // Extract model_id from response const botMessage = { sender: "bot", text: responseText, model_id: responseModelId, // Include model_id }; addMessage(currentChatId, botMessage); scrollToBottom(); } catch (error) { console.error("Error:", error); const errorMessage = { sender: "bot", text: "Sorry, something went wrong. Please try again.", }; addMessage(currentChatId, errorMessage); scrollToBottom(); } finally { // Remove typing indicator setIsTyping(false); }});
const handleKeyDown = useCallback( (e) => { if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); handleSend(); } }, [handleSend] );
const handleEditorKeyDown = useCallback((e) => { if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); handleSend(); } }, [handleSend]);
const scrollToBottom = useCallback(() => { messagesEndRef.current?.scrollIntoView({ behavior: "smooth" }); }, []);
if (!currentChat) { return ( <div className="flex-1 p-4">No active chat. Please start a new chat.</div> ); }
const handleSystemPromptChange = (e) => { const newPrompt = e.target.value; updateChat(currentChatId, { systemPrompt: newPrompt }); };
const toggleSystemPrompt = () => { setIsSystemPromptOpen(!isSystemPromptOpen); };
return ( <div className="flex flex-col h-screen"> <div className="flex-1 p-32 pt-8 pb-8 overflow-y-auto bg-[#eeeeee] dark:bg-[#161618]"> {/* Removed Model Selector Dropdown */}
{/* Chat Messages */} {currentChat.messages.map((msg, index) => ( <Message key={index} chatId={currentChatId} messageIndex={index} sender={msg.sender} text={msg.text} model_id={msg.model_id} // Pass model_id /> ))} {isTyping && ( <div className="mb-4 flex justify-start"> <div className="max-w-xs md:max-w-md lg:max-w-lg p-3 rounded-lg bg-gray-200 dark:bg-gray-800 text-gray-800 dark:text-gray-200 flex items-center"> <div className="flex space-x-1 mr-2"> <div className="w-2 h-2 bg-gray-600 rounded-full animate-bounce-custom animation-delay-0"></div> <div className="w-2 h-2 bg-gray-600 rounded-full animate-bounce-custom animation-delay-200"></div> <div className="w-2 h-2 bg-gray-600 rounded-full animate-bounce-custom animation-delay-400"></div> </div> <span className="text-sm">Echo is typing...</span> </div> </div> )} <div ref={messagesEndRef} /> </div> <div id="message_area" className="p-4 border-t dark:border-gray-700 bg-white dark:bg-[#161618]" > <button onClick={toggleSystemPrompt} className="mb-2 text-sm text-blue-500 hover:underline focus:outline-none" > {isSystemPromptOpen ? "Hide System Prompt" : "Show System Prompt"} </button> {isSystemPromptOpen && ( <textarea className="w-full p-2 border rounded-lg resize-none dark:bg-gray-800 dark:text-gray-200 mb-2" rows="3" placeholder="Enter system prompt..." value={currentChat.systemPrompt} onChange={handleSystemPromptChange} /> )} <div className="flex flex-row"> <div className="flex-grow"> <InlineCodeEditor value={message} onChange={setMessage} onAttachCode={handleAttachCode} onKeyDown={handleEditorKeyDown} /> </div> <div className="flex flex-col flex-shrink-0 items-start pl-4 space-y-2"> <button onClick={() => setIsCodeModalOpen(true)} className="bg-blue-500 text-white px-3 py-2 rounded-lg hover:bg-blue-600 flex-grow w-full" > Attach Code </button> <button className="bg-green-500 text-white px-4 py-2 rounded-lg hover:bg-green-600 flex-grow mt-2 w-full" onClick={handleSend} > Send </button> </div> </div> </div> {isCodeModalOpen && ( <CodeModal onClose={() => { setIsCodeModalOpen(false); setCurrentEditingCode(null); }} onSave={handleCodeSave} initialData={currentEditingCode} /> )} </div>); }
export default ChatInterface; // src/components/InlineCodeEditor.js import React, { useRef, useEffect, useCallback } from 'react'; import CodeAttachmentBubble from './CodeAttachmentBubble'; import { renderCodeBubble } from '../utils/renderCodeBubble';
function InlineCodeEditor({ value, onChange, onAttachCode }) { const editorRef = useRef(null);
useEffect(() => { if (editorRef.current && editorRef.current.innerHTML !== formatContent(value)) { editorRef.current.innerHTML = formatContent(value); } }, [value]);
const formatContent = (content) => { return content.replace(/<code([^>])>([\s\S]?)</code>/g, (match, attributes, code) => { const fileName = attributes.match(/fileName="([^"])"/)?.[1] || 'Untitled'; const notes = attributes.match(/notes="([^"])"/)?.[1] || ''; // Pass the actual codeContent to renderCodeBubble return renderCodeBubble(fileName, notes, code); }); };
const handleInput = useCallback(() => { if (editorRef.current) { const content = editorRef.current.innerHTML; const plainText = content.replace(/<span class="code-bubble"[^>]>[^<]</span>/g, (match) => { const fileName = match.match(/data-filename="([^"])"/)?.[1]; const notes = match.match(/data-notes="([^"])"/)?.[1]; const codeContentEscaped = match.match(/data-codecontent="([^"]*)"/)?.[1]; // Unescape the codeContent const codeContent = codeContentEscaped ? decodeURIComponent(codeContentEscaped) : ''; return
<code fileName="${fileName}" notes="${notes}">${codeContent}</code>; }); onChange(plainText); } }, [onChange]);const handleKeyDown = useCallback((e) => { if (e.key === 'Enter') { if (e.shiftKey) { // Allow Shift+Enter to insert a newline // Let the event propagate naturally } else { // Prevent default behavior and emit a custom event or handle sending the message // Here, you might want to trigger the send action if needed // For InlineCodeEditor, we'll allow the parent to handle message sending // by not preventing default here } } }, []);
const handlePaste = (e) => { e.preventDefault(); const text = e.clipboardData.getData('text/plain'); document.execCommand('insertText', false, text); };
const handleBubbleClick = useCallback((e) => { if (e.target.classList.contains('code-bubble')) { const fileName = e.target.getAttribute('data-filename'); const notes = e.target.getAttribute('data-notes'); const codeContentEscaped = e.target.getAttribute('data-codecontent'); const codeContent = codeContentEscaped ? decodeURIComponent(codeContentEscaped) : ''; onAttachCode({ fileName, notes, codeContent }); } }, [onAttachCode]);
return ( <div className="relative border rounded-lg p-2 bg-white dark:bg-[#18181b] text-black dark:text-white"> <div ref={editorRef} className="w-full min-h-[100px] max-h-[300px] overflow-y-auto p-2 focus:outline-none break-all" contentEditable onInput={handleInput} onKeyDown={handleKeyDown} onPaste={handlePaste} onClick={handleBubbleClick} role="textbox" aria-multiline="true" aria-label="Code Editor" /> </div> ); }
export default InlineCodeEditor; import React, { useContext, useState } from 'react'; import ReactMarkdown from 'react-markdown'; import { Prism as SyntaxHighlighter } from 'react-syntax-highlighter'; import { coldarkDark } from 'react-syntax-highlighter/dist/esm/styles/prism'; import { CodeContext } from '../context/CodeContext'; import { ExternalLinkIcon, ClipboardCopyIcon } from '@heroicons/react/outline'; import { CopyToClipboard } from 'react-copy-to-clipboard';
const MarkdownRenderer = ({ text }) => { const { showCode } = useContext(CodeContext); const [copiedCode, setCopiedCode] = useState({}); // Track copied state per code block
return ( <ReactMarkdown components={{ code({ node, inline, className, children, ...props }) { const match = /language-(\w+)/.exec(className || ''); if (!inline && match) { const language = match[1]; const codeContent = String(children).replace(/\n$/, ''); const key = node.position.start.line; // Unique key per block based on line number
const handleCopy = () => { setCopiedCode((prev) => ({ ...prev, [key]: true })); setTimeout(() => { setCopiedCode((prev) => ({ ...prev, [key]: false })); }, 2000); }; return ( <div className="relative my-4"> <SyntaxHighlighter style={coldarkDark} language={language} PreTag="div" {...props}> {codeContent} </SyntaxHighlighter> <div className="absolute top-2 right-2 flex space-x-2"> <CopyToClipboard text={codeContent} onCopy={handleCopy}> <button className="bg-gray-700 bg-opacity-50 text-white p-1 rounded hover:bg-opacity-75 flex items-center" title="Copy Code" > <ClipboardCopyIcon className="h-4 w-4" /> {copiedCode[key] && <span className="ml-1 text-xs">Copied!</span>} </button> </CopyToClipboard> <button className="bg-gray-700 bg-opacity-50 text-white p-1 rounded hover:bg-opacity-75 flex items-center" onClick={() => showCode({ codeContent: codeContent, fileName: 'codeblock', notes: '', }) } title="Pop Out Code" > <ExternalLinkIcon className="h-4 w-4" /> </button> </div> </div> ); } else { return ( <code className={className} {...props}> {children} </code> ); } }, h1: ({ node, ...props }) => <h1 style={{ fontSize: '2.5em', marginBottom: '1em', marginTop: '1.25em' }} {...props} />, h2: ({ node, ...props }) => <h2 style={{ fontSize: '2em', marginBottom: '0.5em', marginTop: '0.75em' }} {...props} />, h3: ({ node, ...props }) => <h3 style={{ fontSize: '1.75em', marginBottom: '0.5em', marginTop: '0.75em' }} {...props} />, h4: ({ node, ...props }) => <h4 style={{ fontSize: '1.5em', marginBottom: '0.5em', marginTop: '0.75em' }} {...props} />, h5: ({ node, ...props }) => <h5 style={{ fontSize: '1.25em', marginBottom: '0.5em' }} {...props} />, h6: ({ node, ...props }) => <h6 style={{ fontSize: '1.1em', marginBottom: '0.5em' }} {...props} />, hr: ({ node, ...props }) => <hr style={{ marginTop: '1.5em', marginBottom: '1em' }} {...props} />, li: ({ node, ...props }) => <li style={{ marginLeft: '0.5em' }} {...props} />, }} > {text} </ReactMarkdown>); };
export default MarkdownRenderer;// src/components/Message.js import React, { useState, useContext } from 'react'; import MarkdownRenderer from './MarkdownRenderer'; import { CopyToClipboard } from 'react-copy-to-clipboard'; import { ClipboardCopyIcon } from '@heroicons/react/solid'; import { CodeContext } from '../context/CodeContext'; import CodeAttachmentBubble from './CodeAttachmentBubble'; import CodeModal from './CodeModal'; import { ChatContext } from '../context/ChatContext';
function Message({ chatId, messageIndex, sender, text, model_id }) { const [copied, setCopied] = useState(false); const { showCode } = useContext(CodeContext); const [isEditModalOpen, setIsEditModalOpen] = useState(false); const [currentAttachment, setCurrentAttachment] = useState(null); const { updateMessage } = useContext(ChatContext); // Ensure ChatContext is imported const { models } = useContext(ChatContext); // Access models from context
const modelName = model_id ? models.find((model) => model.id === model_id)?.name || "Unknown Model" : null;
const handleCopy = () => { setCopied(true); setTimeout(() => setCopied(false), 2000); };
const safeText = String(text);
// Function to extract code attachments const extractCodeAttachments = (text) => { const codeRegex = /<code(?:\s+fileName="([^"])")?(?:\s+notes="([^"])")?>([\s\S]*?)</code>/g; let match; const attachments = []; while ((match = codeRegex.exec(text)) !== null) { attachments.push({ fileName: match[1] || 'Untitled', notes: match[2] || '', codeContent: match[3], }); } return attachments; };
const codeAttachments = extractCodeAttachments(safeText); const cleanedText = safeText.replace(/<code(?:\s+fileName="[^"]")?(?:\s+notes="[^"]")?>[\s\S]*?</code>/g, '');
// Handlers for editing and deleting attachments const handleEdit = (attachment) => { setCurrentAttachment(attachment); setIsEditModalOpen(true); };
const handleDelete = (attachment) => { // Implement deletion logic // For example, remove the attachment's <code> block from the message text const updatedText = text.replace(
<code fileName="${attachment.fileName}" notes="${attachment.notes}">${attachment.codeContent}</code>, '' ); updateMessage(chatId, messageIndex, { text: updatedText }); };const handleUpdateAttachment = (updatedAttachment) => { // Replace the old <code> block with the updated one const oldCodeBlockRegex = new RegExp(
<code(?:\\s+fileName="${updatedAttachment.fileName || 'Untitled'}")?(?:\\s+notes="${updatedAttachment.notes || ''}")?>[\\s\\S]*?<\\/code>, 'g' ); const newCodeBlock =<code fileName="${updatedAttachment.fileName}" notes="${updatedAttachment.notes}">${updatedAttachment.codeContent}</code>; const updatedText = text.replace(oldCodeBlockRegex, newCodeBlock); updateMessage(chatId, messageIndex, { text: updatedText }); };return ( <> <div className={
mb-4 flex ${sender === 'user' ? 'justify-end' : 'justify-start'}}> <div className={max-w-xs md:max-w-md lg:max-w-5xl p-5 rounded-xl ${ sender === 'user' ? 'bg-zinc-950 text-white' : 'bg-gray-200 dark:bg-[#282828] text-gray-800 dark:text-gray-200' }} > {sender === 'bot' && modelName && ( <div className="mb-2 text-sm text-gray-500 dark:text-gray-400"> <strong>Model:</strong> {modelName} </div> )}<MarkdownRenderer text={cleanedText} /> <div className="mt-2 flex flex-wrap"> {codeAttachments.map((attachment, index) => ( <CodeAttachmentBubble key={index} attachment={attachment} onEdit={() => handleEdit(attachment)} onDelete={() => handleDelete(attachment)} /> ))} </div> <CopyToClipboard text={text} onCopy={handleCopy}> <button className="mt-2 text-sm text-gray-500 hover:text-gray-700 flex items-center"> <ClipboardCopyIcon className="h-5 w-5 mr-1" /> {copied ? 'Copied!' : 'Copy'} </button> </CopyToClipboard> </div> </div> {isEditModalOpen && currentAttachment && ( <CodeModal onClose={() => setIsEditModalOpen(false)} onSave={handleUpdateAttachment} initialData={currentAttachment} /> )} </>); }
export default Message;// src/context/ChatContext.js import React, { createContext, useState, useEffect } from 'react'; import { v4 as uuidv4 } from 'uuid';
export const ChatContext = createContext();
export const ChatProvider = ({ children }) => { const [chats, setChats] = useState(() => { const saved = localStorage.getItem('chats'); return saved ? JSON.parse(saved) : []; });
useEffect(() => { const saved = localStorage.getItem('chats'); if (saved) { const parsedChats = JSON.parse(saved).map(chat => ({ ...chat, messages: chat.messages.map(msg => ({ ...msg, text: String(msg.text) // Ensure text is string })) })); setChats(parsedChats); } else { setChats([]); } }, []);
const [currentChatId, setCurrentChatId] = useState(() => { const saved = localStorage.getItem('currentChatId'); return saved ? JSON.parse(saved) : null; });
const [models, setModels] = useState([]); // List of available models const [selectedModelId, setSelectedModelId] = useState(() => { const saved = localStorage.getItem('selectedModelId'); return saved ? JSON.parse(saved) : null; });
// Fetch models from the backend on component mount useEffect(() => { fetch('http://localhost:8000/api/models') .then((res) => { if (!res.ok) { throw new Error(
HTTP error! Status: ${res.status}); } return res.json(); }) .then((data) => { console.log('Fetched models:', data); // Debugging line if (Array.isArray(data) && data.length > 0 && !selectedModelId) { setSelectedModelId(data[0].id); // Select the first model by default } setModels(data); }) .catch((error) => { console.error('Error fetching models:', error); setModels([]); // Prevent.maperrors }); }, []);// Persist chats to localStorage useEffect(() => { localStorage.setItem('chats', JSON.stringify(chats)); }, [chats]);
// Persist currentChatId to localStorage useEffect(() => { localStorage.setItem('currentChatId', JSON.stringify(currentChatId)); }, [currentChatId]);
// Persist selectedModelId to localStorage useEffect(() => { if (selectedModelId) { localStorage.setItem('selectedModelId', JSON.stringify(selectedModelId)); } }, [selectedModelId]);
const addChat = (name =
Chat ${chats.length + 1}) => { const newChat = { id: uuidv4(), name: name, messages: [], systemPrompt: '', model_id: selectedModelId, // Associate with selected model }; setChats((prev) => [newChat, ...prev]); setCurrentChatId(newChat.id); };const updateChat = (id, updatedChat) => { console.log(
Updating chat with ID: ${id}, updatedChat); // Add this line setChats((prevChats) => prevChats.map((chat) => (chat.id === id ? { ...chat, ...updatedChat } : chat)) ); };const addMessage = (id, message) => { setChats((prevChats) => prevChats.map((chat) => chat.id === id ? { ...chat, messages: [...chat.messages, { ...message, text: String(message.text) }] } : chat ) ); };
const deleteChat = (id) => { setChats((prevChats) => prevChats.filter((chat) => chat.id !== id)); // If the deleted chat was the current one, reset currentChatId if (id === currentChatId) { setCurrentChatId(null); } };
const clearChats = () => { setChats([]); setCurrentChatId(null); };
const updateMessage = (chatId, messageIndex, updatedMessage) => { setChats((prevChats) => prevChats.map((chat) => chat.id === chatId ? { ...chat, messages: chat.messages.map((msg, idx) => idx === messageIndex ? { ...msg, text: String(updatedMessage.text) } : msg ), } : chat ) ); };
const addModel = (model) => { setModels((prev) => [...prev, model]); };
const removeModel = (modelId) => { setModels((prev) => prev.filter((model) => model.id !== modelId)); // Optionally, handle chat associations if the removed model was in use if (selectedModelId === modelId) { setSelectedModelId(models.length > 0 ? models[0].id : null); } };
return ( <ChatContext.Provider value={{ chats, currentChatId, setCurrentChatId, addChat, updateChat, addMessage, updateMessage, deleteChat, clearChats, models, addModel, removeModel, selectedModelId, setSelectedModelId, }} > {children} </ChatContext.Provider> ); };
- Assistant
Experiencing performance issues in a React application, especially with a chat interface handling long messages, can be frustrating. Based on the provided code snippets, the slowness when typing in the input area likely stems from several factors, including inefficient rendering of messages, heavy processing during input events, and possibly excessive re-renders of components. Below are detailed strategies and code optimizations to address and resolve these performance issues.
1. Optimize Message Rendering
a. Use Unique Keys Instead of Index
Using the
indexas a key in lists can lead to unnecessary re-renders, especially when the list changes. Instead, use a unique identifier for each message.Update in
ChatInterface.js:{currentChat.messages.map((msg) => ( <Message key={msg.id} // Ensure each message has a unique `id` property chatId={currentChatId} message={msg} model_id={msg.model_id} /> ))}Ensure Each Message Has a Unique ID:
Modify your
addMessagefunction inChatContext.jsto assign a uniqueidto each message:import { v4 as uuidv4 } from 'uuid'; // ... const addMessage = (id, message) => { setChats((prevChats) => prevChats.map((chat) => chat.id === id ? { ...chat, messages: [...chat.messages, { ...message, id: uuidv4(), text: String(message.text) }] } : chat ) ); };b. Memoize the
MessageComponentPrevent unnecessary re-renders of the
Messagecomponent by memoizing it. This ensures that messages only re-render when their props change.Update
Message.js:import React, { useState, useContext, memo } from 'react'; // ... other imports function Message({ chatId, message, model_id }) { // ... existing code } export default memo(Message);2. Implement Virtualization for the Message List
Rendering all messages at once can be resource-intensive, especially with long chat histories. Virtualization renders only the visible messages, significantly improving performance.
Use
react-windowfor Virtualization:-
Install
react-window:npm install react-window -
Update
ChatInterface.js:import React, { /* ... */, useCallback } from "react"; import { FixedSizeList as List } from 'react-window'; import AutoSizer from 'react-virtualized-auto-sizer'; // ... other imports function ChatInterface() { // ... existing code const Row = useCallback(({ index, style }) => { const msg = currentChat.messages[index]; return ( <div style={style}> <Message key={msg.id} chatId={currentChatId} message={msg} model_id={msg.model_id} /> </div> ); }, [currentChat.messages, currentChatId]); return ( <div className="flex flex-col h-screen"> <div className="flex-1 p-32 pt-8 pb-8 overflow-y-auto bg-[#eeeeee] dark:bg-[#161618]"> <AutoSizer> {({ height, width }) => ( <List height={height} itemCount={currentChat.messages.length} itemSize={100} // Adjust based on average message height width={width} > {Row} </List> )} </AutoSizer> {isTyping && ( // ... typing indicator )} <div ref={messagesEndRef} /> </div> {/* ... input area and other components */} </div> ); } export default ChatInterface;
Note: Adjust the
itemSizebased on your typical message height. For variable heights, consider usingreact-virtualized'sCellMeasurer.3. Optimize the
InlineCodeEditorComponentThe
InlineCodeEditorperforms regex operations and DOM manipulations on every input, which can be costly for large messages. Here's how to optimize it:a. Debounce the Input Handling
Debouncing reduces the frequency of
onChangecalls, preventing performance hits from rapid state updates.Update
InlineCodeEditor.js:import React, { useRef, useEffect, useCallback } from 'react'; import CodeAttachmentBubble from './CodeAttachmentBubble'; import { renderCodeBubble } from '../utils/renderCodeBubble'; import debounce from 'lodash.debounce'; // Install lodash.debounce function InlineCodeEditor({ value, onChange, onAttachCode }) { const editorRef = useRef(null); useEffect(() => { if (editorRef.current && editorRef.current.innerHTML !== formatContent(value)) { editorRef.current.innerHTML = formatContent(value); } }, [value]); const formatContent = (content) => { return content.replace(/<code([^>]*)>([\s\S]*?)<\/code>/g, (match, attributes, code) => { const fileName = attributes.match(/fileName="([^"]*)"/)?.[1] || 'Untitled'; const notes = attributes.match(/notes="([^"]*)"/)?.[1] || ''; return renderCodeBubble(fileName, notes, code); }); }; const handleInput = useCallback( debounce(() => { if (editorRef.current) { const content = editorRef.current.innerHTML; const plainText = content.replace(/<span class="code-bubble"[^>]*>[^<]*<\/span>/g, (match) => { const fileName = match.match(/data-filename="([^"]*)"/)?.[1]; const notes = match.match(/data-notes="([^"]*)"/)?.[1]; const codeContentEscaped = match.match(/data-codecontent="([^"]*)"/)?.[1]; const codeContent = codeContentEscaped ? decodeURIComponent(codeContentEscaped) : ''; return `<code fileName="${fileName}" notes="${notes}">${codeContent}</code>`; }); onChange(plainText); } }, 300), // Adjust debounce delay as needed [onChange] ); const handleKeyDown = useCallback((e) => { if (e.key === 'Enter') { if (e.shiftKey) { // Allow Shift+Enter to insert a newline } else { e.preventDefault(); // Trigger send action if needed } } }, []); const handlePaste = (e) => { e.preventDefault(); const text = e.clipboardData.getData('text/plain'); document.execCommand('insertText', false, text); }; const handleBubbleClick = useCallback((e) => { if (e.target.classList.contains('code-bubble')) { const fileName = e.target.getAttribute('data-filename'); const notes = e.target.getAttribute('data-notes'); const codeContentEscaped = e.target.getAttribute('data-codecontent'); const codeContent = codeContentEscaped ? decodeURIComponent(codeContentEscaped) : ''; onAttachCode({ fileName, notes, codeContent }); } }, [onAttachCode]); return ( <div className="relative border rounded-lg p-2 bg-white dark:bg-[#18181b] text-black dark:text-white"> <div ref={editorRef} className="w-full min-h-[100px] max-h-[300px] overflow-y-auto p-2 focus:outline-none break-all" contentEditable onInput={handleInput} onKeyDown={handleKeyDown} onPaste={handlePaste} onClick={handleBubbleClick} role="textbox" aria-multiline="true" aria-label="Code Editor" /> </div> ); } export default InlineCodeEditor;Install
lodash.debounce:npm install lodash.debounceb. Optimize Regex Operations
Complex regex operations can slow down the input processing. Optimize your regex patterns or limit their scope.
4. Prevent Unnecessary Re-renders in
MarkdownRendererandMessageBoth
MarkdownRendererandMessageperform operations that can be optimized.a. Memoize
MarkdownRendererEnsure
MarkdownRendereronly re-renders when thetextprop changes.Update
MarkdownRenderer.js:import React, { useContext, useState, memo } from 'react'; // ... other imports const MarkdownRenderer = memo(({ text }) => { // ... existing code }); export default MarkdownRenderer;b. Optimize State Management in
MessageAvoid maintaining multiple states that can trigger re-renders. For example, managing
copied,isEditModalOpen, andcurrentAttachmentseparately can be optimized.Refactor
Message.js:import React, { useState, useContext, memo } from 'react'; // ... other imports function Message({ chatId, message, model_id }) { const [modalState, setModalState] = useState({ isEditModalOpen: false, currentAttachment: null, copied: false, }); const { showCode } = useContext(CodeContext); const { updateMessage, models } = useContext(ChatContext); const modelName = model_id ? models.find((model) => model.id === model_id)?.name || "Unknown Model" : null; const handleCopy = () => { setModalState((prev) => ({ ...prev, copied: true })); setTimeout(() => { setModalState((prev) => ({ ...prev, copied: false })); }, 2000); }; // ... existing code return ( <> <div className={`mb-4 flex ${message.sender === 'user' ? 'justify-end' : 'justify-start'}`}> <div className={`max-w-xs md:max-w-md lg:max-w-5xl p-5 rounded-xl ${ message.sender === 'user' ? 'bg-zinc-950 text-white' : 'bg-gray-200 dark:bg-[#282828] text-gray-800 dark:text-gray-200' }`} > {message.sender === 'bot' && modelName && ( <div className="mb-2 text-sm text-gray-500 dark:text-gray-400"> <strong>Model:</strong> {modelName} </div> )} <MarkdownRenderer text={cleanedText} /> <div className="mt-2 flex flex-wrap"> {codeAttachments.map((attachment, index) => ( <CodeAttachmentBubble key={attachment.id || index} // Preferably use a unique id for attachments attachment={attachment} onEdit={() => handleEdit(attachment)} onDelete={() => handleDelete(attachment)} /> ))} </div> <CopyToClipboard text={message.text} onCopy={handleCopy}> <button className="mt-2 text-sm text-gray-500 hover:text-gray-700 flex items-center"> <ClipboardCopyIcon className="h-5 w-5 mr-1" /> {modalState.copied ? 'Copied!' : 'Copy'} </button> </CopyToClipboard> </div> </div> {modalState.isEditModalOpen && modalState.currentAttachment && ( <CodeModal onClose={() => setModalState((prev) => ({ ...prev, isEditModalOpen: false, currentAttachment: null }))} onSave={handleUpdateAttachment} initialData={modalState.currentAttachment} /> )} </> ); } export default memo(Message);5. Profile and Identify Performance Bottlenecks
Before and after applying optimizations, it's crucial to profile your application to identify where the main bottlenecks are.
a. Use React Developer Tools Profiler
-
Install React DevTools:
-
Profile Your Application:
- Open your application in the browser.
- Open DevTools → React tab → Profiler.
- Start profiling and interact with your app to capture performance data.
- Analyze which components are re-rendering frequently or taking the most time.
b. Use Browser Performance Tools
- Open Performance Tab in DevTools:
- Start recording.
- Perform actions that cause slowness (e.g., typing long messages).
- Stop recording and analyze the flame chart to locate long-running tasks.
6. Additional Optimizations
a. Throttle Scrolling and Reflow
Ensure that scrolling actions, especially after sending a message, don’t trigger excessive reflows or repaints.
Optimize
scrollToBottominChatInterface.js:const scrollToBottom = useCallback(() => { if (messagesEndRef.current) { messagesEndRef.current.scrollIntoView({ behavior: "smooth" }); } }, []);Consider using
requestAnimationFramefor smoother scrolling if needed.b. Reduce the Size of Stored Data
Storing large amounts of data in
localStoragecan slow down your app. Consider:- Limiting the number of messages stored.
- Implementing pagination or lazy loading for older messages.
- Compressing the stored data if feasible.
c. Avoid Inline Functions and Objects
Passing inline functions or objects can cause child components to re-render unnecessarily as their references change on every render.
Example Optimization: Instead of:
<Message key={msg.id} chatId={currentChatId} message={msg} model_id={msg.model_id} />Ensure
msgand its properties are stable. If needed, extract properties outside the map:{currentChat.messages.map((msg) => { const { id, text, sender, model_id } = msg; return ( <Message key={id} chatId={currentChatId} message={{ id, text, sender, model_id }} /> ); })}7. Consider State Management Enhancements
If your application grows in complexity, consider more efficient state management solutions like Recoil or Zustand, which offer better performance characteristics for large-scale state.
8. Final Thoughts
By implementing the above optimizations, you should observe a significant improvement in your application's performance, especially concerning slow typing and rendering issues. Here's a summary checklist:
- Use unique keys for list items to prevent unnecessary re-renders.
- Memoize components that don't need to re-render on every state change.
- Implement virtualization for long lists to render only visible items.
- Debounce input handlers to reduce the frequency of heavy operations.
- Profile your application to identify and address specific bottlenecks.
- Optimize regex and DOM manipulations to be as efficient as possible.
- Limit stored data to what's necessary to maintain responsiveness.
Applying these strategies should help mitigate the performance issues you're facing with your AI assistant interface.
-