@umituz/web-localization 1.1.8 → 1.1.9

package/dist/domain/entities/translation.entity.d.ts

@@ -14,6 +14,7 @@ export interface TranslationResponse {
     readonly targetLanguage: string;
     readonly success: boolean;
     readonly error?: string;
+    readonly cached?: boolean;
 }
 export interface TranslationItem {
     readonly key: string;

package/dist/domain/interfaces/translation-service.interface.d.ts

@@ -4,7 +4,6 @@ import type { TranslationRequest, TranslationResponse, TranslationStats } from "
  */
 export interface TranslationServiceConfig {
     minDelay?: number;
-    maxRetries?: number;
     timeout?: number;
     apiKey?: string;
 }
@@ -16,5 +15,5 @@ export interface ITranslationService {
     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, onTranslate?: (key: string, from: string, to: string) => void): Promise<void>;
+    translateObject(sourceObject: Record<string, unknown>, targetObject: Record<string, unknown>, targetLanguage: string, path?: string, stats?: TranslationStats, onTranslate?: (key: string, from: string, to: string) => void, force?: boolean): Promise<void>;
 }

package/dist/infrastructure/constants/index.d.ts

@@ -8,3 +8,5 @@ export declare const DEFAULT_TIMEOUT = 10000;
 export declare const DEFAULT_LOCALES_DIR = "src/locales";
 export declare const DEFAULT_SOURCE_DIR = "src";
 export declare const DEFAULT_BASE_LANGUAGE = "en-US";
+export declare const TRANSLATION_BATCH_SIZE = 50;
+export declare const TRANSLATION_CONCURRENCY_LIMIT = 10;

package/dist/infrastructure/constants/index.js

@@ -8,3 +8,6 @@ export const DEFAULT_TIMEOUT = 10000;
 export const DEFAULT_LOCALES_DIR = "src/locales";
 export const DEFAULT_SOURCE_DIR = "src";
 export const DEFAULT_BASE_LANGUAGE = "en-US";
+// Translation batch settings
+export const TRANSLATION_BATCH_SIZE = 50;
+export const TRANSLATION_CONCURRENCY_LIMIT = 10;

package/dist/infrastructure/services/cli.service.d.ts

