i18next-cli 1.34.0 → 1.34.1

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

@@ -1 +1,362 @@
-import{ScopeManager as e}from"../parsers/scope-manager.js";import{ExpressionResolver as t}from"../parsers/expression-resolver.js";import{CallExpressionHandler as r}from"../parsers/call-expression-handler.js";import{JSXHandler as a}from"../parsers/jsx-handler.js";class s{pluginContext;config;logger;hooks;get objectKeys(){return this.callExpressionHandler.objectKeys}scopeManager;expressionResolver;callExpressionHandler;jsxHandler;currentFile="";currentCode="";constructor(s,i,n,o,p){this.pluginContext=i,this.config=s,this.logger=n,this.hooks={onBeforeVisitNode:o?.onBeforeVisitNode,onAfterVisitNode:o?.onAfterVisitNode,resolvePossibleKeyStringValues:o?.resolvePossibleKeyStringValues,resolvePossibleContextStringValues:o?.resolvePossibleContextStringValues},this.scopeManager=new e(s),this.expressionResolver=p??new t(this.hooks),this.callExpressionHandler=new r(s,i,n,this.expressionResolver,()=>this.getCurrentFile(),()=>this.getCurrentCode()),this.jsxHandler=new a(s,i,this.expressionResolver,()=>this.getCurrentFile(),()=>this.getCurrentCode())}visit(e){this.scopeManager.reset(),this.expressionResolver.resetFileSymbols(),this.scopeManager.enterScope(),this.walk(e),this.scopeManager.exitScope()}walk(e){if(!e)return;let t=!1;if("Function"===e.type||"FunctionDeclaration"===e.type||"FunctionDecl"===e.type||"FnDecl"===e.type||"ArrowFunctionExpression"===e.type||"FunctionExpression"===e.type||"MethodDefinition"===e.type||"ClassMethod"===e.type||"ObjectMethod"===e.type){this.scopeManager.enterScope(),t=!0;const r=e.params&&Array.isArray(e.params)?e.params:e.params||[];for(const e of r){let t;if(!e)continue;if("Identifier"===e.type?t=e:"AssignmentPattern"===e.type&&e.left&&"Identifier"===e.left.type?t=e.left:"RestElement"===e.type&&e.argument&&"Identifier"===e.argument.type?t=e.argument:"Param"!==e.type&&"FnParam"!==e.type&&"Arg"!==e.type||!e.pat||"Identifier"!==e.pat.type?"Param"!==e.type&&"FnParam"!==e.type&&"Arg"!==e.type||!e.pattern||"Identifier"!==e.pattern.type?e.pat&&"Identifier"===e.pat.type?t=e.pat:e.pattern&&"Identifier"===e.pattern.type?t=e.pattern:e.left&&e.left.param&&"Identifier"===e.left.param.type?t=e.left.param:e.param&&"Identifier"===e.param.type&&(t=e.param):t=e.pattern:t=e.pat,!t)continue;const r=t.value??t.name;if(!r)continue;const a=t.typeAnnotation??e.typeAnnotation??(e.left&&e.left.typeAnnotation);let s;s=a?"TsTypeAnn"===a.type||"TsTypeAnnotation"===a.type?a.typeAnnotation??a:a:void 0;const i=e=>{if(e){if(e.typeName&&"Identifier"===e.typeName.type)return e.typeName.value??e.typeName.name;if(e.typeName&&"TsQualifiedName"===e.typeName.type){const t=e.typeName.right??e.typeName;return t?.value??t?.name}return e.typeName&&"string"==typeof e.typeName?e.typeName:"Identifier"===e.type?e.value??e.name:e.id?e.id?.value??e.id?.name??e.id:void 0}},n=e=>{if(e)return"TsLiteralType"===e.type&&e.literal?e.literal.value??e.literal.raw:"StringLiteral"===e.type||"Str"===e.type||"Literal"===e.type?e.value??e.raw??e.value:!e.literal||"StringLiteral"!==e.literal.type&&"Str"!==e.literal.type?"string"==typeof e.value?e.value:e.params&&Array.isArray(e.params)&&e.params[0]?n(e.params[0]):e.typeArguments&&Array.isArray(e.typeArguments)&&e.typeArguments[0]?n(e.typeArguments[0]):e.typeParameters&&Array.isArray(e.typeParameters)&&e.typeParameters[0]?n(e.typeParameters[0]):e.typeParams&&Array.isArray(e.typeParams)&&e.typeParams[0]?n(e.typeParams[0]):void 0:e.literal.value};if(s&&("TsTypeReference"===s.type||"TsTypeRef"===s.type||"TsTypeReference"===s.type)){if("TFunction"===i(s)){const e=[s.typeParameters?.params?.[0],s.typeParameters?.[0],s.typeArguments?.params?.[0],s.typeArguments?.[0],s.typeParams?.params?.[0],s.typeParams?.[0],s.params?.[0],s.args?.[0],s.typeParameters,s.typeArguments,s.typeParams];let t;for(const r of e)if(r){t=r;break}const a=n(t);a&&this.scopeManager.setVarInScope(r,{defaultNs:a})}}}}switch(this.hooks.onBeforeVisitNode?.(e),e.type){case"VariableDeclarator":this.scopeManager.handleVariableDeclarator(e),this.expressionResolver.captureVariableDeclarator(e);break;case"TSEnumDeclaration":case"TsEnumDeclaration":case"TsEnumDecl":this.expressionResolver.captureEnumDeclaration(e);break;case"CallExpression":this.callExpressionHandler.handleCallExpression(e,this.scopeManager.getVarFromScope.bind(this.scopeManager));break;case"JSXElement":this.jsxHandler.handleJSXElement(e,this.scopeManager.getVarFromScope.bind(this.scopeManager))}this.hooks.onAfterVisitNode?.(e);for(const t in e){if("span"===t)continue;const r=e[t];if(Array.isArray(r)){for(const e of r)if(e&&"object"==typeof e)if("VariableDeclarator"!==e.type){if(e&&e.id&&Array.isArray(e.members)&&this.expressionResolver.captureEnumDeclaration(e),"VariableDeclaration"===e.type&&Array.isArray(e.declarations))for(const t of e.declarations)t&&"object"==typeof t&&"VariableDeclarator"===t.type&&(this.scopeManager.handleVariableDeclarator(t),this.expressionResolver.captureVariableDeclarator(t))}else this.scopeManager.handleVariableDeclarator(e),this.expressionResolver.captureVariableDeclarator(e);for(const e of r)e&&"object"==typeof e&&this.walk(e)}else r&&"object"==typeof r&&this.walk(r)}t&&this.scopeManager.exitScope()}getVarFromScope(e){return this.scopeManager.getVarFromScope(e)}setCurrentFile(e,t){this.currentFile=e,this.currentCode=t,this.callExpressionHandler.resetSearchIndex(),this.jsxHandler.resetSearchIndex()}getCurrentFile(){return this.currentFile}getCurrentCode(){return this.currentCode}}export{s as ASTVisitors};
+import { ScopeManager } from '../parsers/scope-manager.js';
+import { ExpressionResolver } from '../parsers/expression-resolver.js';
+import { CallExpressionHandler } from '../parsers/call-expression-handler.js';
+import { JSXHandler } from '../parsers/jsx-handler.js';
+
+/**
+ * AST visitor class that traverses JavaScript/TypeScript syntax trees to extract translation keys.
+ *
+ * This class implements a manual recursive walker that:
+ * - Maintains scope information for tracking useTranslation and getFixedT calls
+ * - Extracts keys from t() function calls with various argument patterns
+ * - Handles JSX Trans components with complex children serialization
+ * - Supports both string literals and selector API for type-safe keys
+ * - Processes pluralization and context variants
+ * - Manages namespace resolution from multiple sources
+ *
+ * The visitor respects configuration options for separators, function names,
+ * component names, and other extraction settings.
+ *
+ * @example
+ * ```typescript
+ * const visitors = new ASTVisitors(config, pluginContext, logger)
+ * visitors.visit(parsedAST)
+ *
+ * // The pluginContext will now contain all extracted keys
+ * ```
+ */
+class ASTVisitors {
+    pluginContext;
+    config;
+    logger;
+    hooks;
+    get objectKeys() {
+        return this.callExpressionHandler.objectKeys;
+    }
+    scopeManager;
+    expressionResolver;
+    callExpressionHandler;
+    jsxHandler;
+    currentFile = '';
+    currentCode = '';
+    /**
+     * Creates a new AST visitor instance.
+     *
+     * @param config - Toolkit configuration with extraction settings
+     * @param pluginContext - Context for adding discovered translation keys
+     * @param logger - Logger for warnings and debug information
+     */
+    constructor(config, pluginContext, logger, hooks, expressionResolver) {
+        this.pluginContext = pluginContext;
+        this.config = config;
+        this.logger = logger;
+        this.hooks = {
+            onBeforeVisitNode: hooks?.onBeforeVisitNode,
+            onAfterVisitNode: hooks?.onAfterVisitNode,
+            resolvePossibleKeyStringValues: hooks?.resolvePossibleKeyStringValues,
+            resolvePossibleContextStringValues: hooks?.resolvePossibleContextStringValues
+        };
+        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.jsxHandler = new JSXHandler(config, pluginContext, this.expressionResolver, () => this.getCurrentFile(), () => this.getCurrentCode());
+    }
+    /**
+     * Main entry point for AST traversal.
+     * Creates a root scope and begins the recursive walk through the syntax tree.
+     *
+     * @param node - The root module node to traverse
+     */
+    visit(node) {
+        // Reset any per-file scope state to avoid leaking scopes between files.
+        this.scopeManager.reset();
+        // Reset per-file captured variables in the expression resolver so variables from other files don't leak.
+        this.expressionResolver.resetFileSymbols();
+        this.scopeManager.enterScope(); // Create the root scope for the file
+        this.walk(node);
+        this.scopeManager.exitScope(); // Clean up the root scope
+    }
+    /**
+     * Recursively walks through AST nodes, handling scoping and visiting logic.
+     *
+     * This is the core traversal method that:
+     * 1. Manages function scopes (enter/exit)
+     * 2. Dispatches to specific handlers based on node type
+     * 3. Recursively processes child nodes
+     * 4. Maintains proper scope cleanup
+     *
+     * @param node - The current AST node to process
+     *
+     * @private
+     */
+    walk(node) {
+        if (!node)
+            return;
+        let isNewScope = false;
+        // ENTER SCOPE for functions
+        // Accept many SWC/TS AST variants for function-like nodes (declarations, expressions, arrow functions)
+        if (node.type === 'Function' ||
+            node.type === 'FunctionDeclaration' ||
+            node.type === 'FunctionDecl' ||
+            node.type === 'FnDecl' ||
+            node.type === 'ArrowFunctionExpression' ||
+            node.type === 'FunctionExpression' ||
+            node.type === 'MethodDefinition' ||
+            node.type === 'ClassMethod' ||
+            node.type === 'ObjectMethod') {
+            this.scopeManager.enterScope();
+            isNewScope = true;
+            const params = (node.params && Array.isArray(node.params)) ? node.params : (node.params || []);
+            for (const p of params) {
+                // handle common param shapes: Identifier, AssignmentPattern (default), RestElement ignored
+                let ident;
+                if (!p)
+                    continue;
+                // direct identifier (arrow fn params etc)
+                if (p.type === 'Identifier')
+                    ident = p;
+                // default params: (x = ...) -> AssignmentPattern.left
+                else if (p.type === 'AssignmentPattern' && p.left && p.left.type === 'Identifier')
+                    ident = p.left;
+                // rest: (...args)
+                else if (p.type === 'RestElement' && p.argument && p.argument.type === 'Identifier')
+                    ident = p.argument;
+                // SWC/TS often wrap params: { pat: Identifier } or { pattern: Identifier } or FnParam/Param
+                else if ((p.type === 'Param' || p.type === 'FnParam' || p.type === 'Arg') && p.pat && p.pat.type === 'Identifier')
+                    ident = p.pat;
+                else if ((p.type === 'Param' || p.type === 'FnParam' || p.type === 'Arg') && p.pattern && p.pattern.type === 'Identifier')
+                    ident = p.pattern;
+                else if (p.pat && p.pat.type === 'Identifier')
+                    ident = p.pat;
+                else if (p.pattern && p.pattern.type === 'Identifier')
+                    ident = p.pattern;
+                // some parsers expose .param or .left.param shapes
+                else if ((p.left && p.left.param && p.left.param.type === 'Identifier'))
+                    ident = p.left.param;
+                else if ((p.param && p.param.type === 'Identifier'))
+                    ident = p.param;
+                if (!ident)
+                    continue;
+                const paramKey = (ident.value ?? ident.name);
+                if (!paramKey)
+                    continue;
+                // Try to locate TypeScript type node carried on the identifier.
+                const rawTypeAnn = (ident.typeAnnotation ?? p.typeAnnotation ?? (p.left && p.left.typeAnnotation));
+                let typeAnn;
+                if (rawTypeAnn) {
+                    // SWC may wrap the actual TS type in a wrapper like TsTypeAnn / TsTypeAnnotation
+                    if (rawTypeAnn.type === 'TsTypeAnn' || rawTypeAnn.type === 'TsTypeAnnotation') {
+                        typeAnn = rawTypeAnn.typeAnnotation ?? rawTypeAnn;
+                    }
+                    else {
+                        typeAnn = rawTypeAnn;
+                    }
+                }
+                else {
+                    typeAnn = undefined;
+                }
+                // Small helpers to robustly extract the referenced type name and literal string
+                const extractTypeName = (ta) => {
+                    if (!ta)
+                        return undefined;
+                    // Identifier style: { type: 'Identifier', value: 'TFunction' } OR { name: 'TFunction' }
+                    if (ta.typeName && (ta.typeName.type === 'Identifier'))
+                        return ta.typeName.value ?? ta.typeName.name;
+                    if (ta.typeName && ta.typeName.type === 'TsQualifiedName') {
+                        // Qualified like Foo.TFunction -> try right side
+                        const right = (ta.typeName.right ?? ta.typeName);
+                        return right?.value ?? right?.name;
+                    }
+                    if (ta.typeName && typeof ta.typeName === 'string')
+                        return ta.typeName;
+                    if (ta.type === 'Identifier')
+                        return ta.value ?? ta.name;
+                    if (ta.id)
+                        return ta.id?.value ?? ta.id?.name ?? ta.id;
+                    return undefined;
+                };
+                const extractStringLiteralValue = (node) => {
+                    if (!node)
+                        return undefined;
+                    // shapes: TsLiteralType -> { literal: { type: 'StringLiteral', value: 'x' } }
+                    if (node.type === 'TsLiteralType' && node.literal)
+                        return node.literal.value ?? node.literal.raw;
+                    if (node.type === 'StringLiteral' || node.type === 'Str' || node.type === 'Literal')
+                        return node.value ?? node.raw ?? node.value;
+                    if (node.literal && (node.literal.type === 'StringLiteral' || node.literal.type === 'Str'))
+                        return node.literal.value;
+                    // some SWC builds put the string directly on .value
+                    if (typeof node.value === 'string')
+                        return node.value;
+                    // handle wrapped parameter like { params: [ ... ] } where a literal might be one level deeper
+                    if (node.params && Array.isArray(node.params) && node.params[0])
+                        return extractStringLiteralValue(node.params[0]);
+                    if (node.typeArguments && Array.isArray(node.typeArguments) && node.typeArguments[0])
+                        return extractStringLiteralValue(node.typeArguments[0]);
+                    if (node.typeParameters && Array.isArray(node.typeParameters) && node.typeParameters[0])
+                        return extractStringLiteralValue(node.typeParameters[0]);
+                    if (node.typeParams && Array.isArray(node.typeParams) && node.typeParams[0])
+                        return extractStringLiteralValue(node.typeParams[0]);
+                    return undefined;
+                };
+                // Detect TsTypeReference like: TFunction<"my-custom-namespace">
+                if (typeAnn && (typeAnn.type === 'TsTypeReference' || typeAnn.type === 'TsTypeRef' || typeAnn.type === 'TsTypeReference')) {
+                    const finalTypeName = extractTypeName(typeAnn);
+                    if (finalTypeName === 'TFunction') {
+                        // support multiple AST shapes for type parameters:
+                        // - typeAnn.typeParameters?.params?.[0]
+                        // - typeAnn.typeArguments?.params?.[0]
+                        // - typeAnn.typeParams?.[0] / typeAnn.params?.[0]
+                        const candidates = [
+                            typeAnn.typeParameters?.params?.[0],
+                            typeAnn.typeParameters?.[0],
+                            typeAnn.typeArguments?.params?.[0],
+                            typeAnn.typeArguments?.[0],
+                            typeAnn.typeParams?.params?.[0],
+                            typeAnn.typeParams?.[0],
+                            typeAnn.params?.[0],
+                            typeAnn.args?.[0],
+                            typeAnn.typeParameters, // fallback if it's directly the literal
+                            typeAnn.typeArguments,
+                            typeAnn.typeParams,
+                        ];
+                        let tp;
+                        for (const c of candidates) {
+                            if (c) {
+                                tp = c;
+                                break;
+                            }
+                        }
+                        const ns = extractStringLiteralValue(tp);
+                        if (ns) {
+                            this.scopeManager.setVarInScope(paramKey, { defaultNs: ns });
+                        }
+                    }
+                }
+            }
+        }
+        this.hooks.onBeforeVisitNode?.(node);
+        // --- VISIT LOGIC ---
+        // Handle specific node types
+        switch (node.type) {
+            case 'VariableDeclarator':
+                this.scopeManager.handleVariableDeclarator(node);
+                // Capture simple variable initializers so the expressionResolver can
+                // resolve identifiers / member expressions that reference them.
+                this.expressionResolver.captureVariableDeclarator(node);
+                break;
+            case 'TSEnumDeclaration':
+            case 'TsEnumDeclaration':
+            case 'TsEnumDecl':
+                // capture enums into resolver symbol table
+                this.expressionResolver.captureEnumDeclaration(node);
+                break;
+            case 'CallExpression':
+                this.callExpressionHandler.handleCallExpression(node, this.scopeManager.getVarFromScope.bind(this.scopeManager));
+                break;
+            case 'JSXElement':
+                this.jsxHandler.handleJSXElement(node, this.scopeManager.getVarFromScope.bind(this.scopeManager));
+                break;
+        }
+        this.hooks.onAfterVisitNode?.(node);
+        // --- END VISIT LOGIC ---
+        // --- RECURSION ---
+        // Recurse into the children of the current node
+        for (const key in node) {
+            if (key === 'span')
+                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.
+                for (const item of child) {
+                    if (!item || typeof item !== 'object')
+                        continue;
+                    // Direct declarator present in arrays (rare)
+                    if (item.type === 'VariableDeclarator') {
+                        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)) {
+                        this.expressionResolver.captureEnumDeclaration(item);
+                        // continue to allow further traversal
+                    }
+                    // Common case: VariableDeclaration which contains .declarations (VariableDeclarator[])
+                    if (item.type === 'VariableDeclaration' && Array.isArray(item.declarations)) {
+                        for (const decl of item.declarations) {
+                            if (decl && typeof decl === 'object' && decl.type === 'VariableDeclarator') {
+                                this.scopeManager.handleVariableDeclarator(decl);
+                                this.expressionResolver.captureVariableDeclarator(decl);
+                            }
+                        }
+                    }
+                }
+                for (const item of child) {
+                    // Be less strict: if it's a non-null object, walk it.
+                    // This allows traversal into nodes that might not have a `.type` property
+                    // but still contain other valid AST nodes.
+                    if (item && typeof item === 'object') {
+                        this.walk(item);
+                    }
+                }
+            }
+            else if (child && typeof child === 'object') {
+                // The condition for single objects should be the same as for array items.
+                // Do not require `child.type`. This allows traversal into class method bodies.
+                this.walk(child);
+            }
+        }
+        // --- END RECURSION ---
+        // LEAVE SCOPE for functions
+        if (isNewScope) {
+            this.scopeManager.exitScope();
+        }
+    }
+    /**
+     * Retrieves variable information from the scope chain.
+     * Searches from innermost to outermost scope.
+     *
+     * @param name - Variable name to look up
+     * @returns Scope information if found, undefined otherwise
+     *
+     * @private
+     */
+    getVarFromScope(name) {
+        return this.scopeManager.getVarFromScope(name);
+    }
+    /**
+     * Sets the current file path and code used by the extractor.
+     * Also resets the search index for location tracking.
+     */
+    setCurrentFile(file, code) {
+        this.currentFile = file;
+        this.currentCode = code;
+        // Reset search indexes when processing a new file
+        this.callExpressionHandler.resetSearchIndex();
+        this.jsxHandler.resetSearchIndex();
+    }
+    /**
+     * Returns the currently set file path.
+     *
+     * @returns The current file path as a string, or `undefined` if no file has been set.
+     * @remarks
+     * Use this to retrieve the file context that was previously set via `setCurrentFile`.
+     */
+    getCurrentFile() {
+        return this.currentFile;
+    }
+    /**
+     * @returns The full source code string for the file currently under processing.
+     */
+    getCurrentCode() {
+        return this.currentCode;
+    }
+}
+
+export { ASTVisitors };

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

