i18next-cli 1.49.3 → 1.49.5

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.49.3'); // This string is replaced with the actual version at build time by rollup
+    .version('1.49.5'); // 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

@@ -64,6 +64,65 @@ class ASTVisitors {
         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());
     }
+    /**
+     * Lightweight pre-scan pass: populates the shared constant / type-alias / array tables
+     * (`sharedConstants` in ScopeManager; `sharedVariableTable` and `sharedTypeAliasTable`
+     * in ExpressionResolver) WITHOUT performing any key extraction.
+     *
+     * Callers should invoke this for ALL source files before calling `visit()` for any file,
+     * so that cross-file identifier references — e.g. `useTranslation(NS_CALENDAR)` where
+     * `NS_CALENDAR` is exported from a separate constants file — are already resolved when
+     * the hook call is encountered during the extraction pass.
+     *
+     * The per-file tables (variableTable, typeAliasTable) are reset on each call so that
+     * local bindings from one file do not bleed into another; the shared tables accumulate
+     * across all calls and are intentionally NOT cleared here.
+     */
+    preScanForConstants(node) {
+        this.expressionResolver.resetFileSymbols();
+        this._walkForConstants(node);
+    }
+    /**
+     * Recursive walker used exclusively by `preScanForConstants`.
+     * Dispatches only to constant-capturing handlers; never extracts translation keys.
+     */
+    _walkForConstants(node) {
+        if (!node || typeof node !== 'object')
+            return;
+        switch (node.type) {
+            case 'VariableDeclarator':
+                // String constants  → ScopeManager.sharedConstants
+                // as-const arrays/objects → ExpressionResolver.sharedVariableTable
+                this.scopeManager.handleVariableDeclarator(node);
+                this.expressionResolver.captureVariableDeclarator(node);
+                break;
+            case 'TsTypeAliasDeclaration':
+            case 'TSTypeAliasDeclaration':
+            case 'TsTypeAliasDecl':
+                // Type aliases → ExpressionResolver.sharedTypeAliasTable
+                this.expressionResolver.captureTypeAliasDeclaration(node);
+                break;
+            case 'FunctionDeclaration':
+            case 'FnDecl':
+                // Return-type annotations for t(fn()) patterns
+                this.expressionResolver.captureFunctionDeclaration(node);
+                break;
+        }
+        for (const key in node) {
+            if (key === 'span')
+                continue;
+            const child = node[key];
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    if (item && typeof item === 'object')
+                        this._walkForConstants(item);
+                }
+            }
+            else if (child && typeof child === 'object') {
+                this._walkForConstants(child);
+            }
+        }
+    }
     /**
      * Main entry point for AST traversal.
      * Creates a root scope and begins the recursive walk through the syntax tree.
@@ -456,6 +515,10 @@ class ASTVisitors {
      * 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.
+     *
+     * Also handles:
+     *   `Object.keys(MAP).map/forEach(k => ...)`  → param bound to MAP's keys
+     *   `Object.values(MAP).map/forEach(v => ...)` → param bound to MAP's values
      */
     tryGetArrayIterationCallbackInfo(node) {
         try {
@@ -469,36 +532,67 @@ class ASTVisitors {
                 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 };
+            // ── Case 1: KNOWN_ARRAY.map(x => ...) ─────────────────────────────────
+            if (obj?.type === 'Identifier') {
+                const values = this.expressionResolver.getVariableValues(obj.value);
+                if (values && values.length > 0) {
+                    return this.extractCallbackParam(node, values);
+                }
+            }
+            // ── Case 2: Object.keys(MAP).map(k => ...) ────────────────────────────
+            //            Object.values(MAP).map(v => ...)
+            // callee.object is a CallExpression: Object.keys(...) / Object.values(...)
+            if (obj?.type === 'CallExpression') {
+                const innerCallee = obj.callee;
+                // Must be `Object.keys` or `Object.values`
+                if (innerCallee?.type === 'MemberExpression' &&
+                    innerCallee.object?.type === 'Identifier' &&
+                    innerCallee.object.value === 'Object' &&
+                    innerCallee.property?.type === 'Identifier' &&
+                    (innerCallee.property.value === 'keys' || innerCallee.property.value === 'values')) {
+                    const isKeys = innerCallee.property.value === 'keys';
+                    // The single argument to Object.keys/values must be a known identifier
+                    const mapArg = obj.arguments?.[0]?.expression;
+                    if (mapArg?.type === 'Identifier') {
+                        const mapEntry = this.expressionResolver.getObjectMap(mapArg.value);
+                        if (mapEntry) {
+                            const values = isKeys ? Object.keys(mapEntry) : Object.values(mapEntry);
+                            if (values.length > 0) {
+                                return this.extractCallbackParam(node, values);
+                            }
+                        }
+                    }
+                }
+            }
+            return undefined;
         }
         catch {
             return undefined;
         }
     }
