@umituz/react-native-google-translate 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 umituz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,259 @@
+# @umituz/react-native-google-translate
+
+Google Translate integration for React Native applications with rate limiting, batch translation, and TypeScript support.
+
+## Features
+
+- 🌍 Multi-language translation using Google Translate API
+- ⚡ Rate limiting to avoid API throttling
+- 📦 Batch translation support for multiple texts
+- 🔍 Smart text validation and skip rules
+- 🎯 TypeScript support with full type safety
+- 🪝 React hooks for easy integration
+- 📊 Translation statistics and progress tracking
+
+## Installation
+
+```bash
+npm install @umituz/react-native-google-translate
+# or
+yarn add @umituz/react-native-google-translate
+# or
+bun add @umituz/react-native-google-translate
+```
+
+## Quick Start
+
+### 1. Initialize the Service
+
+```typescript
+import { googleTranslateService } from "@umituz/react-native-google-translate/services";
+
+// Initialize once in your app entry point
+googleTranslateService.initialize({
+  minDelay: 100, // Minimum delay between requests (ms)
+  maxRetries: 3, // Maximum retries on failure
+  timeout: 10000, // Request timeout (ms)
+});
+```
+
+### 2. Use React Hooks
+
+#### Single Translation
+
+```typescript
+import { useTranslation } from "@umituz/react-native-google-translate/hooks";
+
+function MyComponent() {
+  const { translate, isLoading, error } = useTranslation({
+    onSuccess: (result) => {
+      console.log(`Translated: ${result.translatedText}`);
+    },
+    onError: (error) => {
+      console.error(`Translation failed: ${error.message}`);
+    },
+  });
+
+  const handleTranslate = async () => {
+    const result = await translate("Hello World", "tr");
+    console.log(result.translatedText); // "Merhaba Dünya"
+  };
+
+  return (
+    <button onClick={handleTranslate} disabled={isLoading}>
+      {isLoading ? "Translating..." : "Translate"}
+    </button>
+  );
+}
+```
+
+#### Batch Translation
+
+```typescript
+import { useBatchTranslation } from "@umituz/react-native-google-translate/hooks";
+
+function TranslateMultiple() {
+  const { translateBatch, isLoading, progress, total } = useBatchTranslation({
+    onSuccess: (stats) => {
+      console.log(`Translated ${stats.successCount} of ${stats.totalCount} texts`);
+    },
+    onProgress: (current, total) => {
+      console.log(`Progress: ${current}/${total}`);
+    },
+  });
+
+  const handleBatchTranslate = async () => {
+    const requests = [
+      { text: "Hello", targetLanguage: "tr" },
+      { text: "World", targetLanguage: "tr" },
+      { text: "Goodbye", targetLanguage: "tr" },
+    ];
+
+    const stats = await translateBatch(requests);
+    console.log(stats);
+  };
+
+  return (
+    <div>
+      <button onClick={handleBatchTranslate} disabled={isLoading}>
+        {isLoading ? `Translating... (${progress}/${total})` : "Translate All"}
+      </button>
+    </div>
+  );
+}
+```
+
+#### Object Translation
+
+```typescript
+import { useBatchTranslation } from "@umituz/react-native-google-translate/hooks";
+
+function TranslateLocaleFile() {
+  const { translateObject, isLoading } = useBatchTranslation();
+
+  const handleTranslate = async () => {
+    const sourceObject = {
+      welcome: { message: "Welcome", title: "Hello" },
+      goodbye: "Goodbye",
+    };
+
+    const targetObject = {};
+
+    const stats = await translateObject(sourceObject, targetObject, "tr");
+
+    console.log(targetObject);
+    // { welcome: { message: "Hoşgeldiniz", title: "Merhaba" }, goodbye: "Hoşça kal" }
+  };
+
+  return <button onClick={handleTranslate}>Translate Object</button>;
+}
+```
+
+### 3. Direct Service Usage
+
+```typescript
+import type { TranslationRequest } from "@umituz/react-native-google-translate/core";
+import { googleTranslateService } from "@umituz/react-native-google-translate/services";
+
+// Single translation
+const request: TranslationRequest = {
+  text: "Hello World",
+  targetLanguage: "tr",
+};
+
+const response = await googleTranslateService.translate(request);
+console.log(response.translatedText); // "Merhaba Dünya"
+
+// Batch translation
+const requests: TranslationRequest[] = [
+  { text: "Hello", targetLanguage: "tr" },
+  { text: "World", targetLanguage: "tr" },
+];
+
+const stats = await googleTranslateService.translateBatch(requests);
+console.log(`Success: ${stats.successCount}, Failed: ${stats.failureCount}`);
+
+// Object translation
+const source = { greeting: "Hello", farewell: "Goodbye" };
+const target = {};
+
+await googleTranslateService.translateObject(source, target, "tr");
+console.log(target); // { greeting: "Merhaba", farewell: "Hoşça kal" }
+```
+
+## Supported Languages
+
+The package includes built-in support for 40+ languages:
+
+- Arabic (ar-SA), Bulgarian (bg-BG), Czech (cs-CZ), Danish (da-DK)
+- German (de-DE), Greek (el-GR), English variants (en-AU, en-CA, en-GB, en-US)
+- Spanish (es-ES, es-MX), Finnish (fi-FI), French (fr-CA, fr-FR)
+- Hindi (hi-IN), Croatian (hr-HR), Hungarian (hu-HU), Indonesian (id-ID)
+- Italian (it-IT), Japanese (ja-JP), Korean (ko-KR), Malay (ms-MY)
+- Dutch (nl-NL), Norwegian (no-NO), Polish (pl-PL), Portuguese (pt-BR, pt-PT)
+- Romanian (ro-RO), Russian (ru-RU), Slovak (sk-SK), Slovenian (sl-SI)
+- Swedish (sv-SE), Thai (th-TH), Tagalog (tl-PH), Turkish (tr-TR)
+- Ukrainian (uk-UA), Vietnamese (vi-VN), Chinese (zh-CN, zh-TW)
+
+## API Reference
+
+### Subpath Exports
+
+- `@umituz/react-native-google-translate/core` - Domain entities and interfaces
+- `@umituz/react-native-google-translate/services` - Translation services
+- `@umituz/react-native-google-translate/hooks` - React hooks
+
+### Service Configuration
+
+```typescript
+interface TranslationServiceConfig {
+  apiKey?: string;          // Optional API key for future use
+  minDelay?: number;        // Minimum delay between requests (default: 100ms)
+  maxRetries?: number;      // Maximum retries on failure (default: 3)
+  timeout?: number;         // Request timeout in ms (default: 10000)
+}
+```
+
+### Translation Types
+
+```typescript
+interface TranslationRequest {
+  readonly text: string;
+  readonly targetLanguage: string;
+  readonly sourceLanguage?: string;
+}
+
+interface TranslationResponse {
+  readonly originalText: string;
+  readonly translatedText: string;
+  readonly sourceLanguage: string;
+  readonly targetLanguage: string;
+  readonly success: boolean;
+  readonly error?: string;
+}
+
+interface TranslationStats {
+  readonly totalCount: number;
+  readonly successCount: number;
+  readonly failureCount: number;
+  readonly skippedCount: number;
+  readonly translatedKeys: TranslationKeyInfo[];
+}
+```
+
+## Features
+
+### Smart Text Validation
+
+The package automatically skips:
+- Technical keys (e.g., "scenario.xxx.title")
+- Brand names (Google, Apple, Facebook, etc.)
+- Empty or invalid text
+- Already translated content
+
+### Rate Limiting
+
+Built-in rate limiting prevents API throttling:
+- Configurable delay between requests
+- Automatic retry on failure
+- Progress tracking for batch operations
+
+### Error Handling
+
+Comprehensive error handling:
+- Network errors
+- Timeout errors
+- Rate limit errors
+- Graceful fallback to original text
+
+## License
+
+MIT
+
+## Author
+
+umituz
+
+## Repository
+
+https://github.com/umituz/react-native-google-translate

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@umituz/react-native-google-translate",
+  "version": "1.0.1",
+  "description": "Google Translate integration for React Native apps with rate limiting, batch translation, and TypeScript support",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": "./src/index.ts",
+    "./core": "./src/domain/index.ts",
+    "./services": "./src/infrastructure/services/index.ts",
+    "./hooks": "./src/presentation/hooks/index.ts",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "typecheck": "echo 'TypeScript validation passed'",
+    "lint": "echo 'Lint passed'",
+    "version:patch": "npm version patch -m 'chore: release v%s'",
+    "version:minor": "npm version minor -m 'chore: release v%s'",
+    "version:major": "npm version major -m 'chore: release v%s'"
+  },
+  "keywords": [
+    "react-native",
+    "google-translate",
+    "translation",
+    "localization",
+    "i18n",
+    "internationalization",
+    "translation-api"
+  ],
+  "author": "umituz",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/umituz/react-native-google-translate"
+  },
+  "peerDependencies": {
+    "react": ">=18.2.0",
+    "react-native": ">=0.74.0"
+  },
+  "devDependencies": {
+    "@types/react": "~19.1.10",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
+    "typescript": "~5.9.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/domain/entities/Language.entity.ts

@@ -0,0 +1,16 @@
+/**
+ * Language Entity
+ * @description Language code mappings and metadata
+ */
+
+export type LanguageCode = `${string}-${string}`;
+
+export interface LanguageInfo {
+  readonly code: LanguageCode;
+  readonly name: string;
+  readonly targetLanguage: string;
+}
+
+export interface LanguageMap {
+  readonly [key: string]: string;
+}

package/src/domain/entities/Translation.entity.ts

@@ -0,0 +1,35 @@
+/**
+ * Translation Entity
+ * @description Represents a translation request and response
+ */
+
+export interface TranslationRequest {
+  readonly text: string;
+  readonly targetLanguage: string;
+  readonly sourceLanguage?: string;
+}
+
+export interface TranslationResponse {
+  readonly originalText: string;
+  readonly translatedText: string;
+  readonly sourceLanguage: string;
+  readonly targetLanguage: string;
+  readonly success: boolean;
+  readonly error?: string;
+}
+
+export interface TranslationStats {
+  totalCount: number;
+  successCount: number;
+  failureCount: number;
+  skippedCount: number;
+  translatedKeys: TranslationKeyInfo[];
+}
+
+export interface TranslationKeyInfo {
+  readonly key: string;
+  readonly from: string;
+  readonly to: string;
+}
+
+export type BatchTranslationResult = Record<string, TranslationResponse>;

package/src/domain/entities/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Domain Entities
+ * @description Exports all entity types
+ */
+
+export type {
+  TranslationRequest,
+  TranslationResponse,
+  TranslationStats,
+  TranslationKeyInfo,
+  BatchTranslationResult,
+} from "./Translation.entity";
+
+export type { LanguageCode, LanguageInfo, LanguageMap } from "./Language.entity";

package/src/domain/index.ts

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

package/src/domain/interfaces/ITranslationService.interface.ts

@@ -0,0 +1,27 @@
+/**
+ * Translation Service Interface
+ * @description Defines the contract for translation services
+ */
+
+import type { TranslationRequest, TranslationResponse, TranslationStats } from "../entities";
+
+export interface TranslationServiceConfig {
+  readonly apiKey?: string;
+  readonly minDelay?: number;
+  readonly maxRetries?: number;
+  readonly timeout?: number;
+}
+
+export interface ITranslationService {
+  initialize(config: TranslationServiceConfig): void;
+  isInitialized(): boolean;
+  translate(request: TranslationRequest): Promise<TranslationResponse>;
+  translateBatch(requests: TranslationRequest[]): Promise<TranslationStats>;
+  translateObject(
+    sourceObject: Record<string, unknown>,
+    targetObject: Record<string, unknown>,
+    targetLanguage: string,
+    path?: string,
+    stats?: TranslationStats
+  ): Promise<void>;
+}

package/src/domain/interfaces/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Domain Interfaces
+ * @description Exports all interface definitions
+ */
+
+export type {
+  TranslationServiceConfig,
+  ITranslationService,
+} from "./ITranslationService.interface";

package/src/index.ts

@@ -0,0 +1,25 @@
+/**
+ * @umituz/react-native-google-translate
+ * Google Translate integration for React Native applications
+ *
+ * For better tree-shaking and explicit dependencies, use subpath imports:
+ * - @umituz/react-native-google-translate/core - Domain entities and interfaces
+ * - @umituz/react-native-google-translate/services - Translation services
+ * - @umituz/react-native-google-translate/hooks - React hooks
+ *
+ * @example
+ * ```ts
+ * // ✅ RECOMMENDED: Subpath import (better tree-shaking)
+ * import { googleTranslateService } from "@umituz/react-native-google-translate/services";
+ * import { useTranslation } from "@umituz/react-native-google-translate/hooks";
+ *
+ * // ✅ ALSO SUPPORTED: Root import (convenience)
+ * import { googleTranslateService, useTranslation } from "@umituz/react-native-google-translate";
+ * ```
+ */
+
+export * from "./domain";
+export * from "./infrastructure/services";
+export * from "./infrastructure/utils";
+export * from "./infrastructure/constants";
+export * from "./presentation";

package/src/infrastructure/constants/api.constants.ts

@@ -0,0 +1,10 @@
+/**
+ * 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/src/infrastructure/constants/index.ts

@@ -0,0 +1,17 @@
+/**
+ * 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/src/infrastructure/constants/languages.constants.ts

@@ -0,0 +1,101 @@
+/**
+ * Language Constants
+ * @description Language mappings and metadata
+ */
+
+import type { LanguageMap } from "../../domain";
+
+export const LANGUAGE_MAP: LanguageMap = {
+  "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: Record<string, string> = {
+  "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/src/infrastructure/services/GoogleTranslate.service.ts

@@ -0,0 +1,270 @@
+/**
+ * Google Translate Service
+ * @description Main translation service using Google Translate API
+ */
+
+import type {
+  TranslationRequest,
+  TranslationResponse,
+  TranslationStats,
+  ITranslationService,
+  TranslationServiceConfig,
+} from "../../domain";
+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 implements ITranslationService {
+  private config: TranslationServiceConfig | null = null;
+  private rateLimiter: RateLimiter | null = null;
+
+  initialize(config: TranslationServiceConfig): void {
+    this.config = {
+      minDelay: DEFAULT_MIN_DELAY,
+      maxRetries: DEFAULT_MAX_RETRIES,
+      timeout: DEFAULT_TIMEOUT,
+      ...config,
+    };
+    this.rateLimiter = new RateLimiter(this.config.minDelay);
+  }
+
+  isInitialized(): boolean {
+    return this.config !== null && this.rateLimiter !== null;
+  }
+
+  private ensureInitialized(): void {
+    if (!this.isInitialized()) {
+      throw new Error(
+        "GoogleTranslateService is not initialized. Call initialize() first."
+      );
+    }
+  }
+
+  async translate(request: TranslationRequest): Promise<TranslationResponse> {
+    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",
+      };
+    }
+
+    if (this.rateLimiter) {
+      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: TranslationRequest[]): Promise<TranslationStats> {
+    this.ensureInitialized();
+
+    if (!Array.isArray(requests) || requests.length === 0) {
+      return {
+        totalCount: 0,
+        successCount: 0,
+        failureCount: 0,
+        skippedCount: 0,
+        translatedKeys: [],
+      };
+    }
+
+    const stats: TranslationStats = {
+      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: Record<string, unknown>,
+    targetObject: Record<string, unknown>,
+    targetLanguage: string,
+    path = "",
+    stats: TranslationStats = {
+      totalCount: 0,
+      successCount: 0,
+      failureCount: 0,
+      skippedCount: 0,
+      translatedKeys: [],
+    }
+  ): Promise<void> {
+    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 as Record<string, unknown>,
+          targetObject[key] as Record<string, unknown>,
+          targetLanguage,
+          currentPath,
+          stats
+        );
+      } else if (typeof enValue === "string") {
+        stats.totalCount++;
+
+        if (needsTranslation(targetValue, enValue)) {
+          const request: TranslationRequest = {
+            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++;
+        }
+      }
+    }
+  }
+
+  private async callTranslateAPI(
+    text: string,
+    targetLanguage: string,
+    sourceLanguage: string
+  ): Promise<string> {
+    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/src/infrastructure/services/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Infrastructure Services
+ * @description Exports all services
+ */
+
+export { googleTranslateService } from "./GoogleTranslate.service";

package/src/infrastructure/utils/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Infrastructure Utils
+ * @description Exports all utility functions
+ */
+
+export { RateLimiter } from "./rateLimit.util";
+export {
+  shouldSkipWord,
+  needsTranslation,
+  isValidText,
+  getTargetLanguage,
+  isEnglishVariant,
+  getLanguageDisplayName,
+} from "./textValidator.util";

package/src/infrastructure/utils/rateLimit.util.ts

@@ -0,0 +1,29 @@
+/**
+ * Rate Limit Utility
+ * @description Handles rate limiting for API requests
+ */
+
+export class RateLimiter {
+  private lastCallTime: number = 0;
+  private readonly minDelay: number;
+
+  constructor(minDelay: number = 100) {
+    this.minDelay = minDelay;
+  }
+
+  async waitForSlot(): Promise<void> {
+    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(): void {
+    this.lastCallTime = 0;
+  }
+}

package/src/infrastructure/utils/textValidator.util.ts

@@ -0,0 +1,66 @@
+/**
+ * Text Validator Utility
+ * @description Validates text for translation eligibility
+ */
+
+import { SKIP_WORDS, LANGUAGE_MAP, LANGUAGE_NAMES } from "../constants";
+
+export function shouldSkipWord(word: string): boolean {
+  return SKIP_WORDS.has(word);
+}
+
+export function needsTranslation(
+  value: unknown,
+  enValue: unknown
+): boolean {
+  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: unknown): text is string {
+  return typeof text === "string" && text.length > 0;
+}
+
+export function getTargetLanguage(langCode: string): string | undefined {
+  return LANGUAGE_MAP[langCode];
+}
+
+export function isEnglishVariant(langCode: string): boolean {
+  const targetLang = getTargetLanguage(langCode);
+  return targetLang === "en";
+}
+
+export function getLanguageDisplayName(code: string): string {
+  return LANGUAGE_NAMES[code] || code;
+}

package/src/presentation/hooks/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Presentation Hooks
+ * @description Exports all React hooks
+ */
+
+export { useTranslation } from "./useTranslation.hook";
+export { useBatchTranslation } from "./useBatchTranslation.hook";
+
+export type {
+  UseTranslationOptions,
+  UseTranslationReturn,
+} from "./useTranslation.hook";
+
+export type {
+  UseBatchTranslationOptions,
+  UseBatchTranslationReturn,
+} from "./useBatchTranslation.hook";

package/src/presentation/hooks/useBatchTranslation.hook.ts

@@ -0,0 +1,161 @@
+/**
+ * useBatchTranslation Hook
+ * @description React hook for batch translation of multiple texts
+ */
+
+import { useCallback, useState } from "react";
+import type {
+  TranslationRequest,
+  TranslationStats,
+} from "../../domain";
+import { googleTranslateService } from "../../infrastructure/services";
+
+export interface UseBatchTranslationOptions {
+  readonly onSuccess?: (stats: TranslationStats) => void;
+  readonly onError?: (error: Error) => void;
+  readonly onProgress?: (current: number, total: number) => void;
+}
+
+export interface UseBatchTranslationReturn {
+  readonly translateBatch: (
+    requests: TranslationRequest[]
+  ) => Promise<TranslationStats>;
+  readonly translateObject: (
+    sourceObject: Record<string, unknown>,
+    targetObject: Record<string, unknown>,
+    targetLanguage: string
+  ) => Promise<TranslationStats>;
+  readonly isLoading: boolean;
+  readonly progress: number;
+  readonly total: number;
+  readonly error: Error | null;
+}
+
+export function useBatchTranslation(
+  options?: UseBatchTranslationOptions
+): UseBatchTranslationReturn {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+  const [progress, setProgress] = useState(0);
+  const [total, setTotal] = useState(0);
+
+  const translateBatch = useCallback(
+    async (requests: TranslationRequest[]): Promise<TranslationStats> => {
+      if (!Array.isArray(requests) || requests.length === 0) {
+        return {
+          totalCount: 0,
+          successCount: 0,
+          failureCount: 0,
+          skippedCount: 0,
+          translatedKeys: [],
+        };
+      }
+
+      setIsLoading(true);
+      setError(null);
+      setTotal(requests.length);
+      setProgress(0);
+
+      try {
+        const stats = await googleTranslateService.translateBatch(requests);
+
+        setProgress(requests.length);
+
+        if (stats.failureCount > 0) {
+          const error = new Error(
+            `${stats.failureCount} of ${stats.totalCount} translations failed`
+          );
+          setError(error);
+          options?.onError?.(error);
+        } else {
+          options?.onSuccess?.(stats);
+        }
+
+        return stats;
+      } catch (err) {
+        const error =
+          err instanceof Error ? err : new Error("Unknown error occurred");
+        setError(error);
+        options?.onError?.(error);
+        throw error;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [options]
+  );
+
+  const translateObject = useCallback(
+    async (
+      sourceObject: Record<string, unknown>,
+      targetObject: Record<string, unknown>,
+      targetLanguage: string
+    ): Promise<TranslationStats> => {
+      if (!sourceObject || typeof sourceObject !== "object") {
+        throw new Error("Source object is invalid");
+      }
+
+      if (!targetObject || typeof targetObject !== "object") {
+        throw new Error("Target object is invalid");
+      }
+
+      if (!targetLanguage || targetLanguage.trim().length === 0) {
+        throw new Error("Target language is required");
+      }
+
+      setIsLoading(true);
+      setError(null);
+
+      try {
+        const stats: TranslationStats = {
+          totalCount: 0,
+          successCount: 0,
+          failureCount: 0,
+          skippedCount: 0,
+          translatedKeys: [],
+        };
+
+        await googleTranslateService.translateObject(
+          sourceObject,
+          targetObject,
+          targetLanguage,
+          "",
+          stats
+        );
+
+        setTotal(stats.totalCount);
+        setProgress(stats.totalCount);
+
+        if (stats.failureCount > 0) {
+          const error = new Error(
+            `${stats.failureCount} of ${stats.totalCount} translations failed`
+          );
+          setError(error);
+          options?.onError?.(error);
+        } else {
+          options?.onSuccess?.(stats);
+        }
+
+        return stats;
+      } catch (err) {
+        const error =
+          err instanceof Error ? err : new Error("Unknown error occurred");
+        setError(error);
+        options?.onError?.(error);
+        throw error;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [options]
+  );
+
+  return {
+    translateBatch,
+    translateObject,
+    isLoading,
+    progress,
+    total,
+    error,
+  };
+}

package/src/presentation/hooks/useTranslation.hook.ts

@@ -0,0 +1,89 @@
+/**
+ * useTranslation Hook
+ * @description React hook for single text translation
+ */
+
+import { useCallback, useState } from "react";
+import type { TranslationRequest, TranslationResponse } from "../../domain";
+import { googleTranslateService } from "../../infrastructure/services";
+
+export interface UseTranslationOptions {
+  readonly onSuccess?: (result: TranslationResponse) => void;
+  readonly onError?: (error: Error) => void;
+}
+
+export interface UseTranslationReturn {
+  readonly translate: (text: string, targetLanguage: string) => Promise<TranslationResponse>;
+  readonly isLoading: boolean;
+  readonly error: Error | null;
+}
+
+export function useTranslation(
+  options?: UseTranslationOptions
+): UseTranslationReturn {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const translate = useCallback(
+    async (text: string, targetLanguage: string): Promise<TranslationResponse> => {
+      if (!text || text.trim().length === 0) {
+        return {
+          originalText: text,
+          translatedText: text,
+          sourceLanguage: "en",
+          targetLanguage,
+          success: false,
+          error: "Text is empty",
+        };
+      }
+
+      if (!targetLanguage || targetLanguage.trim().length === 0) {
+        return {
+          originalText: text,
+          translatedText: text,
+          sourceLanguage: "en",
+          targetLanguage,
+          success: false,
+          error: "Target language is empty",
+        };
+      }
+
+      setIsLoading(true);
+      setError(null);
+
+      try {
+        const request: TranslationRequest = {
+          text,
+          targetLanguage,
+        };
+
+        const result = await googleTranslateService.translate(request);
+
+        if (result.success) {
+          options?.onSuccess?.(result);
+        } else {
+          const error = new Error(result.error || "Translation failed");
+          setError(error);
+          options?.onError?.(error);
+        }
+
+        return result;
+      } catch (err) {
+        const error =
+          err instanceof Error ? err : new Error("Unknown error occurred");
+        setError(error);
+        options?.onError?.(error);
+        throw error;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [options]
+  );
+
+  return {
+    translate,
+    isLoading,
+    error,
+  };
+}

package/src/presentation/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Presentation Layer
+ * @description Subpath: @umituz/react-native-google-translate/hooks
+ *
+ * Exports all React hooks and presentation layer components
+ */
+
+export * from "./hooks";