@umituz/react-native-google-translate 1.0.4 → 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();
+}

package/dist/scripts/translate.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * Translate Missing Script
+ * Automatically translates missing strings using Google Translate
+ */
+import fs from 'fs';
+import path from 'path';
+import { parseTypeScriptFile, generateTypeScriptContent, } from './utils/file-parser';
+import { googleTranslateService, getTargetLanguage, getLanguageDisplayName } from '../infrastructure/services';
+// Width of terminal line to clear for progress updates
+const PROGRESS_LINE_WIDTH = 80;
+export async function translateMissing(options) {
+    const { targetDir, srcDir, skipSync = false } = options;
+    // Initialize the translation service
+    googleTranslateService.initialize({
+        minDelay: 100,
+        maxRetries: 3,
+        timeout: 10000,
+    });
+    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;
+    }
+    const files = fs.readdirSync(localesDir)
+        .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== 'en-US.ts')
+        .sort();
+    console.log(`\n📊 Languages to translate: ${files.length}\n`);
+    const enUS = parseTypeScriptFile(enUSPath);
+    for (const file of files) {
+        const langCode = file.replace('.ts', '');
+        // Skip English variants
+        const targetLang = getTargetLanguage(langCode);
+        if (!targetLang || targetLang === 'en') {
+            console.log(`⏭️  Skipping ${langCode} (English variant)`);
+            continue;
+        }
+        const langName = getLanguageDisplayName(langCode);
+        console.log(`🌍 Translating ${langCode} (${langName})...`);
+        const targetPath = path.join(localesDir, file);
+        const target = parseTypeScriptFile(targetPath);
+        const stats = {
+            totalCount: 0,
+            successCount: 0,
+            failureCount: 0,
+            skippedCount: 0,
+            translatedKeys: [],
+        };
+        await googleTranslateService.translateObject(enUS, target, targetLang, '', stats);
+        // Clear progress line
+        process.stdout.write('\r' + ' '.repeat(PROGRESS_LINE_WIDTH) + '\r');
+        if (stats.successCount > 0) {
+            const content = generateTypeScriptContent(target, langCode);
+            fs.writeFileSync(targetPath, content);
+            console.log(`      ✅ Successfully translated ${stats.successCount} keys:`);
+            // Detailed logging of translated keys
+            const displayCount = Math.min(stats.translatedKeys.length, 15);
+            stats.translatedKeys.slice(0, displayCount).forEach(item => {
+                console.log(`         • ${item.key}: "${item.from}" → "${item.to}"`);
+            });
+            if (stats.translatedKeys.length > displayCount) {
+                console.log(`         ... and ${stats.translatedKeys.length - displayCount} more.`);
+            }
+        }
+        else {
+            console.log(`      ✨ Already up to date.`);
+        }
+    }
+    console.log('\n✅ All translations completed!');
+}
+// CLI interface
+export function runTranslateMissing() {
+    const args = process.argv.slice(2).filter(arg => !arg.startsWith('--'));
+    const targetDir = args[0] || 'src/infrastructure/locales';
+    const srcDir = args[1];
+    const skipSync = process.argv.includes('--no-sync');
+    console.log('🚀 Starting integrated translation workflow...');
+    translateMissing({ targetDir, srcDir, skipSync }).catch(err => {
+        console.error('\n❌ Translation workflow failed:', err.message);
+        process.exit(1);
+    });
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runTranslateMissing();
+}

