i18next-cli 1.48.1 → 1.49.1

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;
@@ -288,6 +299,18 @@ class ASTVisitors {
         }
         this.hooks.onAfterVisitNode?.(node);
         // --- END VISIT LOGIC ---
+        // Detect array iteration calls (.map / .forEach / .flatMap etc.) on a known
+        // as-const array so the callback parameter is bound to the array values while
+        // the callback body is walked.  We inject the binding BEFORE generic recursion
+        // and remove it AFTER, so the whole subtree sees the correct value.
+        let arrayCallbackCleanup;
+        if (node.type === 'CallExpression') {
+            const info = this.tryGetArrayIterationCallbackInfo(node);
+            if (info) {
+                this.expressionResolver.setTemporaryVariable(info.paramName, info.values);
+                arrayCallbackCleanup = () => this.expressionResolver.deleteTemporaryVariable(info.paramName);
+            }
+        }
         // --- RECURSION ---
         // Recurse into the children of the current node
         for (const key in node) {
@@ -295,32 +318,112 @@ class ASTVisitors {
                 continue;
             const child = node[key];
             if (Array.isArray(child)) {
-                // Pre-scan array children to register VariableDeclarator-based scopes
-                // (e.g., `const { t } = useTranslation(...)`) before walking the rest
-                // of the items. This ensures that functions/arrow-functions defined
-                // earlier in the same block that reference t will resolve to the
-                // correct scope even if the `useTranslation` declarator appears later.
+                // Pre-scan array children in THREE passes:
+                //   Pass 1 — variables WITH init (arrays, objects, strings, fns) + enums
+                //   Pass 2 — type aliases + functions (may depend on pass-1 arrays)
+                //   Pass 3 — `declare const x: Type` (no init; depends on pass-2 type aliases)
+                // This ordering ensures e.g.:
+                //   const OPTS = ['a','b'] as const          → pass 1
+                //   type T = (typeof OPTS)[number]            → pass 2 (resolves OPTS)
+                //   declare const v: T                        → pass 3 (resolves T)
+                // ── Pass 1: variables with init ──────────────────────────────────────
                 for (const item of child) {
                     if (!item || typeof item !== 'object')
                         continue;
-                    // Direct declarator present in arrays (rare)
-                    if (item.type === 'VariableDeclarator') {
+                    // Direct declarator (rare)
+                    if (item.type === 'VariableDeclarator' && item.init) {
                         this.scopeManager.handleVariableDeclarator(item);
                         this.expressionResolver.captureVariableDeclarator(item);
                         continue;
                     }
-                    // enum declarations can appear as ExportDeclaration.declaration earlier; be permissive
-                    if (item && item.id && Array.isArray(item.members)) {
+                    // enum declarations
+                    if (item.id && Array.isArray(item.members)) {
                         this.expressionResolver.captureEnumDeclaration(item);
-                        // continue to allow further traversal
                     }
-                    // Common case: VariableDeclaration which contains .declarations (VariableDeclarator[])
+                    // Bare VariableDeclaration — only declarators that have an init
+                    if (item.type === 'VariableDeclaration' && Array.isArray(item.declarations)) {
+                        for (const decl of item.declarations) {
+                            if (decl?.type === 'VariableDeclarator' && decl.init) {
+                                this.scopeManager.handleVariableDeclarator(decl);
+                                this.expressionResolver.captureVariableDeclarator(decl);
+                            }
+                        }
+                    }
+                    // ExportDeclaration wrapping VariableDeclaration — only inited declarators
+                    if ((item.type === 'ExportDeclaration' || item.type === 'ExportNamedDeclaration') && item.declaration) {
+                        const inner = item.declaration;
+                        if (inner.type === 'VariableDeclaration' && Array.isArray(inner.declarations)) {
+                            for (const vd of inner.declarations) {
+                                if (vd?.type === 'VariableDeclarator' && vd.init) {
+                                    this.scopeManager.handleVariableDeclarator(vd);
+                                    this.expressionResolver.captureVariableDeclarator(vd);
+                                }
+                            }
+                        }
+                    }
+                }
+                // ── Pass 2: type aliases + functions ─────────────────────────────────
+                for (const item of child) {
+                    if (!item || typeof item !== 'object')
+                        continue;
+                    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);
+                    }
+                    if ((item.type === 'ExportDeclaration' || item.type === 'ExportNamedDeclaration') && item.declaration) {
+                        const inner = item.declaration;
+                        if (inner.type === 'TsTypeAliasDeclaration' || inner.type === 'TSTypeAliasDeclaration' || inner.type === 'TsTypeAliasDecl') {
+                            this.expressionResolver.captureTypeAliasDeclaration(inner);
+                        }
+                        if (inner.type === 'FunctionDeclaration' || inner.type === 'FnDecl') {
+                            this.expressionResolver.captureFunctionDeclaration(inner);
+                        }
+                    }
+                }
+                // ── Pass 3: `declare const x: Type` — no init, depends on type aliases ─
+                // Also re-processes ArrayPattern destructuring (e.g. useState<T>) whose
+                // type argument resolution failed in Pass 1 because typeAliasTable was empty.
+                for (const item of child) {
+                    if (!item || typeof item !== 'object')
+                        continue;
+                    // Direct declarator with no init
+                    if (item.type === 'VariableDeclarator' && !item.init) {
+                        this.scopeManager.handleVariableDeclarator(item);
+                        this.expressionResolver.captureVariableDeclarator(item);
+                        continue;
+                    }
+                    // ArrayPattern destructuring with init — re-run now that type aliases are populated
+                    if (item.type === 'VariableDeclarator' && item.init && item.id?.type === 'ArrayPattern') {
+                        this.expressionResolver.captureVariableDeclarator(item);
+                        continue;
+                    }
+                    // VariableDeclaration — process no-init declarators and re-process ArrayPattern ones
                     if (item.type === 'VariableDeclaration' && Array.isArray(item.declarations)) {
                         for (const decl of item.declarations) {
-                            if (decl && typeof decl === 'object' && decl.type === 'VariableDeclarator') {
+                            if (!decl.init) {
                                 this.scopeManager.handleVariableDeclarator(decl);
                                 this.expressionResolver.captureVariableDeclarator(decl);
                             }
+                            else if (decl.id?.type === 'ArrayPattern') {
+                                this.expressionResolver.captureVariableDeclarator(decl);
+                            }
+                        }
+                    }
+                    // ExportDeclaration wrapping — same logic
+                    if ((item.type === 'ExportDeclaration' || item.type === 'ExportNamedDeclaration') && item.declaration) {
+                        const inner = item.declaration;
+                        if (inner.type === 'VariableDeclaration' && Array.isArray(inner.declarations)) {
+                            for (const vd of inner.declarations) {
+                                if (!vd.init) {
+                                    this.scopeManager.handleVariableDeclarator(vd);
+                                    this.expressionResolver.captureVariableDeclarator(vd);
+                                }
+                                else if (vd.id?.type === 'ArrayPattern') {
+                                    this.expressionResolver.captureVariableDeclarator(vd);
+                                }
+                            }
                         }
                     }
                 }
@@ -340,11 +443,60 @@ class ASTVisitors {
             }
         }
         // --- END RECURSION ---
+        // Remove temporary callback param binding if one was injected for this node
+        arrayCallbackCleanup?.();
         // LEAVE SCOPE for functions
         if (isNewScope) {
             this.scopeManager.exitScope();
         }
     }
+    /**
+     * If `node` is a call like `ARRAY.map(param => ...)` where ARRAY is a known
+     * string-array constant, returns the callback's first parameter name and the
+     * array values so the caller can inject a temporary variable binding.
+     */
+    tryGetArrayIterationCallbackInfo(node) {
+        try {
+            const callee = node.callee;
+            if (callee?.type !== 'MemberExpression')
+                return undefined;
+            const prop = callee.property;
+            if (prop?.type !== 'Identifier')
+                return undefined;
+            if (!['map', 'forEach', 'flatMap', 'filter', 'find', 'some', 'every'].includes(prop.value))
+                return undefined;
+            // The object must be an identifier whose value is a known string array
+            const obj = callee.object;
+            if (obj?.type !== 'Identifier')
+                return undefined;
+            const values = this.expressionResolver.getVariableValues(obj.value);
+            if (!values || values.length === 0)
+                return undefined;
+            // First argument must be a callback with at least one parameter
+            const callbackArg = node.arguments?.[0]?.expression;
+            if (!callbackArg)
+                return undefined;
+            // Normalise param across SWC shapes: ArrowFunctionExpression / FunctionExpression
+            const params = callbackArg.params ?? callbackArg.parameters ?? [];
+            const firstParam = params[0];
+            if (!firstParam)
+                return undefined;
+            // SWC wraps params in `Param { pat: Identifier }` or exposes them directly
+            const ident = firstParam.type === 'Identifier'
+                ? firstParam
+                : firstParam.type === 'Param' && firstParam.pat?.type === 'Identifier'
+                    ? firstParam.pat
+                    : firstParam.type === 'AssignmentPattern' && firstParam.left?.type === 'Identifier'
+                        ? firstParam.left
+                        : null;
+            if (!ident)
+                return undefined;
+            return { paramName: ident.value, values };
+        }
+        catch {
+            return undefined;
+        }
+    }
     /**
      * Retrieves variable information from the scope chain.
      * Searches from innermost to outermost scope.

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,18 @@ 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();
+    // Shared (cross-file) table for string-array constants (e.g. `as const` arrays).
+    // Persists across resetFileSymbols() so exported arrays are visible to importers.
+    sharedVariableTable = new Map();
+    // Shared (cross-file) table for type aliases — populated alongside typeAliasTable.
+    // Persists across resetFileSymbols() so exported type aliases are visible to importers.
+    sharedTypeAliasTable = new Map();
+    // Temporary per-scope variable overrides, used to inject .map() / .forEach()
+    // callback parameters while the callback body is being walked.
+    temporaryVariables = new Map();
     constructor(hooks) {
         this.hooks = hooks;
     }
@@ -15,6 +27,8 @@ class ExpressionResolver {
      */
     resetFileSymbols() {
         this.variableTable.clear();
+        this.typeAliasTable.clear();
+        this.temporaryVariables.clear();
     }
     /**
      * Capture a VariableDeclarator node to record simple statically analyzable
@@ -28,17 +42,74 @@ class ExpressionResolver {
      */
     captureVariableDeclarator(node) {
         try {
-            if (!node || !node.id || !node.init)
+            if (!node || !node.id)
                 return;
+            // ── ArrayPattern id: `const [x, y] = fn<T>(...)` ────────────────────────
+            // Handles `const [state] = useState<'a'|'b'>('a')` or similar generic calls
+            // where the type argument is a finite string-literal union.
+            if (node.id.type === 'ArrayPattern' && node.init) {
+                const init = node.init;
+                // Unwrap await / as-expressions
+                let callExpr = init;
+                while (callExpr?.type === 'AwaitExpression')
+                    callExpr = callExpr.argument;
+                while (callExpr?.type === 'TsConstAssertion' ||
+                    callExpr?.type === 'TsAsExpression' ||
+                    callExpr?.type === 'TsSatisfiesExpression')
+                    callExpr = callExpr.expression;
+                if (callExpr?.type === 'CallExpression') {
+                    const typeArgs = callExpr.typeArguments?.params ??
+                        callExpr.typeParameters?.params ??
+                        [];
+                    if (typeArgs.length > 0) {
+                        const vals = this.resolvePossibleStringValuesFromType(typeArgs[0]);
+                        if (vals.length > 0) {
+                            // Bind each array-pattern element: first element is the state variable
+                            for (const el of node.id.elements) {
+                                if (!el)
+                                    continue;
+                                const ident = el.type === 'Identifier' ? el : (el.type === 'AssignmentPattern' && el.left?.type === 'Identifier' ? el.left : null);
+                                if (ident) {
+                                    this.variableTable.set(ident.value, vals);
+                                }
+                                break; // only bind the first element (the state value, not the setter)
+                            }
+                        }
+                    }
+                }
+                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;
@@ -58,16 +129,147 @@ class ExpressionResolver {
                     return;
                 }
             }
+            // ArrayExpression -> list of string values
+            // Handles `const OPTS = ['a', 'b', 'c'] as const`
+            if (unwrappedInit.type === 'ArrayExpression' && Array.isArray(unwrappedInit.elements)) {
+                const vals = [];
+                for (const elem of unwrappedInit.elements) {
+                    if (!elem || !elem.expression)
+                        continue;
+                    const resolved = this.resolvePossibleStringValuesFromExpression(elem.expression);
+                    if (resolved.length === 1)
+                        vals.push(resolved[0]);
+                }
+                if (vals.length > 0) {
+                    this.variableTable.set(name, vals);
+                    // Also share so importing files can see this array
+                    this.sharedVariableTable.set(name, vals);
+                    return;
+                }
+            }
             // For other initializers, try to resolve to one-or-more strings
             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);
+                // Also share so importing files can resolve this alias by name
+                this.sharedTypeAliasTable.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;
+    }
+    /**
+     * Temporarily bind a variable name to a set of string values.
+     * Used by ast-visitors to inject .map()/.forEach() callback parameters.
+     * Call deleteTemporaryVariable() after walking the callback body.
+     */
+    setTemporaryVariable(name, values) {
+        this.temporaryVariables.set(name, values);
+    }
+    /**
+     * Remove a previously-injected temporary variable binding.
+     */
+    deleteTemporaryVariable(name) {
+        this.temporaryVariables.delete(name);
+    }
+    /**
+     * Return the array values stored for a variable name, checking all tables.
+     * Returns undefined if the name is not a known string array.
+     */
+    getVariableValues(name) {
+        const tmp = this.temporaryVariables.get(name);
+        if (tmp)
+            return tmp;
+        const v = this.variableTable.get(name);
+        if (Array.isArray(v))
+            return v;
+        return this.sharedVariableTable.get(name);
+    }
     /**
      * Capture a TypeScript enum declaration so members can be resolved later.
      * Accepts SWC node shapes like `TsEnumDeclaration` / `TSEnumDeclaration`.
@@ -218,11 +420,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,11 +504,25 @@ 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') {
+            // Check temporary (callback param) overrides first
+            const tmp = this.temporaryVariables.get(expression.value);
+            if (tmp)
+                return tmp;
             const v = this.variableTable.get(expression.value);
-            if (!v)
+            if (!v) {
+                // Fall back to shared cross-file array table
+                const sv = this.sharedVariableTable.get(expression.value);
+                if (sv)
+                    return sv;
                 return [];
+            }
             if (Array.isArray(v))
                 return v;
             // object map - cannot be used directly as key, so return empty
@@ -291,6 +532,11 @@ class ExpressionResolver {
         return [];
     }
     resolvePossibleStringValuesFromType(type, returnEmptyStrings = false) {
+        // Unwrap TsParenthesizedType — SWC explicitly emits these for grouped types like
+        // `(typeof X)[number]` where `(typeof X)` becomes TsParenthesizedType { typeAnnotation: TsTypeQuery }
+        if (type.type === 'TsParenthesizedType') {
+            return this.resolvePossibleStringValuesFromType(type.typeAnnotation, returnEmptyStrings);
+        }
         if (type.type === 'TsUnionType') {
             return type.types.flatMap((t) => this.resolvePossibleStringValuesFromType(t, returnEmptyStrings));
         }
@@ -306,6 +552,46 @@ 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) ?? this.sharedTypeAliasTable.get(typeName);
+                if (aliasVals && aliasVals.length > 0)
+                    return aliasVals;
+            }
+        }
+        // `(typeof ACCESS_OPTIONS)[number]` — resolve through the shared array variable table.
+        // SWC emits: TsIndexedAccessType {
+        //   objectType: TsParenthesizedType { typeAnnotation: TsTypeQuery { exprName: Identifier } }
+        //   indexType: TsKeywordType
+        // }
+        // The parens around `typeof X` produce a TsParenthesizedType wrapper that we must unwrap.
+        if (type.type === 'TsIndexedAccessType') {
+            try {
+                let objType = type.objectType;
+                // Unwrap TsParenthesizedType wrapper (SWC preserves explicit parens in type positions)
+                while (objType?.type === 'TsParenthesizedType') {
+                    objType = objType.typeAnnotation;
+                }
+                if (objType?.type === 'TsTypeQuery' || objType?.type === 'TSTypeQuery') {
+                    // SWC: TsTypeQuery.exprName is TsEntityName (Identifier | TsQualifiedName)
+                    const exprName = objType.exprName ?? objType.expr ?? objType.entityName;
+                    // access .value (Identifier) or fall back to .name for alternate SWC builds
+                    const varName = exprName?.value ?? exprName?.name;
+                    if (varName) {
+                        const vals = this.getVariableValues(varName);
+                        if (vals && vals.length > 0)
+                            return vals;
+                    }
+                }
+            }
+            catch { }
+        }
         // 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.1",
   "description": "A unified, high-performance i18next CLI.",
   "type": "module",
   "bin": {

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

@@ -65,6 +65,12 @@ export declare class ASTVisitors {
      * @private
      */
     private walk;
+    /**
+     * If `node` is a call like `ARRAY.map(param => ...)` where ARRAY is a known
+     * string-array constant, returns the callback's first parameter name and the
+     * array values so the caller can inject a temporary variable binding.
+     */
+    private tryGetArrayIterationCallbackInfo;
     /**
      * Retrieves variable information from the scope chain.
      * Searches from innermost to outermost scope.