i18next-cli 1.24.12 → 1.24.14

package/src/utils/file-utils.ts

@@ -1,167 +0,0 @@
-import { mkdir, readFile, writeFile, access } from 'node:fs/promises'
-import { dirname, extname, resolve, normalize } from 'node:path'
-import { createJiti } from 'jiti'
-import type { I18nextToolkitConfig } from '../types'
-import { getTsConfigAliases } from '../config'
-
-/**
- * Ensures that the directory for a given file path exists.
- * Creates all necessary parent directories recursively if they don't exist.
- *
- * @param filePath - The file path for which to ensure the directory exists
- *
- * @example
- * ```typescript
- * await ensureDirectoryExists('/path/to/nested/file.json')
- * // Creates /path/to/nested/ directory if it doesn't exist
- * ```
- */
-export async function ensureDirectoryExists (filePath: string): Promise<void> {
-  const dir = dirname(filePath)
-  await mkdir(dir, { recursive: true })
-}
-
-/**
- * Reads a file asynchronously and returns its content as a UTF-8 string.
- *
- * @param filePath - The path to the file to read
- * @returns Promise resolving to the file content as a string
- *
- * @example
- * ```typescript
- * const content = await readFileAsync('./config.json')
- * const config = JSON.parse(content)
- * ```
- */
-export async function readFileAsync (filePath: string): Promise<string> {
-  return await readFile(filePath, 'utf-8')
-}
-
-/**
- * Writes data to a file asynchronously.
- *
- * @param filePath - The path where to write the file
- * @param data - The string data to write to the file
- *
- * @example
- * ```typescript
- * const jsonData = JSON.stringify({ key: 'value' }, null, 2)
- * await writeFileAsync('./output.json', jsonData)
- * ```
- */
-export async function writeFileAsync (filePath: string, data: string): Promise<void> {
-  await writeFile(filePath, data)
-}
-
-/**
- * Resolve an output template (string or function) into an actual path string.
- *
- * - If `outputTemplate` is a function, call it with (language, namespace)
- * - If it's a string, replace placeholders:
- *    - {{language}} or {{lng}} -> language
- *    - {{namespace}} -> namespace (or removed if namespace is undefined)
- * - Normalizes duplicate slashes and returns a platform-correct path.
- */
-export function getOutputPath (
-  outputTemplate: string | ((language: string, namespace?: string) => string) | undefined,
-  language: string,
-  namespace?: string
-): string {
-  if (!outputTemplate) {
-    // Fallback to a sensible default
-    return normalize(`locales/${language}/${namespace ?? 'translation'}.json`)
-  }
-
-  if (typeof outputTemplate === 'function') {
-    try {
-      const result = String(outputTemplate(language, namespace))
-      return normalize(result.replace(/\/\/+/g, '/'))
-    } catch {
-      // If user function throws, fallback to default path
-      return normalize(`locales/${language}/${namespace ?? 'translation'}.json`)
-    }
-  }
-
-  // It's a string template
-  let out = String(outputTemplate)
-  out = out.replace(/\{\{language\}\}|\{\{lng\}\}/g, language)
-
-  if (namespace !== undefined && namespace !== null) {
-    out = out.replace(/\{\{namespace\}\}/g, namespace)
-  } else {
-    // remove any occurrences of /{{namespace}} or {{namespace}} (keeping surrounding slashes tidy)
-    out = out.replace(/\/?\{\{namespace\}\}/g, '')
-  }
-
-  // collapse duplicate slashes and normalize to platform-specific separators
-  out = out.replace(/\/\/+/g, '/')
-  return normalize(out)
-}
-
-/**
- * Dynamically loads a translation file, supporting .json, .js, and .ts formats.
- * @param filePath - The path to the translation file.
- * @returns The parsed content of the file, or null if not found or failed to parse.
- */
-export async function loadTranslationFile (filePath: string): Promise<Record<string, any> | null> {
-  const fullPath = resolve(process.cwd(), filePath)
-  try {
-    await access(fullPath)
-  } catch {
-    return null // File doesn't exist
-  }
-
-  try {
-    const ext = extname(fullPath).toLowerCase()
-
-    if (ext === '.json') {
-      const content = await readFile(fullPath, 'utf-8')
-      return JSON.parse(content)
-    } else if (ext === '.ts' || ext === '.js') {
-      // Load TypeScript path aliases for proper module resolution
-      const aliases = await getTsConfigAliases()
-
-      const jiti = createJiti(process.cwd(), {
-        alias: aliases,
-        interopDefault: true,
-      })
-
-      const module = await jiti.import(fullPath, { default: true }) as unknown
-      return module as Record<string, any> | null
-    }
-
-    return null // Unsupported file type
-  } catch (error) {
-    console.warn(`Could not parse translation file ${filePath}:`, error)
-    return null
-  }
-}
-
-/**
- * Serializes a translation object into a string based on the desired format.
- * @param data - The translation data object.
- * @param format - The desired output format ('json', 'js-esm', etc.).
- * @param indentation - The number of spaces for indentation.
- * @returns The serialized file content as a string.
- */
-export function serializeTranslationFile (
-  data: Record<string, any>,
-  format: I18nextToolkitConfig['extract']['outputFormat'] = 'json',
-  indentation: number | string = 2
-): string {
-  const jsonString = JSON.stringify(data, null, indentation)
-
-  switch (format) {
-    case 'js':
-    case 'js-esm':
-      return `export default ${jsonString};\n`
-    case 'js-cjs':
-      return `module.exports = ${jsonString};\n`
-    case 'ts':
-      // Using `as const` provides better type inference for TypeScript users
-      return `export default ${jsonString} as const;\n`
-    case 'json':
-    default:
-      return `${jsonString}\n`
-  }
-}

