i18next-cli 1.54.2 → 1.55.0

package/dist/cjs/cli.js

@@ -11,6 +11,7 @@ var heuristicConfig = require('./heuristic-config.js');
 var extractor = require('./extractor/core/extractor.js');
 require('./extractor/parsers/jsx-parser.js');
 require('node:path');
+var nestedObject = require('./utils/nested-object.js');
 require('node:fs/promises');
 require('jiti');
 require('@croct/json5-parser');
@@ -31,7 +32,7 @@ const program = new commander.Command();
 program
     .name('i18next-cli')
     .description('A unified, high-performance i18next CLI.')
-    .version('1.54.2'); // This string is replaced with the actual version at build time by rollup
+    .version('1.55.0'); // This string is replaced with the actual version at build time by rollup
 // new: global config override option
 program.option('-c, --config <path>', 'Path to i18next-cli config file (overrides detection)');
 program
@@ -51,7 +52,7 @@ program
         const runExtract = async () => {
             // --sync-all implies sync-primary behavior
             const syncPrimary = !!options.syncPrimary || !!options.syncAll;
-            const { anyFileUpdated, hasErrors } = await extractor.runExtractor(config$1, {
+            const { anyFileUpdated, hasErrors, results } = await extractor.runExtractor(config$1, {
                 isWatchMode: !!options.watch,
                 isDryRun: !!options.dryRun,
                 syncPrimaryWithDefaults: syncPrimary,
@@ -65,6 +66,7 @@ program
             }
             else if (options.ci && anyFileUpdated) {
                 console.error('❌ Some files were updated. This should not happen in CI mode.');
+                printCiDiff(results, config$1);
                 process.exit(1);
             }
             if (hasErrors && !options.watch) {
@@ -328,5 +330,67 @@ const expandGlobs = async (patterns = []) => {
     const sets = await Promise.all(arr.map(p => glob.glob(p || '', { nodir: true })));
     return Array.from(new Set(sets.flat()));
 };
+function printCiDiff(results, config) {
+    const rawSep = config.extract.keySeparator;
+    const keySeparator = rawSep === false ? false : (rawSep ?? '.');
+    for (const result of results) {
+        if (!result.updated)
+            continue;
+        const existing = result.existingTranslations || {};
+        const next = result.newTranslations || {};
+        const oldKeys = new Set(nestedObject.getNestedKeys(existing, keySeparator));
+        const newKeys = new Set(nestedObject.getNestedKeys(next, keySeparator));
+        const added = [];
+        const removed = [];
+        const changed = [];
+        for (const k of newKeys) {
+            if (!oldKeys.has(k)) {
+                added.push(k);
+            }
+            else {
+                const oldVal = nestedObject.getNestedValue(existing, k, keySeparator);
+                const newVal = nestedObject.getNestedValue(next, k, keySeparator);
+                if (oldVal !== newVal)
+                    changed.push(k);
+            }
+        }
+        for (const k of oldKeys) {
+            if (!newKeys.has(k))
+                removed.push(k);
+        }
+        const nsLabel = result.namespace
+            ? ` [${result.locale}/${result.namespace}]`
+            : ` [${result.locale}]`;
+        console.error(`\n  ${result.path}${nsLabel}`);
+        if (added.length === 0 && removed.length === 0 && changed.length === 0) {
+            console.error('    (no key differences — only formatting or ordering changes)');
+            continue;
+        }
+        added.sort();
+        removed.sort();
+        changed.sort();
+        for (const k of added) {
+            const v = nestedObject.getNestedValue(next, k, keySeparator);
+            console.error(node_util.styleText('green', `    + ${k}: ${formatCiDiffValue(v)}`));
+        }
+        for (const k of removed) {
+            const v = nestedObject.getNestedValue(existing, k, keySeparator);
+            console.error(node_util.styleText('red', `    - ${k}: ${formatCiDiffValue(v)}`));
+        }
+        for (const k of changed) {
+            const oldV = nestedObject.getNestedValue(existing, k, keySeparator);
+            const newV = nestedObject.getNestedValue(next, k, keySeparator);
+            console.error(node_util.styleText('yellow', `    ~ ${k}: ${formatCiDiffValue(oldV)} → ${formatCiDiffValue(newV)}`));
+        }
+    }
+}
+function formatCiDiffValue(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
 
 exports.program = program;

package/dist/cjs/extractor/core/ast-visitors.js

@@ -96,6 +96,16 @@ class ASTVisitors {
                 this.scopeManager.handleVariableDeclarator(node);
                 this.expressionResolver.captureVariableDeclarator(node);
                 break;
+            case 'TSEnumDeclaration':
+            case 'TsEnumDeclaration':
+            case 'TsEnumDecl':
+                // Enums → ExpressionResolver.sharedEnumTable. Needed in pre-scan so
+                // that function bodies referencing enum members (e.g. `return
+                // OrganizationType.ROUTING`) can be resolved by the body-inference
+                // branch of captureFunctionDeclaration when we hit the function later
+                // in the same file.
+                this.expressionResolver.captureEnumDeclaration(node);
+                break;
             case 'TsTypeAliasDeclaration':
             case 'TSTypeAliasDeclaration':
             case 'TsTypeAliasDecl':
@@ -104,7 +114,7 @@ class ASTVisitors {
                 break;
             case 'FunctionDeclaration':
             case 'FnDecl':
-                // Return-type annotations for t(fn()) patterns
+                // Return-type annotations or inferred return values for t(fn()) patterns
                 this.expressionResolver.captureFunctionDeclaration(node);
                 break;
         }

package/dist/cjs/extractor/core/extractor.js

@@ -99,7 +99,7 @@ async function runExtractor(config, options = {}) {
         // always show the funnel regardless of cooldown.
         if (anyFileUpdated && !options.isDryRun && !options.quiet)
             await printLocizeFunnel(options.logger, anyNewFile);
-        return { anyFileUpdated, hasErrors: fileErrors.length > 0 };
+        return { anyFileUpdated, hasErrors: fileErrors.length > 0, results };
     }
     catch (error) {
         spinner.fail(node_util.styleText('red', 'Extraction failed.'));

package/dist/cjs/extractor/parsers/expression-resolver.js

@@ -18,6 +18,11 @@ class ExpressionResolver {
     // Shared (cross-file) table for type aliases — populated alongside typeAliasTable.
     // Persists across resetFileSymbols() so exported type aliases are visible to importers.
     sharedTypeAliasTable = new Map();
+    // Shared (cross-file) table for function return-value sets. Populated from
+    // both explicit return-type annotations and body-inferred return values so
+    // that `t(fn())` / `const x = fn(); t(\`...${x}...\`)` work across files.
+    // Persists across resetFileSymbols() just like the other shared tables.
+    sharedFunctionReturnTable = new Map();
     // Temporary per-scope variable overrides, used to inject .map() / .forEach()
     // callback parameters while the callback body is being walked.
     temporaryVariables = new Map();
@@ -168,15 +173,23 @@ class ExpressionResolver {
                 return;
             }
             // pattern 3 (arrow function variant):
-            // `const fn = (): 'a' | 'b' => ...` — capture the explicit return type annotation.
+            // `const fn = (): 'a' | 'b' => ...` — capture the explicit return type annotation,
+            // OR fall back to walking the body's return expressions / expression body
+            // when no annotation is present (mirrors TS's own return-type inference).
             if (unwrappedInit.type === 'ArrowFunctionExpression' || unwrappedInit.type === 'FunctionExpression') {
+                let returnVals = [];
                 const rawReturnType = unwrappedInit.returnType ?? unwrappedInit.typeAnnotation;
                 if (rawReturnType) {
+                    // Explicit annotation — trust it even when it resolves to [].
                     const tsType = rawReturnType.typeAnnotation ?? rawReturnType;
-                    const returnVals = this.resolvePossibleStringValuesFromType(tsType);
-                    if (returnVals.length > 0) {
-                        this.variableTable.set(name, returnVals);
-                    }
+                    returnVals = this.resolvePossibleStringValuesFromType(tsType);
+                }
+                else {
+                    returnVals = this.inferReturnValuesFromFunctionBody(unwrappedInit);
+                }
+                if (returnVals.length > 0) {
+                    this.variableTable.set(name, returnVals);
+                    this.sharedFunctionReturnTable.set(name, returnVals);
                 }
             }
         }
@@ -231,19 +244,85 @@ class ExpressionResolver {
             // or directly in `.returnType` (FunctionExpression / ArrowFunctionExpression).
             const fn = node.function ?? node;
             const rawReturnType = fn.returnType ?? fn.typeAnnotation;
-            if (!rawReturnType)
-                return;
-            // Unwrap TsTypeAnnotation wrapper if present
-            const tsType = rawReturnType.typeAnnotation ?? rawReturnType;
-            const vals = this.resolvePossibleStringValuesFromType(tsType);
+            let vals = [];
+            if (rawReturnType) {
+                // Unwrap TsTypeAnnotation wrapper if present. Explicit annotations are
+                // authoritative: if the author declared the return type we trust it,
+                // even when it resolves to [] (e.g. plain `string`). Falling back to
+                // body inference in that case would invent keys the author deliberately
+                // opted out of.
+                const tsType = rawReturnType.typeAnnotation ?? rawReturnType;
+                vals = this.resolvePossibleStringValuesFromType(tsType);
+            }
+            else {
+                // No annotation — infer from body. Mirrors TS's own return-type
+                // inference for functions like:
+                //   function getCurrentAppType() {
+                //     if (...) return OrganizationType.ROUTING;
+                //     if (...) return OrganizationType.CONTRACTOR;
+                //   }
+                vals = this.inferReturnValuesFromFunctionBody(fn);
+            }
             if (vals.length > 0) {
                 this.variableTable.set(name, vals);
+                this.sharedFunctionReturnTable.set(name, vals);
             }
         }
         catch {
             // noop
         }
     }
+    /**
+     * Walk a function body's ReturnStatements and union the statically-resolvable
+     * string values of their argument expressions. Does NOT descend into nested
+     * function declarations (their returns belong to the inner function, not us).
+     *
+     * This is how we mirror TypeScript's implicit return-type inference for the
+     * purpose of extracting translation keys — we don't need exhaustiveness, just
+     * the set of string values any return statement could produce.
+     */
+    inferReturnValuesFromFunctionBody(fn) {
+        const body = fn?.body;
+        if (!body)
+            return [];
+        const collected = [];
+        const visit = (n) => {
+            if (!n || typeof n !== 'object')
+                return;
+            // Don't descend into nested function bodies — their returns aren't ours.
+            if (n !== body && (n.type === 'FunctionDeclaration' ||
+                n.type === 'FunctionExpression' ||
+                n.type === 'ArrowFunctionExpression'))
+                return;
+            if (n.type === 'ReturnStatement' && n.argument) {
+                const vals = this.resolvePossibleStringValuesFromExpression(n.argument);
+                if (vals.length > 0)
+                    collected.push(...vals);
+            }
+            for (const key of Object.keys(n)) {
+                const child = n[key];
+                if (Array.isArray(child)) {
+                    for (const item of child) {
+                        if (item && typeof item === 'object')
+                            visit(item);
+                    }
+                }
+                else if (child && typeof child === 'object' && typeof child.type === 'string') {
+                    visit(child);
+                }
+            }
+        };
+        // Arrow functions with an expression body (no BlockStatement) — `() => expr` —
+        // have their return expression directly as `body`.
+        if (body.type !== 'BlockStatement') {
+            const vals = this.resolvePossibleStringValuesFromExpression(body);
+            if (vals.length > 0)
+                return Array.from(new Set(vals));
+            return [];
+        }
+        visit(body);
+        return Array.from(new Set(collected));
+    }
     /**
      * Extract a raw TsType node from an identifier's type annotation.
      * SWC may wrap it in a `TsTypeAnnotation` node — this unwraps it.
@@ -503,7 +582,10 @@ class ExpressionResolver {
             catch { }
         }
         // pattern 3:
-        // `t(fn())` — resolve to the function's known return-type union when captured.
+        // `t(fn())` — resolve to the function's known return-value set (either
+        // from an explicit annotation or inferred from the function body). Check
+        // the per-file variable table first (same-file capture) and fall back to
+        // the shared cross-file table populated during pre-scan.
         if (expression.type === 'CallExpression') {
             try {
                 const callee = expression.callee;
@@ -511,6 +593,9 @@ class ExpressionResolver {
                     const v = this.variableTable.get(callee.value);
                     if (Array.isArray(v) && v.length > 0)
                         return v;
+                    const sv = this.sharedFunctionReturnTable.get(callee.value);
+                    if (sv && sv.length > 0)
+                        return sv;
                 }
             }
             catch { }

package/dist/esm/cli.js

@@ -9,6 +9,7 @@ import { detectConfig } from './heuristic-config.js';
 import { runExtractor } from './extractor/core/extractor.js';
 import './extractor/parsers/jsx-parser.js';
 import 'node:path';
+import { getNestedKeys, getNestedValue } from './utils/nested-object.js';
 import 'node:fs/promises';
 import 'jiti';
 import '@croct/json5-parser';
@@ -29,7 +30,7 @@ const program = new Command();
 program
     .name('i18next-cli')
     .description('A unified, high-performance i18next CLI.')
-    .version('1.54.2'); // This string is replaced with the actual version at build time by rollup
+    .version('1.55.0'); // This string is replaced with the actual version at build time by rollup
 // new: global config override option
 program.option('-c, --config <path>', 'Path to i18next-cli config file (overrides detection)');
 program
@@ -49,7 +50,7 @@ program
         const runExtract = async () => {
             // --sync-all implies sync-primary behavior
             const syncPrimary = !!options.syncPrimary || !!options.syncAll;
-            const { anyFileUpdated, hasErrors } = await runExtractor(config, {
+            const { anyFileUpdated, hasErrors, results } = await runExtractor(config, {
                 isWatchMode: !!options.watch,
                 isDryRun: !!options.dryRun,
                 syncPrimaryWithDefaults: syncPrimary,
@@ -63,6 +64,7 @@ program
             }
             else if (options.ci && anyFileUpdated) {
                 console.error('❌ Some files were updated. This should not happen in CI mode.');
+                printCiDiff(results, config);
                 process.exit(1);
             }
             if (hasErrors && !options.watch) {
@@ -326,5 +328,67 @@ const expandGlobs = async (patterns = []) => {
     const sets = await Promise.all(arr.map(p => glob(p || '', { nodir: true })));
     return Array.from(new Set(sets.flat()));
 };
+function printCiDiff(results, config) {
+    const rawSep = config.extract.keySeparator;
+    const keySeparator = rawSep === false ? false : (rawSep ?? '.');
+    for (const result of results) {
+        if (!result.updated)
+            continue;
+        const existing = result.existingTranslations || {};
+        const next = result.newTranslations || {};
+        const oldKeys = new Set(getNestedKeys(existing, keySeparator));
+        const newKeys = new Set(getNestedKeys(next, keySeparator));
+        const added = [];
+        const removed = [];
+        const changed = [];
+        for (const k of newKeys) {
+            if (!oldKeys.has(k)) {
+                added.push(k);
+            }
+            else {
+                const oldVal = getNestedValue(existing, k, keySeparator);
+                const newVal = getNestedValue(next, k, keySeparator);
+                if (oldVal !== newVal)
+                    changed.push(k);
+            }
+        }
+        for (const k of oldKeys) {
+            if (!newKeys.has(k))
+                removed.push(k);
+        }
+        const nsLabel = result.namespace
+            ? ` [${result.locale}/${result.namespace}]`
+            : ` [${result.locale}]`;
+        console.error(`\n  ${result.path}${nsLabel}`);
+        if (added.length === 0 && removed.length === 0 && changed.length === 0) {
+            console.error('    (no key differences — only formatting or ordering changes)');
+            continue;
+        }
+        added.sort();
+        removed.sort();
+        changed.sort();
+        for (const k of added) {
+            const v = getNestedValue(next, k, keySeparator);
+            console.error(styleText('green', `    + ${k}: ${formatCiDiffValue(v)}`));
+        }
+        for (const k of removed) {
+            const v = getNestedValue(existing, k, keySeparator);
+            console.error(styleText('red', `    - ${k}: ${formatCiDiffValue(v)}`));
+        }
+        for (const k of changed) {
+            const oldV = getNestedValue(existing, k, keySeparator);
+            const newV = getNestedValue(next, k, keySeparator);
+            console.error(styleText('yellow', `    ~ ${k}: ${formatCiDiffValue(oldV)} → ${formatCiDiffValue(newV)}`));
+        }
+    }
+}
+function formatCiDiffValue(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
 
 export { program };

package/dist/esm/extractor/core/ast-visitors.js

@@ -94,6 +94,16 @@ class ASTVisitors {
                 this.scopeManager.handleVariableDeclarator(node);
                 this.expressionResolver.captureVariableDeclarator(node);
                 break;
+            case 'TSEnumDeclaration':
+            case 'TsEnumDeclaration':
+            case 'TsEnumDecl':
+                // Enums → ExpressionResolver.sharedEnumTable. Needed in pre-scan so
+                // that function bodies referencing enum members (e.g. `return
+                // OrganizationType.ROUTING`) can be resolved by the body-inference
+                // branch of captureFunctionDeclaration when we hit the function later
+                // in the same file.
+                this.expressionResolver.captureEnumDeclaration(node);
+                break;
             case 'TsTypeAliasDeclaration':
             case 'TSTypeAliasDeclaration':
             case 'TsTypeAliasDecl':
@@ -102,7 +112,7 @@ class ASTVisitors {
                 break;
             case 'FunctionDeclaration':
             case 'FnDecl':
-                // Return-type annotations for t(fn()) patterns
+                // Return-type annotations or inferred return values for t(fn()) patterns
                 this.expressionResolver.captureFunctionDeclaration(node);
                 break;
         }

package/dist/esm/extractor/core/extractor.js

@@ -97,7 +97,7 @@ async function runExtractor(config, options = {}) {
         // always show the funnel regardless of cooldown.
         if (anyFileUpdated && !options.isDryRun && !options.quiet)
             await printLocizeFunnel(options.logger, anyNewFile);
-        return { anyFileUpdated, hasErrors: fileErrors.length > 0 };
+        return { anyFileUpdated, hasErrors: fileErrors.length > 0, results };
     }
     catch (error) {
         spinner.fail(styleText('red', 'Extraction failed.'));

package/dist/esm/extractor/parsers/expression-resolver.js

@@ -16,6 +16,11 @@ class ExpressionResolver {
     // Shared (cross-file) table for type aliases — populated alongside typeAliasTable.
     // Persists across resetFileSymbols() so exported type aliases are visible to importers.
     sharedTypeAliasTable = new Map();
+    // Shared (cross-file) table for function return-value sets. Populated from
+    // both explicit return-type annotations and body-inferred return values so
+    // that `t(fn())` / `const x = fn(); t(\`...${x}...\`)` work across files.
+    // Persists across resetFileSymbols() just like the other shared tables.
+    sharedFunctionReturnTable = new Map();
     // Temporary per-scope variable overrides, used to inject .map() / .forEach()
     // callback parameters while the callback body is being walked.
     temporaryVariables = new Map();
@@ -166,15 +171,23 @@ class ExpressionResolver {
                 return;
             }
             // pattern 3 (arrow function variant):
-            // `const fn = (): 'a' | 'b' => ...` — capture the explicit return type annotation.
+            // `const fn = (): 'a' | 'b' => ...` — capture the explicit return type annotation,
+            // OR fall back to walking the body's return expressions / expression body
+            // when no annotation is present (mirrors TS's own return-type inference).
             if (unwrappedInit.type === 'ArrowFunctionExpression' || unwrappedInit.type === 'FunctionExpression') {
+                let returnVals = [];
                 const rawReturnType = unwrappedInit.returnType ?? unwrappedInit.typeAnnotation;
                 if (rawReturnType) {
+                    // Explicit annotation — trust it even when it resolves to [].
                     const tsType = rawReturnType.typeAnnotation ?? rawReturnType;
-                    const returnVals = this.resolvePossibleStringValuesFromType(tsType);
-                    if (returnVals.length > 0) {
-                        this.variableTable.set(name, returnVals);
-                    }
+                    returnVals = this.resolvePossibleStringValuesFromType(tsType);
+                }
+                else {
+                    returnVals = this.inferReturnValuesFromFunctionBody(unwrappedInit);
+                }
+                if (returnVals.length > 0) {
+                    this.variableTable.set(name, returnVals);
+                    this.sharedFunctionReturnTable.set(name, returnVals);
                 }
             }
         }
@@ -229,19 +242,85 @@ class ExpressionResolver {
             // or directly in `.returnType` (FunctionExpression / ArrowFunctionExpression).
             const fn = node.function ?? node;
             const rawReturnType = fn.returnType ?? fn.typeAnnotation;
-            if (!rawReturnType)
-                return;
-            // Unwrap TsTypeAnnotation wrapper if present
-            const tsType = rawReturnType.typeAnnotation ?? rawReturnType;
-            const vals = this.resolvePossibleStringValuesFromType(tsType);
+            let vals = [];
+            if (rawReturnType) {
+                // Unwrap TsTypeAnnotation wrapper if present. Explicit annotations are
+                // authoritative: if the author declared the return type we trust it,
+                // even when it resolves to [] (e.g. plain `string`). Falling back to
+                // body inference in that case would invent keys the author deliberately
+                // opted out of.
+                const tsType = rawReturnType.typeAnnotation ?? rawReturnType;
+                vals = this.resolvePossibleStringValuesFromType(tsType);
+            }
+            else {
+                // No annotation — infer from body. Mirrors TS's own return-type
+                // inference for functions like:
+                //   function getCurrentAppType() {
+                //     if (...) return OrganizationType.ROUTING;
+                //     if (...) return OrganizationType.CONTRACTOR;
+                //   }
+                vals = this.inferReturnValuesFromFunctionBody(fn);
+            }
             if (vals.length > 0) {
                 this.variableTable.set(name, vals);
+                this.sharedFunctionReturnTable.set(name, vals);
             }
         }
         catch {
             // noop
         }
     }
+    /**
+     * Walk a function body's ReturnStatements and union the statically-resolvable
+     * string values of their argument expressions. Does NOT descend into nested
+     * function declarations (their returns belong to the inner function, not us).
+     *
+     * This is how we mirror TypeScript's implicit return-type inference for the
+     * purpose of extracting translation keys — we don't need exhaustiveness, just
+     * the set of string values any return statement could produce.
+     */
+    inferReturnValuesFromFunctionBody(fn) {
+        const body = fn?.body;
+        if (!body)
+            return [];
+        const collected = [];
+        const visit = (n) => {
+            if (!n || typeof n !== 'object')
+                return;
+            // Don't descend into nested function bodies — their returns aren't ours.
+            if (n !== body && (n.type === 'FunctionDeclaration' ||
+                n.type === 'FunctionExpression' ||
+                n.type === 'ArrowFunctionExpression'))
+                return;
+            if (n.type === 'ReturnStatement' && n.argument) {
+                const vals = this.resolvePossibleStringValuesFromExpression(n.argument);
+                if (vals.length > 0)
+                    collected.push(...vals);
+            }
+            for (const key of Object.keys(n)) {
+                const child = n[key];
+                if (Array.isArray(child)) {
+                    for (const item of child) {
+                        if (item && typeof item === 'object')
+                            visit(item);
+                    }
+                }
+                else if (child && typeof child === 'object' && typeof child.type === 'string') {
+                    visit(child);
+                }
+            }
+        };
+        // Arrow functions with an expression body (no BlockStatement) — `() => expr` —
+        // have their return expression directly as `body`.
+        if (body.type !== 'BlockStatement') {
+            const vals = this.resolvePossibleStringValuesFromExpression(body);
+            if (vals.length > 0)
+                return Array.from(new Set(vals));
+            return [];
+        }
+        visit(body);
+        return Array.from(new Set(collected));
+    }
     /**
      * Extract a raw TsType node from an identifier's type annotation.
      * SWC may wrap it in a `TsTypeAnnotation` node — this unwraps it.
@@ -501,7 +580,10 @@ class ExpressionResolver {
             catch { }
         }
         // pattern 3:
-        // `t(fn())` — resolve to the function's known return-type union when captured.
+        // `t(fn())` — resolve to the function's known return-value set (either
+        // from an explicit annotation or inferred from the function body). Check
+        // the per-file variable table first (same-file capture) and fall back to
+        // the shared cross-file table populated during pre-scan.
         if (expression.type === 'CallExpression') {
             try {
                 const callee = expression.callee;
@@ -509,6 +591,9 @@ class ExpressionResolver {
                     const v = this.variableTable.get(callee.value);
                     if (Array.isArray(v) && v.length > 0)
                         return v;
+                    const sv = this.sharedFunctionReturnTable.get(callee.value);
+                    if (sv && sv.length > 0)
+                        return sv;
                 }
             }
             catch { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18next-cli",
-  "version": "1.54.2",
+  "version": "1.55.0",
   "description": "A unified, high-performance i18next CLI.",
   "type": "module",
   "bin": {

package/types/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAmBnC,QAAA,MAAM,OAAO,SAAgB,CAAA;AA6U7B,OAAO,EAAE,OAAO,EAAE,CAAA"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAoBnC,QAAA,MAAM,OAAO,SAAgB,CAAA;AAiZ7B,OAAO,EAAE,OAAO,EAAE,CAAA"}

package/types/extractor/core/ast-visitors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ast-visitors.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/ast-visitors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAQ,MAAM,WAAW,CAAA;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC7G,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAItE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAe;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,KAAK,CAAiB;IAE9B,IAAW,UAAU,gBAEpB;IAED,SAAgB,YAAY,EAAE,YAAY,CAAA;IAC1C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoB;IACvD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAuB;IAC7D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAY;IACvC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,WAAW,CAAa;IAEhC;;;;;;OAMG;gBAED,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,eAAe,EACvB,kBAAkB,CAAC,EAAE,kBAAkB;IAiCzC;;;;;;;;;;;;;OAaG;IACI,mBAAmB,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAK/C;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAoCzB;;;;;OAKG;IACI,KAAK,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAUjC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,IAAI;IAoXZ;;;;;;;;OAQG;IACH,OAAO,CAAC,gCAAgC;IAqDxC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAqB5B;;;;;;;;OAQG;IACI,eAAe,CAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAI5D;;OAEG;IACI,cAAc,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAKxD;;;;;;OAMG;IACI,cAAc,IAAK,MAAM;IAIhC;;OAEG;IACI,cAAc,IAAK,MAAM;CAGjC"}
+{"version":3,"file":"ast-visitors.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/ast-visitors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAQ,MAAM,WAAW,CAAA;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC7G,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAItE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAe;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,KAAK,CAAiB;IAE9B,IAAW,UAAU,gBAEpB;IAED,SAAgB,YAAY,EAAE,YAAY,CAAA;IAC1C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoB;IACvD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAuB;IAC7D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAY;IACvC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,WAAW,CAAa;IAEhC;;;;;;OAMG;gBAED,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,eAAe,EACvB,kBAAkB,CAAC,EAAE,kBAAkB;IAiCzC;;;;;;;;;;;;;OAaG;IACI,mBAAmB,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAK/C;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IA8CzB;;;;;OAKG;IACI,KAAK,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAUjC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,IAAI;IAoXZ;;;;;;;;OAQG;IACH,OAAO,CAAC,gCAAgC;IAqDxC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAqB5B;;;;;;;;OAQG;IACI,eAAe,CAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAI5D;;OAEG;IACI,cAAc,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAKxD;;;;;;OAMG;IACI,cAAc,IAAK,MAAM;IAIhC;;OAEG;IACI,cAAc,IAAK,MAAM;CAGjC"}

package/types/extractor/core/extractor.d.ts

@@ -37,6 +37,7 @@ export declare function runExtractor(config: I18nextToolkitConfig, options?: {
 }): Promise<{
     anyFileUpdated: boolean;
     hasErrors: boolean;
+    results: TranslationResult[];
 }>;
 /**
  * Processes an individual source file for translation key extraction.

package/types/extractor/core/extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/extractor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAO5G,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAK/C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,oBAAoB,EAC5B,OAAO,GAAE;IACP,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;CACX,GACL,OAAO,CAAC;IAAE,cAAc,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAAC,CA8E1D;AAwBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EAAE,EACjB,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,MAAM,GAAE,MAA4B,EACpC,UAAU,CAAC,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,IAAI,CAAC,CAoJf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,MAAM,GAAE,MAA4B,EACpC,UAAU,CAAC,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,IAAI,CAAC,CA6Df;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,OAAO,CAAE,MAAM,EAAE,oBAAoB,EAAE,EAAE,uBAA+B,EAAE,GAAE;IAAE,uBAAuB,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAO1K"}
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/extractor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAO5G,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAK/C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,oBAAoB,EAC5B,OAAO,GAAE;IACP,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;CACX,GACL,OAAO,CAAC;IAAE,cAAc,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,iBAAiB,EAAE,CAAA;CAAE,CAAC,CA8ExF;AAwBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EAAE,EACjB,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,MAAM,GAAE,MAA4B,EACpC,UAAU,CAAC,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,IAAI,CAAC,CAoJf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,MAAM,GAAE,MAA4B,EACpC,UAAU,CAAC,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,IAAI,CAAC,CA6Df;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,OAAO,CAAE,MAAM,EAAE,oBAAoB,EAAE,EAAE,uBAA+B,EAAE,GAAE;IAAE,uBAAuB,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAO1K"}

package/types/extractor/parsers/expression-resolver.d.ts

@@ -7,6 +7,7 @@ export declare class ExpressionResolver {
     private typeAliasTable;
     private sharedVariableTable;
     private sharedTypeAliasTable;
+    private sharedFunctionReturnTable;
     private temporaryVariables;
     constructor(hooks: ASTVisitorHooks);
     /**
@@ -44,6 +45,16 @@ export declare class ExpressionResolver {
      * SWC node shapes: `FunctionDeclaration` / `FnDecl`
      */
     captureFunctionDeclaration(node: any): void;
+    /**
+     * Walk a function body's ReturnStatements and union the statically-resolvable
+     * string values of their argument expressions. Does NOT descend into nested
+     * function declarations (their returns belong to the inner function, not us).
+     *
+     * This is how we mirror TypeScript's implicit return-type inference for the
+     * purpose of extracting translation keys — we don't need exhaustiveness, just
+     * the set of string values any return statement could produce.
+     */
+    private inferReturnValuesFromFunctionBody;
     /**
      * Extract a raw TsType node from an identifier's type annotation.
      * SWC may wrap it in a `TsTypeAnnotation` node — this unwraps it.

package/types/extractor/parsers/expression-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expression-resolver.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/expression-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAkD,MAAM,WAAW,CAAA;AAC3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAErD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,KAAK,CAAiB;IAK9B,OAAO,CAAC,aAAa,CAA4D;IAGjF,OAAO,CAAC,eAAe,CAAiD;IAIxE,OAAO,CAAC,cAAc,CAAmC;IAIzD,OAAO,CAAC,mBAAmB,CAAmC;IAI9D,OAAO,CAAC,oBAAoB,CAAmC;IAI/D,OAAO,CAAC,kBAAkB,CAAmC;gBAEhD,KAAK,EAAE,eAAe;IAInC;;OAEG;IACI,gBAAgB,IAAK,IAAI;IAMhC;;;;;;;;;OASG;IACH,yBAAyB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAoJ3C;;;;;;;OAOG;IACH,2BAA2B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAkB7C;;;;;;;;;OASG;IACH,0BAA0B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAoB5C;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;;OAIG;IACI,oBAAoB,CAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAIlE;;OAEG;IACI,uBAAuB,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAInD;;;;OAIG;IACI,yBAAyB,CAAE,MAAM,EAAE,GAAG,GAAG,MAAM,EAAE;IAQxD;;;OAGG;IACI,iBAAiB,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAQ7D;;;;OAIG;IACI,YAAY,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;IAQtE;;;;;OAKG;IACH,sBAAsB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAwBxC;;;;;;;OAOG;IACH,kCAAkC,CAAE,UAAU,EAAE,UAAU,GAAG,MAAM,EAAE;IAKrE;;;;;;;OAOG;IACH,8BAA8B,CAAE,UAAU,EAAE,UAAU,GAAG,MAAM,EAAE;IAKjE;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,yCAAyC;IAsNjD,OAAO,CAAC,mCAAmC;IAiH3C;;;;;;OAMG;IACH,OAAO,CAAC,6CAA6C;IAyBrD;;;;;;OAMG;IACH,OAAO,CAAC,kDAAkD;CAwB3D"}
+{"version":3,"file":"expression-resolver.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/expression-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAkD,MAAM,WAAW,CAAA;AAC3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAErD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,KAAK,CAAiB;IAK9B,OAAO,CAAC,aAAa,CAA4D;IAGjF,OAAO,CAAC,eAAe,CAAiD;IAIxE,OAAO,CAAC,cAAc,CAAmC;IAIzD,OAAO,CAAC,mBAAmB,CAAmC;IAI9D,OAAO,CAAC,oBAAoB,CAAmC;IAM/D,OAAO,CAAC,yBAAyB,CAAmC;IAIpE,OAAO,CAAC,kBAAkB,CAAmC;gBAEhD,KAAK,EAAE,eAAe;IAInC;;OAEG;IACI,gBAAgB,IAAK,IAAI;IAMhC;;;;;;;;;OASG;IACH,yBAAyB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IA2J3C;;;;;;;OAOG;IACH,2BAA2B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAkB7C;;;;;;;;;OASG;IACH,0BAA0B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAqC5C;;;;;;;;OAQG;IACH,OAAO,CAAC,iCAAiC;IA6CzC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;;OAIG;IACI,oBAAoB,CAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAIlE;;OAEG;IACI,uBAAuB,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAInD;;;;OAIG;IACI,yBAAyB,CAAE,MAAM,EAAE,GAAG,GAAG,MAAM,EAAE;IAQxD;;;OAGG;IACI,iBAAiB,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAQ7D;;;;OAIG;IACI,YAAY,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;IAQtE;;;;;OAKG;IACH,sBAAsB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAwBxC;;;;;;;OAOG;IACH,kCAAkC,CAAE,UAAU,EAAE,UAAU,GAAG,MAAM,EAAE;IAKrE;;;;;;;OAOG;IACH,8BAA8B,CAAE,UAAU,EAAE,UAAU,GAAG,MAAM,EAAE;IAKjE;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,yCAAyC;IA2NjD,OAAO,CAAC,mCAAmC;IAiH3C;;;;;;OAMG;IACH,OAAO,CAAC,6CAA6C;IAyBrD;;;;;;OAMG;IACH,OAAO,CAAC,kDAAkD;CAwB3D"}