poly-lexis 0.1.0 → 0.2.0

package/README.md

@@ -1,36 +1,36 @@
-# Lexis
+# poly-lexis
 
 A powerful CLI and library for managing i18n translations with validation, auto-translation, and TypeScript type generation.
 
 ## Overview
 
-Lexis provides a complete solution for managing internationalization (i18n) in your applications. It offers smart translation management with automatic validation, Google Translate integration for auto-filling missing translations, and TypeScript type generation for type-safe translations.
+poly-lexis provides a complete solution for managing internationalization (i18n) in your applications. It offers smart translation management with automatic validation, Google Translate integration for auto-filling missing translations, and TypeScript type generation for type-safe translations.
 
 ## Installation
 
 ```bash
-npm install lexis
+npm install poly-lexis
 # or
-yarn add lexis
+yarn add poly-lexis
 # or
-pnpm add lexis
+pnpm add poly-lexis
 ```
 
 ## Quick Start
 
 ```bash
 # Initialize translations in your project
-npx lexis
+npx poly-lexis
 
 # Add a new translation key
-npx lexis add
+npx poly-lexis add
 
 # Auto-fill missing translations
 export GOOGLE_TRANSLATE_API_KEY=your_key
-npx lexis --auto-fill
+npx poly-lexis --auto-fill
 
 # Validate and generate types
-npx lexis
+npx poly-lexis
 ```
 
 ## Features
@@ -51,32 +51,32 @@ Run without any command to validate, auto-fill (optional), and generate types:
 
 ```bash
 # Basic validation and type generation
-lexis
+poly-lexis
 
 # With auto-translation
-lexis --auto-fill
+poly-lexis --auto-fill
 
 # Auto-fill only specific language
-lexis --auto-fill --language fr
+poly-lexis --auto-fill --language fr
 
 # Dry run to preview changes
-lexis --auto-fill --dry-run
+poly-lexis --auto-fill --dry-run
 
 # Skip type generation
-lexis --skip-types
+poly-lexis --skip-types
 ```
 
 ### Add Translation Keys
 
 ```bash
 # Interactive mode
-lexis add
+poly-lexis add
 
 # With flags
-lexis add --namespace common --key HELLO --value "Hello"
+poly-lexis add --namespace common --key HELLO --value "Hello"
 
 # With auto-translation
-lexis add -n common -k WELCOME -v "Welcome" --auto-fill
+poly-lexis add -n common -k WELCOME -v "Welcome" --auto-fill
 ```
 
 ### CLI Options
@@ -97,7 +97,7 @@ lexis add -n common -k WELCOME -v "Welcome" --auto-fill
 
 ## Configuration
 
-Lexis uses a `.translationsrc.json` file in your project root for configuration:
+poly-lexis uses a `.translationsrc.json` file in your project root for configuration:
 
 ```json
 {
@@ -157,12 +157,12 @@ Translation files are organized by namespace and language:
 
 ## Programmatic API
 
-Lexis can be used as a library in your Node.js code:
+poly-lexis can be used as a library in your Node.js code:
 
 ### Initialize Translations
 
 ```typescript
-import { initTranslationsInteractive } from 'lexis';
+import { initTranslationsInteractive } from 'poly-lexis';
 
 await initTranslationsInteractive(process.cwd());
 ```
@@ -170,7 +170,7 @@ await initTranslationsInteractive(process.cwd());
 ### Add Translation Key
 
 ```typescript
