i18next-cli 1.17.1 → 1.18.0

package/src/cli.ts

@@ -12,7 +12,7 @@ import { runTypesGenerator } from './types-generator'
 import { runSyncer } from './syncer'
 import { runMigrator } from './migrator'
 import { runInit } from './init'
-import { runLinter } from './linter'
+import { runLinterCli } from './linter'
 import { runStatus } from './status'
 import { runLocizeSync, runLocizeDownload, runLocizeMigrate } from './locize'
 import type { I18nextToolkitConfig } from './types'
@@ -22,7 +22,7 @@ const program = new Command()
 program
   .name('i18next-cli')
   .description('A unified, high-performance i18next CLI.')
-  .version('1.17.1')
+  .version('1.18.0')
 
 // new: global config override option
 program.option('-c, --config <path>', 'Path to i18next-cli config file (overrides detection)')
@@ -174,7 +174,7 @@ program
         console.log(chalk.green('Project structure detected successfully!'))
         config = detected as I18nextToolkitConfig
       }
-      await runLinter(config)
+      await runLinterCli(config)
     }
 
     // Run the linter once initially

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

@@ -100,6 +100,17 @@ export async function findKeys (
     await plugin.onEnd?.(allKeys)
   }
 
+  // Normalization: mark already-expanded plural keys
+  const pluralSeparator = otherConfig.extract?.pluralSeparator ?? '_'
+  const categories = ['zero', 'one', 'two', 'few', 'many', 'other']
+  for (const ek of allKeys.values()) {
+    const parts = String(ek.key).split(pluralSeparator)
+    const last = parts[parts.length - 1]
+    const isOrdinal = parts.length >= 3 && parts[parts.length - 2] === 'ordinal'
+    if (categories.includes(last) || (isOrdinal && categories.includes(last))) {
+      ;(ek as any).isExpandedPlural = true
+    }
+  }
   return { allKeys, objectKeys: astVisitors.objectKeys }
 }
 

package/src/extractor/core/translation-manager.ts