package/dist/scripts/utils/file-parser.js

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import path from 'path';
+import { getLanguageDisplayName } from '../../infrastructure/utils/textValidator.util';
+/**
+ * File Parser
+ * Parse and generate TypeScript translation files
+ */
+export function parseTypeScriptFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    // Match: export default { ... } OR export const NAME = { ... }
+    const match = content.match(/export\s+(?:default|const\s+\w+\s*=)\s*(\{[\s\S]*\});?\s*$/);
+    if (!match) {
+        throw new Error(`Could not parse TypeScript file: ${filePath}`);
+    }
+    const objectStr = match[1].replace(/;$/, '');
+    try {
+        // Basic evaluation for simple objects (safe for generated translation files)
+        // Only contains string literals, numbers, booleans, and nested objects
+        // eslint-disable-next-line no-eval
+        return eval(`(${objectStr})`);
+    }
+    catch (error) {
+        // File might be a barrel file with named imports
+        const dir = path.dirname(filePath);
+        const importMatches = [...content.matchAll(/import\s*\{\s*(\w+)\s*\}\s*from\s*["']\.\/(\w+)["']/g)];
+        if (importMatches.length > 0) {
+            const result = {};
+            for (const [, varName, moduleName] of importMatches) {
+                const subFilePath = path.join(dir, `${moduleName}.ts`);
+                if (fs.existsSync(subFilePath)) {
+                    try {
+                        result[varName] = parseTypeScriptFile(subFilePath);
+                    }
+                    catch (subError) {
+                        // Log sub-file parse errors but continue with other files
+                        console.warn(`Warning: Could not parse sub-file ${subFilePath}: ${subError instanceof Error ? subError.message : 'Unknown error'}`);
+                    }
+                }
+            }
+            if (Object.keys(result).length > 0) {
+                return result;
+            }
+        }
+    }
+    return {};
+}
+export function stringifyValue(value, indent = 2) {
+    if (typeof value === 'string') {
+        const escaped = value
+            .replace(/\\/g, '\\\\')
+            .replace(/"/g, '\\"')
+            .replace(/\n/g, '\\n');
+        return `"${escaped}"`;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '[]';
+        const items = value.map(v => stringifyValue(v, indent + 2));
+        return `[${items.join(', ')}]`;
+    }
+    if (typeof value === 'object' && value !== null) {
+        const entries = Object.entries(value);
+        if (entries.length === 0) {
+            return '{}';
+        }
+        const spaces = ' '.repeat(indent);
+        const innerSpaces = ' '.repeat(indent + 2);
+        const entriesStr = entries
+            .sort((a, b) => a[0].localeCompare(b[0]))
+            .map(([k, v]) => {
+            const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? k : `"${k}"`;
+            return `${innerSpaces}${key}: ${stringifyValue(v, indent + 2)}`;
+        })
+            .join(',\n');
+        return `{\n${entriesStr},\n${spaces}}`;
+    }
+    return String(value);
+}
+export function generateTypeScriptContent(obj, langCode) {
+    const langName = getLanguageDisplayName(langCode);
+    const isBase = langCode === 'en-US';
+    const objString = stringifyValue(obj, 0);
+    return `/**
+ * ${langName} Translations
+ * ${isBase ? 'Base translations file' : 'Auto-synced from en-US.ts'}
+ */
+
+export default ${objString};
+`;
+}

package/dist/scripts/utils/index.js

@@ -0,0 +1,9 @@
+/**
+ * Scripts Utils
+ * Utility functions for translation scripts
+ */
+export * from './file-parser';
+export * from './key-detector';
+export * from './key-extractor';
+export * from './object-helper';
+export * from './sync-helper';

package/dist/scripts/utils/key-detector.js

@@ -0,0 +1,39 @@
+/**
+ * Key Detector
+ * Detects new, missing, and removed keys between source and target objects
+ */
+export function detectNewKeys(sourceObj, targetObj, path = '', newKeys = []) {
+    for (const key in sourceObj) {
+        const currentPath = path ? `${path}.${key}` : key;
+        const sourceValue = sourceObj[key];
+        const targetValue = targetObj[key];
+        if (!Object.prototype.hasOwnProperty.call(targetObj, key)) {
+            newKeys.push({ path: currentPath, value: sourceValue });
+        }
+        else if (typeof sourceValue === 'object' &&
+            sourceValue !== null &&
+            !Array.isArray(sourceValue)) {
+            if (typeof targetValue === 'object' && targetValue !== null && !Array.isArray(targetValue)) {
+                detectNewKeys(sourceValue, targetValue, currentPath, newKeys);
+            }
+        }
+    }
+    return newKeys;
+}
+export function detectMissingKeys(sourceObj, targetObj, path = '', missingKeys = []) {
+    for (const key in targetObj) {
+        const currentPath = path ? `${path}.${key}` : key;
+        if (!Object.prototype.hasOwnProperty.call(sourceObj, key)) {
+            missingKeys.push(currentPath);
+        }
+        else if (typeof sourceObj[key] === 'object' &&
+            sourceObj[key] !== null &&
+            !Array.isArray(sourceObj[key]) &&
+            typeof targetObj[key] === 'object' &&
+            targetObj[key] !== null &&
+            !Array.isArray(targetObj[key])) {
+            detectMissingKeys(sourceObj[key], targetObj[key], currentPath, missingKeys);
+        }
+    }
+    return missingKeys;
+}

package/dist/scripts/utils/key-extractor.js

@@ -0,0 +1,95 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Generic Key Extractor
+ * Scans source code for i18n translation keys
+ */
+const IGNORED_DOMAINS = ['.com', '.org', '.net', '.io', '.co', '.app', '.ai', '.gov', '.edu'];
+const IGNORED_EXTENSIONS = [
+    '.ts', '.tsx', '.js', '.jsx', '.json', '.yaml', '.yml',
+    '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.pdf',
+    '.mp4', '.mov', '.avi', '.mp3', '.wav', '.css', '.scss', '.md'
+];
+const IGNORED_LAYOUT_VALS = new Set([
+    'center', 'row', 'column', 'flex', 'absolute', 'relative', 'hidden', 'visible',
+    'transparent', 'bold', 'normal', 'italic', 'contain', 'cover', 'stretch',
+    'top', 'bottom', 'left', 'right', 'middle', 'auto', 'none', 'underline',
+    'capitalize', 'uppercase', 'lowercase', 'solid', 'dotted', 'dashed', 'wrap',
+    'nowrap', 'space-between', 'space-around', 'flex-start', 'flex-end', 'baseline',
+    'react', 'index', 'default', 'string', 'number', 'boolean', 'key', 'id'
+]);
+function extractFromFile(content, keyMap) {
+    // Pattern 1: t('key') or t("key")
+    const tRegex = /(?:^|\W)t\(['"`]([^'"`]+)['"`]\)/g;
+    let match;
+    while ((match = tRegex.exec(content)) !== null) {
+        const key = match[1];
+        if (!key.includes('${') && !keyMap.has(key)) {
+            keyMap.set(key, key);
+        }
+    }
+    // Pattern 2: Dot-notation strings (potential i18n keys)
+    const dotRegex = /['"`]([a-z][a-z0-9_]*\.(?:[a-z0-9_]+\.)+[a-z0-9_]+)['"`]/gi;
+    while ((match = dotRegex.exec(content)) !== null) {
+        const key = match[1];
+        const isIgnoredDomain = IGNORED_DOMAINS.some(ext => key.toLowerCase().endsWith(ext));
+        const isIgnoredExt = IGNORED_EXTENSIONS.some(ext => key.toLowerCase().endsWith(ext));
+        if (!isIgnoredDomain && !isIgnoredExt && !key.includes(' ') && !keyMap.has(key)) {
+            keyMap.set(key, key);
+        }
+    }
+    // Pattern 3: Template literals t(`prefix.${var}`)
+    const templateRegex = /t\(\`([a-z0-9_.]+)\.\$\{/g;
+    while ((match = templateRegex.exec(content)) !== null) {
+        const prefix = match[1];
+        const arrayMatches = content.matchAll(/\[([\s\S]*?)\]/g);
+        for (const arrayMatch of arrayMatches) {
+            const inner = arrayMatch[1];
+            const idMatches = inner.matchAll(/['"`]([a-z0-9_]{2,40})['"`]/g);
+            for (const idMatch of idMatches) {
+                const id = idMatch[1];
+                if (IGNORED_LAYOUT_VALS.has(id.toLowerCase()))
+                    continue;
+                if (/^[0-9]+$/.test(id))
+                    continue;
+                const dynamicKey = `${prefix}.${id}`;
+                if (!keyMap.has(dynamicKey)) {
+                    keyMap.set(dynamicKey, dynamicKey);
+                }
+            }
+        }
+    }
+}
+function walkDirectory(dir, keyMap, skipDirs = ['node_modules', '.expo', '.git', 'build', 'ios', 'android', 'assets', 'locales', '__tests__']) {
+    if (!fs.existsSync(dir))
+        return;
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        const fullPath = path.join(dir, file);
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+            if (!skipDirs.includes(file)) {
+                walkDirectory(fullPath, keyMap, skipDirs);
+            }
+        }
+        else if (/\.(ts|tsx|js|jsx)$/.test(file)) {
+            const content = fs.readFileSync(fullPath, 'utf8');
+            extractFromFile(content, keyMap);
+        }
+    }
+}
+export function extractUsedKeys(srcDir) {
+    const keyMap = new Map();
+    if (!srcDir)
+        return keyMap;
+    const projectRoot = process.cwd();
+    const absoluteSrcDir = path.resolve(projectRoot, srcDir);
+    // Scan project source
+    walkDirectory(absoluteSrcDir, keyMap);
+    // Scan @umituz packages for shared keys
+    const packagesDir = path.resolve(projectRoot, 'node_modules/@umituz');
+    if (fs.existsSync(packagesDir)) {
+        walkDirectory(packagesDir, keyMap);
+    }
+    return keyMap;
+}

package/dist/scripts/utils/object-helper.js

@@ -0,0 +1,43 @@
+/**
+ * Object Helper
+ * Utilities for deep object manipulation
+ */
+/**
+ * Set a value in a nested object, creating intermediate objects if necessary
+ * Returns true if the key was newly added, false if it already existed
+ */
+export function setDeep(obj, path, value) {
+    const keys = path.split('.');
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (!current[key] || typeof current[key] !== 'object' || Array.isArray(current[key])) {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    if (current[lastKey] === undefined) {
+        current[lastKey] = value;
+        return true;
+    }
+    return false;
+}
+/**
+ * Count all leaf keys in a nested object
+ */
+export function countKeys(obj) {
+    let count = 0;
+    const walk = (o) => {
+        for (const k in o) {
+            if (typeof o[k] === 'object' && o[k] !== null) {
+                walk(o[k]);
+            }
+            else {
+                count++;
+            }
+        }
+    };
+    walk(obj);
+    return count;
+}

package/dist/scripts/utils/sync-helper.js

@@ -0,0 +1,47 @@
+/**
+ * Sync Helper
+ * Helper functions for synchronizing translation keys
+ */
+export function addMissingKeys(sourceObj, targetObj, stats = {}) {
+    stats.added = stats.added || 0;
+    stats.newKeys = stats.newKeys || [];
+    for (const key in sourceObj) {
+        const sourceValue = sourceObj[key];
+        const isNewKey = !Object.prototype.hasOwnProperty.call(targetObj, key);
+        if (isNewKey) {
+            targetObj[key] = sourceValue;
+            stats.added++;
+            stats.newKeys.push(key);
+        }
+        else if (typeof sourceValue === 'object' &&
+            sourceValue !== null &&
+            !Array.isArray(sourceValue)) {
+            if (!targetObj[key] || typeof targetObj[key] !== 'object') {
+                targetObj[key] = {};
+            }
+            addMissingKeys(sourceValue, targetObj[key], stats);
+        }
+    }
+    return stats;
+}
+export function removeExtraKeys(sourceObj, targetObj, stats = {}) {
+    stats.removed = stats.removed || 0;
+    stats.removedKeys = stats.removedKeys || [];
+    for (const key in targetObj) {
+        const isExtraKey = !Object.prototype.hasOwnProperty.call(sourceObj, key);
+        if (isExtraKey) {
+            delete targetObj[key];
+            stats.removed++;
+            stats.removedKeys.push(key);
+        }
+        else if (typeof sourceObj[key] === 'object' &&
+            sourceObj[key] !== null &&
+            !Array.isArray(sourceObj[key]) &&
+            typeof targetObj[key] === 'object' &&
+            targetObj[key] !== null &&
+            !Array.isArray(targetObj[key])) {
+            removeExtraKeys(sourceObj[key], targetObj[key], stats);
+        }
+    }
+    return stats;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-google-translate",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Google Translate integration for React Native apps with rate limiting, batch translation, and TypeScript support",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -16,10 +16,12 @@
     "./*": "./src/*/index.ts"
   },
   "scripts": {
-    "setup": "node src/scripts/setup.ts",
-    "translate": "node src/scripts/translate.ts",
-    "sync": "node src/scripts/sync.ts",
-    "i18n:setup": "node src/scripts/setup.ts",
+    "build:scripts": "tsc -p tsconfig.scripts.json",
+    "setup": "node dist/scripts/setup.js",
+    "translate": "node dist/scripts/translate.js",
+    "sync": "node dist/scripts/sync.js",
+    "i18n:setup": "node dist/scripts/setup.js",
+    "prepublishOnly": "npm run build:scripts",
     "typecheck": "tsc --noEmit",
     "lint": "echo 'Lint passed'",
     "version:patch": "npm version patch -m 'chore: release v%s'",
@@ -56,6 +58,7 @@
   },
   "files": [
     "src",
+    "dist",
     "README.md",
     "LICENSE"
   ]

package/src/scripts/setup.ts

@@ -51,8 +51,8 @@ export function setupLanguages(options: SetupLanguagesOptions): boolean {
     .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/))
     .sort();
 
-  const imports = [];
-  const exports = [];
+  const imports: string[] = [];
+  const exports: string[] = [];
 
   files.forEach(file => {
     const code = file.replace('.ts', '');