@@ -1 +1,241 @@
-import t from"ora";import a from"chalk";import{parse as e}from"@swc/core";import{mkdir as o,writeFile as r,readFile as n}from"node:fs/promises";import{dirname as s,extname as i}from"node:path";import{findKeys as c}from"./key-finder.js";import{getTranslations as l}from"./translation-manager.js";import{validateExtractorConfig as m,ExtractorError as p}from"../../utils/validation.js";import{extractKeysFromComments as f}from"../parsers/comment-parser.js";import{ConsoleLogger as y}from"../../utils/logger.js";import{loadRawJson5Content as u,serializeTranslationFile as g}from"../../utils/file-utils.js";import{shouldShowFunnel as d,recordFunnelShown as w}from"../../utils/funnel-msg-tracker.js";async function x(e,{isWatchMode:n=!1,isDryRun:i=!1,syncPrimaryWithDefaults:p=!1,syncAll:f=!1}={},x=new y){e.extract.primaryLanguage||=e.locales[0]||"en",e.extract.secondaryLanguages||=e.locales.filter(t=>t!==e?.extract?.primaryLanguage),e.extract.functions||=["t","*.t"],e.extract.transComponents||=["Trans"],m(e);const h=e.plugins||[],j=t("Running i18next key extractor...\n").start();try{const{allKeys:t,objectKeys:n}=await c(e,x);j.text=`Found ${t.size} unique keys. Updating translation files...`;const m=await l(t,n,e,{syncPrimaryWithDefaults:p,syncAll:f});let y=!1;for(const t of m)if(t.updated&&(y=!0,!i)){const n=e.extract.outputFormat??(t.path.endsWith(".json5")?"json5":"json"),i="json5"===n?await u(t.path)??void 0:void 0,c=g(t.newTranslations,n,e.extract.indentation,i);await o(s(t.path),{recursive:!0}),await r(t.path,c),x.info(a.green(`Updated: ${t.path}`))}if(h.length>0){j.text="Running post-extraction plugins...";for(const t of h)await(t.afterSync?.(m,e))}return j.succeed(a.bold("Extraction complete!")),y&&await async function(){if(!await d("extract"))return;return console.log(a.yellow.bold("\n💡 Tip: Tired of running the extractor manually?")),console.log('   Discover a real-time "push" workflow with `saveMissing` and Locize AI,'),console.log("   where keys are created and translated automatically as you code."),console.log(`   Learn more: ${a.cyan("https://www.locize.com/blog/i18next-savemissing-ai-automation")}`),console.log(`   Watch the video: ${a.cyan("https://youtu.be/joPsZghT3wM")}`),w("extract")}(),y}catch(t){throw j.fail(a.red("Extraction failed.")),t}}async function h(t,o,r,s,c,l=new y){try{let a=await n(t,"utf-8");for(const e of o)try{const o=await(e.onLoad?.(a,t));void 0!==o&&(a=o)}catch(t){l.warn(`Plugin ${e.name} onLoad failed:`,t)}const m=i(t).toLowerCase(),y=".ts"===m||".tsx"===m||".mts"===m||".cts"===m,u=".tsx"===m,g=".jsx"===m;let d;try{d=await e(a,{syntax:y?"typescript":"ecmascript",tsx:u,jsx:g,decorators:!0,dynamicImport:!0,comments:!0})}catch(o){if(".ts"!==m||u){if(".js"!==m||g)throw new p("Failed to process file",t,o);try{d=await e(a,{syntax:"ecmascript",jsx:!0,decorators:!0,dynamicImport:!0,comments:!0}),l.info?.(`Parsed ${t} using JSX fallback`)}catch(a){throw new p("Failed to process file",t,a)}}else try{d=await e(a,{syntax:"typescript",tsx:!0,decorators:!0,dynamicImport:!0,comments:!0}),l.info?.(`Parsed ${t} using TSX fallback`)}catch(a){throw new p("Failed to process file",t,a)}}s.getVarFromScope=r.getVarFromScope.bind(r),r.setCurrentFile(t,a),r.visit(d),!1!==c.extract.extractFromComments&&f(a,s,c,r.getVarFromScope.bind(r))}catch(e){l.warn(`${a.yellow("Skipping file due to error:")} ${t}`);const o=e,r="string"==typeof o?.message&&o.message.trim().length>0?o.message:("string"==typeof o?o:"")||o?.toString?.()||"Unknown error";l.warn(`  ${r}`),o?.message&&""!==String(o.message).trim()||!o?.stack||l.warn(`  ${String(o.stack)}`)}}async function j(t,{syncPrimaryWithDefaults:a=!1}={}){t.extract.primaryLanguage||=t.locales[0]||"en",t.extract.secondaryLanguages||=t.locales.filter(a=>a!==t?.extract?.primaryLanguage),t.extract.functions||=["t","*.t"],t.extract.transComponents||=["Trans"];const{allKeys:e,objectKeys:o}=await c(t);return l(e,o,t,{syncPrimaryWithDefaults:a})}export{j as extract,h as processFile,x as runExtractor};
+import ora from 'ora';
+import chalk from 'chalk';
+import { parse } from '@swc/core';
+import { mkdir, writeFile, readFile } from 'node:fs/promises';
+import { dirname, extname } from 'node:path';
+import { findKeys } from './key-finder.js';
+import { getTranslations } from './translation-manager.js';
+import { validateExtractorConfig, ExtractorError } from '../../utils/validation.js';
+import { extractKeysFromComments } from '../parsers/comment-parser.js';
+import { ConsoleLogger } from '../../utils/logger.js';
+import { loadRawJson5Content, serializeTranslationFile } from '../../utils/file-utils.js';
+import { shouldShowFunnel, recordFunnelShown } from '../../utils/funnel-msg-tracker.js';
+
+/**
+ * Main extractor function that runs the complete key extraction and file generation process.
+ *
+ * This is the primary entry point that:
+ * 1. Validates configuration
+ * 2. Sets up default sync options
+ * 3. Finds all translation keys across source files
+ * 4. Generates/updates translation files for all locales
+ * 5. Provides progress feedback via spinner
+ * 6. Returns whether any files were updated
+ *
+ * @param config - The i18next toolkit configuration object
+ * @param logger - Logger instance for output (defaults to ConsoleLogger)
+ * @returns Promise resolving to boolean indicating if any files were updated
+ *
+ * @throws {ExtractorError} When configuration validation fails or extraction process encounters errors
+ *
+ * @example
+ * ```typescript
+ * const config = await loadConfig()
+ * const updated = await runExtractor(config)
+ * if (updated) {
+ *   console.log('Translation files were updated')
+ * }
+ * ```
+ */
+async function runExtractor(config, { isWatchMode = false, isDryRun = false, syncPrimaryWithDefaults = false, syncAll = false } = {}, logger = new ConsoleLogger()) {
+    config.extract.primaryLanguage ||= config.locales[0] || 'en';
+    config.extract.secondaryLanguages ||= config.locales.filter((l) => l !== config?.extract?.primaryLanguage);
+    // Ensure default function and component names are set if not provided.
+    config.extract.functions ||= ['t', '*.t'];
+    config.extract.transComponents ||= ['Trans'];
+    validateExtractorConfig(config);
+    const plugins = config.plugins || [];
+    const spinner = ora('Running i18next key extractor...\n').start();
+    try {
+        const { allKeys, objectKeys } = await findKeys(config, logger);
+        spinner.text = `Found ${allKeys.size} unique keys. Updating translation files...`;
+        const results = await getTranslations(allKeys, objectKeys, config, { syncPrimaryWithDefaults, syncAll });
+        let anyFileUpdated = false;
+        for (const result of results) {
+            if (result.updated) {
+                anyFileUpdated = true;
+                if (!isDryRun) {
+                    // prefer explicit outputFormat; otherwise infer from file extension per-file
+                    const effectiveFormat = config.extract.outputFormat ?? (result.path.endsWith('.json5') ? 'json5' : 'json');
+                    const rawContent = effectiveFormat === 'json5'
+                        ? (await loadRawJson5Content(result.path)) ?? undefined
+                        : undefined;
+                    const fileContent = serializeTranslationFile(result.newTranslations, effectiveFormat, config.extract.indentation, rawContent);
+                    await mkdir(dirname(result.path), { recursive: true });
+                    await writeFile(result.path, fileContent);
+                    logger.info(chalk.green(`Updated: ${result.path}`));
+                }
+            }
+        }
+        // Run afterSync hooks from plugins
+        if (plugins.length > 0) {
+            spinner.text = 'Running post-extraction plugins...';
+            for (const plugin of plugins) {
+                await plugin.afterSync?.(results, config);
+            }
+        }
+        spinner.succeed(chalk.bold('Extraction complete!'));
+        // Show the funnel message only if files were actually changed.
+        if (anyFileUpdated)
+            await printLocizeFunnel();
+        return anyFileUpdated;
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Extraction failed.'));
+        // Re-throw or handle error
+        throw error;
+    }
+}
+/**
+ * Processes an individual source file for translation key extraction.
+ *
+ * This function:
+ * 1. Reads the source file
+ * 2. Runs plugin onLoad hooks for code transformation
+ * 3. Parses the code into an Abstract Syntax Tree (AST) using SWC
+ * 4. Extracts keys from comments using regex patterns
+ * 5. Traverses the AST using visitors to find translation calls
+ * 6. Runs plugin onVisitNode hooks for custom extraction logic
+ *
+ * @param file - Path to the source file to process
+ * @param config - The i18next toolkit configuration object
+ * @param logger - Logger instance for output
+ * @param allKeys - Map to accumulate found translation keys
+ *
+ * @throws {ExtractorError} When file processing fails
+ *
+ * @internal
+ */
+async function processFile(file, plugins, astVisitors, pluginContext, config, logger = new ConsoleLogger()) {
+    try {
+        let code = await readFile(file, 'utf-8');
+        // Run onLoad hooks from plugins with error handling
+        for (const plugin of plugins) {
+            try {
+                const result = await plugin.onLoad?.(code, file);
+                if (result !== undefined) {
+                    code = result;
+                }
+            }
+            catch (err) {
+                logger.warn(`Plugin ${plugin.name} onLoad failed:`, err);
+                // Continue with the original code if the plugin fails
+            }
+        }
+        // Determine parser options from file extension so .ts is not parsed as TSX
+        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) {
+            // Fallback for .ts files with JSX (already present)
+            if (fileExt === '.ts' && !isTSX) {
+                try {
+                    ast = await parse(code, {
+                        syntax: 'typescript',
+                        tsx: true,
+                        decorators: true,
+                        dynamicImport: true,
+                        comments: true,
+                    });
+                    logger.info?.(`Parsed ${file} using TSX fallback`);
+                }
+                catch (err2) {
+                    throw new ExtractorError('Failed to process file', file, err2);
+                }
+                // Fallback for .js files with JSX
+            }
+            else if (fileExt === '.js' && !isJSX) {
+                try {
+                    ast = await parse(code, {
+                        syntax: 'ecmascript',
+                        jsx: true,
+                        decorators: true,
+                        dynamicImport: true,
+                        comments: true,
+                    });
+                    logger.info?.(`Parsed ${file} using JSX fallback`);
+                }
+                catch (err2) {
+                    throw new ExtractorError('Failed to process file', file, err2);
+                }
+            }
+            else {
+                throw new ExtractorError('Failed to process file', file, err);
+            }
+        }
+        // "Wire up" the visitor's scope method to the context.
+        // This avoids a circular dependency while giving plugins access to the scope.
+        pluginContext.getVarFromScope = astVisitors.getVarFromScope.bind(astVisitors);
+        // Pass BOTH file and code
+        astVisitors.setCurrentFile(file, code);
+        // 3. FIRST: Visit the AST to build scope information
+        astVisitors.visit(ast);
+        // 4. THEN: Extract keys from comments with scope resolution (now scope info is available)
+        if (config.extract.extractFromComments !== false) {
+            extractKeysFromComments(code, pluginContext, config, astVisitors.getVarFromScope.bind(astVisitors));
+        }
+    }
+    catch (error) {
+        logger.warn(`${chalk.yellow('Skipping file 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';
+        logger.warn(`  ${msg}`);
+        // If message is missing, stack is often the only useful clue
+        if ((!err?.message || String(err.message).trim() === '') && err?.stack) {
+            logger.warn(`  ${String(err.stack)}`);
+        }
+    }
+}
+/**
+ * Simplified extraction function that returns translation results without file writing.
+ * Used primarily for testing and programmatic access.
+ *
+ * @param config - The i18next toolkit configuration object
+ * @returns Promise resolving to array of translation results
+ *
+ * @example
+ * ```typescript
+ * const results = await extract(config)
+ * for (const result of results) {
+ *   console.log(`${result.path}: ${result.updated ? 'Updated' : 'No changes'}`)
+ * }
+ * ```
+ */
+async function extract(config, { syncPrimaryWithDefaults = false } = {}) {
+    config.extract.primaryLanguage ||= config.locales[0] || 'en';
+    config.extract.secondaryLanguages ||= config.locales.filter((l) => l !== config?.extract?.primaryLanguage);
+    config.extract.functions ||= ['t', '*.t'];
+    config.extract.transComponents ||= ['Trans'];
+    const { allKeys, objectKeys } = await findKeys(config);
+    return getTranslations(allKeys, objectKeys, config, { syncPrimaryWithDefaults });
+}
+/**
+ * Prints a promotional message for the locize saveMissing workflow.
+ * This message is shown after a successful extraction that resulted in changes.
+ */
+async function printLocizeFunnel() {
+    if (!(await shouldShowFunnel('extract')))
+        return;
+    console.log(chalk.yellow.bold('\n💡 Tip: Tired of running the extractor manually?'));
+    console.log('   Discover a real-time "push" workflow with `saveMissing` and Locize AI,');
+    console.log('   where keys are created and translated automatically as you code.');
+    console.log(`   Learn more: ${chalk.cyan('https://www.locize.com/blog/i18next-savemissing-ai-automation')}`);
+    console.log(`   Watch the video: ${chalk.cyan('https://youtu.be/joPsZghT3wM')}`);
+    return recordFunnelShown('extract');
+}
+
+export { extract, processFile, runExtractor };