poly-lexis 0.4.1 → 0.4.3

package/dist/index.d.ts

@@ -199,7 +199,7 @@ interface AddKeyOptions {
     value: string;
     /** Auto-translate to all languages */
     autoTranslate?: boolean;
-    /** Google Translate API key */
+    /** Translation API key (DeepL or Google Translate) */
     apiKey?: string;
 }
 /**

package/dist/index.js

@@ -741,7 +741,7 @@ var init_types = __esm({
       languages: ["en"],
       sourceLanguage: "en",
       typesOutputPath: "src/types/i18nTypes.ts",
-      provider: "google",
+      provider: "deepl",
       useFallbackLanguages: true
     };
     DEFAULT_LANGUAGES = ["en", "fr", "it", "pl", "es", "pt", "de", "nl", "sv", "hu", "cs", "ja"];
@@ -881,9 +881,9 @@ var init_init = __esm({
 });
 
 // src/translations/cli/add-key.ts
-import * as path3 from "path";
+import * as path4 from "path";
 
-// src/translations/utils/google-translate-provider.ts
+// src/translations/utils/deepl-translate-provider.ts
 init_language_fallback();
 function preserveVariables(text) {
   const variableMap = /* @__PURE__ */ new Map();
@@ -903,6 +903,99 @@ function restoreVariables(text, variableMap) {
   }
   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 } = preserveVariables(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 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;
+  }
+  async validateConfig() {
+    const apiKey = process.env.DEEPL_API_KEY;
+    return !!apiKey;
+  }
+};
+
+// src/translations/utils/google-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;
+}
 var GoogleTranslateProvider = class {
   async translate(options) {
     const { text, sourceLang, targetLang, apiKey, useFallbackLanguages = true } = options;
@@ -919,7 +1012,7 @@ var GoogleTranslateProvider = class {
       logLanguageFallback(sourceLangResult, "google");
       resolvedSourceLang = sourceLangResult.resolvedLanguage;
     }
-    const { textWithPlaceholders, variableMap } = preserveVariables(text);
+    const { textWithPlaceholders, variableMap } = preserveVariables2(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;
@@ -940,7 +1033,7 @@ var GoogleTranslateProvider = class {
       throw new Error(`Google Translate API error: ${data.error.message}`);
     }
     const translatedText = data.data.translations[0].translatedText;
-    return restoreVariables(translatedText, variableMap);
+    return restoreVariables2(translatedText, variableMap);
   }
   async translateBatch(texts, sourceLang, targetLang, apiKey, delayMs = 100) {
     const results = [];
@@ -993,11 +1086,79 @@ async function translateBatch(texts, targetLang, sourceLang = "en", apiKey, dela
 
 // src/translations/cli/add-key.ts
 init_utils();
+
+// src/translations/cli/generate-types.ts
+init_utils();
 init_init();
-async function addTranslationKey(projectRoot, options) {
+import { execSync } from "child_process";
+import * as fs3 from "fs";
+import * as path3 from "path";
+var typeTemplate = (translationKeys, namespaceKeys) => `
+  export const translationKeys = [${translationKeys.map((key) => `"${key}"`).join(", ")}] as const;
+  export const namespaceKeys = [${namespaceKeys.map((key) => `"${key}"`).join(", ")}] as const;
+
+  export type TranslationKey = typeof translationKeys[number];
+  export type TranslationNamespace = typeof namespaceKeys[number];
+`;
+function generateTranslationTypes(projectRoot = process.cwd()) {
+  console.log("=====");
+  console.time("i18n types generated");
+  console.log("Generating i18n types");
+  console.log("=====");
   const config = loadConfig(projectRoot);
   const translationsPath = path3.join(projectRoot, config.translationsPath);
+  const sourceLanguage = config.sourceLanguage;
+  const outputFilePath = path3.join(projectRoot, config.typesOutputPath);
+  const dirPath = path3.join(translationsPath, sourceLanguage);
+  if (!fs3.existsSync(dirPath)) {
+    throw new Error(`Source language directory not found: ${dirPath}`);
+  }
+  const namespaces = getNamespaces(translationsPath, sourceLanguage);
+  if (!namespaces.length) {
+    throw new Error(`No translation files found in ${dirPath}`);
+  }
+  const translations = readTranslations(translationsPath, sourceLanguage);
+  let allKeys = [];
+  for (const namespace of namespaces) {
+    const keys = Object.keys(translations[namespace] || {});
+    allKeys = allKeys.concat(keys);
+  }
+  const outputDir = path3.dirname(outputFilePath);
+  if (!fs3.existsSync(outputDir)) {
+    fs3.mkdirSync(outputDir, { recursive: true });
+  }
+  const typeString = typeTemplate(allKeys, namespaces);
+  fs3.writeFileSync(outputFilePath, typeString, "utf8");
+  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
+    });
+  } catch {
+    console.warn("Failed to format with Biome, continuing without formatting...");
+  }
+  console.timeEnd("i18n types generated");
+  console.log("=====");
+}
+
+// src/translations/cli/add-key.ts
+init_init();
+async function addTranslationKey(projectRoot, options) {
+  const config = loadConfig(projectRoot);
+  const translationsPath = path4.join(projectRoot, config.translationsPath);
   const { namespace, key, value, autoTranslate = false, apiKey } = 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());
+    }
+  }
   console.log("=====");
   console.log("Adding translation key");
   console.log("=====");
