i18n-llm-translate/engines/ml/google_.js

Automatically translates namespace-based JSON translation files across multiple languages from any source language

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createGoogleTranslateEngine = createGoogleTranslateEngine;
const util_1 = require("../../util");
const logger_1 = require("../../logger");
function createGoogleTranslateEngine(config) {
    if (!config.apiKey) {
        throw new Error('Google Translate > Missing apiKey');
    }
    const API_BASE = 'https://translation.googleapis.com/language/translate/v2';
    function fetchTranslations(targetLanguageCode, translations, options) {
        return __awaiter(this, void 0, void 0, function* () {
            const url = new URL(API_BASE);
            url.searchParams.append('key', config.apiKey);
            const body = {
                q: translations,
                target: targetLanguageCode,
                source: options.baseLanguageCode,
                format: 'text'
            };
            const result = yield fetch(url.toString(), {
                body: JSON.stringify(body),
                headers: {
                    'Content-Type': 'application/json',
                },
                method: 'POST',
            });
            if (!result.ok) {
                const errorText = yield result.text();
                throw new Error(`Google Translate API error: ${result.status}\n${errorText}`);
            }
            return JSON.parse(yield result.text());
        });
    }
    return {
        name: 'Google Translate',
        type: 'ml',
        canBeTrustedWithVariablesTranslation: false,
        translate(translations, options) {
            return __awaiter(this, void 0, void 0, function* () {
                const flatTranslations = (0, util_1.flattenObject)(translations);
                const languagesTranslations = {};
                const logger = options.logger || logger_1.defaultLogger;
                for (let targetLanguageCode of options.targetLanguageCodes) {
                    logger.engineDebug('Google Translate', `Translating '${options.baseLanguageCode}' > '${targetLanguageCode}'`);
                    const baseTranslationsValues = Object.values(flatTranslations);
                    const result = yield fetchTranslations(targetLanguageCode, baseTranslationsValues, options);
                    const languageTranslations = {};
                    const keys = Object.keys(flatTranslations);
                    for (let i = 0; i < result.data.translations.length; i++) {
                        languageTranslations[keys[i]] = result.data.translations[i].translatedText;
                    }
                    languagesTranslations[targetLanguageCode] = (0, util_1.unflattenObject)(languageTranslations);
                }
                return languagesTranslations;
            });
        },
        translateMissed(missingTranslations, options) {
            return __awaiter(this, void 0, void 0, function* () {
                const flatBaseTranslations = (0, util_1.flattenObject)(missingTranslations.baseLanguageTranslations);
                const languagesTranslations = {};
                const logger = options.logger || logger_1.defaultLogger;
                for (let targetLanguageCode in missingTranslations.targetLanguageTranslationsKeys) {
                    logger.engineDebug('Google Translate', `Translating '${options.baseLanguageCode}' > '${targetLanguageCode}'`);
                    const missingKeys = Object.keys((0, util_1.flattenObject)(missingTranslations.targetLanguageTranslationsKeys[targetLanguageCode]));
                    const missingValues = [];
                    for (let missingKey of missingKeys) {
                        missingValues.push(flatBaseTranslations[missingKey]);
                    }
                    const result = yield fetchTranslations(targetLanguageCode, missingValues, options);
                    const languageTranslations = {};
                    for (let i = 0; i < result.data.translations.length; i++) {
                        languageTranslations[missingKeys[i]] = result.data.translations[i].translatedText;
                    }
                    languagesTranslations[targetLanguageCode] = (0, util_1.unflattenObject)(languageTranslations);
                }
                return languagesTranslations;
            });
        },
        estimatePrice(usage) {
            if (!('charactersCount' in usage))
                return undefined;
            const { charactersCount } = usage;
            if (charactersCount === 0) {
                return undefined;
            }
            // Google Cloud Translation API pricing (as of 2024):
            // - $20 per 1M characters for text translation
            const PRICE_PER_MILLION_CHARS = 20; // USD
            const CHARS_PER_MILLION = 1000000;
            const millionsOfChars = charactersCount / CHARS_PER_MILLION;
            const estimatedCost = millionsOfChars * PRICE_PER_MILLION_CHARS;
            return `~$${estimatedCost.toFixed(4)}`;
        }
    };
}