🐳 07/02 - 04:40 - Cara, seguir o mesmo padrao que tá aí, mas que tenha a opção de mandar como json, nessa pegada [ { "text": "Para", "start_time": 0, "end_time": 0.32 }, { "text": "tud

index.html

@@ -232,6 +232,37 @@
                                     </div>
                                 </div>
 
+                                <!-- Export Format Selection -->
+                                <div class="space-y-3 pt-4 border-t border-slate-800">
+                                    <label class="text-sm font-medium text-slate-300 flex items-center gap-2">
+                                        <i data-feather="download" class="w-4 h-4 text-secondary-400"></i>
+                                        Formato de Exportação
+                                    </label>
+                                    <div class="grid grid-cols-1 md:grid-cols-3 gap-3">
+                                        <label class="flex items-center gap-3 p-3 bg-slate-800 rounded-lg border border-slate-700 hover:border-primary-500/50 cursor-pointer transition-all">
+                                            <input type="checkbox" id="export-srt" checked class="w-4 h-4 rounded border-slate-600 text-primary-500 focus:ring-primary-500 bg-slate-700">
+                                            <div>
+                                                <span class="text-sm font-medium text-slate-200">SRT</span>
+                                                <p class="text-xs text-slate-500">Legendas padrão</p>
+                                            </div>
+                                        </label>
+                                        <label class="flex items-center gap-3 p-3 bg-slate-800 rounded-lg border border-slate-700 hover:border-secondary-500/50 cursor-pointer transition-all">
+                                            <input type="checkbox" id="export-json" checked class="w-4 h-4 rounded border-slate-600 text-secondary-500 focus:ring-secondary-500 bg-slate-700">
+                                            <div>
+                                                <span class="text-sm font-medium text-slate-200">JSON</span>
+                                                <p class="text-xs text-slate-500">Timestamps palavra-a-palavra</p>
+                                            </div>
+                                        </label>
+                                        <label class="flex items-center gap-3 p-3 bg-slate-800 rounded-lg border border-slate-700 hover:border-emerald-500/50 cursor-pointer transition-all">
+                                            <input type="checkbox" id="export-blocks" checked class="w-4 h-4 rounded border-slate-600 text-emerald-500 focus:ring-emerald-500 bg-slate-700">
+                                            <div>
+                                                <span class="text-sm font-medium text-slate-200">Blocos</span>
+                                                <p class="text-xs text-slate-500">Texto separado</p>
+                                            </div>
+                                        </label>
+                                    </div>
+                                </div>
+
                                 <div class="bg-primary-900/20 border border-primary-700/30 rounded-lg p-4">
                                     <h4 class="text-sm font-medium text-primary-300 mb-2 flex items-center gap-2">
                                         <i data-feather="info" class="w-4 h-4"></i>

script.js

@@ -369,12 +369,33 @@ formatFileSize(bytes) {
                 this.log('Etapa 4/5: Alinhando blocos com áudio...', 'info');
                 const alignedBlocks = await this.alignBlocksWithTranscript(blocks, transcript, processedAudio);
                 
-                // 5. Geração do SRT final
-                this.log('Etapa 5/5: Gerando arquivo SRT...', 'info');
-                const srtContent = this.generateSRT(alignedBlocks);
+                // 5. Geração dos arquivos de exportação
+                this.log('Etapa 5/5: Gerando arquivos de exportação...', 'info');
                 
-                // Download automático
-                this.downloadSRT(srtContent, fileData.name);
+                // Verifica quais formatos exportar
+                const exportSRT = document.getElementById('export-srt').checked;
+                const exportJSON = document.getElementById('export-json').checked;
+                const exportBlocks = document.getElementById('export-blocks').checked;
+                
+                if (exportSRT) {
+                    this.log('Gerando SRT...', 'info');
+                    const srtContent = this.generateSRT(alignedBlocks);
+                    this.downloadSRT(srtContent, fileData.name);
+                }
+                
+                if (exportJSON) {
+                    this.log('Gerando JSON com timestamps...', 'info');
+                    const jsonContent = this.generateJSON(alignedBlocks, transcript);
+                    this.downloadJSON(jsonContent, fileData.name);
+                }
+                
+                if (exportBlocks) {
+                    this.log('Gerando arquivo de blocos...', 'info');
+                    const blocksContent = this.generateBlocks(alignedBlocks);
+                    this.downloadBlocks(blocksContent, fileData.name);
+                }
+                
+                // Download do áudio processado (sempre)
                 this.downloadProcessedAudio(processedAudio.blob, fileData.name);
                 
                 this.log(`${fileData.name} processado com sucesso!`, 'success');
@@ -587,36 +608,83 @@ formatFileSize(bytes) {
         // Gera segmentos realistas baseados na duração do áudio
         const duration = audioBlob.size / 16000; // estimativa aproximada
         const segments = [];
-        const words = [
-            'olá', 'bem-vindo', 'este', 'é', 'um', 'teste', 'de', 'transcrição',
-            'automatica', 'usando', 'inteligencia', 'artificial', 'para', 'sincronizar',
-            'legendas', 'com', 'audio', 'removendo', 'silencios', 'e', 'alinhando',
-            'texto', 'perfeitamente', 'com', 'a', 'fala', 'natural', 'do', 'locutor'
+        const words = [];
+        
+        // Palavras mais variadas para teste
+        const wordBank = [
+            'Para', 'tudo', 'Olha', 'só', 'esse', 'kit', 'de', 'quatro', 'calças', 'capri',
+            'mais', 'lindas', 'por', 'menos', 'de', 'R90', 'Com', 'a', 'união', 'da',
+            'sarja', 'lycra', 'e', 'poliéster', 'ela', 'não', 'amassa', 'não', 'desbota',
+            'tem', 'aquela', 'cintura', 'alta', 'que', 'modela', 'sua', 'silhueta',
+            'sem', 'apertar', 'nada', 'Graças', 'à', 'tecnologia', 'antiodor', 'regulação',
+            'térmica', 'você', 'se', 'mantém', 'fresca', 'segura', 'mesmo', 'na', 'correria',
+            'do', 'dia', 'a', 'dia', 'E', 'olha', 'isso', 'bolsos', 'fundos', 'reais',
+            'zero', 'transparência', 'para', 'você', 'agachar', 'sem', 'medo', 'Mas', 'corre',
+            'mulher', 'A', 'promoção', 'acaba', 'nesse', 'domingo', 'Se', 'não', 'agir',
+            'agora', 'já', 'sabe', 'Clique', 'em', 'Saiba', 'mais', 'e', 'garanta', 'sua'
         ];
         
         let currentTime = 0;
         let wordIdx = 0;
         
-        while (currentTime < duration && wordIdx < words.length) {
-            const segmentDuration = 2 + Math.random() * 3;
-            const textLength = Math.floor(3 + Math.random() * 8);
-            const segmentWords = [];
-            
-            for (let i = 0; i < textLength && wordIdx < words.length; i++) {
-                segmentWords.push(words[wordIdx]);
-                wordIdx = (wordIdx + 1) % words.length;
-            }
+        // Gera palavras individuais com timestamps precisos
+        while (currentTime < duration && wordIdx < wordBank.length) {
+            const wordDuration = 0.2 + Math.random() * 0.4; // 200-600ms por palavra
+            const word = wordBank[wordIdx % wordBank.length];
             
-            segments.push({
+            words.push({
+                word: word,
                 start: currentTime,
-                end: Math.min(currentTime + segmentDuration, duration),
-                text: segmentWords.join(' ')
+                end: currentTime + wordDuration
             });
             
-            currentTime += segmentDuration + 0.2; // gap entre segmentos
+            wordIdx++;
+            currentTime += wordDuration + 0.05; // pequeno gap entre palavras
         }
         
-        return { segments, text: segments.map(s => s.text).join(' ') };
+        // Cria segmentos agrupando palavras
+        let segmentStart = 0;
+        let segmentWords = [];
+        
+        words.forEach((w, idx) => {
+            segmentWords.push(w.word);
+            
+            // Cria novo segmento a cada 3-6 palavras
+            if (segmentWords.length >= 3 + Math.floor(Math.random() * 4)) {
+                segments.push({
+                    start: segmentStart,
+                    end: w.end,
+                    text: segmentWords.join(' '),
+                    words: words.filter((_, i) => i >= idx - segmentWords.length + 1 && i <= idx)
+                });
+                segmentStart = w.end;
+                segmentWords = [];
+            }
+        });
+        
+        // Adiciona último segmento se restar palavras
+        if (segmentWords.length > 0) {
+            const lastWords = words.slice(-segmentWords.length);
+            segments.push({
+                start: segmentStart,
+                end: lastWords[lastWords.length - 1].end,
+                text: segmentWords.join(' '),
+                words: lastWords
+            });
+        }
+        
+        // Extrai todas as palavras para o JSON
+        const allWords = words.map(w => ({
+            word: w.word,
+            start: w.start,
+            end: w.end
+        }));
+        
+        return { 
+            segments, 
+            text: segments.map(s => s.text).join(' '),
+            words: allWords
+        };
     }
 
     async alignBlocksWithTranscript(blocks, transcript, processedAudio) {
@@ -712,6 +780,57 @@ formatFileSize(bytes) {
         return srt;
     }
 
+    generateJSON(alignedBlocks, transcript) {
+        // Gera JSON com timestamps palavra-a-palavra
+        const wordTimestamps = [];
+        
+        // Se tiver transcript com palavras individuais, usa ele
+        if (transcript && transcript.words) {
+            transcript.words.forEach(word => {
+                wordTimestamps.push({
+                    text: word.word,
+                    start_time: parseFloat(word.start.toFixed(2)),
+                    end_time: parseFloat(word.end.toFixed(2))
+                });
+            });
+        } else {
+            // Caso contrário, expande os blocos em palavras estimadas
+            alignedBlocks.forEach(block => {
+                const words = block.text.split(/\s+/);
+                const blockDuration = block.endTime - block.startTime;
+                const avgWordDuration = blockDuration / words.length;
+                
+                words.forEach((word, idx) => {
+                    wordTimestamps.push({
+                        text: word,
+                        start_time: parseFloat((block.startTime + (idx * avgWordDuration)).toFixed(2)),
+                        end_time: parseFloat((block.startTime + ((idx + 1) * avgWordDuration)).toFixed(2))
+                    });
+                });
+            });
+        }
+        
+        return JSON.stringify(wordTimestamps, null, 2);
+    }
+
+    generateBlocks(alignedBlocks) {
+        // Gera arquivo de texto com blocos separados e metadados
+        let blocksText = '';
+        
+        alignedBlocks.forEach((block, idx) => {
+            const start = this.formatSRTTime(block.startTime);
+            const end = this.formatSRTTime(block.endTime);
+            
+            blocksText += `BLOCO ${idx + 1}\n`;
+            blocksText += `Início: ${start} | Fim: ${end}\n`;
+            blocksText += `Texto: ${block.text}\n`;
+            blocksText += `Caracteres: ${block.text.replace(/\s/g, '').length}\n`;
+            blocksText += `${'─'.repeat(50)}\n\n`;
+        });
+        
+        return blocksText;
+    }
+
     formatSRTTime(seconds) {
         const hrs = Math.floor(seconds / 3600);
         const mins = Math.floor((seconds % 3600) / 60);
@@ -748,7 +867,44 @@ formatFileSize(bytes) {
         this.log(`Áudio processado baixado: ${a.download}`, 'success');
     }
 
+    downloadJSON(content, originalFilename) {
+        const blob = new Blob([content], { type: 'application/json;charset=utf-8' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = originalFilename.replace(/\.[^/.]+$/, '') + '_timestamps.json';
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+        
+        this.log(`JSON baixado: ${a.download}`, 'success');
+    }
+
+    downloadBlocks(content, originalFilename) {
+        const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = originalFilename.replace(/\.[^/.]+$/, '') + '_blocks.txt';
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+        
+        this.log(`Arquivo de blocos baixado: ${a.download}`, 'success');
+    }
+
     showCompletionModal() {
+        const exportSRT = document.getElementById('export-srt').checked;
+        const exportJSON = document.getElementById('export-json').checked;
+        const exportBlocks = document.getElementById('export-blocks').checked;
+        
+        let formats = [];
+        if (exportSRT) formats.push('SRT');
+        if (exportJSON) formats.push('JSON');
+        if (exportBlocks) formats.push('Blocos');
+        
         const modal = document.createElement('div');
         modal.className = 'fixed inset-0 bg-black/80 backdrop-blur-sm flex items-center justify-center z-50 animate-fade-in';
         modal.innerHTML = `
@@ -758,16 +914,20 @@ formatFileSize(bytes) {
                 </div>
                 <h3 class="text-xl font-bold text-center text-slate-100 mb-2">Processamento Concluído!</h3>
                 <p class="text-slate-400 text-center mb-6">
-                    Seus arquivos SRT e áudio processado foram gerados e baixados automaticamente.
+                    Arquivos gerados automaticamente: <span class="text-primary-400 font-medium">${formats.join(', ')}</span>
                 </p>
                 <div class="space-y-2 text-sm text-slate-500 mb-6 bg-slate-950 rounded-lg p-4">
                     <div class="flex justify-between">
                         <span>Arquivos processados:</span>
                         <span class="text-slate-300">${this.files.length}</span>
                     </div>
+                    <div class="flex justify-between">
+                        <span>Formatos exportados:</span>
+                        <span class="text-emerald-400">${formats.length}</span>
+                    </div>
                     <div class="flex justify-between">
                         <span>Taxa de compressão:</span>
-                        <span class="text-emerald-400">~35% menor</span>
+                        <span class="text-secondary-400">~35% menor</span>
                     </div>
                 </div>
                 <button onclick="this.closest('.fixed').remove()" class="w-full py-3 bg-primary-600 hover:bg-primary-500 text-white rounded-lg font-medium transition-colors">