package/src/utils/funnel-msg-tracker.ts

@@ -1,84 +0,0 @@
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-import { readFile, writeFile } from 'node:fs/promises'
-
-/**
- * In-memory cache to track which funnel messages have been shown in the current session.
- */
-const hasLocizeFunnelBeenShown: Record<string, boolean> = {}
-
-/**
- * Path to the persistent file that stores the last time each funnel message was shown.
- * Stored in the OS temporary directory to persist across CLI sessions.
- */
-const LAST_FUNNEL_FILE = join(tmpdir(), 'i18next-cli-last-funnel-message-shown.json') // Store in OS temp dir
-
-/**
- * Cooldown period in milliseconds before a funnel message can be shown again.
- * Currently set to 24 hours.
- */
-const TIP_COOLDOWN_MS = 24 * 60 * 60 * 1000 // 24 hours
-
-/**
- * Determines whether a funnel message should be shown to the user.
- *
- * A funnel message will not be shown if:
- * - It has already been shown in the current session (in-memory cache)
- * - It was shown within the last 24 hours (persistent file cache)
- *
- * @param funnelMessage - The unique identifier for the funnel message
- * @returns Promise that resolves to true if the message should be shown, false otherwise
- */
-export async function shouldShowFunnel (funnelMessage: string): Promise<boolean> {
-  if (hasLocizeFunnelBeenShown[funnelMessage]) return false
-
-  try {
-    const content = await readFile(LAST_FUNNEL_FILE, 'utf-8')
-    const cnt: Record<string, number> = JSON.parse(content)
-    if (Date.now() - (cnt[funnelMessage] || 0) < TIP_COOLDOWN_MS) {
-      return false // Less than 24 hours since last shown
-    }
-  } catch (e) {
-    // File doesn't exist or is invalid, assume it's okay to show the tip
-  }
-  return true
-}
-
-/**
- * Records that a funnel message has been shown to the user.
- *
- * Updates both the in-memory cache and the persistent file cache with the current timestamp.
- * This prevents the message from being shown again within the cooldown period.
- *
- * @param funnelMessage - The unique identifier for the funnel message that was shown
- * @returns Promise that resolves when the record has been updated
- */
-export async function recordFunnelShown (funnelMessage: string): Promise<void> {
-  try {
-    hasLocizeFunnelBeenShown[funnelMessage] = true
-    let data: Record<string, number> = {}
-    try {
-      const existing = await readFile(LAST_FUNNEL_FILE, 'utf-8')
-      data = JSON.parse(existing) as Record<string, number>
-    } catch (err) {
-      // ignore, we'll create a new file
-    }
-    data[funnelMessage] = Date.now()
-    await writeFile(LAST_FUNNEL_FILE, JSON.stringify(data))
-  } catch (e) {
-    // Ignore errors here, it's just a best-effort cache
-  }
-}
-
-/**
- * Resets the in-memory cache for a specific funnel message.
- *
- * This function is intended for testing purposes only. It clears the session cache
- * but does not affect the persistent file cache.
- *
- * @param funnelMessage - The unique identifier for the funnel message to reset
- */
-// just for the tests
-export function reset (funnelMessage: string) {
-  delete hasLocizeFunnelBeenShown[funnelMessage]
-}