+    /**
+     * Extracts the first callback parameter identifier from an iteration call node
+     * and pairs it with the provided values array.
+     */
+    extractCallbackParam(node, values) {
+        const callbackArg = node.arguments?.[0]?.expression;
+        if (!callbackArg)
+            return undefined;
+        const params = callbackArg.params ?? callbackArg.parameters ?? [];
+        const firstParam = params[0];
+        if (!firstParam)
+            return undefined;
+        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 };
+    }
     /**
      * Retrieves variable information from the scope chain.
      * Searches from innermost to outermost scope.

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

@@ -236,7 +236,80 @@ async function processFile(file, plugins, astVisitors, pluginContext, config, lo
     }
 }
 /**
- * Simplified extraction function that returns translation results without file writing.
+ * Lightweight pre-scan pass for a single file.
+ *
+ * Parses the file and calls `astVisitors.preScanForConstants()` to populate
+ * cross-file shared constant / type-alias / array tables WITHOUT extracting
+ * any translation keys or running plugin hooks.
+ *
+ * Intended to be called for ALL files in a first pass before `processFile` is
+ * called for any file, ensuring that exported identifier references such as
+ * `NS_CALENDAR` from `@core/translations/ns` are resolved in all files
+ * regardless of processing order.
+ *
+ * @param file   - Absolute or CWD-relative path of the source file to pre-scan
+ * @param astVisitors - Shared visitor instance (holds the shared constant tables)
+ * @param config - Extractor configuration (without plugins)
+ * @param logger - Logger for warnings/errors
+ * @param fileErrors - Optional array to collect per-file error messages
+ */
+async function preScanFile(file, astVisitors, config, logger$1 = new logger.ConsoleLogger(), fileErrors) {
+    try {
+        const code = await promises.readFile(file, 'utf-8');
+        const fileExt = node_path.extname(file).toLowerCase();
+        const isTypeScriptFile = fileExt === '.ts' || fileExt === '.tsx' || fileExt === '.mts' || fileExt === '.cts';
+        const isTSX = fileExt === '.tsx';
+        const isJSX = fileExt === '.jsx';
+        let ast;
+        try {
+            ast = await core.parse(code, {
+                syntax: isTypeScriptFile ? 'typescript' : 'ecmascript',
+                tsx: isTSX,
+                jsx: isJSX,
+                decorators: true,
+                dynamicImport: true,
+                comments: true,
+            });
+        }
+        catch (err) {
+            if (fileExt === '.ts' && !isTSX) {
+                try {
+                    ast = await core.parse(code, { syntax: 'typescript', tsx: true, decorators: true, dynamicImport: true, comments: true });
+                }
+                catch (err2) {
+                    throw new validation.ExtractorError('Failed to pre-scan file', file, err2);
+                }
+            }
+            else if (fileExt === '.js' && !isJSX) {
+                try {
+                    ast = await core.parse(code, { syntax: 'ecmascript', jsx: true, decorators: true, dynamicImport: true, comments: true });
+                }
+                catch (err2) {
+                    throw new validation.ExtractorError('Failed to pre-scan file', file, err2);
+                }
+            }
+            else {
+                throw new validation.ExtractorError('Failed to pre-scan file', file, err);
+            }
+        }
+        const firstTokenIdx = astUtils.findFirstTokenIndex(code);
+        astUtils.normalizeASTSpans(ast, ast.span.start - firstTokenIdx);
+        astVisitors.setCurrentFile(file, code);
+        astVisitors.preScanForConstants(ast);
+    }
+    catch (error) {
+        if (error instanceof pluginManager.ConflictError)
+            throw error;
+        logger$1.warn(`${node_util.styleText('yellow', 'Skipping file in constants pre-scan due to error:')} ${file}`);
+        const err = error;
+        const msg = typeof err?.message === 'string' && err.message.trim().length > 0
+            ? err.message
+            : (typeof err === 'string' ? err : '') || err?.toString?.() || 'Unknown error';
+        if (fileErrors)
+            fileErrors.push(`${file}: ${msg}`);
+    }
+}
+/**
  * Used primarily for testing and programmatic access.
  *
  * @param config - The i18next toolkit configuration object
@@ -287,5 +360,6 @@ async function printLocizeFunnel(logger$1, force) {
 }
 
 exports.extract = extract;
+exports.preScanFile = preScanFile;
 exports.processFile = processFile;
 exports.runExtractor = runExtractor;

package/dist/cjs/extractor/core/key-finder.js

@@ -86,7 +86,16 @@ async function findKeys(config, logger$1 = new logger.ConsoleLogger(), fileError
     pluginContext.getVarFromScope = astVisitors$1.getVarFromScope.bind(astVisitors$1);
     // 5. Initialize plugins
     await pluginManager.initializePlugins(plugins);
-    // 6. Process each file
+    // 6. Pre-scan all files to populate cross-file shared constant tables BEFORE any
+    //    key extraction begins. This ensures that identifier-based namespace references
+    //    such as `useTranslation(NS_CALENDAR)` or `t('key', { ns: NS_SETTINGS })` resolve
+    //    correctly even when the defining constants file is processed after the file that
+    //    uses the identifier.
+    for (const file of sourceFiles) {
+        await extractor.preScanFile(file, astVisitors$1, otherConfig, logger$1, fileErrors);
+    }
+    // 7. Extraction pass: all shared tables are now fully populated, so every
+    //    identifier reference can be resolved regardless of file order.
     for (const file of sourceFiles) {
         await extractor.processFile(file, plugins, astVisitors$1, pluginContext, otherConfig, logger$1, fileErrors);
     }

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

@@ -272,6 +272,20 @@ class ExpressionResolver {
             return v;
         return this.sharedVariableTable.get(name);
     }
+    /**
+     * Return the as-const object map stored for a variable name.
+     * Returns undefined if the name is not a known object map.
+     * Checks per-file variableTable first, then sharedEnumTable (for enums).
+     */
+    getObjectMap(name) {
+        const v = this.variableTable.get(name);
+        if (v && !Array.isArray(v) && typeof v === 'object')
+            return v;
+        const ev = this.sharedEnumTable.get(name);
+        if (ev)
+            return ev;
+        return undefined;
+    }
     /**
      * Capture a TypeScript enum declaration so members can be resolved later.
      * Accepts SWC node shapes like `TsEnumDeclaration` / `TSEnumDeclaration`.
@@ -557,14 +571,25 @@ class ExpressionResolver {
         // pattern 2:
         // Resolve a named type alias reference: `declare const x: ChangeType`
         // where `type ChangeType = 'all' | 'next' | 'this'` was captured earlier.
+        // Also handles `declare const d: SomeEnum` where SomeEnum is a TS enum with string values.
         if (type.type === 'TsTypeReference') {
             const typeName = type.typeName?.type === 'Identifier'
                 ? type.typeName.value
                 : undefined;
             if (typeName) {
+                // 1. Check type alias table first (exact match for string-literal unions)
                 const aliasVals = this.typeAliasTable.get(typeName) ?? this.sharedTypeAliasTable.get(typeName);
                 if (aliasVals && aliasVals.length > 0)
                     return aliasVals;
+                // 2. Fall back to enum: `declare const d: Direction` where Direction is a string enum.
+                //    sharedEnumTable maps enum-name → { MemberName: value }.
+                //    A variable typed as the enum can take any of the enum's string values.
+                const enumMap = this.sharedEnumTable.get(typeName);
+                if (enumMap) {
+                    const enumVals = Object.values(enumMap);
+                    if (enumVals.length > 0)
+                        return enumVals;
+                }
             }
         }
         // `(typeof ACCESS_OPTIONS)[number]` — resolve through the shared array variable table.
@@ -594,6 +619,40 @@ class ExpressionResolver {
             }
             catch { }
         }
+        // `keyof typeof MAP` — resolve to the keys of a known as-const object map.
+        // SWC emits: TsTypeOperator {
+        //   operator: 'keyof',
+        //   typeAnnotation: TsTypeQuery { exprName: Identifier }
+        // }
+        // This is the type of a variable that iterates over map keys:
+        //   declare const k: keyof typeof LABELS; t(LABELS[k])
+        //   Object.keys(MAP).forEach(k => t(MAP[k]))
+        if (type.type === 'TsTypeOperator') {
+            try {
+                const op = type.operator;
+                if (op === 'keyof') {
+                    let inner = type.typeAnnotation;
+                    while (inner?.type === 'TsParenthesizedType')
+                        inner = inner.typeAnnotation;
+                    if (inner?.type === 'TsTypeQuery' || inner?.type === 'TSTypeQuery') {
+                        const exprName = inner.exprName ?? inner.expr ?? inner.entityName;
+                        const varName = exprName?.value ?? exprName?.name;
+                        if (varName) {
+                            // Look up in variableTable (local) or sharedVariableTable (cross-file) for object maps
+                            const v = this.variableTable.get(varName) ?? this.sharedVariableTable.get(varName);
+                            if (v && !Array.isArray(v) && typeof v === 'object') {
+                                return Object.keys(v);
+                            }
+                            // Also check sharedEnumTable (enum keys)
+                            const ev = this.sharedEnumTable.get(varName);
+                            if (ev)
+                                return Object.keys(ev);
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
         // We can't statically determine the value of other expressions (e.g., variables, function calls)
         return [];
     }

package/dist/cjs/types-generator.js

@@ -27,10 +27,10 @@ async function loadFile(file) {
                 type: 'commonjs'
             }
         });
-        const exports = {};
-        const module = { exports };
+        const exports$1 = {};
+        const module = { exports: exports$1 };
         const context = vm.createContext({
-            exports,
+            exports: exports$1,
             module,
             require: (id) => require(id),
             console,

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.49.3'); // This string is replaced with the actual version at build time by rollup
+    .version('1.49.5'); // 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

@@ -62,6 +62,65 @@ class ASTVisitors {
         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());
     }
+    /**
+     * Lightweight pre-scan pass: populates the shared constant / type-alias / array tables
+     * (`sharedConstants` in ScopeManager; `sharedVariableTable` and `sharedTypeAliasTable`
+     * in ExpressionResolver) WITHOUT performing any key extraction.
+     *
+     * Callers should invoke this for ALL source files before calling `visit()` for any file,
+     * so that cross-file identifier references — e.g. `useTranslation(NS_CALENDAR)` where
+     * `NS_CALENDAR` is exported from a separate constants file — are already resolved when
+     * the hook call is encountered during the extraction pass.
+     *
+     * The per-file tables (variableTable, typeAliasTable) are reset on each call so that
+     * local bindings from one file do not bleed into another; the shared tables accumulate
+     * across all calls and are intentionally NOT cleared here.
+     */
+    preScanForConstants(node) {
+        this.expressionResolver.resetFileSymbols();
+        this._walkForConstants(node);
+    }
+    /**
+     * Recursive walker used exclusively by `preScanForConstants`.
+     * Dispatches only to constant-capturing handlers; never extracts translation keys.
+     */
+    _walkForConstants(node) {
+        if (!node || typeof node !== 'object')
+            return;
+        switch (node.type) {
+            case 'VariableDeclarator':
+                // String constants  → ScopeManager.sharedConstants
+                // as-const arrays/objects → ExpressionResolver.sharedVariableTable
+                this.scopeManager.handleVariableDeclarator(node);
+                this.expressionResolver.captureVariableDeclarator(node);
+                break;
+            case 'TsTypeAliasDeclaration':
+            case 'TSTypeAliasDeclaration':
+            case 'TsTypeAliasDecl':
+                // Type aliases → ExpressionResolver.sharedTypeAliasTable
+                this.expressionResolver.captureTypeAliasDeclaration(node);
+                break;
+            case 'FunctionDeclaration':
+            case 'FnDecl':
+                // Return-type annotations for t(fn()) patterns
+                this.expressionResolver.captureFunctionDeclaration(node);
+                break;
+        }
+        for (const key in node) {
+            if (key === 'span')
+                continue;
+            const child = node[key];
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    if (item && typeof item === 'object')
+                        this._walkForConstants(item);
+                }
+            }
+            else if (child && typeof child === 'object') {
+                this._walkForConstants(child);
+            }
+        }
+    }
     /**
      * Main entry point for AST traversal.
      * Creates a root scope and begins the recursive walk through the syntax tree.
@@ -454,6 +513,10 @@ class ASTVisitors {
      * 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.
+     *
+     * Also handles:
+     *   `Object.keys(MAP).map/forEach(k => ...)`  → param bound to MAP's keys
+     *   `Object.values(MAP).map/forEach(v => ...)` → param bound to MAP's values
      */
     tryGetArrayIterationCallbackInfo(node) {
         try {
@@ -467,36 +530,67 @@ class ASTVisitors {
                 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 };
+            // ── Case 1: KNOWN_ARRAY.map(x => ...) ─────────────────────────────────
+            if (obj?.type === 'Identifier') {
+                const values = this.expressionResolver.getVariableValues(obj.value);
+                if (values && values.length > 0) {
+                    return this.extractCallbackParam(node, values);
+                }
+            }
+            // ── Case 2: Object.keys(MAP).map(k => ...) ────────────────────────────
+            //            Object.values(MAP).map(v => ...)
+            // callee.object is a CallExpression: Object.keys(...) / Object.values(...)
+            if (obj?.type === 'CallExpression') {
+                const innerCallee = obj.callee;
+                // Must be `Object.keys` or `Object.values`
+                if (innerCallee?.type === 'MemberExpression' &&
+                    innerCallee.object?.type === 'Identifier' &&
+                    innerCallee.object.value === 'Object' &&
+                    innerCallee.property?.type === 'Identifier' &&
+                    (innerCallee.property.value === 'keys' || innerCallee.property.value === 'values')) {
+                    const isKeys = innerCallee.property.value === 'keys';
+                    // The single argument to Object.keys/values must be a known identifier
+                    const mapArg = obj.arguments?.[0]?.expression;
+                    if (mapArg?.type === 'Identifier') {
+                        const mapEntry = this.expressionResolver.getObjectMap(mapArg.value);
+                        if (mapEntry) {
+                            const values = isKeys ? Object.keys(mapEntry) : Object.values(mapEntry);
+                            if (values.length > 0) {
+                                return this.extractCallbackParam(node, values);
+                            }
+                        }
+                    }
+                }
+            }
+            return undefined;
         }
         catch {
             return undefined;
         }
     }
