i18next-cli 1.54.2 → 1.56.0

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/cjs/status.js

@@ -10,6 +10,7 @@ require('glob');
 var nestedObject = require('./utils/nested-object.js');
 var fileUtils = require('./utils/file-utils.js');
 var pluralRules = require('./utils/plural-rules.js');
+var contextVariants = require('./utils/context-variants.js');
 var funnelMsgTracker = require('./utils/funnel-msg-tracker.js');
 require('./extractor/parsers/jsx-parser.js');
 
@@ -82,7 +83,8 @@ 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 keyFinder.findKeys(config);
-    const { secondaryLanguages, keySeparator = '.', defaultNS = 'translation', mergeNamespaces = false, pluralSeparator = '_', fallbackNS } = config.extract;
+    const { secondaryLanguages, keySeparator = '.', defaultNS = 'translation', mergeNamespaces = false, pluralSeparator = '_', contextSeparator = '_', fallbackNS } = config.extract;
+    const primaryLanguage = config.extract.primaryLanguage || config.locales[0] || 'en';
     const keysByNs = new Map();
     for (const key of allExtractedKeys.values()) {
         const ns = key.ns || defaultNS || 'translation';
@@ -105,6 +107,40 @@ async function generateStatusReport(config) {
         keysByNs,
         locales: new Map(),
     };
+    // Discover context variants that live in the primary translation file but
+    // are not directly extracted as keys (see issue #243). When source code uses
+    // a dynamic context value like `t('exportType', { context: type })`, the
+    // extractor can only tag the base key as "accepting context"; the actual
+    // context values (`_gas`, `_water`, ...) are only visible in the primary
+    // translation file. Without this scan, status never checks those variants
+    // for translation gaps in secondary locales.
+    const keysAcceptingContext = new Set();
+    for (const keys of keysByNs.values()) {
+        for (const k of keys) {
+            if (k.keyAcceptingContext)
+                keysAcceptingContext.add(k.keyAcceptingContext);
+        }
+    }
+    const contextVariantsByNs = new Map();
+    if (keysAcceptingContext.size > 0) {
+        const primaryMerged = mergeNamespaces
+            ? ((await fileUtils.loadTranslationFile(node_path.resolve(process.cwd(), fileUtils.getOutputPath(config.extract.output, primaryLanguage, (defaultNS === false ? 'translation' : (defaultNS || 'translation')))))) || {})
+            : null;
+        for (const ns of keysByNs.keys()) {
+            const primaryNsTranslations = mergeNamespaces
+                ? (primaryMerged?.[ns] ?? primaryMerged ?? {})
+                : ((await fileUtils.loadTranslationFile(node_path.resolve(process.cwd(), fileUtils.getOutputPath(config.extract.output, primaryLanguage, ns)))) || {});
+            const primaryKeys = nestedObject.getNestedKeys(primaryNsTranslations, keySeparator ?? '.');
+            const variants = [];
+            for (const primaryKey of primaryKeys) {
+                if (contextVariants.isContextVariantOfAcceptingKey(primaryKey, keysAcceptingContext, pluralSeparator, contextSeparator)) {
+                    variants.push(primaryKey);
+                }
+            }
+            if (variants.length > 0)
+                contextVariantsByNs.set(ns, variants);
+        }
+    }
     for (const locale of secondaryLanguages) {
         let totalTranslatedForLocale = 0;
         let totalEmptyForLocale = 0;
@@ -172,6 +208,7 @@ async function generateStatusReport(config) {
                 }
                 return primaryState;
             };
+            const processedKeys = new Set();
             for (const { key: baseKey, hasCount, isOrdinal, isExpandedPlural } of keysInNs) {
                 if (hasCount) {
                     if (isExpandedPlural) {
@@ -185,7 +222,8 @@ async function generateStatusReport(config) {
                         // 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)) {
+                        if (localePluralCategories.includes(category) && !processedKeys.has(baseKey)) {
+                            processedKeys.add(baseKey);
                             totalInNs++;
                             const state = resolveAndClassify(baseKey);
                             if (state === 'translated')
@@ -202,10 +240,13 @@ async function generateStatusReport(config) {
                         // 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}`;
+                            if (processedKeys.has(pluralKey))
+                                continue;
+                            processedKeys.add(pluralKey);
+                            totalInNs++;
                             const state = resolveAndClassify(pluralKey);
                             if (state === 'translated')
                                 translatedInNs++;
@@ -218,17 +259,37 @@ async function generateStatusReport(config) {
                     }
                 }
                 else {
-                    totalInNs++;
-                    const state = resolveAndClassify(baseKey);
-                    if (state === 'translated')
-                        translatedInNs++;
-                    else if (state === 'empty')
-                        emptyInNs++;
-                    else
-                        absentInNs++;
-                    keyDetails.push({ key: baseKey, state });
+                    if (!processedKeys.has(baseKey)) {
+                        processedKeys.add(baseKey);
+                        totalInNs++;
+                        const state = resolveAndClassify(baseKey);
+                        if (state === 'translated')
+                            translatedInNs++;
+                        else if (state === 'empty')
+                            emptyInNs++;
+                        else
+                            absentInNs++;
+                        keyDetails.push({ key: baseKey, state });
+                    }
                 }
             }
+            // Additionally check context variants discovered in the primary file
+            // (see issue #243). Skip variants already counted via extracted keys.
+            const contextVariants = contextVariantsByNs.get(ns) || [];
+            for (const variantKey of contextVariants) {
+                if (processedKeys.has(variantKey))
+                    continue;
+                processedKeys.add(variantKey);
+                totalInNs++;
+                const state = resolveAndClassify(variantKey);
+                if (state === 'translated')
+                    translatedInNs++;
+                else if (state === 'empty')
+                    emptyInNs++;
+                else
+                    absentInNs++;
+                keyDetails.push({ key: variantKey, state });
+            }
             namespaces.set(ns, { totalKeys: totalInNs, translatedKeys: translatedInNs, emptyKeys: emptyInNs, absentKeys: absentInNs, keyDetails });
             totalTranslatedForLocale += translatedInNs;
             totalEmptyForLocale += emptyInNs;

package/dist/cjs/utils/context-variants.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/**
+ * Helpers for reasoning about context variants of translation keys.
+ *
+ * A "key accepting context" is a base key that was called with a `context`
+ * option in source code (e.g. `t('friend', { context: gender })`). Its
+ * variants in the translation file look like `<base><contextSeparator><ctx>`
+ * (optionally suffixed with a CLDR plural form).
+ */
+const pluralForms = ['zero', 'one', 'two', 'few', 'many', 'other'];
+/**
+ * Checks if an existing key is a context variant of a base key that accepts context.
+ * Handles:
+ * - Keys suffixed with a CLDR plural form (e.g. `friend_male_one`).
+ * - Context values that contain the separator (e.g. `mc_laren`).
+ *
+ * @param existingKey - The key from the translation file to check
+ * @param keysAcceptingContext - Set of base keys that were used with context in source code
+ * @param pluralSeparator - The separator used for plural forms (default: '_')
+ * @param contextSeparator - The separator used for context variants (default: '_')
+ * @returns true if the existing key is a context variant of a key accepting context
+ */
+function isContextVariantOfAcceptingKey(existingKey, keysAcceptingContext, pluralSeparator, contextSeparator) {
+    if (keysAcceptingContext.size === 0) {
+        return false;
+    }
+    let potentialBaseKey = existingKey;
+    // First, try removing plural suffixes if present
+    for (const form of pluralForms) {
+        if (potentialBaseKey.endsWith(`${pluralSeparator}${form}`)) {
+            potentialBaseKey = potentialBaseKey.slice(0, -(pluralSeparator.length + form.length));
+            break;
+        }
+        if (potentialBaseKey.endsWith(`${pluralSeparator}ordinal${pluralSeparator}${form}`)) {
+            potentialBaseKey = potentialBaseKey.slice(0, -(pluralSeparator.length + 'ordinal'.length + pluralSeparator.length + form.length));
+            break;
+        }
+    }
+    // The context value itself may contain the separator — try every possible
+    // split to find a base that matches an accepting-context key.
+    const parts = potentialBaseKey.split(contextSeparator);
+    if (parts.length > 1) {
+        for (let i = 1; i < parts.length; i++) {
+            const baseWithoutContext = parts.slice(0, -i).join(contextSeparator);
+            if (keysAcceptingContext.has(baseWithoutContext)) {
+                return true;
+            }
+        }
+    }
+    // Also accept the plural-stripped key itself as a direct match
+    // (e.g. `friend_other` → base `friend`).
+    if (keysAcceptingContext.has(potentialBaseKey)) {
+        return true;
+    }
+    return false;
+}
+
+exports.isContextVariantOfAcceptingKey = isContextVariantOfAcceptingKey;

package/dist/cjs/utils/nesting.js

@@ -0,0 +1,100 @@
+'use strict';
+
+/**
+ * Shared parser for i18next-style nested translation references of the form
+ * `$t(key, { options })`.
+ *
+ * Used in two places:
+ * 1. The extractor's AST pass scans source-code keys and default values for
+ *    nested references and registers the referenced keys (so they show up in
+ *    output translation files).
+ * 2. The translation-manager uses it during `removeUnusedKeys` cleanup so
+ *    keys that are only referenced from inside a translation value (and thus
+ *    invisible to the AST pass) are preserved instead of being deleted.
+ */
+const naturalLanguageChars = /[ ,?!;]/;
+const looksLikeNaturalLanguage = (s) => naturalLanguageChars.test(s);
+const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * Scans a string for `$t(...)` references and returns metadata about each one.
+ * The implementation mirrors the behaviour of i18next's Interpolator so that
+ * the extractor and translation manager agree on what counts as a reference.
+ */
+function parseNestedReferences(text, config) {
+    if (!text || typeof text !== 'string')
+        return [];
+    const prefix = config.nestingPrefix ?? '$t(';
+    const suffix = config.nestingSuffix ?? ')';
+    const separator = config.nestingOptionsSeparator ?? ',';
+    const nsSeparator = config.nsSeparator ?? ':';
+    const escapedPrefix = escapeRegex(prefix);
+    const escapedSuffix = escapeRegex(suffix);
+    // Regex adapted from i18next Interpolator.js — matches `$t(key)` or
+    // `$t(key, { options })` with (limited) support for balanced parens and
+    // quoted strings.
+    const nestingRegexp = new RegExp(`${escapedPrefix}((?:[^()"']+|"[^"]*"|'[^']*'|\\((?:[^()]|"[^"]*"|'[^']*')*\\))*?)${escapedSuffix}`, 'g');
+    const results = [];
+    let match;
+    while ((match = nestingRegexp.exec(text)) !== null) {
+        const content = match[1];
+        if (!content)
+            continue;
+        let key = content;
+        let optionsString = '';
+        if (content.indexOf(separator) < 0) {
+            key = content.trim();
+        }
+        else {
+            // i18next does: const c = key.split(new RegExp(`${sep}[ ]*{`));
+            // This assumes options start with `{`.
+            const sepRegex = new RegExp(`${escapeRegex(separator)}[ ]*{`);
+            const parts = content.split(sepRegex);
+            if (parts.length > 1) {
+                key = parts[0].trim();
+                optionsString = `{${parts.slice(1).join(separator + ' {')}`;
+            }
+            else {
+                const sepIdx = content.indexOf(separator);
+                key = content.substring(0, sepIdx).trim();
+                optionsString = content.substring(sepIdx + 1).trim();
+            }
+        }
+        if ((key.startsWith("'") && key.endsWith("'")) || (key.startsWith('"') && key.endsWith('"'))) {
+            key = key.slice(1, -1);
+        }
+        if (!key)
+            continue;
+        let ns;
+        if (nsSeparator && typeof nsSeparator === 'string' && key.includes(nsSeparator)) {
+            const parts = key.split(nsSeparator);
+            const candidateNs = parts[0];
+            if (!looksLikeNaturalLanguage(candidateNs)) {
+                ns = parts.shift();
+                key = parts.join(nsSeparator);
+                if (!key || key.trim() === '')
+                    continue;
+            }
+            else {
+                ns = config.defaultNS;
+            }
+        }
+        else {
+            ns = config.defaultNS;
+        }
+        let hasCount = false;
+        let context;
+        if (optionsString) {
+            if (/['"]?count['"]?\s*:/.test(optionsString)) {
+                hasCount = true;
+            }
+            const contextMatch = /['"]?context['"]?\s*:\s*(['"])(.*?)\1/.exec(optionsString);
+            if (contextMatch) {
+                context = contextMatch[2];
+            }
+        }
+        results.push({ key, ns, hasCount, context });
+    }
+    return results;
+}
+
+exports.parseNestedReferences = parseNestedReferences;

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.56.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.'));