i18next-cli 0.9.18 → 0.9.20

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

@@ -1,6 +1,7 @@
 import type { Module, Node, CallExpression, VariableDeclarator, JSXElement, ArrowFunctionExpression, ObjectExpression, Expression } from '@swc/core'
 import type { PluginContext, I18nextToolkitConfig, Logger } from '../../types'
 import { extractFromTransComponent } from './jsx-parser'
+import { getObjectProperty, getObjectPropValue } from './ast-utils'
 
 /**
  * Represents variable scope information tracked during AST traversal.
@@ -308,7 +309,7 @@ export class ASTVisitors {
     const optionsArg = callExpr.arguments?.[hookConfig.keyPrefixArg]?.expression
     let keyPrefix: string | undefined
     if (optionsArg?.type === 'ObjectExpression') {
-      const kp = this.getObjectPropValue(optionsArg, 'keyPrefix')
+      const kp = getObjectPropValue(optionsArg, 'keyPrefix')
       keyPrefix = typeof kp === 'string' ? kp : undefined
     }
 
@@ -374,7 +375,7 @@ export class ASTVisitors {
     if (!isFunctionToParse || node.arguments.length === 0) return
 
     const firstArg = node.arguments[0].expression
-    const keysToProcess: string[] = []
+    let keysToProcess: string[] = []
 
     if (firstArg.type === 'StringLiteral') {
       keysToProcess.push(firstArg.value)
@@ -390,8 +391,20 @@ export class ASTVisitors {
       }
     }
 
+    keysToProcess = keysToProcess.filter(key => !!key)
     if (keysToProcess.length === 0) return
 
+    let isOrdinalByKey = false
+    const pluralSeparator = this.config.extract.pluralSeparator ?? '_'
+
+    for (let i = 0; i < keysToProcess.length; i++) {
+      if (keysToProcess[i].endsWith(`${pluralSeparator}ordinal`)) {
+        isOrdinalByKey = true
+        // Normalize the key by stripping the suffix
+        keysToProcess[i] = keysToProcess[i].slice(0, -8)
+      }
+    }
+
     let defaultValue: string | undefined
     let options: ObjectExpression | undefined
 
@@ -409,7 +422,7 @@ export class ASTVisitors {
         options = arg3
       }
     }
-    const defaultValueFromOptions = options ? this.getObjectPropValue(options, 'defaultValue') : undefined
+    const defaultValueFromOptions = options ? getObjectPropValue(options, 'defaultValue') : undefined
     const finalDefaultValue = (typeof defaultValueFromOptions === 'string' ? defaultValueFromOptions : defaultValue)
 
     // Loop through each key found (could be one or more) and process it
@@ -419,7 +432,7 @@ export class ASTVisitors {
 
       // Determine namespace (explicit ns > scope ns > ns:key > default)
       if (options) {
-        const nsVal = this.getObjectPropValue(options, 'ns')
+        const nsVal = getObjectPropValue(options, 'ns')
         if (typeof nsVal === 'string') ns = nsVal
       }
       if (!ns && scopeInfo?.defaultNs) ns = scopeInfo.defaultNs
@@ -443,7 +456,7 @@ export class ASTVisitors {
 
       // Handle plurals, context, and returnObjects
       if (options) {
-        const contextProp = this.getObjectProperty(options, 'context')
+        const contextProp = getObjectProperty(options, 'context')
 
         // 1. Handle Dynamic Context (Ternary) first
         if (contextProp?.value?.type === 'ConditionalExpression') {
@@ -461,7 +474,7 @@ export class ASTVisitors {
         }
 
         // 2. Handle Static Context
-        const contextValue = this.getObjectPropValue(options, 'context')
+        const contextValue = getObjectPropValue(options, 'context')
         if (typeof contextValue === 'string' && contextValue) {
           const contextSeparator = this.config.extract.contextSeparator ?? '_'
           this.pluginContext.addKey({ key: `${finalKey}${contextSeparator}${contextValue}`, ns, defaultValue: dv })
@@ -469,13 +482,16 @@ export class ASTVisitors {
         }
 
         // 3. Handle Plurals
-        if (this.getObjectPropValue(options, 'count') !== undefined) {
-          this.handlePluralKeys(finalKey, ns, options)
+        const hasCount = getObjectPropValue(options, 'count') !== undefined
+        const isOrdinalByOption = getObjectPropValue(options, 'ordinal') === true
+        if (hasCount || isOrdinalByKey) {
+          // Pass the combined ordinal flag to the handler
+          this.handlePluralKeys(finalKey, ns, options, isOrdinalByOption || isOrdinalByKey)
           continue
         }
 
         // 4. Handle returnObjects
-        if (this.getObjectPropValue(options, 'returnObjects') === true) {
+        if (getObjectPropValue(options, 'returnObjects') === true) {
           this.objectKeys.add(finalKey)
           // Fall through to add the base key itself
         }
@@ -496,43 +512,50 @@ export class ASTVisitors {
    * @param key - Base key name for pluralization
    * @param ns - Namespace for the keys
    * @param options - object expression options
+   * @param isOrdinal - isOrdinal flag
    *
    * @private
    */