+    /**
+     * Extracts the first callback parameter identifier from an iteration call node
+     * and pairs it with the provided values array.
+     */
+    extractCallbackParam(node, values) {
+        const callbackArg = node.arguments?.[0]?.expression;
+        if (!callbackArg)
+            return undefined;
+        const params = callbackArg.params ?? callbackArg.parameters ?? [];
+        const firstParam = params[0];
+        if (!firstParam)
+            return undefined;
+        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 };
+    }
     /**
      * Retrieves variable information from the scope chain.
      * Searches from innermost to outermost scope.

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

@@ -234,7 +234,80 @@ async function processFile(file, plugins, astVisitors, pluginContext, config, lo
     }
 }
 /**
- * Simplified extraction function that returns translation results without file writing.
+ * Lightweight pre-scan pass for a single file.
+ *
+ * Parses the file and calls `astVisitors.preScanForConstants()` to populate
+ * cross-file shared constant / type-alias / array tables WITHOUT extracting
+ * any translation keys or running plugin hooks.
+ *
+ * Intended to be called for ALL files in a first pass before `processFile` is
+ * called for any file, ensuring that exported identifier references such as
+ * `NS_CALENDAR` from `@core/translations/ns` are resolved in all files
+ * regardless of processing order.
+ *
+ * @param file   - Absolute or CWD-relative path of the source file to pre-scan
+ * @param astVisitors - Shared visitor instance (holds the shared constant tables)
+ * @param config - Extractor configuration (without plugins)
+ * @param logger - Logger for warnings/errors
+ * @param fileErrors - Optional array to collect per-file error messages
+ */
+async function preScanFile(file, astVisitors, config, logger = new ConsoleLogger(), fileErrors) {
+    try {
+        const code = await readFile(file, 'utf-8');
+        const fileExt = extname(file).toLowerCase();
+        const isTypeScriptFile = fileExt === '.ts' || fileExt === '.tsx' || fileExt === '.mts' || fileExt === '.cts';
+        const isTSX = fileExt === '.tsx';
+        const isJSX = fileExt === '.jsx';
+        let ast;
+        try {
+            ast = await parse(code, {
+                syntax: isTypeScriptFile ? 'typescript' : 'ecmascript',
+                tsx: isTSX,
+                jsx: isJSX,
+                decorators: true,
+                dynamicImport: true,
+                comments: true,
+            });
+        }
+        catch (err) {
+            if (fileExt === '.ts' && !isTSX) {
+                try {
+                    ast = await parse(code, { syntax: 'typescript', tsx: true, decorators: true, dynamicImport: true, comments: true });
+                }
+                catch (err2) {
+                    throw new ExtractorError('Failed to pre-scan file', file, err2);
+                }
+            }
+            else if (fileExt === '.js' && !isJSX) {
+                try {
+                    ast = await parse(code, { syntax: 'ecmascript', jsx: true, decorators: true, dynamicImport: true, comments: true });
+                }
+                catch (err2) {
+                    throw new ExtractorError('Failed to pre-scan file', file, err2);
+                }
+            }
+            else {
+                throw new ExtractorError('Failed to pre-scan file', file, err);
+            }
+        }
+        const firstTokenIdx = findFirstTokenIndex(code);
+        normalizeASTSpans(ast, ast.span.start - firstTokenIdx);
+        astVisitors.setCurrentFile(file, code);
+        astVisitors.preScanForConstants(ast);
+    }
+    catch (error) {
+        if (error instanceof ConflictError)
+            throw error;
+        logger.warn(`${styleText('yellow', 'Skipping file in constants pre-scan due to error:')} ${file}`);
+        const err = error;
+        const msg = typeof err?.message === 'string' && err.message.trim().length > 0
+            ? err.message
+            : (typeof err === 'string' ? err : '') || err?.toString?.() || 'Unknown error';
+        if (fileErrors)
+            fileErrors.push(`${file}: ${msg}`);
+    }
+}
+/**
  * Used primarily for testing and programmatic access.
  *
  * @param config - The i18next toolkit configuration object
@@ -284,4 +357,4 @@ async function printLocizeFunnel(logger, force) {
     return recordFunnelShown('extract');
 }
 
-export { extract, processFile, runExtractor };
+export { extract, preScanFile, processFile, runExtractor };

package/dist/esm/extractor/core/key-finder.js

@@ -1,5 +1,5 @@
 import { glob } from 'glob';
-import { processFile } from './extractor.js';
+import { preScanFile, processFile } from './extractor.js';
 import { ConsoleLogger } from '../../utils/logger.js';
 import { createPluginContext, initializePlugins } from '../plugin-manager.js';
 import { ASTVisitors } from './ast-visitors.js';
@@ -84,7 +84,16 @@ async function findKeys(config, logger = new ConsoleLogger(), fileErrors) {
     pluginContext.getVarFromScope = astVisitors.getVarFromScope.bind(astVisitors);
     // 5. Initialize plugins
     await initializePlugins(plugins);
-    // 6. Process each file
+    // 6. Pre-scan all files to populate cross-file shared constant tables BEFORE any
+    //    key extraction begins. This ensures that identifier-based namespace references
+    //    such as `useTranslation(NS_CALENDAR)` or `t('key', { ns: NS_SETTINGS })` resolve
+    //    correctly even when the defining constants file is processed after the file that
+    //    uses the identifier.
+    for (const file of sourceFiles) {
+        await preScanFile(file, astVisitors, otherConfig, logger, fileErrors);
+    }
+    // 7. Extraction pass: all shared tables are now fully populated, so every
+    //    identifier reference can be resolved regardless of file order.
     for (const file of sourceFiles) {
         await processFile(file, plugins, astVisitors, pluginContext, otherConfig, logger, fileErrors);
     }

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

@@ -270,6 +270,20 @@ class ExpressionResolver {
             return v;
         return this.sharedVariableTable.get(name);
     }
+    /**
+     * Return the as-const object map stored for a variable name.
+     * Returns undefined if the name is not a known object map.
+     * Checks per-file variableTable first, then sharedEnumTable (for enums).
+     */
+    getObjectMap(name) {
+        const v = this.variableTable.get(name);
+        if (v && !Array.isArray(v) && typeof v === 'object')
+            return v;
+        const ev = this.sharedEnumTable.get(name);
+        if (ev)
+            return ev;
+        return undefined;
+    }
     /**
      * Capture a TypeScript enum declaration so members can be resolved later.
      * Accepts SWC node shapes like `TsEnumDeclaration` / `TSEnumDeclaration`.
@@ -555,14 +569,25 @@ class ExpressionResolver {
         // pattern 2:
         // Resolve a named type alias reference: `declare const x: ChangeType`
         // where `type ChangeType = 'all' | 'next' | 'this'` was captured earlier.
+        // Also handles `declare const d: SomeEnum` where SomeEnum is a TS enum with string values.
         if (type.type === 'TsTypeReference') {
             const typeName = type.typeName?.type === 'Identifier'
                 ? type.typeName.value
                 : undefined;
             if (typeName) {
+                // 1. Check type alias table first (exact match for string-literal unions)
                 const aliasVals = this.typeAliasTable.get(typeName) ?? this.sharedTypeAliasTable.get(typeName);
                 if (aliasVals && aliasVals.length > 0)
                     return aliasVals;
+                // 2. Fall back to enum: `declare const d: Direction` where Direction is a string enum.
+                //    sharedEnumTable maps enum-name → { MemberName: value }.
+                //    A variable typed as the enum can take any of the enum's string values.
+                const enumMap = this.sharedEnumTable.get(typeName);
+                if (enumMap) {
+                    const enumVals = Object.values(enumMap);
+                    if (enumVals.length > 0)
+                        return enumVals;
+                }
             }
         }
         // `(typeof ACCESS_OPTIONS)[number]` — resolve through the shared array variable table.
@@ -592,6 +617,40 @@ class ExpressionResolver {
             }
             catch { }
         }
+        // `keyof typeof MAP` — resolve to the keys of a known as-const object map.
+        // SWC emits: TsTypeOperator {
+        //   operator: 'keyof',
+        //   typeAnnotation: TsTypeQuery { exprName: Identifier }
+        // }
+        // This is the type of a variable that iterates over map keys:
+        //   declare const k: keyof typeof LABELS; t(LABELS[k])
+        //   Object.keys(MAP).forEach(k => t(MAP[k]))
+        if (type.type === 'TsTypeOperator') {
+            try {
+                const op = type.operator;
+                if (op === 'keyof') {
+                    let inner = type.typeAnnotation;
+                    while (inner?.type === 'TsParenthesizedType')
+                        inner = inner.typeAnnotation;
+                    if (inner?.type === 'TsTypeQuery' || inner?.type === 'TSTypeQuery') {
+                        const exprName = inner.exprName ?? inner.expr ?? inner.entityName;
+                        const varName = exprName?.value ?? exprName?.name;
+                        if (varName) {
+                            // Look up in variableTable (local) or sharedVariableTable (cross-file) for object maps
+                            const v = this.variableTable.get(varName) ?? this.sharedVariableTable.get(varName);
+                            if (v && !Array.isArray(v) && typeof v === 'object') {
+                                return Object.keys(v);
+                            }
+                            // Also check sharedEnumTable (enum keys)
+                            const ev = this.sharedEnumTable.get(varName);
+                            if (ev)
+                                return Object.keys(ev);
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
         // We can't statically determine the value of other expressions (e.g., variables, function calls)
         return [];
     }

package/dist/esm/types-generator.js

@@ -25,10 +25,10 @@ async function loadFile(file) {
                 type: 'commonjs'
             }
         });
-        const exports = {};
-        const module = { exports };
+        const exports$1 = {};
+        const module = { exports: exports$1 };
         const context = vm.createContext({
-            exports,
+            exports: exports$1,
             module,
             require: (id) => require(id),
             console,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18next-cli",
-  "version": "1.49.3",
+  "version": "1.49.5",
   "description": "A unified, high-performance i18next CLI.",
   "type": "module",
   "bin": {
@@ -52,39 +52,39 @@
     "url": "https://github.com/i18next/i18next-cli/issues"
   },
   "devDependencies": {
-    "@rollup/plugin-replace": "6.0.3",
-    "@rollup/plugin-terser": "0.4.4",
-    "@types/inquirer": "9.0.9",
-    "@types/node": "25.3.3",
-    "@types/react": "19.2.14",
-    "@typescript-eslint/parser": "^8.56.1",
-    "@vitest/coverage-v8": "4.0.18",
-    "eslint": "9.39.2",
+    "@rollup/plugin-replace": "^6.0.3",
+    "@rollup/plugin-terser": "^1.0.0",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.4.0",
+    "@types/react": "^19.2.14",
+    "@typescript-eslint/parser": "^8.57.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^9.39.2",
     "eslint-import-resolver-typescript": "^4.4.4",
-    "eslint-plugin-import": "2.32.0",
-    "memfs": "4.56.11",
-    "neostandard": "0.13.0",
-    "rollup-plugin-typescript2": "0.36.0",
-    "typescript": "5.9.3",
-    "unplugin-swc": "1.5.9",
-    "vitest": "4.0.18"
+    "eslint-plugin-import": "^2.32.0",
+    "memfs": "^4.56.11",
+    "neostandard": "^0.13.0",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "typescript": "^5.9.3",
+    "unplugin-swc": "^1.5.9",
+    "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@croct/json5-parser": "0.2.2",
-    "@swc/core": "1.15.18",
-    "chokidar": "5.0.0",
-    "commander": "14.0.3",
-    "execa": "9.6.1",
-    "glob": "13.0.6",
-    "i18next-resources-for-ts": "2.0.0",
-    "inquirer": "13.3.0",
-    "jiti": "2.6.1",
-    "jsonc-parser": "3.3.1",
-    "magic-string": "0.30.21",
-    "minimatch": "10.2.4",
-    "ora": "9.3.0",
+    "@croct/json5-parser": "^0.2.2",
+    "@swc/core": "^1.15.18",
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.3",
+    "execa": "^9.6.1",
+    "glob": "^13.0.6",
+    "i18next-resources-for-ts": "^2.0.1",
+    "inquirer": "^13.3.0",
+    "jiti": "^2.6.1",
+    "jsonc-parser": "^3.3.1",
+    "magic-string": "^0.30.21",
+    "minimatch": "^10.2.4",
+    "ora": "^9.3.0",
     "react": "^19.2.4",
-    "react-i18next": "^16.5.5",
-    "yaml": "2.8.2"
+    "react-i18next": "^16.5.6",
+    "yaml": "^2.8.2"
   }
 }

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

@@ -44,6 +44,26 @@ export declare class ASTVisitors {
      * @param logger - Logger for warnings and debug information
      */
     constructor(config: Omit<I18nextToolkitConfig, 'plugins'>, pluginContext: PluginContext, logger: Logger, hooks?: ASTVisitorHooks, expressionResolver?: ExpressionResolver);