@@ -1027,7 +1188,7 @@ async function addTranslationKey(projectRoot, options) {
           targetTranslations[namespace] = {};
         }
         if (!targetTranslations[namespace][key] || targetTranslations[namespace][key].trim() === "") {
-          const translated = await translateText(value, lang, sourceLang, apiKey);
+          const translated = await translateText(value, lang, sourceLang, apiKey, config.useFallbackLanguages ?? true);
           targetTranslations[namespace][key] = translated;
           const sorted = sortKeys(targetTranslations[namespace]);
           writeTranslation(translationsPath, lang, namespace, sorted);
@@ -1063,6 +1224,12 @@ async function addTranslationKey(projectRoot, options) {
   console.log("=====");
   console.log("Translation key added successfully!");
   console.log("=====");
+  console.log("\nRegenerating TypeScript types...");
+  try {
+    generateTranslationTypes(projectRoot);
+  } catch (error) {
+    console.error("Failed to generate types:", error instanceof Error ? error.message : "Unknown error");
+  }
 }
 async function addTranslationKeys(projectRoot, entries, autoTranslate = false, apiKey) {
   console.log(`Adding ${entries.length} translation keys...`);
@@ -1078,112 +1245,17 @@ 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
+import * as path6 from "path";
 init_utils();
 init_init();
 
 // src/translations/cli/validate.ts
 init_utils();
 init_init();
-import * as path4 from "path";
+import * as path5 from "path";
 function validateTranslations(projectRoot = process.cwd()) {
   const config = loadConfig(projectRoot);
-  const translationsPath = path4.join(projectRoot, config.translationsPath);
+  const translationsPath = path5.join(projectRoot, config.translationsPath);
   const sourceLanguage = config.sourceLanguage;
   const missing = [];
   const empty = [];
@@ -1266,7 +1338,7 @@ function getMissingForLanguage(projectRoot, language) {
 // src/translations/cli/auto-fill.ts
 async function autoFillTranslations(projectRoot = process.cwd(), options = {}) {
   const config = loadConfig(projectRoot);
-  const translationsPath = path5.join(projectRoot, config.translationsPath);
+  const translationsPath = path6.join(projectRoot, config.translationsPath);
   const { apiKey, limit = 1e3, delayMs = 100, dryRun = false } = options;
   const currentProvider = getTranslationProvider();
   const isDefaultGoogleProvider = currentProvider.constructor.name === "GoogleTranslateProvider";
@@ -1359,7 +1431,7 @@ Processing language: ${language}`);
 }
 async function fillNamespace(projectRoot, language, namespace, apiKey) {
   const config = loadConfig(projectRoot);
-  const translationsPath = path5.join(projectRoot, config.translationsPath);
+  const translationsPath = path6.join(projectRoot, config.translationsPath);
   const currentProvider = getTranslationProvider();
   const isDefaultGoogleProvider = currentProvider.constructor.name === "GoogleTranslateProvider";
   if (isDefaultGoogleProvider) {
@@ -1402,62 +1474,6 @@ async function fillNamespace(projectRoot, language, namespace, apiKey) {
   }
 }
 
-// src/translations/cli/generate-types.ts
-init_utils();
-init_init();
-import { execSync } from "child_process";
-import * as fs3 from "fs";
-import * as path6 from "path";
-var typeTemplate = (translationKeys, namespaceKeys) => `
-  export const translationKeys = [${translationKeys.map((key) => `"${key}"`).join(", ")}] as const;
-  export const namespaceKeys = [${namespaceKeys.map((key) => `"${key}"`).join(", ")}] as const;
-
-  export type TranslationKey = typeof translationKeys[number];
-  export type TranslationNamespace = typeof namespaceKeys[number];
-`;
-function generateTranslationTypes(projectRoot = process.cwd()) {
-  console.log("=====");
-  console.time("i18n types generated");
-  console.log("Generating i18n types");
-  console.log("=====");
-  const config = loadConfig(projectRoot);
-  const translationsPath = path6.join(projectRoot, config.translationsPath);
-  const sourceLanguage = config.sourceLanguage;
-  const outputFilePath = path6.join(projectRoot, config.typesOutputPath);
-  const dirPath = path6.join(translationsPath, sourceLanguage);
-  if (!fs3.existsSync(dirPath)) {
-    throw new Error(`Source language directory not found: ${dirPath}`);
-  }
-  const namespaces = getNamespaces(translationsPath, sourceLanguage);
-  if (!namespaces.length) {
-    throw new Error(`No translation files found in ${dirPath}`);
-  }
-  const translations = readTranslations(translationsPath, sourceLanguage);
-  let allKeys = [];
-  for (const namespace of namespaces) {
-    const keys = Object.keys(translations[namespace] || {});
-    allKeys = allKeys.concat(keys);
-  }
-  const outputDir = path6.dirname(outputFilePath);
-  if (!fs3.existsSync(outputDir)) {
-    fs3.mkdirSync(outputDir, { recursive: true });
-  }
-  const typeString = typeTemplate(allKeys, namespaces);
-  fs3.writeFileSync(outputFilePath, typeString, "utf8");
-  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
-    });
-  } catch {
-    console.warn("Failed to format with Biome, continuing without formatting...");
-  }
-  console.timeEnd("i18n types generated");
-  console.log("=====");
-}
-
 // src/translations/index.ts
 init_init();