⚡ Optimize sequential file processing with Promise.all

Chat/components/ChatInput.tsx

@@ -127,40 +127,57 @@ export const ChatInput: React.FC<ChatInputProps> = ({
   }, [input]);
 
   const attachFiles = async (files: FileList | File[]) => {
-    const newAttachments: Attachment[] = [];
+    const fileArray = Array.from(files);
     const errors: string[] = [];
-    for (const file of Array.from(files)) {
-      const validation = validateFileForUpload(file);
-      if (!validation.isValid) {
-        errors.push(`${file.name}: ${validation.error}`);
-        continue;
-      }
-      try {
-        const result = await processFile(file);
-        logFileProcessing(result);
-        if (result.success) {
-          const previewUrl = result.imageData || result.text || result.base64 || '';
-          newAttachments.push({
-            id: uuidv4(),
-            file,
-            previewUrl,
-            type: result.type,
-            name: result.name,
-            size: result.size
-          });
-        } else {
-          errors.push(`${file.name}: ${result.error}`);
+
+    const processingResults = await Promise.all(
+      fileArray.map(async (file) => {
+        const validation = validateFileForUpload(file);
+        if (!validation.isValid) {
+          return { success: false, error: validation.error, fileName: file.name };
+        }
+
+        try {
+          const result = await processFile(file);
+          logFileProcessing(result);
+          if (result.success) {
+            const previewUrl = result.imageData || result.text || result.base64 || '';
+            return {
+              success: true,
+              attachment: {
+                id: uuidv4(),
+                file,
+                previewUrl,
+                type: result.type,
+                name: result.name,
+                size: result.size
+              }
+            };
+          } else {
+            return { success: false, error: result.error, fileName: file.name };
+          }
+        } catch {
+          return { success: false, error: 'Failed to process file', fileName: file.name };
         }
-      } catch {
-        errors.push(`${file.name}: Failed to process file`);
+      })
+    );
+
+    const newAttachments: Attachment[] = [];
+    processingResults.forEach((res) => {
+      if (res.success && res.attachment) {
+        newAttachments.push(res.attachment);
+      } else if (!res.success) {
+        errors.push(`${res.fileName}: ${res.error}`);
       }
-    }
+    });
+
     if (errors.length > 0) {
       setFileErrors(errors);
       errors.forEach(error => addToast(error, 'error'));
     } else {
       setFileErrors([]);
     }
+
     if (newAttachments.length > 0) {
       setAttachments(prev => [...prev, ...newAttachments]);
       addToast(t('chat_input.toast_attached', { count: newAttachments.length }), 'success');

Chat/services/fileService.ts

@@ -257,14 +257,7 @@ export const processFile = async (file: File): Promise<FileUploadResult> => {
 
 // Múltiplos arquivos
 export const processMultipleFiles = async (files: File[]): Promise<FileUploadResult[]> => {
-  const results: FileUploadResult[] = [];
-
-  for (const file of files) {
-    const result = await processFile(file);
-    results.push(result);
-  }
-
-  return results;
+  return Promise.all(files.map(file => processFile(file)));
 };
 
 // Validar arquivo antes do upload

benchmark.js

@@ -0,0 +1,44 @@
+
+const mockProcessFile = async (file) => {
+  // Simulate file processing delay (e.g., reading, resizing, etc.)
+  await new Promise(resolve => setTimeout(resolve, 100));
+  return { success: true, name: file.name };
+};
+
+const sequentialProcess = async (files) => {
+  const results = [];
+  for (const file of files) {
+    const result = await mockProcessFile(file);
+    results.push(result);
+  }
+  return results;
+};
+
+const parallelProcess = async (files) => {
+  return await Promise.all(files.map(file => mockProcessFile(file)));
+};
+
+const runBenchmark = async () => {
+  const dummyFiles = Array.from({ length: 10 }, (_, i) => ({ name: `file${i}.png` }));
+
+  console.log(`🚀 Starting benchmark with ${dummyFiles.length} files...`);
+
+  // Sequential
+  const startSeq = Date.now();
+  await sequentialProcess(dummyFiles);
+  const endSeq = Date.now();
+  const seqTime = endSeq - startSeq;
+  console.log(`⏱️ Sequential processing: ${seqTime}ms`);
+
+  // Parallel
+  const startPar = Date.now();
+  await parallelProcess(dummyFiles);
+  const endPar = Date.now();
+  const parTime = endPar - startPar;
+  console.log(`⏱️ Parallel processing: ${parTime}ms`);
+
+  const improvement = ((seqTime - parTime) / seqTime * 100).toFixed(2);
+  console.log(`✅ Improvement: ${improvement}% faster`);
+};
+
+runBenchmark();