+    /**
+     * Lightweight pre-scan pass: populates the shared constant / type-alias / array tables
+     * (`sharedConstants` in ScopeManager; `sharedVariableTable` and `sharedTypeAliasTable`
+     * in ExpressionResolver) WITHOUT performing any key extraction.
+     *
+     * Callers should invoke this for ALL source files before calling `visit()` for any file,
+     * so that cross-file identifier references — e.g. `useTranslation(NS_CALENDAR)` where
+     * `NS_CALENDAR` is exported from a separate constants file — are already resolved when
+     * the hook call is encountered during the extraction pass.
+     *
+     * The per-file tables (variableTable, typeAliasTable) are reset on each call so that
+     * local bindings from one file do not bleed into another; the shared tables accumulate
+     * across all calls and are intentionally NOT cleared here.
+     */
+    preScanForConstants(node: Module): void;
+    /**
+     * Recursive walker used exclusively by `preScanForConstants`.
+     * Dispatches only to constant-capturing handlers; never extracts translation keys.
+     */
+    private _walkForConstants;
     /**
      * Main entry point for AST traversal.
      * Creates a root scope and begins the recursive walk through the syntax tree.
@@ -69,8 +89,17 @@ export declare class ASTVisitors {
      * 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.
+     *
+     * Also handles:
+     *   `Object.keys(MAP).map/forEach(k => ...)`  → param bound to MAP's keys
+     *   `Object.values(MAP).map/forEach(v => ...)` → param bound to MAP's values
      */
     private tryGetArrayIterationCallbackInfo;
