@umituz/web-localization 1.0.1

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

@@ -0,0 +1,202 @@
+/**
+ * Google Translate Service
+ * @description Main translation service using Google Translate API
+ */
+import { RateLimiter } from "../utils/rate-limit.util";
+import { shouldSkipWord, needsTranslation, isValidText, } from "../utils/text-validator.util";
+import { GOOGLE_TRANSLATE_API_URL, DEFAULT_MIN_DELAY, DEFAULT_TIMEOUT, } from "../constants";
+class GoogleTranslateService {
+    config = null;
+    rateLimiter = null;
+    initialize(config) {
+        this.config = {
+            minDelay: DEFAULT_MIN_DELAY,
+            timeout: DEFAULT_TIMEOUT,
+            ...config,
+        };
+        this.rateLimiter = new 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 (!isValidText(text) || shouldSkipWord(text)) {
+            return {
+                originalText: text,
+                translatedText: text,
+                sourceLanguage,
+                targetLanguage,
+                success: true,
+            };
+        }
+        if (!targetLanguage || targetLanguage.trim().length === 0) {
+            return {
+                originalText: text,
+                translatedText: text,
+                sourceLanguage,
+                targetLanguage,
+                success: false,
+                error: "Invalid target language",
+            };
+        }
+        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();
+        const stats = {
+            totalCount: requests.length,
+            successCount: 0,
+            failureCount: 0,
+            skippedCount: 0,
+            translatedKeys: [],
+        };
+        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++;
+                }
+            }
+        }
+        return stats;
+    }
+    async translateObject(sourceObject, targetObject, targetLanguage, path = "", stats = {
+        totalCount: 0,
+        successCount: 0,
+        failureCount: 0,
+        skippedCount: 0,
+        translatedKeys: [],
+    }, onTranslate) {
+        if (!sourceObject || typeof sourceObject !== "object")
+            return;
+        if (!targetObject || typeof targetObject !== "object")
+            return;
+        if (!targetLanguage || targetLanguage.trim().length === 0)
+            return;
+        const keys = Object.keys(sourceObject);
+        const textsToTranslate = [];
+        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, onTranslate);
+            }
+            else if (typeof enValue === "string") {
+                stats.totalCount++;
+                if (needsTranslation(targetValue, enValue)) {
+                    textsToTranslate.push({ key, enValue, currentPath });
+                }
+                else {
+                    stats.skippedCount++;
+                }
+            }
+        }
+        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 => ({
+                    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;
+                        if (onTranslate)
+                            onTranslate(currentPath, enValue, translatedItem.to);
+                        resultIndex++;
+                    }
+                }
+            }
+        }
+    }
+    async callTranslateAPI(text, targetLanguage, sourceLanguage) {
+        const timeout = this.config?.timeout || DEFAULT_TIMEOUT;
+        const encodedText = encodeURIComponent(text);
+        const url = `${GOOGLE_TRANSLATE_API_URL}?client=gtx&sl=${sourceLanguage}&tl=${targetLanguage}&dt=t&q=${encodedText}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(url, {
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`API request failed: ${response.status}`);
+            }
+            const data = await response.json();
+            if (Array.isArray(data) &&
+                data.length > 0 &&
+                Array.isArray(data[0]) &&
+                data[0].length > 0 &&
+                Array.isArray(data[0][0]) &&
+                typeof data[0][0][0] === "string") {
+                return data[0][0][0];
+            }
+            return text;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+export const googleTranslateService = new GoogleTranslateService();
+export { GoogleTranslateService };

package/src/infrastructure/services/google-translate.service.ts

@@ -0,0 +1,279 @@
+/**
+ * Google Translate Service
+ * @description Main translation service using Google Translate API
+ */
+
+import type {
+  TranslationRequest,
+  TranslationResponse,
+  TranslationStats,
+} from "../../domain/entities/translation.entity";
+import type {
+  ITranslationService,
+  TranslationServiceConfig,
+} from "../../domain/interfaces/translation-service.interface";
+import { RateLimiter } from "../utils/rate-limit.util";
+import {
+  shouldSkipWord,
+  needsTranslation,
+  isValidText,
+} from "../utils/text-validator.util";
+import {
+  GOOGLE_TRANSLATE_API_URL,
+  DEFAULT_MIN_DELAY,
+  DEFAULT_TIMEOUT,
+} from "../constants";
+
+class GoogleTranslateService implements ITranslationService {
+  private config: TranslationServiceConfig | null = null;
+  private rateLimiter: RateLimiter | null = null;
+
+  initialize(config: TranslationServiceConfig): void {
+    this.config = {
+      minDelay: DEFAULT_MIN_DELAY,
+      timeout: DEFAULT_TIMEOUT,
+      ...config,
+    };
+    this.rateLimiter = new RateLimiter(this.config.minDelay);
+  }
+
+  isInitialized(): boolean {
+    return this.config !== null && this.rateLimiter !== null;
+  }
+
+  private ensureInitialized(): void {
+    if (!this.isInitialized()) {
+      throw new Error(
+        "GoogleTranslateService is not initialized. Call initialize() first."
+      );
+    }
+  }
+
+  async translate(request: TranslationRequest): Promise<TranslationResponse> {
+    this.ensureInitialized();
+
+    const { text, targetLanguage, sourceLanguage = "en" } = request;
+
+    if (!isValidText(text) || shouldSkipWord(text)) {
+      return {
+        originalText: text,
+        translatedText: text,
+        sourceLanguage,
+        targetLanguage,
+        success: true,
+      };
+    }
+
+    if (!targetLanguage || targetLanguage.trim().length === 0) {
+      return {
+        originalText: text,
+        translatedText: text,
+        sourceLanguage,
+        targetLanguage,
+        success: false,
+        error: "Invalid target language",
+      };
+    }
+
+    await this.rateLimiter!.waitForSlot();
+
+    try {
+      const translatedText = await this.callTranslateAPI(
+        text,
+        targetLanguage,
+        sourceLanguage
+      );
+
+      return {
+        originalText: text,
+        translatedText,
+        sourceLanguage,
+        targetLanguage,
+        success: true,
+      };
+    } catch (error) {
+      return {
+        originalText: text,
+        translatedText: text,
+        sourceLanguage,
+        targetLanguage,
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  }
+
+  async translateBatch(requests: TranslationRequest[]): Promise<TranslationStats> {
+    this.ensureInitialized();
+
+    const stats: TranslationStats = {
+      totalCount: requests.length,
+      successCount: 0,
+      failureCount: 0,
+      skippedCount: 0,
+      translatedKeys: [],
+    };
+
+    if (!Array.isArray(requests) || requests.length === 0) {
+      return stats;
+    }
+
+    // Process requests concurrently with controlled parallelism
+    const concurrencyLimit = 10;
+    const chunks: TranslationRequest[][] = [];
+
+    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++;
+        }
+      }
+    }
+
+    return stats;
+  }
+
+  async translateObject(
+    sourceObject: Record<string, unknown>,
+    targetObject: Record<string, unknown>,
+    targetLanguage: string,
+    path = "",
+    stats: TranslationStats = {
+      totalCount: 0,
+      successCount: 0,
+      failureCount: 0,
+      skippedCount: 0,
+      translatedKeys: [],
+    },
+    onTranslate?: (key: string, from: string, to: string) => void
+  ): Promise<void> {
+    if (!sourceObject || typeof sourceObject !== "object") return;
+    if (!targetObject || typeof targetObject !== "object") return;
+    if (!targetLanguage || targetLanguage.trim().length === 0) return;
+
+    const keys = Object.keys(sourceObject);
+    const textsToTranslate: Array<{key: string; enValue: string; currentPath: string}> = [];
+
+    for (const key of keys) {
+      const enValue = sourceObject[key];
+      const targetValue = targetObject[key];
+      const currentPath = path ? `${path}.${key}` : key;
+
+      if (typeof enValue === "object" && enValue !== null) {
+        if (!targetObject[key] || typeof targetObject[key] !== "object") {
+          targetObject[key] = {};
+        }
+        await this.translateObject(
+          enValue as Record<string, unknown>,
+          targetObject[key] as Record<string, unknown>,
+          targetLanguage,
+          currentPath,
+          stats,
+          onTranslate
+        );
+      } else if (typeof enValue === "string") {
+        stats.totalCount++;
+        if (needsTranslation(targetValue, enValue)) {
+          textsToTranslate.push({key, enValue, currentPath});
+        } else {
+          stats.skippedCount++;
+        }
+      }
+    }
+
+    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 => ({
+            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;
+            if (onTranslate) onTranslate(currentPath, enValue, translatedItem.to);
+            resultIndex++;
+          }
+        }
+      }
+    }
+  }
+
+  private async callTranslateAPI(
+    text: string,
+    targetLanguage: string,
+    sourceLanguage: string
+  ): Promise<string> {
+    const timeout = this.config?.timeout || DEFAULT_TIMEOUT;
+    const encodedText = encodeURIComponent(text);
+    const url = `${GOOGLE_TRANSLATE_API_URL}?client=gtx&sl=${sourceLanguage}&tl=${targetLanguage}&dt=t&q=${encodedText}`;
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      const response = await fetch(url, {
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        throw new Error(`API request failed: ${response.status}`);
+      }
+
+      const data = await response.json();
+
+      if (
+        Array.isArray(data) &&
+        data.length > 0 &&
+        Array.isArray(data[0]) &&
+        data[0].length > 0 &&
+        Array.isArray(data[0][0]) &&
+        typeof data[0][0][0] === "string"
+      ) {
+        return data[0][0][0];
+      }
+
+      return text;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
+export const googleTranslateService = new GoogleTranslateService();
+export { GoogleTranslateService };

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

@@ -0,0 +1,10 @@
+/**
+ * Parses a TypeScript file containing an object export
+ * @description Simplistic parser for 'export default { ... }' or 'export const data = { ... }'
+ */
+export declare function parseTypeScriptFile(filePath: string): Record<string, unknown>;
+/**
+ * Generates a TypeScript file content from an object
+ */
+export declare function generateTypeScriptContent(obj: Record<string, unknown>, langCode?: string): string;
+//# sourceMappingURL=file.util.d.ts.map

package/src/infrastructure/utils/file.util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.util.d.ts","sourceRoot":"","sources":["file.util.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAoB7E;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAajG"}

package/src/infrastructure/utils/file.util.js

@@ -0,0 +1,41 @@
+import fs from "fs";
+/**
+ * Parses a TypeScript file containing an object export
+ * @description Simplistic parser for 'export default { ... }' or 'export const data = { ... }'
+ */
+export function parseTypeScriptFile(filePath) {
+    if (!fs.existsSync(filePath))
+        return {};
+    const content = fs.readFileSync(filePath, "utf-8");
+    // Extract the object part
+    // This is a naive implementation, but matches the pattern used in the project
+    const match = content.match(/export (default|const [^=]+ =) (\{[\s\S]*\});?\s*$/);
+    if (!match)
+        return {};
+    try {
+        // Evaluate the object string to a real JS object
+        // Using Function instead of eval for slightly better safety
+        const objStr = match[2];
+        const obj = new Function(`return ${objStr}`)();
+        return obj;
+    }
+    catch (err) {
+        console.error(`Error parsing ${filePath}:`, err);
+        return {};
+    }
+}
+/**
+ * Generates a TypeScript file content from an object
+ */
+export function generateTypeScriptContent(obj, langCode) {
+    const jsonStr = JSON.stringify(obj, null, 2);
+    // Clean up keys (remove quotes if possible, though JSON.stringify adds them)
+    // For simplicity, we'll keep them as valid JS objects
+    return `/**
+ * Localization: ${langCode || "unknown"}
+ * Generated by @umituz/web-localization
+ */
+
+export default ${jsonStr};
+`;
+}

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

@@ -0,0 +1,46 @@
+import fs from "fs";
+import path from "path";
+
+/**
+ * Parses a TypeScript file containing an object export
+ * @description Simplistic parser for 'export default { ... }' or 'export const data = { ... }'
+ */
+export function parseTypeScriptFile(filePath: string): Record<string, unknown> {
+  if (!fs.existsSync(filePath)) return {};
+  
+  const content = fs.readFileSync(filePath, "utf-8");
+  
+  // Extract the object part
+  // This is a naive implementation, but matches the pattern used in the project
+  const match = content.match(/export (default|const [^=]+ =) (\{[\s\S]*\});?\s*$/);
+  if (!match) return {};
+  
+  try {
+    // Evaluate the object string to a real JS object
+    // Using Function instead of eval for slightly better safety
+    const objStr = match[2];
+    const obj = new Function(`return ${objStr}`)();
+    return obj;
+  } catch (err) {
+    console.error(`Error parsing ${filePath}:`, err);
+    return {};
+  }
+}
+
+/**
+ * Generates a TypeScript file content from an object
+ */
+export function generateTypeScriptContent(obj: Record<string, unknown>, langCode?: string): string {
+  const jsonStr = JSON.stringify(obj, null, 2);
+  
+  // Clean up keys (remove quotes if possible, though JSON.stringify adds them)
+  // For simplicity, we'll keep them as valid JS objects
+  
+  return `/**
+ * Localization: ${langCode || "unknown"}
+ * Generated by @umituz/web-localization
+ */
+
+export default ${jsonStr};
+`;
+}

package/src/infrastructure/utils/rate-limit.util.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Simple Rate Limiter
+ * @description Controls the frequency of API requests
+ */
+export declare class RateLimiter {
+    private lastRequestTime;
+    private minDelay;
+    constructor(minDelay?: number);
+    waitForSlot(): Promise<void>;
+}
+//# sourceMappingURL=rate-limit.util.d.ts.map

package/src/infrastructure/utils/rate-limit.util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.util.d.ts","sourceRoot":"","sources":["rate-limit.util.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,qBAAa,WAAW;IACtB,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,SAAM;IAIpB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;CAWnC"}

package/src/infrastructure/utils/rate-limit.util.js

@@ -0,0 +1,20 @@
+/**
+ * Simple Rate Limiter
+ * @description Controls the frequency of API requests
+ */
+export class RateLimiter {
+    lastRequestTime = 0;
+    minDelay;
+    constructor(minDelay = 100) {
+        this.minDelay = minDelay;
+    }
+    async waitForSlot() {
+        const now = Date.now();
+        const elapsedTime = now - this.lastRequestTime;
+        if (elapsedTime < this.minDelay) {
+            const waitTime = this.minDelay - elapsedTime;
+            await new Promise(resolve => setTimeout(resolve, waitTime));
+        }
+        this.lastRequestTime = Date.now();
+    }
+}

package/src/infrastructure/utils/rate-limit.util.ts

@@ -0,0 +1,25 @@
+/**
+ * Simple Rate Limiter
+ * @description Controls the frequency of API requests
+ */
+
+export class RateLimiter {
+  private lastRequestTime = 0;
+  private minDelay: number;
+
+  constructor(minDelay = 100) {
+    this.minDelay = minDelay;
+  }
+
+  async waitForSlot(): Promise<void> {
+    const now = Date.now();
+    const elapsedTime = now - this.lastRequestTime;
+    
+    if (elapsedTime < this.minDelay) {
+      const waitTime = this.minDelay - elapsedTime;
+      await new Promise(resolve => setTimeout(resolve, waitTime));
+    }
+    
+    this.lastRequestTime = Date.now();
+  }
+}

package/src/infrastructure/utils/text-validator.util.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Text Validation Utilities
+ */
+/**
+ * Validates if the text is suitable for translation
+ */
+export declare function isValidText(text: unknown): text is string;
+/**
+ * Checks if a word should be skipped (e.g., proper nouns, symbols)
+ */
+export declare function shouldSkipWord(text: string): boolean;
+/**
+ * Determines if a key needs translation
+ */
+export declare function needsTranslation(targetValue: unknown, sourceValue: string): boolean;
+//# sourceMappingURL=text-validator.util.d.ts.map

package/src/infrastructure/utils/text-validator.util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-validator.util.d.ts","sourceRoot":"","sources":["text-validator.util.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,MAAM,CAKzD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGpD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAKnF"}