@@ -3,6 +3,7 @@ export interface SyncOptions {
     sourceDir?: string;
     baseLang?: string;
     force?: boolean;
+    concurrency?: number;
 }
 export declare class CLIService {
     sync(options?: SyncOptions): Promise<void>;

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

@@ -3,7 +3,63 @@ import path from "path";
 import chalk from "chalk";
 import { googleTranslateService } from "./google-translate.service.js";
 import { parseTypeScriptFile, generateTypeScriptContent } from "../utils/file.util.js";
-import { DEFAULT_LOCALES_DIR, DEFAULT_BASE_LANGUAGE } from "../constants/index.js";
+import { DEFAULT_LOCALES_DIR, DEFAULT_BASE_LANGUAGE, TRANSLATION_CONCURRENCY_LIMIT, } from "../constants/index.js";
+/**
+ * Semaphore for controlling concurrent operations
+ */
+class Semaphore {
+    permits;
+    queue = [];
+    constructor(permits) {
+        this.permits = permits;
+    }
+    async acquire() {
+        if (this.permits > 0) {
+            this.permits--;
+            return;
+        }
+        return new Promise((resolve) => {
+            this.queue.push(resolve);
+        });
+    }
+    release() {
+        this.permits++;
+        const next = this.queue.shift();
+        if (next) {
+            this.permits--;
+            next();
+        }
+    }
+    async run(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+}
+// Extracted outside loop for better performance
+const syncObject = (source, target) => {
+    const result = { ...target };
+    for (const key in source) {
+        if (typeof source[key] === "object" && source[key] !== null) {
+            result[key] = syncObject(source[key], target[key] || {});
+        }
+        else if (target[key] === undefined) {
+            // Let empty string indicate untranslated state
+            result[key] = typeof source[key] === "string" ? "" : source[key];
+        }
+    }
+    // Remove extra keys
+    for (const key in target) {
+        if (source[key] === undefined) {
+            delete result[key];
+        }
+    }
+    return result;
+};
 export class CLIService {
     async sync(options = {}) {
         const localesDir = path.resolve(process.cwd(), options.localesDir || DEFAULT_LOCALES_DIR);
@@ -18,38 +74,27 @@ export class CLIService {
             return;
         }
         const baseData = parseTypeScriptFile(baseLangPath);
+        // Pre-compile regex for better performance
+        const localeFileRegex = /^[a-z]{2}(-[A-Z]{2})?\.ts$/;
         const files = fs.readdirSync(localesDir)
-            .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== `${baseLang}.ts`)
+            .filter(f => localeFileRegex.test(f) && f !== `${baseLang}.ts`)
             .sort();
         console.log(chalk.blue(`📊 Found ${files.length} languages to sync with ${baseLang}.\n`));
-        for (const file of files) {
-            const targetPath = path.join(localesDir, file);
-            const targetData = parseTypeScriptFile(targetPath);
-            const langCode = file.replace(".ts", "");
-            // Deep merge with base data structure
-            const syncObject = (source, target) => {
-                const result = { ...target };
-                for (const key in source) {
-                    if (typeof source[key] === "object" && source[key] !== null) {
-                        result[key] = syncObject(source[key], target[key] || {});
-                    }
-                    else if (target[key] === undefined) {
-                        // Let empty string indicate untranslated state
-                        result[key] = typeof source[key] === "string" ? "" : source[key];
-                    }
-                }
-                // Remove extra keys
-                for (const key in target) {
-                    if (source[key] === undefined) {
-                        delete result[key];
-                    }
-                }
-                return result;
-            };
-            const syncedData = syncObject(baseData, targetData);
-            fs.writeFileSync(targetPath, generateTypeScriptContent(syncedData, langCode));
-            console.log(chalk.green(`   🌍 ${langCode}: Synced structure.`));
-        }
+        // Process files in parallel with controlled concurrency
+        const concurrency = options.concurrency || TRANSLATION_CONCURRENCY_LIMIT;
+        const semaphore = new Semaphore(concurrency);
+        const syncPromises = files.map(async (file) => {
+            return semaphore.run(async () => {
+                const targetPath = path.join(localesDir, file);
+                const targetData = parseTypeScriptFile(targetPath);
+                const langCode = path.basename(file, ".ts");
+                const syncedData = syncObject(baseData, targetData);
+                fs.writeFileSync(targetPath, generateTypeScriptContent(syncedData, langCode));
+                // Non-blocking progress update
+                process.stdout.write(chalk.green(`   🌍 ${langCode}: Synced structure.\n`));
+            });
+        });
+        await Promise.all(syncPromises);
         console.log(chalk.bold.green("\n✅ Synchronization completed!"));
     }
     async translate(options = {}) {
@@ -62,35 +107,82 @@ export class CLIService {
         }
         googleTranslateService.initialize({});
         const baseData = parseTypeScriptFile(baseLangPath);
+        // Pre-compile regex for better performance
+        const localeFileRegex = /^[a-z]{2}(-[A-Z]{2})?\.ts$/;
         const files = fs.readdirSync(localesDir)
-            .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== `${baseLang}.ts`)
+            .filter(f => localeFileRegex.test(f) && f !== `${baseLang}.ts`)
             .sort();
         console.log(chalk.blue.bold(`🚀 Starting automatic translation for ${files.length} languages...\n`));
-        for (const file of files) {
-            const targetPath = path.join(localesDir, file);
-            const targetData = parseTypeScriptFile(targetPath);
-            const langCode = file.replace(".ts", "");
-            const stats = {
-                totalCount: 0,
-                successCount: 0,
-                failureCount: 0,
-                skippedCount: 0,
-                translatedKeys: []
-            };
-            console.log(chalk.yellow(`🌍 Translating ${langCode}...`));
-            await googleTranslateService.translateObject(baseData, targetData, langCode.split("-")[0], // ISO 639-1
-            "", stats, (key, from, to) => {
-                process.stdout.write(chalk.gray(`   • ${key}: ${from.substring(0, 15)}... → ${to.substring(0, 15)}...\r`));
-            }, options.force);
-            if (stats.successCount > 0) {
-                fs.writeFileSync(targetPath, generateTypeScriptContent(targetData, langCode));
-                console.log(chalk.green(`   ✅ Successfully translated ${stats.successCount} keys.`));
-            }
-            else {
-                console.log(chalk.gray("   ✨ Already up to date."));
-            }
-        }
+        // Process languages in parallel with controlled concurrency
+        const concurrency = options.concurrency || TRANSLATION_CONCURRENCY_LIMIT;
+        const semaphore = new Semaphore(concurrency);
+        // Shared statistics tracking
+        const totalStats = {
+            totalLanguages: files.length,
+            completedLanguages: 0,
+            totalSuccess: 0,
+            totalFailure: 0,
+        };
+        const translatePromises = files.map(async (file) => {
+            return semaphore.run(async () => {
+                const targetPath = path.join(localesDir, file);
+                const targetData = parseTypeScriptFile(targetPath);
+                const langCode = path.basename(file, ".ts");
+                const stats = {
+                    totalCount: 0,
+                    successCount: 0,
+                    failureCount: 0,
+                    skippedCount: 0,
+                    translatedKeys: []
+                };
+                // Non-blocking progress update with language name
+                const langName = langCode.padEnd(6);
+                process.stdout.write(chalk.yellow(`🌍 Translating ${langName}...\n`));
+                try {
+                    // Extract ISO 639-1 language code (e.g., "en" from "en-US")
+                    const targetLang = langCode.includes("-") ? langCode.split("-")[0] : langCode;
+                    await googleTranslateService.translateObject(baseData, targetData, targetLang, "", stats, (_key, _from, _to) => {
+                        // Non-blocking per-key progress (only in verbose mode or for debugging)
+                        // Commented out to reduce console spam
+                        // process.stdout.write(chalk.gray(`   • ${key}: ${from.substring(0, 15)}... → ${to.substring(0, 15)}...\r`));
+                    }, options.force);
+                    // Write translated content
+                    if (stats.successCount > 0) {
+                        fs.writeFileSync(targetPath, generateTypeScriptContent(targetData, langCode));
+                        totalStats.totalSuccess += stats.successCount;
+                        process.stdout.write(chalk.green(`   ✅ ${langName} Successfully translated ${stats.successCount} keys.\n`));
+                    }
+                    else if (stats.failureCount > 0) {
+                        totalStats.totalFailure += stats.failureCount;
+                        process.stdout.write(chalk.red(`   ❌ ${langName} Failed to translate ${stats.failureCount} keys.\n`));
+                    }
+                    else {
+                        process.stdout.write(chalk.gray(`   ✨ ${langName} Already up to date.\n`));
+                    }
+                }
+                catch (error) {
+                    totalStats.totalFailure += stats.failureCount;
+                    const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+                    process.stdout.write(chalk.red(`   ❌ ${langName} Error: ${errorMsg}\n`));
+                }
+                finally {
+                    totalStats.completedLanguages++;
+                }
+            });
+        });
+        await Promise.all(translatePromises);
+        // Final summary
         console.log(chalk.bold.green("\n✅ All translations completed!"));
+        console.log(chalk.gray(`   📊 Processed ${totalStats.completedLanguages}/${totalStats.totalLanguages} languages`));
+        if (totalStats.totalSuccess > 0) {
+            console.log(chalk.green(`   ✅ Total keys translated: ${totalStats.totalSuccess}`));
+        }
+        if (totalStats.totalFailure > 0) {
+            console.log(chalk.red(`   ❌ Total keys failed: ${totalStats.totalFailure}`));
+        }
+        // Display cache statistics
+        const cacheStats = googleTranslateService.getCacheStats();
+        console.log(chalk.gray(`   💾 Cache hit rate: ${cacheStats.size}/${cacheStats.maxSize}`));
     }
 }
 export const cliService = new CLIService();

