i18next-cli 1.24.12 → 1.24.14

package/src/init.ts

@@ -1,175 +0,0 @@
-import inquirer from 'inquirer'
-import { writeFile, readFile } from 'node:fs/promises'
-import { resolve } from 'node:path'
-import { detectConfig } from './heuristic-config'
-
-/**
- * Determines if the current project is configured as an ESM project.
- * Checks the package.json file for `"type": "module"`.
- *
- * @returns Promise resolving to true if ESM, false if CommonJS
- *
- * @example
- * ```typescript
- * const isESM = await isEsmProject()
- * if (isESM) {
- *   // Generate ESM syntax
- * } else {
- *   // Generate CommonJS syntax
- * }
- * ```
- */
-async function isEsmProject (): Promise<boolean> {
-  try {
-    const packageJsonPath = resolve(process.cwd(), 'package.json')
-    const content = await readFile(packageJsonPath, 'utf-8')
-    const packageJson = JSON.parse(content)
-    return packageJson.type === 'module'
-  } catch {
-    return true // Default to ESM if package.json is not found or readable
-  }
-}
-
-/**
- * Interactive setup wizard for creating a new i18next-cli configuration file.
- *
- * This function provides a guided setup experience that:
- * 1. Asks the user for their preferred configuration file type (TypeScript or JavaScript)
- * 2. Collects basic project settings (locales, input patterns, output paths)
- * 3. Detects the project module system (ESM vs CommonJS) for JavaScript files
- * 4. Generates an appropriate configuration file with proper syntax
- * 5. Provides helpful defaults for common use cases
- *
- * The generated configuration includes:
- * - Locale specification
- * - Input file patterns for source scanning
- * - Output path templates with placeholders
- * - Proper imports and exports for the detected module system
- * - JSDoc type annotations for JavaScript files
- *
- * @example
- * ```typescript
- * // Run the interactive setup
- * await runInit()
- *
- * // This will create either:
- * // - i18next.config.ts (TypeScript)
- * // - i18next.config.js (JavaScript ESM/CommonJS)
- * ```
- */
-export async function runInit () {
-  console.log('Welcome to the i18next-cli setup wizard!')
-  console.log('Scanning your project for a recommended configuration...')
-
-  const detectedConfig = await detectConfig()
-  if (detectedConfig) {
-    console.log('✅ Found a potential project structure. Using it for suggestions.')
-  } else {
-    console.log('Could not detect a project structure. Using standard defaults.')
-  }
-  if (typeof detectedConfig?.extract?.input === 'string') detectedConfig.extract.input = [detectedConfig?.extract?.input]
-
-  // If heuristic detection returned a function for extract.output, don't use it as a prompt default.
-  // Prompt defaults must be strings; leave undefined so the prompt falls back to a sensible default.
-  if (detectedConfig && typeof detectedConfig.extract?.output === 'function') {
-    delete (detectedConfig.extract as any).output
-  }
-
-  const answers = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'fileType',
-      message: 'What kind of configuration file do you want?',
-      choices: ['TypeScript (i18next.config.ts)', 'JavaScript (i18next.config.js)'],
-    },
-    {
-      type: 'input',
-      name: 'locales',
-      message: 'What locales does your project support? (comma-separated)',
-      default: detectedConfig?.locales?.join(',') || 'en,de,fr',
-      filter: (input: string) => input.split(',').map(s => s.trim()),
-    },
-    {
-      type: 'input',
-      name: 'input',
-      message: 'What is the glob pattern for your source files?',
-      default: detectedConfig?.extract?.input ? (detectedConfig.extract.input || [])[0] : 'src/**/*.{js,jsx,ts,tsx}',
-    },
-    {
-      type: 'input',
-      name: 'output',
-      message: 'What is the path for your output resource files?',
-      // ensure the default is a string (detectedConfig.extract.output may be a function)
-      default: typeof detectedConfig?.extract?.output === 'string'
-        ? detectedConfig!.extract!.output!
-        : 'public/locales/{{language}}/{{namespace}}.json',
-    },
-  ])
-
-  const isTypeScript = answers.fileType.includes('TypeScript')
-  const isEsm = await isEsmProject()
-  const fileName = isTypeScript ? 'i18next.config.ts' : 'i18next.config.js'
-
-  const configObject = {
-    locales: answers.locales,
-    extract: {
-      input: answers.input,
-      output: answers.output,
-    },
-  }
-
-  // Helper to serialize a JS value as a JS literal:
-  function toJs (value: any, indent = 2, level = 0): string {
-    const pad = (n: number) => ' '.repeat(n * indent)
-    const currentPad = pad(level)
-    const nextPad = pad(level + 1)
-
-    if (value === null || typeof value === 'number' || typeof value === 'boolean') {
-      return JSON.stringify(value)
-    }
-    if (typeof value === 'string') {
-      return JSON.stringify(value) // keeps double quotes and proper escaping
-    }
-    if (Array.isArray(value)) {
-      if (value.length === 0) return '[]'
-      const items = value.map(v => `${nextPad}${toJs(v, indent, level + 1)}`).join(',\n')
-      return `[\n${items}\n${currentPad}]`
-    }
-    if (typeof value === 'object') {
-      const keys = Object.keys(value)
-      if (keys.length === 0) return '{}'
-      const entries = keys.map(key => {
-        // Use unquoted key if it's a valid identifier otherwise JSON.stringify(key)
-        const validId = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
-        const printedKey = validId ? key : JSON.stringify(key)
-        return `${nextPad}${printedKey}: ${toJs(value[key], indent, level + 1)}`
-      }).join(',\n')
-      return `{\n${entries}\n${currentPad}}`
-    }
-
-    // Fallback
-    return JSON.stringify(value)
-  }
-
-  let fileContent = ''
-  if (isTypeScript) {
-    fileContent = `import { defineConfig } from 'i18next-cli';
-
-export default defineConfig(${toJs(configObject)});`
-  } else if (isEsm) {
-    fileContent = `import { defineConfig } from 'i18next-cli';
-
-/** @type {import('i18next-cli').I18nextToolkitConfig} */
-export default defineConfig(${toJs(configObject)});`
-  } else { // CJS
-    fileContent = `const { defineConfig } = require('i18next-cli');
-
-/** @type {import('i18next-cli').I18nextToolkitConfig} */
-module.exports = defineConfig(${toJs(configObject)});`
-  }
-
-  const outputPath = resolve(process.cwd(), fileName)
-  await writeFile(outputPath, fileContent.trim())
-
-  console.log(`✅ Configuration file created at: ${outputPath}`)
-}

