@umituz/react-native-google-translate 1.0.4 → 1.0.6

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

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Language Entity
+ * @description Language code mappings and metadata
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Translation Entity
+ * @description Represents a translation request and response
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/domain/entities/index.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Domain Entities
+ * @description Exports all entity types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/domain/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Domain Layer
+ * @description Subpath: @umituz/react-native-google-translate/core
+ *
+ * Exports all domain entities and interfaces
+ */
+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("./entities"), exports);
+__exportStar(require("./interfaces"), exports);

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

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Translation Service Interface
+ * @description Defines the contract for translation services
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/domain/interfaces/index.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Domain Interfaces
+ * @description Exports all interface definitions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * API Constants
+ * @description Google Translate API configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MAX_RETRIES = exports.DEFAULT_MIN_DELAY = exports.DEFAULT_TIMEOUT = exports.GOOGLE_TRANSLATE_API_URL = void 0;
+exports.GOOGLE_TRANSLATE_API_URL = "https://translate.googleapis.com/translate_a/single";
+exports.DEFAULT_TIMEOUT = 10000;
+exports.DEFAULT_MIN_DELAY = 100;
+exports.DEFAULT_MAX_RETRIES = 3;

package/dist/infrastructure/constants/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Infrastructure Constants
+ * @description Exports all constant definitions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MAX_RETRIES = exports.DEFAULT_MIN_DELAY = exports.DEFAULT_TIMEOUT = exports.GOOGLE_TRANSLATE_API_URL = exports.LANGUAGE_NAMES = exports.SKIP_WORDS = exports.LANGUAGE_MAP = void 0;
+var languages_constants_1 = require("./languages.constants");
+Object.defineProperty(exports, "LANGUAGE_MAP", { enumerable: true, get: function () { return languages_constants_1.LANGUAGE_MAP; } });
+Object.defineProperty(exports, "SKIP_WORDS", { enumerable: true, get: function () { return languages_constants_1.SKIP_WORDS; } });
+Object.defineProperty(exports, "LANGUAGE_NAMES", { enumerable: true, get: function () { return languages_constants_1.LANGUAGE_NAMES; } });
+var api_constants_1 = require("./api.constants");
+Object.defineProperty(exports, "GOOGLE_TRANSLATE_API_URL", { enumerable: true, get: function () { return api_constants_1.GOOGLE_TRANSLATE_API_URL; } });
+Object.defineProperty(exports, "DEFAULT_TIMEOUT", { enumerable: true, get: function () { return api_constants_1.DEFAULT_TIMEOUT; } });
+Object.defineProperty(exports, "DEFAULT_MIN_DELAY", { enumerable: true, get: function () { return api_constants_1.DEFAULT_MIN_DELAY; } });
+Object.defineProperty(exports, "DEFAULT_MAX_RETRIES", { enumerable: true, get: function () { return api_constants_1.DEFAULT_MAX_RETRIES; } });

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

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Language Constants
+ * @description Language mappings and metadata
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LANGUAGE_NAMES = exports.SKIP_WORDS = exports.LANGUAGE_MAP = void 0;
+exports.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",
+};
+exports.SKIP_WORDS = new Set([
+    "Google",
+    "Apple",
+    "Facebook",
+    "Instagram",
+    "Twitter",
+    "YouTube",
+    "WhatsApp",
+]);
+exports.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/index.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Infrastructure Layer
+ * @description Subpath: @umituz/react-native-google-translate/infrastructure
+ *
+ * Exports all infrastructure services, utils, and constants
+ */
+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("./services"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./constants"), exports);

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

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * Google Translate Service
+ * @description Main translation service using Google Translate API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.googleTranslateService = void 0;
+const rateLimit_util_1 = require("../utils/rateLimit.util");
+const textValidator_util_1 = require("../utils/textValidator.util");
+const constants_1 = require("../constants");
+class GoogleTranslateService {
+    config = null;
+    rateLimiter = null;
+    initialize(config) {
+        this.config = {
+            minDelay: constants_1.DEFAULT_MIN_DELAY,
+            maxRetries: constants_1.DEFAULT_MAX_RETRIES,
+            timeout: constants_1.DEFAULT_TIMEOUT,
+            ...config,
+        };
+        this.rateLimiter = new rateLimit_util_1.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 (!(0, textValidator_util_1.isValidText)(text) || (0, textValidator_util_1.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 ((0, textValidator_util_1.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 || constants_1.DEFAULT_TIMEOUT;
+        const encodedText = encodeURIComponent(text);
+        const url = `${constants_1.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);
+        }
+    }
+}
+exports.googleTranslateService = new GoogleTranslateService();

package/dist/infrastructure/services/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Infrastructure Services
+ * @description Exports all services and utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LANGUAGE_NAMES = exports.SKIP_WORDS = exports.LANGUAGE_MAP = exports.getLanguageDisplayName = exports.isEnglishVariant = exports.getTargetLanguage = exports.isValidText = exports.needsTranslation = exports.shouldSkipWord = exports.googleTranslateService = void 0;
+var GoogleTranslate_service_1 = require("./GoogleTranslate.service");
+Object.defineProperty(exports, "googleTranslateService", { enumerable: true, get: function () { return GoogleTranslate_service_1.googleTranslateService; } });
+var textValidator_util_1 = require("../utils/textValidator.util");
+Object.defineProperty(exports, "shouldSkipWord", { enumerable: true, get: function () { return textValidator_util_1.shouldSkipWord; } });
+Object.defineProperty(exports, "needsTranslation", { enumerable: true, get: function () { return textValidator_util_1.needsTranslation; } });
+Object.defineProperty(exports, "isValidText", { enumerable: true, get: function () { return textValidator_util_1.isValidText; } });
+Object.defineProperty(exports, "getTargetLanguage", { enumerable: true, get: function () { return textValidator_util_1.getTargetLanguage; } });
+Object.defineProperty(exports, "isEnglishVariant", { enumerable: true, get: function () { return textValidator_util_1.isEnglishVariant; } });
+Object.defineProperty(exports, "getLanguageDisplayName", { enumerable: true, get: function () { return textValidator_util_1.getLanguageDisplayName; } });
+var languages_constants_1 = require("../constants/languages.constants");
+Object.defineProperty(exports, "LANGUAGE_MAP", { enumerable: true, get: function () { return languages_constants_1.LANGUAGE_MAP; } });
+Object.defineProperty(exports, "SKIP_WORDS", { enumerable: true, get: function () { return languages_constants_1.SKIP_WORDS; } });
+Object.defineProperty(exports, "LANGUAGE_NAMES", { enumerable: true, get: function () { return languages_constants_1.LANGUAGE_NAMES; } });

package/dist/infrastructure/utils/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Infrastructure Utils
+ * @description Exports all utility functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLanguageDisplayName = exports.isEnglishVariant = exports.getTargetLanguage = exports.isValidText = exports.needsTranslation = exports.shouldSkipWord = exports.RateLimiter = void 0;
+var rateLimit_util_1 = require("./rateLimit.util");
+Object.defineProperty(exports, "RateLimiter", { enumerable: true, get: function () { return rateLimit_util_1.RateLimiter; } });
+var textValidator_util_1 = require("./textValidator.util");
+Object.defineProperty(exports, "shouldSkipWord", { enumerable: true, get: function () { return textValidator_util_1.shouldSkipWord; } });
+Object.defineProperty(exports, "needsTranslation", { enumerable: true, get: function () { return textValidator_util_1.needsTranslation; } });
+Object.defineProperty(exports, "isValidText", { enumerable: true, get: function () { return textValidator_util_1.isValidText; } });
+Object.defineProperty(exports, "getTargetLanguage", { enumerable: true, get: function () { return textValidator_util_1.getTargetLanguage; } });
+Object.defineProperty(exports, "isEnglishVariant", { enumerable: true, get: function () { return textValidator_util_1.isEnglishVariant; } });
+Object.defineProperty(exports, "getLanguageDisplayName", { enumerable: true, get: function () { return textValidator_util_1.getLanguageDisplayName; } });

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

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Rate Limit Utility
+ * @description Handles rate limiting for API requests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiter = void 0;
+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;
+    }
+}
+exports.RateLimiter = RateLimiter;

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

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Text Validator Utility
+ * @description Validates text for translation eligibility
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldSkipWord = shouldSkipWord;
+exports.needsTranslation = needsTranslation;
+exports.isValidText = isValidText;
+exports.getTargetLanguage = getTargetLanguage;
+exports.isEnglishVariant = isEnglishVariant;
+exports.getLanguageDisplayName = getLanguageDisplayName;
+const constants_1 = require("../constants");
+function shouldSkipWord(word) {
+    return constants_1.SKIP_WORDS.has(word);
+}
+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;
+}
+function isValidText(text) {
+    return typeof text === "string" && text.length > 0;
+}
+function getTargetLanguage(langCode) {
+    return constants_1.LANGUAGE_MAP[langCode];
+}
+function isEnglishVariant(langCode) {
+    const targetLang = getTargetLanguage(langCode);
+    return targetLang === "en";
+}
+function getLanguageDisplayName(code) {
+    return constants_1.LANGUAGE_NAMES[code] || code;
+}

package/dist/scripts/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Translation Scripts
+ * Scripts for translating and synchronizing localization files
+ */
+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("./translate"), exports);
+__exportStar(require("./sync"), exports);
+__exportStar(require("./setup"), exports);
+__exportStar(require("./utils"), exports);

package/dist/scripts/setup.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * 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]
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupLanguages = setupLanguages;
+exports.runSetupLanguages = runSetupLanguages;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const services_1 = require("../infrastructure/services");
+function setupLanguages(options) {
+    const { targetDir } = options;
+    const localesDir = path_1.default.resolve(process.cwd(), targetDir);
+    if (!fs_1.default.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(services_1.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_1.default.join(localesDir, `${langCode}.ts`);
+        if (!fs_1.default.existsSync(filePath)) {
+            const langName = (0, services_1.getLanguageDisplayName)(langCode);
+            fs_1.default.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_1.default.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_1.default.writeFileSync(path_1.default.join(localesDir, 'index.ts'), content);
+    console.log(`✅ Generated index.ts with ${files.length} languages`);
+    return true;
+}
+// CLI interface
+function runSetupLanguages() {
+    const targetDir = process.argv[2] || 'src/infrastructure/locales';
+    console.log('🚀 Setting up language files...\n');
+    setupLanguages({ targetDir });
+}
+// Check if this file is being run directly
+if (require.main === module || process.argv[1].endsWith('/setup.js') || process.argv[1].endsWith('\\setup.js')) {
+    runSetupLanguages();
+}