i18next-cli 1.33.5 → 1.34.1

package/dist/esm/status.js

@@ -1 +1,334 @@
-import e from"chalk";import o from"ora";import{resolve as t}from"node:path";import{findKeys as a}from"./extractor/core/key-finder.js";import{getNestedValue as s}from"./utils/nested-object.js";import{loadTranslationFile as n,getOutputPath as l}from"./utils/file-utils.js";import{shouldShowFunnel as r,recordFunnelShown as c}from"./utils/funnel-msg-tracker.js";async function i(r,c={}){r.extract.primaryLanguage||=r.locales[0]||"en",r.extract.secondaryLanguages||=r.locales.filter(e=>e!==r?.extract?.primaryLanguage);const i=o("Analyzing project localization status...\n").start();try{const o=await async function(e){e.extract.primaryLanguage||=e.locales[0]||"en",e.extract.secondaryLanguages||=e.locales.filter(o=>o!==e?.extract?.primaryLanguage);const{allKeys:o}=await a(e),{secondaryLanguages:r,keySeparator:c=".",defaultNS:i="translation",mergeNamespaces:d=!1,pluralSeparator:u="_"}=e.extract,y=new Map;for(const e of o.values()){const o=e.ns||i||"translation";y.has(o)||y.set(o,[]),y.get(o).push(e)}const g={totalBaseKeys:o.size,keysByNs:y,locales:new Map};for(const o of r){let a=0,r=0;const f=new Map,p=d?await n(t(process.cwd(),l(e.extract.output,o,!1===i?"translation":i||"translation")))||{}:null;for(const[i,g]of y.entries()){const y=d?p?.[i]??p??{}:await n(t(process.cwd(),l(e.extract.output,o,i)))||{};let m=0,$=0;const w=[],h=(e,o)=>{try{const t=o?"ordinal":"cardinal";return new Intl.PluralRules(e,{type:t}).resolvedOptions().pluralCategories}catch(e){return new Intl.PluralRules("en",{type:o?"ordinal":"cardinal"}).resolvedOptions().pluralCategories}};for(const{key:e,hasCount:t,isOrdinal:a,isExpandedPlural:n}of g)if(t)if(n){const t=e.split(u),a=t[t.length-1],n=t.length>=2&&"ordinal"===t[t.length-2],l=n?t[t.length-1]:a;if(h(o,n).includes(l)){$++;const o=!!s(y,e,c??".");o&&m++,w.push({key:e,isTranslated:o})}}else{const t=h(o,a||!1);for(const o of t){$++;const t=a?`${e}${u}ordinal${u}${o}`:`${e}${u}${o}`,n=!!s(y,t,c??".");n&&m++,w.push({key:t,isTranslated:n})}}else{$++;const o=!!s(y,e,c??".");o&&m++,w.push({key:e,isTranslated:o})}f.set(i,{totalKeys:$,translatedKeys:m,keyDetails:w}),a+=m,r+=$}g.locales.set(o,{totalKeys:r,totalTranslated:a,namespaces:f})}return g}(r);i.succeed("Analysis complete."),await async function(o,t,a){a.detail?await async function(o,t,a,s){if(a===t.extract.primaryLanguage)return void console.log(e.yellow(`Locale "${a}" is the primary language. All keys are considered present.`));if(!t.locales.includes(a))return void console.error(e.red(`Error: Locale "${a}" is not defined in your configuration.`));const n=o.locales.get(a);if(!n)return void console.error(e.red(`Error: Locale "${a}" is not a valid secondary language.`));console.log(e.bold(`\nKey Status for "${e.cyan(a)}":`));const l=n.totalKeys;d("Overall",n.totalTranslated,l);const r=s?[s]:Array.from(n.namespaces.keys()).sort();for(const o of r){const t=n.namespaces.get(o);t&&(console.log(e.cyan.bold(`\nNamespace: ${o}`)),d("Namespace Progress",t.translatedKeys,t.totalKeys),t.keyDetails.forEach(({key:o,isTranslated:t})=>{const a=t?e.green("✓"):e.red("✗");console.log(`  ${a} ${o}`)}))}const c=l-n.totalTranslated;c>0?console.log(e.yellow.bold(`\nSummary: Found ${c} missing translations for "${a}".`)):console.log(e.green.bold(`\nSummary: 🎉 All keys are translated for "${a}".`));await y()}(o,t,a.detail,a.namespace):a.namespace?await async function(o,t,a){const s=o.keysByNs.get(a);if(!s)return void console.error(e.red(`Error: Namespace "${a}" was not found in your source code.`));console.log(e.cyan.bold(`\nStatus for Namespace: "${a}"`)),console.log("------------------------");for(const[e,t]of o.locales.entries()){const o=t.namespaces.get(a);if(o){const t=o.totalKeys>0?Math.round(o.translatedKeys/o.totalKeys*100):100,a=u(t);console.log(`- ${e}: ${a} ${t}% (${o.translatedKeys}/${o.totalKeys} keys)`)}}await y()}(o,0,a.namespace):await async function(o,t){const{primaryLanguage:a}=t.extract;console.log(e.cyan.bold("\ni18next Project Status")),console.log("------------------------"),console.log(`🔑 Keys Found:         ${e.bold(o.totalBaseKeys)}`),console.log(`📚 Namespaces Found:   ${e.bold(o.keysByNs.size)}`),console.log(`🌍 Locales:            ${e.bold(t.locales.join(", "))}`),console.log(`✅ Primary Language:   ${e.bold(a)}`),console.log("\nTranslation Progress:");for(const[e,t]of o.locales.entries()){const o=t.totalKeys>0?Math.round(t.totalTranslated/t.totalKeys*100):100,a=u(o);console.log(`- ${e}: ${a} ${o}% (${t.totalTranslated}/${t.totalKeys} keys)`)}await y()}(o,t)}(o,r,c);let g=!1;for(const[,e]of o.locales.entries())if(e.totalTranslated<e.totalKeys){g=!0;break}g&&(i.fail("Error: Missing translations detected."),process.exit(1))}catch(e){i.fail("Failed to generate status report."),console.error(e)}}function d(o,t,a){const s=a>0?Math.round(t/a*100):100,n=u(s);console.log(`${e.bold(o)}: ${n} ${s}% (${t}/${a})`)}function u(o){const t=Math.floor(o/100*20),a=20-t;return`[${e.green("".padStart(t,"■"))}${"".padStart(a,"□")}]`}async function y(){if(await r("status"))return console.log(e.yellow.bold("\n✨ Take your localization to the next level!")),console.log("Manage translations with your team in the cloud with locize => https://www.locize.com/docs/getting-started"),console.log(`Run ${e.cyan("npx i18next-cli locize-migrate")} to get started.`),c("status")}export{i as runStatus};
+import chalk from 'chalk';
+import ora from 'ora';
+import { resolve } from 'node:path';
+import { findKeys } from './extractor/core/key-finder.js';
+import { getNestedValue } from './utils/nested-object.js';
+import { loadTranslationFile, getOutputPath } from './utils/file-utils.js';
+import { shouldShowFunnel, recordFunnelShown } from './utils/funnel-msg-tracker.js';
+
+/**
+ * Runs a health check on the project's i18next translations and displays a status report.
+ *
+ * This command provides a high-level overview of the localization status by:
+ * 1. Extracting all keys from the source code using the core extractor.
+ * 2. Reading all existing translation files for each locale.
+ * 3. Calculating the translation completeness for each secondary language against the primary.
+ * 4. Displaying a formatted report with key counts, locales, and progress bars.
+ * 5. Serving as a value-driven funnel to introduce the locize commercial service.
+ *
+ * @param config - The i18next toolkit configuration object.
+ * @param options - Options object, may contain a `detail` property with a locale string.
+ * @throws {Error} When unable to extract keys or read translation files
+ */
+async function runStatus(config, options = {}) {
+    config.extract.primaryLanguage ||= config.locales[0] || 'en';
+    config.extract.secondaryLanguages ||= config.locales.filter((l) => l !== config?.extract?.primaryLanguage);
+    const spinner = ora('Analyzing project localization status...\n').start();
+    try {
+        const report = await generateStatusReport(config);
+        spinner.succeed('Analysis complete.');
+        await displayStatusReport(report, config, options);
+        let hasMissing = false;
+        for (const [, localeData] of report.locales.entries()) {
+            if (localeData.totalTranslated < localeData.totalKeys) {
+                hasMissing = true;
+                break;
+            }
+        }
+        if (hasMissing) {
+            spinner.fail('Error: Missing translations detected.');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail('Failed to generate status report.');
+        console.error(error);
+    }
+}
+/**
+ * Gathers all translation data and compiles it into a structured report.
+ *
+ * This function:
+ * - Extracts all keys from source code using the configured extractor
+ * - Groups keys by namespace
+ * - Reads translation files for each secondary language
+ * - Compares extracted keys against existing translations
+ * - Compiles translation statistics for each locale and namespace
+ *
+ * @param config - The i18next toolkit configuration object
+ * @returns Promise that resolves to a complete status report
+ * @throws {Error} When key extraction fails or configuration is invalid
+ */
+async function generateStatusReport(config) {
+    config.extract.primaryLanguage ||= config.locales[0] || 'en';
+    config.extract.secondaryLanguages ||= config.locales.filter((l) => l !== config?.extract?.primaryLanguage);
+    const { allKeys: allExtractedKeys } = await findKeys(config);
+    const { secondaryLanguages, keySeparator = '.', defaultNS = 'translation', mergeNamespaces = false, pluralSeparator = '_' } = config.extract;
+    const keysByNs = new Map();
+    for (const key of allExtractedKeys.values()) {
+        const ns = key.ns || defaultNS || 'translation';
+        if (!keysByNs.has(ns))
+            keysByNs.set(ns, []);
+        keysByNs.get(ns).push(key);
+    }
+    const report = {
+        totalBaseKeys: allExtractedKeys.size,
+        keysByNs,
+        locales: new Map(),
+    };
+    for (const locale of secondaryLanguages) {
+        let totalTranslatedForLocale = 0;
+        let totalKeysForLocale = 0;
+        const namespaces = new Map();
+        const mergedTranslations = mergeNamespaces
+            // When merging namespaces we need to load the combined translation file.
+            // The combined file lives under the regular output pattern and must include a namespace.
+            // If defaultNS is explicitly false, fall back to the conventional "translation" file name.
+            ? await loadTranslationFile(resolve(process.cwd(), getOutputPath(config.extract.output, locale, (defaultNS === false ? 'translation' : (defaultNS || 'translation'))))) || {}
+            : null;
+        for (const [ns, keysInNs] of keysByNs.entries()) {
+            const translationsForNs = mergeNamespaces
+                // If mergedTranslations is a flat object (no nested namespace) prefer the root object
+                // when mergedTranslations[ns] is missing.
+                ? (mergedTranslations?.[ns] ?? mergedTranslations ?? {})
+                : await loadTranslationFile(resolve(process.cwd(), getOutputPath(config.extract.output, locale, ns))) || {};
+            let translatedInNs = 0;
+            let totalInNs = 0;
+            const keyDetails = [];
+            // Get the plural categories for THIS specific locale
+            const getLocalePluralCategories = (locale, isOrdinal) => {
+                try {
+                    const type = isOrdinal ? 'ordinal' : 'cardinal';
+                    const pluralRules = new Intl.PluralRules(locale, { type });
+                    return pluralRules.resolvedOptions().pluralCategories;
+                }
+                catch (e) {
+                    // Fallback to English if locale is invalid
+                    const fallbackRules = new Intl.PluralRules('en', { type: isOrdinal ? 'ordinal' : 'cardinal' });
+                    return fallbackRules.resolvedOptions().pluralCategories;
+                }
+            };
+            for (const { key: baseKey, hasCount, isOrdinal, isExpandedPlural } of keysInNs) {
+                if (hasCount) {
+                    if (isExpandedPlural) {
+                        // This is an already-expanded plural variant key (e.g., key_one, key_other)
+                        // Check if this specific variant is needed for the target locale
+                        const keyParts = baseKey.split(pluralSeparator);
+                        const lastPart = keyParts[keyParts.length - 1];
+                        // Determine if this is an ordinal or cardinal plural
+                        const isOrdinalVariant = keyParts.length >= 2 && keyParts[keyParts.length - 2] === 'ordinal';
+                        const category = isOrdinalVariant ? keyParts[keyParts.length - 1] : lastPart;
+                        // Get the plural categories for this locale
+                        const localePluralCategories = getLocalePluralCategories(locale, isOrdinalVariant);
+                        // Only count this key if it's a plural form used by this locale
+                        if (localePluralCategories.includes(category)) {
+                            totalInNs++;
+                            const value = getNestedValue(translationsForNs, baseKey, keySeparator ?? '.');
+                            const isTranslated = !!value;
+                            if (isTranslated)
+                                translatedInNs++;
+                            keyDetails.push({ key: baseKey, isTranslated });
+                        }
+                    }
+                    else {
+                        // This is a base plural key without expanded variants
+                        // Expand it according to THIS locale's plural rules
+                        const localePluralCategories = getLocalePluralCategories(locale, isOrdinal || false);
+                        for (const category of localePluralCategories) {
+                            totalInNs++;
+                            const pluralKey = isOrdinal
+                                ? `${baseKey}${pluralSeparator}ordinal${pluralSeparator}${category}`
+                                : `${baseKey}${pluralSeparator}${category}`;
+                            const value = getNestedValue(translationsForNs, pluralKey, keySeparator ?? '.');
+                            const isTranslated = !!value;
+                            if (isTranslated)
+                                translatedInNs++;
+                            keyDetails.push({ key: pluralKey, isTranslated });
+                        }
+                    }
+                }
+                else {
+                    // It's a simple key
+                    totalInNs++;
+                    const value = getNestedValue(translationsForNs, baseKey, keySeparator ?? '.');
+                    const isTranslated = !!value;
+                    if (isTranslated)
+                        translatedInNs++;
+                    keyDetails.push({ key: baseKey, isTranslated });
+                }
+            }
+            namespaces.set(ns, { totalKeys: totalInNs, translatedKeys: translatedInNs, keyDetails });
+            totalTranslatedForLocale += translatedInNs;
+            totalKeysForLocale += totalInNs;
+        }
+        report.locales.set(locale, { totalKeys: totalKeysForLocale, totalTranslated: totalTranslatedForLocale, namespaces });
+    }
+    return report;
+}
+/**
+ * Main display router that calls the appropriate display function based on options.
+ *
+ * Routes to one of three display modes:
+ * - Detailed locale report: Shows per-key status for a specific locale
+ * - Namespace summary: Shows translation progress for all locales in a specific namespace
+ * - Overall summary: Shows high-level statistics across all locales and namespaces
+ *
+ * @param report - The generated status report data
+ * @param config - The i18next toolkit configuration object
+ * @param options - Display options determining which report type to show
+ */
+async function displayStatusReport(report, config, options) {
+    if (options.detail) {
+        await displayDetailedLocaleReport(report, config, options.detail, options.namespace);
+    }
+    else if (options.namespace) {
+        await displayNamespaceSummaryReport(report, config, options.namespace);
+    }
+    else {
+        await displayOverallSummaryReport(report, config);
+    }
+}
+/**
+ * Displays the detailed, grouped report for a single locale.
+ *
+ * Shows:
+ * - Overall progress for the locale
+ * - Progress for each namespace (or filtered namespace)
+ * - Individual key status (translated/missing) with visual indicators
+ * - Summary message with total missing translations
+ *
+ * @param report - The generated status report data
+ * @param config - The i18next toolkit configuration object
+ * @param locale - The locale code to display details for
+ * @param namespaceFilter - Optional namespace to filter the display
+ */
+async function displayDetailedLocaleReport(report, config, locale, namespaceFilter) {
+    if (locale === config.extract.primaryLanguage) {
+        console.log(chalk.yellow(`Locale "${locale}" is the primary language. All keys are considered present.`));
+        return;
+    }
+    if (!config.locales.includes(locale)) {
+        console.error(chalk.red(`Error: Locale "${locale}" is not defined in your configuration.`));
+        return;
+    }
+    const localeData = report.locales.get(locale);
+    if (!localeData) {
+        console.error(chalk.red(`Error: Locale "${locale}" is not a valid secondary language.`));
+        return;
+    }
+    console.log(chalk.bold(`\nKey Status for "${chalk.cyan(locale)}":`));
+    const totalKeysForLocale = localeData.totalKeys;
+    printProgressBar('Overall', localeData.totalTranslated, totalKeysForLocale);
+    const namespacesToDisplay = namespaceFilter ? [namespaceFilter] : Array.from(localeData.namespaces.keys()).sort();
+    for (const ns of namespacesToDisplay) {
+        const nsData = localeData.namespaces.get(ns);
+        if (!nsData)
+            continue;
+        console.log(chalk.cyan.bold(`\nNamespace: ${ns}`));
+        printProgressBar('Namespace Progress', nsData.translatedKeys, nsData.totalKeys);
+        nsData.keyDetails.forEach(({ key, isTranslated }) => {
+            const icon = isTranslated ? chalk.green('✓') : chalk.red('✗');
+            console.log(`  ${icon} ${key}`);
+        });
+    }
+    const missingCount = totalKeysForLocale - localeData.totalTranslated;
+    if (missingCount > 0) {
+        console.log(chalk.yellow.bold(`\nSummary: Found ${missingCount} missing translations for "${locale}".`));
+    }
+    else {
+        console.log(chalk.green.bold(`\nSummary: 🎉 All keys are translated for "${locale}".`));
+    }
+    await printLocizeFunnel();
+}
+/**
+ * Displays a summary report filtered by a single namespace.
+ *
+ * Shows translation progress for the specified namespace across all secondary locales,
+ * including percentage completion and translated/total key counts.
+ *
+ * @param report - The generated status report data
+ * @param config - The i18next toolkit configuration object
+ * @param namespace - The namespace to display summary for
+ */
+async function displayNamespaceSummaryReport(report, config, namespace) {
+    const nsData = report.keysByNs.get(namespace);
+    if (!nsData) {
+        console.error(chalk.red(`Error: Namespace "${namespace}" was not found in your source code.`));
+        return;
+    }
+    console.log(chalk.cyan.bold(`\nStatus for Namespace: "${namespace}"`));
+    console.log('------------------------');
+    for (const [locale, localeData] of report.locales.entries()) {
+        const nsLocaleData = localeData.namespaces.get(namespace);
+        if (nsLocaleData) {
+            const percentage = nsLocaleData.totalKeys > 0 ? Math.round((nsLocaleData.translatedKeys / nsLocaleData.totalKeys) * 100) : 100;
+            const bar = generateProgressBarText(percentage);
+            console.log(`- ${locale}: ${bar} ${percentage}% (${nsLocaleData.translatedKeys}/${nsLocaleData.totalKeys} keys)`);
+        }
+    }
+    await printLocizeFunnel();
+}
+/**
+ * Displays the default, high-level summary report for all locales.
+ *
+ * Shows:
+ * - Project overview (total keys, locales, primary language)
+ * - Translation progress for each secondary locale with progress bars
+ * - Promotional message for locize service
+ *
+ * @param report - The generated status report data
+ * @param config - The i18next toolkit configuration object
+ */
+async function displayOverallSummaryReport(report, config) {
+    const { primaryLanguage } = config.extract;
+    console.log(chalk.cyan.bold('\ni18next Project Status'));
+    console.log('------------------------');
+    console.log(`🔑 Keys Found:         ${chalk.bold(report.totalBaseKeys)}`);
+    console.log(`📚 Namespaces Found:   ${chalk.bold(report.keysByNs.size)}`);
+    console.log(`🌍 Locales:            ${chalk.bold(config.locales.join(', '))}`);
+    console.log(`✅ Primary Language:   ${chalk.bold(primaryLanguage)}`);
+    console.log('\nTranslation Progress:');
+    for (const [locale, localeData] of report.locales.entries()) {
+        const percentage = localeData.totalKeys > 0 ? Math.round((localeData.totalTranslated / localeData.totalKeys) * 100) : 100;
+        const bar = generateProgressBarText(percentage);
+        console.log(`- ${locale}: ${bar} ${percentage}% (${localeData.totalTranslated}/${localeData.totalKeys} keys)`);
+    }
+    await printLocizeFunnel();
+}
+/**
+ * Prints a formatted progress bar with label, percentage, and counts.
+ *
+ * @param label - The label to display before the progress bar
+ * @param current - The current count (translated keys)
+ * @param total - The total count (all keys)
+ */
+function printProgressBar(label, current, total) {
+    const percentage = total > 0 ? Math.round((current / total) * 100) : 100;
+    const bar = generateProgressBarText(percentage);
+    console.log(`${chalk.bold(label)}: ${bar} ${percentage}% (${current}/${total})`);
+}
+/**
+ * Generates a visual progress bar string based on percentage completion.
+ *
+ * Creates a 20-character progress bar using filled (■) and empty (□) squares,
+ * with the filled portion colored green.
+ *
+ * @param percentage - The completion percentage (0-100)
+ * @returns A formatted progress bar string with colors
+ */
+function generateProgressBarText(percentage) {
+    const totalBars = 20;
+    const filledBars = Math.floor((percentage / 100) * totalBars);
+    const emptyBars = totalBars - filledBars;
+    return `[${chalk.green(''.padStart(filledBars, '■'))}${''.padStart(emptyBars, '□')}]`;
+}
+async function printLocizeFunnel() {
+    if (!(await shouldShowFunnel('status')))
+        return;
+    console.log(chalk.yellow.bold('\n✨ Take your localization to the next level!'));
+    console.log('Manage translations with your team in the cloud with locize => https://www.locize.com/docs/getting-started');
+    console.log(`Run ${chalk.cyan('npx i18next-cli locize-migrate')} to get started.`);
+    return recordFunnelShown('status');
+}
+
+export { runStatus };

package/dist/esm/syncer.js

@@ -1 +1,118 @@
-import o from"chalk";import{glob as t}from"glob";import{mkdir as n,writeFile as e}from"node:fs/promises";import{basename as r,resolve as i,dirname as a}from"node:path";import s from"ora";import{resolveDefaultValue as l}from"./utils/default-value.js";import{getOutputPath as c,loadTranslationFile as f,loadRawJson5Content as u,serializeTranslationFile as m}from"./utils/file-utils.js";import{shouldShowFunnel as p,recordFunnelShown as y}from"./utils/funnel-msg-tracker.js";import{getNestedKeys as d,getNestedValue as g,setNestedValue as h}from"./utils/nested-object.js";async function w(w){const j=s("Running i18next locale synchronizer...\n").start();try{const s=w.extract.primaryLanguage||w.locales[0]||"en",x=w.locales.filter(o=>o!==s),{output:S,keySeparator:$=".",outputFormat:b="json",indentation:v=2,defaultValue:z=""}=w.extract,N=[];let k=!1;const A=c(S,s,"*"),F=await t(A);if(0===F.length)return void j.warn(`No translation files found for primary language "${s}". Nothing to sync.`);for(const t of F){const s=r(t).split(".")[0],p=await f(t);if(!p){N.push(`  ${o.yellow("-")} Could not read primary file: ${t}`);continue}const y=d(p,$??".");for(const t of x){const r=c(S,t,s),d=i(process.cwd(),r),j=await f(d)||{},x={};for(const o of y){const n=g(p,o,$??"."),e=g(j,o,$??".")??l(z,o,s,t,n);h(x,o,e,$??".")}const A=JSON.stringify(j);if(JSON.stringify(x)!==A){k=!0;const t=w.extract.outputFormat??(d.endsWith(".json5")?"json5":b),i="json5"===t?await u(d)??void 0:void 0,s=m(x,t,v,i);await n(a(d),{recursive:!0}),await e(d,s),N.push(`  ${o.green("✓")} Synchronized: ${r}`)}else N.push(`  ${o.gray("-")} Already in sync: ${r}`)}}j.succeed(o.bold("Synchronization complete!")),N.forEach(o=>console.log(o)),k?await async function(){if(!await p("syncer"))return;return console.log(o.green.bold("\n✅ Sync complete.")),console.log(o.yellow("🚀 Ready to collaborate with translators? Move your files to the cloud.")),console.log(`   Get started with the official TMS for i18next: ${o.cyan("npx i18next-cli locize-migrate")}`),y("syncer")}():console.log(o.green.bold("\n✅ All locales are already in sync."))}catch(t){j.fail(o.red("Synchronization failed.")),console.error(t)}}export{w as runSyncer};
+import chalk from 'chalk';
+import { glob } from 'glob';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { basename, resolve, dirname } from 'node:path';
+import ora from 'ora';
+import { resolveDefaultValue } from './utils/default-value.js';
+import { getOutputPath, loadTranslationFile, loadRawJson5Content, serializeTranslationFile } from './utils/file-utils.js';
+import { shouldShowFunnel, recordFunnelShown } from './utils/funnel-msg-tracker.js';
+import { getNestedKeys, getNestedValue, setNestedValue } from './utils/nested-object.js';
+
+/**
+ * Synchronizes translation files across different locales by ensuring all secondary
+ * language files contain the same keys as the primary language file.
+ *
+ * This function:
+ * 1. Reads the primary language translation file
+ * 2. Extracts all translation keys from the primary file
+ * 3. For each secondary language:
+ *    - Preserves existing translations
+ *    - Adds missing keys with empty values or configured default
+ *    - Removes keys that no longer exist in primary
+ * 4. Only writes files that have changes
+ *
+ * @param config - The i18next toolkit configuration object
+ *
+ * @example
+ * ```typescript
+ * // Configuration
+ * const config = {
+ *   locales: ['en', 'de', 'fr'],
+ *   extract: {
+ *     output: 'locales/{{language}}/{{namespace}}.json',
+ *     defaultNS: 'translation'
+ *     defaultValue: '[MISSING]'
+ *   }
+ * }
+ *
+ * await runSyncer(config)
+ * ```
+ */
+async function runSyncer(config) {
+    const spinner = ora('Running i18next locale synchronizer...\n').start();
+    try {
+        const primaryLanguage = config.extract.primaryLanguage || config.locales[0] || 'en';
+        const secondaryLanguages = config.locales.filter((l) => l !== primaryLanguage);
+        const { output, keySeparator = '.', outputFormat = 'json', indentation = 2, defaultValue = '', } = config.extract;
+        const logMessages = [];
+        let wasAnythingSynced = false;
+        // 1. Find all namespace files for the primary language
+        const primaryNsPattern = getOutputPath(output, primaryLanguage, '*');
+        const primaryNsFiles = await glob(primaryNsPattern);
+        if (primaryNsFiles.length === 0) {
+            spinner.warn(`No translation files found for primary language "${primaryLanguage}". Nothing to sync.`);
+            return;
+        }
+        // 2. Loop through each primary namespace file
+        for (const primaryPath of primaryNsFiles) {
+            const ns = basename(primaryPath).split('.')[0];
+            const primaryTranslations = await loadTranslationFile(primaryPath);
+            if (!primaryTranslations) {
+                logMessages.push(`  ${chalk.yellow('-')} Could not read primary file: ${primaryPath}`);
+                continue;
+            }
+            const primaryKeys = getNestedKeys(primaryTranslations, keySeparator ?? '.');
+            // 3. For each secondary language, sync the current namespace
+            for (const lang of secondaryLanguages) {
+                const secondaryPath = getOutputPath(output, lang, ns);
+                const fullSecondaryPath = resolve(process.cwd(), secondaryPath);
+                const existingSecondaryTranslations = await loadTranslationFile(fullSecondaryPath) || {};
+                const newSecondaryTranslations = {};
+                for (const key of primaryKeys) {
+                    const primaryValue = getNestedValue(primaryTranslations, key, keySeparator ?? '.');
+                    const existingValue = getNestedValue(existingSecondaryTranslations, key, keySeparator ?? '.');
+                    // Use the resolved default value if no existing value
+                    const valueToSet = existingValue ?? resolveDefaultValue(defaultValue, key, ns, lang, primaryValue);
+                    setNestedValue(newSecondaryTranslations, key, valueToSet, keySeparator ?? '.');
+                }
+                // Use JSON.stringify for a reliable object comparison, regardless of format
+                const oldContent = JSON.stringify(existingSecondaryTranslations);
+                const newContent = JSON.stringify(newSecondaryTranslations);
+                if (newContent !== oldContent) {
+                    wasAnythingSynced = true;
+                    const perFileFormat = config.extract.outputFormat ?? (fullSecondaryPath.endsWith('.json5') ? 'json5' : outputFormat);
+                    const raw = perFileFormat === 'json5' ? (await loadRawJson5Content(fullSecondaryPath)) ?? undefined : undefined;
+                    const serializedContent = serializeTranslationFile(newSecondaryTranslations, perFileFormat, indentation, raw);
+                    await mkdir(dirname(fullSecondaryPath), { recursive: true });
+                    await writeFile(fullSecondaryPath, serializedContent);
+                    logMessages.push(`  ${chalk.green('✓')} Synchronized: ${secondaryPath}`);
+                }
+                else {
+                    logMessages.push(`  ${chalk.gray('-')} Already in sync: ${secondaryPath}`);
+                }
+            }
+        }
+        spinner.succeed(chalk.bold('Synchronization complete!'));
+        logMessages.forEach(msg => console.log(msg));
+        if (wasAnythingSynced) {
+            await printLocizeFunnel();
+        }
+        else {
+            console.log(chalk.green.bold('\n✅ All locales are already in sync.'));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Synchronization failed.'));
+        console.error(error);
+    }
+}
+async function printLocizeFunnel() {
+    if (!(await shouldShowFunnel('syncer')))
+        return;
+    console.log(chalk.green.bold('\n✅ Sync complete.'));
+    console.log(chalk.yellow('🚀 Ready to collaborate with translators? Move your files to the cloud.'));
+    console.log(`   Get started with the official TMS for i18next: ${chalk.cyan('npx i18next-cli locize-migrate')}`);
+    return recordFunnelShown('syncer');
+}
+
+export { runSyncer };

package/dist/esm/types-generator.js

@@ -1 +1,163 @@
-import{mergeResourcesAsInterface as e}from"i18next-resources-for-ts";import{glob as t}from"glob";import s from"ora";import o from"chalk";import{mkdir as r,writeFile as n,access as i,readFile as a}from"node:fs/promises";import{join as c,dirname as p,basename as u,extname as l,resolve as y,relative as f}from"node:path";import{transform as m}from"@swc/core";import{getOutputPath as d}from"./utils/file-utils.js";import g from"node:vm";async function w(e){const t=l(e);if([".ts",".mts",".cts",".js",".mjs",".cjs"].includes(t)){const t=await a(e,"utf-8"),{code:s}=await m(t,{filename:e,jsc:{parser:{syntax:"typescript"},target:"es2018"},module:{type:"commonjs"}}),o={},r={exports:o},n=g.createContext({exports:o,module:r,require:e=>require(e),console:console,process:process});new g.Script(s,{filename:e}).runInContext(n);return n.module.exports?.default||n.module.exports}const s=await a(e,"utf-8");return JSON.parse(s)}async function x(a){const m=s("Generating TypeScript types for translations...\n").start();try{a.extract.primaryLanguage||=a.locales[0]||"en";let s=a.extract.output||`locales/${a.extract.primaryLanguage}/*.json`;if(s=d(s,a.extract.primaryLanguage||"en","*"),a.types||(a.types={input:s,output:"src/@types/i18next.d.ts"}),void 0===a.types.input&&(a.types.input=s),a.types.output||(a.types.output="src/@types/i18next.d.ts"),a.types.resourcesFile||(a.types.resourcesFile=c(p(a.types?.output),"resources.d.ts")),!a.types?.input||a.types?.input.length<0)return void console.log("No input defined!");const g=await t(a.types?.input||[],{cwd:process.cwd()}),x=[];for(const e of g){const t=u(e,l(e)),s=await w(e);if(a.extract?.mergeNamespaces&&s&&"object"==typeof s){const t=Object.keys(s),r=t.filter(e=>s[e]&&"object"==typeof s[e]);if(r.length>0){for(const e of r)x.push({name:e,resources:s[e]});const n=t.filter(e=>!s[e]||"object"!=typeof s[e]);n.length>0&&console.warn(o.yellow(`Warning: The file ${e} contains top-level keys that are not objects (${n.join(", ")}). When 'mergeNamespaces' is enabled, top-level keys are treated as namespaces. These keys will be ignored.`));continue}}x.push({name:t,resources:s})}const h=[],b=a.types?.enableSelector||!1,$=a.types?.indentation??a.extract.indentation??2,j=`// This file is automatically generated by i18next-cli. Do not edit manually.\n${e(x,{optimize:!!b,indentation:$})}`,S=y(process.cwd(),a.types?.output||""),v=y(process.cwd(),a.types.resourcesFile);let T;await r(p(v),{recursive:!0}),await n(v,j),h.push(`  ${o.green("✓")} Resources interface written to ${a.types.resourcesFile}`);try{await i(S),T=!0}catch(e){T=!1}if(!T){const e=f(p(S),v).replace(/\\/g,"/").replace(/\.d\.ts$/,""),t=`// This file is automatically generated by i18next-cli, because it was not existing. You can edit it based on your needs: https://www.i18next.com/overview/typescript#custom-type-options\nimport Resources from './${e}';\n\ndeclare module 'i18next' {\n  interface CustomTypeOptions {\n    enableSelector: ${"string"==typeof b?`"${b}"`:b};\n    defaultNS: ${!1===a.extract.defaultNS?"false":`'${a.extract.defaultNS||"translation"}'`};\n    resources: Resources;\n  }\n}`;await r(p(S),{recursive:!0}),await n(S,t),h.push(`  ${o.green("✓")} TypeScript definitions written to ${a.types.output||""}`)}m.succeed(o.bold("TypeScript definitions generated successfully.")),h.forEach(e=>console.log(e))}catch(e){m.fail(o.red("Failed to generate TypeScript definitions.")),console.error(e)}}export{x as runTypesGenerator};
+import { mergeResourcesAsInterface } from 'i18next-resources-for-ts';
+import { glob } from 'glob';
+import ora from 'ora';
+import chalk from 'chalk';
+import { mkdir, writeFile, access, readFile } from 'node:fs/promises';
+import { join, dirname, basename, extname, resolve, relative } from 'node:path';
+import { transform } from '@swc/core';
+import { getOutputPath } from './utils/file-utils.js';
+import vm from 'node:vm';
+
+async function loadFile(file) {
+    const ext = extname(file);
+    if (['.ts', '.mts', '.cts', '.js', '.mjs', '.cjs'].includes(ext)) {
+        const content = await readFile(file, 'utf-8');
+        const { code } = await transform(content, {
+            filename: file,
+            jsc: {
+                parser: {
+                    syntax: 'typescript',
+                },
+                target: 'es2018'
+            },
+            module: {
+                type: 'commonjs'
+            }
+        });
+        const exports = {};
+        const module = { exports };
+        const context = vm.createContext({
+            exports,
+            module,
+            require: (id) => require(id),
+            console,
+            process
+        });
+        const script = new vm.Script(code, { filename: file });
+        script.runInContext(context);
+        // @ts-ignore
+        const exported = context.module.exports?.default || context.module.exports;
+        return exported;
+    }
+    const content = await readFile(file, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * Generates TypeScript type definitions for i18next translations.
+ *
+ * This function:
+ * 1. Reads translation files based on the input glob patterns
+ * 2. Generates TypeScript interfaces using i18next-resources-for-ts
+ * 3. Creates separate resources.d.ts and main i18next.d.ts files
+ * 4. Handles namespace detection from filenames
+ * 5. Supports type-safe selector API when enabled
+ *
+ * @param config - The i18next toolkit configuration object
+ *
+ * @example
+ * ```typescript
+ * // Configuration
+ * const config = {
+ *   types: {
+ *     input: ['locales/en/*.json'],
+ *     output: 'src/types/i18next.d.ts',
+ *     enableSelector: true
+ *   }
+ * }
+ *
+ * await runTypesGenerator(config)
+ * ```
+ */
+async function runTypesGenerator(config) {
+    const spinner = ora('Generating TypeScript types for translations...\n').start();
+    try {
+        config.extract.primaryLanguage ||= config.locales[0] || 'en';
+        let defaultTypesInputPath = config.extract.output || `locales/${config.extract.primaryLanguage}/*.json`;
+        defaultTypesInputPath = getOutputPath(defaultTypesInputPath, config.extract.primaryLanguage || 'en', '*');
+        if (!config.types)
+            config.types = { input: defaultTypesInputPath, output: 'src/@types/i18next.d.ts' };
+        if (config.types.input === undefined)
+            config.types.input = defaultTypesInputPath;
+        if (!config.types.output)
+            config.types.output = 'src/@types/i18next.d.ts';
+        if (!config.types.resourcesFile)
+            config.types.resourcesFile = join(dirname(config.types?.output), 'resources.d.ts');
+        if (!config.types?.input || config.types?.input.length < 0) {
+            console.log('No input defined!');
+            return;
+        }
+        const resourceFiles = await glob(config.types?.input || [], {
+            cwd: process.cwd(),
+        });
+        const resources = [];
+        for (const file of resourceFiles) {
+            const namespace = basename(file, extname(file));
+            const parsedContent = await loadFile(file);
+            // If mergeNamespaces is used, a single file can contain multiple namespaces
+            // (e.g. { "translation": { ... }, "common": { ... } } in a per-language file).
+            // In that case, expose each top-level key as a namespace entry so the type
+            // generator will produce top-level namespace interfaces (not a language wrapper).
+            if (config.extract?.mergeNamespaces && parsedContent && typeof parsedContent === 'object') {
+                const keys = Object.keys(parsedContent);
+                const objectKeys = keys.filter(k => parsedContent[k] && typeof parsedContent[k] === 'object');
+                // If we have at least one object and we are in mergeNamespaces mode, assume it's a merged file
+                if (objectKeys.length > 0) {
+                    for (const nsName of objectKeys) {
+                        resources.push({ name: nsName, resources: parsedContent[nsName] });
+                    }
+                    const nonObjectKeys = keys.filter(k => !parsedContent[k] || typeof parsedContent[k] !== 'object');
+                    if (nonObjectKeys.length > 0) {
+                        console.warn(chalk.yellow(`Warning: The file ${file} contains top-level keys that are not objects (${nonObjectKeys.join(', ')}). When 'mergeNamespaces' is enabled, top-level keys are treated as namespaces. These keys will be ignored.`));
+                    }
+                    continue;
+                }
+            }
+            resources.push({ name: namespace, resources: parsedContent });
+        }
+        const logMessages = [];
+        const enableSelector = config.types?.enableSelector || false;
+        const indentation = config.types?.indentation ?? config.extract.indentation ?? 2;
+        const interfaceDefinition = `// This file is automatically generated by i18next-cli. Do not edit manually.
+${mergeResourcesAsInterface(resources, { optimize: !!enableSelector, indentation })}`;
+        const outputPath = resolve(process.cwd(), config.types?.output || '');
+        const resourcesOutputPath = resolve(process.cwd(), config.types.resourcesFile);
+        await mkdir(dirname(resourcesOutputPath), { recursive: true });
+        await writeFile(resourcesOutputPath, interfaceDefinition);
+        logMessages.push(`  ${chalk.green('✓')} Resources interface written to ${config.types.resourcesFile}`);
+        let outputPathExists;
+        try {
+            await access(outputPath);
+            outputPathExists = true;
+        }
+        catch (e) {
+            outputPathExists = false;
+        }
+        if (!outputPathExists) {
+            // The main output file will now import from the resources file
+            const importPath = relative(dirname(outputPath), resourcesOutputPath)
+                .replace(/\\/g, '/').replace(/\.d\.ts$/, ''); // Make it a valid module path
+            const defaultNS = config.extract.defaultNS === false ? 'false' : `'${config.extract.defaultNS || 'translation'}'`;
+            const fileContent = `// This file is automatically generated by i18next-cli, because it was not existing. You can edit it based on your needs: https://www.i18next.com/overview/typescript#custom-type-options
+import Resources from './${importPath}';
+
+declare module 'i18next' {
+  interface CustomTypeOptions {
+    enableSelector: ${typeof enableSelector === 'string' ? `"${enableSelector}"` : enableSelector};
+    defaultNS: ${defaultNS};
+    resources: Resources;
+  }
+}`;
+            await mkdir(dirname(outputPath), { recursive: true });
+            await writeFile(outputPath, fileContent);
+            logMessages.push(`  ${chalk.green('✓')} TypeScript definitions written to ${config.types.output || ''}`);
+        }
+        spinner.succeed(chalk.bold('TypeScript definitions generated successfully.'));
+        logMessages.forEach(msg => console.log(msg));
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to generate TypeScript definitions.'));
+        console.error(error);
+    }
+}
+
+export { runTypesGenerator };