i18next-cli 1.10.1 → 1.10.2

package/src/extractor/parsers/expression-resolver.ts

@@ -0,0 +1,178 @@
+import type { Expression, TsType, TemplateLiteral, TsTemplateLiteralType } from '@swc/core'
+import type { ASTVisitorHooks } from '../../types'
+
+export class ExpressionResolver {
+  private hooks: ASTVisitorHooks
+
+  constructor (hooks: ASTVisitorHooks) {
+    this.hooks = hooks
+  }
+
+  /**
+   * 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.
+   */
+  resolvePossibleContextStringValues (expression: Expression): string[] {
+    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.
+   */
+  resolvePossibleKeyStringValues (expression: Expression): string[] {
+    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,
+   * etc.) the value cannot be determined statically and an empty array is returned.
+   *
+   * @param expression - The SWC AST expression node to resolve
+   * @param returnEmptyStrings - Whether to include empty strings in the result
+   * @returns An array of possible string values that the expression may produce.
+   */
+  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.resolvePossibleStringValuesFromExpression(expression.consequent, returnEmptyStrings)
+      const alternateValues = this.resolvePossibleStringValuesFromExpression(expression.alternate, returnEmptyStrings)
+      return [...consequentValues, ...alternateValues]
+    }
+
+    if (expression.type === 'Identifier' && expression.value === 'undefined') {
+      return [] // Handle the `undefined` case
+    }
+
+    if (expression.type === 'TemplateLiteral') {
+      return this.resolvePossibleStringValuesFromTemplateString(expression)
+    }
+
+    if (expression.type === 'NumericLiteral' || expression.type === 'BooleanLiteral') {
+      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 string to one or more possible strings that can be
+   * determined statically from the AST.
+   *
+   * @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
+    if (templateString.quasis.length === 1 && templateString.expressions.length === 0) {
+      // Ex. `translation.key.no.substitution`
+      return [templateString.quasis[0].cooked || '']
+    }
+
+    // Ex. `translation.key.with.expression.${x ? 'title' : 'description'}`
+    const [firstQuasis, ...tails] = templateString.quasis
+
+    const stringValues = templateString.expressions.reduce(
+      (heads, expression, i) => {
+        return heads.flatMap((head) => {
+          const tail = tails[i]?.cooked ?? ''
+          return this.resolvePossibleStringValuesFromExpression(expression, true).map(
+            (expressionValue) => `${head}${expressionValue}${tail}`
+          )
+        })
+      },
+      [firstQuasis.cooked ?? '']
+    )
+
+    return stringValues
+  }
+
+  /**
+   * Resolves a template literal type to one or more possible strings that can be
+   * determined statically from the AST.
+   *
+   * @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
+  }
+}

package/src/extractor/parsers/jsx-handler.ts

@@ -0,0 +1,358 @@
+import type { JSXElement, ObjectExpression } from '@swc/core'
+import type { PluginContext, I18nextToolkitConfig, ExtractedKey } from '../../types'
+import { ExpressionResolver } from './expression-resolver'
+import { extractFromTransComponent } from './jsx-parser'
+import { getObjectPropValue } from './ast-utils'
+
+export class JSXHandler {
+  private config: Omit<I18nextToolkitConfig, 'plugins'>
+  private pluginContext: PluginContext
+  private expressionResolver: ExpressionResolver
+
+  constructor (
+    config: Omit<I18nextToolkitConfig, 'plugins'>,
+    pluginContext: PluginContext,
+    expressionResolver: ExpressionResolver
+  ) {
+    this.config = config
+    this.pluginContext = pluginContext
+    this.expressionResolver = expressionResolver
+  }
+
+  /**
+   * Processes JSX elements to extract translation keys from Trans components.
+   *
+   * Identifies configured Trans components and delegates to the JSX parser
+   * for complex children serialization and attribute extraction.
+   *
+   * @param node - JSX element node to process
+   * @param getScopeInfo - Function to retrieve scope information for variables
+   */
+  handleJSXElement (node: JSXElement, getScopeInfo: (name: string) => { defaultNs?: string; keyPrefix?: string } | undefined): void {
+    const elementName = this.getElementName(node)
+
+    if (elementName && (this.config.extract.transComponents || ['Trans']).includes(elementName)) {
+      const extractedAttributes = extractFromTransComponent(node, this.config)
+
+      const keysToProcess: string[] = []
+
+      if (extractedAttributes) {
+        if (extractedAttributes.keyExpression) {
+          const keyValues = this.expressionResolver.resolvePossibleKeyStringValues(extractedAttributes.keyExpression)
+          keysToProcess.push(...keyValues)
+        } else {
+          keysToProcess.push(extractedAttributes.serializedChildren)
+        }
+
+        let extractedKeys: ExtractedKey[]
+
+        const { contextExpression, optionsNode, defaultValue, hasCount, isOrdinal, serializedChildren } = extractedAttributes
+
+        // If ns is not explicitly set on the component, try to find it from the key
+        // or the `t` prop
+        if (!extractedAttributes.ns) {
+          extractedKeys = keysToProcess.map(key => {
+            const nsSeparator = this.config.extract.nsSeparator ?? ':'
+            let ns: string | undefined
+
+            // If the key contains a namespace separator, it takes precedence
+            // over the default t ns value
+            if (nsSeparator && key.includes(nsSeparator)) {
+              let parts: string[]
+              ([ns, ...parts] = key.split(nsSeparator))
+
+              key = parts.join(nsSeparator)
+            }
+
+            return {
+              key,
+              ns,
+              defaultValue: defaultValue || serializedChildren,
+              hasCount,
+              isOrdinal,
+            }
+          })
+
+          const tProp = node.opening.attributes?.find(
+            attr =>
+              attr.type === 'JSXAttribute' &&
+              attr.name.type === 'Identifier' &&
+              attr.name.value === 't'
+          )
+
+          // Check if the prop value is an identifier (e.g., t={t})
+          if (
+            tProp?.type === 'JSXAttribute' &&
+            tProp.value?.type === 'JSXExpressionContainer' &&
+            tProp.value.expression.type === 'Identifier'
+          ) {
+            const tIdentifier = tProp.value.expression.value
+            const scopeInfo = getScopeInfo(tIdentifier)
+            if (scopeInfo?.defaultNs) {
+              extractedKeys.forEach(key => {
+                if (!key.ns) {
+                  key.ns = scopeInfo.defaultNs
+                }
+              })
+            }
+          }
+        } else {
+          const { ns } = extractedAttributes
+          extractedKeys = keysToProcess.map(key => {
+            return {
+              key,
+              ns,
+              defaultValue: defaultValue || serializedChildren,
+              hasCount,
+              isOrdinal,
+            }
+          })
+        }
+
+        extractedKeys.forEach(key => {
+          // Apply defaultNS from config if no namespace was found on the component and
+          // the key does not contain a namespace prefix
+          if (!key.ns) {
+            key.ns = this.config.extract.defaultNS
+          }
+        })
+
+        // Handle the combination of context and count
+        if (contextExpression && hasCount) {
+          // 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.expressionResolver.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 {
+            // 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.expressionResolver.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.expressionResolver.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 })
+              }
+            }
+            // 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(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) {
+          // 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))
+          }
+        } else {
+          // No count or context - just add the base keys
+          extractedKeys.forEach(extractedKey => {
+            this.pluginContext.addKey({
+              key: extractedKey.key,
+              ns: extractedKey.ns,
+              defaultValue: extractedKey.defaultValue
+            })
+          })
+        }
+      }
+    }
+  }
+
+  /**
+   * Generates plural keys for Trans components, with support for tOptions plural defaults.
+   *
+   * @param key - Base key name for pluralization
+   * @param defaultValue - Default value for the keys
+   * @param ns - Namespace for the keys
+   * @param isOrdinal - Whether to generate ordinal plural forms
+   * @param optionsNode - Optional tOptions object expression for plural-specific defaults
+   */
+  private generatePluralKeysForTrans (key: string, defaultValue: string | undefined, ns: string | undefined, isOrdinal: boolean, optionsNode?: ObjectExpression): void {
+    try {
+      const type = isOrdinal ? 'ordinal' : 'cardinal'
+      const pluralCategories = new Intl.PluralRules(this.config.extract?.primaryLanguage, { type }).resolvedOptions().pluralCategories
+      const pluralSeparator = this.config.extract.pluralSeparator ?? '_'
+
+      // Get plural-specific default values from tOptions if available
+      let otherDefault: string | undefined
+      let ordinalOtherDefault: string | undefined
+
+      if (optionsNode) {
+        otherDefault = getObjectPropValue(optionsNode, `defaultValue${pluralSeparator}other`) as string | undefined
+        ordinalOtherDefault = getObjectPropValue(optionsNode, `defaultValue${pluralSeparator}ordinal${pluralSeparator}other`) as string | undefined
+      }
+
+      for (const category of pluralCategories) {
+        // 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 = optionsNode ? getObjectPropValue(optionsNode, specificDefaultKey) as string | undefined : undefined
+
+        // Determine the final default value using a clear fallback chain
+        let finalDefaultValue: string | undefined
+        if (typeof specificDefault === 'string') {
+          // 1. Use the most specific default if it exists (e.g., defaultValue_one)
+          finalDefaultValue = specificDefault
+        } else if (category === 'one' && typeof defaultValue === 'string') {
+          // 2. SPECIAL CASE: The 'one' category falls back to the main default value (children content)
+          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 default value
+          finalDefaultValue = defaultValue
+        } else {
+          // 5. Final fallback to the base key itself
+          finalDefaultValue = key
+        }
+
+        const finalKey = isOrdinal
+          ? `${key}${pluralSeparator}ordinal${pluralSeparator}${category}`
+          : `${key}${pluralSeparator}${category}`
+
+        this.pluginContext.addKey({
+          key: finalKey,
+          ns,
+          defaultValue: finalDefaultValue,
+          hasCount: true,
+          isOrdinal
+        })
+      }
+    } catch (e) {
+      // Fallback to a simple key if Intl API fails
+      this.pluginContext.addKey({ key, ns, defaultValue })
+    }
+  }
+
+  /**
+   * Extracts element name from JSX opening tag.
+   *
+   * Handles both simple identifiers and member expressions:
+   * - `<Trans>` → 'Trans'
+   * - `<React.Trans>` → 'React.Trans'
+   *
+   * @param node - JSX element node
+   * @returns Element name or undefined if not extractable
+   */
+  private getElementName (node: JSXElement): string | undefined {
+    if (node.opening.name.type === 'Identifier') {
+      return node.opening.name.value
+    } else if (node.opening.name.type === 'JSXMemberExpression') {
+      let curr: any = node.opening.name
+      const names: string[] = []
+      while (curr.type === 'JSXMemberExpression') {
+        if (curr.property.type === 'Identifier') names.unshift(curr.property.value)
+        curr = curr.object
+      }
+      if (curr.type === 'Identifier') names.unshift(curr.value)
+      return names.join('.')
+    }
+    return undefined
+  }
+}