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

package/dist/scripts/sync.js

@@ -1,33 +1,41 @@
 #!/usr/bin/env node
+"use strict";
 /**
  * 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);
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncLanguageFile = syncLanguageFile;
+exports.syncTranslations = syncTranslations;
+exports.runSyncTranslations = runSyncTranslations;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const file_parser_1 = require("./utils/file-parser");
+const sync_helper_1 = require("./utils/sync-helper");
+const key_detector_1 = require("./utils/key-detector");
+const key_extractor_1 = require("./utils/key-extractor");
+const object_helper_1 = require("./utils/object-helper");
+function syncLanguageFile(enUSPath, targetPath, langCode) {
+    const enUS = (0, file_parser_1.parseTypeScriptFile)(enUSPath);
     let target;
     try {
-        target = parseTypeScriptFile(targetPath);
+        target = (0, file_parser_1.parseTypeScriptFile)(targetPath);
     }
     catch {
         target = {};
     }
-    const detectedNewKeys = detectNewKeys(enUS, target);
+    const detectedNewKeys = (0, key_detector_1.detectNewKeys)(enUS, target);
     const addStats = { added: 0, newKeys: [] };
     const removeStats = { removed: 0, removedKeys: [] };
-    addMissingKeys(enUS, target, addStats);
-    removeExtraKeys(enUS, target, removeStats);
+    (0, sync_helper_1.addMissingKeys)(enUS, target, addStats);
+    (0, sync_helper_1.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);
+        const content = (0, file_parser_1.generateTypeScriptContent)(target, langCode);
+        fs_1.default.writeFileSync(targetPath, content);
     }
     return {
         added: addStats.added,
@@ -42,9 +50,9 @@ function processExtraction(srcDir, enUSPath) {
     if (!srcDir)
         return;
     console.log(`🔍 Scanning source code and dependencies: ${srcDir}...`);
-    const usedKeyMap = extractUsedKeys(srcDir);
+    const usedKeyMap = (0, key_extractor_1.extractUsedKeys)(srcDir);
     console.log(`   Found ${usedKeyMap.size} unique keys.`);
-    const oldEnUS = parseTypeScriptFile(enUSPath);
+    const oldEnUS = (0, file_parser_1.parseTypeScriptFile)(enUSPath);
     const newEnUS = {};
     let addedCount = 0;
     for (const [key, defaultValue] of usedKeyMap) {
@@ -58,34 +66,34 @@ function processExtraction(srcDir, enUSPath) {
         // 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 ((0, object_helper_1.setDeep)(newEnUS, key, valueToSet)) {
             if (!isActuallyTranslated)
                 addedCount++;
         }
     }
-    const oldTotal = countKeys(oldEnUS);
-    const newTotal = countKeys(newEnUS);
+    const oldTotal = (0, object_helper_1.countKeys)(oldEnUS);
+    const newTotal = (0, object_helper_1.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);
+    const content = (0, file_parser_1.generateTypeScriptContent)(newEnUS, 'en-US');
+    fs_1.default.writeFileSync(enUSPath, content);
 }
-export function syncTranslations(options) {
+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)) {
+    const localesDir = path_1.default.resolve(process.cwd(), targetDir);
+    const enUSPath = path_1.default.join(localesDir, 'en-US.ts');
+    if (!fs_1.default.existsSync(localesDir) || !fs_1.default.existsSync(enUSPath)) {
         console.error(`❌ Localization files not found in: ${localesDir}`);
         return false;
     }
     processExtraction(srcDir, enUSPath);
-    const files = fs.readdirSync(localesDir)
+    const files = fs_1.default.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 targetPath = path_1.default.join(localesDir, file);
         const result = syncLanguageFile(enUSPath, targetPath, langCode);
         if (result.changed) {
             console.log(`   🌍 ${langCode}: ✏️  +${result.added || 0} keys, -${result.removed || 0} keys`);
@@ -95,12 +103,13 @@ export function syncTranslations(options) {
     return true;
 }
 // CLI interface
-export function runSyncTranslations() {
+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]}`) {
+// Check if this file is being run directly
+if (require.main === module || process.argv[1].endsWith('/sync.js') || process.argv[1].endsWith('\\sync.js')) {
     runSyncTranslations();
 }

package/dist/scripts/translate.js

@@ -1,45 +1,52 @@
 #!/usr/bin/env node
+"use strict";
 /**
  * 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';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateMissing = translateMissing;
+exports.runTranslateMissing = runTranslateMissing;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const file_parser_1 = require("./utils/file-parser");
+const services_1 = require("../infrastructure/services");
 // Width of terminal line to clear for progress updates
 const PROGRESS_LINE_WIDTH = 80;
-export async function translateMissing(options) {
+async function translateMissing(options) {
     const { targetDir, srcDir, skipSync = false } = options;
     // Initialize the translation service
-    googleTranslateService.initialize({
+    services_1.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)) {
+    const localesDir = path_1.default.resolve(process.cwd(), targetDir);
+    const enUSPath = path_1.default.join(localesDir, 'en-US.ts');
+    if (!fs_1.default.existsSync(localesDir) || !fs_1.default.existsSync(enUSPath)) {
         console.error(`❌ Localization files not found in: ${localesDir}`);
         return;
     }
-    const files = fs.readdirSync(localesDir)
+    const files = fs_1.default.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);
+    const enUS = (0, file_parser_1.parseTypeScriptFile)(enUSPath);
     for (const file of files) {
         const langCode = file.replace('.ts', '');
         // Skip English variants
-        const targetLang = getTargetLanguage(langCode);
+        const targetLang = (0, services_1.getTargetLanguage)(langCode);
         if (!targetLang || targetLang === 'en') {
             console.log(`⏭️  Skipping ${langCode} (English variant)`);
             continue;
         }
-        const langName = getLanguageDisplayName(langCode);
+        const langName = (0, services_1.getLanguageDisplayName)(langCode);
         console.log(`🌍 Translating ${langCode} (${langName})...`);
-        const targetPath = path.join(localesDir, file);
-        const target = parseTypeScriptFile(targetPath);
+        const targetPath = path_1.default.join(localesDir, file);
+        const target = (0, file_parser_1.parseTypeScriptFile)(targetPath);
         const stats = {
             totalCount: 0,
             successCount: 0,
@@ -47,12 +54,12 @@ export async function translateMissing(options) {
             skippedCount: 0,
             translatedKeys: [],
         };
-        await googleTranslateService.translateObject(enUS, target, targetLang, '', stats);
+        await services_1.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);
+            const content = (0, file_parser_1.generateTypeScriptContent)(target, langCode);
+            fs_1.default.writeFileSync(targetPath, content);
             console.log(`      ✅ Successfully translated ${stats.successCount} keys:`);
             // Detailed logging of translated keys
             const displayCount = Math.min(stats.translatedKeys.length, 15);
@@ -70,7 +77,7 @@ export async function translateMissing(options) {
     console.log('\n✅ All translations completed!');
 }
 // CLI interface
-export function runTranslateMissing() {
+function runTranslateMissing() {
     const args = process.argv.slice(2).filter(arg => !arg.startsWith('--'));
     const targetDir = args[0] || 'src/infrastructure/locales';
     const srcDir = args[1];
@@ -81,6 +88,7 @@ export function runTranslateMissing() {
         process.exit(1);
     });
 }
-if (import.meta.url === `file://${process.argv[1]}`) {
+// Check if this file is being run directly
+if (require.main === module || process.argv[1].endsWith('/translate.js') || process.argv[1].endsWith('\\translate.js')) {
     runTranslateMissing();
 }

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

@@ -1,12 +1,20 @@
-import fs from 'fs';
-import path from 'path';
-import { getLanguageDisplayName } from '../../infrastructure/utils/textValidator.util';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTypeScriptFile = parseTypeScriptFile;
+exports.stringifyValue = stringifyValue;
+exports.generateTypeScriptContent = generateTypeScriptContent;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const textValidator_util_1 = require("../../infrastructure/utils/textValidator.util");
 /**
  * File Parser
  * Parse and generate TypeScript translation files
  */
