i18next-cli 1.48.1 → 1.49.0

package/dist/cjs/cli.js

@@ -31,7 +31,7 @@ const program = new commander.Command();
 program
     .name('i18next-cli')
     .description('A unified, high-performance i18next CLI.')
-    .version('1.48.1'); // This string is replaced with the actual version at build time by rollup
+    .version('1.49.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

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

@@ -61,7 +61,7 @@ class ASTVisitors {
         this.scopeManager = new scopeManager.ScopeManager(config);
         // use shared resolver when provided so captured enums/objects are visible across files
         this.expressionResolver = expressionResolver$1 ?? new expressionResolver.ExpressionResolver(this.hooks);
-        this.callExpressionHandler = new callExpressionHandler.CallExpressionHandler(config, pluginContext, logger, this.expressionResolver, () => this.getCurrentFile(), () => this.getCurrentCode());
+        this.callExpressionHandler = new callExpressionHandler.CallExpressionHandler(config, pluginContext, logger, this.expressionResolver, () => this.getCurrentFile(), () => this.getCurrentCode(), (name) => this.scopeManager.resolveSimpleStringIdentifier(name));
         this.jsxHandler = new jsxHandler.JSXHandler(config, pluginContext, this.expressionResolver, () => this.getCurrentFile(), () => this.getCurrentCode());
     }
     /**
@@ -273,6 +273,17 @@ class ASTVisitors {
                 // capture enums into resolver symbol table
                 this.expressionResolver.captureEnumDeclaration(node);
                 break;
+            // pattern 2: capture type aliases so `declare const x: Alias` can be resolved
+            case 'TsTypeAliasDeclaration':
+            case 'TSTypeAliasDeclaration':
+            case 'TsTypeAliasDecl':
+                this.expressionResolver.captureTypeAliasDeclaration(node);
+                break;
+            // pattern 3: capture function return types so `t(fn())` can be resolved
+            case 'FunctionDeclaration':
+            case 'FnDecl':
+                this.expressionResolver.captureFunctionDeclaration(node);
+                break;
             case 'CallExpression':
                 this.callExpressionHandler.handleCallExpression(node, this.scopeManager.getVarFromScope.bind(this.scopeManager));
                 break;
@@ -316,6 +327,23 @@ class ASTVisitors {
                         this.expressionResolver.captureEnumDeclaration(item);
                         // continue to allow further traversal
                     }
+                    // pre-scan type alias declarations and function declarations
+                    if (item.type === 'TsTypeAliasDeclaration' || item.type === 'TSTypeAliasDeclaration' || item.type === 'TsTypeAliasDecl') {
+                        this.expressionResolver.captureTypeAliasDeclaration(item);
+                    }
+                    if (item.type === 'FunctionDeclaration' || item.type === 'FnDecl') {
+                        this.expressionResolver.captureFunctionDeclaration(item);
+                    }
+                    // Also handle ExportDeclaration wrapping either of the above
+                    if ((item.type === 'ExportDeclaration' || item.type === 'ExportNamedDeclaration') && item.declaration) {
+                        const decl = item.declaration;
+                        if (decl.type === 'TsTypeAliasDeclaration' || decl.type === 'TSTypeAliasDeclaration' || decl.type === 'TsTypeAliasDecl') {
+                            this.expressionResolver.captureTypeAliasDeclaration(decl);
+                        }
+                        if (decl.type === 'FunctionDeclaration' || decl.type === 'FnDecl') {
+                            this.expressionResolver.captureFunctionDeclaration(decl);
+                        }
+                    }
                     // Common case: VariableDeclaration which contains .declarations (VariableDeclarator[])
                     if (item.type === 'VariableDeclaration' && Array.isArray(item.declarations)) {
                         for (const decl of item.declarations) {

package/dist/cjs/extractor/parsers/call-expression-handler.js

@@ -12,13 +12,15 @@ class CallExpressionHandler {
     objectKeys = new Set();
     getCurrentFile;
     getCurrentCode;
-    constructor(config, pluginContext, logger, expressionResolver, getCurrentFile, getCurrentCode) {
+    resolveIdentifier;
+    constructor(config, pluginContext, logger, expressionResolver, getCurrentFile, getCurrentCode, resolveIdentifier = () => undefined) {
         this.config = config;
         this.pluginContext = pluginContext;
         this.logger = logger;
         this.expressionResolver = expressionResolver;
         this.getCurrentFile = getCurrentFile;
         this.getCurrentCode = getCurrentCode;
+        this.resolveIdentifier = resolveIdentifier;
     }
     /**
      * Computes line and column from a node's normalised span.
@@ -153,8 +155,8 @@ class CallExpressionHandler {
             // Determine namespace (explicit ns > ns:key > scope ns > default)
             // See https://www.i18next.com/overview/api#getfixedt
             if (options) {
-                const nsVal = astUtils.getObjectPropValue(options, 'ns');
-                if (typeof nsVal === 'string')
+                const nsVal = astUtils.getObjectPropValue(options, 'ns', this.resolveIdentifier);
+                if (typeof nsVal === 'string' && nsVal !== '')
                     ns = nsVal;
             }
             const nsSeparator = this.config.extract.nsSeparator ?? ':';

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

@@ -9,6 +9,9 @@ class ExpressionResolver {
     variableTable = new Map();
     // Shared (cross-file) table for enums / exported object maps that should persist
     sharedEnumTable = new Map();
+    // Per-file table for type aliases: Maps typeName -> string[]
+    // e.g. `type ChangeType = 'all' | 'next' | 'this'` -> { ChangeType: ['all', 'next', 'this'] }
+    typeAliasTable = new Map();
     constructor(hooks) {
         this.hooks = hooks;
     }
@@ -17,6 +20,7 @@ class ExpressionResolver {
      */
     resetFileSymbols() {
         this.variableTable.clear();
+        this.typeAliasTable.clear();
     }
     /**
      * Capture a VariableDeclarator node to record simple statically analyzable
@@ -30,17 +34,39 @@ class ExpressionResolver {
      */
     captureVariableDeclarator(node) {
         try {
-            if (!node || !node.id || !node.init)
+            if (!node || !node.id)
                 return;
             // only handle simple identifier bindings like `const x = ...`
             if (node.id.type !== 'Identifier')
                 return;
             const name = node.id.value;
+            // pattern 1:
+            // Handle `declare const x: 'a' | 'b'` and `declare const x: SomeUnion`
+            // where there is no initializer but a TypeScript type annotation.
+            if (!node.init) {
+                const typeAnnotation = this.extractTypeAnnotation(node.id);
+                if (typeAnnotation) {
+                    const vals = this.resolvePossibleStringValuesFromType(typeAnnotation);
+                    if (vals.length > 0) {
+                        this.variableTable.set(name, vals);
+                    }
+                }
+                return;
+            }
             const init = node.init;
+            // Unwrap TS type assertion wrappers before inspecting the shape of the initializer.
+            // `{ ... } as const` → TsConstAssertion; `x as Type` → TsAsExpression; etc.
+            // We need the raw expression to detect ObjectExpression and ArrowFunctionExpression.
+            let unwrappedInit = init;
+            while (unwrappedInit?.type === 'TsConstAssertion' ||
+                unwrappedInit?.type === 'TsAsExpression' ||
+                unwrappedInit?.type === 'TsSatisfiesExpression') {
+                unwrappedInit = unwrappedInit.expression;
+            }
             // ObjectExpression -> map of string props
-            if (init.type === 'ObjectExpression' && Array.isArray(init.properties)) {
+            if (unwrappedInit.type === 'ObjectExpression' && Array.isArray(unwrappedInit.properties)) {
                 const map = {};
-                for (const p of init.properties) {
+                for (const p of unwrappedInit.properties) {
                     if (!p || p.type !== 'KeyValueProperty')
                         continue;
                     const keyNode = p.key;
@@ -64,12 +90,96 @@ class ExpressionResolver {
             const vals = this.resolvePossibleStringValuesFromExpression(init);
             if (vals.length > 0) {
                 this.variableTable.set(name, vals);
+                return;
+            }
+            // pattern 3 (arrow function variant):
+            // `const fn = (): 'a' | 'b' => ...` — capture the explicit return type annotation.
+            if (unwrappedInit.type === 'ArrowFunctionExpression' || unwrappedInit.type === 'FunctionExpression') {
+                const rawReturnType = unwrappedInit.returnType ?? unwrappedInit.typeAnnotation;
+                if (rawReturnType) {
+                    const tsType = rawReturnType.typeAnnotation ?? rawReturnType;
+                    const returnVals = this.resolvePossibleStringValuesFromType(tsType);
+                    if (returnVals.length > 0) {
+                        this.variableTable.set(name, returnVals);
+                    }
+                }
             }
         }
         catch {
             // be silent - conservative only
         }
     }
+    /**
+     * Capture a TypeScript type alias so that `declare const x: AliasName` can
+     * be resolved to its string union members later.
+     *
+     * Handles: `type Foo = 'a' | 'b' | 'c'`
+     *
+     * SWC node shapes: `TsTypeAliasDeclaration` / `TsTypeAliasDecl`
+     */
+    captureTypeAliasDeclaration(node) {
+        try {
+            const name = node?.id?.type === 'Identifier' ? node.id.value : undefined;
+            if (!name)
+                return;
+            // SWC puts the actual type in `.typeAnnotation`
+            const tsType = node.typeAnnotation ?? node.typeAnn;
+            if (!tsType)
+                return;
+            const vals = this.resolvePossibleStringValuesFromType(tsType);
+            if (vals.length > 0) {
+                this.typeAliasTable.set(name, vals);
+            }
+        }
+        catch {
+            // noop
+        }
+    }
+    /**
+     * Capture the return-type annotation of a function declaration so that
+     * `t(fn())` calls can be expanded to all union members.
+     *
+     * Handles both `function f(): 'a' | 'b' { ... }` and
+     * `const f = (): 'a' | 'b' => ...` (the arrow-function form is captured
+     * via captureVariableDeclarator when the init is an ArrowFunctionExpression).
+     *
+     * SWC node shapes: `FunctionDeclaration` / `FnDecl`
+     */
+    captureFunctionDeclaration(node) {
+        try {
+            const name = node?.identifier?.value ?? node?.id?.value;
+            if (!name)
+                return;
+            // SWC places the return type annotation in `.function.returnType` (FunctionDeclaration)
+            // 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);
+            if (vals.length > 0) {
+                this.variableTable.set(name, vals);
+            }
+        }
+        catch {
+            // noop
+        }
+    }
+    /**
+     * Extract a raw TsType node from an identifier's type annotation.
+     * SWC may wrap it in a `TsTypeAnnotation` node — this unwraps it.
+     */
+    extractTypeAnnotation(idNode) {
+        const raw = idNode?.typeAnnotation;
+        if (!raw)
+            return undefined;
+        // TsTypeAnnotation wrapper -> .typeAnnotation holds the actual TsType
+        if (raw.type === 'TsTypeAnnotation')
+            return raw.typeAnnotation;
+        return raw;
+    }
     /**
      * Capture a TypeScript enum declaration so members can be resolved later.
      * Accepts SWC node shapes like `TsEnumDeclaration` / `TSEnumDeclaration`.
@@ -220,11 +330,36 @@ class ExpressionResolver {
                         if (propName && base[propName] !== undefined) {
                             return [base[propName]];
                         }
+                        // pattern 4:
+                        // `map[identifierVar]` where identifierVar resolves to a known set of keys.
+                        // Try to enumerate which map values are reachable.
+                        if (prop.type === 'Computed' && prop.expression) {
+                            const keyVals = this.resolvePossibleStringValuesFromExpression(prop.expression, returnEmptyStrings);
+                            if (keyVals.length > 0) {
+                                // Return only the map values for the known keys (subset access)
+                                return keyVals.map(k => base[k]).filter((v) => v !== undefined);
+                            }
+                            // Cannot narrow the key at all — return all map values as a conservative fallback
+                            return Object.values(base);
+                        }
                     }
                 }
             }
             catch { }
         }
+        // pattern 3:
+        // `t(fn())` — resolve to the function's known return-type union when captured.
+        if (expression.type === 'CallExpression') {
+            try {
+                const callee = expression.callee;
+                if (callee?.type === 'Identifier') {
+                    const v = this.variableTable.get(callee.value);
+                    if (Array.isArray(v) && v.length > 0)
+                        return v;
+                }
+            }
+            catch { }
+        }
         // Binary concatenation support (e.g., a + '_' + b)
         // SWC binary expr can be represented as `BinExpr` with left/right; be permissive:
         if (expression.left && expression.right) {
@@ -279,6 +414,11 @@ class ExpressionResolver {
             const annotation = expression.typeAnnotation;
             return this.resolvePossibleStringValuesFromType(annotation, returnEmptyStrings);
         }
+        // `expr as const` — delegate to the underlying expression (the type annotation is
+        // just `const`, which carries no union information, so we want the value side).
+        if (expression.type === 'TsConstAssertion') {
+            return this.resolvePossibleStringValuesFromExpression(expression.expression, returnEmptyStrings);
+        }
         // Identifier resolution via captured per-file variable table only
         if (expression.type === 'Identifier') {
             const v = this.variableTable.get(expression.value);
@@ -308,6 +448,19 @@ class ExpressionResolver {
                 return [`${type.literal.value}`]; // Handle literals like 5 or true
             }
         }
+        // pattern 2:
+        // Resolve a named type alias reference: `declare const x: ChangeType`
+        // where `type ChangeType = 'all' | 'next' | 'this'` was captured earlier.
+        if (type.type === 'TsTypeReference') {
+            const typeName = type.typeName?.type === 'Identifier'
+                ? type.typeName.value
+                : undefined;
+            if (typeName) {
+                const aliasVals = this.typeAliasTable.get(typeName);
+                if (aliasVals && aliasVals.length > 0)
+                    return aliasVals;
+            }
+        }
         // We can't statically determine the value of other expressions (e.g., variables, function calls)
         return [];
     }

package/dist/esm/cli.js

@@ -29,7 +29,7 @@ const program = new Command();
 program
     .name('i18next-cli')
     .description('A unified, high-performance i18next CLI.')
-    .version('1.48.1'); // This string is replaced with the actual version at build time by rollup
+    .version('1.49.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

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

@@ -59,7 +59,7 @@ class ASTVisitors {
         this.scopeManager = new ScopeManager(config);
         // use shared resolver when provided so captured enums/objects are visible across files
         this.expressionResolver = expressionResolver ?? new ExpressionResolver(this.hooks);
-        this.callExpressionHandler = new CallExpressionHandler(config, pluginContext, logger, this.expressionResolver, () => this.getCurrentFile(), () => this.getCurrentCode());
+        this.callExpressionHandler = new CallExpressionHandler(config, pluginContext, logger, this.expressionResolver, () => this.getCurrentFile(), () => this.getCurrentCode(), (name) => this.scopeManager.resolveSimpleStringIdentifier(name));
         this.jsxHandler = new JSXHandler(config, pluginContext, this.expressionResolver, () => this.getCurrentFile(), () => this.getCurrentCode());
     }
     /**
@@ -271,6 +271,17 @@ class ASTVisitors {
                 // capture enums into resolver symbol table
                 this.expressionResolver.captureEnumDeclaration(node);
                 break;
+            // pattern 2: capture type aliases so `declare const x: Alias` can be resolved
+            case 'TsTypeAliasDeclaration':
+            case 'TSTypeAliasDeclaration':
+            case 'TsTypeAliasDecl':
+                this.expressionResolver.captureTypeAliasDeclaration(node);
+                break;
+            // pattern 3: capture function return types so `t(fn())` can be resolved
+            case 'FunctionDeclaration':
+            case 'FnDecl':
+                this.expressionResolver.captureFunctionDeclaration(node);
+                break;
             case 'CallExpression':
                 this.callExpressionHandler.handleCallExpression(node, this.scopeManager.getVarFromScope.bind(this.scopeManager));
                 break;
@@ -314,6 +325,23 @@ class ASTVisitors {
                         this.expressionResolver.captureEnumDeclaration(item);
                         // continue to allow further traversal
                     }
+                    // pre-scan type alias declarations and function declarations
+                    if (item.type === 'TsTypeAliasDeclaration' || item.type === 'TSTypeAliasDeclaration' || item.type === 'TsTypeAliasDecl') {
+                        this.expressionResolver.captureTypeAliasDeclaration(item);
+                    }
+                    if (item.type === 'FunctionDeclaration' || item.type === 'FnDecl') {
+                        this.expressionResolver.captureFunctionDeclaration(item);
+                    }
+                    // Also handle ExportDeclaration wrapping either of the above
+                    if ((item.type === 'ExportDeclaration' || item.type === 'ExportNamedDeclaration') && item.declaration) {
+                        const decl = item.declaration;
+                        if (decl.type === 'TsTypeAliasDeclaration' || decl.type === 'TSTypeAliasDeclaration' || decl.type === 'TsTypeAliasDecl') {
+                            this.expressionResolver.captureTypeAliasDeclaration(decl);
+                        }
+                        if (decl.type === 'FunctionDeclaration' || decl.type === 'FnDecl') {
+                            this.expressionResolver.captureFunctionDeclaration(decl);
+                        }
+                    }
                     // Common case: VariableDeclaration which contains .declarations (VariableDeclarator[])
                     if (item.type === 'VariableDeclaration' && Array.isArray(item.declarations)) {
                         for (const decl of item.declarations) {

package/dist/esm/extractor/parsers/call-expression-handler.js

@@ -10,13 +10,15 @@ class CallExpressionHandler {
     objectKeys = new Set();
     getCurrentFile;
     getCurrentCode;
-    constructor(config, pluginContext, logger, expressionResolver, getCurrentFile, getCurrentCode) {
+    resolveIdentifier;
+    constructor(config, pluginContext, logger, expressionResolver, getCurrentFile, getCurrentCode, resolveIdentifier = () => undefined) {
         this.config = config;
         this.pluginContext = pluginContext;
         this.logger = logger;
         this.expressionResolver = expressionResolver;
         this.getCurrentFile = getCurrentFile;
         this.getCurrentCode = getCurrentCode;
+        this.resolveIdentifier = resolveIdentifier;
     }
     /**
      * Computes line and column from a node's normalised span.
@@ -151,8 +153,8 @@ class CallExpressionHandler {
             // Determine namespace (explicit ns > ns:key > scope ns > default)
             // See https://www.i18next.com/overview/api#getfixedt
             if (options) {
-                const nsVal = getObjectPropValue(options, 'ns');
-                if (typeof nsVal === 'string')
+                const nsVal = getObjectPropValue(options, 'ns', this.resolveIdentifier);
+                if (typeof nsVal === 'string' && nsVal !== '')
                     ns = nsVal;
             }
             const nsSeparator = this.config.extract.nsSeparator ?? ':';

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

@@ -7,6 +7,9 @@ class ExpressionResolver {
     variableTable = new Map();
     // Shared (cross-file) table for enums / exported object maps that should persist
     sharedEnumTable = new Map();
+    // Per-file table for type aliases: Maps typeName -> string[]
+    // e.g. `type ChangeType = 'all' | 'next' | 'this'` -> { ChangeType: ['all', 'next', 'this'] }
+    typeAliasTable = new Map();
     constructor(hooks) {
         this.hooks = hooks;
     }
@@ -15,6 +18,7 @@ class ExpressionResolver {
      */
     resetFileSymbols() {
         this.variableTable.clear();
+        this.typeAliasTable.clear();
     }
     /**
      * Capture a VariableDeclarator node to record simple statically analyzable
@@ -28,17 +32,39 @@ class ExpressionResolver {
      */
     captureVariableDeclarator(node) {
         try {
-            if (!node || !node.id || !node.init)
+            if (!node || !node.id)
                 return;
             // only handle simple identifier bindings like `const x = ...`
             if (node.id.type !== 'Identifier')
                 return;
             const name = node.id.value;
+            // pattern 1:
+            // Handle `declare const x: 'a' | 'b'` and `declare const x: SomeUnion`
+            // where there is no initializer but a TypeScript type annotation.
+            if (!node.init) {
+                const typeAnnotation = this.extractTypeAnnotation(node.id);
+                if (typeAnnotation) {
+                    const vals = this.resolvePossibleStringValuesFromType(typeAnnotation);
+                    if (vals.length > 0) {
+                        this.variableTable.set(name, vals);
+                    }
+                }
+                return;
+            }
             const init = node.init;
+            // Unwrap TS type assertion wrappers before inspecting the shape of the initializer.
+            // `{ ... } as const` → TsConstAssertion; `x as Type` → TsAsExpression; etc.
+            // We need the raw expression to detect ObjectExpression and ArrowFunctionExpression.
+            let unwrappedInit = init;
+            while (unwrappedInit?.type === 'TsConstAssertion' ||
+                unwrappedInit?.type === 'TsAsExpression' ||
+                unwrappedInit?.type === 'TsSatisfiesExpression') {
+                unwrappedInit = unwrappedInit.expression;
+            }
             // ObjectExpression -> map of string props
-            if (init.type === 'ObjectExpression' && Array.isArray(init.properties)) {
+            if (unwrappedInit.type === 'ObjectExpression' && Array.isArray(unwrappedInit.properties)) {
                 const map = {};
-                for (const p of init.properties) {
+                for (const p of unwrappedInit.properties) {
                     if (!p || p.type !== 'KeyValueProperty')
                         continue;
                     const keyNode = p.key;
@@ -62,12 +88,96 @@ class ExpressionResolver {
             const vals = this.resolvePossibleStringValuesFromExpression(init);
             if (vals.length > 0) {
                 this.variableTable.set(name, vals);
+                return;
+            }
+            // pattern 3 (arrow function variant):
+            // `const fn = (): 'a' | 'b' => ...` — capture the explicit return type annotation.
+            if (unwrappedInit.type === 'ArrowFunctionExpression' || unwrappedInit.type === 'FunctionExpression') {
+                const rawReturnType = unwrappedInit.returnType ?? unwrappedInit.typeAnnotation;
+                if (rawReturnType) {
+                    const tsType = rawReturnType.typeAnnotation ?? rawReturnType;
+                    const returnVals = this.resolvePossibleStringValuesFromType(tsType);
+                    if (returnVals.length > 0) {
+                        this.variableTable.set(name, returnVals);
+                    }
+                }
             }
         }
         catch {
             // be silent - conservative only
         }
     }
+    /**
+     * Capture a TypeScript type alias so that `declare const x: AliasName` can
+     * be resolved to its string union members later.
+     *
+     * Handles: `type Foo = 'a' | 'b' | 'c'`
+     *
+     * SWC node shapes: `TsTypeAliasDeclaration` / `TsTypeAliasDecl`
+     */
+    captureTypeAliasDeclaration(node) {
+        try {
+            const name = node?.id?.type === 'Identifier' ? node.id.value : undefined;
+            if (!name)
+                return;
+            // SWC puts the actual type in `.typeAnnotation`
+            const tsType = node.typeAnnotation ?? node.typeAnn;
+            if (!tsType)
+                return;
+            const vals = this.resolvePossibleStringValuesFromType(tsType);
+            if (vals.length > 0) {
+                this.typeAliasTable.set(name, vals);
+            }
+        }
+        catch {
+            // noop
+        }
+    }
+    /**
+     * Capture the return-type annotation of a function declaration so that
+     * `t(fn())` calls can be expanded to all union members.
+     *
+     * Handles both `function f(): 'a' | 'b' { ... }` and
+     * `const f = (): 'a' | 'b' => ...` (the arrow-function form is captured
+     * via captureVariableDeclarator when the init is an ArrowFunctionExpression).
+     *
+     * SWC node shapes: `FunctionDeclaration` / `FnDecl`
+     */
+    captureFunctionDeclaration(node) {
+        try {
+            const name = node?.identifier?.value ?? node?.id?.value;
+            if (!name)
+                return;
+            // SWC places the return type annotation in `.function.returnType` (FunctionDeclaration)
+            // 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);
+            if (vals.length > 0) {
+                this.variableTable.set(name, vals);
+            }
+        }
+        catch {
+            // noop
+        }
+    }
+    /**
+     * Extract a raw TsType node from an identifier's type annotation.
+     * SWC may wrap it in a `TsTypeAnnotation` node — this unwraps it.
+     */
+    extractTypeAnnotation(idNode) {
+        const raw = idNode?.typeAnnotation;
+        if (!raw)
+            return undefined;
+        // TsTypeAnnotation wrapper -> .typeAnnotation holds the actual TsType
+        if (raw.type === 'TsTypeAnnotation')
+            return raw.typeAnnotation;
+        return raw;
+    }
     /**
      * Capture a TypeScript enum declaration so members can be resolved later.
      * Accepts SWC node shapes like `TsEnumDeclaration` / `TSEnumDeclaration`.
@@ -218,11 +328,36 @@ class ExpressionResolver {
                         if (propName && base[propName] !== undefined) {
                             return [base[propName]];
                         }
+                        // pattern 4:
+                        // `map[identifierVar]` where identifierVar resolves to a known set of keys.
+                        // Try to enumerate which map values are reachable.
+                        if (prop.type === 'Computed' && prop.expression) {
+                            const keyVals = this.resolvePossibleStringValuesFromExpression(prop.expression, returnEmptyStrings);
+                            if (keyVals.length > 0) {
+                                // Return only the map values for the known keys (subset access)
+                                return keyVals.map(k => base[k]).filter((v) => v !== undefined);
+                            }
+                            // Cannot narrow the key at all — return all map values as a conservative fallback
+                            return Object.values(base);
+                        }
                     }
                 }
             }
             catch { }
         }
+        // pattern 3:
+        // `t(fn())` — resolve to the function's known return-type union when captured.
+        if (expression.type === 'CallExpression') {
+            try {
+                const callee = expression.callee;
+                if (callee?.type === 'Identifier') {
+                    const v = this.variableTable.get(callee.value);
+                    if (Array.isArray(v) && v.length > 0)
+                        return v;
+                }
+            }
+            catch { }
+        }
         // Binary concatenation support (e.g., a + '_' + b)
         // SWC binary expr can be represented as `BinExpr` with left/right; be permissive:
         if (expression.left && expression.right) {
@@ -277,6 +412,11 @@ class ExpressionResolver {
             const annotation = expression.typeAnnotation;
             return this.resolvePossibleStringValuesFromType(annotation, returnEmptyStrings);
         }
+        // `expr as const` — delegate to the underlying expression (the type annotation is
+        // just `const`, which carries no union information, so we want the value side).
+        if (expression.type === 'TsConstAssertion') {
+            return this.resolvePossibleStringValuesFromExpression(expression.expression, returnEmptyStrings);
+        }
         // Identifier resolution via captured per-file variable table only
         if (expression.type === 'Identifier') {
             const v = this.variableTable.get(expression.value);
@@ -306,6 +446,19 @@ class ExpressionResolver {
                 return [`${type.literal.value}`]; // Handle literals like 5 or true
             }
         }
+        // pattern 2:
+        // Resolve a named type alias reference: `declare const x: ChangeType`
+        // where `type ChangeType = 'all' | 'next' | 'this'` was captured earlier.
+        if (type.type === 'TsTypeReference') {
+            const typeName = type.typeName?.type === 'Identifier'
+                ? type.typeName.value
+                : undefined;
+            if (typeName) {
+                const aliasVals = this.typeAliasTable.get(typeName);
+                if (aliasVals && aliasVals.length > 0)
+                    return aliasVals;
+            }
+        }
         // We can't statically determine the value of other expressions (e.g., variables, function calls)
         return [];
     }

package/package.json

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

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,aAAa,CAAA;AAC1G,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAInE;;;;;;;;;;;;;;;;;;;;;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;IAgCzC;;;;;OAKG;IACI,KAAK,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAUjC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,IAAI;IAoPZ;;;;;;;;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,aAAa,CAAA;AAC1G,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAInE;;;;;;;;;;;;;;;;;;;;;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;;;;;OAKG;IACI,KAAK,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAUjC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,IAAI;IAgRZ;;;;;;;;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/parsers/call-expression-handler.d.ts

@@ -9,7 +9,8 @@ export declare class CallExpressionHandler {
     objectKeys: Set<string>;
     private getCurrentFile;
     private getCurrentCode;
-    constructor(config: Omit<I18nextToolkitConfig, 'plugins'>, pluginContext: PluginContext, logger: Logger, expressionResolver: ExpressionResolver, getCurrentFile: () => string, getCurrentCode: () => string);
+    private resolveIdentifier;
+    constructor(config: Omit<I18nextToolkitConfig, 'plugins'>, pluginContext: PluginContext, logger: Logger, expressionResolver: ExpressionResolver, getCurrentFile: () => string, getCurrentCode: () => string, resolveIdentifier?: (name: string) => string | undefined);
     /**
      * Computes line and column from a node's normalised span.
      * For call / new expressions the location points to the first argument

package/types/extractor/parsers/call-expression-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"call-expression-handler.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/call-expression-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAA6C,MAAM,WAAW,CAAA;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,EAAgB,SAAS,EAAE,MAAM,aAAa,CAAA;AACvG,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAM1D,qBAAa,qBAAqB;IAChC,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,kBAAkB,CAAoB;IACvC,UAAU,cAAoB;IACrC,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,cAAc,CAAc;gBAGlC,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EACd,kBAAkB,EAAE,kBAAkB,EACtC,cAAc,EAAE,MAAM,MAAM,EAC5B,cAAc,EAAE,MAAM,MAAM;IAU9B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAAE,IAAI,EAAE,cAAc,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,GAAG,SAAS,GAAG,IAAI;IAgYxG;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA4BzB,OAAO,CAAC,oBAAoB;IA6E5B,OAAO,CAAC,wBAAwB;IAyEhC;;;;;;OAMG;IACH,OAAO,CAAC,4BAA4B;IA8BpC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,sBAAsB;IA2C9B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,gBAAgB;IAyMxB;;;;;;;;;OASG;IACH,OAAO,CAAC,eAAe;CA2BxB"}
+{"version":3,"file":"call-expression-handler.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/call-expression-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAA6C,MAAM,WAAW,CAAA;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,EAAgB,SAAS,EAAE,MAAM,aAAa,CAAA;AACvG,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAM1D,qBAAa,qBAAqB;IAChC,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,kBAAkB,CAAoB;IACvC,UAAU,cAAoB;IACrC,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,iBAAiB,CAAsC;gBAG7D,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EACd,kBAAkB,EAAE,kBAAkB,EACtC,cAAc,EAAE,MAAM,MAAM,EAC5B,cAAc,EAAE,MAAM,MAAM,EAC5B,iBAAiB,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAA2B;IAW3E;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAAE,IAAI,EAAE,cAAc,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,GAAG,SAAS,GAAG,IAAI;IAgYxG;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA4BzB,OAAO,CAAC,oBAAoB;IA6E5B,OAAO,CAAC,wBAAwB;IAyEhC;;;;;;OAMG;IACH,OAAO,CAAC,4BAA4B;IA8BpC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,sBAAsB;IA2C9B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,gBAAgB;IAyMxB;;;;;;;;;OASG;IACH,OAAO,CAAC,eAAe;CA2BxB"}

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

@@ -4,6 +4,7 @@ export declare class ExpressionResolver {
     private hooks;
     private variableTable;
     private sharedEnumTable;
+    private typeAliasTable;
     constructor(hooks: ASTVisitorHooks);
     /**
      * Clear per-file captured variables. Enums / shared maps are kept.
@@ -20,6 +21,31 @@ export declare class ExpressionResolver {
      * @param node - VariableDeclarator-like node (has .id and .init)
      */
     captureVariableDeclarator(node: any): void;
+    /**
+     * Capture a TypeScript type alias so that `declare const x: AliasName` can
+     * be resolved to its string union members later.
+     *
+     * Handles: `type Foo = 'a' | 'b' | 'c'`
+     *
+     * SWC node shapes: `TsTypeAliasDeclaration` / `TsTypeAliasDecl`
+     */
+    captureTypeAliasDeclaration(node: any): void;
+    /**
+     * Capture the return-type annotation of a function declaration so that
+     * `t(fn())` calls can be expanded to all union members.
+     *
+     * Handles both `function f(): 'a' | 'b' { ... }` and
+     * `const f = (): 'a' | 'b' => ...` (the arrow-function form is captured
+     * via captureVariableDeclarator when the init is an ArrowFunctionExpression).
+     *
+     * SWC node shapes: `FunctionDeclaration` / `FnDecl`
+     */
+    captureFunctionDeclaration(node: any): void;
+    /**
+     * Extract a raw TsType node from an identifier's type annotation.
+     * SWC may wrap it in a `TsTypeAnnotation` node — this unwraps it.
+     */
+    private extractTypeAnnotation;
     /**
      * Capture a TypeScript enum declaration so members can be resolved later.
      * Accepts SWC node shapes like `TsEnumDeclaration` / `TSEnumDeclaration`.

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,aAAa,CAAA;AAElD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,KAAK,CAAiB;IAK9B,OAAO,CAAC,aAAa,CAA4D;IAGjF,OAAO,CAAC,eAAe,CAAiD;gBAE3D,KAAK,EAAE,eAAe;IAInC;;OAEG;IACI,gBAAgB,IAAK,IAAI;IAIhC;;;;;;;;;OASG;IACH,yBAAyB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAwC3C;;;;;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;IAyJjD,OAAO,CAAC,mCAAmC;IAwB3C;;;;;;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,aAAa,CAAA;AAElD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,KAAK,CAAiB;IAK9B,OAAO,CAAC,aAAa,CAA4D;IAGjF,OAAO,CAAC,eAAe,CAAiD;IAIxE,OAAO,CAAC,cAAc,CAAmC;gBAE5C,KAAK,EAAE,eAAe;IAInC;;OAEG;IACI,gBAAgB,IAAK,IAAI;IAKhC;;;;;;;;;OASG;IACH,yBAAyB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAiF3C;;;;;;;OAOG;IACH,2BAA2B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAgB7C;;;;;;;;;OASG;IACH,0BAA0B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAoB5C;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;;;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;IAwLjD,OAAO,CAAC,mCAAmC;IAsC3C;;;;;;OAMG;IACH,OAAO,CAAC,6CAA6C;IAyBrD;;;;;;OAMG;IACH,OAAO,CAAC,kDAAkD;CAwB3D"}