+    /**
+     * Extracts the first callback parameter identifier from an iteration call node
+     * and pairs it with the provided values array.
+     */
+    private extractCallbackParam;
     /**
      * Retrieves variable information from the scope chain.
      * Searches from innermost to outermost scope.

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

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

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

@@ -59,7 +59,25 @@ export declare function runExtractor(config: I18nextToolkitConfig, options?: {
  */
 export declare function processFile(file: string, plugins: Plugin[], astVisitors: ASTVisitors, pluginContext: PluginContext, config: Omit<I18nextToolkitConfig, 'plugins'>, logger?: Logger, fileErrors?: string[]): Promise<void>;
 /**
- * Simplified extraction function that returns translation results without file writing.
+ * Lightweight pre-scan pass for a single file.
+ *
+ * Parses the file and calls `astVisitors.preScanForConstants()` to populate
+ * cross-file shared constant / type-alias / array tables WITHOUT extracting
+ * any translation keys or running plugin hooks.
+ *
+ * Intended to be called for ALL files in a first pass before `processFile` is
+ * called for any file, ensuring that exported identifier references such as
+ * `NS_CALENDAR` from `@core/translations/ns` are resolved in all files
+ * regardless of processing order.
+ *
+ * @param file   - Absolute or CWD-relative path of the source file to pre-scan
+ * @param astVisitors - Shared visitor instance (holds the shared constant tables)
+ * @param config - Extractor configuration (without plugins)
+ * @param logger - Logger for warnings/errors
+ * @param fileErrors - Optional array to collect per-file error messages
+ */
+export declare function preScanFile(file: string, astVisitors: ASTVisitors, config: Omit<I18nextToolkitConfig, 'plugins'>, logger?: Logger, fileErrors?: string[]): Promise<void>;
+/**
  * Used primarily for testing and programmatic access.
  *
  * @param config - The i18next toolkit configuration object

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

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

package/types/extractor/core/key-finder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"key-finder.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/key-finder.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,oBAAoB,EAAmB,MAAM,gBAAgB,CAAA;AAOjG;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,oBAAoB,EAC5B,MAAM,GAAE,MAA4B,EACpC,UAAU,CAAC,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC;IAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC,CA6E1E"}
+{"version":3,"file":"key-finder.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/key-finder.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,oBAAoB,EAAmB,MAAM,gBAAgB,CAAA;AAOjG;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,oBAAoB,EAC5B,MAAM,GAAE,MAA4B,EACpC,UAAU,CAAC,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC;IAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC,CAuF1E"}

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

@@ -64,6 +64,12 @@ export declare class ExpressionResolver {
      * Returns undefined if the name is not a known string array.
      */
     getVariableValues(name: string): string[] | undefined;
