i18next-cli 1.8.0 → 1.10.0

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

@@ -1,4 +1,4 @@
-import type { Module, Node, CallExpression, VariableDeclarator, JSXElement, ArrowFunctionExpression, ObjectExpression, Expression, TemplateLiteral } from '@swc/core'
+import type { Module, Node, CallExpression, VariableDeclarator, JSXElement, ArrowFunctionExpression, ObjectExpression, Expression, TemplateLiteral, TsType, TsTemplateLiteralType } from '@swc/core'
 import type { PluginContext, I18nextToolkitConfig, Logger, ExtractedKey, ScopeInfo } from '../../types'
 import { extractFromTransComponent } from './jsx-parser'
 import { getObjectProperty, getObjectPropValue } from './ast-utils'
@@ -547,15 +547,44 @@ export class ASTVisitors {
         const parts = key.split(nsSeparator)
         ns = parts.shift()
         key = parts.join(nsSeparator)
+
+        if (!key || key.trim() === '') {
+          this.logger.warn(`Skipping key that became empty after namespace removal: '${ns}${nsSeparator}'`)
+          continue
+        }
       }
 
       if (!ns && scopeInfo?.defaultNs) ns = scopeInfo.defaultNs
       if (!ns) ns = this.config.extract.defaultNS
 
       let finalKey = key
+
+      // Apply keyPrefix AFTER namespace extraction
       if (scopeInfo?.keyPrefix) {
         const keySeparator = this.config.extract.keySeparator ?? '.'
-        finalKey = `${scopeInfo.keyPrefix}${keySeparator}${key}`
+
+        // Apply keyPrefix - handle case where keyPrefix already ends with separator
+        if (keySeparator !== false) {
+          if (scopeInfo.keyPrefix.endsWith(keySeparator)) {
+            finalKey = `${scopeInfo.keyPrefix}${key}`
+          } else {
+            finalKey = `${scopeInfo.keyPrefix}${keySeparator}${key}`
+          }
+        } else {
+          finalKey = `${scopeInfo.keyPrefix}${key}`
+        }
+
+        // Validate keyPrefix combinations that create problematic keys
+        if (keySeparator !== false) {
+          // Check for patterns that would create empty segments in the nested key structure
+          const segments = finalKey.split(keySeparator)
+          const hasEmptySegment = segments.some(segment => segment.trim() === '')
+
+          if (hasEmptySegment) {
+            this.logger.warn(`Skipping key with empty segments: '${finalKey}' (keyPrefix: '${scopeInfo.keyPrefix}', key: '${key}')`)
+            continue
+          }
+        }
       }
 
       const isLastKey = i === keysToProcess.length - 1