package/src/utils/logger.ts

@@ -1,36 +0,0 @@
-import type { Logger } from '../types'
-
-/**
- * Default console-based logger implementation for the i18next toolkit.
- * Provides basic logging functionality with different severity levels.
- *
- * @example
- * ```typescript
- * const logger = new ConsoleLogger()
- * logger.info('Extraction started')
- * logger.warn('Deprecated configuration option used')
- * logger.error('Failed to parse file')
- * ```
- */
-export class ConsoleLogger implements Logger {
-  /**
-   * Logs an informational message to the console.
-   *
-   * @param message - The message to log
-   */
-  info (message: string): void { console.log(message) }
-
-  /**
-   * Logs a warning message to the console.
-   *
-   * @param message - The warning message to log
-   */
-  warn (message: string): void { console.warn(message) }
-
-  /**
-   * Logs an error message to the console.
-   *
-   * @param message - The error message to log
-   */
-  error (message: string): void { console.error(message) }
-}

package/src/utils/nested-object.ts

@@ -1,135 +0,0 @@
-/**
- * Sets a nested value in an object using a key path and separator.
- * Creates intermediate objects as needed.
- *
- * @param obj - The target object to modify
- * @param path - The key path (e.g., 'user.profile.name')
- * @param value - The value to set
- * @param keySeparator - The separator to use for splitting the path, or false for flat keys
- *
- * @example
- * ```typescript
- * const obj = {}
- * setNestedValue(obj, 'user.profile.name', 'John', '.')
- * // Result: { user: { profile: { name: 'John' } } }
- *
- * // With flat keys
- * setNestedValue(obj, 'user.name', 'Jane', false)
- * // Result: { 'user.name': 'Jane' }
- * ```
- */
-export function setNestedValue (
-  obj: Record<string, any>,
-  path: string,
-  value: any,
-  keySeparator: string | false
-): void {
-  if (keySeparator === false) {
-    obj[path] = value
-    return
-  }
-
-  const keys = path.split(keySeparator)
-  let current = obj
-
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i]
-    const isLastKey = i === keys.length - 1
-
-    if (isLastKey) {
-      // We've reached the end of the path, set the value.
-      current[key] = value
-      return
-    }
-
-    const nextLevel = current[key]
-
-    // Check for a conflict: the path requires an object, but a primitive exists.
-    if (nextLevel !== undefined && (typeof nextLevel !== 'object' || nextLevel === null)) {
-      // Conflict detected. The parent path is already a leaf node.
-      // We must set the entire original path as a flat key on the root object.
-      obj[path] = value
-      return // Stop processing to prevent overwriting the parent.
-    }
-
-    // If the path doesn't exist, create an empty object to continue.
-    if (nextLevel === undefined) {
-      current[key] = {}
-    }
-
-    current = current[key]
-  }
-}
-
-/**
- * Retrieves a nested value from an object using a key path and separator.
- *
- * @param obj - The object to search in
- * @param path - The key path (e.g., 'user.profile.name')
- * @param keySeparator - The separator to use for splitting the path, or false for flat keys
- * @returns The found value or undefined if not found
- *
- * @example
- * ```typescript
- * const obj = { user: { profile: { name: 'John' } } }
- * const name = getNestedValue(obj, 'user.profile.name', '.')
- * // Returns: 'John'
- *
- * // With flat keys
- * const flatObj = { 'user.name': 'Jane' }
- * const name = getNestedValue(flatObj, 'user.name', false)
- * // Returns: 'Jane'
- * ```
- */
-export function getNestedValue (
-  obj: Record<string, any>,
-  path: string,
-  keySeparator: string | false
-): any {
-  if (keySeparator === false) {
-    return obj[path]
-  }
-  return path.split(keySeparator).reduce((acc, key) => acc && acc[key], obj)
-}
-
-/**
- * Extracts all nested keys from an object, optionally with a prefix.
- * Recursively traverses the object structure to build a flat list of key paths.
- *
- * @param obj - The object to extract keys from
- * @param keySeparator - The separator to use for joining keys, or false for flat keys
- * @param prefix - Optional prefix to prepend to all keys
- * @returns Array of all nested key paths
- *
- * @example
- * ```typescript
- * const obj = {
- *   user: {
- *     profile: { name: 'John', age: 30 },
- *     settings: { theme: 'dark' }
- *   }
- * }
- *
- * const keys = getNestedKeys(obj, '.')
- * // Returns: ['user.profile.name', 'user.profile.age', 'user.settings.theme']
- *
- * // With flat keys
- * const flatObj = { 'user.name': 'Jane', 'user.age': 25 }
- * const flatKeys = getNestedKeys(flatObj, false)
- * // Returns: ['user.name', 'user.age']
- * ```
- */
-export function getNestedKeys (obj: object, keySeparator: string | false, prefix = ''): string[] {
-  if (keySeparator === false) {
-    return Object.keys(obj)
-  }
-  return Object.entries(obj).reduce((acc, [key, value]) => {
-    const newKey = prefix ? `${prefix}${keySeparator}${key}` : key
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-      acc.push(...getNestedKeys(value, keySeparator, newKey))
-    } else {
-      acc.push(newKey)
-    }
-    return acc
-  }, [] as string[])
-}