-  private handlePluralKeys (key: string, ns: string | undefined, options: ObjectExpression): void {
+  private handlePluralKeys (key: string, ns: string | undefined, options: ObjectExpression, isOrdinal: boolean): void {
     try {
-      const isOrdinal = this.getObjectPropValue(options, 'ordinal') === true
       const type = isOrdinal ? 'ordinal' : 'cardinal'
 
       const pluralCategories = new Intl.PluralRules(this.config.extract?.primaryLanguage, { type }).resolvedOptions().pluralCategories
       const pluralSeparator = this.config.extract.pluralSeparator ?? '_'
 
-      const defaultValue = this.getObjectPropValue(options, 'defaultValue')
-      const defaultValueOther = this.getObjectPropValue(options, 'defaultValue_other')
+      // Get all possible default values once at the start
+      const defaultValue = getObjectPropValue(options, 'defaultValue')
+      const otherDefault = getObjectPropValue(options, `defaultValue${pluralSeparator}other`)
+      const ordinalOtherDefault = getObjectPropValue(options, `defaultValue${pluralSeparator}ordinal${pluralSeparator}other`)
 
       for (const category of pluralCategories) {
-        // Construct the specific defaultValue key, e.g., `defaultValue_ordinal_one` or `defaultValue_one`
-        const specificDefaultKey = isOrdinal ? `defaultValue_ordinal_${category}` : `defaultValue_${category}`
-        const specificDefault = this.getObjectPropValue(options, specificDefaultKey)
+        // 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)
 
+        // 2. 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') {
-          // 'one' specifically falls back to the main `defaultValue` prop
+          // 2. SPECIAL CASE: The 'one' category falls back to the main 'defaultValue' prop
           finalDefaultValue = defaultValue
-        } else if (typeof defaultValueOther === 'string') {
-          // All other categories fall back to `defaultValue_other`
-          finalDefaultValue = defaultValueOther
+        } 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') {
-          // If all else fails, use the main `defaultValue` as a last resort
+          // 4. If no '_other' is found, all categories can fall back to the main 'defaultValue'
           finalDefaultValue = defaultValue
         } else {
-          finalDefaultValue = key // Fallback to the key itself
+          // 5. Final fallback to the base key itself
+          finalDefaultValue = key
         }
 
-        // Construct the final key, e.g., `key_ordinal_one` or `key_one`
+        // 3. Construct the final plural key
         const finalKey = isOrdinal
           ? `${key}${pluralSeparator}ordinal${pluralSeparator}${category}`
           : `${key}${pluralSeparator}${category}`
@@ -542,12 +565,13 @@ export class ASTVisitors {
           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.`)
       // Fallback to a simple key if Intl API fails
-      const defaultValue = this.getObjectPropValue(options, 'defaultValue')
+      const defaultValue = getObjectPropValue(options, 'defaultValue')
       this.pluginContext.addKey({ key, ns, defaultValue: typeof defaultValue === 'string' ? defaultValue : key })
     }
   }
@@ -595,20 +619,20 @@ export class ASTVisitors {
     if (elementName && (this.config.extract.transComponents || ['Trans']).includes(elementName)) {
       const extractedKey = extractFromTransComponent(node, this.config)
       if (extractedKey) {
-      // If ns is not explicitly set on the component, try to find it from the `t` prop
+        // If ns is not explicitly set on the component, try to find it from the `t` prop
         if (!extractedKey.ns) {
           const tProp = node.opening.attributes?.find(
             attr =>
               attr.type === 'JSXAttribute' &&
-            attr.name.type === 'Identifier' &&
-            attr.name.value === 't'
+              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'
+            tProp.value?.type === 'JSXExpressionContainer' &&
+            tProp.value.expression.type === 'Identifier'
           ) {
             const tIdentifier = tProp.value.expression.value
             const scopeInfo = this.getVarFromScope(tIdentifier)
@@ -631,15 +655,35 @@ export class ASTVisitors {
             for (const context of contextValues) {
               this.pluginContext.addKey({ key: `${extractedKey.key}${contextSeparator}${context}`, ns: extractedKey.ns, defaultValue: extractedKey.defaultValue })
             }
-            // Add the base key as well
-            this.pluginContext.addKey(extractedKey)
+            // Only add the base key as a fallback if the context is dynamic (i.e., not a simple string).
+            if (extractedKey.contextExpression.type !== 'StringLiteral') {
+              this.pluginContext.addKey(extractedKey)
+            }
           }
         } else if (extractedKey.hasCount) {
-          this.handleSimplePluralKeys(extractedKey.key, extractedKey.defaultValue, extractedKey.ns)
+          // 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
+
+          // If tOptions are provided, use the advanced plural handler
+          const optionsNode = extractedKey.optionsNode ?? { type: 'ObjectExpression', properties: [], span: { start: 0, end: 0, ctxt: 0 } }
+
+          // Inject the defaultValue from children into the options object
+          optionsNode.properties.push({
+            type: 'KeyValueProperty',
+            key: { type: 'Identifier', value: 'defaultValue', optional: false, span: { start: 0, end: 0, ctxt: 0 } },
+            value: { type: 'StringLiteral', value: extractedKey.defaultValue!, span: { start: 0, end: 0, ctxt: 0 } }
+          })
+
+          this.handlePluralKeys(extractedKey.key, extractedKey.ns, optionsNode, isOrdinal)
         } else {
           this.pluginContext.addKey(extractedKey)
         }
-      // The duplicated addKey call has been removed.
       }
     }
   }
@@ -672,47 +716,6 @@ export class ASTVisitors {
     return undefined
   }
 
-  /**
-   * Extracts string value from object property.
-   *
-   * Looks for properties by name and returns their string values.
-   * Used for extracting options like 'ns', 'defaultValue', 'context', etc.
-   *
-   * @param object - Object expression to search
-   * @param propName - Property name to find
-   * @returns String value if found, empty string if property exists but isn't a string, undefined if not found
-   *
-   * @private
-   */
-  private getObjectPropValue (object: ObjectExpression, propName: string): string | boolean | number | undefined {
-    const prop = (object.properties).find(
-      (p) =>
-        p.type === 'KeyValueProperty' &&
-        (
-          (p.key?.type === 'Identifier' && p.key.value === propName) ||
-          (p.key?.type === 'StringLiteral' && p.key.value === propName)
-        )
-    )
-
-    if (prop?.type === 'KeyValueProperty') {
-      const val = prop.value
-      // Return concrete literal values when possible
-      if (val.type === 'StringLiteral') {
-        return val.value
-      }
-      if (val.type === 'BooleanLiteral') {
-        return val.value
-      }
-      if (val.type === 'NumericLiteral') {
-        return val.value
-      }
-      // For other expression types (identifier, member expr, etc.) we only care that the prop exists.
-      // Return an empty string to indicate presence.
-      return ''
-    }
-    return undefined
-  }
-
   /**
    * Extracts translation key from selector API arrow function.
    *
@@ -807,32 +810,6 @@ export class ASTVisitors {
     return []
   }
 
-  /**
-   * Finds and returns the full property node (KeyValueProperty) for the given
-   * property name from an ObjectExpression.
-   *
-   * Matches both identifier keys (e.g., { ns: 'value' }) and string literal keys
-   * (e.g., { 'ns': 'value' }).
-   *
-   * This helper returns the full property node rather than just its primitive
-   * value so callers can inspect expression types (ConditionalExpression, etc.).
-   *
-   * @private
-   * @param object - The SWC ObjectExpression to search
-   * @param propName - The property name to locate
-   * @returns The matching KeyValueProperty node if found, otherwise undefined.
-   */
-  private getObjectProperty (object: ObjectExpression, propName: string): any {
-    return (object.properties).find(
-      (p) =>
-        p.type === 'KeyValueProperty' &&
-        (
-          (p.key?.type === 'Identifier' && p.key.value === propName) ||
-          (p.key?.type === 'StringLiteral' && p.key.value === propName)
-        )
-    )
-  }
-
   /**
    * Finds the configuration for a given useTranslation function name.
    * Applies default argument positions if none are specified.

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

@@ -1,5 +1,6 @@
 import type { JSXElement } from '@swc/core'
 import type { ExtractedKey, I18nextToolkitConfig } from '../../types'
+import { getObjectProperty, getObjectPropValue } from './ast-utils'
 
 /**
  * Extracts translation keys from JSX Trans components.
@@ -55,13 +56,23 @@ export function extractFromTransComponent (node: JSXElement, config: I18nextTool
   )
   const hasCount = !!countAttr
 
+  const tOptionsAttr = node.opening.attributes?.find(
+    (attr) =>
+      attr.type === 'JSXAttribute' &&
+      attr.name.type === 'Identifier' &&
+      attr.name.value === 'tOptions'
+  )
+  const optionsNode = (tOptionsAttr?.type === 'JSXAttribute' && tOptionsAttr.value?.type === 'JSXExpressionContainer' && tOptionsAttr.value.expression.type === 'ObjectExpression')
+    ? tOptionsAttr.value.expression
+    : undefined
+
   const contextAttr = node.opening.attributes?.find(
     (attr) =>
       attr.type === 'JSXAttribute' &&
       attr.name.type === 'Identifier' &&
       attr.name.value === 'context'
   )
-  const contextExpression = (contextAttr?.type === 'JSXAttribute' && contextAttr.value?.type === 'JSXExpressionContainer')
+  let contextExpression = (contextAttr?.type === 'JSXAttribute' && contextAttr.value?.type === 'JSXExpressionContainer')
     ? contextAttr.value.expression
     : undefined
 
@@ -76,13 +87,27 @@ export function extractFromTransComponent (node: JSXElement, config: I18nextTool
     return null
   }
 
-  const nsAttr = node.opening.attributes?.find(
-    (attr) =>
-      attr.type === 'JSXAttribute' && attr.name.type === 'Identifier' && attr.name.value === 'ns'
-  )
-  const ns = nsAttr?.type === 'JSXAttribute' && nsAttr.value?.type === 'StringLiteral'
-    ? nsAttr.value.value
-    : undefined
+  // 1. Prioritize direct props for 'ns' and 'context'
+  const nsAttr = node.opening.attributes?.find(attr => attr.type === 'JSXAttribute' && attr.name.type === 'Identifier' && attr.name.value === 'ns')
+  let ns: string | undefined
+  if (nsAttr?.type === 'JSXAttribute' && nsAttr.value?.type === 'StringLiteral') {
+    ns = nsAttr.value.value
+  } else {
+    ns = undefined
+  }
+
+  // 2. If not found, fall back to looking inside tOptions
+  if (optionsNode) {
+    if (ns === undefined) {
+      ns = getObjectPropValue(optionsNode, 'ns') as string | undefined
+    }
+    if (contextExpression === undefined) {
+      const contextPropFromOptions = getObjectProperty(optionsNode, 'context')
+      if (contextPropFromOptions?.value) {
+        contextExpression = contextPropFromOptions.value
+      }
+    }
+  }
 
   let defaultValue = config.extract.defaultValue || ''
   if (defaultsAttr?.type === 'JSXAttribute' && defaultsAttr.value?.type === 'StringLiteral') {
@@ -91,7 +116,7 @@ export function extractFromTransComponent (node: JSXElement, config: I18nextTool
     defaultValue = serializeJSXChildren(node.children, config)
   }
 
-  return { key, ns, defaultValue: defaultValue || key, hasCount, contextExpression }
+  return { key, ns, defaultValue: defaultValue || key, hasCount, contextExpression, optionsNode }
 }
 
 /**

package/src/locize.ts

@@ -81,13 +81,6 @@ async function interactiveCredentialSetup (config: I18nextToolkitConfig): Promis
     return undefined
   }
 
-  // Use the entered credentials for the current run
-  config.locize = {
-    projectId: answers.projectId,
-    apiKey: answers.apiKey,
-    version: answers.version,
-  }
-
   const { save } = await inquirer.prompt([{
     type: 'confirm',
     name: 'save',
@@ -116,33 +109,29 @@ LOCIZE_API_KEY=${answers.apiKey}
     console.log(chalk.green(configSnippet))
   }
 
-  return config.locize
+  return {
+    projectId: answers.projectId,
+    apiKey: answers.apiKey,
+    version: answers.version,
+  }
 }
 
 /**
- * Converts CLI options and configuration into locize-cli command arguments.
- *
- * Maps toolkit configuration and CLI flags to the appropriate locize-cli arguments:
- * - `updateValues` → `--update-values`
- * - `sourceLanguageOnly` → `--reference-language-only`
- * - `compareModificationTime` → `--compare-modification-time`
- * - `dryRun` → `--dry`
- *
- * @param command - The locize command being executed
- * @param cliOptions - CLI options passed to the command
- * @param locizeConfig - Locize configuration from the config file
- * @returns Array of command-line arguments
- *
- * @example
- * ```typescript
- * const args = cliOptionsToArgs('sync', { updateValues: true }, { dryRun: false })
- * // Returns: ['--update-values', 'true']
- * ```
+ * Helper function to build the array of arguments for the execa call.
+ * This ensures the logic is consistent for both the initial run and the retry.
  */
-function cliOptionsToArgs (command: 'sync' | 'download' | 'migrate', cliOptions: any = {}, locizeConfig: any = {}) {
-  const commandArgs: string[] = []
+function buildArgs (command: string, config: I18nextToolkitConfig, cliOptions: any): string[] {
+  const { locize: locizeConfig = {}, extract } = config
+  const { projectId, apiKey, version } = locizeConfig
+
+  const commandArgs: string[] = [command]
+
+  if (projectId) commandArgs.push('--project-id', projectId)
+  if (apiKey) commandArgs.push('--api-key', apiKey)
+  if (version) commandArgs.push('--ver', version)
+  // TODO: there might be more configurable locize-cli options in future
 
-  // Pass-through options
+  // Pass-through options from the CLI
   if (command === 'sync') {
     const updateValues = cliOptions.updateValues ?? locizeConfig.updateValues
     if (updateValues) commandArgs.push('--update-values', 'true')
@@ -154,6 +143,9 @@ function cliOptionsToArgs (command: 'sync' | 'download' | 'migrate', cliOptions:
     if (dryRun) commandArgs.push('--dry', 'true')
   }
 
+  const basePath = resolve(process.cwd(), extract.output.split('/{{language}}/')[0])
+  commandArgs.push('--path', basePath)
+
   return commandArgs
 }
 
@@ -189,44 +181,33 @@ async function runLocizeCommand (command: 'sync' | 'download' | 'migrate', confi
 
   const spinner = ora(`Running 'locize ${command}'...\n`).start()
 
-  const locizeConfig = config.locize || {}
-  const { projectId, apiKey, version } = locizeConfig
-  let commandArgs: string[] = [command]
-
-  if (projectId) commandArgs.push('--project-id', projectId)
-  if (apiKey) commandArgs.push('--api-key', apiKey)
-  if (version) commandArgs.push('--ver', version)
-  // TODO: there might be more configurable locize-cli options in future
-
-  commandArgs.push(...cliOptionsToArgs(command, cliOptions, locizeConfig))
-
-  const basePath = resolve(process.cwd(), config.extract.output.split('/{{language}}/')[0])
-  commandArgs.push('--path', basePath)
+  let effectiveConfig = config
 
   try {
-    console.log(chalk.cyan(`\nRunning 'locize ${commandArgs.join(' ')}'...`))
-    const result = await execa('locize', commandArgs, { stdio: 'pipe' })
+    // 1. First attempt
+    const initialArgs = buildArgs(command, effectiveConfig, cliOptions)
+    console.log(chalk.cyan(`\nRunning 'locize ${initialArgs.join(' ')}'...`))
+    const result = await execa('locize', initialArgs, { stdio: 'pipe' })
+
     spinner.succeed(chalk.green(`'locize ${command}' completed successfully.`))
     if (result?.stdout) console.log(result.stdout) // Print captured output on success
   } catch (error: any) {
     const stderr = error.stderr || ''
     if (stderr.includes('missing required argument')) {
-      // Fallback to interactive setup
-      const newCredentials = await interactiveCredentialSetup(config)
+      // 2. Auth failure, trigger interactive setup
+      const newCredentials = await interactiveCredentialSetup(effectiveConfig)
       if (newCredentials) {
-        // Retry the command with the new credentials
-        commandArgs = [command]
-        if (newCredentials.projectId) commandArgs.push('--project-id', newCredentials.projectId)
-        if (newCredentials.apiKey) commandArgs.push('--api-key', newCredentials.apiKey)
-        if (newCredentials.version) commandArgs.push('--ver', newCredentials.version)
-        // TODO: there might be more configurable locize-cli options in future
-        commandArgs.push(...cliOptionsToArgs(command, cliOptions, locizeConfig))
-        commandArgs.push('--path', basePath)
+        effectiveConfig = { ...effectiveConfig, locize: newCredentials }
+
+        spinner.start('Retrying with new credentials...')
         try {
-          spinner.start('Retrying with new credentials...') // Restart spinner
-          const result = await execa('locize', commandArgs, { stdio: 'pipe' })
+          // 3. Retry attempt, rebuilding args with the NOW-UPDATED currentConfig object
+          const retryArgs = buildArgs(command, effectiveConfig, cliOptions)
+          console.log(chalk.cyan(`\nRunning 'locize ${retryArgs.join(' ')}'...`))
+          const result = await execa('locize', retryArgs, { stdio: 'pipe' })
+
           spinner.succeed(chalk.green('Retry successful!'))
-          if (result?.stdout) console.log(result.stdout) // Print captured output on success
+          if (result?.stdout) console.log(result.stdout)
         } catch (retryError: any) {
           spinner.fail(chalk.red('Error during retry.'))
           console.error(retryError.stderr || retryError.message)