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

package/dist/scripts/sync.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Sync Translations Script
+ * Synchronizes translation keys from en-US.ts to all other language files
+ */
+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 = (0, file_parser_1.parseTypeScriptFile)(targetPath);
+    }
+    catch {
+        target = {};
+    }
+    const detectedNewKeys = (0, key_detector_1.detectNewKeys)(enUS, target);
+    const addStats = { added: 0, newKeys: [] };
+    const removeStats = { removed: 0, removedKeys: [] };
+    (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 = (0, file_parser_1.generateTypeScriptContent)(target, langCode);
+        fs_1.default.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 = (0, key_extractor_1.extractUsedKeys)(srcDir);
+    console.log(`   Found ${usedKeyMap.size} unique keys.`);
+    const oldEnUS = (0, file_parser_1.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 ((0, object_helper_1.setDeep)(newEnUS, key, valueToSet)) {
+            if (!isActuallyTranslated)
+                addedCount++;
+        }
+    }
+    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 = (0, file_parser_1.generateTypeScriptContent)(newEnUS, 'en-US');
+    fs_1.default.writeFileSync(enUSPath, content);
+}
+function syncTranslations(options) {
+    const { targetDir, srcDir } = options;
+    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_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_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`);
+        }
+    });
+    console.log(`\n✅ Synchronization completed!`);
+    return true;
+}
+// CLI interface
+function runSyncTranslations() {
+    const targetDir = process.argv[2] || 'src/infrastructure/locales';
+    const srcDir = process.argv[3];
+    console.log('🚀 Starting translation synchronization...\n');
+    syncTranslations({ targetDir, srcDir });
+}
+// 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

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Translate Missing Script
+ * Automatically translates missing strings using Google Translate
+ */
+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;
+async function translateMissing(options) {
+    const { targetDir, srcDir, skipSync = false } = options;
+    // Initialize the translation service
+    services_1.googleTranslateService.initialize({
+        minDelay: 100,
+        maxRetries: 3,
+        timeout: 10000,
+    });
+    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_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 = (0, file_parser_1.parseTypeScriptFile)(enUSPath);
+    for (const file of files) {
+        const langCode = file.replace('.ts', '');
+        // Skip English variants
+        const targetLang = (0, services_1.getTargetLanguage)(langCode);
+        if (!targetLang || targetLang === 'en') {
+            console.log(`⏭️  Skipping ${langCode} (English variant)`);
+            continue;
+        }
+        const langName = (0, services_1.getLanguageDisplayName)(langCode);
+        console.log(`🌍 Translating ${langCode} (${langName})...`);
+        const targetPath = path_1.default.join(localesDir, file);
+        const target = (0, file_parser_1.parseTypeScriptFile)(targetPath);
+        const stats = {
+            totalCount: 0,
+            successCount: 0,
+            failureCount: 0,
+            skippedCount: 0,
+            translatedKeys: [],
+        };
+        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 = (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);
+            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
+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);
+    });
+}
+// 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

@@ -0,0 +1,98 @@
+"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
+ */
+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) {
+        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_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_1.default.join(dir, `${moduleName}.ts`);
+                if (fs_1.default.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 {};
+}
+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);
+}
+function generateTypeScriptContent(obj, langCode) {
+    const langName = (0, textValidator_util_1.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,25 @@
+"use strict";
+/**
+ * Scripts Utils
+ * Utility functions for translation scripts
+ */
+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

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Key Detector
+ * Detects new, missing, and removed keys between source and target objects
+ */
+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];
+        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;
+}
+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,101 @@
+"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
+ */
+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_1.default.existsSync(dir))
+        return;
+    const files = fs_1.default.readdirSync(dir);
+    for (const file of files) {
+        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_1.default.readFileSync(fullPath, 'utf8');
+            extractFromFile(content, keyMap);
+        }
+    }
+}
+function extractUsedKeys(srcDir) {
+    const keyMap = new Map();
+    if (!srcDir)
+        return keyMap;
+    const projectRoot = process.cwd();
+    const absoluteSrcDir = path_1.default.resolve(projectRoot, srcDir);
+    // Scan project source
+    walkDirectory(absoluteSrcDir, keyMap);
+    // Scan @umituz packages for shared keys
+    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

@@ -0,0 +1,47 @@
+"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
+ */
+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
+ */
+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,51 @@
+"use strict";
+/**
+ * Sync Helper
+ * Helper functions for synchronizing translation keys
+ */
+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) {
+        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;
+}
+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.6",
   "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', '');
@@ -90,6 +90,7 @@ export function runSetupLanguages(): void {
   setupLanguages({ targetDir });
 }
 
-if (import.meta.url === `file://${process.argv[1]}`) {
+// 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();
 }

package/src/scripts/sync.ts

@@ -148,6 +148,7 @@ export function runSyncTranslations(): void {
   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/src/scripts/translate.ts

@@ -121,6 +121,7 @@ export function runTranslateMissing(): void {
   });
 }
 
-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();
 }