poly-lexis 0.5.1 → 0.5.2

package/dist/cli/translations.js

@@ -1782,10 +1782,30 @@ function getMissingForLanguage(projectRoot, language) {
 }
 
 // src/translations/cli/auto-fill.ts
+async function processConcurrently(items, concurrency, processor) {
+  const results = [];
+  const executing = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const promise = processor(item, i).then((result) => {
+      results[i] = result;
+    });
+    executing.push(promise);
+    if (executing.length >= concurrency) {
+      await Promise.race(executing);
+      const index = executing.indexOf(promise);
+      if (index !== -1) {
+        executing.splice(index, 1);
+      }
+    }
+  }
+  await Promise.all(executing);
+  return results;
+}
 async function autoFillTranslations(projectRoot = process.cwd(), options = {}) {
   const config = loadConfig(projectRoot);
   const translationsPath = path8.join(projectRoot, config.translationsPath);
-  const { apiKey, limit = 1e3, delayMs = 100, dryRun = false } = options;
+  const { apiKey, limit = Infinity, delayMs = 50, dryRun = false, concurrency = 5 } = options;
   const currentProvider = getTranslationProvider();
   const isDefaultGoogleProvider = currentProvider.constructor.name === "GoogleTranslateProvider";
   if (isDefaultGoogleProvider) {
@@ -1812,7 +1832,8 @@ async function autoFillTranslations(projectRoot = process.cwd(), options = {}) {
   console.log("Auto-filling translations");
   console.log("=====");
   console.log(`Languages: ${languagesToProcess.join(", ")}`);
-  console.log(`Limit: ${limit}`);
+  console.log(`Limit: ${limit === Infinity ? "unlimited" : limit}`);
+  console.log(`Concurrency: ${concurrency}`);
   console.log(`Dry run: ${dryRun}`);
   console.log("=====");
   let totalProcessed = 0;
@@ -1832,11 +1853,12 @@ Processing language: ${language}`);
     }
     console.log(`  Found ${missing.length} translations to fill`);
     const remainingLimit = limit - totalProcessed;
-    const itemsToProcess = missing.slice(0, remainingLimit);
-    for (const item of itemsToProcess) {
-      totalProcessed++;
+    const itemsToProcess = missing.slice(0, remainingLimit === Infinity ? missing.length : remainingLimit);
+    const results = await processConcurrently(itemsToProcess, concurrency, async (item, index) => {
+      const currentCount = totalProcessed + index + 1;
+      const limitDisplay = limit === Infinity ? itemsToProcess.length : limit;
       try {
-        console.log(`  [${totalProcessed}/${limit}] Translating ${item.namespace}.${item.key}`);
+        console.log(`  [${currentCount}/${limitDisplay}] Translating ${item.namespace}.${item.key}`);
         console.log(`    EN: "${item.sourceValue}"`);
         const translated = await translateText(
           item.sourceValue,
@@ -1858,14 +1880,17 @@ Processing language: ${language}`);
         } else {
           console.log("    \u2713 Dry run - not saved");
         }
-        totalTranslated++;
-        if (delayMs > 0 && totalProcessed < limit) {
+        if (delayMs > 0) {
           await new Promise((resolve) => setTimeout(resolve, delayMs));
         }
+        return { success: true, item };
       } catch (error) {
         console.error(`    \u2717 Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+        return { success: false, item };
       }
-    }
+    });
+    totalProcessed += itemsToProcess.length;
+    totalTranslated += results.filter((r) => r.success).length;
   }
   console.log("\n=====");
   console.log(`Total processed: ${totalProcessed}`);
@@ -1880,7 +1905,7 @@ Processing language: ${language}`);
 init_generate_types();
 init_init();
 async function manageTranslations(projectRoot = process.cwd(), options = {}) {
-  const { autoFill = false, apiKey, limit = 1e3, language, skipTypes = false, dryRun = false } = options;
+  const { autoFill = false, apiKey, limit, concurrency = 5, language, skipTypes = false, dryRun = false } = options;
   console.log("=====");
   console.log("Translation Management");
   console.log("=====");
@@ -1938,9 +1963,10 @@ async function manageTranslations(projectRoot = process.cwd(), options = {}) {
         await autoFillTranslations(projectRoot, {
           apiKey,
           limit,
+          concurrency,
           language,
           dryRun,
-          delayMs: 100
+          delayMs: 50
         });
         if (!dryRun) {
           console.log("\n\u{1F50D} Re-validating after auto-fill...\n");
@@ -2006,8 +2032,11 @@ var { values, positionals } = parseArgs({
       type: "string"
     },
     limit: {
+      type: "string"
+    },
+    concurrency: {
       type: "string",
-      default: "1000"
+      default: "5"
     },
     language: {
       type: "string",
@@ -2057,7 +2086,8 @@ Options (Smart Mode):
   -a, --auto-fill         Auto-fill missing translations with DeepL or Google Translate
   --api-key <key>         Translation API key (or set DEEPL_API_KEY/GOOGLE_TRANSLATE_API_KEY)
   -l, --language <lang>   Process only this language
-  --limit <number>        Max translations to process (default: 1000)
+  --limit <number>        Max translations to process (default: unlimited)
+  --concurrency <number>  Number of concurrent translation requests (default: 5)
   --skip-types            Skip TypeScript type generation
   -d, --dry-run           Preview changes without saving
   -h, --help              Show this help
@@ -2272,11 +2302,13 @@ if (command === "find-unused") {
     const provider = config.provider || "deepl";
     const envVarName = provider === "google" ? "GOOGLE_TRANSLATE_API_KEY" : "DEEPL_API_KEY";
     const apiKey = values["api-key"] || process.env[envVarName];
-    const limit = Number.parseInt(values.limit || "1000", 10);
+    const limit = values.limit ? Number.parseInt(values.limit, 10) : void 0;
+    const concurrency = Number.parseInt(values.concurrency || "5", 10);
     manageTranslations(process.cwd(), {
       autoFill: values["auto-fill"],
       apiKey,
       limit,
+      concurrency,
       language: values.language,
       skipTypes: values["skip-types"],
       dryRun: values["dry-run"]