mute-english-api/src/services/baiduTranslate.js

提供英语词典和百度翻译等API服务的npm包，支持多种翻译服务集成

/**
 * 百度翻译服务模块
 * 提供文本翻译功能
 */

import configManager from '../config/index.js';
import { MD5 } from '../utils/crypto.js';

/**
 * 百度翻译API函数
 * @param {string} query - 需要翻译的文本，多个query可以用\n连接
 * @param {string} from - 源语言，默认为'en'
 * @param {string} to - 目标语言，默认为'zh'
 * @returns {Promise<Object>} - 翻译结果
 */
export async function translateText(query, from = 'en', to = 'zh') {
    try {
        // 参数验证
        if (!query || typeof query !== 'string') {
            throw new Error('query参数不能为空且必须是字符串');
        }

        if (!configManager.validateBaiduTranslateConfig()) {
            throw new Error('请先使用 setBaiduTranslateConfig() 设置百度翻译API的APPID和KEY，或通过环境变量 BAIDU_TRANSLATE_APPID 和 BAIDU_TRANSLATE_KEY 设置');
        }

        const config = configManager.getBaiduTranslateConfig();
        
        // 生成时间戳作为salt
        const salt = Date.now().toString();
        
        // 生成签名
        const str1 = config.appid + query + salt + config.key;
        const sign = MD5(str1);

        // 构建请求参数
        const params = new URLSearchParams({
            q: query,
            appid: config.appid,
            salt: salt,
            from: from,
            to: to,
            sign: sign
        });

        // 发送请求
        const response = await fetch(`${config.apiUrl}?${params}`, {
            method: 'GET',
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded'
            }
        });

        if (!response.ok) {
            throw new Error(`HTTP错误: ${response.status}`);
        }

        const result = await response.json();

        // 检查API返回的错误
        if (result.error_code) {
            throw new Error(`百度翻译API错误: ${result.error_code} - ${result.error_msg}`);
        }

        return {
            success: true,
            data: result,
            translated: result.trans_result?.map(item => item.dst).join('\n') || ''
        };

    } catch (error) {
        console.error('翻译失败:', error);
        return {
            success: false,
            error: error.message,
            data: null,
            translated: ''
        };
    }
}

/**
 * 设置百度翻译API配置
 * @param {string} appid - 百度翻译API的APPID
 * @param {string} key - 百度翻译API的KEY
 */
export function setBaiduTranslateConfig(appid, key) {
    configManager.setBaiduTranslateConfig(appid, key);
}

/**
 * 获取百度翻译支持的语言列表
 * @returns {Object} 支持的语言代码和名称映射
 */
export function getSupportedLanguages() {
    const config = configManager.getBaiduTranslateConfig();
    return config.supportedLanguages;
}

/**
 * 验证语言代码是否受支持
 * @param {string} langCode - 语言代码
 * @returns {boolean} 是否支持该语言
 */
export function isLanguageSupported(langCode) {
    const supportedLanguages = getSupportedLanguages();
    return langCode in supportedLanguages;
}

/**
 * 批量翻译函数
 * @param {Array<string>} queries - 需要翻译的文本数组
 * @param {string} from - 源语言，默认为'en'
 * @param {string} to - 目标语言，默认为'zh'
 * @param {number} delay - 请求间隔时间(毫秒)，默认1000ms，避免频率限制
 * @returns {Promise<Array>} - 翻译结果数组
 */
export async function batchTranslate(queries, from = 'en', to = 'zh', delay = null) {
    if (!Array.isArray(queries)) {
        throw new Error('queries参数必须是数组');
    }

    const config = configManager.getBaiduTranslateConfig();
    const actualDelay = delay !== null ? delay : config.defaults.delay;
    const results = [];
    
    for (let i = 0; i < queries.length; i++) {
        const result = await translateText(queries[i], from, to);
        results.push(result);
        
        // 添加延迟，避免API频率限制
        if (i < queries.length - 1) {
            await new Promise(resolve => setTimeout(resolve, actualDelay));
        }
    }
    
    return results;
}

/**
 * 检测文本语言（通过百度翻译API）
 * @param {string} text - 需要检测的文本
 * @returns {Promise<Object>} - 检测结果
 */
export async function detectLanguage(text) {
    const result = await translateText(text, 'auto', 'en');
    if (result.success && result.data && result.data.from) {
        return {
            success: true,
            language: result.data.from,
            languageName: getSupportedLanguages()[result.data.from] || '未知语言'
        };
    }
    return {
        success: false,
        error: '语言检测失败'
    };
}

// 导出默认对象以保持兼容性
export default {
    translateText,
    setBaiduTranslateConfig,
    getSupportedLanguages,
    isLanguageSupported,
    batchTranslate,
    detectLanguage
};