@umituz/web-localization 1.1.7 → 1.1.9

package/dist/infrastructure/services/google-translate.service.js

@@ -1,29 +1,127 @@
 /**
- * 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 { RateLimiter } from "../utils/rate-limit.util.js";
 import { shouldSkipWord, needsTranslation, isValidText, } from "../utils/text-validator.util.js";
-import { GOOGLE_TRANSLATE_API_URL, DEFAULT_MIN_DELAY, DEFAULT_TIMEOUT, } from "../constants/index.js";
+import { GOOGLE_TRANSLATE_API_URL, DEFAULT_MIN_DELAY, DEFAULT_TIMEOUT, DEFAULT_MAX_RETRIES, TRANSLATION_BATCH_SIZE, TRANSLATION_CONCURRENCY_LIMIT, } from "../constants/index.js";
+/**
+ * Object pool for reusing Map instances
+ */
+class MapPool {
+    pool = [];
+    maxPoolSize = 10;
+    acquire() {
+        return this.pool.pop() || new Map();
+    }
+    release(map) {
+        if (map.size === 0 && this.pool.length < this.maxPoolSize) {
+            this.pool.push(map);
+        }
+    }
+    clear() {
+        this.pool.length = 0;
+    }
+}
 class GoogleTranslateService {
     config = null;
-    rateLimiter = null;
+    _rateLimiter = null;
+    // Translation cache with LRU-style eviction
+    translationCache = new Map();
+    maxCacheSize = 1000;
+    cacheTTL = 1000 * 60 * 60; // 1 hour
+    // Object pools
+    mapPool = new MapPool();
+    // Performance tracking
+    activeRequests = 0;
+    maxConcurrentRequests = 20;
     initialize(config) {
         this.config = {
             minDelay: DEFAULT_MIN_DELAY,
             timeout: DEFAULT_TIMEOUT,
             ...config,
         };
-        this.rateLimiter = new RateLimiter(this.config.minDelay);
+        this._rateLimiter = new RateLimiter(this.config.minDelay);
     }
     isInitialized() {
-        return this.config !== null && this.rateLimiter !== null;
+        return this.config !== null && this._rateLimiter !== null;
+    }
+    get rateLimiter() {
+        if (!this._rateLimiter) {
+            throw new Error("RateLimiter not initialized");
+        }
+        return this._rateLimiter;
     }
     ensureInitialized() {
         if (!this.isInitialized()) {
             throw new Error("GoogleTranslateService is not initialized. Call initialize() first.");
         }
     }
+    /**
+     * Generate cache key for translation
+     */
+    getCacheKey(text, targetLang, sourceLang) {
+        return `${sourceLang}|${targetLang}|${text}`;
+    }
+    /**
+     * Get translation from cache
+     */
+    getFromCache(text, targetLang, sourceLang) {
+        const key = this.getCacheKey(text, targetLang, sourceLang);
+        const entry = this.translationCache.get(key);
+        if (!entry)
+            return null;
+        // Check if entry has expired
+        const now = Date.now();
+        if (now - entry.timestamp > this.cacheTTL) {
+            this.translationCache.delete(key);
+            return null;
+        }
+        // Update access count and timestamp for LRU
+        entry.accessCount++;
+        entry.timestamp = now;
+        return entry.translation;
+    }
+    /**
+     * Store translation in cache with automatic eviction
+     */
+    storeInCache(text, targetLang, sourceLang, translation) {
+        // If cache is full, remove least recently used entries
+        if (this.translationCache.size >= this.maxCacheSize) {
+            let oldestKey = null;
+            let oldestTime = Infinity;
+            for (const [key, entry] of this.translationCache) {
+                if (entry.timestamp < oldestTime) {
+                    oldestTime = entry.timestamp;
+                    oldestKey = key;
+                }
+            }
+            if (oldestKey) {
+                this.translationCache.delete(oldestKey);
+            }
+        }
+        const key = this.getCacheKey(text, targetLang, sourceLang);
+        this.translationCache.set(key, {
+            translation,
+            timestamp: Date.now(),
+            accessCount: 1,
+        });
+    }
+    /**
+     * Clear translation cache
+     */
+    clearCache() {
+        this.translationCache.clear();
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        return {
+            size: this.translationCache.size,
+            maxSize: this.maxCacheSize,
+        };
+    }
     async translate(request) {
         this.ensureInitialized();
         const { text, targetLanguage, sourceLanguage = "en" } = request;
@@ -46,9 +144,28 @@ class GoogleTranslateService {
                 error: "Invalid target language",
             };
         }
-        await this.rateLimiter.waitForSlot();
+        // Check cache first
+        const cachedTranslation = this.getFromCache(text, targetLanguage, sourceLanguage);
+        if (cachedTranslation !== null) {
+            return {
+                originalText: text,
+                translatedText: cachedTranslation,
+                sourceLanguage,
+                targetLanguage,
+                success: true,
+                cached: true,
+            };
+        }
+        // Wait for rate limit slot with normal priority
+        await this.rateLimiter.waitForSlot(5);
         try {
+            const startTime = Date.now();
             const translatedText = await this.callTranslateAPI(text, targetLanguage, sourceLanguage);
+            const responseTime = Date.now() - startTime;
+            // Record response time for dynamic rate adjustment
+            this.rateLimiter.recordResponseTime(responseTime);
+            // Store in cache
+            this.storeInCache(text, targetLanguage, sourceLanguage, translatedText);
             return {
                 originalText: text,
                 translatedText,
@@ -80,33 +197,65 @@ class GoogleTranslateService {
         if (!Array.isArray(requests) || requests.length === 0) {
             return stats;
         }
-        // Process requests concurrently with controlled parallelism
-        const concurrencyLimit = 10;
-        const chunks = [];
-        for (let i = 0; i < requests.length; i += concurrencyLimit) {
-            chunks.push(requests.slice(i, i + concurrencyLimit));
-        }
-        for (const chunk of chunks) {
-            const results = await Promise.all(chunk.map(async (request) => {
-                await this.rateLimiter.waitForSlot();
-                return this.callTranslateAPI(request.text, request.targetLanguage, request.sourceLanguage || "en");
-            }));
-            for (let i = 0; i < chunk.length; i++) {
-                const request = chunk[i];
-                const translatedText = results[i];
-                if (translatedText && translatedText !== request.text) {
-                    stats.successCount++;
-                    stats.translatedKeys.push({
-                        key: request.text,
-                        from: request.text,
-                        to: translatedText,
-                    });
-                }
-                else if (!translatedText) {
-                    stats.failureCount++;
-                }
-                else {
-                    stats.skippedCount++;
+        // Filter out requests that can be served from cache
+        const uncachedRequests = [];
+        const cacheIndexMap = new Map(); // Maps original index to cached translation
+        for (let i = 0; i < requests.length; i++) {
+            const request = requests[i];
+            const cachedTranslation = this.getFromCache(request.text, request.targetLanguage, request.sourceLanguage || "en");
+            if (cachedTranslation !== null) {
+                // Serve from cache
+                cacheIndexMap.set(i, cachedTranslation);
+                stats.successCount++;
+                stats.translatedKeys.push({
+                    key: request.text,
+                    from: request.text,
+                    to: cachedTranslation,
+                });
+            }
+            else {
+                uncachedRequests.push(request);
+            }
+        }
+        stats.skippedCount = cacheIndexMap.size;
+        // Process uncached requests with controlled parallelism
+        if (uncachedRequests.length > 0) {
+            const chunks = [];
+            for (let i = 0; i < uncachedRequests.length; i += TRANSLATION_CONCURRENCY_LIMIT) {
+                chunks.push(uncachedRequests.slice(i, i + TRANSLATION_CONCURRENCY_LIMIT));
+            }
+            for (const chunk of chunks) {
+                const results = await Promise.allSettled(chunk.map(async (request) => {
+                    await this.rateLimiter.waitForSlot(5);
+                    const startTime = Date.now();
+                    const result = await this.callTranslateAPI(request.text, request.targetLanguage, request.sourceLanguage || "en");
+                    const responseTime = Date.now() - startTime;
+                    // Record response time for dynamic rate adjustment
+                    this.rateLimiter.recordResponseTime(responseTime);
+                    return result;
+                }));
+                for (let i = 0; i < chunk.length; i++) {
+                    const request = chunk[i];
+                    const result = results[i];
+                    if (result.status === "fulfilled") {
+                        const translatedText = result.value;
+                        if (translatedText && translatedText !== request.text) {
+                            stats.successCount++;
+                            stats.translatedKeys.push({
+                                key: request.text,
+                                from: request.text,
+                                to: translatedText,
+                            });
+                            // Cache the successful translation
+                            this.storeInCache(request.text, request.targetLanguage, request.sourceLanguage || "en", translatedText);
+                        }
+                        else {
+                            stats.skippedCount++;
+                        }
+                    }
+                    else {
+                        stats.failureCount++;
+                    }
                 }
             }
         }
@@ -125,21 +274,30 @@ class GoogleTranslateService {
             return;
         if (!targetLanguage || targetLanguage.trim().length === 0)
             return;
-        const keys = Object.keys(sourceObject);
+        // First pass: collect all texts to translate (flattens nested structure)
         const textsToTranslate = [];
+        const nestedObjects = [];
+        // Collect texts and nested objects
+        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) {
+                // Prepare nested object for processing
                 if (!targetObject[key] || typeof targetObject[key] !== "object") {
                     targetObject[key] = {};
                 }
-                await this.translateObject(enValue, targetObject[key], targetLanguage, currentPath, stats, onTranslate, force);
+                nestedObjects.push({
+                    key,
+                    sourceObj: enValue,
+                    targetObj: targetObject[key],
+                    currentPath,
+                });
             }
             else if (typeof enValue === "string") {
                 stats.totalCount++;
-                if (force || needsTranslation(targetValue, enValue)) {
+                if (force || needsTranslation(targetValue)) {
                     textsToTranslate.push({ key, enValue, currentPath });
                 }
                 else {
@@ -147,97 +305,155 @@ class GoogleTranslateService {
                 }
             }
         }
+        // Process nested objects recursively
+        for (const nested of nestedObjects) {
+            await this.translateObject(nested.sourceObj, nested.targetObj, targetLanguage, nested.currentPath, stats, onTranslate, force);
+        }
+        // Process texts in batches
         if (textsToTranslate.length > 0) {
-            const batchSize = 50;
-            for (let i = 0; i < textsToTranslate.length; i += batchSize) {
-                const batch = textsToTranslate.slice(i, i + batchSize);
-                const results = await this.translateBatch(batch.map(item => ({
+            for (let i = 0; i < textsToTranslate.length; i += TRANSLATION_BATCH_SIZE) {
+                const batch = textsToTranslate.slice(i, i + TRANSLATION_BATCH_SIZE);
+                const results = await this.translateBatch(batch.map((item) => ({
                     text: item.enValue,
                     targetLanguage,
                 })));
-                let resultIndex = 0;
-                for (let j = 0; j < batch.length; j++) {
-                    const { key, enValue, currentPath } = batch[j];
-                    const translatedItem = results.translatedKeys[resultIndex];
-                    if (translatedItem && translatedItem.from === enValue && translatedItem.to !== enValue) {
-                        targetObject[key] = translatedItem.to;
-                        stats.successCount++;
-                        if (onTranslate)
-                            onTranslate(currentPath, enValue, translatedItem.to);
-                        resultIndex++;
+                // Use object pool for map
+                const translationMap = this.mapPool.acquire();
+                try {
+                    // Create a map for quick lookup of translations
+                    for (const item of results.translatedKeys) {
+                        translationMap.set(item.from, item.to);
                     }
-                    else {
-                        stats.failureCount++;
+                    for (let j = 0; j < batch.length; j++) {
+                        const { key, enValue, currentPath } = batch[j];
+                        const translatedText = translationMap.get(enValue);
+                        if (translatedText && translatedText !== enValue) {
+                            targetObject[key] = translatedText;
+                            stats.successCount++;
+                            if (onTranslate)
+                                onTranslate(currentPath, enValue, translatedText);
+                        }
+                        else {
+                            stats.failureCount++;
+                        }
                     }
                 }
+                finally {
+                    // Clear and release map back to pool
+                    translationMap.clear();
+                    this.mapPool.release(translationMap);
+                }
             }
         }
     }
-    async callTranslateAPI(text, targetLanguage, sourceLanguage, retries = 3, backoffMs = 2000) {
-        // 1. Variable Protection (Extract {{variables}})
-        const varMap = new Map();
-        let counter = 0;
-        // Find all {{something}} patterns
-        let safeText = text.replace(/\{\{([^}]+)\}\}/g, (match) => {
-            const placeholder = `_VAR${counter}_`; // Using a simple token less likely to be split
-            varMap.set(placeholder, match);
-            counter++;
-            return placeholder;
-        });
-        const timeout = this.config?.timeout || DEFAULT_TIMEOUT;
-        const encodedText = encodeURIComponent(safeText);
-        const url = `${GOOGLE_TRANSLATE_API_URL}?client=gtx&sl=${sourceLanguage}&tl=${targetLanguage}&dt=t&q=${encodedText}`;
-        for (let attempt = 0; attempt <= retries; attempt++) {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), timeout);
+    async callTranslateAPI(text, targetLanguage, sourceLanguage, retries = DEFAULT_MAX_RETRIES, backoffMs = 2000) {
+        // Increment active requests counter
+        this.activeRequests++;
+        try {
+            // 1. Variable Protection (Extract {{variables}})
+            // Use object pool for map to reduce GC pressure
+            const varMap = this.mapPool.acquire();
+            let counter = 0;
             try {
-                const response = await fetch(url, {
-                    signal: controller.signal,
+                // Find all {{something}} patterns
+                // Use more specific pattern to avoid false matches
+                const safeText = text.replace(/\{\{([^}]+)\}\}/g, (match) => {
+                    const placeholder = `__VAR${counter}__`;
+                    varMap.set(placeholder, match);
+                    counter++;
+                    return placeholder;
                 });
-                if (!response.ok) {
-                    if (response.status === 429 || response.status >= 500) {
-                        if (attempt < retries) {
-                            clearTimeout(timeoutId);
-                            // Exponential backoff
-                            const delay = backoffMs * Math.pow(2, attempt);
-                            await new Promise(resolve => setTimeout(resolve, delay));
-                            continue;
+                const timeout = this.config?.timeout || DEFAULT_TIMEOUT;
+                const encodedText = encodeURIComponent(safeText);
+                const url = `${GOOGLE_TRANSLATE_API_URL}?client=gtx&sl=${sourceLanguage}&tl=${targetLanguage}&dt=t&q=${encodedText}`;
+                for (let attempt = 0; attempt < retries; attempt++) {
+                    const controller = new AbortController();
+                    const timeoutId = setTimeout(() => controller.abort(), timeout);
+                    try {
+                        const response = await fetch(url, {
+                            signal: controller.signal,
+                        });
+                        if (!response.ok) {
+                            if (response.status === 429 || response.status >= 500) {
+                                if (attempt < retries - 1) {
+                                    clearTimeout(timeoutId);
+                                    // Exponential backoff
+                                    const delay = backoffMs * Math.pow(2, attempt);
+                                    await this.sleep(delay);
+                                    continue;
+                                }
+                            }
+                            throw new Error(`API request failed: ${response.status}`);
+                        }
+                        const data = await response.json();
+                        let translatedStr = safeText;
+                        if (Array.isArray(data) &&
+                            data.length > 0 &&
+                            Array.isArray(data[0]) &&
+                            data[0].length > 0 &&
+                            typeof data[0][0][0] === "string") {
+                            translatedStr = data[0].map((item) => item[0]).join('');
                         }
+                        // 2. Re-inject Variables
+                        if (varMap.size > 0) {
+                            // Sometimes Google adds spaces, like __VAR0__ -> __ VAR0 __
+                            // Use pre-compiled regex patterns for better performance
+                            for (const [placeholder, originalVar] of varMap.entries()) {
+                                // Escape special regex characters in placeholder
+                                const escapedPlaceholder = placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                                // Allow optional spaces between each character
+                                const regex = new RegExp(escapedPlaceholder.split('').join('\\s*'), 'g');
+                                translatedStr = translatedStr.replace(regex, originalVar);
+                            }
+                        }
+                        return translatedStr;
                     }
-                    throw new Error(`API request failed: ${response.status}`);
-                }
-                const data = await response.json();
-                let translatedStr = safeText;
-                if (Array.isArray(data) &&
-                    data.length > 0 &&
-                    Array.isArray(data[0]) &&
-                    data[0].length > 0 &&
-                    typeof data[0][0][0] === "string") {
-                    translatedStr = data[0].map((item) => item[0]).join('');
-                }
-                // 2. Re-inject Variables
-                if (varMap.size > 0) {
-                    // Sometimes Google adds spaces, like _VAR0_ -> _ VAR0 _
-                    for (const [placeholder, originalVar] of varMap.entries()) {
-                        const regex = new RegExp(placeholder.split('').join('\\s*'), 'g');
-                        translatedStr = translatedStr.replace(regex, originalVar);
+                    catch (error) {
+                        clearTimeout(timeoutId);
+                        if (attempt === retries - 1) {
+                            throw error;
+                        }
+                        const delay = backoffMs * Math.pow(2, attempt);
+                        await this.sleep(delay);
+                    }
+                    finally {
+                        clearTimeout(timeoutId);
                     }
                 }
-                return translatedStr;
-            }
-            catch (error) {
-                clearTimeout(timeoutId);
-                if (attempt === retries) {
-                    throw error;
-                }
-                const delay = backoffMs * Math.pow(2, attempt);
-                await new Promise(resolve => setTimeout(resolve, delay));
+                return text;
             }
             finally {
-                clearTimeout(timeoutId);
+                // Clear and release map back to pool
+                varMap.clear();
+                this.mapPool.release(varMap);
             }
         }
-        return text;
+        finally {
+            // Decrement active requests counter
+            this.activeRequests--;
+        }
+    }
+    /**
+     * Optimized sleep function
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Get number of active requests
+     */
+    getActiveRequestCount() {
+        return this.activeRequests;
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        this.clearCache();
+        this.mapPool.clear();
+        if (this._rateLimiter) {
+            this._rateLimiter.clear();
+        }
     }
 }
 export const googleTranslateService = new GoogleTranslateService();

package/dist/infrastructure/utils/file.util.d.ts

@@ -1,9 +1,35 @@
 /**
  * Parses a TypeScript file containing an object export
- * @description Simplistic parser for 'export default { ... }' or 'export const data = { ... }'
+ * @description Improved parser with caching and better error handling
+ * @security Note: Uses Function constructor - only use with trusted local files
  */
 export declare function parseTypeScriptFile(filePath: string): Record<string, unknown>;
 /**
  * Generates a TypeScript file content from an object
+ * @description Optimized content generation with proper escaping
  */
 export declare function generateTypeScriptContent(obj: Record<string, unknown>, langCode?: string): string;
+/**
+ * Clear file content cache
+ * @description Call this when you know files have been modified externally
+ */
+export declare function clearFileCache(): void;
+/**
+ * Get cache statistics
+ */
+export declare function getFileCacheStats(): {
+    size: number;
+    maxSize: number;
+};
+/**
+ * Check if a file exists (async version for better performance)
+ */
+export declare function fileExists(filePath: string): Promise<boolean>;
+/**
+ * Read file content asynchronously (for better performance in non-blocking scenarios)
+ */
+export declare function readFileAsync(filePath: string): Promise<string | null>;
+/**
+ * Write file content asynchronously (for better performance in non-blocking scenarios)
+ */
+export declare function writeFileAsync(filePath: string, content: string): Promise<void>;