i18next-cli 1.10.1 → 1.10.2

package/src/extractor/parsers/scope-manager.ts

@@ -0,0 +1,327 @@
+import type { VariableDeclarator, CallExpression } from '@swc/core'
+import type { ScopeInfo, UseTranslationHookConfig, I18nextToolkitConfig } from '../../types'
+import { getObjectPropValue } from './ast-utils'
+
+export class ScopeManager {
+  private scopeStack: Array<Map<string, ScopeInfo>> = []
+  private config: Omit<I18nextToolkitConfig, 'plugins'>
+  private scope: Map<string, { defaultNs?: string; keyPrefix?: string }> = new Map()
+
+  constructor (config: Omit<I18nextToolkitConfig, 'plugins'>) {
+    this.config = config
+  }
+
+  /**
+   * Enters a new variable scope by pushing a new scope map onto the stack.
+   * Used when entering functions to isolate variable declarations.
+   */
+  enterScope (): void {
+    this.scopeStack.push(new Map())
+  }
+
+  /**
+   * Exits the current variable scope by popping the top scope map.
+   * Used when leaving functions to clean up variable tracking.
+   */
+  exitScope (): void {
+    this.scopeStack.pop()
+  }
+
+  /**
+   * Stores variable information in the current scope.
+   * Used to track translation functions and their configuration.
+   *
+   * @param name - Variable name to store
+   * @param info - Scope information about the variable
+   */
+  setVarInScope (name: string, info: ScopeInfo): void {
+    if (this.scopeStack.length > 0) {
+      this.scopeStack[this.scopeStack.length - 1].set(name, info)
+    }
+  }
+
+  /**
+   * 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
+   */
+  getVarFromScope (name: string): ScopeInfo | undefined {
+    // First check the proper scope stack (this is the primary source of truth)
+    for (let i = this.scopeStack.length - 1; i >= 0; i--) {
+      if (this.scopeStack[i].has(name)) {
+        const scopeInfo = this.scopeStack[i].get(name)
+        return scopeInfo
+      }
+    }
+
+    // Then check the legacy scope tracking for useTranslation calls (for comment parsing)
+    const legacyScope = this.scope.get(name)
+    if (legacyScope) {
+      return legacyScope
+    }
+
+    return undefined
+  }
+
+  /**
+   * Handles variable declarations that might define translation functions.
+   *
+   * Processes two patterns:
+   * 1. `const { t } = useTranslation(...)` - React i18next pattern
+   * 2. `const t = i18next.getFixedT(...)` - Core i18next pattern
+   *
+   * Extracts namespace and key prefix information for later use.
+   *
+   * @param node - Variable declarator node to process
+   */
+  handleVariableDeclarator (node: VariableDeclarator): void {
+    const init = node.init
+    if (!init) return
+
+    // Determine the actual call expression, looking inside AwaitExpressions.
+    const callExpr =
+      init.type === 'AwaitExpression' && init.argument.type === 'CallExpression'
+        ? init.argument
+        : init.type === 'CallExpression'
+          ? init
+          : null
+
+    if (!callExpr) return
+
+    const callee = callExpr.callee
+
+    // Handle: const { t } = useTranslation(...)
+    if (callee.type === 'Identifier') {
+      const hookConfig = this.getUseTranslationConfig(callee.value)
+      if (hookConfig) {
+        this.handleUseTranslationDeclarator(node, callExpr, hookConfig)
+
+        // ALSO store in the legacy scope for comment parsing compatibility
+        this.handleUseTranslationForComments(node, callExpr, hookConfig)
+        return
+      }
+    }
+
+    // Handle: const t = i18next.getFixedT(...)
+    if (
+      callee.type === 'MemberExpression' &&
+      callee.property.type === 'Identifier' &&
+      callee.property.value === 'getFixedT'
+    ) {
+      this.handleGetFixedTDeclarator(node, callExpr)
+    }
+  }
+
+  /**
+   * Handles useTranslation calls for comment scope resolution.
+   * This is a separate method to store scope info in the legacy scope map
+   * that the comment parser can access.
+   *
+   * @param node - Variable declarator with useTranslation call
+   * @param callExpr - The CallExpression node representing the useTranslation invocation
+   * @param hookConfig - Configuration describing argument positions for namespace and keyPrefix
+   */
+  private getUseTranslationConfig (name: string): UseTranslationHookConfig | undefined {
+    const useTranslationNames = this.config.extract.useTranslationNames || ['useTranslation']
+
+    for (const item of useTranslationNames) {
+      if (typeof item === 'string' && item === name) {
+        // Default behavior for simple string entries
+        return { name, nsArg: 0, keyPrefixArg: 1 }
+      }
+      if (typeof item === 'object' && item.name === name) {
+        // Custom configuration with specified or default argument positions
+        return {
+          name: item.name,
+          nsArg: item.nsArg ?? 0,
+          keyPrefixArg: item.keyPrefixArg ?? 1,
+        }
+      }
+    }
+    return undefined
+  }
+
+  /**
+   * Processes useTranslation hook declarations to extract scope information.
+   *
+   * Handles various destructuring patterns:
+   * - `const [t] = useTranslation('ns')` - Array destructuring
+   * - `const { t } = useTranslation('ns')` - Object destructuring
+   * - `const { t: myT } = useTranslation('ns')` - Aliased destructuring
+   *
+   * Extracts namespace from the first argument and keyPrefix from options.
+   *
+   * @param node - Variable declarator with useTranslation call
+   * @param callExpr - The CallExpression node representing the useTranslation invocation
+   * @param hookConfig - Configuration describing argument positions for namespace and keyPrefix
+   */
+  private handleUseTranslationForComments (node: VariableDeclarator, callExpr: CallExpression, hookConfig: UseTranslationHookConfig): void {
+    let variableName: string | undefined
+
+    // Handle simple assignment: let t = useTranslation()
+    if (node.id.type === 'Identifier') {
+      variableName = node.id.value
+    }
+
+    // Handle array destructuring: const [t, i18n] = useTranslation()
+    if (node.id.type === 'ArrayPattern') {
+      const firstElement = node.id.elements[0]
+      if (firstElement?.type === 'Identifier') {
+        variableName = firstElement.value
+      }
+    }
+
+    // Handle object destructuring: const { t } or { t: t1 } = useTranslation()
+    if (node.id.type === 'ObjectPattern') {
+      for (const prop of node.id.properties) {
+        if (prop.type === 'AssignmentPatternProperty' && prop.key.type === 'Identifier' && prop.key.value === 't') {
+          // This handles { t = defaultT }
+          variableName = 't'
+          break
+        }
+        if (prop.type === 'KeyValuePatternProperty' && prop.key.type === 'Identifier' && prop.key.value === 't' && prop.value.type === 'Identifier') {
+          // This handles { t: myT }
+          variableName = prop.value.value
+          break
+        }
+      }
+    }
+
+    // If we couldn't find a `t` function being declared, exit
+    if (!variableName) return
+
+    // Extract namespace from useTranslation arguments
+    const nsArg = callExpr.arguments?.[hookConfig.nsArg]?.expression
+    const optionsArg = callExpr.arguments?.[hookConfig.keyPrefixArg]?.expression
+
+    let defaultNs: string | undefined
+    let keyPrefix: string | undefined
+
+    // Parse namespace argument
+    if (nsArg?.type === 'StringLiteral') {
+      defaultNs = nsArg.value
+    } else if (nsArg?.type === 'ArrayExpression' && nsArg.elements[0]?.expression.type === 'StringLiteral') {
+      defaultNs = nsArg.elements[0].expression.value
+    }
+
+    // Parse keyPrefix from options object
+    if (optionsArg?.type === 'ObjectExpression') {
+      const keyPrefixProp = optionsArg.properties.find(
+        prop => prop.type === 'KeyValueProperty' &&
+                prop.key.type === 'Identifier' &&
+                prop.key.value === 'keyPrefix'
+      )
+      if (keyPrefixProp?.type === 'KeyValueProperty' && keyPrefixProp.value.type === 'StringLiteral') {
+        keyPrefix = keyPrefixProp.value.value
+      }
+    }
+
+    // Store in the legacy scope map for comment parsing
+    if (defaultNs || keyPrefix) {
+      this.scope.set(variableName, { defaultNs, keyPrefix })
+    }
+  }
+
+  /**
+   * Processes useTranslation hook declarations to extract scope information.
+   *
+   * Handles various destructuring patterns:
+   * - `const [t] = useTranslation('ns')` - Array destructuring
+   * - `const { t } = useTranslation('ns')` - Object destructuring
+   * - `const { t: myT } = useTranslation('ns')` - Aliased destructuring
+   *
+   * Extracts namespace from the first argument and keyPrefix from options.
+   *
+   * @param node - Variable declarator with useTranslation call
+   * @param callExpr - The CallExpression node representing the useTranslation invocation
+   * @param hookConfig - Configuration describing argument positions for namespace and keyPrefix
+   */
+  private handleUseTranslationDeclarator (node: VariableDeclarator, callExpr: CallExpression, hookConfig: UseTranslationHookConfig): void {
+    let variableName: string | undefined
+
+    // Handle simple assignment: let t = useTranslation()
+    if (node.id.type === 'Identifier') {
+      variableName = node.id.value
+    }
+
+    // Handle array destructuring: const [t, i18n] = useTranslation()
+    if (node.id.type === 'ArrayPattern') {
+      const firstElement = node.id.elements[0]
+      if (firstElement?.type === 'Identifier') {
+        variableName = firstElement.value
+      }
+    }
+
+    // Handle object destructuring: const { t } or { t: t1 } = useTranslation()
+    if (node.id.type === 'ObjectPattern') {
+      for (const prop of node.id.properties) {
+        if (prop.type === 'AssignmentPatternProperty' && prop.key.type === 'Identifier' && prop.key.value === 't') {
+          // This handles { t = defaultT }
+          variableName = 't'
+          break
+        }
+        if (prop.type === 'KeyValuePatternProperty' && prop.key.type === 'Identifier' && prop.key.value === 't' && prop.value.type === 'Identifier') {
+          // This handles { t: myT }
+          variableName = prop.value.value
+          break
+        }
+      }
+    }
+
+    // If we couldn't find a `t` function being declared, exit
+    if (!variableName) return
+
+    // Use the configured argument indices from hookConfig
+    const nsArg = callExpr.arguments?.[hookConfig.nsArg]?.expression
+
+    let defaultNs: string | undefined
+    if (nsArg?.type === 'StringLiteral') {
+      defaultNs = nsArg.value
+    } else if (nsArg?.type === 'ArrayExpression' && nsArg.elements[0]?.expression.type === 'StringLiteral') {
+      defaultNs = nsArg.elements[0].expression.value
+    }
+
+    const optionsArg = callExpr.arguments?.[hookConfig.keyPrefixArg]?.expression
+    let keyPrefix: string | undefined
+    if (optionsArg?.type === 'ObjectExpression') {
+      const kp = getObjectPropValue(optionsArg, 'keyPrefix')
+      keyPrefix = typeof kp === 'string' ? kp : undefined
+    }
+
+    // Store the scope info for the declared variable
+    this.setVarInScope(variableName, { defaultNs, keyPrefix })
+  }
+
+  /**
+   * Processes getFixedT function declarations to extract scope information.
+   *
+   * Handles the pattern: `const t = i18next.getFixedT(lng, ns, keyPrefix)`
+   * - Ignores the first argument (language)
+   * - Extracts namespace from the second argument
+   * - Extracts key prefix from the third argument
+   *
+   * @param node - Variable declarator with getFixedT call
+   * @param callExpr - The CallExpression node representing the getFixedT invocation
+   */
+  private handleGetFixedTDeclarator (node: VariableDeclarator, callExpr: CallExpression): void {
+    // Ensure we are assigning to a simple variable, e.g., const t = ...
+    if (node.id.type !== 'Identifier' || !node.init || node.init.type !== 'CallExpression') return
+
+    const variableName = node.id.value
+    const args = callExpr.arguments
+
+    // getFixedT(lng, ns, keyPrefix)
+    // We ignore the first argument (lng) for key extraction.
+    const nsArg = args[1]?.expression
+    const keyPrefixArg = args[2]?.expression
+
+    const defaultNs = (nsArg?.type === 'StringLiteral') ? nsArg.value : undefined
+    const keyPrefix = (keyPrefixArg?.type === 'StringLiteral') ? keyPrefixArg.value : undefined
+
+    if (defaultNs || keyPrefix) {
+      this.setVarInScope(variableName, { defaultNs, keyPrefix })
+    }
+  }
+}

