@umituz/react-native-google-translate 1.0.3 → 1.0.5

package/dist/domain/entities/Language.entity.js

@@ -0,0 +1,5 @@
+/**
+ * Language Entity
+ * @description Language code mappings and metadata
+ */
+export {};

package/dist/domain/entities/Translation.entity.js

@@ -0,0 +1,5 @@
+/**
+ * Translation Entity
+ * @description Represents a translation request and response
+ */
+export {};

package/dist/domain/entities/index.js

@@ -0,0 +1,5 @@
+/**
+ * Domain Entities
+ * @description Exports all entity types
+ */
+export {};

package/dist/domain/index.js

@@ -0,0 +1,8 @@
+/**
+ * Domain Layer
+ * @description Subpath: @umituz/react-native-google-translate/core
+ *
+ * Exports all domain entities and interfaces
+ */
+export * from "./entities";
+export * from "./interfaces";

package/dist/domain/interfaces/ITranslationService.interface.js

@@ -0,0 +1,5 @@
+/**
+ * Translation Service Interface
+ * @description Defines the contract for translation services
+ */
+export {};

package/dist/domain/interfaces/index.js

@@ -0,0 +1,5 @@
+/**
+ * Domain Interfaces
+ * @description Exports all interface definitions
+ */
+export {};

package/dist/infrastructure/constants/api.constants.js

@@ -0,0 +1,8 @@
+/**
+ * API Constants
+ * @description Google Translate API configuration
+ */
+export const GOOGLE_TRANSLATE_API_URL = "https://translate.googleapis.com/translate_a/single";
+export const DEFAULT_TIMEOUT = 10000;
+export const DEFAULT_MIN_DELAY = 100;
+export const DEFAULT_MAX_RETRIES = 3;

package/dist/infrastructure/constants/index.js

@@ -0,0 +1,6 @@
+/**
+ * Infrastructure Constants
+ * @description Exports all constant definitions
+ */
+export { LANGUAGE_MAP, SKIP_WORDS, LANGUAGE_NAMES, } from "./languages.constants";
+export { GOOGLE_TRANSLATE_API_URL, DEFAULT_TIMEOUT, DEFAULT_MIN_DELAY, DEFAULT_MAX_RETRIES, } from "./api.constants";

package/dist/infrastructure/constants/languages.constants.js

@@ -0,0 +1,96 @@
+/**
+ * Language Constants
+ * @description Language mappings and metadata
+ */
+export const LANGUAGE_MAP = {
+    "ar-SA": "ar",
+    "bg-BG": "bg",
+    "cs-CZ": "cs",
+    "da-DK": "da",
+    "de-DE": "de",
+    "el-GR": "el",
+    "en-AU": "en",
+    "en-CA": "en",
+    "en-GB": "en",
+    "es-ES": "es",
+    "es-MX": "es",
+    "fi-FI": "fi",
+    "fr-CA": "fr",
+    "fr-FR": "fr",
+    "hi-IN": "hi",
+    "hr-HR": "hr",
+    "hu-HU": "hu",
+    "id-ID": "id",
+    "it-IT": "it",
+    "ja-JP": "ja",
+    "ko-KR": "ko",
+    "ms-MY": "ms",
+    "nl-NL": "nl",
+    "no-NO": "no",
+    "pl-PL": "pl",
+    "pt-BR": "pt",
+    "pt-PT": "pt",
+    "ro-RO": "ro",
+    "ru-RU": "ru",
+    "sk-SK": "sk",
+    "sl-SI": "sl",
+    "sv-SE": "sv",
+    "th-TH": "th",
+    "tl-PH": "tl",
+    "tr-TR": "tr",
+    "uk-UA": "uk",
+    "vi-VN": "vi",
+    "zh-CN": "zh-CN",
+    "zh-TW": "zh-TW",
+};
+export const SKIP_WORDS = new Set([
+    "Google",
+    "Apple",
+    "Facebook",
+    "Instagram",
+    "Twitter",
+    "YouTube",
+    "WhatsApp",
+]);
+export const LANGUAGE_NAMES = {
+    "ar-SA": "Arabic (Saudi Arabia)",
+    "bg-BG": "Bulgarian",
+    "cs-CZ": "Czech",
+    "da-DK": "Danish",
+    "de-DE": "German",
+    "el-GR": "Greek",
+    "en-AU": "English (Australia)",
+    "en-CA": "English (Canada)",
+    "en-GB": "English (UK)",
+    "en-US": "English (US)",
+    "es-ES": "Spanish (Spain)",
+    "es-MX": "Spanish (Mexico)",
+    "fi-FI": "Finnish",
+    "fr-CA": "French (Canada)",
+    "fr-FR": "French (France)",
+    "hi-IN": "Hindi",
+    "hr-HR": "Croatian",
+    "hu-HU": "Hungarian",
+    "id-ID": "Indonesian",
+    "it-IT": "Italian",
+    "ja-JP": "Japanese",
+    "ko-KR": "Korean",
+    "ms-MY": "Malay",
+    "nl-NL": "Dutch",
+    "no-NO": "Norwegian",
+    "pl-PL": "Polish",
+    "pt-BR": "Portuguese (Brazil)",
+    "pt-PT": "Portuguese (Portugal)",
+    "ro-RO": "Romanian",
+    "ru-RU": "Russian",
+    "sk-SK": "Slovak",
+    "sl-SI": "Slovenian",
+    "sv-SE": "Swedish",
+    "th-TH": "Thai",
+    "tl-PH": "Tagalog",
+    "tr-TR": "Turkish",
+    "uk-UA": "Ukrainian",
+    "vi-VN": "Vietnamese",
+    "zh-CN": "Chinese (Simplified)",
+    "zh-TW": "Chinese (Traditional)",
+};