-import { addTranslationKey } from 'lexis';
+import { addTranslationKey } from 'poly-lexis';
 
 await addTranslationKey(process.cwd(), {
   namespace: 'common',
@@ -184,7 +184,7 @@ await addTranslationKey(process.cwd(), {
 ### Validate Translations
 
 ```typescript
-import { validateTranslations } from 'lexis';
+import { validateTranslations } from 'poly-lexis';
 
 const result = await validateTranslations(
   '/path/to/translations',
@@ -200,7 +200,7 @@ if (!result.valid) {
 ### Generate TypeScript Types
 
 ```typescript
-import { generateTranslationTypes } from 'lexis';
+import { generateTranslationTypes } from 'poly-lexis';
 
 generateTranslationTypes(process.cwd());
 ```
@@ -208,7 +208,7 @@ generateTranslationTypes(process.cwd());
 ### Auto-fill Missing Translations
 
 ```typescript
-import { autoFillTranslations } from 'lexis';
+import { autoFillTranslations } from 'poly-lexis';
 
 await autoFillTranslations({
   translationsPath: '/path/to/translations',

package/dist/cli/translations.js

@@ -48,7 +48,8 @@ function writeTranslation(translationsPath, language, namespace, translations) {
     fs.mkdirSync(langPath, { recursive: true });
   }
   const filePath = path2.join(langPath, `${namespace}.json`);
-  fs.writeFileSync(filePath, JSON.stringify(translations, null, 2) + "\n", "utf-8");
+  fs.writeFileSync(filePath, `${JSON.stringify(translations, null, 2)}
+`, "utf-8");
 }
 function getAvailableLanguages(translationsPath) {
   if (!fs.existsSync(translationsPath)) {
@@ -106,54 +107,274 @@ var init_schema = __esm({
     "use strict";
     init_esm_shims();
     SUPPORTED_LANGUAGES = [
+      "af",
+      // Afrikaans
+      "sq",
+      // Albanian
+      "am",
+      // Amharic
+      "ar",
+      // Arabic
+      "hy",
+      // Armenian
+      "as",
+      // Assamese
+      "ay",
+      // Aymara
+      "az",
+      // Azerbaijani
+      "bm",
+      // Bambara
+      "eu",
+      // Basque
+      "be",
+      // Belarusian
+      "bn",
+      // Bengali
+      "bho",
+      // Bhojpuri
+      "bs",
+      // Bosnian
+      "bg",
+      // Bulgarian
+      "ca",
+      // Catalan
+      "ceb",
+      // Cebuano
+      "ny",
+      // Chichewa
+      "zh",
+      // Chinese (Simplified) - Google uses 'zh' or 'zh-CN'
+      "zh_cn",
+      // Chinese (Simplified) - alternative format
+      "zh_tw",
+      // Chinese (Traditional)
+      "co",
+      // Corsican
+      "hr",
+      // Croatian
+      "cs",
+      // Czech
+      "da",
+      // Danish
+      "dv",
+      // Dhivehi
+      "doi",
+      // Dogri
+      "nl",
+      // Dutch
       "en",
       // English
+      "eo",
+      // Esperanto
+      "et",
+      // Estonian
+      "ee",
+      // Ewe
+      "tl",
+      // Filipino (Tagalog)
+      "fi",
+      // Finnish
       "fr",
       // French
-      "it",
-      // Italian
-      "pl",
-      // Polish
-      "es",
-      // Spanish
-      "pt",
-      // Portuguese
+      "gl",
+      // Galician
+      "ka",
+      // Georgian
       "de",
       // German
-      "de_at",
-      // German (Austria)
-      "nl",
-      // Dutch
-      "sv",
-      // Swedish
+      "el",
+      // Greek
+      "gn",
+      // Guarani
+      "gu",
+      // Gujarati
+      "ht",
+      // Haitian Creole
+      "ha",
+      // Hausa
+      "haw",
+      // Hawaiian
+      "iw",
+      // Hebrew (legacy code, 'he' is preferred)
+      "he",
+      // Hebrew
+      "hi",
+      // Hindi
+      "hmn",
+      // Hmong
       "hu",
       // Hungarian
-      "cs",
-      // Czech
+      "is",
+      // Icelandic
+      "ig",
+      // Igbo
+      "ilo",
+      // Ilocano
+      "id",
+      // Indonesian
+      "ga",
+      // Irish
+      "it",
+      // Italian
       "ja",
       // Japanese
-      "zh_hk",
-      // Chinese (Hong Kong)
-      "zh_cn",
-      // Chinese (Simplified)
+      "jw",
+      // Javanese
+      "kn",
+      // Kannada
+      "kk",
+      // Kazakh
+      "km",
+      // Khmer
+      "rw",
+      // Kinyarwanda
+      "gom",
+      // Konkani
       "ko",
       // Korean
+      "kri",
+      // Krio
+      "ku",
+      // Kurdish (Kurmanji)
+      "ckb",
+      // Kurdish (Sorani)
+      "ky",
+      // Kyrgyz
+      "lo",
+      // Lao
+      "la",
+      // Latin
+      "lv",
+      // Latvian
+      "ln",
+      // Lingala
+      "lt",
+      // Lithuanian
+      "lg",
+      // Luganda
+      "lb",
+      // Luxembourgish
+      "mk",
+      // Macedonian
+      "mai",
+      // Maithili
+      "mg",
+      // Malagasy
+      "ms",
+      // Malay
+      "ml",
+      // Malayalam
+      "mt",
+      // Maltese
+      "mi",
+      // Maori
+      "mr",
+      // Marathi
+      "mni",
+      // Meiteilon (Manipuri)
+      "lus",
+      // Mizo
+      "mn",
+      // Mongolian
+      "my",
+      // Myanmar (Burmese)
+      "ne",
+      // Nepali
+      "no",
+      // Norwegian
+      "or",
+      // Odia
+      "om",
+      // Oromo
+      "ps",
+      // Pashto
+      "fa",
+      // Persian
+      "pl",
+      // Polish
+      "pt",
+      // Portuguese
+      "pt_br",
+      // Portuguese (Brazil)
+      "pa",
+      // Punjabi
+      "qu",
+      // Quechua
+      "ro",
+      // Romanian
       "ru",
       // Russian
-      "ar",
-      // Arabic
-      "he",
-      // Hebrew
+      "sm",
+      // Samoan
+      "sa",
+      // Sanskrit
+      "gd",
+      // Scottish Gaelic
+      "sr",
+      // Serbian
+      "st",
+      // Sesotho
+      "sn",
+      // Shona
+      "sd",
+      // Sindhi
+      "si",
+      // Sinhala
+      "sk",
+      // Slovak
+      "sl",
+      // Slovenian
+      "so",
+      // Somali
+      "es",
+      // Spanish
+      "su",
+      // Sundanese
+      "sw",
+      // Swahili
+      "sv",
+      // Swedish
+      "tg",
+      // Tajik
+      "ta",
+      // Tamil
+      "tt",
+      // Tatar
+      "te",
+      // Telugu
+      "th",
+      // Thai
+      "ti",
+      // Tigrinya
+      "ts",
+      // Tsonga
       "tr",
       // Turkish
-      "da",
-      // Danish
-      "fi",
-      // Finnish
-      "no",
-      // Norwegian
-      "pt_br"
-      // Portuguese (Brazil)
+      "tk",
+      // Turkmen
+      "ak",
+      // Twi
+      "uk",
+      // Ukrainian
+      "ur",
+      // Urdu
+      "ug",
+      // Uyghur
+      "uz",
+      // Uzbek
+      "vi",
+      // Vietnamese
+      "cy",
+      // Welsh
+      "xh",
+      // Xhosa
+      "yi",
+      // Yiddish
+      "yo",
+      // Yoruba
+      "zu"
+      // Zulu
     ];
   }
 });
@@ -255,7 +476,8 @@ function initTranslations(projectRoot, config = {}) {
       ERROR: "Error",
       SUCCESS: "Success"
     };
-    fs2.writeFileSync(commonPath, JSON.stringify(sampleTranslations, null, 2) + "\n", "utf-8");
+    fs2.writeFileSync(commonPath, `${JSON.stringify(sampleTranslations, null, 2)}
+`, "utf-8");
     console.log(`Created sample file: ${commonPath}`);
   }
   for (const lang of languages) {
@@ -275,7 +497,8 @@ function initTranslations(projectRoot, config = {}) {
       sourceLanguage,
       typesOutputPath: finalConfig.typesOutputPath
     };
-    fs2.writeFileSync(configPath, JSON.stringify(configContent, null, 2) + "\n", "utf-8");
+    fs2.writeFileSync(configPath, `${JSON.stringify(configContent, null, 2)}
+`, "utf-8");
     console.log(`Created config file: ${configPath}`);
   }
   console.log("=====");
@@ -357,7 +580,10 @@ function generateTranslationTypes(projectRoot = process.cwd()) {
   console.log(`Generated types with ${allKeys.length} keys and ${namespaces.length} namespaces`);
   console.log(`Output: ${outputFilePath}`);
   try {
-    execSync(`pnpm biome format --write ${outputFilePath}`, { stdio: "inherit", cwd: projectRoot });
+    execSync(`pnpm biome format --write ${outputFilePath}`, {
+      stdio: "inherit",
+      cwd: projectRoot
+    });
   } catch {
     console.warn("Failed to format with Biome, continuing without formatting...");
   }
@@ -384,10 +610,10 @@ var init_generate_types = __esm({
 // src/cli/translations.ts
 init_esm_shims();
 import "dotenv/config";
-import { confirm as confirm2, input as input2, select } from "@inquirer/prompts";
 import * as fs5 from "fs";
 import * as path10 from "path";
 import { parseArgs } from "util";
+import { confirm as confirm2, input as input2, select } from "@inquirer/prompts";
 
 // src/translations/cli/add-key.ts
 init_esm_shims();
@@ -395,10 +621,10 @@ import * as path4 from "path";
 
 // src/translations/utils/translator.ts
 init_esm_shims();
-async function translateText(text, targetLang, sourceLang = "en", apiKey) {
-  if (!apiKey) {
-    throw new Error("Google Translate API key is required. Set GOOGLE_TRANSLATE_API_KEY environment variable.");
-  }
+
+// src/translations/utils/google-translate-provider.ts
+init_esm_shims();
+function preserveVariables(text) {
   const variableMap = /* @__PURE__ */ new Map();
   let placeholderIndex = 0;
   const textWithPlaceholders = text.replace(/\{\{([^}]+)\}\}/g, (match) => {
@@ -407,29 +633,81 @@ async function translateText(text, targetLang, sourceLang = "en", apiKey) {
     placeholderIndex++;
     return placeholder;
   });
-  const url = `https://translation.googleapis.com/language/translate/v2?key=${apiKey}`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      q: textWithPlaceholders,
-      source: sourceLang,
-      target: targetLang.split("_")[0],
-      // Convert 'pt_BR' to 'pt'
-      format: "text"
-    })
-  });
-  const data = await response.json();
-  if (data.error) {
-    throw new Error(`Google Translate API error: ${data.error.message}`);
-  }
-  let translatedText = data.data.translations[0].translatedText;
+  return { textWithPlaceholders, variableMap };
+}
+function restoreVariables(text, variableMap) {
+  let result = text;
   for (const [placeholder, original] of variableMap) {
-    translatedText = translatedText.replace(new RegExp(placeholder, "g"), original);
+    result = result.replace(new RegExp(placeholder, "g"), original);
+  }
+  return result;
+}
+var GoogleTranslateProvider = class {
+  async translate(options) {
+    const { text, sourceLang, targetLang, apiKey } = options;
+    if (!apiKey) {
+      throw new Error(
+        "Google Translate API key is required. Set GOOGLE_TRANSLATE_API_KEY environment variable or provide apiKey in options."
+      );
+    }
+    const { textWithPlaceholders, variableMap } = preserveVariables(text);
+    const url = `https://translation.googleapis.com/language/translate/v2?key=${apiKey}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        q: textWithPlaceholders,
+        source: sourceLang,
+        target: targetLang.split("_")[0],
+        // Convert 'pt_BR' to 'pt'
+        format: "text"
+      })
+    });
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Google Translate API error: ${data.error.message}`);
+    }
+    const translatedText = data.data.translations[0].translatedText;
+    return restoreVariables(translatedText, variableMap);
+  }
+  async translateBatch(texts, sourceLang, targetLang, apiKey, delayMs = 100) {
+    const results = [];
+    for (const text of texts) {
+      const translated = await this.translate({
+        text,
+        sourceLang,
+        targetLang,
+        apiKey
+      });
+      results.push(translated);
+      if (delayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+    return results;
   }
-  return translatedText;
+  async validateConfig() {
+    const apiKey = process.env.GOOGLE_TRANSLATE_API_KEY;
+    return !!apiKey;
+  }
+};
+
+// src/translations/utils/translator.ts
+var defaultProvider = new GoogleTranslateProvider();
+var customProvider = null;
+function getTranslationProvider() {
+  return customProvider || defaultProvider;
+}
+async function translateText(text, targetLang, sourceLang = "en", apiKey) {
+  const provider = getTranslationProvider();
+  return provider.translate({
+    text,
+    sourceLang,
+    targetLang,
+    apiKey
+  });
 }
 
 // src/translations/cli/add-key.ts