i18next-cli 1.6.0 → 1.7.0

package/src/extractor/core/extractor.ts

@@ -3,11 +3,10 @@ import chalk from 'chalk'
 import { parse } from '@swc/core'
 import { mkdir, readFile, writeFile } from 'node:fs/promises'
 import { dirname } from 'node:path'
-import type { Logger, ExtractedKey, PluginContext, I18nextToolkitConfig } from '../../types'
+import type { Logger, I18nextToolkitConfig, Plugin, PluginContext } from '../../types'
 import { findKeys } from './key-finder'
 import { getTranslations } from './translation-manager'
 import { validateExtractorConfig, ExtractorError } from '../../utils/validation'
-import { createPluginContext } from '../plugin-manager'
 import { extractKeysFromComments } from '../parsers/comment-parser'
 import { ASTVisitors } from '../parsers/ast-visitors'
 import { ConsoleLogger } from '../../utils/logger'
@@ -60,6 +59,8 @@ export async function runExtractor (
 
   validateExtractorConfig(config)
 
+  const plugins = config.plugins || []
+
   const spinner = ora('Running i18next key extractor...\n').start()
 
   try {
@@ -87,9 +88,9 @@ export async function runExtractor (
     }
 
     // Run afterSync hooks from plugins
-    if ((config.plugins || []).length > 0) {
+    if (plugins.length > 0) {
       spinner.text = 'Running post-extraction plugins...'
-      for (const plugin of (config.plugins || [])) {
+      for (const plugin of plugins) {
         await plugin.afterSync?.(results, config)
       }
     }
@@ -129,16 +130,17 @@ export async function runExtractor (
  */
 export async function processFile (
   file: string,
-  config: I18nextToolkitConfig,
-  allKeys: Map<string, ExtractedKey>,
+  plugins: Plugin[],
   astVisitors: ASTVisitors,
+  pluginContext: PluginContext,
+  config: Omit<I18nextToolkitConfig, 'plugins'>,
   logger: Logger = new ConsoleLogger()
 ): Promise<void> {
   try {
     let code = await readFile(file, 'utf-8')
 
     // Run onLoad hooks from plugins with error handling
-    for (const plugin of (config.plugins || [])) {
+    for (const plugin of plugins) {
       try {
         const result = await plugin.onLoad?.(code, file)
         if (result !== undefined) {
@@ -157,60 +159,20 @@ export async function processFile (
       comments: true
     })
 
-    // 1. Create the base context with config and logger.
-    const pluginContext = createPluginContext(allKeys, config, logger)
-
-    // 2. "Wire up" the visitor's scope method to the context.
+    // "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)
 
-    // Extract keys from comments with scope resolution
-    extractKeysFromComments(code, pluginContext, config, astVisitors.getVarFromScope.bind(astVisitors))
-
+    // 3. FIRST: Visit the AST to build scope information
     astVisitors.visit(ast)
 
-    // Run plugin visitors
-    if ((config.plugins || []).length > 0) {
-      traverseEveryNode(ast, (config.plugins || []), pluginContext, logger)
-    }
+    // 4. THEN: Extract keys from comments with scope resolution (now scope info is available)
+    extractKeysFromComments(code, pluginContext, config, astVisitors.getVarFromScope.bind(astVisitors))
   } catch (error) {
     throw new ExtractorError('Failed to process file', file, error as Error)
   }
 }
 
-/**
- * Recursively traverses AST nodes and calls plugin onVisitNode hooks.
- *
- * @param node - The AST node to traverse
- * @param plugins - Array of plugins to run hooks for
- * @param pluginContext - Context object with helper methods for plugins
- *
- * @internal
- */
-function traverseEveryNode (node: any, plugins: any[], pluginContext: PluginContext, logger: Logger = new ConsoleLogger()): void {
-  if (!node || typeof node !== 'object') return
-
-  // Call plugins for this node
-  for (const plugin of plugins) {
-    try {
-      plugin.onVisitNode?.(node, pluginContext)
-    } catch (err) {
-      logger.warn(`Plugin ${plugin.name} onVisitNode failed:`, err)
-    }
-  }
-
-  for (const key of Object.keys(node)) {
-    const child = node[key]
-    if (Array.isArray(child)) {
-      for (const c of child) {
-        if (c && typeof c === 'object') traverseEveryNode(c, plugins, pluginContext, logger)
-      }
-    } else if (child && typeof child === 'object') {
-      traverseEveryNode(child, plugins, pluginContext, logger)
-    }
-  }
-}
-
 /**
  * Simplified extraction function that returns translation results without file writing.
  * Used primarily for testing and programmatic access.

package/src/extractor/core/key-finder.ts

@@ -1,9 +1,10 @@
 import { glob } from 'glob'
+import type { Expression } from '@swc/core'
 import type { ExtractedKey, Logger, I18nextToolkitConfig } from '../../types'
 import { processFile } from './extractor'
 import { ConsoleLogger } from '../../utils/logger'
 import { initializePlugins, createPluginContext } from '../plugin-manager'
-import { ASTVisitors } from '../parsers/ast-visitors'
+import { type ASTVisitorHooks, ASTVisitors } from '../parsers/ast-visitors'
 
 /**
  * Main function for finding translation keys across all source files in a project.
@@ -37,27 +38,65 @@ export async function findKeys (
   config: I18nextToolkitConfig,
   logger: Logger = new ConsoleLogger()
 ): Promise<{ allKeys: Map<string, ExtractedKey>, objectKeys: Set<string> }> {
+  const { plugins: pluginsOrUndefined, ...otherConfig } = config
+  const plugins = pluginsOrUndefined || []
+
   const sourceFiles = await processSourceFiles(config)
   const allKeys = new Map<string, ExtractedKey>()
 
   // 1. Create the base context with config and logger.
-  const pluginContext = createPluginContext(allKeys, config, logger)
+  const pluginContext = createPluginContext(allKeys, plugins, otherConfig, logger)
+
+  // 2. Create hooks for plugins to hook into AST
+  const hooks = {
+    onBeforeVisitNode: (node) => {
+      for (const plugin of plugins) {
+        try {
+          plugin.onVisitNode?.(node, pluginContext)
+        } catch (err) {
+          logger.warn(`Plugin ${plugin.name} onVisitNode failed:`, err)
+        }
+      }
+    },
+    resolvePossibleKeyStringValues: (expression: Expression) => {
+      return plugins.flatMap(plugin => {
+        try {
+          return plugin.extractKeysFromExpression?.(expression, config, logger) ?? []
+        } catch (err) {
+          logger.warn(`Plugin ${plugin.name} extractKeysFromExpression failed:`, err)
+          return []
+        }
+      })
+    },
+    resolvePossibleContextStringValues: (expression: Expression) => {
+      return plugins.flatMap(plugin => {
+        try {
+          return plugin.extractContextFromExpression?.(expression, config, logger) ?? []
+        } catch (err) {
+          logger.warn(`Plugin ${plugin.name} extractContextFromExpression failed:`, err)
+          return []
+        }
+      })
+    },
+  } satisfies ASTVisitorHooks
 
-  // 2. Create the visitor instance, passing it the context.
-  const astVisitors = new ASTVisitors(config, pluginContext, logger)
+  // 3. Create the visitor instance, passing it the context.
+  const astVisitors = new ASTVisitors(otherConfig, pluginContext, logger, hooks)
 
-  // 3. "Wire up" the visitor's scope method to the context.
+  // 4. "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)
 
-  await initializePlugins(config.plugins || [])
+  // 5. Initialize plugins
+  await initializePlugins(plugins)
 
+  // 6. Process each file
   for (const file of sourceFiles) {
-    await processFile(file, config, allKeys, astVisitors, logger)
+    await processFile(file, plugins, astVisitors, pluginContext, otherConfig, logger)
   }
 
-  // Run onEnd hooks
-  for (const plugin of (config.plugins || [])) {
+  // 7. Run onEnd hooks
+  for (const plugin of plugins) {
     await plugin.onEnd?.(allKeys)
   }
 

package/src/extractor/parsers/ast-visitors.ts

@@ -9,6 +9,13 @@ interface UseTranslationHookConfig {
   keyPrefixArg: number;
 }
 
+export interface ASTVisitorHooks {
+  onBeforeVisitNode?: (node: Node) => void
+  onAfterVisitNode?: (node: Node) => void
+  resolvePossibleContextStringValues?: (expression: Expression, returnEmptyStrings?: boolean) => string[]
+  resolvePossibleKeyStringValues?: (expression: Expression, returnEmptyStrings?: boolean) => string[]
+}
+
 /**
  * AST visitor class that traverses JavaScript/TypeScript syntax trees to extract translation keys.
  *
@@ -33,12 +40,15 @@ interface UseTranslationHookConfig {
  */
 export class ASTVisitors {
   private readonly pluginContext: PluginContext
-  private readonly config: I18nextToolkitConfig
+  private readonly config: Omit<I18nextToolkitConfig, 'plugins'>
   private readonly logger: Logger
   private scopeStack: Array<Map<string, ScopeInfo>> = []
+  private hooks: ASTVisitorHooks
 
   public objectKeys = new Set<string>()
 
+  private scope: Map<string, { defaultNs?: string; keyPrefix?: string }> = new Map()
+
   /**
    * Creates a new AST visitor instance.
    *
@@ -47,13 +57,20 @@ export class ASTVisitors {
    * @param logger - Logger for warnings and debug information
    */
   constructor (
-    config: I18nextToolkitConfig,
+    config: Omit<I18nextToolkitConfig, 'plugins'>,
     pluginContext: PluginContext,
-    logger: Logger
+    logger: Logger,
+    hooks?: ASTVisitorHooks
   ) {
     this.pluginContext = pluginContext
     this.config = config
     this.logger = logger
+    this.hooks = {
+      onBeforeVisitNode: hooks?.onBeforeVisitNode,
+      onAfterVisitNode: hooks?.onAfterVisitNode,
+      resolvePossibleKeyStringValues: hooks?.resolvePossibleKeyStringValues,
+      resolvePossibleContextStringValues: hooks?.resolvePossibleContextStringValues
+    }
   }
 
   /**
@@ -91,6 +108,8 @@ export class ASTVisitors {
       isNewScope = true
     }
 
+    this.hooks.onBeforeVisitNode?.(node)
+
     // --- VISIT LOGIC ---
     // Handle specific node types
     switch (node.type) {
@@ -104,6 +123,9 @@ export class ASTVisitors {
         this.handleJSXElement(node)
         break
     }
+
+    this.hooks.onAfterVisitNode?.(node)
+
     // --- END VISIT LOGIC ---
 
     // --- RECURSION ---
@@ -180,11 +202,20 @@ export class ASTVisitors {
    * @private
    */
   public 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)) {
-        return this.scopeStack[i].get(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
   }
 
@@ -222,6 +253,9 @@ export class ASTVisitors {
       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
       }
     }
@@ -236,6 +270,84 @@ export class ASTVisitors {
     }
   }
 
+  /**
+   * 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
+   */
+  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.
    *
@@ -456,8 +568,17 @@ export class ASTVisitors {
         const keysWithContext: ExtractedKey[] = []
 
         // 1. Handle Context
-        if (contextProp?.value?.type === 'ConditionalExpression') {
-          const contextValues = this.resolvePossibleStringValues(contextProp.value)
+        if (contextProp?.value?.type === 'StringLiteral' || contextProp?.value.type === 'NumericLiteral' || contextProp?.value.type === 'BooleanLiteral') {
+          // If the context is static, we don't need to add the base key
+          const contextValue = `${contextProp.value.value}`
+
+          const contextSeparator = this.config.extract.contextSeparator ?? '_'
+          // Ignore context: ''
+          if (contextValue !== '') {
+            keysWithContext.push({ key: `${finalKey}${contextSeparator}${contextValue}`, ns, defaultValue: dv })
+          }
+        } else if (contextProp?.value) {
+          const contextValues = this.resolvePossibleContextStringValues(contextProp.value)
           const contextSeparator = this.config.extract.contextSeparator ?? '_'
 
           if (contextValues.length > 0) {
@@ -467,11 +588,6 @@ export class ASTVisitors {
             // For dynamic context, also add the base key as a fallback
             keysWithContext.push({ key: finalKey, ns, defaultValue: dv })
           }
-        } else if (contextProp?.value?.type === 'StringLiteral') {
-          const contextValue = contextProp.value.value
-
-          const contextSeparator = this.config.extract.contextSeparator ?? '_'
-          keysWithContext.push({ key: `${finalKey}${contextSeparator}${contextValue}`, ns, defaultValue: dv })
         }
 
         // 2. Handle Plurals
@@ -540,11 +656,11 @@ export class ASTVisitors {
     } else if (firstArg.type === 'ArrayExpression') {
       for (const element of firstArg.elements) {
         if (element?.expression) {
-          keysToProcess.push(...this.resolvePossibleStringValues(element.expression))
+          keysToProcess.push(...this.resolvePossibleKeyStringValues(element.expression))
         }
       }
     } else {
-      keysToProcess.push(...this.resolvePossibleStringValues(firstArg))
+      keysToProcess.push(...this.resolvePossibleKeyStringValues(firstArg))
     }
 
     return {
@@ -674,7 +790,7 @@ export class ASTVisitors {
 
       if (extractedAttributes) {
         if (extractedAttributes.keyExpression) {
-          const keyValues = this.resolvePossibleStringValues(extractedAttributes.keyExpression)
+          const keyValues = this.resolvePossibleKeyStringValues(extractedAttributes.keyExpression)
           keysToProcess.push(...keyValues)
         } else {
           keysToProcess.push(extractedAttributes.serializedChildren)
@@ -752,7 +868,7 @@ export class ASTVisitors {
           )
           const isOrdinal = !!ordinalAttr
 
-          const contextValues = this.resolvePossibleStringValues(contextExpression)
+          const contextValues = this.resolvePossibleContextStringValues(contextExpression)
           const contextSeparator = this.config.extract.contextSeparator ?? '_'
 
           // Generate all combinations of context and plural forms
@@ -772,7 +888,7 @@ export class ASTVisitors {
             extractedKeys.forEach(extractedKey => this.generatePluralKeysForTrans(extractedKey.key, extractedKey.defaultValue, extractedKey.ns, isOrdinal, optionsNode))
           }
         } else if (contextExpression) {
-          const contextValues = this.resolvePossibleStringValues(contextExpression)
+          const contextValues = this.resolvePossibleContextStringValues(contextExpression)
           const contextSeparator = this.config.extract.contextSeparator ?? '_'
 
           if (contextValues.length > 0) {
@@ -963,13 +1079,48 @@ export class ASTVisitors {
     return null
   }
 
+  /**
+   * Resolves an expression to one or more possible context string values that can be
+   * determined statically from the AST. This is a wrapper around the plugin hook
+   * `extractContextFromExpression` and {@link resolvePossibleStringValuesFromExpression}.
+   *
+   * @param expression - The SWC AST expression node to resolve
+   * @returns An array of possible context string values that the expression may produce.
+   *
+   * @private
+   */
+  private resolvePossibleContextStringValues (expression: Expression) {
+    const strings = this.hooks.resolvePossibleContextStringValues?.(expression) ?? []
+
+    return [...strings, ...this.resolvePossibleStringValuesFromExpression(expression)]
+  }
+
+  /**
+   * Resolves an expression to one or more possible key string values that can be
+   * determined statically from the AST. This is a wrapper around the plugin hook
+   * `extractKeysFromExpression` and {@link resolvePossibleStringValuesFromExpression}.
+   *
+   * @param expression - The SWC AST expression node to resolve
+   * @returns An array of possible key string values that the expression may produce.
+   *
+   * @private
+   */
+  private resolvePossibleKeyStringValues (expression: Expression) {
+    const strings = this.hooks.resolvePossibleKeyStringValues?.(expression) ?? []
+
+    return [...strings, ...this.resolvePossibleStringValuesFromExpression(expression)]
+  }
+
   /**
    * Resolves an expression to one or more possible string values that can be
    * determined statically from the AST.
    *
    * Supports:
    * - StringLiteral -> single value (filtered to exclude empty strings for context)
+   * - NumericLiteral -> single value
+   * - BooleanLiteral -> single value
    * - ConditionalExpression (ternary) -> union of consequent and alternate resolved values
+   * - TemplateLiteral -> union of all possible string values
    * - The identifier `undefined` -> empty array
    *
    * For any other expression types (identifiers, function calls, member expressions,
@@ -980,15 +1131,15 @@ export class ASTVisitors {
    * @param returnEmptyStrings - Whether to include empty strings in the result
    * @returns An array of possible string values that the expression may produce.
    */
-  private resolvePossibleStringValues (expression: Expression, returnEmptyStrings = false): string[] {
+  private resolvePossibleStringValuesFromExpression (expression: Expression, returnEmptyStrings = false): string[] {
     if (expression.type === 'StringLiteral') {
       // Filter out empty strings as they should be treated as "no context" like i18next does
       return expression.value || returnEmptyStrings ? [expression.value] : []
     }
 
     if (expression.type === 'ConditionalExpression') { // This is a ternary operator
-      const consequentValues = this.resolvePossibleStringValues(expression.consequent, returnEmptyStrings)
-      const alternateValues = this.resolvePossibleStringValues(expression.alternate, returnEmptyStrings)
+      const consequentValues = this.resolvePossibleStringValuesFromExpression(expression.consequent, returnEmptyStrings)
+      const alternateValues = this.resolvePossibleStringValuesFromExpression(expression.alternate, returnEmptyStrings)
       return [...consequentValues, ...alternateValues]
     }
 
@@ -1030,7 +1181,7 @@ export class ASTVisitors {
       (heads, expression, i) => {
         return heads.flatMap((head) => {
           const tail = tails[i]?.cooked ?? ''
-          return this.resolvePossibleStringValues(expression, true).map(
+          return this.resolvePossibleStringValuesFromExpression(expression, true).map(
             (expressionValue) => `${head}${expressionValue}${tail}`
           )
         })

package/src/extractor/parsers/comment-parser.ts

@@ -43,6 +43,8 @@ export function extractKeysFromComments (
       const remainder = text.slice(match.index + match[0].length)
 
       const defaultValue = parseDefaultValueFromComment(remainder)
+      const context = parseContextFromComment(remainder)
+      const count = parseCountFromComment(remainder)
 
       // 1. Check for namespace in options object first (e.g., { ns: 'common' })
       ns = parseNsFromComment(remainder)
@@ -55,7 +57,7 @@ export function extractKeysFromComments (
         key = parts.join(nsSeparator)
       }
 
-      // 3. NEW: If no explicit namespace found, try to resolve from scope
+      // 3. If no explicit namespace found, try to resolve from scope
       // This allows commented t() calls to inherit namespace from useTranslation scope
       if (!ns && scopeResolver) {
         const scopeInfo = scopeResolver('t')
@@ -67,11 +69,89 @@ export function extractKeysFromComments (
       // 4. Final fallback to configured default namespace
       if (!ns) ns = config.extract.defaultNS
 
-      pluginContext.addKey({ key, ns, defaultValue: defaultValue ?? key })
+      // 5. Handle context and count combinations
+      if (context && count) {
+        // Generate all combinations: base plural + context+plural
+        generatePluralKeys(key, defaultValue ?? key, ns, pluginContext, config)
+        generateContextPluralKeys(key, defaultValue ?? key, ns, context, pluginContext, config)
+      } else if (context) {
+        // Just context variants
+        pluginContext.addKey({ key, ns, defaultValue: defaultValue ?? key })
+        pluginContext.addKey({ key: `${key}_${context}`, ns, defaultValue: defaultValue ?? key })
+      } else if (count) {
+        // Just plural variants
+        generatePluralKeys(key, defaultValue ?? key, ns, pluginContext, config)
+      } else {
+        // Simple key
+        pluginContext.addKey({ key, ns, defaultValue: defaultValue ?? key })
+      }
     }
   }
 }
 
+/**
+ * Generates plural keys for a given base key
+ */
+function generatePluralKeys (
+  key: string,
+  defaultValue: string,
+  ns: string | undefined,
+  pluginContext: PluginContext,
+  config: I18nextToolkitConfig
+): void {
+  const primaryLanguage = config.extract.primaryLanguage || config.locales[0] || 'en'
+  const pluralRules = new Intl.PluralRules(primaryLanguage)
+
+  // Get all possible plural categories for the primary language
+  const testNumbers = [0, 1, 2, 3, 5, 100] // Test various numbers to find all categories
+  const categories = new Set<string>()
+
+  for (const num of testNumbers) {
+    categories.add(pluralRules.select(num))
+  }
+
+  // Generate keys for each plural category
+  for (const category of categories) {
+    pluginContext.addKey({
+      key: `${key}_${category}`,
+      ns,
+      defaultValue
+    })
+  }
+}
+
+/**
+ * Generates context + plural combination keys
+ */
+function generateContextPluralKeys (
+  key: string,
+  defaultValue: string,
+  ns: string | undefined,
+  context: string,
+  pluginContext: PluginContext,
+  config: I18nextToolkitConfig
+): void {
+  const primaryLanguage = config.extract.primaryLanguage || config.locales[0] || 'en'
+  const pluralRules = new Intl.PluralRules(primaryLanguage)
+
+  // Get all possible plural categories for the primary language
+  const testNumbers = [0, 1, 2, 3, 5, 100]
+  const categories = new Set<string>()
+
+  for (const num of testNumbers) {
+    categories.add(pluralRules.select(num))
+  }
+
+  // Generate keys for each context + plural combination
+  for (const category of categories) {
+    pluginContext.addKey({
+      key: `${key}_${context}_${category}`,
+      ns,
+      defaultValue
+    })
+  }
+}
+
 /**
  * Parses default value from the remainder of a comment after a translation function call.
  * Supports both string literals and object syntax with defaultValue property.
@@ -136,3 +216,37 @@ function collectCommentTexts (src: string): string[] {
 
   return texts
 }
+
+/**
+ * Parses context from the remainder of a comment after a translation function call.
+ * Looks for context specified in options object syntax.
+ *
+ * @param remainder - The remaining text after the translation key
+ * @returns The parsed context value or undefined if none found
+ *
+ * @internal
+ */
+function parseContextFromComment (remainder: string): string | undefined {
+  // Look for context in an options object, e.g., { context: 'male' }
+  const contextObj = /^\s*,\s*\{[^}]*context\s*:\s*(['"])(.*?)\1/.exec(remainder)
+  if (contextObj) return contextObj[2]
+
+  return undefined
+}
+
+/**
+ * Parses count from the remainder of a comment after a translation function call.
+ * Looks for count specified in options object syntax.
+ *
+ * @param remainder - The remaining text after the translation key
+ * @returns The parsed count value or undefined if none found
+ *
+ * @internal
+ */
+function parseCountFromComment (remainder: string): number | undefined {
+  // Look for count in an options object, e.g., { count: 1 }
+  const countObj = /^\s*,\s*\{[^}]*count\s*:\s*(\d+)/.exec(remainder)
+  if (countObj) return parseInt(countObj[1], 10)
+
+  return undefined
+}