package/src/extractor.ts

@@ -2,7 +2,7 @@
 import { runExtractor, extract } from './extractor/core/extractor'
 import { findKeys } from './extractor/core/key-finder'
 import { getTranslations } from './extractor/core/translation-manager'
-import { ASTVisitors } from './extractor/parsers/ast-visitors'
+import { ASTVisitors } from './extractor/core/ast-visitors'
 import type { PluginContext } from './types'
 
 export {

package/src/types.ts

@@ -421,3 +421,85 @@ export interface ScopeInfo {
   /** Key prefix to prepend to all translation keys in this scope */
   keyPrefix?: string;
 }
+
+/**
+ * Configuration for useTranslation hook patterns.
+ * Defines how to extract namespace and key prefix information from hook calls.
+ *
+ * @example
+ * ```typescript
+ * // For: const { t } = useTranslation('common', { keyPrefix: 'user' })
+ * const config: UseTranslationHookConfig = {
+ *   name: 'useTranslation',
+ *   nsArg: 0,      // namespace is first argument
+ *   keyPrefixArg: 1 // keyPrefix is in second argument (options object)
+ * }
+ * ```
+ */
+export interface UseTranslationHookConfig {
+  /** The name of the hook function (e.g., 'useTranslation', 'getT') */
+  name: string;
+  /** Zero-based index of the argument containing the namespace */
+  nsArg: number;
+  /** Zero-based index of the argument containing options with keyPrefix */
+  keyPrefixArg: number;
+}
+
+/**
+ * Optional hooks for customizing AST visitor behavior during extraction.
+ * Allows plugins and external code to extend the visitor's capabilities.
+ *
+ * @example
+ * ```typescript
+ * const hooks: ASTVisitorHooks = {
+ *   onBeforeVisitNode: (node) => {
+ *     console.log(`Visiting ${node.type}`)
+ *   },
+ *
+ *   resolvePossibleKeyStringValues: (expression) => {
+ *     // Custom logic to extract keys from complex expressions
+ *     if (isCustomKeyExpression(expression)) {
+ *       return ['custom.key.1', 'custom.key.2']
+ *     }
+ *     return []
+ *   }
+ * }
+ * ```
+ */
+export interface ASTVisitorHooks {
+  /**
+   * Called before visiting each AST node during traversal.
+   * Useful for logging, debugging, or pre-processing nodes.
+   *
+   * @param node - The AST node about to be visited
+   */
+  onBeforeVisitNode?: (node: Node) => void
+
+  /**
+   * Called after visiting each AST node during traversal.
+   * Useful for cleanup, post-processing, or collecting statistics.
+   *
+   * @param node - The AST node that was just visited
+   */
+  onAfterVisitNode?: (node: Node) => void
+
+  /**
+   * Custom resolver for extracting context values from expressions.
+   * Supplements the built-in expression resolution with plugin-specific logic.
+   *
+   * @param expression - The expression to extract context from
+   * @param returnEmptyStrings - Whether to include empty strings in results
+   * @returns Array of possible context string values
+   */
+  resolvePossibleContextStringValues?: (expression: Expression, returnEmptyStrings?: boolean) => string[]
+
+  /**
+   * Custom resolver for extracting translation keys from expressions.
+   * Supplements the built-in expression resolution with plugin-specific logic.
+   *
+   * @param expression - The expression to extract keys from
+   * @param returnEmptyStrings - Whether to include empty strings in results
+   * @returns Array of possible translation key values
+   */
+  resolvePossibleKeyStringValues?: (expression: Expression, returnEmptyStrings?: boolean) => string[]
+}

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

@@ -0,0 +1,75 @@
+import type { Module } from '@swc/core';
+import type { PluginContext, I18nextToolkitConfig, Logger, ASTVisitorHooks, ScopeInfo } from '../../types';
+/**
+ * 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
+ * ```
+ */
+export declare class ASTVisitors {
+    private readonly pluginContext;
+    private readonly config;
+    private readonly logger;
+    private hooks;
+    get objectKeys(): Set<string>;
+    private readonly scopeManager;
+    private readonly expressionResolver;
+    private readonly callExpressionHandler;
+    private readonly jsxHandler;
+    /**
+     * 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: Omit<I18nextToolkitConfig, 'plugins'>, pluginContext: PluginContext, logger: Logger, hooks?: ASTVisitorHooks);
+    /**
+     * 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: Module): void;
+    /**
+     * 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
+     */
+    private walk;
+    /**
+     * 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: string): ScopeInfo | undefined;
+}
+//# sourceMappingURL=ast-visitors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ast-visitors.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/ast-visitors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAQ,MAAM,WAAW,CAAA;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAM1G;;;;;;;;;;;;;;;;;;;;;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,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAC3C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoB;IACvD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAuB;IAC7D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAY;IAEvC;;;;;;OAMG;gBAED,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,eAAe;IAkBzB;;;;;OAKG;IACI,KAAK,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAMjC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,IAAI;IA2DZ;;;;;;;;OAQG;IACI,eAAe,CAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;CAG7D"}

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

@@ -1,5 +1,5 @@
 import type { Logger, I18nextToolkitConfig, Plugin, PluginContext } from '../../types';
-import { ASTVisitors } from '../parsers/ast-visitors';
+import { ASTVisitors } from './ast-visitors';
 /**
  * Main extractor function that runs the complete key extraction and file generation process.
  *

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":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAKtF,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAKrD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,oBAAoB,EAC5B,EACE,WAAmB,EACnB,QAAgB,EACjB,GAAE;IACD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACf,EACN,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC,OAAO,CAAC,CAyDlB;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,GACnC,OAAO,CAAC,IAAI,CAAC,CAoCf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,OAAO,CAAE,MAAM,EAAE,oBAAoB,sDAO1D"}
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/extractor.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAKtF,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAK5C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,oBAAoB,EAC5B,EACE,WAAmB,EACnB,QAAgB,EACjB,GAAE;IACD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACf,EACN,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC,OAAO,CAAC,CAyDlB;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,GACnC,OAAO,CAAC,IAAI,CAAC,CAoCf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,OAAO,CAAE,MAAM,EAAE,oBAAoB,sDAO1D"}

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,EAAE,MAAM,aAAa,CAAA;AAM7E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,oBAAoB,EAC5B,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC;IAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC,CAgE1E"}
+{"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,aAAa,CAAA;AAM9F;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,oBAAoB,EAC5B,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC;IAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC,CAgE1E"}

package/types/extractor/core/translation-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translation-manager.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/translation-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AA6MnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAC/B,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EACvB,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA8E9B"}
+{"version":3,"file":"translation-manager.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/translation-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AA6RnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAC/B,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EACvB,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA8E9B"}

package/types/extractor/index.d.ts

@@ -1,7 +1,7 @@
 export * from './core/extractor';
 export * from './core/key-finder';
 export * from './core/translation-manager';
-export * from './parsers/ast-visitors';
+export * from './core/ast-visitors';
 export * from './parsers/comment-parser';
 export * from './parsers/jsx-parser';
 export * from './plugin-manager';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extractor/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA;AACjC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,wBAAwB,CAAA;AACtC,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA;AACpC,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extractor/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA;AACjC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA;AACpC,cAAc,kBAAkB,CAAA"}

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

@@ -0,0 +1,74 @@
+import type { CallExpression } from '@swc/core';
+import type { PluginContext, I18nextToolkitConfig, Logger, ScopeInfo } from '../../types';
+import { ExpressionResolver } from './expression-resolver';
+export declare class CallExpressionHandler {
+    private pluginContext;
+    private config;
+    private logger;
+    private expressionResolver;
+    objectKeys: Set<string>;
+    constructor(config: Omit<I18nextToolkitConfig, 'plugins'>, pluginContext: PluginContext, logger: Logger, expressionResolver: ExpressionResolver);
+    /**
+     * Processes function call expressions to extract translation keys.
+     *
+     * This is the core extraction method that handles:
+     * - Standard t() calls with string literals
+     * - Selector API calls with arrow functions: `t($ => $.path.to.key)`
+     * - Namespace resolution from multiple sources
+     * - Default value extraction from various argument patterns
+     * - Pluralization and context handling
+     * - Key prefix application from scope
+     *
+     * @param node - Call expression node to process
+     * @param getScopeInfo - Function to retrieve scope information for variables
+     */
+    handleCallExpression(node: CallExpression, getScopeInfo: (name: string) => ScopeInfo | undefined): void;
+    /**
+     * Processed a call expression to extract keys from the specified argument.
+     *
+     * @param node - The call expression node
+     * @param argIndex - The index of the argument to process
+     * @returns An object containing the keys to process and a flag indicating if the selector API is used
+     */
+    private handleCallExpressionArgument;
+    /**
+     * Extracts translation key from selector API arrow function.
+     *
+     * Processes selector expressions like:
+     * - `$ => $.path.to.key` → 'path.to.key'
+     * - `$ => $.app['title'].main` → 'app.title.main'
+     * - `$ => { return $.nested.key; }` → 'nested.key'
+     *
+     * Handles both dot notation and bracket notation, respecting
+     * the configured key separator or flat key structure.
+     *
+     * @param node - Arrow function expression from selector call
+     * @returns Extracted key path or null if not statically analyzable
+     */
+    private extractKeyFromSelector;
+    /**
+     * Generates plural form keys based on the primary language's plural rules.
+     *
+     * Uses Intl.PluralRules to determine the correct plural categories
+     * for the configured primary language and generates suffixed keys
+     * for each category (e.g., 'item_one', 'item_other').
+     *
+     * @param key - Base key name for pluralization
+     * @param ns - Namespace for the keys
+     * @param options - object expression options
+     * @param isOrdinal - isOrdinal flag
+     */
+    private handlePluralKeys;
+    /**
+     * Serializes a callee node (Identifier or MemberExpression) into a string.
+     *
+     * Produces a dotted name for simple callees that can be used for scope lookups
+     * or configuration matching.
+     *
+     * @param callee - The CallExpression callee node to serialize
+     * @returns A dotted string name for supported callees, or null when the callee
+     *          is a computed/unsupported expression.
+     */
+    private getFunctionName;
+}
+//# sourceMappingURL=call-expression-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"call-expression-handler.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/call-expression-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAA6C,MAAM,WAAW,CAAA;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,EAAgB,SAAS,EAAE,MAAM,aAAa,CAAA;AACvG,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAG1D,qBAAa,qBAAqB;IAChC,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,kBAAkB,CAAoB;IACvC,UAAU,cAAoB;gBAGnC,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EACd,kBAAkB,EAAE,kBAAkB;IAQxC;;;;;;;;;;;;;OAaG;IACH,oBAAoB,CAAE,IAAI,EAAE,cAAc,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,GAAG,SAAS,GAAG,IAAI;IAqMxG;;;;;;OAMG;IACH,OAAO,CAAC,4BAA4B;IA8BpC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,sBAAsB;IA2C9B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,gBAAgB;IA+HxB;;;;;;;;;OASG;IACH,OAAO,CAAC,eAAe;CA2BxB"}