@@ -123,18 +123,26 @@ function buildNewTranslationsForNs (
 
   // Get the plural categories for the target language
   const targetLanguagePluralCategories = new Set<string>()
+  // Track cardinal plural categories separately so we can special-case single-"other" languages
+  let cardinalCategories: string[] = []
+  let ordinalCategories: string[] = []
   try {
     const cardinalRules = new Intl.PluralRules(locale, { type: 'cardinal' })
     const ordinalRules = new Intl.PluralRules(locale, { type: 'ordinal' })
 
-    cardinalRules.resolvedOptions().pluralCategories.forEach(cat => targetLanguagePluralCategories.add(cat))
+    cardinalCategories = cardinalRules.resolvedOptions().pluralCategories
+    ordinalCategories = ordinalRules.resolvedOptions().pluralCategories
+    cardinalCategories.forEach(cat => targetLanguagePluralCategories.add(cat))
     ordinalRules.resolvedOptions().pluralCategories.forEach(cat => targetLanguagePluralCategories.add(`ordinal_${cat}`))
   } catch (e) {
-    // Fallback to English if locale is invalid
-    const cardinalRules = new Intl.PluralRules(primaryLanguage || 'en', { type: 'cardinal' })
-    const ordinalRules = new Intl.PluralRules(primaryLanguage || 'en', { type: 'ordinal' })
-
-    cardinalRules.resolvedOptions().pluralCategories.forEach(cat => targetLanguagePluralCategories.add(cat))
+    // Fallback to primaryLanguage (or English) if locale is invalid
+    const fallbackLang = primaryLanguage || 'en'
+    const cardinalRules = new Intl.PluralRules(fallbackLang, { type: 'cardinal' })
+    const ordinalRules = new Intl.PluralRules(fallbackLang, { type: 'ordinal' })
+
+    cardinalCategories = cardinalRules.resolvedOptions().pluralCategories
+    ordinalCategories = ordinalRules.resolvedOptions().pluralCategories
+    cardinalCategories.forEach(cat => targetLanguagePluralCategories.add(cat))
     ordinalRules.resolvedOptions().pluralCategories.forEach(cat => targetLanguagePluralCategories.add(`ordinal_${cat}`))
   }
 
@@ -153,6 +161,22 @@ function buildNewTranslationsForNs (
     // For plural keys, check if this specific plural form is needed for the target language
     const keyParts = key.split(pluralSeparator)
 
+    // If this is a base plural key (no plural suffix), keep it so that the
+    // builder can expand it to the target locale's plural forms.
+    if (hasCount && keyParts.length === 1) {
+      return true
+    }
+
+    // Special-case single-cardinal-"other" languages (ja/zh/ko etc.):
+    // when the target language's cardinal categories are exactly ['other'],
+    // the extractor may have emitted the base key (no "_other" suffix).
+    // Accept the base key in that situation, while still accepting explicit *_other variants.
+    if (cardinalCategories.length === 1 && cardinalCategories[0] === 'other') {
+      // If this is a plain/base key (no plural suffix), include it.
+      if (keyParts.length === 1) return true
+      // Otherwise fall through and check the explicit suffix as before.
+    }
+
     if (isOrdinal && keyParts.includes('ordinal')) {
       // For ordinal plurals: key_context_ordinal_category or key_ordinal_category
       const lastPart = keyParts[keyParts.length - 1]
@@ -166,6 +190,24 @@ function buildNewTranslationsForNs (
     return true
   })
 
+  // NEW: detect bases that already have expanded plural variants extracted.
+  // If a base has explicit expanded variants (e.g. key_one, key_other or key_ordinal_one),
+  // we should avoid generating/expanding the base plural key for that base to prevent
+  // double-generation / duplicate counting.
+  const expandedBases = new Set<string>()
+  for (const ek of filteredKeys) {
+    if (ek.isExpandedPlural) {
+      const parts = String(ek.key).split(pluralSeparator)
+      // If ordinal form like "key_ordinal_one" -> base should strip "_ordinal_<cat>"
+      if (parts.length >= 3 && parts[parts.length - 2] === 'ordinal') {
+        expandedBases.add(parts.slice(0, -2).join(pluralSeparator))
+      } else {
+        // strip single trailing category
+        expandedBases.add(parts.slice(0, -1).join(pluralSeparator))
+      }
+    }
+  }
+
   // If `removeUnusedKeys` is true, start with an empty object. Otherwise, start with a clone of the existing translations.
   let newTranslations: Record<string, any> = removeUnusedKeys
     ? {}
@@ -208,7 +250,52 @@ function buildNewTranslationsForNs (
   }
 
   // 1. Build the object first, without any sorting.
-  for (const { key, defaultValue, explicitDefault } of filteredKeys) {
+  for (const { key, defaultValue, explicitDefault, hasCount, isExpandedPlural, isOrdinal } of filteredKeys) {
+    // If this is a base plural key (hasCount true but not an already-expanded variant)
+    // and we detected explicit expanded variants for this base, skip expanding the base.
+    if (hasCount && !isExpandedPlural) {
+      const parts = String(key).split(pluralSeparator)
+      let base = key
+      if (parts.length >= 3 && parts[parts.length - 2] === 'ordinal') {
+        base = parts.slice(0, -2).join(pluralSeparator)
+      } else if (parts.length >= 2) {
+        base = parts.slice(0, -1).join(pluralSeparator)
+      }
+      if (expandedBases.has(base)) {
+        // Skip generating/expanding this base key because explicit expanded forms exist.
+        continue
+      }
+    }
+
+    // If this is a base plural key (no explicit suffix) and the locale is NOT the primary,
+    // expand it into locale-specific plural variants (e.g. key_one, key_other).
+    // Use the extracted defaultValue (fallback to base) for variant values.
+    if (hasCount && !isExpandedPlural) {
+      const parts = String(key).split(pluralSeparator)
+      const isBaseKey = parts.length === 1
+      if (isBaseKey && locale !== primaryLanguage) {
+        // If explicit expanded variants exist, do not expand the base.
+        const base = key
+        if (expandedBases.has(base)) {
+          // Skip expansion when explicit variants were provided
+        } else {
+          // choose categories based on ordinal flag
+          const categories = isOrdinal ? ordinalCategories : cardinalCategories
+          for (const category of categories) {
+            const finalKey = isOrdinal
+              ? `${base}${pluralSeparator}ordinal${pluralSeparator}${category}`
+              : `${base}${pluralSeparator}${category}`
+
+            // For secondary locales, prefer the extracted defaultValue (fallback to base) as test expects.
+            const valueToSet = (typeof defaultValue === 'string' && defaultValue !== undefined) ? defaultValue : base
+            setNestedValue(newTranslations, finalKey, valueToSet, keySeparator ?? '.')
+          }
+        }
+        // We've expanded variants for this base key; skip the normal single-key handling.
+        continue
+      }
+    }
+
     const existingValue = getNestedValue(existingTranslations, key, keySeparator ?? '.')
     const isLeafInNewKeys = !filteredKeys.some(otherKey => otherKey.key.startsWith(`${key}${keySeparator}`) && otherKey.key !== key)
 

package/src/extractor/parsers/call-expression-handler.ts

@@ -261,6 +261,67 @@ export class CallExpressionHandler {
           return false
         })()
         if (hasCount || isOrdinalByKey) {
+          // QUICK PATH: If ALL target locales only have the "other" category,
+          // emit base/context keys directly (avoid generating *_other). This
+          // mirrors the special-case in handlePluralKeys but is placed here as a
+          // defensive guard to ensure keys are always emitted.
+          try {
+            const typeForCheck = isOrdinalByKey ? 'ordinal' : 'cardinal'
+            // Prefer the configured primaryLanguage as the deciding signal for
+            // "single-other" languages (ja/zh/ko). Fall back to union of locales.
+            const primaryLang = this.config.extract?.primaryLanguage || (Array.isArray(this.config.locales) ? this.config.locales[0] : undefined) || 'en'
+            let isSingleOther = false
+            try {
+              const primaryCategories = new Intl.PluralRules(primaryLang, { type: typeForCheck }).resolvedOptions().pluralCategories
+              if (primaryCategories.length === 1 && primaryCategories[0] === 'other') {
+                isSingleOther = true
+              }
+            } catch {
+              // ignore and fall back to union-of-locales check below
+            }
+
+            if (!isSingleOther) {
+              const allPluralCategoriesCheck = new Set<string>()
+              for (const locale of this.config.locales) {
+                try {
+                  const rules = new Intl.PluralRules(locale, { type: typeForCheck })
+                  rules.resolvedOptions().pluralCategories.forEach(c => allPluralCategoriesCheck.add(c))
+                } catch {
+                  new Intl.PluralRules('en', { type: typeForCheck }).resolvedOptions().pluralCategories.forEach(c => allPluralCategoriesCheck.add(c))
+                }
+              }
+              const pluralCategoriesCheck = Array.from(allPluralCategoriesCheck).sort()
+              if (pluralCategoriesCheck.length === 1 && pluralCategoriesCheck[0] === 'other') {
+                isSingleOther = true
+              }
+            }
+
+            if (isSingleOther) {
+              // Emit only base/context keys (no _other) and skip the heavy plural path.
+              if (keysWithContext.length > 0) {
+                for (const k of keysWithContext) {
+                  this.pluginContext.addKey({
+                    key: k.key,
+                    ns: k.ns,
+                    defaultValue: k.defaultValue,
+                    hasCount: true,
+                    isOrdinal: isOrdinalByKey
+                  })
+                }
+              } else {
+                this.pluginContext.addKey({
+                  key: finalKey,
+                  ns,
+                  defaultValue: dv,
+                  hasCount: true,
+                  isOrdinal: isOrdinalByKey
+                })
+              }
+              continue
+            }
+          } catch (e) {
+            // Ignore Intl failures here and fall through to normal logic
+          }
           // Check if plurals are disabled
           if (this.config.extract.disablePlurals) {
             // When plurals are disabled, treat count as a regular option (for interpolation only)
@@ -480,6 +541,55 @@ export class CallExpressionHandler {
         keysToGenerate.push({ key })
       }
 
+      // If the only plural category across configured locales is "other",
+      // prefer the base key (no "_other" suffix) as it's more natural for languages
+      // with no grammatical plural forms (ja/zh/ko).
+      // Prefer the configured primaryLanguage as signal for single-"other" languages.
+      // If primaryLanguage indicates single-"other", treat as that case; otherwise
+      // fall back to earlier union-of-locales check that produced `pluralCategories`.
+      const primaryLang = this.config.extract?.primaryLanguage || (Array.isArray(this.config.locales) ? this.config.locales[0] : undefined) || 'en'
+      let primaryIsSingleOther = false
+      try {
+        const primaryCats = new Intl.PluralRules(primaryLang, { type }).resolvedOptions().pluralCategories
+        if (primaryCats.length === 1 && primaryCats[0] === 'other') primaryIsSingleOther = true
+      } catch {
+        primaryIsSingleOther = false
+      }
+
+      if (primaryIsSingleOther || (pluralCategories.length === 1 && pluralCategories[0] === 'other')) {
+        for (const { key: baseKey, context } of keysToGenerate) {
+          const specificOther = getObjectPropValue(options, `defaultValue${pluralSeparator}other`)
+          // Final default resolution:
+          // 1) plural-specific defaultValue_other
+          // 2) general defaultValue (from options)
+          // 3) defaultValueFromCall (string arg)
+          // 4) fallback to key (or context-key for context variants)
+          let finalDefaultValue: string | undefined
+          if (typeof specificOther === 'string') {
+            finalDefaultValue = specificOther
+          } else if (typeof defaultValue === 'string') {
+            finalDefaultValue = defaultValue
+          } else if (typeof defaultValueFromCall === 'string') {
+            finalDefaultValue = defaultValueFromCall
+          } else {
+            finalDefaultValue = context ? `${baseKey}_${context}` : baseKey
+          }
+
+          const ctxSep = this.config.extract.contextSeparator ?? '_'
+          const finalKey = context ? `${baseKey}${ctxSep}${context}` : baseKey
+
+          this.pluginContext.addKey({
+            key: finalKey,
+            ns,
+            defaultValue: finalDefaultValue,
+            hasCount: true,
+            isOrdinal,
+            explicitDefault: Boolean(explicitDefaultFromSource || typeof specificOther === 'string')
+          })
+        }
+        return
+      }
+
       // Generate plural forms for each key variant
       for (const { key: baseKey, context } of keysToGenerate) {
         for (const category of pluralCategories) {

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

@@ -185,6 +185,18 @@ function generatePluralKeys (
     const pluralCategories = Array.from(allPluralCategories).sort()
     const pluralSeparator = config.extract.pluralSeparator ?? '_'
 
+    // If the only plural category is "other", prefer emitting the base key instead of "key_other"
+    if (pluralCategories.length === 1 && pluralCategories[0] === 'other') {
+      // Emit base key only
+      pluginContext.addKey({
+        key,
+        ns,
+        defaultValue,
+        hasCount: true
+      })
+      return
+    }
+
     // Generate keys for each plural category
     for (const category of pluralCategories) {
       const finalKey = isOrdinal

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

@@ -286,6 +286,24 @@ export class JSXHandler {
         ordinalOtherDefault = getObjectPropValue(optionsNode, `defaultValue${pluralSeparator}ordinal${pluralSeparator}other`) as string | undefined
       }
 
+      // Special-case single-"other" languages: generate base key (or context variant) instead of key_other
+      if (pluralCategories.length === 1 && pluralCategories[0] === 'other') {
+        // Determine final default for the base/other form
+        const specificDefault = optionsNode ? getObjectPropValue(optionsNode, `defaultValue${pluralSeparator}other`) as string | undefined : undefined
+        const finalDefault = typeof specificDefault === 'string' ? specificDefault : (typeof defaultValue === 'string' ? defaultValue : key)
+
+        // add base key (no suffix)
+        this.pluginContext.addKey({
+          key,
+          ns,
+          defaultValue: finalDefault,
+          hasCount: true,
+          isOrdinal,
+          explicitDefault: Boolean(explicitDefaultFromSource || typeof specificDefault === 'string' || typeof otherDefault === 'string')
+        })
+        return
+      }
+
       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}`

package/src/linter.ts

@@ -1,10 +1,87 @@
 import { glob } from 'glob'
 import { readFile } from 'node:fs/promises'
 import { parse } from '@swc/core'
+import { EventEmitter } from 'node:events'
 import chalk from 'chalk'
 import ora from 'ora'
 import type { I18nextToolkitConfig } from './types'
 
+type LinterEventMap = {
+  progress: [{
+    message: string;
+  }];
+  done: [{
+    success: boolean;
+    message: string;
+    files: Record<string, HardcodedString[]>;
+  }];
+  error: [error: Error];
+}
+
+export class Linter extends EventEmitter<LinterEventMap> {
+  private config: I18nextToolkitConfig
+
+  constructor (config: I18nextToolkitConfig) {
+    super({ captureRejections: true })
+    this.config = config
+  }
+
+  wrapError (error: unknown) {
+    const prefix = 'Linter failed to run: '
+    if (error instanceof Error) {
+      if (error.message.startsWith(prefix)) {
+        return error
+      }
+      const wrappedError = new Error(`${prefix}${error.message}`)
+      wrappedError.stack = error.stack
+      return wrappedError
+    }
+    return new Error(`${prefix}${String(error)}`)
+  }
+
+  async run () {
+    const { config } = this
+    try {
+      this.emit('progress', { message: 'Finding source files to analyze...' })
+      const defaultIgnore = ['node_modules/**']
+      const userIgnore = Array.isArray(config.extract.ignore)
+        ? config.extract.ignore
+        : config.extract.ignore ? [config.extract.ignore] : []
+
+      const sourceFiles = await glob(config.extract.input, {
+        ignore: [...defaultIgnore, ...userIgnore]
+      })
+      this.emit('progress', { message: `Analyzing ${sourceFiles.length} source files...` })
+      let totalIssues = 0
+      const issuesByFile = new Map<string, HardcodedString[]>()
+
+      for (const file of sourceFiles) {
+        const code = await readFile(file, 'utf-8')
+        const ast = await parse(code, {
+          syntax: 'typescript',
+          tsx: true,
+          decorators: true
+        })
+        const hardcodedStrings = findHardcodedStrings(ast, code, config)
+
+        if (hardcodedStrings.length > 0) {
+          totalIssues += hardcodedStrings.length
+          issuesByFile.set(file, hardcodedStrings)
+        }
+      }
+
+      const files = Object.fromEntries(issuesByFile.entries())
+      const data = { success: totalIssues === 0, message: totalIssues > 0 ? `Linter found ${totalIssues} potential issues.` : 'No issues found.', files }
+      this.emit('done', data)
+      return data
+    } catch (error) {
+      const wrappedError = this.wrapError(error)
+      this.emit('error', wrappedError)
+      throw wrappedError
+    }
+  }
+}
+
 /**
  * Runs the i18next linter to detect hardcoded strings and other potential issues.
  *
@@ -32,44 +109,25 @@ import type { I18nextToolkitConfig } from './types'
  *
  * await runLinter(config)
  * // Outputs issues found or success message
- * // Exits with code 1 if issues found, 0 if clean
  * ```
  */
 export async function runLinter (config: I18nextToolkitConfig) {
-  const spinner = ora('Analyzing source files...\n').start()
+  return new Linter(config).run()
+}
 
+export async function runLinterCli (config: I18nextToolkitConfig) {
+  const linter = new Linter(config)
+  const spinner = ora().start()
+  linter.on('progress', (event) => {
+    spinner.text = event.message
+  })
   try {
-    const defaultIgnore = ['node_modules/**']
-    const userIgnore = Array.isArray(config.extract.ignore)
-      ? config.extract.ignore
-      : config.extract.ignore ? [config.extract.ignore] : []
-
-    const sourceFiles = await glob(config.extract.input, {
-      ignore: [...defaultIgnore, ...userIgnore]
-    })
-    let totalIssues = 0
-    const issuesByFile = new Map<string, HardcodedString[]>()
-
-    for (const file of sourceFiles) {
-      const code = await readFile(file, 'utf-8')
-      const ast = await parse(code, {
-        syntax: 'typescript',
-        tsx: true,
-        decorators: true
-      })
-      const hardcodedStrings = findHardcodedStrings(ast, code, config)
-
-      if (hardcodedStrings.length > 0) {
-        totalIssues += hardcodedStrings.length
-        issuesByFile.set(file, hardcodedStrings)
-      }
-    }
-
-    if (totalIssues > 0) {
-      spinner.fail(chalk.red.bold(`Linter found ${totalIssues} potential issues.`))
+    const { success, message, files } = await linter.run()
+    if (!success) {
+      spinner.fail(chalk.red.bold(message))
 
       // Print detailed report after spinner fails
-      for (const [file, issues] of issuesByFile.entries()) {
+      for (const [file, issues] of Object.entries(files)) {
         console.log(chalk.yellow(`\n${file}`))
         issues.forEach(({ text, line }) => {
           console.log(`  ${chalk.gray(`${line}:`)} ${chalk.red('Error:')} Found hardcoded string: "${text}"`)
@@ -77,11 +135,12 @@ export async function runLinter (config: I18nextToolkitConfig) {
       }
       process.exit(1)
     } else {
-      spinner.succeed(chalk.green.bold('No issues found.'))
+      spinner.succeed(chalk.green.bold(message))
     }
   } catch (error) {
-    spinner.fail(chalk.red('Linter failed to run.'))
-    console.error(error)
+    const wrappedError = linter.wrapError(error)
+    spinner.fail(wrappedError.message)
+    console.error(wrappedError)
     process.exit(1)
   }
 }

package/src/status.ts

@@ -124,20 +124,28 @@ async function generateStatusReport (config: I18nextToolkitConfig): Promise<Stat
       const keyDetails: Array<{ key: string; isTranslated: boolean }> = []
 
       // This is the new, language-aware logic loop
-      for (const { key: baseKey, hasCount, isOrdinal } of keysInNs) {
+      for (const { key: baseKey, hasCount, isOrdinal, isExpandedPlural } of keysInNs) {
         if (hasCount) {
-          const type = isOrdinal ? 'ordinal' : 'cardinal'
-          // It's a plural key: expand it based on the current locale's rules
-          const pluralCategories = new Intl.PluralRules(locale, { type }).resolvedOptions().pluralCategories
-          for (const category of pluralCategories) {
+          // Rely only on the extractor-provided flag; extractor must set isExpandedPlural
+          if (isExpandedPlural) {
             totalInNs++
-            const pluralKey = isOrdinal
-              ? `${baseKey}${pluralSeparator}ordinal${pluralSeparator}${category}`
-              : `${baseKey}${pluralSeparator}${category}`
-            const value = getNestedValue(translationsForNs, pluralKey, keySeparator ?? '.')
+            const value = getNestedValue(translationsForNs, baseKey, keySeparator ?? '.')
             const isTranslated = !!value
             if (isTranslated) translatedInNs++
-            keyDetails.push({ key: pluralKey, isTranslated })
+            keyDetails.push({ key: baseKey, isTranslated })
+          } else {
+            const type = isOrdinal ? 'ordinal' : 'cardinal'
+            const pluralCategories = new Intl.PluralRules(locale, { type }).resolvedOptions().pluralCategories
+            for (const category of pluralCategories) {
+              totalInNs++
+              const pluralKey = isOrdinal
+                ? `${baseKey}${pluralSeparator}ordinal${pluralSeparator}${category}`
+                : `${baseKey}${pluralSeparator}${category}`
+              const value = getNestedValue(translationsForNs, pluralKey, keySeparator ?? '.')
+              const isTranslated = !!value
+              if (isTranslated) translatedInNs++
+              keyDetails.push({ key: pluralKey, isTranslated })
+            }
           }
         } else {
           // It's a simple key

package/src/types.ts

@@ -319,6 +319,9 @@ export interface ExtractedKey {
 
   /** Whether the defaultValue was explicitly provided in source code (vs derived from children/key) */
   explicitDefault?: boolean;
+
+  /** True when the extractor returned an already-expanded plural form (e.g. "key_one") */
+  isExpandedPlural?: boolean
 }
 
 /**

package/types/extractor/core/key-finder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"key-finder.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/key-finder.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,oBAAoB,EAAmB,MAAM,aAAa,CAAA;AAM9F;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,oBAAoB,EAC5B,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC;IAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC,CAgE1E"}
+{"version":3,"file":"key-finder.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/key-finder.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,oBAAoB,EAAmB,MAAM,aAAa,CAAA;AAM9F;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,oBAAoB,EAC5B,MAAM,GAAE,MAA4B,GACnC,OAAO,CAAC;IAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC,CA2E1E"}

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

@@ -1 +1 @@
-{"version":3,"file":"translation-manager.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/translation-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AA2UnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAC/B,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EACvB,MAAM,EAAE,oBAAoB,EAC5B,EAAE,uBAA+B,EAAE,GAAE;IAAE,uBAAuB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9E,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA6F9B"}
+{"version":3,"file":"translation-manager.d.ts","sourceRoot":"","sources":["../../../src/extractor/core/translation-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAkanF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAC/B,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EACvB,MAAM,EAAE,oBAAoB,EAC5B,EAAE,uBAA+B,EAAE,GAAE;IAAE,uBAAuB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9E,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA6F9B"}

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

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

package/types/extractor/parsers/jsx-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsx-handler.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/jsx-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAoB,MAAM,WAAW,CAAA;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAgB,MAAM,aAAa,CAAA;AACpF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAI1D,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,kBAAkB,CAAoB;gBAG5C,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,kBAAkB,EAAE,kBAAkB;IAOxC;;;;;;;;OAQG;IACH,gBAAgB,CAAE,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,GAAG,IAAI;IA0OjI;;;;;;;;OAQG;IACH,OAAO,CAAC,0BAA0B;IAgElC;;;;;;;;;OASG;IACH,OAAO,CAAC,cAAc;CAevB"}
+{"version":3,"file":"jsx-handler.d.ts","sourceRoot":"","sources":["../../../src/extractor/parsers/jsx-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAoB,MAAM,WAAW,CAAA;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAgB,MAAM,aAAa,CAAA;AACpF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAI1D,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,kBAAkB,CAAoB;gBAG5C,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,EAC7C,aAAa,EAAE,aAAa,EAC5B,kBAAkB,EAAE,kBAAkB;IAOxC;;;;;;;;OAQG;IACH,gBAAgB,CAAE,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,GAAG,IAAI;IA0OjI;;;;;;;;OAQG;IACH,OAAO,CAAC,0BAA0B;IAkFlC;;;;;;;;;OASG;IACH,OAAO,CAAC,cAAc;CAevB"}

package/types/linter.d.ts

@@ -1,4 +1,32 @@
+import { EventEmitter } from 'node:events';
 import type { I18nextToolkitConfig } from './types';
+type LinterEventMap = {
+    progress: [
+        {
+            message: string;
+        }
+    ];
+    done: [
+        {
+            success: boolean;
+            message: string;
+            files: Record<string, HardcodedString[]>;
+        }
+    ];
+    error: [error: Error];
+};
+export declare class Linter extends EventEmitter<LinterEventMap> {
+    private config;
+    constructor(config: I18nextToolkitConfig);
+    wrapError(error: unknown): Error;
+    run(): Promise<{
+        success: boolean;
+        message: string;
+        files: {
+            [k: string]: HardcodedString[];
+        };
+    }>;
+}
 /**
  * Runs the i18next linter to detect hardcoded strings and other potential issues.
  *
@@ -26,8 +54,24 @@ import type { I18nextToolkitConfig } from './types';
  *
  * await runLinter(config)
  * // Outputs issues found or success message
- * // Exits with code 1 if issues found, 0 if clean
  * ```
  */
-export declare function runLinter(config: I18nextToolkitConfig): Promise<void>;
+export declare function runLinter(config: I18nextToolkitConfig): Promise<{
+    success: boolean;
+    message: string;
+    files: {
+        [k: string]: HardcodedString[];
+    };
+}>;
+export declare function runLinterCli(config: I18nextToolkitConfig): Promise<void>;
+/**
+ * Represents a found hardcoded string with its location information.
+ */
+interface HardcodedString {
+    /** The hardcoded text content */
+    text: string;
+    /** Line number where the string was found */
+    line: number;
+}
+export {};
 //# sourceMappingURL=linter.d.ts.map

package/types/linter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linter.d.ts","sourceRoot":"","sources":["../src/linter.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,SAAS,CAAE,MAAM,EAAE,oBAAoB,iBAiD5D"}
+{"version":3,"file":"linter.d.ts","sourceRoot":"","sources":["../src/linter.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAG1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAEnD,KAAK,cAAc,GAAG;IACpB,QAAQ,EAAE;QAAC;YACT,OAAO,EAAE,MAAM,CAAC;SACjB;KAAC,CAAC;IACH,IAAI,EAAE;QAAC;YACL,OAAO,EAAE,OAAO,CAAC;YACjB,OAAO,EAAE,MAAM,CAAC;YAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;SAC1C;KAAC,CAAC;IACH,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CACvB,CAAA;AAED,qBAAa,MAAO,SAAQ,YAAY,CAAC,cAAc,CAAC;IACtD,OAAO,CAAC,MAAM,CAAsB;gBAEvB,MAAM,EAAE,oBAAoB;IAKzC,SAAS,CAAE,KAAK,EAAE,OAAO;IAanB,GAAG;;;;;;;CAyCV;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,SAAS,CAAE,MAAM,EAAE,oBAAoB;;;;;;GAE5D;AAED,wBAAsB,YAAY,CAAE,MAAM,EAAE,oBAAoB,iBA4B/D;AAED;;GAEG;AACH,UAAU,eAAe;IACvB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;CACd"}

package/types/types.d.ts

@@ -262,6 +262,8 @@ export interface ExtractedKey {
     contextExpression?: Expression;
     /** Whether the defaultValue was explicitly provided in source code (vs derived from children/key) */
     explicitDefault?: boolean;
+    /** True when the extractor returned an already-expanded plural form (e.g. "key_one") */
+    isExpandedPlural?: boolean;
 }
 /**
  * Result of processing translation files for a specific locale and namespace.