locai 2.2.0 → 2.4.0

package/dist/core/adapters/android-adapter.js

@@ -0,0 +1,107 @@
+import { XMLParser, XMLBuilder } from "fast-xml-parser";
+/**
+ * Adapter for Android XML resources files (strings.xml)
+ */
+export class AndroidAdapter {
+    extensions = [".xml"];
+    parser;
+    builder;
+    constructor() {
+        this.parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_",
+            textNodeName: "#text",
+            isArray: (name) => name === "string" || name === "string-array" || name === "item",
+        });
+        this.builder = new XMLBuilder({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_",
+            textNodeName: "#text",
+            format: true,
+            indentBy: "    ",
+        });
+    }
+    async parse(content) {
+        try {
+            const parsed = this.parser.parse(content);
+            // Extract strings resources
+            const resources = parsed.resources || {};
+            const result = {};
+            // Handle regular strings
+            if (resources.string) {
+                resources.string.forEach((item) => {
+                    const key = item["@_name"];
+                    const value = item["#text"];
+                    if (key) {
+                        result[key] = value || "";
+                    }
+                });
+            }
+            // Handle string arrays (flattened as array_name.index)
+            if (resources["string-array"]) {
+                resources["string-array"].forEach((array) => {
+                    const arrayName = array["@_name"];
+                    if (array.item) {
+                        array.item.forEach((value, index) => {
+                            result[`${arrayName}.${index}`] = value;
+                        });
+                    }
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Failed to parse Android XML: ${error.message}`);
+        }
+    }
+    async serialize(data) {
+        const resources = {
+            string: [],
+            "string-array": [],
+        };
+        // Collect keys to handle arrays properly
+        const arrays = {};
+        const strings = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (key.includes(".")) {
+                const [arrayName, indexStr] = key.split(".");
+                if (!isNaN(Number(indexStr))) {
+                    if (!arrays[arrayName])
+                        arrays[arrayName] = [];
+                    arrays[arrayName][Number(indexStr)] = value;
+                    continue;
+                }
+            }
+            strings[key] = value;
+        }
+        // Add strings
+        for (const [key, value] of Object.entries(strings)) {
+            resources.string.push({
+                "@_name": key,
+                "#text": value,
+            });
+        }
+        // Add arrays
+        for (const [key, items] of Object.entries(arrays)) {
+            resources["string-array"].push({
+                "@_name": key,
+                item: items.filter((i) => i !== undefined),
+            });
+        }
+        // Sort by name for consistency
+        resources.string.sort((a, b) => a["@_name"].localeCompare(b["@_name"]));
+        resources["string-array"].sort((a, b) => a["@_name"].localeCompare(b["@_name"]));
+        if (resources["string-array"].length === 0)
+            delete resources["string-array"];
+        if (resources.string.length === 0)
+            delete resources.string;
+        const xmlObj = {
+            "?xml": {
+                "@_version": "1.0",
+                "@_encoding": "utf-8",
+            },
+            resources: resources,
+        };
+        return this.builder.build(xmlObj);
+    }
+}

package/dist/core/adapters/factory.js

@@ -3,6 +3,8 @@ import { JsonAdapter } from "./json-adapter.js";
 import { YamlAdapter } from "./yaml-adapter.js";
 import { PoAdapter } from "./po-adapter.js";
 import { PropertiesAdapter } from "./properties-adapter.js";
+import { AndroidAdapter } from "./android-adapter.js";
+import { IosAdapter } from "./ios-adapter.js";
 /**
  * Factory class to manage file format adapters
  */
@@ -12,6 +14,8 @@ export class FormatFactory {
         new YamlAdapter(),
         new PoAdapter(),
         new PropertiesAdapter(),
+        new AndroidAdapter(),
+        new IosAdapter(),
     ];
     /**
      * Get adapter for a specific file path

package/dist/core/adapters/ios-adapter.d.ts

@@ -0,0 +1,10 @@
+import { FileFormatAdapter } from "./base-adapter.js";
+/**
+ * Adapter for iOS .strings files
+ * Format: "KEY" = "VALUE";
+ */
+export declare class IosAdapter implements FileFormatAdapter {
+    extensions: string[];
+    parse(content: string): Promise<Record<string, any>>;
+    serialize(data: Record<string, any>): Promise<string>;
+}

package/dist/core/adapters/ios-adapter.js

@@ -0,0 +1,45 @@
+/**
+ * Adapter for iOS .strings files
+ * Format: "KEY" = "VALUE";
+ */
+export class IosAdapter {
+    extensions = [".strings"];
+    async parse(content) {
+        const result = {};
+        const lines = content.split(/\r?\n/);
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Skip comments and empty lines
+            if (!trimmed || trimmed.startsWith("/*") || trimmed.startsWith("//")) {
+                continue;
+            }
+            // Parse "key" = "value";
+            // Handle escaped quotes in value
+            const match = trimmed.match(/^"(.+)"\s*=\s*"(.*)";$/);
+            if (match) {
+                const key = match[1];
+                let value = match[2];
+                // Unescape quotes and newlines if needed
+                value = value.replace(/\\"/g, '"').replace(/\\n/g, "\n");
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    async serialize(data) {
+        let output = "";
+        // Sort keys for deterministic output
+        const keys = Object.keys(data).sort();
+        for (const key of keys) {
+            let value = data[key];
+            if (typeof value !== "string") {
+                value = String(value);
+            }
+            // Escape quotes and newlines
+            const safeKey = key; // Keys usually don't have quotes, but simplistic handling
+            const safeValue = value.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+            output += `"${safeKey}" = "${safeValue}";\n`;
+        }
+        return output;
+    }
+}

package/dist/providers/openai.js

@@ -40,7 +40,7 @@ class OpenAIProvider extends BaseProvider {
         return RetryHelper.withRetry(async () => {
             try {
                 const response = await this.client.post(this.getEndpoint(), {
-                    model: config.model || "gpt-5.2-chat-latest",
+                    model: config.model || "gpt-4o",
                     ...promptData,
                     temperature: config.temperature,
                     max_completion_tokens: config.maxTokens || config.max_tokens,
@@ -65,7 +65,7 @@ class OpenAIProvider extends BaseProvider {
     }
     async analyze(prompt, options = {}) {
         const config = this.getConfig({
-            model: options.model || "gpt-5.2-chat-latest",
+            model: options.model || "gpt-4o",
             temperature: options.temperature || 0.2,
             maxTokens: options.maxTokens || 1000,
         });
@@ -94,7 +94,7 @@ class OpenAIProvider extends BaseProvider {
     }
     async chat(messages, options = {}) {
         const config = this.getConfig({
-            model: options.model || "gpt-5.2-chat-latest",
+            model: options.model || "gpt-4o",
             temperature: options.temperature || 0.3,
             maxTokens: options.maxTokens || 2000,
         });

package/dist/services/language-processor.d.ts

@@ -0,0 +1,22 @@
+import Orchestrator from "../core/orchestrator.js";
+import { TranslationOptions, GlobalStats, LanguageProcessResult } from "../types/index.js";
+export declare class LanguageProcessor {
+    /**
+     * Process a single language translation.
+     * @param {string} targetLang - Target language code.
+     * @param {string} sourceFile - Path to source file.
+     * @param {Record<string, any>} flattenedSource - Flattened source content.
+     * @param {Orchestrator} orchestrator - Orchestrator instance.
+     * @param {TranslationOptions} options - Translation options.
+     * @param {GlobalStats} globalStats - Global statistics object.
+     * @param {any} comparison - State comparison result.
+     * @returns {Promise<LanguageProcessResult>} - Status and messages for this language.
+     */
+    static processLanguage(targetLang: string, sourceFile: string, flattenedSource: Record<string, any>, orchestrator: Orchestrator, options: TranslationOptions, globalStats: GlobalStats, comparison: any): Promise<LanguageProcessResult>;
+    /**
+     * Check if text only contains placeholders and whitespace.
+     * @param {string} text - Text to check.
+     * @returns {boolean} - True if text only contains placeholders.
+     */
+    static isPlaceholderOnlyText(text: string): boolean;
+}

package/dist/services/language-processor.js

@@ -0,0 +1,239 @@
+import path from "path";
+import { FileManager } from "../utils/file-manager.js";
+import ObjectTransformer from "../utils/object-transformer.js";
+import InputValidator from "../utils/input-validator.js";
+import uiManager from "../utils/ui-manager.js";
+import statisticsManager from "../utils/statistics-manager.js";
+export class LanguageProcessor {
+    /**
+     * Process a single language translation.
+     * @param {string} targetLang - Target language code.
+     * @param {string} sourceFile - Path to source file.
+     * @param {Record<string, any>} flattenedSource - Flattened source content.
+     * @param {Orchestrator} orchestrator - Orchestrator instance.
+     * @param {TranslationOptions} options - Translation options.
+     * @param {GlobalStats} globalStats - Global statistics object.
+     * @param {any} comparison - State comparison result.
+     * @returns {Promise<LanguageProcessResult>} - Status and messages for this language.
+     */
+    static async processLanguage(targetLang, sourceFile, flattenedSource, orchestrator, options, globalStats, comparison) {
+        if (!targetLang) {
+            throw new Error("Invalid target language provided");
+        }
+        const langStartTime = Date.now();
+        try {
+            if (!targetLang || typeof targetLang !== "string") {
+                throw new Error("Invalid target language provided");
+            }
+            if (!sourceFile || typeof sourceFile !== "string") {
+                throw new Error("Invalid source file path provided");
+            }
+            if (!flattenedSource || typeof flattenedSource !== "object") {
+                throw new Error("Invalid flattened source data provided");
+            }
+            if (!orchestrator || typeof orchestrator.processTranslations !== "function") {
+                throw new Error("Invalid orchestrator instance provided");
+            }
+            if (!globalStats || typeof globalStats !== "object") {
+                throw new Error("Invalid global stats object provided");
+            }
+            const safeTargetLang = InputValidator.validateLanguageCode(targetLang, "target language");
+            await uiManager.log(`Starting translations for ${safeTargetLang}`);
+            let finalStatus = null;
+            let savedMessage = undefined;
+            statisticsManager.initLanguageStats(safeTargetLang);
+            const sourceDir = path.dirname(sourceFile);
+            const safeTargetFilename = `${safeTargetLang}.json`;
+            const targetPath = InputValidator.createSafeFilePath(sourceDir, safeTargetFilename);
+            let targetContent = {};
+            try {
+                targetContent = await FileManager.readJSON(targetPath);
+                if (!targetContent || typeof targetContent !== "object") {
+                    console.warn(`Invalid content in ${targetPath}, using empty object`);
+                    targetContent = {};
+                }
+            }
+            catch (err) {
+                if (err.code === "ENOENT") {
+                    await uiManager.log(`\ud83c\udd95 Creating new translation file for ${safeTargetLang}`);
+                }
+                else {
+                    if (options.debug) {
+                        console.warn(`Error reading ${targetPath}: ${err.message}, using empty object`);
+                    }
+                }
+                targetContent = {};
+            }
+            let flattenedTarget = {};
+            try {
+                flattenedTarget = ObjectTransformer.flatten(targetContent);
+                if (!flattenedTarget || typeof flattenedTarget !== "object") {
+                    flattenedTarget = {};
+                }
+            }
+            catch (err) {
+                console.warn(`Error flattening target content: ${err.message}, using empty object`);
+                flattenedTarget = {};
+            }
+            const missingKeys = [];
+            let hasPlaceholderOnlyChanges = false;
+            for (const [key, sourceText] of Object.entries(flattenedSource)) {
+                try {
+                    InputValidator.validateKey(key, "translation key");
+                    InputValidator.validateText(sourceText, "source text");
+                }
+                catch (keyError) {
+                    await uiManager.log(`\u26a0\ufe0f Skipping invalid key/text: ${keyError.message}`);
+                    globalStats.languages[safeTargetLang].failed++;
+                    globalStats.failed++;
+                    continue;
+                }
+                globalStats.languages[safeTargetLang].processed++;
+                if (this.isPlaceholderOnlyText(sourceText)) {
+                    const existingValue = flattenedTarget[key];
+                    if (existingValue !== sourceText) {
+                        flattenedTarget[key] = sourceText;
+                        hasPlaceholderOnlyChanges = true;
+                        if (options.debug) {
+                            await uiManager.log(`   Copying placeholder-only text: "${sourceText}"`);
+                        }
+                    }
+                    globalStats.languages[safeTargetLang].skipped++;
+                    globalStats.skipped++;
+                    continue;
+                }
+                const isNewKey = comparison.newKeys.includes(key);
+                const isModifiedKey = comparison.modifiedKeys.includes(key);
+                const keyExistsInTarget = key in flattenedTarget;
+                if (keyExistsInTarget && !options.forceUpdate && !isModifiedKey) {
+                    globalStats.languages[safeTargetLang].skipped++;
+                    globalStats.skipped++;
+                    continue;
+                }
+                missingKeys.push({
+                    key,
+                    text: sourceText,
+                    targetLang: safeTargetLang,
+                    existingTranslation: flattenedTarget[key],
+                    isModified: isModifiedKey,
+                    isNew: isNewKey,
+                });
+            }
+            if (missingKeys.length === 0 && !hasPlaceholderOnlyChanges) {
+                await uiManager.log(`All translations exist for ${safeTargetLang}`);
+                globalStats.languages[safeTargetLang].timeMs = Date.now() - langStartTime;
+                return { status: { completed: 0, total: 0, language: safeTargetLang } };
+            }
+            if (missingKeys.length > 0) {
+                await uiManager.log(`Found ${missingKeys.length} missing translations for ${safeTargetLang}`);
+            }
+            let results = [];
+            if (missingKeys.length > 0) {
+                try {
+                    results = await orchestrator.processTranslations(missingKeys);
+                    if (!Array.isArray(results)) {
+                        console.warn("Invalid results from orchestrator, using empty array");
+                        results = [];
+                    }
+                }
+                catch (err) {
+                    console.error(`Error processing translations for ${safeTargetLang}: ${err.message}`);
+                    results = [];
+                    if (globalStats.languages[safeTargetLang]) {
+                        globalStats.languages[safeTargetLang].failed += missingKeys.length;
+                        globalStats.failed += missingKeys.length;
+                    }
+                }
+            }
+            else {
+                if (hasPlaceholderOnlyChanges) {
+                    await uiManager.log(`Found placeholder-only changes for ${safeTargetLang}`);
+                }
+            }
+            try {
+                if (orchestrator?.progress &&
+                    typeof orchestrator.progress.getStatus === "function") {
+                    finalStatus = orchestrator.progress.getStatus();
+                }
+            }
+            catch (err) {
+                console.warn(`Error getting orchestrator status: ${err.message}`);
+            }
+            let validResults = [];
+            try {
+                validResults = results.filter((result) => result && result.success === true);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                validResults = validResults.filter((result) => result.key &&
+                    typeof result.key === "string" &&
+                    result.translated &&
+                    typeof result.translated === "string");
+            }
+            catch (err) {
+                console.warn(`Error filtering results: ${err.message}`);
+                validResults = [];
+            }
+            if (validResults.length > 0) {
+                validResults.forEach(({ key, translated }) => {
+                    if (translated) {
+                        flattenedTarget[key] = translated;
+                    }
+                });
+            }
+            const hasChangesToSave = validResults.length > 0 || hasPlaceholderOnlyChanges;
+            if (hasChangesToSave) {
+                const unflattened = ObjectTransformer.unflatten(flattenedTarget);
+                await FileManager.writeJSON(targetPath, unflattened);
+                globalStats.total += validResults.length;
+                globalStats.success += validResults.length;
+                globalStats.failed += results.length - validResults.length;
+                globalStats.languages[safeTargetLang].added += validResults.length;
+                globalStats.languages[safeTargetLang].failed +=
+                    results.length - validResults.length;
+                validResults.forEach((result) => {
+                    if (result.context) {
+                        const category = result.context.category || "general";
+                        globalStats.byCategory[category] =
+                            (globalStats.byCategory[category] || 0) + 1;
+                        if (!globalStats.details[category]) {
+                            globalStats.details[category] = {
+                                totalConfidence: 0,
+                                samples: 0,
+                            };
+                        }
+                        globalStats.details[category].totalConfidence +=
+                            result.context.confidence || 0;
+                        globalStats.details[category].samples++;
+                    }
+                });
+                savedMessage = `Translations saved: ${safeTargetLang}.json`;
+            }
+            globalStats.languages[safeTargetLang].timeMs = Date.now() - langStartTime;
+            return { status: finalStatus, savedMessage };
+        }
+        catch (error) {
+            const safeError = error.message.includes("outside working directory")
+                ? "Invalid file path detected"
+                : error.message;
+            await uiManager.log(`\n\u274c Error processing ${targetLang}: ${safeError}`);
+            if (globalStats.languages[targetLang]) {
+                globalStats.languages[targetLang].error = safeError;
+                globalStats.languages[targetLang].timeMs = Date.now() - langStartTime;
+            }
+            return { status: null, error: safeError };
+        }
+    }
+    /**
+     * Check if text only contains placeholders and whitespace.
+     * @param {string} text - Text to check.
+     * @returns {boolean} - True if text only contains placeholders.
+     */
+    static isPlaceholderOnlyText(text) {
+        if (!text || typeof text !== "string") {
+            return false;
+        }
+        // Remove all placeholders from the text
+        const placeholderRegex = /\{[^}]+\}|\$\{[^}]+\}|%[sd]/g;
+        const textWithoutPlaceholders = text.replace(placeholderRegex, "").trim();
+        return textWithoutPlaceholders.length === 0;
+    }
+}

package/dist/services/translation-service.d.ts

@@ -1,60 +1,12 @@
 import Orchestrator from "../core/orchestrator.js";
-import { OrchestratorOptions } from "../core/orchestrator.js";
 import StateManager from "../utils/state-manager.js";
-export interface TranslationOptions extends OrchestratorOptions {
-    source: string;
-    targets?: string[];
-    localesDir?: string;
-    debug?: boolean;
-    forceUpdate?: boolean;
-    syncOptions?: {
-        enabled?: boolean;
-        removeDeletedKeys?: boolean;
-    };
-    concurrencyLimit?: number;
-    saveReviewQueue?: boolean;
-    minConfidence?: number;
-    fileExtensions?: string[];
-}
-export interface GlobalStats {
-    total: number;
-    success: number;
-    failed: number;
-    skipped: number;
-    languages: Record<string, any>;
-    byCategory: Record<string, number>;
-    details: Record<string, {
-        totalConfidence: number;
-        samples: number;
-    }>;
-    error?: {
-        message: string;
-        time: string;
-        stack?: string;
-    };
-    orchestrators: any[];
-    endTime?: string;
-    totalDuration?: number;
-    totalTime: number;
-    startTime: string;
-}
-interface LanguageProcessResult {
-    status: any;
-    savedMessage?: string;
-    error?: string;
-}
+import { TranslationOptions, GlobalStats, LanguageProcessResult } from "../types/index.js";
 /**
  * Service for handling file translation operations.
  * Orchestrates the translation process including state management,
  * verification, and statistics collection.
  */
 declare class TranslationService {
-    /**
-     * Check if text only contains placeholders and whitespace.
-     * @param {string} text - Text to check.
-     * @returns {boolean} - True if text only contains placeholders.
-     */
-    isPlaceholderOnlyText(text: string): boolean;
     /**
      * Main translator function to process source file and create translations.
      * @param {string} file - Path to source file.