@@ -594,14 +623,19 @@ export class ASTVisitors {
         const hasCount = getObjectPropValue(options, 'count') !== undefined
         const isOrdinalByOption = getObjectPropValue(options, 'ordinal') === true
         if (hasCount || isOrdinalByKey) {
-          // If we have keys with context pluralize them
-          if (keysWithContext.length > 0) {
-            for (const { key, ns } of keysWithContext) {
-              // Pass the combined ordinal flag and the default value to the handler
-              this.handlePluralKeys(key, ns, options, isOrdinalByOption || isOrdinalByKey, finalDefaultValue)
+          // Check if plurals are disabled
+          if (this.config.extract.disablePlurals) {
+            // When plurals are disabled, treat count as a regular option (for interpolation only)
+            // Still handle context normally
+            if (keysWithContext.length > 0) {
+              keysWithContext.forEach(this.pluginContext.addKey)
+            } else {
+              // No context, just add the base key (no plurals even if count is present)
+              this.pluginContext.addKey({ key: finalKey, ns, defaultValue: dv })
             }
           } else {
-            // Otherwise pluralize the base key
+            // Original plural handling logic when plurals are enabled
+            // Always pass the base key to handlePluralKeys - it will handle context internally
             this.handlePluralKeys(finalKey, ns, options, isOrdinalByOption || isOrdinalByKey, finalDefaultValue)
           }
 
@@ -687,7 +721,23 @@ export class ASTVisitors {
     try {
       const type = isOrdinal ? 'ordinal' : 'cardinal'
 
-      const pluralCategories = new Intl.PluralRules(this.config.extract?.primaryLanguage, { type }).resolvedOptions().pluralCategories
+      // Generate plural forms for ALL target languages to ensure we have all necessary keys
+      const allPluralCategories = new Set<string>()
+
+      for (const locale of this.config.locales) {
+        try {
+          const pluralRules = new Intl.PluralRules(locale, { type })
+          const categories = pluralRules.resolvedOptions().pluralCategories
+          categories.forEach(cat => allPluralCategories.add(cat))
+        } catch (e) {
+          // If a locale is invalid, fall back to English rules
+          const englishRules = new Intl.PluralRules('en', { type })
+          const categories = englishRules.resolvedOptions().pluralCategories
+          categories.forEach(cat => allPluralCategories.add(cat))
+        }
+      }
+
+      const pluralCategories = Array.from(allPluralCategories).sort()
       const pluralSeparator = this.config.extract.pluralSeparator ?? '_'
 
       // Get all possible default values once at the start
@@ -709,49 +759,82 @@ export class ASTVisitors {
         }
       }
 
-      for (const category of pluralCategories) {
-        // 1. Look for the most specific default value (e.g., defaultValue_ordinal_one)
-        const specificDefaultKey = isOrdinal ? `defaultValue${pluralSeparator}ordinal${pluralSeparator}${category}` : `defaultValue${pluralSeparator}${category}`
-        const specificDefault = getObjectPropValue(options, specificDefaultKey)
+      // Handle context - both static and dynamic
+      const contextProp = getObjectProperty(options, 'context')
+      const keysToGenerate: Array<{ key: string, context?: string }> = []
 
-        // 2. Determine the final default value using a clear fallback chain
-        let finalDefaultValue: string | undefined
-        if (typeof specificDefault === 'string') {
-          // 1. HIGHEST PRIORITY: Use the most specific default if it exists (e.g., defaultValue_few)
-          finalDefaultValue = specificDefault
-        } else if (category === 'one' && typeof defaultValue === 'string') {
-          // 2. SPECIAL CASE: The 'one' category falls back to the main 'defaultValue' prop
-          finalDefaultValue = defaultValue
-        } else if (isOrdinal && typeof ordinalOtherDefault === 'string') {
-          // 3a. Other ordinal categories fall back to 'defaultValue_ordinal_other'
-          finalDefaultValue = ordinalOtherDefault
-        } else if (!isOrdinal && typeof otherDefault === 'string') {
-          // 3b. Other cardinal categories fall back to 'defaultValue_other'
-          finalDefaultValue = otherDefault
-        } else if (typeof defaultValue === 'string') {
-          // 4. If no '_other' is found, all categories can fall back to the main 'defaultValue'
-          finalDefaultValue = defaultValue
-        } else if (defaultValueFromCall && targetCategory === category) {
-          // 5. LOWER PRIORITY: If we have a default value from the t() call and this category matches the count,
-          //    use the default value from the call (only if no other defaults exist)
-          finalDefaultValue = defaultValueFromCall
+      if (contextProp?.value) {
+        // Handle dynamic context by resolving all possible values
+        const contextValues = this.resolvePossibleContextStringValues(contextProp.value)
+
+        if (contextValues.length > 0) {
+          // Generate keys for each context value
+          for (const contextValue of contextValues) {
+            if (contextValue.length > 0) { // Skip empty contexts
+              keysToGenerate.push({ key, context: contextValue })
+            }
+          }
+
+          // For dynamic context, also generate base plural forms if generateBasePluralForms is not disabled
+          const shouldGenerateBaseForms = this.config.extract?.generateBasePluralForms !== false
+          if (shouldGenerateBaseForms) {
+            keysToGenerate.push({ key })
+          }
         } else {
-          // 6. Final fallback to the base key itself
-          finalDefaultValue = key
+          // Couldn't resolve context, fall back to base key only
+          keysToGenerate.push({ key })
         }
+      } else {
+        // No context, always generate base plural forms
+        keysToGenerate.push({ key })
+      }
 
-        // 3. Construct the final plural key
-        const finalKey = isOrdinal
-          ? `${key}${pluralSeparator}ordinal${pluralSeparator}${category}`
-          : `${key}${pluralSeparator}${category}`
+      // Generate plural forms for each key variant
+      for (const { key: baseKey, context } of keysToGenerate) {
+        for (const category of pluralCategories) {
+          // 1. Look for the most specific default value
+          const specificDefaultKey = isOrdinal ? `defaultValue${pluralSeparator}ordinal${pluralSeparator}${category}` : `defaultValue${pluralSeparator}${category}`
+          const specificDefault = getObjectPropValue(options, specificDefaultKey)
+
+          // 2. Determine the final default value using a clear fallback chain
+          let finalDefaultValue: string | undefined
+          if (typeof specificDefault === 'string') {
+            finalDefaultValue = specificDefault
+          } else if (category === 'one' && typeof defaultValue === 'string') {
+            finalDefaultValue = defaultValue
+          } else if (isOrdinal && typeof ordinalOtherDefault === 'string') {
+            finalDefaultValue = ordinalOtherDefault
+          } else if (!isOrdinal && typeof otherDefault === 'string') {
+            finalDefaultValue = otherDefault
+          } else if (typeof defaultValue === 'string') {
+            finalDefaultValue = defaultValue
+          } else if (defaultValueFromCall && targetCategory === category) {
+            finalDefaultValue = defaultValueFromCall
+          } else {
+            finalDefaultValue = baseKey
+          }
 
-        this.pluginContext.addKey({
-          key: finalKey,
-          ns,
-          defaultValue: finalDefaultValue,
-          hasCount: true,
-          isOrdinal
-        })
+          // 3. Construct the final plural key
+          let finalKey: string
+          if (context) {
+            const contextSeparator = this.config.extract.contextSeparator ?? '_'
+            finalKey = isOrdinal
+              ? `${baseKey}${contextSeparator}${context}${pluralSeparator}ordinal${pluralSeparator}${category}`
+              : `${baseKey}${contextSeparator}${context}${pluralSeparator}${category}`
+          } else {
+            finalKey = isOrdinal
+              ? `${baseKey}${pluralSeparator}ordinal${pluralSeparator}${category}`
+              : `${baseKey}${pluralSeparator}${category}`
+          }
+
+          this.pluginContext.addKey({
+            key: finalKey,
+            ns,
+            defaultValue: finalDefaultValue,
+            hasCount: true,
+            isOrdinal
+          })
+        }
       }
     } catch (e) {
       this.logger.warn(`Could not determine plural rules for language "${this.config.extract?.primaryLanguage}". Falling back to simple key extraction.`)
@@ -862,39 +945,85 @@ export class ASTVisitors {
 
         // Handle the combination of context and count
         if (contextExpression && hasCount) {
-          // Find isOrdinal prop on the <Trans> component
-          const ordinalAttr = node.opening.attributes?.find(
-            (attr) =>
-              attr.type === 'JSXAttribute' &&
-              attr.name.type === 'Identifier' &&
-              attr.name.value === 'ordinal'
-          )
-          const isOrdinal = !!ordinalAttr
-
-          const contextValues = this.resolvePossibleContextStringValues(contextExpression)
-          const contextSeparator = this.config.extract.contextSeparator ?? '_'
-
-          // Generate all combinations of context and plural forms
-          if (contextValues.length > 0) {
-            // Generate base plural forms (no context)
-            extractedKeys.forEach(extractedKey => this.generatePluralKeysForTrans(extractedKey.key, extractedKey.defaultValue, extractedKey.ns, isOrdinal, optionsNode))
-
-            // Generate context + plural combinations
-            for (const context of contextValues) {
-              for (const extractedKey of extractedKeys) {
-                const contextKey = `${extractedKey.key}${contextSeparator}${context}`
-                this.generatePluralKeysForTrans(contextKey, extractedKey.defaultValue, extractedKey.ns, isOrdinal, optionsNode)
+          // Check if plurals are disabled
+          if (this.config.extract.disablePlurals) {
+            // When plurals are disabled, treat count as a regular option
+            // Still handle context normally
+            const contextValues = this.resolvePossibleContextStringValues(contextExpression)
+            const contextSeparator = this.config.extract.contextSeparator ?? '_'
+
+            if (contextValues.length > 0) {
+              // For static context (string literal), only add context variants
+              if (contextExpression.type === 'StringLiteral') {
+                for (const context of contextValues) {
+                  for (const extractedKey of extractedKeys) {
+                    const contextKey = `${extractedKey.key}${contextSeparator}${context}`
+                    this.pluginContext.addKey({ key: contextKey, ns: extractedKey.ns, defaultValue: extractedKey.defaultValue })
+                  }
+                }
+              } else {
+                // For dynamic context, add both base and context variants
+                extractedKeys.forEach(extractedKey => {
+                  this.pluginContext.addKey({
+                    key: extractedKey.key,
+                    ns: extractedKey.ns,
+                    defaultValue: extractedKey.defaultValue
+                  })
+                })
+                for (const context of contextValues) {
+                  for (const extractedKey of extractedKeys) {
+                    const contextKey = `${extractedKey.key}${contextSeparator}${context}`
+                    this.pluginContext.addKey({ key: contextKey, ns: extractedKey.ns, defaultValue: extractedKey.defaultValue })
+                  }
+                }
               }
+            } else {
+              // Fallback to just base keys if context resolution fails
+              extractedKeys.forEach(extractedKey => {
+                this.pluginContext.addKey({
+                  key: extractedKey.key,
+                  ns: extractedKey.ns,
+                  defaultValue: extractedKey.defaultValue
+                })
+              })
             }
           } else {
-            // Fallback to just plural forms if context resolution fails
-            extractedKeys.forEach(extractedKey => this.generatePluralKeysForTrans(extractedKey.key, extractedKey.defaultValue, extractedKey.ns, isOrdinal, optionsNode))
+            // Original plural handling logic when plurals are enabled
+            // Find isOrdinal prop on the <Trans> component
+            const ordinalAttr = node.opening.attributes?.find(
+              (attr) =>
+                attr.type === 'JSXAttribute' &&
+                attr.name.type === 'Identifier' &&
+                attr.name.value === 'ordinal'
+            )
+            const isOrdinal = !!ordinalAttr
+
+            const contextValues = this.resolvePossibleContextStringValues(contextExpression)
+            const contextSeparator = this.config.extract.contextSeparator ?? '_'
+
+            // Generate all combinations of context and plural forms
+            if (contextValues.length > 0) {
+              // Generate base plural forms (no context)
+              extractedKeys.forEach(extractedKey => this.generatePluralKeysForTrans(extractedKey.key, extractedKey.defaultValue, extractedKey.ns, isOrdinal, optionsNode))
+
+              // Generate context + plural combinations
+              for (const context of contextValues) {
+                for (const extractedKey of extractedKeys) {
+                  const contextKey = `${extractedKey.key}${contextSeparator}${context}`
+                  this.generatePluralKeysForTrans(contextKey, extractedKey.defaultValue, extractedKey.ns, isOrdinal, optionsNode)
+                }
+              }
+            } else {
+              // Fallback to just plural forms if context resolution fails
+              extractedKeys.forEach(extractedKey => this.generatePluralKeysForTrans(extractedKey.key, extractedKey.defaultValue, extractedKey.ns, isOrdinal, optionsNode))
+            }
           }
         } else if (contextExpression) {
           const contextValues = this.resolvePossibleContextStringValues(contextExpression)
           const contextSeparator = this.config.extract.contextSeparator ?? '_'
 
           if (contextValues.length > 0) {
+            // Add context variants
             for (const context of contextValues) {
               for (const { key, ns, defaultValue } of extractedKeys) {
                 this.pluginContext.addKey({ key: `${key}${contextSeparator}${context}`, ns, defaultValue })
@@ -902,22 +1031,57 @@ export class ASTVisitors {
             }
             // Only add the base key as a fallback if the context is dynamic (i.e., not a simple string).
             if (contextExpression.type !== 'StringLiteral') {
-              extractedKeys.forEach(this.pluginContext.addKey)
+              extractedKeys.forEach(extractedKey => {
+                this.pluginContext.addKey({
+                  key: extractedKey.key,
+                  ns: extractedKey.ns,
+                  defaultValue: extractedKey.defaultValue
+                })
+              })
             }
+          } else {
+            // If no context values were resolved, just add base keys
+            extractedKeys.forEach(extractedKey => {
+              this.pluginContext.addKey({
+                key: extractedKey.key,
+                ns: extractedKey.ns,
+                defaultValue: extractedKey.defaultValue
+              })
+            })
           }
         } else if (hasCount) {
-          // Find isOrdinal prop on the <Trans> component
-          const ordinalAttr = node.opening.attributes?.find(
-            (attr) =>
-              attr.type === 'JSXAttribute' &&
-              attr.name.type === 'Identifier' &&
-              attr.name.value === 'ordinal'
-          )
-          const isOrdinal = !!ordinalAttr
+          // Check if plurals are disabled
+          if (this.config.extract.disablePlurals) {
+            // When plurals are disabled, just add the base keys (no plural forms)
+            extractedKeys.forEach(extractedKey => {
+              this.pluginContext.addKey({
+                key: extractedKey.key,
+                ns: extractedKey.ns,
+                defaultValue: extractedKey.defaultValue
+              })
+            })
+          } else {
+            // Original plural handling logic when plurals are enabled
+            // Find isOrdinal prop on the <Trans> component
+            const ordinalAttr = node.opening.attributes?.find(
+              (attr) =>
+                attr.type === 'JSXAttribute' &&
+                attr.name.type === 'Identifier' &&
+                attr.name.value === 'ordinal'
+            )
+            const isOrdinal = !!ordinalAttr
 
-          extractedKeys.forEach(extractedKey => this.generatePluralKeysForTrans(extractedKey.key, extractedKey.defaultValue, extractedKey.ns, isOrdinal, optionsNode))
+            extractedKeys.forEach(extractedKey => this.generatePluralKeysForTrans(extractedKey.key, extractedKey.defaultValue, extractedKey.ns, isOrdinal, optionsNode))
+          }
         } else {
-          extractedKeys.forEach(this.pluginContext.addKey)
+          // No count or context - just add the base keys
+          extractedKeys.forEach(extractedKey => {
+            this.pluginContext.addKey({
+              key: extractedKey.key,
+              ns: extractedKey.ns,
+              defaultValue: extractedKey.defaultValue
+            })
+          })
         }
       }
     }
@@ -1158,17 +1322,49 @@ export class ASTVisitors {
       return [`${expression.value}`] // Handle literals like 5 or true
     }
 
+    // Support building translation keys for
+    // `variable satisfies 'coaching' | 'therapy'`
+    if (expression.type === 'TsSatisfiesExpression' || expression.type === 'TsAsExpression') {
+      const annotation = expression.typeAnnotation
+
+      return this.resolvePossibleStringValuesFromType(annotation, returnEmptyStrings)
+    }
+
+    // We can't statically determine the value of other expressions (e.g., variables, function calls)
+    return []
+  }
+
+  private resolvePossibleStringValuesFromType (type: TsType, returnEmptyStrings = false): string[] {
+    if (type.type === 'TsUnionType') {
+      return type.types.flatMap((t) => this.resolvePossibleStringValuesFromType(t, returnEmptyStrings))
+    }
+
+    if (type.type === 'TsLiteralType') {
+      if (type.literal.type === 'StringLiteral') {
+        // Filter out empty strings as they should be treated as "no context" like i18next does
+        return type.literal.value || returnEmptyStrings ? [type.literal.value] : []
+      }
+
+      if (type.literal.type === 'TemplateLiteral') {
+        return this.resolvePossibleStringValuesFromTemplateLiteralType(type.literal)
+      }
+
+      if (type.literal.type === 'NumericLiteral' || type.literal.type === 'BooleanLiteral') {
+        return [`${type.literal.value}`] // Handle literals like 5 or true
+      }
+    }
+
     // We can't statically determine the value of other expressions (e.g., variables, function calls)
     return []
   }
 
   /**
-   * Resolves a template literal to one or more possible string values that can be
+   * Resolves a template literal string to one or more possible strings that can be
    * determined statically from the AST.
    *
    * @private
-   * @param templateString - The SWC AST template literal node to resolve
-   * @returns An array of possible string values that the template literal may produce.
+   * @param templateString - The SWC AST template literal string to resolve
+   * @returns An array of possible string values that the template may produce.
    */
   private resolvePossibleStringValuesFromTemplateString (templateString: TemplateLiteral): string[] {
     // If there are no expressions, we can just return the cooked value
@@ -1177,7 +1373,7 @@ export class ASTVisitors {
       return [templateString.quasis[0].cooked || '']
     }
 
-    // Ex. `translation.key.with.expression.${x ? 'title' : 'description}`
+    // Ex. `translation.key.with.expression.${x ? 'title' : 'description'}`
     const [firstQuasis, ...tails] = templateString.quasis
 
     const stringValues = templateString.expressions.reduce(
@@ -1195,6 +1391,39 @@ export class ASTVisitors {
     return stringValues
   }
 
+  /**
+   * Resolves a template literal type to one or more possible strings that can be
+   * determined statically from the AST.
+   *
+   * @private
+   * @param templateLiteralType - The SWC AST template literal type to resolve
+   * @returns An array of possible string values that the template may produce.
+   */
+  private resolvePossibleStringValuesFromTemplateLiteralType (templateLiteralType: TsTemplateLiteralType): string[] {
+    // If there are no types, we can just return the cooked value
+    if (templateLiteralType.quasis.length === 1 && templateLiteralType.types.length === 0) {
+      // Ex. `translation.key.no.substitution`
+      return [templateLiteralType.quasis[0].cooked || '']
+    }
+
+    // Ex. `translation.key.with.expression.${'title' | 'description'}`
+    const [firstQuasis, ...tails] = templateLiteralType.quasis
+
+    const stringValues = templateLiteralType.types.reduce(
+      (heads, type, i) => {
+        return heads.flatMap((head) => {
+          const tail = tails[i]?.cooked ?? ''
+          return this.resolvePossibleStringValuesFromType(type, true).map(
+            (expressionValue) => `${head}${expressionValue}${tail}`
+          )
+        })
+      },
+      [firstQuasis.cooked ?? '']
+    )
+
+    return stringValues
+  }
+
   /**
    * Finds the configuration for a given useTranslation function name.
    * Applies default argument positions if none are specified.

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

@@ -39,6 +39,12 @@ export function extractKeysFromComments (
     let match: RegExpExecArray | null
     while ((match = keyRegex.exec(text)) !== null) {
       let key = match[2]
+
+      // Validate that the key is not empty or whitespace-only
+      if (!key || key.trim() === '') {
+        continue // Skip empty keys
+      }
+
       let ns: string | undefined
       const remainder = text.slice(match.index + match[0].length)
 
@@ -54,6 +60,11 @@ export function extractKeysFromComments (
         isOrdinalByKey = true
         // Normalize the key by stripping the suffix
         key = key.slice(0, -(pluralSeparator.length + 7)) // Remove "_ordinal"
+
+        // Validate that the key is still not empty after normalization
+        if (!key || key.trim() === '') {
+          continue // Skip keys that become empty after normalization
+        }
       }
 
       const isOrdinal = ordinal === true || isOrdinalByKey
@@ -81,21 +92,38 @@ export function extractKeysFromComments (
       // 4. Final fallback to configured default namespace
       if (!ns) ns = config.extract.defaultNS
 
-      // 5. Handle context and count combinations
-      if (context && count) {
-        // Generate all combinations: base plural + context+plural
-        generatePluralKeys(key, defaultValue ?? key, ns, pluginContext, config, isOrdinal)
-        generateContextPluralKeys(key, defaultValue ?? key, ns, context, pluginContext, config, isOrdinal)
-      } 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, isOrdinal)
+      // 5. Handle context and count combinations based on disablePlurals setting
+      if (config.extract.disablePlurals) {
+        // When plurals are disabled, ignore count for key generation
+        if (context) {
+          // Only generate context variants (no base key when context is static)
+          pluginContext.addKey({ key: `${key}_${context}`, ns, defaultValue: defaultValue ?? key })
+        } else {
+          // Simple key (ignore count)
+          pluginContext.addKey({ key, ns, defaultValue: defaultValue ?? key })
+        }
       } else {
-        // Simple key
-        pluginContext.addKey({ key, ns, defaultValue: defaultValue ?? key })
+        // Original plural handling logic when plurals are enabled
+        if (context && count) {
+          // Generate context+plural combinations
+          generateContextPluralKeys(key, defaultValue ?? key, ns, context, pluginContext, config, isOrdinal)
+
+          // Only generate base plural forms if generateBasePluralForms is not disabled
+          const shouldGenerateBaseForms = config.extract?.generateBasePluralForms !== false
+          if (shouldGenerateBaseForms) {
+            generatePluralKeys(key, defaultValue ?? key, ns, pluginContext, config, isOrdinal)
+          }
+        } 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, isOrdinal)
+        } else {
+          // Simple key
+          pluginContext.addKey({ key, ns, defaultValue: defaultValue ?? key })
+        }
       }
     }
   }
@@ -114,8 +142,24 @@ function generatePluralKeys (
 ): void {
   try {
     const type = isOrdinal ? 'ordinal' : 'cardinal'
-    const primaryLanguage = config.extract.primaryLanguage || config.locales[0] || 'en'
-    const pluralCategories = new Intl.PluralRules(primaryLanguage, { type }).resolvedOptions().pluralCategories
+
+    // Generate plural forms for ALL target languages to ensure we have all necessary keys
+    const allPluralCategories = new Set<string>()
+
+    for (const locale of config.locales) {
+      try {
+        const pluralRules = new Intl.PluralRules(locale, { type })
+        const categories = pluralRules.resolvedOptions().pluralCategories
+        categories.forEach(cat => allPluralCategories.add(cat))
+      } catch (e) {
+        // If a locale is invalid, fall back to English rules
+        const englishRules = new Intl.PluralRules('en', { type })
+        const categories = englishRules.resolvedOptions().pluralCategories
+        categories.forEach(cat => allPluralCategories.add(cat))
+      }
+    }
+
+    const pluralCategories = Array.from(allPluralCategories).sort()
     const pluralSeparator = config.extract.pluralSeparator ?? '_'
 
     // Generate keys for each plural category
@@ -152,8 +196,24 @@ function generateContextPluralKeys (
 ): void {
   try {
     const type = isOrdinal ? 'ordinal' : 'cardinal'
-    const primaryLanguage = config.extract.primaryLanguage || config.locales[0] || 'en'
-    const pluralCategories = new Intl.PluralRules(primaryLanguage, { type }).resolvedOptions().pluralCategories
+
+    // Generate plural forms for ALL target languages to ensure we have all necessary keys
+    const allPluralCategories = new Set<string>()
+
+    for (const locale of config.locales) {
+      try {
+        const pluralRules = new Intl.PluralRules(locale, { type })
+        const categories = pluralRules.resolvedOptions().pluralCategories
+        categories.forEach(cat => allPluralCategories.add(cat))
+      } catch (e) {
+        // If a locale is invalid, fall back to English rules
+        const englishRules = new Intl.PluralRules(config.extract.primaryLanguage || 'en', { type })
+        const categories = englishRules.resolvedOptions().pluralCategories
+        categories.forEach(cat => allPluralCategories.add(cat))
+      }
+    }
+
+    const pluralCategories = Array.from(allPluralCategories).sort()
     const pluralSeparator = config.extract.pluralSeparator ?? '_'
 
     // Generate keys for each context + plural combination