package/src/linter.ts

@@ -1,345 +0,0 @@
-import { glob } from 'glob'
-import { readFile } from 'node:fs/promises'
-import { parse } from '@swc/core'
-import { extname } from 'node:path'
-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')
-
-        // Determine parser options from file extension so .ts is not parsed as TSX
-        const fileExt = extname(file).toLowerCase()
-        const isTypeScriptFile = fileExt === '.ts' || fileExt === '.tsx' || fileExt === '.mts' || fileExt === '.cts'
-        const isTSX = fileExt === '.tsx'
-        const isJSX = fileExt === '.jsx'
-
-        let ast: any
-        try {
-          ast = await parse(code, {
-            syntax: isTypeScriptFile ? 'typescript' : 'ecmascript',
-            tsx: isTSX,
-            jsx: isJSX,
-            decorators: true
-          })
-        } catch (err) {
-          // Some projects use JSX/TSX in .ts files. Try one fallback parse with tsx:true
-          // if the original file was a .ts (not .tsx). If that still fails, emit error and continue.
-          if (fileExt === '.ts' && !isTSX) {
-            try {
-              ast = await parse(code, {
-                syntax: 'typescript',
-                tsx: true,
-                decorators: true
-              })
-              // optional: emit a progress message so consumers know a fallback happened
-              this.emit('progress', { message: `Parsed ${file} using TSX fallback` })
-            } catch (err2) {
-              const wrapped = this.wrapError(err2)
-              this.emit('error', wrapped)
-              continue
-            }
-          } else {
-            const wrapped = this.wrapError(err)
-            this.emit('error', wrapped)
-            continue
-          }
-        }
-
-        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.
- *
- * This function performs static analysis on source files to identify:
- * - Hardcoded text strings in JSX elements
- * - Hardcoded strings in JSX attributes (like alt text, titles, etc.)
- * - Text that should be extracted for translation
- *
- * The linter respects configuration settings:
- * - Uses the same input patterns as the extractor
- * - Ignores content inside configured Trans components
- * - Skips technical content like script/style tags
- * - Identifies numeric values and interpolation syntax to avoid false positives
- *
- * @param config - The toolkit configuration with input patterns and component names
- *
- * @example
- * ```typescript
- * const config = {
- *   extract: {
- *     input: ['src/**\/*.{ts,tsx}'],
- *     transComponents: ['Trans', 'Translation']
- *   }
- * }
- *
- * await runLinter(config)
- * // Outputs issues found or success message
- * ```
- */
-export async function runLinter (config: I18nextToolkitConfig) {
-  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 { 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 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}"`)
-        })
-      }
-      process.exit(1)
-    } else {
-      spinner.succeed(chalk.green.bold(message))
-    }
-  } catch (error) {
-    const wrappedError = linter.wrapError(error)
-    spinner.fail(wrappedError.message)
-    console.error(wrappedError)
-    process.exit(1)
-  }
-}
-
-/**
- * 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;
-}
-
-const isUrlOrPath = (text: string) => /^(https|http|\/\/|^\/)/.test(text)
-
-/**
- * Analyzes an AST to find potentially hardcoded strings that should be translated.
- *
- * This function traverses the syntax tree looking for:
- * 1. JSX text nodes with translatable content
- * 2. String literals in JSX attributes that might need translation
- *
- * It applies several filters to reduce false positives:
- * - Ignores content inside Trans components (already handled)
- * - Skips script and style tag content (technical, not user-facing)
- * - Filters out numeric values (usually not translatable)
- * - Ignores interpolation syntax starting with `{{`
- * - Filters out ellipsis/spread operator notation `...`
- * - Only reports non-empty, trimmed strings
- *
- * @param ast - The parsed AST to analyze
- * @param code - Original source code for line number calculation
- * @param config - Configuration containing Trans component names
- * @returns Array of found hardcoded strings with location info
- *
- * @example
- * ```typescript
- * const issues = findHardcodedStrings(ast, sourceCode, config)
- * issues.forEach(issue => {
- *   console.log(`Line ${issue.line}: "${issue.text}"`)
- * })
- * ```
- */
-function findHardcodedStrings (ast: any, code: string, config: I18nextToolkitConfig): HardcodedString[] {
-  const issues: HardcodedString[] = []
-  // A list of AST nodes that have been identified as potential issues.
-  const nodesToLint: any[] = []
-
-  const getLineNumber = (pos: number): number => {
-    return code.substring(0, pos).split('\n').length
-  }
-
-  const transComponents = config.extract.transComponents || ['Trans']
-  const defaultIgnoredAttributes = ['className', 'key', 'id', 'style', 'href', 'i18nKey', 'defaults', 'type', 'target']
-  const defaultIgnoredTags = ['script', 'style', 'code']
-  const customIgnoredTags = config.extract.ignoredTags || []
-  const allIgnoredTags = new Set([...transComponents, ...defaultIgnoredTags, ...customIgnoredTags])
-  const customIgnoredAttributes = config.extract.ignoredAttributes || []
-  const ignoredAttributes = new Set([...defaultIgnoredAttributes, ...customIgnoredAttributes])
-
-  // Helper: robustly extract a JSX element name from different node shapes
-  const extractJSXName = (node: any): string | null => {
-    if (!node) return null
-    // node might be JSXOpeningElement / JSXSelfClosingElement (has .name)
-    const nameNode = node.name ?? node.opening?.name ?? node.opening?.name
-    if (!nameNode) {
-      // maybe this node is a full JSXElement with opening.name
-      if (node.opening?.name) return extractJSXName({ name: node.opening.name })
-      return null
-    }
-
-    const fromIdentifier = (n: any): string | null => {
-      if (!n) return null
-      if (n.type === 'JSXIdentifier' && (n.name || n.value)) return (n.name ?? n.value)
-      if (n.type === 'Identifier' && (n.name || n.value)) return (n.name ?? n.value)
-      if (n.type === 'JSXMemberExpression') {
-        const object = fromIdentifier(n.object)
-        const property = fromIdentifier(n.property)
-        return object && property ? `${object}.${property}` : (property ?? object)
-      }
-      // fallback attempts
-      return n.name ?? n.value ?? n.property?.name ?? n.property?.value ?? null
-    }
-
-    return fromIdentifier(nameNode)
-  }
-
-  // Helper: return true if any JSX ancestor is in the ignored tags set
-  const isWithinIgnoredElement = (ancestors: any[]): boolean => {
-    for (let i = ancestors.length - 1; i >= 0; i--) {
-      const an = ancestors[i]
-      if (!an || typeof an !== 'object') continue
-      if (an.type === 'JSXElement' || an.type === 'JSXOpeningElement' || an.type === 'JSXSelfClosingElement') {
-        const name = extractJSXName(an)
-        if (name && allIgnoredTags.has(name)) return true
-      }
-    }
-    return false
-  }
-
-  // --- PHASE 1: Collect all potentially problematic nodes ---
-  const walk = (node: any, ancestors: any[]) => {
-    if (!node || typeof node !== 'object') return
-
-    const currentAncestors = [...ancestors, node]
-
-    if (node.type === 'JSXText') {
-      const isIgnored = isWithinIgnoredElement(currentAncestors)
-
-      if (!isIgnored) {
-        const text = node.value.trim()
-        // Filter out: empty strings, single chars, URLs, numbers, interpolations, and ellipsis
-        if (text && text.length > 1 && text !== '...' && !isUrlOrPath(text) && isNaN(Number(text)) && !text.startsWith('{{')) {
-          nodesToLint.push(node) // Collect the node
-        }
-      }
-    }
-
-    if (node.type === 'StringLiteral') {
-      const parent = currentAncestors[currentAncestors.length - 2]
-      // Determine whether this attribute is inside any ignored element (handles nested Trans etc.)
-      const insideIgnored = isWithinIgnoredElement(currentAncestors)
-
-      if (parent?.type === 'JSXAttribute' && !ignoredAttributes.has(parent.name.value) && !insideIgnored) {
-        const text = node.value.trim()
-        // Filter out: empty strings, URLs, numbers, and ellipsis
-        if (text && text !== '...' && !isUrlOrPath(text) && isNaN(Number(text))) {
-          nodesToLint.push(node) // Collect the node
-        }
-      }
-    }
-
-    // Recurse into children
-    for (const key of Object.keys(node)) {
-      if (key === 'span') continue
-      const child = node[key]
-      if (Array.isArray(child)) {
-        child.forEach(item => walk(item, currentAncestors))
-      } else if (child && typeof child === 'object') {
-        walk(child, currentAncestors)
-      }
-    }
-  }
-
-  walk(ast, []) // Run the walk to collect nodes
-
-  // --- PHASE 2: Find line numbers using a tracked search on the raw source code ---
-  let lastSearchIndex = 0
-  for (const node of nodesToLint) {
-    // For StringLiterals, the `raw` property includes the quotes ("..."), which is
-    // much more unique for searching than the plain `value`.
-    const searchText = node.raw ?? node.value
-
-    const position = code.indexOf(searchText, lastSearchIndex)
-
-    if (position > -1) {
-      issues.push({
-        text: node.value.trim(),
-        line: getLineNumber(position),
-      })
-      lastSearchIndex = position + searchText.length
-    }
-  }
-
-  return issues
-}