-export function parseTypeScriptFile(filePath) {
-    const content = fs.readFileSync(filePath, 'utf8');
+function parseTypeScriptFile(filePath) {
+    const content = fs_1.default.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) {
@@ -21,13 +29,13 @@ export function parseTypeScriptFile(filePath) {
     }
     catch (error) {
         // File might be a barrel file with named imports
-        const dir = path.dirname(filePath);
+        const dir = path_1.default.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)) {
+                const subFilePath = path_1.default.join(dir, `${moduleName}.ts`);
+                if (fs_1.default.existsSync(subFilePath)) {
                     try {
                         result[varName] = parseTypeScriptFile(subFilePath);
                     }
@@ -44,7 +52,7 @@ export function parseTypeScriptFile(filePath) {
     }
     return {};
 }
-export function stringifyValue(value, indent = 2) {
+function stringifyValue(value, indent = 2) {
     if (typeof value === 'string') {
         const escaped = value
             .replace(/\\/g, '\\\\')
@@ -76,8 +84,8 @@ export function stringifyValue(value, indent = 2) {
     }
     return String(value);
 }
-export function generateTypeScriptContent(obj, langCode) {
-    const langName = getLanguageDisplayName(langCode);
+function generateTypeScriptContent(obj, langCode) {
+    const langName = (0, textValidator_util_1.getLanguageDisplayName)(langCode);
     const isBase = langCode === 'en-US';
     const objString = stringifyValue(obj, 0);
     return `/**

package/dist/scripts/utils/index.js

@@ -1,9 +1,25 @@
+"use strict";
 /**
  * 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';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./file-parser"), exports);
+__exportStar(require("./key-detector"), exports);
+__exportStar(require("./key-extractor"), exports);
+__exportStar(require("./object-helper"), exports);
+__exportStar(require("./sync-helper"), exports);

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

@@ -1,8 +1,12 @@
+"use strict";
 /**
  * Key Detector
  * Detects new, missing, and removed keys between source and target objects
  */
-export function detectNewKeys(sourceObj, targetObj, path = '', newKeys = []) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectNewKeys = detectNewKeys;
+exports.detectMissingKeys = detectMissingKeys;
+function detectNewKeys(sourceObj, targetObj, path = '', newKeys = []) {
     for (const key in sourceObj) {
         const currentPath = path ? `${path}.${key}` : key;
         const sourceValue = sourceObj[key];
@@ -20,7 +24,7 @@ export function detectNewKeys(sourceObj, targetObj, path = '', newKeys = []) {
     }
     return newKeys;
 }
-export function detectMissingKeys(sourceObj, targetObj, path = '', missingKeys = []) {
+function detectMissingKeys(sourceObj, targetObj, path = '', missingKeys = []) {
     for (const key in targetObj) {
         const currentPath = path ? `${path}.${key}` : key;
         if (!Object.prototype.hasOwnProperty.call(sourceObj, key)) {

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

@@ -1,5 +1,11 @@
-import fs from 'fs';
-import path from 'path';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractUsedKeys = extractUsedKeys;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 /**
  * Generic Key Extractor
  * Scans source code for i18n translation keys
@@ -61,34 +67,34 @@ function extractFromFile(content, keyMap) {
     }
 }
 function walkDirectory(dir, keyMap, skipDirs = ['node_modules', '.expo', '.git', 'build', 'ios', 'android', 'assets', 'locales', '__tests__']) {
-    if (!fs.existsSync(dir))
+    if (!fs_1.default.existsSync(dir))
         return;
-    const files = fs.readdirSync(dir);
+    const files = fs_1.default.readdirSync(dir);
     for (const file of files) {
-        const fullPath = path.join(dir, file);
-        const stat = fs.statSync(fullPath);
+        const fullPath = path_1.default.join(dir, file);
+        const stat = fs_1.default.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');
+            const content = fs_1.default.readFileSync(fullPath, 'utf8');
             extractFromFile(content, keyMap);
         }
     }
 }
-export function extractUsedKeys(srcDir) {
+function extractUsedKeys(srcDir) {
     const keyMap = new Map();
     if (!srcDir)
         return keyMap;
     const projectRoot = process.cwd();
-    const absoluteSrcDir = path.resolve(projectRoot, srcDir);
+    const absoluteSrcDir = path_1.default.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)) {
+    const packagesDir = path_1.default.resolve(projectRoot, 'node_modules/@umituz');
+    if (fs_1.default.existsSync(packagesDir)) {
         walkDirectory(packagesDir, keyMap);
     }
     return keyMap;

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

@@ -1,12 +1,16 @@
+"use strict";
 /**
  * Object Helper
  * Utilities for deep object manipulation
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDeep = setDeep;
+exports.countKeys = countKeys;
 /**
  * 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) {
+function setDeep(obj, path, value) {
     const keys = path.split('.');
     let current = obj;
     for (let i = 0; i < keys.length - 1; i++) {
@@ -26,7 +30,7 @@ export function setDeep(obj, path, value) {
 /**
  * Count all leaf keys in a nested object
  */
-export function countKeys(obj) {
+function countKeys(obj) {
     let count = 0;
     const walk = (o) => {
         for (const k in o) {

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

@@ -1,8 +1,12 @@
+"use strict";
 /**
  * Sync Helper
  * Helper functions for synchronizing translation keys
  */
-export function addMissingKeys(sourceObj, targetObj, stats = {}) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMissingKeys = addMissingKeys;
+exports.removeExtraKeys = removeExtraKeys;
+function addMissingKeys(sourceObj, targetObj, stats = {}) {
     stats.added = stats.added || 0;
     stats.newKeys = stats.newKeys || [];
     for (const key in sourceObj) {
@@ -24,7 +28,7 @@ export function addMissingKeys(sourceObj, targetObj, stats = {}) {
     }
     return stats;
 }
-export function removeExtraKeys(sourceObj, targetObj, stats = {}) {
+function removeExtraKeys(sourceObj, targetObj, stats = {}) {
     stats.removed = stats.removed || 0;
     stats.removedKeys = stats.removedKeys || [];
     for (const key in targetObj) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-google-translate",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Google Translate integration for React Native apps with rate limiting, batch translation, and TypeScript support",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/infrastructure/services/GoogleTranslate.service.ts

@@ -117,6 +117,8 @@ class GoogleTranslateService implements ITranslationService {
       };
     }
 
+    // Use batch API call for better performance
+    const batchSize = 50;
     const stats: TranslationStats = {
       totalCount: requests.length,
       successCount: 0,
@@ -125,22 +127,52 @@ class GoogleTranslateService implements ITranslationService {
       translatedKeys: [],
     };
 
-    for (const request of requests) {
-      const result = await this.translate(request);
+    for (let i = 0; i < requests.length; i += batchSize) {
+      const batch = requests.slice(i, i + batchSize);
 
-      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,
-          });
+      // Wait for rate limiter once per batch instead of once per request
+      await this.rateLimiter!.waitForSlot();
+
+      try {
+        const translations = await this.callTranslateAPIBatch(batch, requests[0].targetLanguage);
+
+        for (let j = 0; j < batch.length; j++) {
+          const request = batch[j];
+          const translatedText = translations[j];
+
+          if (translatedText && translatedText !== request.text) {
+            stats.successCount++;
+            stats.translatedKeys.push({
+              key: request.text,
+              from: request.text,
+              to: translatedText,
+            });
+          } else if (!translatedText) {
+            stats.failureCount++;
+          } else {
+            stats.skippedCount++;
+          }
+        }
+      } catch (error) {
+        // Fallback to individual requests on batch failure
+        for (const request of batch) {
+          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++;
+          }
         }
-      } else {
-        stats.failureCount++;
       }
     }
 
@@ -174,6 +206,9 @@ class GoogleTranslateService implements ITranslationService {
 
     const keys = Object.keys(sourceObject);
 
+    // Collect all texts to translate first
+    const textsToTranslate: Array<{key: string; enValue: string; currentPath: string}> = [];
+
     for (const key of keys) {
       const enValue = sourceObject[key];
       const targetValue = targetObject[key];
@@ -197,28 +232,43 @@ class GoogleTranslateService implements ITranslationService {
         stats.totalCount++;
 
         if (needsTranslation(targetValue, enValue)) {
-          const request: TranslationRequest = {
-            text: enValue,
+          textsToTranslate.push({key, enValue, currentPath});
+        } else {
+          stats.skippedCount++;
+        }
+      }
+    }
+
+    // Batch translate all texts at once
+    if (textsToTranslate.length > 0) {
+      const batchSize = 50; // Google Translate API can handle ~50 texts at once
+      for (let i = 0; i < textsToTranslate.length; i += batchSize) {
+        const batch = textsToTranslate.slice(i, i + batchSize);
+        const results = await this.translateBatch(
+          batch.map(item => ({
+            text: item.enValue,
             targetLanguage,
-          };
+          }))
+        );
 
-          const result = await this.translate(request);
+        // Apply translations
+        for (let j = 0; j < batch.length; j++) {
+          const {key, enValue, currentPath} = batch[j];
+          const translatedKey = results.translatedKeys[j];
 
-          if (result.success && result.translatedText !== enValue) {
-            targetObject[key] = result.translatedText;
+          if (translatedKey && translatedKey.from !== enValue) {
+            targetObject[key] = translatedKey.to;
             stats.successCount++;
             stats.translatedKeys.push({
               key: currentPath,
               from: enValue,
-              to: result.translatedText,
+              to: translatedKey.to,
             });
-          } else if (!result.success) {
+          } else if (!translatedKey) {
             stats.failureCount++;
           } else {
             stats.skippedCount++;
           }
-        } else {
-          stats.skippedCount++;
         }
       }
     }
@@ -264,6 +314,55 @@ class GoogleTranslateService implements ITranslationService {
       clearTimeout(timeoutId);
     }
   }
+
+  private async callTranslateAPIBatch(
+    requests: TranslationRequest[],
+    targetLanguage: string,
+    sourceLanguage: string = "en"
+  ): Promise<string[]> {
+    const timeout = this.config?.timeout || DEFAULT_TIMEOUT;
+
+    // Build batch request URL
+    const queryParts = requests.map(req => encodeURIComponent(req.text)).join('&q=');
+    const url = `${GOOGLE_TRANSLATE_API_URL}?client=gtx&sl=${sourceLanguage}&tl=${targetLanguage}&dt=t&q=${queryParts}`;
+
+    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(`Batch API request failed: ${response.status}`);
+      }
+
+      const data = await response.json();
+
+      // Extract translations from batch response
+      const translations: string[] = [];
+
+      if (Array.isArray(data) && data.length > 0) {
+        for (let i = 0; i < requests.length; i++) {
+          if (
+            Array.isArray(data[i]) &&
+            data[i].length > 0 &&
+            Array.isArray(data[i][0]) &&
+            typeof data[i][0][0] === "string"
+          ) {
+            translations.push(data[i][0][0]);
+          } else {
+            translations.push(requests[i].text); // Fallback to original
+          }
+        }
+      }
+
+      return translations;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
 }
 
 export const googleTranslateService = new GoogleTranslateService();