package/dist/infrastructure/services/GoogleTranslate.service.js

@@ -0,0 +1,200 @@
+/**
+ * Google Translate Service
+ * @description Main translation service using Google Translate API
+ */
+import { RateLimiter } from "../utils/rateLimit.util";
+import { shouldSkipWord, needsTranslation, isValidText, } from "../utils/textValidator.util";
+import { GOOGLE_TRANSLATE_API_URL, DEFAULT_MIN_DELAY, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT, } from "../constants";
+class GoogleTranslateService {
+    config = null;
+    rateLimiter = null;
+    initialize(config) {
+        this.config = {
+            minDelay: DEFAULT_MIN_DELAY,
+            maxRetries: DEFAULT_MAX_RETRIES,
+            timeout: DEFAULT_TIMEOUT,
+            ...config,
+        };
+        this.rateLimiter = new RateLimiter(this.config.minDelay);
+    }
+    isInitialized() {
+        return this.config !== null && this.rateLimiter !== null;
+    }
+    ensureInitialized() {
+        if (!this.isInitialized()) {
+            throw new Error("GoogleTranslateService is not initialized. Call initialize() first.");
+        }
+    }
+    async translate(request) {
+        this.ensureInitialized();
+        const { text, targetLanguage, sourceLanguage = "en" } = request;
+        if (!isValidText(text) || shouldSkipWord(text)) {
+            return {
+                originalText: text,
+                translatedText: text,
+                sourceLanguage,
+                targetLanguage,
+                success: true,
+            };
+        }
+        if (!targetLanguage || targetLanguage.trim().length === 0) {
+            return {
+                originalText: text,
+                translatedText: text,
+                sourceLanguage,
+                targetLanguage,
+                success: false,
+                error: "Invalid target language",
+            };
+        }
+        // After ensureInitialized(), rateLimiter is guaranteed to be non-null
+        await this.rateLimiter.waitForSlot();
+        try {
+            const translatedText = await this.callTranslateAPI(text, targetLanguage, sourceLanguage);
+            return {
+                originalText: text,
+                translatedText,
+                sourceLanguage,
+                targetLanguage,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                originalText: text,
+                translatedText: text,
+                sourceLanguage,
+                targetLanguage,
+                success: false,
+                error: error instanceof Error ? error.message : "Unknown error",
+            };
+        }
+    }
+    async translateBatch(requests) {
+        this.ensureInitialized();
+        if (!Array.isArray(requests) || requests.length === 0) {
+            return {
+                totalCount: 0,
+                successCount: 0,
+                failureCount: 0,
+                skippedCount: 0,
+                translatedKeys: [],
+            };
+        }
+        const stats = {
+            totalCount: requests.length,
+            successCount: 0,
+            failureCount: 0,
+            skippedCount: 0,
+            translatedKeys: [],
+        };
+        for (const request of requests) {
+            const result = await this.translate(request);
+            if (result.success) {
+                if (result.translatedText === result.originalText) {
+                    stats.skippedCount++;
+                }
+                else {
+                    stats.successCount++;
+                    stats.translatedKeys.push({
+                        key: request.text,
+                        from: result.originalText,
+                        to: result.translatedText,
+                    });
+                }
+            }
+            else {
+                stats.failureCount++;
+            }
+        }
+        return stats;
+    }
+    async translateObject(sourceObject, targetObject, targetLanguage, path = "", stats = {
+        totalCount: 0,
+        successCount: 0,
+        failureCount: 0,
+        skippedCount: 0,
+        translatedKeys: [],
+    }) {
+        if (!sourceObject || typeof sourceObject !== "object") {
+            return;
+        }
+        if (!targetObject || typeof targetObject !== "object") {
+            return;
+        }
+        if (!targetLanguage || targetLanguage.trim().length === 0) {
+            return;
+        }
+        const keys = Object.keys(sourceObject);
+        for (const key of keys) {
+            const enValue = sourceObject[key];
+            const targetValue = targetObject[key];
+            const currentPath = path ? `${path}.${key}` : key;
+            if (typeof enValue === "object" && enValue !== null) {
+                if (!targetObject[key] ||
+                    typeof targetObject[key] !== "object") {
+                    targetObject[key] = {};
+                }
+                await this.translateObject(enValue, targetObject[key], targetLanguage, currentPath, stats);
+            }
+            else if (typeof enValue === "string") {
+                stats.totalCount++;
+                if (needsTranslation(targetValue, enValue)) {
+                    const request = {
+                        text: enValue,
+                        targetLanguage,
+                    };
+                    const result = await this.translate(request);
+                    if (result.success && result.translatedText !== enValue) {
+                        targetObject[key] = result.translatedText;
+                        stats.successCount++;
+                        stats.translatedKeys.push({
+                            key: currentPath,
+                            from: enValue,
+                            to: result.translatedText,
+                        });
+                    }
+                    else if (!result.success) {
+                        stats.failureCount++;
+                    }
+                    else {
+                        stats.skippedCount++;
+                    }
+                }
+                else {
+                    stats.skippedCount++;
+                }
+            }
+        }
+    }
+    async callTranslateAPI(text, targetLanguage, sourceLanguage) {
+        const timeout = this.config?.timeout || DEFAULT_TIMEOUT;
+        const encodedText = encodeURIComponent(text);
+        const url = `${GOOGLE_TRANSLATE_API_URL}?client=gtx&sl=${sourceLanguage}&tl=${targetLanguage}&dt=t&q=${encodedText}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(url, {
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`API request failed: ${response.status}`);
+            }
+            const data = await response.json();
+            // Type guard for Google Translate API response structure
+            if (Array.isArray(data) &&
+                data.length > 0 &&
+                Array.isArray(data[0]) &&
+                data[0].length > 0 &&
+                Array.isArray(data[0][0]) &&
+                typeof data[0][0][0] === "string") {
+                return data[0][0][0];
+            }
+            return text;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+export const googleTranslateService = new GoogleTranslateService();

package/dist/infrastructure/services/index.js

@@ -0,0 +1,7 @@
+/**
+ * Infrastructure Services
+ * @description Exports all services and utilities
+ */
+export { googleTranslateService } from "./GoogleTranslate.service";
+export { shouldSkipWord, needsTranslation, isValidText, getTargetLanguage, isEnglishVariant, getLanguageDisplayName, } from "../utils/textValidator.util";
+export { LANGUAGE_MAP, SKIP_WORDS, LANGUAGE_NAMES, } from "../constants/languages.constants";

package/dist/infrastructure/utils/rateLimit.util.js

@@ -0,0 +1,23 @@
+/**
+ * Rate Limit Utility
+ * @description Handles rate limiting for API requests
+ */
+export class RateLimiter {
+    lastCallTime = 0;
+    minDelay;
+    constructor(minDelay = 100) {
+        this.minDelay = minDelay;
+    }
+    async waitForSlot() {
+        const now = Date.now();
+        const elapsed = now - this.lastCallTime;
+        const waitTime = Math.max(0, this.minDelay - elapsed);
+        if (waitTime > 0) {
+            await new Promise((resolve) => setTimeout(resolve, waitTime));
+        }
+        this.lastCallTime = Date.now();
+    }
+    reset() {
+        this.lastCallTime = 0;
+    }
+}

package/dist/infrastructure/utils/textValidator.util.js

@@ -0,0 +1,50 @@
+/**
+ * Text Validator Utility
+ * @description Validates text for translation eligibility
+ */
+import { SKIP_WORDS, LANGUAGE_MAP, LANGUAGE_NAMES } from "../constants";
+export function shouldSkipWord(word) {
+    return SKIP_WORDS.has(word);
+}
+export function needsTranslation(value, enValue) {
+    if (typeof enValue !== "string" || !enValue.trim()) {
+        return false;
+    }
+    if (shouldSkipWord(enValue)) {
+        return false;
+    }
+    // Skip technical keys (e.g., "scenario.xxx.title")
+    const isTechnicalKey = enValue.includes(".") && !enValue.includes(" ");
+    if (isTechnicalKey) {
+        return false;
+    }
+    // If value is missing or same as English, it needs translation
+    if (!value || typeof value !== "string") {
+        return true;
+    }
+    if (value === enValue) {
+        const isSingleWord = !enValue.includes(" ") && enValue.length < 20;
+        return !isSingleWord;
+    }
+    // Detect outdated template patterns (e.g., {{appName}}, {{variable}})
+    if (typeof value === "string") {
+        const hasTemplatePattern = value.includes("{{") && value.includes("}}");
+        if (hasTemplatePattern && !enValue.includes("{{")) {
+            return true;
+        }
+    }
+    return false;
+}
+export function isValidText(text) {
+    return typeof text === "string" && text.length > 0;
+}
+export function getTargetLanguage(langCode) {
+    return LANGUAGE_MAP[langCode];
+}
+export function isEnglishVariant(langCode) {
+    const targetLang = getTargetLanguage(langCode);
+    return targetLang === "en";
+}
+export function getLanguageDisplayName(code) {
+    return LANGUAGE_NAMES[code] || code;
+}

package/dist/scripts/index.js

@@ -0,0 +1,8 @@
+/**
+ * Translation Scripts
+ * Scripts for translating and synchronizing localization files
+ */
+export * from './translate';
+export * from './sync';
+export * from './setup';
+export * from './utils';

package/dist/scripts/setup.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+/**
+ * Setup Languages Script
+ * Creates stub files for all supported languages (if not exist),
+ * then generates index.ts from all available translation files.
+ * Usage: node setup.ts [locales-dir]
+ */
+import fs from 'fs';
+import path from 'path';
+import { LANGUAGE_MAP, getLanguageDisplayName } from '../infrastructure/services';
+export function setupLanguages(options) {
+    const { targetDir } = options;
+    const localesDir = path.resolve(process.cwd(), targetDir);
+    if (!fs.existsSync(localesDir)) {
+        console.error(`❌ Locales directory not found: ${localesDir}`);
+        return false;
+    }
+    // Create stub files for all supported languages that don't exist yet
+    let created = 0;
+    for (const langCode of Object.keys(LANGUAGE_MAP)) {
+        // Skip English variants — en-US is the base, others (en-AU, en-GB) are redundant
+        if (langCode.startsWith('en-') && langCode !== 'en-US')
+            continue;
+        const filePath = path.join(localesDir, `${langCode}.ts`);
+        if (!fs.existsSync(filePath)) {
+            const langName = getLanguageDisplayName(langCode);
+            fs.writeFileSync(filePath, `/**\n * ${langName} Translations\n * Auto-synced from en-US.ts\n */\n\nexport default {};\n`);
+            console.log(`   ✅ Created ${langCode}.ts (${langName})`);
+            created++;
+        }
+    }
+    if (created > 0) {
+        console.log(`\n📦 Created ${created} new language stubs.\n`);
+    }
+    // Generate index.ts from all language files
+    const files = fs.readdirSync(localesDir)
+        .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/))
+        .sort();
+    const imports = [];
+    const exports = [];
+    files.forEach(file => {
+        const code = file.replace('.ts', '');
+        const varName = code.replace(/-([a-z0-9])/g, (g) => g[1].toUpperCase()).replace('-', '');
+        imports.push(`import ${varName} from "./${code}";`);
+        exports.push(`  "${code}": ${varName},`);
+    });
+    const content = `/**
+ * Localization Index
+ * Exports all available translation files
+ * Auto-generated by scripts/setup.ts
+ */
+
+${imports.join('\n')}
+
+export const translations = {
+${exports.join('\n')}
+};
+
+export type TranslationKey = keyof typeof translations;
+
+export default translations;
+`;
+    fs.writeFileSync(path.join(localesDir, 'index.ts'), content);
+    console.log(`✅ Generated index.ts with ${files.length} languages`);
+    return true;
+}
+// CLI interface
+export function runSetupLanguages() {
+    const targetDir = process.argv[2] || 'src/infrastructure/locales';
+    console.log('🚀 Setting up language files...\n');
+    setupLanguages({ targetDir });
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runSetupLanguages();
+}

package/dist/scripts/sync.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+/**
+ * Sync Translations Script
+ * Synchronizes translation keys from en-US.ts to all other language files
+ */
+import fs from 'fs';
+import path from 'path';
+import { parseTypeScriptFile, generateTypeScriptContent, } from './utils/file-parser';
+import { addMissingKeys, removeExtraKeys, } from './utils/sync-helper';
+import { detectNewKeys } from './utils/key-detector';
+import { extractUsedKeys } from './utils/key-extractor';
+import { setDeep, countKeys } from './utils/object-helper';
+export function syncLanguageFile(enUSPath, targetPath, langCode) {
+    const enUS = parseTypeScriptFile(enUSPath);
+    let target;
+    try {
+        target = parseTypeScriptFile(targetPath);
+    }
+    catch {
+        target = {};
+    }
+    const detectedNewKeys = detectNewKeys(enUS, target);
+    const addStats = { added: 0, newKeys: [] };
+    const removeStats = { removed: 0, removedKeys: [] };
+    addMissingKeys(enUS, target, addStats);
+    removeExtraKeys(enUS, target, removeStats);
+    const changed = (addStats.added || 0) > 0 || (removeStats.removed || 0) > 0;
+    if (changed) {
+        const content = generateTypeScriptContent(target, langCode);
+        fs.writeFileSync(targetPath, content);
+    }
+    return {
+        added: addStats.added,
+        newKeys: addStats.newKeys,
+        removed: removeStats.removed,
+        removedKeys: removeStats.removedKeys,
+        changed,
+        detectedNewKeys,
+    };
+}
+function processExtraction(srcDir, enUSPath) {
+    if (!srcDir)
+        return;
+    console.log(`🔍 Scanning source code and dependencies: ${srcDir}...`);
+    const usedKeyMap = extractUsedKeys(srcDir);
+    console.log(`   Found ${usedKeyMap.size} unique keys.`);
+    const oldEnUS = parseTypeScriptFile(enUSPath);
+    const newEnUS = {};
+    let addedCount = 0;
+    for (const [key, defaultValue] of usedKeyMap) {
+        // Try to keep existing translation if it exists
+        const existingValue = key.split('.').reduce((obj, k) => {
+            if (obj && typeof obj === 'object' && k in obj) {
+                return obj[k];
+            }
+            return undefined;
+        }, oldEnUS);
+        // We treat it as "not translated" if the value is exactly the key string
+        const isActuallyTranslated = typeof existingValue === 'string' && existingValue !== key;
+        const valueToSet = isActuallyTranslated ? existingValue : defaultValue;
+        if (setDeep(newEnUS, key, valueToSet)) {
+            if (!isActuallyTranslated)
+                addedCount++;
+        }
+    }
+    const oldTotal = countKeys(oldEnUS);
+    const newTotal = countKeys(newEnUS);
+    const removedCount = Math.max(0, oldTotal - (newTotal - addedCount));
+    console.log(`   ✨ Optimized en-US.ts: ${addedCount} keys populated/updated, pruned ${removedCount} unused.`);
+    const content = generateTypeScriptContent(newEnUS, 'en-US');
+    fs.writeFileSync(enUSPath, content);
+}
+export function syncTranslations(options) {
+    const { targetDir, srcDir } = options;
+    const localesDir = path.resolve(process.cwd(), targetDir);
+    const enUSPath = path.join(localesDir, 'en-US.ts');
+    if (!fs.existsSync(localesDir) || !fs.existsSync(enUSPath)) {
+        console.error(`❌ Localization files not found in: ${localesDir}`);
+        return false;
+    }
+    processExtraction(srcDir, enUSPath);
+    const files = fs.readdirSync(localesDir)
+        .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== 'en-US.ts')
+        .sort();
+    console.log(`📊 Languages to sync: ${files.length}\n`);
+    files.forEach(file => {
+        const langCode = file.replace('.ts', '');
+        const targetPath = path.join(localesDir, file);
+        const result = syncLanguageFile(enUSPath, targetPath, langCode);
+        if (result.changed) {
+            console.log(`   🌍 ${langCode}: ✏️  +${result.added || 0} keys, -${result.removed || 0} keys`);
+        }
+    });
+    console.log(`\n✅ Synchronization completed!`);
+    return true;
+}
+// CLI interface
+export function runSyncTranslations() {
+    const targetDir = process.argv[2] || 'src/infrastructure/locales';
+    const srcDir = process.argv[3];
+    console.log('🚀 Starting translation synchronization...\n');
+    syncTranslations({ targetDir, srcDir });
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runSyncTranslations();
+}