+    /**
+     * Return the as-const object map stored for a variable name.
+     * Returns undefined if the name is not a known object map.
+     * Checks per-file variableTable first, then sharedEnumTable (for enums).
+     */
+    getObjectMap(name: string): Record<string, string> | undefined;
     /**
      * 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,gBAAgB,CAAA;AAErD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,KAAK,CAAiB;IAK9B,OAAO,CAAC,aAAa,CAA4D;IAGjF,OAAO,CAAC,eAAe,CAAiD;IAIxE,OAAO,CAAC,cAAc,CAAmC;IAIzD,OAAO,CAAC,mBAAmB,CAAmC;IAI9D,OAAO,CAAC,oBAAoB,CAAmC;IAI/D,OAAO,CAAC,kBAAkB,CAAmC;gBAEhD,KAAK,EAAE,eAAe;IAInC;;OAEG;IACI,gBAAgB,IAAK,IAAI;IAMhC;;;;;;;;;OASG;IACH,yBAAyB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAwI3C;;;;;;;OAOG;IACH,2BAA2B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAkB7C;;;;;;;;;OASG;IACH,0BAA0B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAoB5C;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;;OAIG;IACI,oBAAoB,CAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAIlE;;OAEG;IACI,uBAAuB,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAInD;;;OAGG;IACI,iBAAiB,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAQ7D;;;;;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;IAgMjD,OAAO,CAAC,mCAAmC;IAsE3C;;;;;;OAMG;IACH,OAAO,CAAC,6CAA6C;IAyBrD;;;;;;OAMG;IACH,OAAO,CAAC,kDAAkD;CAwB3D"}
+{"version":3,"file":"expression-resolver.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/expression-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAkD,MAAM,WAAW,CAAA;AAC3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAErD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,KAAK,CAAiB;IAK9B,OAAO,CAAC,aAAa,CAA4D;IAGjF,OAAO,CAAC,eAAe,CAAiD;IAIxE,OAAO,CAAC,cAAc,CAAmC;IAIzD,OAAO,CAAC,mBAAmB,CAAmC;IAI9D,OAAO,CAAC,oBAAoB,CAAmC;IAI/D,OAAO,CAAC,kBAAkB,CAAmC;gBAEhD,KAAK,EAAE,eAAe;IAInC;;OAEG;IACI,gBAAgB,IAAK,IAAI;IAMhC;;;;;;;;;OASG;IACH,yBAAyB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAwI3C;;;;;;;OAOG;IACH,2BAA2B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAkB7C;;;;;;;;;OASG;IACH,0BAA0B,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAoB5C;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;;OAIG;IACI,oBAAoB,CAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAIlE;;OAEG;IACI,uBAAuB,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAInD;;;OAGG;IACI,iBAAiB,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAQ7D;;;;OAIG;IACI,YAAY,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;IAQtE;;;;;OAKG;IACH,sBAAsB,CAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAwBxC;;;;;;;OAOG;IACH,kCAAkC,CAAE,UAAU,EAAE,UAAU,GAAG,MAAM,EAAE;IAKrE;;;;;;;OAOG;IACH,8BAA8B,CAAE,UAAU,EAAE,UAAU,GAAG,MAAM,EAAE;IAKjE;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,yCAAyC;IAgMjD,OAAO,CAAC,mCAAmC;IAiH3C;;;;;;OAMG;IACH,OAAO,CAAC,6CAA6C;IAyBrD;;;;;;OAMG;IACH,OAAO,CAAC,kDAAkD;CAwB3D"}