poly-lexis 0.3.2 → 0.4.1

package/dist/index.js

@@ -8,87 +8,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/translations/utils/utils.ts
-import * as fs from "fs";
-import * as path from "path";
-function readTranslations(translationsPath, language) {
-  const langPath = path.join(translationsPath, language);
-  if (!fs.existsSync(langPath)) {
-    return {};
-  }
-  const files = fs.readdirSync(langPath).filter((f) => f.endsWith(".json"));
-  const translations = {};
-  for (const file of files) {
-    const namespace = path.basename(file, ".json");
-    const filePath = path.join(langPath, file);
-    const content = fs.readFileSync(filePath, "utf-8");
-    translations[namespace] = JSON.parse(content);
-  }
-  return translations;
-}
-function writeTranslation(translationsPath, language, namespace, translations) {
-  const langPath = path.join(translationsPath, language);
-  if (!fs.existsSync(langPath)) {
-    fs.mkdirSync(langPath, { recursive: true });
-  }
-  const filePath = path.join(langPath, `${namespace}.json`);
-  fs.writeFileSync(filePath, `${JSON.stringify(translations, null, 2)}
-`, "utf-8");
-}
-function getAvailableLanguages(translationsPath) {
-  if (!fs.existsSync(translationsPath)) {
-    return [];
-  }
-  return fs.readdirSync(translationsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
-}
-function getNamespaces(translationsPath, language) {
-  const langPath = path.join(translationsPath, language);
-  if (!fs.existsSync(langPath)) {
-    return [];
-  }
-  return fs.readdirSync(langPath).filter((f) => f.endsWith(".json")).map((f) => path.basename(f, ".json"));
-}
-function hasInterpolation(text) {
-  return /\{\{[^}]+\}\}/g.test(text);
-}
-function extractVariables(text) {
-  const matches = text.match(/\{\{([^}]+)\}\}/g);
-  if (!matches) return [];
-  return matches.map((match) => match.replace(/\{\{|\}\}/g, "").trim());
-}
-function validateVariables(sourceText, translatedText) {
-  const sourceVars = extractVariables(sourceText).sort();
-  const translatedVars = extractVariables(translatedText).sort();
-  if (sourceVars.length !== translatedVars.length) {
-    return false;
-  }
-  return sourceVars.every((v, i) => v === translatedVars[i]);
-}
-function sortKeys(obj) {
-  const sorted = {};
-  const keys = Object.keys(obj).sort();
-  for (const key of keys) {
-    sorted[key] = obj[key];
-  }
-  return sorted;
-}
-function ensureTranslationsStructure(translationsPath, languages) {
-  if (!fs.existsSync(translationsPath)) {
-    fs.mkdirSync(translationsPath, { recursive: true });
-  }
-  for (const lang of languages) {
-    const langPath = path.join(translationsPath, lang);
-    if (!fs.existsSync(langPath)) {
-      fs.mkdirSync(langPath, { recursive: true });
-    }
-  }
-}
-var init_utils = __esm({
-  "src/translations/utils/utils.ts"() {
-    "use strict";
-  }
-});
-
 // src/translations/core/schema.ts
 function isValidLanguage(lang) {
   return SUPPORTED_LANGUAGES.includes(lang);
@@ -112,14 +31,14 @@ function isValidLanguageForProvider(lang, provider) {
 function validateLanguages(languages) {
   const invalid = languages.filter((lang) => !isValidLanguage(lang));
   return {
-    valid: invalid.length === 0,
+    valid: !invalid.length,
     invalid
   };
 }
 function validateLanguagesForProvider(languages, provider) {
   const invalid = languages.filter((lang) => !isValidLanguageForProvider(lang, provider));
   return {
-    valid: invalid.length === 0,
+    valid: !invalid.length,
     invalid
   };
 }
@@ -137,6 +56,7 @@ var TRANSLATION_PROVIDERS, DEEPL_LANGUAGES, GOOGLE_LANGUAGES, SUPPORTED_LANGUAGE
 var init_schema = __esm({
   "src/translations/core/schema.ts"() {
     "use strict";
+    init_language_fallback();
     TRANSLATION_PROVIDERS = ["deepl", "google"];
     DEEPL_LANGUAGES = [
       "ar",
@@ -490,6 +410,11 @@ var init_schema = __esm({
           description: "Translation provider to use (deepl or google)",
           enum: TRANSLATION_PROVIDERS,
           default: "deepl"
+        },
+        useFallbackLanguages: {
+          type: "boolean",
+          description: "Enable automatic language fallback for unsupported regional variants (e.g., de_at -> de)",
+          default: false
         }
       },
       required: ["translationsPath", "languages", "sourceLanguage"],
@@ -498,6 +423,314 @@ var init_schema = __esm({
   }
 });
 
+// src/translations/utils/language-fallback.ts
+function resolveLanguageWithFallback(language, provider, enableFallback = true) {
+  const normalizedLanguage = language.toLowerCase();
+  const supportedLanguages = getSupportedLanguagesForProvider(provider);
+  if (isLanguageSupported(normalizedLanguage, supportedLanguages)) {
+    return {
+      resolvedLanguage: normalizedLanguage,
+      usedFallback: false,
+      originalLanguage: language
+    };
+  }
+  if (!enableFallback) {
+    return {
+      resolvedLanguage: normalizedLanguage,
+      usedFallback: false,
+      originalLanguage: language
+    };
+  }
+  const fallbackChain = LANGUAGE_FALLBACK_MAP[normalizedLanguage] || [];
+  for (const fallbackLang of fallbackChain) {
+    if (isLanguageSupported(fallbackLang, supportedLanguages)) {
+      return {
+        resolvedLanguage: fallbackLang,
+        usedFallback: true,
+        originalLanguage: language,
+        fallbackChain: [normalizedLanguage, ...fallbackChain]
+      };
+    }
+  }
+  const baseLang = normalizedLanguage.split("_")[0];
+  if (baseLang !== normalizedLanguage && isLanguageSupported(baseLang, supportedLanguages)) {
+    return {
+      resolvedLanguage: baseLang,
+      usedFallback: true,
+      originalLanguage: language,
+      fallbackChain: [normalizedLanguage, baseLang]
+    };
+  }
+  return {
+    resolvedLanguage: normalizedLanguage,
+    usedFallback: false,
+    originalLanguage: language
+  };
+}
+function getSupportedLanguagesForProvider(provider) {
+  switch (provider) {
+    case "deepl":
+      return DEEPL_LANGUAGES;
+    case "google":
+      return GOOGLE_LANGUAGES;
+    default:
+      return [];
+  }
+}
+function isLanguageSupported(language, supportedLanguages) {
+  return supportedLanguages.includes(language);
+}
+function logLanguageFallback(result, provider) {
+  if (result.usedFallback) {
+    console.warn(
+      `\u26A0\uFE0F  Language fallback: '${result.originalLanguage}' is not supported by ${provider}, using '${result.resolvedLanguage}' instead`
+    );
+    if (result.fallbackChain && result.fallbackChain.length > 2) {
+      console.warn(`   Fallback chain: ${result.fallbackChain.join(" \u2192 ")}`);
+    }
+  }
+}
+function getFallbackMappings() {
+  return { ...LANGUAGE_FALLBACK_MAP };
+}
+var LANGUAGE_FALLBACK_MAP;
+var init_language_fallback = __esm({
+  "src/translations/utils/language-fallback.ts"() {
+    "use strict";
+    init_schema();
+    LANGUAGE_FALLBACK_MAP = {
+      // German variants
+      de_at: ["de"],
+      // Austrian German -> German
+      de_ch: ["de"],
+      // Swiss German -> German
+      de_de: ["de"],
+      // Standard German -> German
+      // English variants
+      en_gb: ["en"],
+      // British English -> English
+      en_us: ["en"],
+      // American English -> English
+      en_au: ["en"],
+      // Australian English -> English
+      en_ca: ["en"],
+      // Canadian English -> English
+      en_nz: ["en"],
+      // New Zealand English -> English
+      // Chinese variants (Hong Kong, Taiwan -> Traditional)
+      zh_hk: ["zh_hant", "zh"],
+      // Hong Kong Chinese -> Traditional Chinese -> Chinese
+      zh_tw: ["zh_hant", "zh"],
+      // Taiwan Chinese -> Traditional Chinese -> Chinese
+      zh_mo: ["zh_hant", "zh"],
+      // Macau Chinese -> Traditional Chinese -> Chinese
+      // Chinese variants (Mainland, Singapore -> Simplified)
+      zh_cn: ["zh_hans", "zh"],
+      // Mainland Chinese -> Simplified Chinese -> Chinese
+      zh_sg: ["zh_hans", "zh"],
+      // Singapore Chinese -> Simplified Chinese -> Chinese
+      // Portuguese variants
+      pt_pt: ["pt"],
+      // European Portuguese -> Portuguese
+      pt_ao: ["pt"],
+      // Angolan Portuguese -> Portuguese
+      pt_mz: ["pt"],
+      // Mozambican Portuguese -> Portuguese
+      // Spanish variants (Latin America)
+      es_mx: ["es_419", "es"],
+      // Mexican Spanish -> Latin American Spanish -> Spanish
+      es_ar: ["es_419", "es"],
+      // Argentine Spanish -> Latin American Spanish -> Spanish
+      es_co: ["es_419", "es"],
+      // Colombian Spanish -> Latin American Spanish -> Spanish
+      es_cl: ["es_419", "es"],
+      // Chilean Spanish -> Latin American Spanish -> Spanish
+      es_pe: ["es_419", "es"],
+      // Peruvian Spanish -> Latin American Spanish -> Spanish
+      es_ve: ["es_419", "es"],
+      // Venezuelan Spanish -> Latin American Spanish -> Spanish
+      es_ec: ["es_419", "es"],
+      // Ecuadorian Spanish -> Latin American Spanish -> Spanish
+      es_gt: ["es_419", "es"],
+      // Guatemalan Spanish -> Latin American Spanish -> Spanish
+      es_cu: ["es_419", "es"],
+      // Cuban Spanish -> Latin American Spanish -> Spanish
+      es_do: ["es_419", "es"],
+      // Dominican Spanish -> Latin American Spanish -> Spanish
+      es_hn: ["es_419", "es"],
+      // Honduran Spanish -> Latin American Spanish -> Spanish
+      es_ni: ["es_419", "es"],
+      // Nicaraguan Spanish -> Latin American Spanish -> Spanish
+      es_sv: ["es_419", "es"],
+      // Salvadoran Spanish -> Latin American Spanish -> Spanish
+      es_cr: ["es_419", "es"],
+      // Costa Rican Spanish -> Latin American Spanish -> Spanish
+      es_pa: ["es_419", "es"],
+      // Panamanian Spanish -> Latin American Spanish -> Spanish
+      es_uy: ["es_419", "es"],
+      // Uruguayan Spanish -> Latin American Spanish -> Spanish
+      es_py: ["es_419", "es"],
+      // Paraguayan Spanish -> Latin American Spanish -> Spanish
+      es_bo: ["es_419", "es"],
+      // Bolivian Spanish -> Latin American Spanish -> Spanish
+      // Spanish (European)
+      es_es: ["es"],
+      // European Spanish -> Spanish
+      // French variants
+      fr_ca: ["fr"],
+      // Canadian French -> French
+      fr_ch: ["fr"],
+      // Swiss French -> French
+      fr_be: ["fr"],
+      // Belgian French -> French
+      fr_fr: ["fr"],
+      // Standard French -> French
+      // Norwegian variants
+      no: ["nb"],
+      // Norwegian -> Norwegian Bokmål
+      nn: ["nb"],
+      // Norwegian Nynorsk -> Norwegian Bokmål
+      // Other regional variants
+      it_ch: ["it"],
+      // Swiss Italian -> Italian
+      nl_be: ["nl"],
+      // Belgian Dutch (Flemish) -> Dutch
+      sv_fi: ["sv"],
+      // Finland Swedish -> Swedish
+      ar_ae: ["ar"],
+      // UAE Arabic -> Arabic
+      ar_sa: ["ar"],
+      // Saudi Arabic -> Arabic
+      ar_eg: ["ar"]
+      // Egyptian Arabic -> Arabic
+    };
+  }
+});
+
+// src/translations/utils/utils.ts
+import * as fs from "fs";
+import * as path from "path";
+function readTranslations(translationsPath, language) {
+  const langPath = path.join(translationsPath, language);
+  if (!fs.existsSync(langPath)) {
+    return {};
+  }
+  const files = fs.readdirSync(langPath).filter((f) => f.endsWith(".json"));
+  const translations = {};
+  for (const file of files) {
+    const namespace = path.basename(file, ".json");
+    const filePath = path.join(langPath, file);
+    const content = fs.readFileSync(filePath, "utf-8");
+    translations[namespace] = JSON.parse(content);
+  }
+  return translations;
+}
+function writeTranslation(translationsPath, language, namespace, translations) {
+  const langPath = path.join(translationsPath, language);
+  if (!fs.existsSync(langPath)) {
+    fs.mkdirSync(langPath, { recursive: true });
+  }
+  const filePath = path.join(langPath, `${namespace}.json`);
+  fs.writeFileSync(filePath, `${JSON.stringify(translations, null, 2)}
+`, "utf-8");
+}
+function getAvailableLanguages(translationsPath) {
+  if (!fs.existsSync(translationsPath)) {
+    return [];
+  }
+  return fs.readdirSync(translationsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+}
+function getNamespaces(translationsPath, language) {
+  const langPath = path.join(translationsPath, language);
+  if (!fs.existsSync(langPath)) {
+    return [];
+  }
+  return fs.readdirSync(langPath).filter((f) => f.endsWith(".json")).map((f) => path.basename(f, ".json"));
+}
+function hasInterpolation(text) {
+  return /\{\{[^}]+\}\}/g.test(text);
+}
+function extractVariables(text) {
+  const matches = text.match(/\{\{([^}]+)\}\}/g);
+  if (!matches) return [];
+  return matches.map((match) => match.replace(/\{\{|\}\}/g, "").trim());
+}
+function validateVariables(sourceText, translatedText) {
+  const sourceVars = extractVariables(sourceText).sort();
+  const translatedVars = extractVariables(translatedText).sort();
+  if (sourceVars.length !== translatedVars.length) {
+    return false;
+  }
+  return sourceVars.every((v, i) => v === translatedVars[i]);
+}
+function sortKeys(obj) {
+  const sorted = {};
+  const keys = Object.keys(obj).sort();
+  for (const key of keys) {
+    sorted[key] = obj[key];
+  }
+  return sorted;
+}
+function ensureTranslationsStructure(translationsPath, languages) {
+  if (!fs.existsSync(translationsPath)) {
+    fs.mkdirSync(translationsPath, { recursive: true });
+  }
+  for (const lang of languages) {
+    const langPath = path.join(translationsPath, lang);
+    if (!fs.existsSync(langPath)) {
+      fs.mkdirSync(langPath, { recursive: true });
+    }
+  }
+}
+function createEmptyTranslationStructure(sourceFile) {
+  const result = {};
+  for (const key of Object.keys(sourceFile)) {
+    result[key] = "";
+  }
+  return result;
+}
+function syncTranslationStructure(translationsPath, languages, sourceLanguage) {
+  const result = {
+    createdFolders: [],
+    createdFiles: [],
+    skippedFiles: []
+  };
+  ensureTranslationsStructure(translationsPath, languages);
+  const sourceNamespaces = getNamespaces(translationsPath, sourceLanguage);
+  if (!sourceNamespaces.length) {
+    return result;
+  }
+  const sourceTranslations = readTranslations(translationsPath, sourceLanguage);
+  const targetLanguages = languages.filter((lang) => lang !== sourceLanguage);
+  for (const language of targetLanguages) {
+    for (const namespace of sourceNamespaces) {
+      const filePath = path.join(translationsPath, language, `${namespace}.json`);
+      if (fs.existsSync(filePath)) {
+        result.skippedFiles.push({
+          language,
+          namespace,
+          reason: "already exists"
+        });
+        continue;
+      }
+      const sourceFile = sourceTranslations[namespace] || {};
+      const emptyStructure = createEmptyTranslationStructure(sourceFile);
+      writeTranslation(translationsPath, language, namespace, emptyStructure);
+      result.createdFiles.push({
+        language,
+        namespace,
+        path: filePath
+      });
+    }
+  }
+  return result;
+}
+var init_utils = __esm({
+  "src/translations/utils/utils.ts"() {
+    "use strict";
+  }
+});
+
 // src/translations/core/types.ts
 var DEFAULT_CONFIG, DEFAULT_LANGUAGES;
 var init_types = __esm({
@@ -507,24 +740,11 @@ var init_types = __esm({
       translationsPath: "public/static/locales",
       languages: ["en"],
       sourceLanguage: "en",
-      typesOutputPath: "src/types/i18nTypes.ts"
+      typesOutputPath: "src/types/i18nTypes.ts",
+      provider: "google",
+      useFallbackLanguages: true
     };
-    DEFAULT_LANGUAGES = [
-      "en",
-      "fr",
-      "it",
-      "pl",
-      "es",
-      "pt",
-      "de",
-      "de_at",
-      "nl",
-      "sv",
-      "hu",
-      "cs",
-      "ja",
-      "zh_hk"
-    ];
+    DEFAULT_LANGUAGES = ["en", "fr", "it", "pl", "es", "pt", "de", "nl", "sv", "hu", "cs", "ja"];
   }
 });
 
@@ -598,12 +818,14 @@ function initTranslations(projectRoot, config = {}) {
 `, "utf-8");
     console.log(`Created sample file: ${commonPath}`);
   }
-  for (const lang of languages) {
-    if (lang === sourceLanguage) continue;
-    const langCommonPath = path2.join(translationsPath, lang, "common.json");
-    if (!fs2.existsSync(langCommonPath)) {
-      fs2.writeFileSync(langCommonPath, "{}\n", "utf-8");
-      console.log(`Created empty file: ${langCommonPath}`);
+  console.log("\nSynchronizing translation structure...");
+  const syncResult = syncTranslationStructure(translationsPath, languages, sourceLanguage);
+  if (syncResult.createdFiles.length > 0) {
+    console.log(`Created ${syncResult.createdFiles.length} namespace files in target languages`);
+    const languageGroups = new Set(syncResult.createdFiles.map((f) => f.language));
+    for (const lang of languageGroups) {
+      const langFiles = syncResult.createdFiles.filter((f) => f.language === lang);
+      console.log(`  ${lang}: ${langFiles.map((f) => f.namespace).join(", ")}`);
     }
   }
   const configPath = path2.join(projectRoot, ".translationsrc.json");
@@ -613,7 +835,8 @@ function initTranslations(projectRoot, config = {}) {
       translationsPath: finalConfig.translationsPath,
       languages,
       sourceLanguage,
-      typesOutputPath: finalConfig.typesOutputPath
+      typesOutputPath: finalConfig.typesOutputPath,
+      provider: finalConfig.provider
     };
     fs2.writeFileSync(configPath, `${JSON.stringify(configContent, null, 2)}
 `, "utf-8");
@@ -661,6 +884,7 @@ var init_init = __esm({
 import * as path3 from "path";
 
 // src/translations/utils/google-translate-provider.ts
+init_language_fallback();
 function preserveVariables(text) {
   const variableMap = /* @__PURE__ */ new Map();
   let placeholderIndex = 0;
@@ -681,14 +905,24 @@ function restoreVariables(text, variableMap) {
 }
 var GoogleTranslateProvider = class {
   async translate(options) {
-    const { text, sourceLang, targetLang, apiKey } = options;
+    const { text, sourceLang, targetLang, apiKey, useFallbackLanguages = true } = 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 targetLangResult = resolveLanguageWithFallback(targetLang, "google", useFallbackLanguages);
+    logLanguageFallback(targetLangResult, "google");
+    let resolvedSourceLang;
+    if (sourceLang) {
+      const sourceLangResult = resolveLanguageWithFallback(sourceLang, "google", useFallbackLanguages);
+      logLanguageFallback(sourceLangResult, "google");
+      resolvedSourceLang = sourceLangResult.resolvedLanguage;
+    }
     const { textWithPlaceholders, variableMap } = preserveVariables(text);
     const url = `https://translation.googleapis.com/language/translate/v2?key=${apiKey}`;
+    const sourceForGoogle = resolvedSourceLang?.includes("_") ? resolvedSourceLang.split("_")[0] : resolvedSourceLang;
+    const targetForGoogle = targetLangResult.resolvedLanguage.includes("_") ? targetLangResult.resolvedLanguage.split("_")[0] : targetLangResult.resolvedLanguage;
     const response = await fetch(url, {
       method: "POST",
       headers: {
@@ -696,9 +930,8 @@ var GoogleTranslateProvider = class {
       },
       body: JSON.stringify({
         q: textWithPlaceholders,
-        source: sourceLang,
-        target: targetLang.split("_")[0],
-        // Convert 'pt_BR' to 'pt'
+        source: sourceForGoogle,
+        target: targetForGoogle,
         format: "text"
       })
     });
@@ -743,13 +976,14 @@ function getTranslationProvider() {
 function resetTranslationProvider() {
   customProvider = null;
 }
-async function translateText(text, targetLang, sourceLang = "en", apiKey) {
+async function translateText(text, targetLang, sourceLang = "en", apiKey, useFallbackLanguages = true) {
   const provider = getTranslationProvider();
   return provider.translate({
     text,
     sourceLang,
     targetLang,
-    apiKey
+    apiKey,
+    useFallbackLanguages
   });
 }
 async function translateBatch(texts, targetLang, sourceLang = "en", apiKey, delayMs = 100) {
@@ -845,6 +1079,101 @@ async function addTranslationKeys(projectRoot, entries, autoTranslate = false, a
 
 // src/translations/cli/auto-fill.ts
 import * as path5 from "path";
+
+// src/translations/utils/deepl-translate-provider.ts
+init_language_fallback();
+function preserveVariables2(text) {
+  const variableMap = /* @__PURE__ */ new Map();
+  let placeholderIndex = 0;
+  const textWithPlaceholders = text.replace(/\{\{([^}]+)\}\}/g, (match) => {
+    const placeholder = `XXX_${placeholderIndex}_XXX`;
+    variableMap.set(placeholder, match);
+    placeholderIndex++;
+    return placeholder;
+  });
+  return { textWithPlaceholders, variableMap };
+}
+function restoreVariables2(text, variableMap) {
+  let result = text;
+  for (const [placeholder, original] of variableMap) {
+    result = result.replace(new RegExp(placeholder, "g"), original);
+  }
+  return result;
+}
+function normalizeLanguageCode(langCode) {
+  return langCode.replace("_", "-").toUpperCase();
+}
+var DeepLTranslateProvider = class {
+  isFreeApi;
+  constructor(isFreeApi = false) {
+    this.isFreeApi = isFreeApi;
+  }
+  getApiEndpoint() {
+    return this.isFreeApi ? "https://api-free.deepl.com/v2/translate" : "https://api.deepl.com/v2/translate";
+  }
+  async translate(options) {
+    const { text, sourceLang, targetLang, apiKey, useFallbackLanguages = true } = options;
+    if (!apiKey) {
+      throw new Error(
+        "DeepL API key is required. Set DEEPL_API_KEY environment variable or provide apiKey in options."
+      );
+    }
+    const targetLangResult = resolveLanguageWithFallback(targetLang, "deepl", useFallbackLanguages);
+    logLanguageFallback(targetLangResult, "deepl");
+    let resolvedSourceLang;
+    if (sourceLang) {
+      const sourceLangResult = resolveLanguageWithFallback(sourceLang, "deepl", useFallbackLanguages);
+      logLanguageFallback(sourceLangResult, "deepl");
+      resolvedSourceLang = sourceLangResult.resolvedLanguage;
+    }
+    const { textWithPlaceholders, variableMap } = preserveVariables2(text);
+    const body = {
+      text: [textWithPlaceholders],
+      target_lang: normalizeLanguageCode(targetLangResult.resolvedLanguage),
+      ...resolvedSourceLang && { source_lang: normalizeLanguageCode(resolvedSourceLang) }
+    };
+    const response = await fetch(this.getApiEndpoint(), {
+      method: "POST",
+      headers: {
+        Authorization: `DeepL-Auth-Key ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`DeepL API error: ${errorData.message || response.statusText} (${response.status})`);
+    }
+    const data = await response.json();
+    if (!data.translations || data.translations.length === 0) {
+      throw new Error("DeepL API returned no translations");
+    }
+    const translatedText = data.translations[0].text;
+    return restoreVariables2(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;
+  }
+  async validateConfig() {
+    const apiKey = process.env.DEEPL_API_KEY;
+    return !!apiKey;
+  }
+};
+
+// src/translations/cli/auto-fill.ts
 init_utils();
 init_init();
 
@@ -860,7 +1189,11 @@ function validateTranslations(projectRoot = process.cwd()) {
   const empty = [];
   const sourceTranslations = readTranslations(translationsPath, sourceLanguage);
   const sourceNamespaces = getNamespaces(translationsPath, sourceLanguage);
-  const languages = getAvailableLanguages(translationsPath).filter((lang) => lang !== sourceLanguage);
+  const languages = config.languages.filter((lang) => lang !== sourceLanguage);
+  const syncResult = syncTranslationStructure(translationsPath, config.languages, sourceLanguage);
+  if (syncResult.createdFiles.length > 0) {
+    console.log(`Created ${syncResult.createdFiles.length} missing namespace files during sync`);
+  }
   console.log("=====");
   console.log("Validating translations");
   console.log("=====");
@@ -893,7 +1226,7 @@ function validateTranslations(projectRoot = process.cwd()) {
       }
     }
   }
-  const valid = missing.length === 0 && empty.length === 0;
+  const valid = !missing.length && !empty.length;
   if (valid) {
     console.log("\u2713 All translations are valid!");
   } else {
@@ -935,10 +1268,28 @@ async function autoFillTranslations(projectRoot = process.cwd(), options = {}) {
   const config = loadConfig(projectRoot);
   const translationsPath = path5.join(projectRoot, config.translationsPath);
   const { apiKey, limit = 1e3, delayMs = 100, dryRun = false } = options;
+  const currentProvider = getTranslationProvider();
+  const isDefaultGoogleProvider = currentProvider.constructor.name === "GoogleTranslateProvider";
+  if (isDefaultGoogleProvider) {
+    const provider = config.provider || "deepl";
+    if (provider === "deepl") {
+      setTranslationProvider(new DeepLTranslateProvider());
+    } else {
+      setTranslationProvider(new GoogleTranslateProvider());
+    }
+  }
   if (!apiKey) {
-    throw new Error("Google Translate API key is required. Set GOOGLE_TRANSLATE_API_KEY or pass --api-key");
+    const provider = config.provider || "deepl";
+    const envVarName = provider === "google" ? "GOOGLE_TRANSLATE_API_KEY" : "DEEPL_API_KEY";
+    throw new Error(`Translation API key is required. Set ${envVarName} or pass --api-key`);
   }
   const languagesToProcess = options.language ? [options.language] : config.languages.filter((lang) => lang !== config.sourceLanguage);
+  console.log("\u{1F504} Synchronizing translation structure...");
+  const syncResult = syncTranslationStructure(translationsPath, config.languages, config.sourceLanguage);
+  if (syncResult.createdFiles.length > 0) {
+    console.log(`Created ${syncResult.createdFiles.length} namespace files
+`);
+  }
   console.log("=====");
   console.log("Auto-filling translations");
   console.log("=====");
@@ -957,7 +1308,7 @@ Reached limit of ${limit} translations`);
     console.log(`
 Processing language: ${language}`);
     const missing = getMissingForLanguage(projectRoot, language);
-    if (missing.length === 0) {
+    if (!missing.length) {
       console.log("  No missing or empty translations");
       continue;
     }
@@ -969,7 +1320,13 @@ Processing language: ${language}`);
       try {
         console.log(`  [${totalProcessed}/${limit}] Translating ${item.namespace}.${item.key}`);
         console.log(`    EN: "${item.sourceValue}"`);
-        const translated = await translateText(item.sourceValue, language, config.sourceLanguage, apiKey);
+        const translated = await translateText(
+          item.sourceValue,
+          language,
+          config.sourceLanguage,
+          apiKey,
+          config.useFallbackLanguages ?? true
+        );
         console.log(`    ${language.toUpperCase()}: "${translated}"`);
         if (!dryRun) {
           const translations = readTranslations(translationsPath, language);
@@ -1003,6 +1360,16 @@ Processing language: ${language}`);
 async function fillNamespace(projectRoot, language, namespace, apiKey) {
   const config = loadConfig(projectRoot);
   const translationsPath = path5.join(projectRoot, config.translationsPath);
+  const currentProvider = getTranslationProvider();
+  const isDefaultGoogleProvider = currentProvider.constructor.name === "GoogleTranslateProvider";
+  if (isDefaultGoogleProvider) {
+    const provider = config.provider || "deepl";
+    if (provider === "deepl") {
+      setTranslationProvider(new DeepLTranslateProvider());
+    } else {
+      setTranslationProvider(new GoogleTranslateProvider());
+    }
+  }
   console.log(`Filling translations for ${language}/${namespace}.json`);
   const sourceTranslations = readTranslations(translationsPath, config.sourceLanguage);
   const targetTranslations = readTranslations(translationsPath, language);
@@ -1015,7 +1382,13 @@ async function fillNamespace(projectRoot, language, namespace, apiKey) {
       continue;
     }
     console.log(`  Translating ${key}...`);
-    const translated = await translateText(sourceValue, language, config.sourceLanguage, apiKey);
+    const translated = await translateText(
+      sourceValue,
+      language,
+      config.sourceLanguage,
+      apiKey,
+      config.useFallbackLanguages ?? true
+    );
     targetKeys[key] = translated;
     count++;
     await new Promise((resolve) => setTimeout(resolve, 100));
@@ -1056,7 +1429,7 @@ function generateTranslationTypes(projectRoot = process.cwd()) {
     throw new Error(`Source language directory not found: ${dirPath}`);
   }
   const namespaces = getNamespaces(translationsPath, sourceLanguage);
-  if (namespaces.length === 0) {
+  if (!namespaces.length) {
     throw new Error(`No translation files found in ${dirPath}`);
   }
   const translations = readTranslations(translationsPath, sourceLanguage);
@@ -1094,7 +1467,7 @@ init_types();
 init_init();
 import * as fs4 from "fs";
 import * as path7 from "path";
-import { checkbox, confirm, input } from "@inquirer/prompts";
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
 async function initTranslationsInteractive(projectRoot = process.cwd()) {
   console.log("\n\u{1F30D} Translation System Setup\n");
   const configPath = path7.join(projectRoot, ".translationsrc.json");
@@ -1173,11 +1546,28 @@ async function initTranslationsInteractive(projectRoot = process.cwd()) {
     message: "Where should TypeScript types be generated?",
     default: DEFAULT_CONFIG.typesOutputPath
   });
+  const provider = await select({
+    message: "Which translation provider would you like to use?",
+    choices: [
+      {
+        name: "DeepL (recommended)",
+        value: "deepl",
+        description: "High-quality translations, requires DEEPL_API_KEY"
+      },
+      {
+        name: "Google Translate",
+        value: "google",
+        description: "Google Cloud Translation API, requires GOOGLE_TRANSLATE_API_KEY"
+      }
+    ],
+    default: "deepl"
+  });
   console.log("\n\u{1F4CB} Configuration Summary:");
   console.log(`   Translations: ${translationsPath}`);
   console.log(`   Languages: ${languages.join(", ")}`);
   console.log(`   Source: ${sourceLanguage}`);
   console.log(`   Types: ${typesOutputPath}`);
+  console.log(`   Provider: ${provider}`);
   const confirmInit = await confirm({
     message: "\nProceed with initialization?",
     default: true
@@ -1190,7 +1580,8 @@ async function initTranslationsInteractive(projectRoot = process.cwd()) {
     translationsPath,
     languages,
     sourceLanguage,
-    typesOutputPath
+    typesOutputPath,
+    provider
   };
   console.log();
   initTranslations(projectRoot, config);
@@ -1247,6 +1638,7 @@ function getLanguageName(code) {
 }
 
 // src/translations/cli/manage.ts
+init_utils();
 import * as fs5 from "fs";
 import * as path8 from "path";
 init_init();
@@ -1272,6 +1664,14 @@ async function manageTranslations(projectRoot = process.cwd(), options = {}) {
     console.log("Please add translation files to the source language directory.\n");
     return false;
   }
+  console.log("\u{1F504} Synchronizing translation structure...\n");
+  const syncResult = syncTranslationStructure(translationsPath, config.languages, config.sourceLanguage);
+  if (syncResult.createdFiles.length > 0) {
+    console.log(`\u2713 Created ${syncResult.createdFiles.length} namespace files
+`);
+  } else {
+    console.log("\u2713 Translation structure is already synchronized\n");
+  }
   console.log("\u{1F50D} Validating translations...\n");
   const validationResult = validateTranslations(projectRoot);
   if (validationResult.valid) {
@@ -1280,8 +1680,11 @@ async function manageTranslations(projectRoot = process.cwd(), options = {}) {
     const totalMissing = validationResult.missing.length + validationResult.empty.length;
     if (autoFill) {
       if (!apiKey) {
+        const provider = config.provider || "deepl";
+        const envVarName = provider === "google" ? "GOOGLE_TRANSLATE_API_KEY" : "DEEPL_API_KEY";
         console.log("\n\u26A0\uFE0F  Auto-fill requested but no API key provided.");
-        console.log("Set GOOGLE_TRANSLATE_API_KEY or pass --api-key to enable auto-fill.\n");
+        console.log(`Set ${envVarName} or pass --api-key to enable auto-fill.
+`);
       } else {
         console.log(`
 \u{1F916} Auto-filling ${totalMissing} missing translations...
@@ -1357,12 +1760,14 @@ export {
   addTranslationKey,
   addTranslationKeys,
   autoFillTranslations,
+  createEmptyTranslationStructure,
   detectExistingTranslations,
   ensureTranslationsStructure,
   extractVariables,
   fillNamespace,
   generateTranslationTypes,
   getAvailableLanguages,
+  getFallbackMappings,
   getMissingForLanguage,
   getNamespaces,
   getSupportedLanguages,
@@ -1375,11 +1780,14 @@ export {
   isValidLanguage,
   isValidLanguageForProvider,
   loadConfig,
+  logLanguageFallback,
   manageTranslations,
   readTranslations,
   resetTranslationProvider,
+  resolveLanguageWithFallback,
   setTranslationProvider,
   sortKeys,
+  syncTranslationStructure,
   translateBatch,
   translateText,
   validateLanguages,