package/src/utils/validation.ts

@@ -1,72 +0,0 @@
-import type { I18nextToolkitConfig } from '../types'
-
-/**
- * Validates the extractor configuration to ensure required fields are present and properly formatted.
- *
- * This function performs the following validations:
- * - Ensures extract.input is specified and non-empty
- * - Ensures extract.output is specified
- * - Ensures locales array is specified and non-empty
- * - Ensures extract.output contains the required {{language}} placeholder
- *
- * @param config - The i18next toolkit configuration object to validate
- *
- * @throws {ExtractorError} When any validation rule fails
- *
- * @example
- * ```typescript
- * try {
- *   validateExtractorConfig(config)
- *   console.log('Configuration is valid')
- * } catch (error) {
- *   console.error('Invalid configuration:', error.message)
- * }
- * ```
- */
-export function validateExtractorConfig (config: I18nextToolkitConfig): void {
-  if (!config.extract.input?.length) {
-    throw new ExtractorError('extract.input must be specified and non-empty')
-  }
-
-  if (!config.extract.output) {
-    throw new ExtractorError('extract.output must be specified')
-  }
-
-  if (!config.locales?.length) {
-    throw new ExtractorError('locales must be specified and non-empty')
-  }
-
-  // If output is a function, we accept it (user is responsible for producing a valid path).
-  if (typeof config.extract.output === 'string') {
-    if (!config.extract.output.includes('{{language}}') && !config.extract.output.includes('{{lng}}')) {
-      throw new ExtractorError('extract.output must contain {{language}} placeholder')
-    }
-  }
-}
-
-/**
- * Custom error class for extraction-related errors.
- * Provides additional context like file path and underlying cause.
- *
- * @example
- * ```typescript
- * throw new ExtractorError('Failed to parse file', 'src/component.tsx', syntaxError)
- * ```
- */
-export class ExtractorError extends Error {
-  /**
-   * Creates a new ExtractorError with optional file context and cause.
-   *
-   * @param message - The error message
-   * @param file - Optional file path where the error occurred
-   * @param cause - Optional underlying error that caused this error
-   */
-  constructor (
-    message: string,
-    public readonly file?: string,
-    public readonly cause?: Error
-  ) {
-    super(file ? `${message} in file ${file}` : message)
-    this.name = 'ExtractorError'
-  }
-}