poly-lexis 0.6.0 → 0.8.1

package/dist/cli/translations.js

@@ -852,11 +852,28 @@ var init_init = __esm({
 // src/translations/cli/generate-types.ts
 var generate_types_exports = {};
 __export(generate_types_exports, {
+  extractPluralBaseKeys: () => extractPluralBaseKeys,
   generateTranslationTypes: () => generateTranslationTypes
 });
 import { execSync } from "child_process";
 import * as fs3 from "fs";
 import * as path4 from "path";
+function extractPluralBaseKeys(keys) {
+  const keySet = new Set(keys);
+  const baseKeys = /* @__PURE__ */ new Set();
+  for (const key of keys) {
+    for (const suffix of PLURAL_SUFFIXES) {
+      if (key.endsWith(suffix)) {
+        const baseKey = key.slice(0, -suffix.length);
+        if (baseKey && !keySet.has(baseKey)) {
+          baseKeys.add(baseKey);
+        }
+        break;
+      }
+    }
+  }
+  return Array.from(baseKeys);
+}
 function generateTranslationTypes(projectRoot = process.cwd()) {
   console.log("=====");
   console.time("i18n types generated");
@@ -880,11 +897,13 @@ function generateTranslationTypes(projectRoot = process.cwd()) {
     const keys = Object.keys(translations[namespace] || {});
     allKeys = allKeys.concat(keys);
   }
+  const pluralBaseKeys = extractPluralBaseKeys(allKeys);
+  allKeys = allKeys.concat(pluralBaseKeys);
   const outputDir = path4.dirname(outputFilePath);
   if (!fs3.existsSync(outputDir)) {
     fs3.mkdirSync(outputDir, { recursive: true });
   }
-  const typeString = typeTemplate(allKeys, namespaces);
+  const typeString = typeTemplate(allKeys, namespaces, config.languages);
   fs3.writeFileSync(outputFilePath, typeString, "utf8");
   console.log(`Generated types with ${allKeys.length} keys and ${namespaces.length} namespaces`);
   console.log(`Output: ${outputFilePath}`);
@@ -899,19 +918,22 @@ function generateTranslationTypes(projectRoot = process.cwd()) {
   console.timeEnd("i18n types generated");
   console.log("=====");
 }
-var typeTemplate;
+var PLURAL_SUFFIXES, typeTemplate;
 var init_generate_types = __esm({
   "src/translations/cli/generate-types.ts"() {
     "use strict";
     init_esm_shims();
     init_utils();
     init_init();
-    typeTemplate = (translationKeys, namespaceKeys) => `
+    PLURAL_SUFFIXES = ["_zero", "_one", "_two", "_few", "_many", "_other"];
+    typeTemplate = (translationKeys, namespaceKeys, languages) => `
   export const translationKeys = [${translationKeys.map((key) => `"${key}"`).join(", ")}] as const;
   export const namespaceKeys = [${namespaceKeys.map((key) => `"${key}"`).join(", ")}] as const;
+  export const languages = [${languages.map((lang) => `"${lang}"`).join(", ")}] as const;
 
   export type TranslationKey = typeof translationKeys[number];
   export type TranslationNamespace = typeof namespaceKeys[number];
+  export type Language = typeof languages[number];
 `;
   }
 });
@@ -1198,11 +1220,97 @@ var init_find_unused = __esm({
   }
 });
 
+// src/translations/cli/find-duplicates.ts
+var find_duplicates_exports = {};
+__export(find_duplicates_exports, {
+  findDuplicates: () => findDuplicates,
+  printDuplicateKeysResult: () => printDuplicateKeysResult
+});
+import * as path11 from "path";
+function findDuplicates(projectRoot = process.cwd()) {
+  const config = loadConfig(projectRoot);
+  const translationsPath = path11.join(projectRoot, config.translationsPath);
+  const sourceLanguage = config.sourceLanguage;
+  const namespaces = getNamespaces(translationsPath, sourceLanguage);
+  const sourceTranslations = readTranslations(translationsPath, sourceLanguage);
+  console.log("=====");
+  console.log("Finding duplicate translations (common namespace)");
+  console.log("=====");
+  console.log(`Source language: ${sourceLanguage}`);
+  console.log(`Namespaces: ${namespaces.join(", ")}`);
+  console.log("=====");
+  const commonValues = sourceTranslations["common"] || {};
+  if (Object.keys(commonValues).length === 0) {
+    console.log("No common namespace found or it is empty.");
+    return { duplicates: [], totalKeysChecked: 0 };
+  }
+  const valueToCommonKey = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(commonValues)) {
+    if (!valueToCommonKey.has(value)) {
+      valueToCommonKey.set(value, key);
+    }
+  }
+  const duplicates = [];
+  let totalKeysChecked = 0;
+  for (const namespace of namespaces) {
+    if (namespace === "common") continue;
+    const nsValues = sourceTranslations[namespace] || {};
+    for (const [key, value] of Object.entries(nsValues)) {
+      totalKeysChecked++;
+      const commonKey = valueToCommonKey.get(value);
+      if (commonKey) {
+        duplicates.push({
+          namespace,
+          key,
+          commonKey,
+          value
+        });
+      }
+    }
+  }
+  console.log("=====");
+  return { duplicates, totalKeysChecked };
+}
+function printDuplicateKeysResult(result) {
+  if (result.duplicates.length === 0) {
+    console.log("\u2713 No duplicate values found across namespaces!");
+    return;
+  }
+  console.log(`
+\u26A0 Found ${result.duplicates.length} values duplicated from common:
+`);
+  const byNamespace = /* @__PURE__ */ new Map();
+  for (const dup of result.duplicates) {
+    const items = byNamespace.get(dup.namespace) || [];
+    items.push(dup);
+    byNamespace.set(dup.namespace, items);
+  }
+  for (const [namespace, items] of byNamespace) {
+    console.log(`  ${namespace}:`);
+    for (const item of items) {
+      console.log(`    - ${item.key} \u2192 common.${item.commonKey} ("${item.value}")`);
+    }
+  }
+  console.log(`
+\u{1F4CA} Summary:`);
+  console.log(`  Keys checked: ${result.totalKeysChecked}`);
+  console.log(`  Duplicates found: ${result.duplicates.length}`);
+  console.log("=====");
+}
+var init_find_duplicates = __esm({
+  "src/translations/cli/find-duplicates.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_init();
+  }
+});
+
 // src/cli/translations.ts
 init_esm_shims();
 import "dotenv/config";
 import * as fs7 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 import { parseArgs } from "util";
 import { confirm as confirm2, input as input2, select as select2 } from "@inquirer/prompts";
 
@@ -2108,9 +2216,10 @@ Smart translation management - automatically handles initialization, validation,
 auto-filling, and type generation based on your project's current state.
 
 Commands:
-  (none)          Smart mode - validates, fills, and generates types
-  add             Add a new translation key
-  find-unused     Find translation keys that are not used in the codebase
+  (none)              Smart mode - validates, fills, and generates types
+  add                 Add a new translation key
+  find-unused         Find translation keys that are not used in the codebase
+  find-duplicates     Find values duplicated from the common namespace
 
 Options (Smart Mode):
   -a, --auto-fill         Auto-fill missing translations with DeepL or Google Translate
@@ -2160,6 +2269,9 @@ Examples:
   # Find unused translation keys
   translations find-unused
 
+  # Find values duplicated from common namespace
+  translations find-duplicates
+
 What happens in smart mode:
   1. Checks if translations are initialized (creates .translationsrc.json if needed)
   2. Validates all translations against source language
@@ -2182,12 +2294,24 @@ if (command === "find-unused") {
       process.exit(1);
     }
   })();
+} else if (command === "find-duplicates") {
+  (async () => {
+    try {
+      const { findDuplicates: findDuplicates2, printDuplicateKeysResult: printDuplicateKeysResult2 } = await Promise.resolve().then(() => (init_find_duplicates(), find_duplicates_exports));
+      console.log("\n\u{1F50D} Finding duplicate translations (common namespace)...\n");
+      const result = findDuplicates2(process.cwd());
+      printDuplicateKeysResult2(result);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  })();
 } else if (command === "add") {
   if (!values.namespace && !values.key && !values.value) {
     (async () => {
       try {
         console.log("\n\u2728 Add a new translation key\n");
-        const configPath = path11.join(process.cwd(), ".translationsrc.json");
+        const configPath = path12.join(process.cwd(), ".translationsrc.json");
         const isInitialized = fs7.existsSync(configPath);
         if (!isInitialized) {
           console.log("\u26A0\uFE0F  Translation structure not initialized.");
@@ -2204,7 +2328,7 @@ if (command === "find-unused") {
           }
         }
         const config = loadConfig(process.cwd());
-        const translationsPath = path11.join(process.cwd(), config.translationsPath);
+        const translationsPath = path12.join(process.cwd(), config.translationsPath);
         const existingNamespaces = getNamespaces(translationsPath, config.sourceLanguage);
         let namespace;
         if (existingNamespaces.length > 0) {
@@ -2327,7 +2451,7 @@ if (command === "find-unused") {
 } else {
   const hasFlags = values["auto-fill"] || values.language || values["skip-types"] || values["dry-run"];
   if (hasFlags) {
-    const configPath = path11.join(process.cwd(), ".translationsrc.json");
+    const configPath = path12.join(process.cwd(), ".translationsrc.json");
     const config = fs7.existsSync(configPath) ? loadConfig(process.cwd()) : { provider: "deepl" };
     const provider = config.provider || "deepl";
     const envVarName = provider === "google" ? "GOOGLE_TRANSLATE_API_KEY" : "DEEPL_API_KEY";
@@ -2353,7 +2477,7 @@ if (command === "find-unused") {
   } else {
     (async () => {
       try {
-        const configPath = path11.join(process.cwd(), ".translationsrc.json");
+        const configPath = path12.join(process.cwd(), ".translationsrc.json");
         const isInitialized = fs7.existsSync(configPath);
         console.log("\n\u{1F30D} Translation Management\n");
         const action = await select2({
@@ -2374,6 +2498,11 @@ if (command === "find-unused") {
               value: "find-unused",
               description: "Find translation keys not used in the codebase"
             },
+            {
+              name: "\u{1F50E} Find duplicate values",
+              value: "find-duplicates",
+              description: "Find values duplicated from the common namespace"
+            },
             {
               name: "\u{1F916} Auto-fill missing translations",
               value: "autofill",
@@ -2413,7 +2542,7 @@ if (command === "find-unused") {
             }
           }
           const config = loadConfig(process.cwd());
-          const translationsPath = path11.join(process.cwd(), config.translationsPath);
+          const translationsPath = path12.join(process.cwd(), config.translationsPath);
           const existingNamespaces = getNamespaces(translationsPath, config.sourceLanguage);
           let namespace;
           if (existingNamespaces.length > 0) {
@@ -2523,6 +2652,10 @@ if (command === "find-unused") {
           const { findUnusedKeys: findUnusedKeys2, printUnusedKeysResult: printUnusedKeysResult2 } = await Promise.resolve().then(() => (init_find_unused(), find_unused_exports));
           const result = findUnusedKeys2(process.cwd());
           printUnusedKeysResult2(result);
+        } else if (action === "find-duplicates") {
+          const { findDuplicates: findDuplicates2, printDuplicateKeysResult: printDuplicateKeysResult2 } = await Promise.resolve().then(() => (init_find_duplicates(), find_duplicates_exports));
+          const result = findDuplicates2(process.cwd());
+          printDuplicateKeysResult2(result);
         } else if (action === "types") {
           console.log("\u{1F4DD} Generating TypeScript types...\n");
           const { generateTranslationTypes: generateTranslationTypes2 } = await Promise.resolve().then(() => (init_generate_types(), generate_types_exports));