package/dist/infrastructure/services/google-translate.service.d.ts

@@ -1,19 +1,61 @@
 /**
- * Google Translate Service
- * @description Main translation service using Google Translate API
+ * Google Translate Service with Performance Optimizations
+ * @description Main translation service using Google Translate API with caching and pooling
  */
 import type { TranslationRequest, TranslationResponse, TranslationStats } from "../../domain/entities/translation.entity.js";
 import type { ITranslationService, TranslationServiceConfig } from "../../domain/interfaces/translation-service.interface.js";
 declare class GoogleTranslateService implements ITranslationService {
     private config;
-    private rateLimiter;
+    private _rateLimiter;
+    private translationCache;
+    private readonly maxCacheSize;
+    private readonly cacheTTL;
+    private readonly mapPool;
+    private activeRequests;
+    private readonly maxConcurrentRequests;
     initialize(config: TranslationServiceConfig): void;
     isInitialized(): boolean;
+    private get rateLimiter();
     private ensureInitialized;
+    /**
+     * Generate cache key for translation
+     */
+    private getCacheKey;
+    /**
+     * Get translation from cache
+     */
+    private getFromCache;
+    /**
+     * Store translation in cache with automatic eviction
+     */
+    private storeInCache;
+    /**
+     * Clear translation cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+    };
     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, onTranslate?: (key: string, from: string, to: string) => void, force?: boolean): Promise<void>;
     private callTranslateAPI;
+    /**
+     * Optimized sleep function
+     */
+    private sleep;
+    /**
+     * Get number of active requests
+     */
+    getActiveRequestCount(): number;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
 }
 export declare const googleTranslateService: GoogleTranslateService;
 export { GoogleTranslateService };