Na minha implementação eu decidi fazer uma leitura de todos os .txt de um diretório e realizando o teste com ele vazio eu queria jogar um erro através deste if (arquivosTxt.length === 0) minha dificuldade foi usar a trataErros do arquivo funcoesErros.js já que implementamos para receber um erro e o caminho mas no meu if não tenho um erro capturado então decidi jogar o erro diretamente e tratar no bloco catch. Poderia me auxiliar me ajudando a entender como poderia ter utilizado essa função ao invés de simplesmente fazer um throw new no block if.

function trataErros(erro, path, message = '') {
    if (erro.code === 'ENOENT') throw new Error(`Arquivo não encontrado em: ${path}`)
    if (message !== '') throw new Error(`${message}`);
}

// module.exports = trataErros;
export { trataErros };

import fs from 'fs'; // Importa o módulo fs para interagir com o sistema de arquivos
import path from "path";
import { trataErros }  from './erros/funcoesErros.js';
import { exibeResultado } from './index.js'
import { formataArquivoTxt } from './helpers.js';   
import { Command } from 'commander';
import chalk from 'chalk';

const program = new Command();

program
    .name('Palavras-repetidas')
    .description('Conta quantas palavras repitidas existem em cada parágrafo')
    .version('0.0.1')
    .option('-e, --entrada <string>', 'diretório onde os arquivos de textos estão')
    .option('-d, --destino <string>', 'diretório onde arquivos devem ser salvos')
    .action((options) => {
        const { entrada, destino } = options;
        if(!entrada || !destino) {
            console.error(chalk.red('Erro: favor inserir diretórios de origem e destino'));
            program.help();
            return;
        }
        // Biblioteca nativa do .JS necessaria para o commander resolve() promise async
        const caminhoEntrada = path.resolve(entrada);
        const caminhoSaida = path.resolve(destino);

        processaArquivos(caminhoEntrada, caminhoSaida)
        .then(() => {
            console.log(chalk.green('Todos os arquivos foram processados e salvos.'));
        })
        .catch(erro => {
            console.log(chalk.red(`Erro: ${erro.message}`));
        })
    })

program.parse();

// Lê um arquivo de forma assíncrona e retorna uma Promise
async function lerArquivo(caminho) {
    try {
        const dados = await fs.promises.readFile(caminho, 'utf-8');
        return exibeResultado(dados);
    } catch(erro) {
        trataErros(erro, caminho);         
    }

}
async function processaArquivos(diretorioEntrada, diretorioSaida) {

    try{
        // Garante que o diretório de saída existe
        if (!fs.existsSync(diretorioSaida)) {
            fs.mkdirSync(diretorioSaida, { recursive: true });
        }
        // Lê todos os arquivos do diretório de entrada
        const arquivos = await fs.promises.readdir(diretorioEntrada)
        // Filtra apenas arquivos .txt para processamento
        const arquivosTxt = arquivos.filter(arquivo => arquivo.endsWith('.txt'));
        // Verifica se algum arquivo .txt está presente
        if (arquivosTxt.length === 0) {
            // Erro nenhum arquivo encontrado
            throw new Error(`Nenhum arquivo .txt encontrado no diretório: ${diretorioEntrada}`);
        }

        const promessas = arquivosTxt.map(async (file) => {
            const caminhoArquivo = `${diretorioEntrada}/${file}`;
            const arquivoSaida = file.replace('.txt', '-resultado.txt');
            const caminhoSaida = `${diretorioSaida}/${arquivoSaida}`
            const resultado = await lerArquivo(caminhoArquivo);

            if(resultado) {
                await criaSalvaArquivo(resultado, caminhoSaida);
            }
        })    
        // Aguarda a conclusão de todas as promessas
        await Promise.all(promessas);
    } catch(erro) {
        if (erro.message !== '') {
            throw erro;
        } else {
            trataErros(erro, diretorioEntrada, `Erro ao processar o diretório de entrada: ${diretorioEntrada}`);
            throw erro;
        }
    }
}
// Função para salvar o resultado em um arquivo
async function criaSalvaArquivo(resultado, caminhoSaida) {
    try {
        const texto = formataArquivoTxt(resultado);
        await fs.promises.writeFile(caminhoSaida, texto, 'utf-8');
        console.log(chalk.green(`Arquivo salvo com sucesso! em: ${caminhoSaida}`));
    } catch(erro) {
        throw new Error(chalk.red(`Erro ao salvar o arquivo em: ${caminhoSaida}`));
    }
    
}