@mocoto/mahoraga 0.14.0 → 0.14.1

package/dist/analysts/corrections/reorganize-barrels.js

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 import { existsSync, promises as fsAsync, readdirSync } from 'node:fs';
 import path from 'node:path';
 import { getMessages } from '../../core/messages/index.js';
@@ -30,8 +31,9 @@ function resolverImportRelativo(arquivoRel, importSpec) {
 function criarMapaMovimentos(mapa, _baseDir) {
     const movimentos = new Map();
     for (const entry of mapa) {
-        if (!entry.ideal || entry.ideal === entry.atual)
+        if (!entry.ideal || entry.ideal === entry.atual) {
             continue;
+        }
         const nomeArquivo = path.basename(entry.arquivo);
         const origemRel = normalizarRel(entry.arquivo.replace(/^src\//, ''));
         const destinoRel = normalizarRel(path.posix.join(entry.ideal.replace(/^src\//, ''), nomeArquivo));
@@ -47,8 +49,9 @@ async function* walkDir(dir) {
         for (const entry of entries) {
             const full = path.join(dir, entry.name);
             if (entry.isDirectory()) {
-                if (SKIP_DIRS.has(entry.name))
+                if (SKIP_DIRS.has(entry.name)) {
                     continue;
+                }
                 yield* walkDir(full);
             }
             else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {
@@ -65,8 +68,9 @@ function ehBarrel(content) {
 async function encontrarBarrels(srcDir) {
     const barrels = [];
     for await (const filePath of walkDir(srcDir)) {
-        if (path.basename(filePath) !== 'index.ts')
+        if (path.basename(filePath) !== 'index.ts') {
             continue;
+        }
         try {
             const content = await fsAsync.readFile(filePath, 'utf-8');
             if (ehBarrel(content)) {
@@ -85,11 +89,13 @@ function analisarExport(linha, barrelRel, movimentos) {
     }
     const PADRAO = /export\s+(?:\*\s+from|(?:default\s+|type\s+)?\{[^}]*\}\s+from)\s+['"]([^'"]+)['"]\s*;?\s*$/;
     const match = PADRAO.exec(linha);
-    if (!match)
+    if (!match) {
         return { exportSpec: null, exportInfo: null };
+    }
     const spec = match[1];
-    if (!spec.startsWith('.'))
+    if (!spec.startsWith('.')) {
         return { exportSpec: spec, exportInfo: null };
+    }
     const resolved = semExt(resolverImportRelativo(barrelRel, spec));
     const moveDest = movimentos.get(resolved) ?? null;
     return { exportSpec: spec, exportInfo: { spec, resolved, moveDest } };
@@ -102,8 +108,9 @@ function analisarBarrel(content, barrelRel, movimentos) {
     const linhas = content.split('\n');
     for (const linha of linhas) {
         const { exportInfo } = analisarExport(linha, barrelRel, movimentos);
-        if (exportInfo)
+        if (exportInfo) {
             exports.push(exportInfo);
+        }
     }
     const movidos = exports.filter(temMoveDest);
     const ficaram = exports.filter(e => e.moveDest === null);
@@ -113,8 +120,9 @@ function analisarBarrel(content, barrelRel, movimentos) {
         const dirs = new Set(movidos.map(e => path.posix.dirname(e.moveDest)));
         if (dirs.size === 1) {
             const val = dirs.values().next().value;
-            if (val !== undefined)
+            if (val !== undefined) {
                 dirDestinoUnico = val;
+            }
         }
     }
     return { barrelRel, exports, movidos, ficaram, todosMovidos, dirDestinoUnico };
@@ -124,8 +132,9 @@ function removerExportsMovidos(content, barrelRel, movimentos) {
     const resultado = [];
     for (const linha of linhas) {
         const { exportSpec, exportInfo } = analisarExport(linha, barrelRel, movimentos);
-        if (exportInfo && exportInfo.moveDest !== null)
+        if (exportInfo && exportInfo.moveDest !== null) {
             continue;
+        }
         if (exportSpec !== null && exportInfo === null) {
             resultado.push(linha);
             continue;
@@ -154,8 +163,9 @@ async function moverBarrel(barrelRel, dirDestino, srcDir) {
 }
 async function criarBarrelSeNecessario(dirRel, exportsParaAdicionar, srcDir) {
     const barrelPath = path.join(srcDir, dirRel, 'index.ts');
-    if (exportsParaAdicionar.length === 0)
+    if (exportsParaAdicionar.length === 0) {
         return false;
+    }
     const linhas = [];
     if (existsSync(barrelPath)) {
         const content = await fsAsync.readFile(barrelPath, 'utf-8');
@@ -163,8 +173,9 @@ async function criarBarrelSeNecessario(dirRel, exportsParaAdicionar, srcDir) {
     }
     for (const exp of exportsParaAdicionar) {
         const moveDest = exp.moveDest;
-        if (!moveDest)
+        if (!moveDest) {
             continue;
+        }
         const nomeArquivo = path.basename(moveDest);
         linhas.push(`export * from './${nomeArquivo}.js';`);
     }
@@ -206,17 +217,20 @@ async function atualizarImportsGlobais(srcDir, movimentos) {
             for (let i = 0; i < linhas.length; i++) {
                 const linha = linhas[i];
                 const trimmed = linha.trim();
-                if (!trimmed.startsWith('import') && !trimmed.startsWith('export') && !trimmed.includes('require('))
+                if (!trimmed.startsWith('import') && !trimmed.startsWith('export') && !trimmed.includes('require(')) {
                     continue;
+                }
                 const matches = linha.matchAll(/(['"])([^'"\n]+?)\1/g);
                 for (const m of matches) {
                     const spec = m[2];
-                    if (!spec)
+                    if (!spec) {
                         continue;
+                    }
                     const isRelative = spec.startsWith('./') || spec.startsWith('../');
                     const isAlias = spec.startsWith('@/') || /^@[^/]+\//.test(spec);
-                    if (!isRelative && !isAlias)
+                    if (!isRelative && !isAlias) {
                         continue;
+                    }
                     let resolved;
                     if (spec.startsWith('@/')) {
                         resolved = semExt(normalizarRel(`src/${spec.slice(2)}`));
@@ -228,13 +242,15 @@ async function atualizarImportsGlobais(srcDir, movimentos) {
                         resolved = semExt(resolverImportRelativo(rel, spec));
                     }
                     const moveDestino = movimentos.get(resolved);
-                    if (!moveDestino)
+                    if (!moveDestino) {
                         continue;
+                    }
                     const fileDir = path.posix.dirname(rel);
                     let newSpec = path.posix.relative(fileDir, moveDestino);
                     newSpec = normalizarRel(newSpec);
-                    if (!newSpec.startsWith('.'))
+                    if (!newSpec.startsWith('.')) {
                         newSpec = `./${newSpec}`;
+                    }
                     const ext = path.extname(spec);
                     if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
                         newSpec += ext;
@@ -261,12 +277,14 @@ async function atualizarImportsGlobais(srcDir, movimentos) {
     return totalReescritos;
 }
 async function extrairNomesExportados(srcDir, relPath, visitados = new Set(), profundidade = 0) {
-    if (profundidade > 5)
+    if (profundidade > 5) {
         return new Set();
+    }
     const caminho = path.join(srcDir, relPath);
     const chave = normalizarRel(relPath);
-    if (visitados.has(chave))
+    if (visitados.has(chave)) {
         return new Set();
+    }
     visitados.add(chave);
     const nomes = new Set();
     try {
@@ -276,21 +294,26 @@ async function extrairNomesExportados(srcDir, relPath, visitados = new Set(), pr
             if (trimmed.startsWith('export default ')) {
                 nomes.add('default');
             }
+            // export function, export async function, export const, export let, export var,
+            // export class, export interface, export type, export enum
             const exportDecl = trimmed.match(/^export\s+(?:type\s+)?(?:(?:async\s+)?(?:function|const|let|var|class|interface|type|enum))\s+(\w+)/);
-            if (exportDecl && exportDecl[1]) {
+            if (exportDecl?.[1]) {
                 nomes.add(exportDecl[1]);
             }
+            // export { name1, name2 as alias, ... }
             const exportList = trimmed.match(/^export\s+type\s*\{([^}]+)\}|^export\s*\{([^}]+)\}/);
             if (exportList) {
                 const body = exportList[1] ?? exportList[2];
                 if (body) {
                     body.split(',').forEach(part => {
                         const m = part.trim().match(/^(\w+)(?:\s+as\s+\w+)?$/);
-                        if (m)
+                        if (m) {
                             nomes.add(m[1]);
+                        }
                     });
                 }
             }
+            // Segue re-exports: export * from './foo'
             const reexportMatch = trimmed.match(/^export\s+(?:type\s+)?\*\s+from\s+['"]([^'"]+)['"]/);
             if (reexportMatch) {
                 const resolved = resolverImportRelativo(relPath, reexportMatch[1]);
@@ -300,12 +323,14 @@ async function extrairNomesExportados(srcDir, relPath, visitados = new Set(), pr
                     resolvedPath = `${basePath}.tsx`;
                 }
                 const subNomes = await extrairNomesExportados(srcDir, resolvedPath, visitados, profundidade + 1);
-                for (const n of subNomes)
+                for (const n of subNomes) {
                     nomes.add(n);
+                }
             }
         }
     }
     catch {
+        // arquivo não encontrado, ignora
     }
     return nomes;
 }
@@ -314,15 +339,19 @@ function classificarExports(content) {
     const values = new Set();
     for (const linha of content.split('\n')) {
         const trimmed = linha.trim();
-        if (!trimmed.startsWith('export'))
+        if (!trimmed.startsWith('export')) {
             continue;
-        if (/from\s+['"]/.test(trimmed))
+        }
+        if (/from\s+['"]/.test(trimmed)) {
             continue;
+        }
+        // export interface X
         let m = trimmed.match(/^export\s+interface\s+(\w+)/);
         if (m) {
             types.add(m[1]);
             continue;
         }
+        // export type X = ... (mas NÃO export type { X })
         if (/^export\s+type\s+(\w+)\s*=/.test(trimmed)) {
             m = trimmed.match(/^export\s+type\s+(\w+)\s*=/);
             if (m) {
@@ -330,11 +359,13 @@ function classificarExports(content) {
                 continue;
             }
         }
+        // export enum X (enum é runtime value)
         m = trimmed.match(/^export\s+enum\s+(\w+)/);
         if (m) {
             values.add(m[1]);
             continue;
         }
+        // export default class/function
         m = trimmed.match(/^export\s+default\s+(?:abstract\s+)?(?:class|function)\s+(\w+)/);
         if (m) {
             values.add(m[1]);
@@ -343,17 +374,20 @@ function classificarExports(content) {
         if (/^export\s+default\s+/.test(trimmed)) {
             continue;
         }
+        // export function/const/let/var/class
         m = trimmed.match(/^export\s+(?:abstract\s+)?(?:async\s+)?(?:function|const|let|var|class)\s+(\w+)/);
         if (m) {
             values.add(m[1]);
             continue;
         }
+        // export { X, Y } - assume que são valores (inferência conservadora)
         m = trimmed.match(/^export\s+(?:type\s+)?\{([^}]+)\}/);
         if (m) {
             m[1].split(',').forEach(part => {
                 const name = part.trim().match(/^(\w+)/);
-                if (name)
+                if (name) {
                     values.add(name[1]);
+                }
             });
             continue;
         }
@@ -361,14 +395,17 @@ function classificarExports(content) {
     return { types, values };
 }
 async function repararImportsBarrelPerdidos(srcDir, barrelsPerdidos, _movimentos) {
-    if (barrelsPerdidos.size === 0)
+    if (barrelsPerdidos.size === 0) {
         return 0;
+    }
     let totalReparados = 0;
+    // Pré-constrói mapa nomeExportado -> moveDest lendo os arquivos destino
     const nomeParaDestino = new Map();
     for (const [, perdas] of barrelsPerdidos) {
         for (const [, dest] of perdas) {
-            if (nomeParaDestino.has(dest))
+            if (nomeParaDestino.has(dest)) {
                 continue;
+            }
             const basePath = semExt(dest);
             let destPath = `${basePath}.ts`;
             if (!(await arquivoExiste(path.join(srcDir, destPath)))) {
@@ -383,16 +420,19 @@ async function repararImportsBarrelPerdidos(srcDir, barrelsPerdidos, _movimentos
         }
     }
     for (const [barrelRel, perdas] of barrelsPerdidos) {
-        if (perdas.size === 0)
+        if (perdas.size === 0) {
             continue;
+        }
+        // Constrói o alias do barrel pra matching nos imports
         const barrelAliasCandidates = new Set();
         barrelAliasCandidates.add(barrelRel.replace(/\/index\.ts$/, ''));
         barrelAliasCandidates.add(barrelRel.replace(/\.ts$/, ''));
         barrelAliasCandidates.add(barrelRel);
         for await (const filePath of walkDir(srcDir)) {
             const rel = normalizarRel(path.relative(srcDir, filePath).replace(/\\/g, '/'));
-            if (rel === barrelRel)
+            if (rel === barrelRel) {
                 continue;
+            }
             try {
                 const content = await fsAsync.readFile(filePath, 'utf-8');
                 const linhas = content.split('\n');
@@ -401,11 +441,13 @@ async function repararImportsBarrelPerdidos(srcDir, barrelsPerdidos, _movimentos
                     const linha = linhas[i];
                     const trimmed = linha.trim();
                     const importMatch = trimmed.match(/^(import|export)\s+(?:type\s+)?(?:\{([^}]*)\})\s+from\s+['"]([^'"]+)['"]/);
-                    if (!importMatch)
+                    if (!importMatch) {
                         continue;
+                    }
                     const [, keyword, namesRaw, spec] = importMatch;
-                    if (!spec || !namesRaw)
+                    if (!spec || !namesRaw) {
                         continue;
+                    }
                     let resolvedSpec;
                     if (spec.startsWith('.')) {
                         resolvedSpec = semExt(resolverImportRelativo(rel, spec));
@@ -419,12 +461,14 @@ async function repararImportsBarrelPerdidos(srcDir, barrelsPerdidos, _movimentos
                     else {
                         continue;
                     }
-                    if (!barrelAliasCandidates.has(resolvedSpec))
+                    if (!barrelAliasCandidates.has(resolvedSpec)) {
                         continue;
+                    }
                     const nomes = namesRaw.split(',').map(n => {
                         const match = n.trim().match(/^(?:type\s+)?(\w+)(?:\s+as\s+(\w+))?/);
-                        if (!match)
+                        if (!match) {
                             return null;
+                        }
                         return { imported: match[1], local: match[2] ?? match[1] };
                     }).filter((n) => n !== null);
                     const nomesQueFicam = [];
@@ -438,8 +482,9 @@ async function repararImportsBarrelPerdidos(srcDir, barrelsPerdidos, _movimentos
                             nomesQueFicam.push(nome);
                         }
                     }
-                    if (nomesQueMoveram.length === 0)
+                    if (nomesQueMoveram.length === 0) {
                         continue;
+                    }
                     const isTypeOnly = trimmed.includes('import type {') || trimmed.includes('export type {');
                     if (nomesQueFicam.length > 0) {
                         const nomesStr = nomesQueFicam.map(n => n.imported !== n.local ? `${n.imported} as ${n.local}` : n.imported).join(', ');
@@ -454,10 +499,12 @@ async function repararImportsBarrelPerdidos(srcDir, barrelsPerdidos, _movimentos
                     for (const nome of nomesQueMoveram) {
                         let newSpec = path.posix.relative(fileDir, nome.dest);
                         newSpec = normalizarRel(newSpec);
-                        if (!newSpec.startsWith('.'))
+                        if (!newSpec.startsWith('.')) {
                             newSpec = `./${newSpec}`;
-                        if (!path.extname(newSpec))
+                        }
+                        if (!path.extname(newSpec)) {
                             newSpec += '.js';
+                        }
                         const typePrefix = isTypeOnly ? 'import type' : 'import';
                         if (nome.imported !== nome.local) {
                             novasLinhas.push(`${typePrefix} { ${nome.imported} as ${nome.local} } from '${newSpec}';`);
@@ -487,8 +534,9 @@ async function repararImportsBarrelPerdidos(srcDir, barrelsPerdidos, _movimentos
 export async function reorganizarBarrelsAposMovimento(baseDir, mapa) {
     const srcDir = path.join(baseDir, 'src');
     const movimentos = criarMapaMovimentos(mapa, baseDir);
-    if (movimentos.size === 0)
+    if (movimentos.size === 0) {
         return;
+    }
     log.info('Reorganizando barrels e atualizando imports após movimentação...');
     const barris = await encontrarBarrels(srcDir);
     const mapDestinos = new Map();
@@ -506,29 +554,36 @@ export async function reorganizarBarrelsAposMovimento(baseDir, mapa) {
             continue;
         }
         const analise = analisarBarrel(content, barrelRel, movimentos);
-        if (!analise.todosMovidos && analise.movidos.length === 0)
+        if (!analise.todosMovidos && analise.movidos.length === 0) {
             continue;
+        }
+        // Caso 1: todos os exports moveram para o MESMO diretório → move o barrel junto
         if (analise.todosMovidos && analise.dirDestinoUnico) {
             const nomeBarrel = path.basename(barrelRel);
             const novoBarrelRel = path.posix.join(analise.dirDestinoUnico, nomeBarrel);
             const destBarrelAbs = path.join(srcDir, novoBarrelRel);
+            // Se o destino já tem barrel, funde (cai no Caso 2 em vez de mover)
             if (!existsSync(destBarrelAbs)) {
                 await moverBarrel(barrelRel, analise.dirDestinoUnico, srcDir);
                 barrisMovidos++;
                 movimentos.set(semExt(barrelRel), semExt(novoBarrelRel));
                 continue;
             }
+            // Fallthrough → Caso 2: remove exports e deixa criarBarrelSeNecessario fundir
         }
+        // Caso 2: alguns exports moveram → remove do barrel antigo
         if (analise.movidos.length > 0) {
             const novoConteudo = removerExportsMovidos(content, barrelRel, movimentos);
             await fsAsync.writeFile(path.join(srcDir, barrelRel), novoConteudo, 'utf-8');
             barrisModificados++;
             log.info(`Barrel atualizado (exports removidos): ${barrelRel}`);
+            // Registra exports removidos pra reparo posterior
             const perdas = new Map();
             for (const exp of analise.movidos) {
                 perdas.set(exp.resolved, exp.moveDest);
             }
             barrelsPerdidos.set(barrelRel, perdas);
+            // Registra os exports que precisam ir para os destinos
             for (const exp of analise.movidos) {
                 const dirDest = path.posix.dirname(exp.moveDest);
                 const lista = mapDestinos.get(dirDest);
@@ -539,26 +594,32 @@ export async function reorganizarBarrelsAposMovimento(baseDir, mapa) {
                     mapDestinos.set(dirDest, [exp]);
                 }
             }
+            // Se após remoção o barrel ficou vazio, apaga
             const vazio = await apagarBarrelSeVazio(barrelRel, srcDir);
-            if (vazio)
+            if (vazio) {
                 barrisRemovidos++;
+            }
         }
     }
+    // Cria/atualiza barrels nos destinos com os exports movidos
     for (const [dirRel, exportsParaAdicionar] of mapDestinos) {
         if (await criarBarrelSeNecessario(dirRel, exportsParaAdicionar, srcDir)) {
             barrisCriados++;
         }
     }
+    // Também cria barrels para destinos que receberam arquivos mas não têm barrel ainda
     const dirsDestino = new Set();
     for (const [, destino] of movimentos) {
         dirsDestino.add(path.posix.dirname(destino));
     }
     for (const dirRel of dirsDestino) {
-        if (mapDestinos.has(dirRel))
+        if (mapDestinos.has(dirRel)) {
             continue;
+        }
         const barrelPath = path.join(srcDir, dirRel, 'index.ts');
-        if (existsSync(barrelPath))
+        if (existsSync(barrelPath)) {
             continue;
+        }
         const exportsNovos = [];
         for (const [, destino] of movimentos) {
             if (path.posix.dirname(destino) === dirRel) {
@@ -575,18 +636,24 @@ export async function reorganizarBarrelsAposMovimento(baseDir, mapa) {
     const importsReescritos = await atualizarImportsGlobais(srcDir, movimentos);
     const importsReparados = await repararImportsBarrelPerdidos(srcDir, barrelsPerdidos, movimentos);
     const partes = [];
-    if (barrisMovidos > 0)
+    if (barrisMovidos > 0) {
         partes.push(`${barrisMovidos} movidos`);
-    if (barrisModificados > 0)
+    }
+    if (barrisModificados > 0) {
         partes.push(`${barrisModificados} modificados`);
-    if (barrisCriados > 0)
+    }
+    if (barrisCriados > 0) {
         partes.push(`${barrisCriados} criados`);
-    if (barrisRemovidos > 0)
+    }
+    if (barrisRemovidos > 0) {
         partes.push(`${barrisRemovidos} removidos`);
-    if (importsReescritos > 0)
+    }
+    if (importsReescritos > 0) {
         partes.push(`${importsReescritos} imports reescritos`);
-    if (importsReparados > 0)
+    }
+    if (importsReparados > 0) {
         partes.push(`${importsReparados} imports reparados`);
+    }
     if (partes.length > 0) {
         log.sucesso(`Barrels: ${partes.join(', ')}`);
     }
@@ -619,19 +686,26 @@ function exportsBarrelExistentes(content) {
     }
     return exports;
 }
+/** Verifica se o barrel contém APENAS re-exports (export * from / export { } from), espaços e comentários.
+ *  Barrels com imports, named exports, ou lógica customizada são considerados "curados" e NÃO devem ser alterados. */
 function barrelEhPuroReexport(content) {
     for (const linha of content.split('\n')) {
         const trimmed = linha.trim();
-        if (!trimmed)
+        if (!trimmed) {
             continue;
-        if (trimmed.startsWith('//'))
+        }
+        if (trimmed.startsWith('//')) {
             continue;
-        if (trimmed.startsWith('/*'))
+        }
+        if (trimmed.startsWith('/*')) {
             continue;
-        if (trimmed.startsWith('*'))
+        }
+        if (trimmed.startsWith('*')) {
             continue;
-        if (/^export\s+(?:\*\s+from|(?:type\s+)?\{[^}]*\}\s+from)\s+['"]/.test(trimmed))
+        }
+        if (/^export\s+(?:\*\s+from|(?:type\s+)?\{[^}]*\}\s+from)\s+['"]/.test(trimmed)) {
             continue;
+        }
         return false;
     }
     return true;
@@ -656,8 +730,9 @@ export async function gerarBarrels(baseDir, dryRun = false) {
             .map(e => path.join(srcDir, e.name));
         while (stack.length > 0) {
             const dir = stack.pop();
-            if (!dir)
+            if (!dir) {
                 break;
+            }
             dirs.push(dir);
             try {
                 const sub = await fsAsync.readdir(dir, { withFileTypes: true });
@@ -677,15 +752,18 @@ export async function gerarBarrels(baseDir, dryRun = false) {
     }
     for (const dir of dirs) {
         const files = listarArquivosDir(dir);
-        if (files.length === 0)
+        if (files.length === 0) {
             continue;
+        }
+        // Filtra .d.ts que são declarações ambientes (não módulos)
         const filesModulo = [];
         for (const f of files) {
             if (f.endsWith('.d.ts')) {
                 try {
                     const content = await fsAsync.readFile(path.join(dir, f), 'utf-8');
-                    if (!/^export\s/m.test(content))
+                    if (!/^export\s/m.test(content)) {
                         continue;
+                    }
                 }
                 catch {
                     continue;
@@ -693,8 +771,10 @@ export async function gerarBarrels(baseDir, dryRun = false) {
             }
             filesModulo.push(f);
         }
-        if (filesModulo.length === 0)
+        if (filesModulo.length === 0) {
             continue;
+        }
+        // Mapeia nomes de exportação para arquivos para detectar conflitos
         const nomeExportParaArquivos = new Map();
         const exportacoesPorArquivo = new Map();
         for (const f of filesModulo) {
@@ -705,19 +785,23 @@ export async function gerarBarrels(baseDir, dryRun = false) {
                 const todos = new Set([...classified.types, ...classified.values]);
                 for (const nome of todos) {
                     const arr = nomeExportParaArquivos.get(nome);
-                    if (arr)
+                    if (arr) {
                         arr.push(f);
-                    else
+                    }
+                    else {
                         nomeExportParaArquivos.set(nome, [f]);
+                    }
                 }
             }
-            catch { }
+            catch { /* arquivo problemático, ignora */ }
         }
-        async function gerarLinhasExportacao(filename) {
+        // Gera linha(s) de export para um arquivo, respeitando conflitos de nome e verbatimModuleSyntax
+        function gerarLinhasExportacao(filename) {
             const spec = gerarSpecExport(filename);
             const classified = exportacoesPorArquivo.get(filename);
-            if (!classified)
+            if (!classified) {
                 return [`export * from '${spec}';`];
+            }
             const { types, values } = classified;
             const todos = new Set([...types, ...values]);
             const unicos = [];
@@ -726,25 +810,30 @@ export async function gerarBarrels(baseDir, dryRun = false) {
                 const arquivos = nomeExportParaArquivos.get(nome);
                 if (arquivos && arquivos.length > 1) {
                     const sorted = [...arquivos].sort();
-                    if (sorted[0] === filename)
+                    if (sorted[0] === filename) {
                         unicos.push(nome);
-                    else
+                    }
+                    else {
                         conflitantes.push(nome);
+                    }
                 }
                 else {
                     unicos.push(nome);
                 }
             }
-            if (conflitantes.length === 0)
+            if (conflitantes.length === 0) {
                 return [`export * from '${spec}';`];
+            }
             if (unicos.length > 0) {
                 const valuesUnicos = unicos.filter(n => values.has(n));
                 const typesUnicos = unicos.filter(n => types.has(n));
                 const parts = [];
-                if (valuesUnicos.length > 0)
+                if (valuesUnicos.length > 0) {
                     parts.push(valuesUnicos.join(', '));
-                if (typesUnicos.length > 0)
+                }
+                if (typesUnicos.length > 0) {
                     parts.push(typesUnicos.map(n => `type ${n}`).join(', '));
+                }
                 return [`export { ${parts.join(', ')} } from '${spec}';`];
             }
             return [];
@@ -760,14 +849,16 @@ export async function gerarBarrels(baseDir, dryRun = false) {
                 }
                 const existentes = exportsBarrelExistentes(content);
                 const existentesSemExt = new Set();
-                for (const s of existentes)
+                for (const s of existentes) {
                     existentesSemExt.add(semExt(s));
+                }
                 const linhasParaAdicionar = [];
                 for (const f of filesModulo) {
                     const spec = gerarSpecExport(f);
-                    if (existentes.has(spec) || existentesSemExt.has(semExt(spec)))
+                    if (existentes.has(spec) || existentesSemExt.has(semExt(spec))) {
                         continue;
-                    const novasLinhas = await gerarLinhasExportacao(f);
+                    }
+                    const novasLinhas = gerarLinhasExportacao(f);
                     linhasParaAdicionar.push(...novasLinhas);
                 }
                 if (linhasParaAdicionar.length === 0) {
@@ -810,7 +901,7 @@ export async function gerarBarrels(baseDir, dryRun = false) {
             try {
                 const linhas = [];
                 for (const f of filesModulo) {
-                    const l = await gerarLinhasExportacao(f);
+                    const l = gerarLinhasExportacao(f);
                     linhas.push(...l);
                 }
                 await fsAsync.writeFile(barrelPath, `${linhas.join('\n')}\n`, 'utf-8');
@@ -830,4 +921,3 @@ export async function gerarBarrels(baseDir, dryRun = false) {
     }
     return resultado;
 }
-//# sourceMappingURL=reorganize-barrels.js.map