i18next-cli 1.46.4 → 1.47.0

package/dist/esm/instrumenter/core/key-generator.js

@@ -0,0 +1,68 @@
+/**
+ * Generates camelCase keys from English string content.
+ *
+ * Examples:
+ *   "Welcome back" → "welcomeBack"
+ *   "Hello, World!" → "helloWorld"
+ *   "You have 3 items" → "youHave3Items"
+ *
+ * @param content - The string content to derive a key from
+ * @returns camelCase key
+ */
+function generateKeyFromContent(content) {
+    // Remove punctuation and split by whitespace and word boundaries
+    const normalized = content
+        .replace(/[^\w\s\d]/g, '') // Remove punctuation
+        .trim();
+    if (!normalized) {
+        return 'key';
+    }
+    // Split on whitespace and camelCase
+    const words = normalized.split(/\s+/);
+    const camelCased = words
+        .map((word, index) => {
+        if (index === 0) {
+            return word.toLowerCase();
+        }
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+        .join('');
+    // If result is empty, use fallback
+    return camelCased.length > 0 ? camelCased : 'key';
+}
+/**
+ * Creates a new key registry with collision detection.
+ */
+function createKeyRegistry() {
+    const keys = new Map();
+    return {
+        keys,
+        add(baseKey, content) {
+            const existing = keys.get(baseKey);
+            // No collision - add the key
+            if (!existing) {
+                keys.set(baseKey, content);
+                return baseKey;
+            }
+            // Same content already exists - return the existing key
+            if (existing === content) {
+                return baseKey;
+            }
+            // Collision detected - try with numeric suffixes
+            let counter = 2;
+            let candidateKey = `${baseKey}${counter}`;
+            while (keys.has(candidateKey)) {
+                const candidate = keys.get(candidateKey);
+                if (candidate === content) {
+                    return candidateKey; // This exact content already has a numbered key
+                }
+                counter++;
+                candidateKey = `${baseKey}${counter}`;
+            }
+            keys.set(candidateKey, content);
+            return candidateKey;
+        }
+    };
+}
+
+export { createKeyRegistry, generateKeyFromContent };

package/dist/esm/instrumenter/core/string-detector.js

@@ -0,0 +1,288 @@
+import { lineColumnFromOffset } from '../../extractor/parsers/ast-utils.js';
+import { translatableAttributeSet, translatablePropertySet } from '../../utils/jsx-attributes.js';
+
+/**
+ * Detects if a string is a candidate for translation based on confidence heuristics.
+ * Returns null if the string should be skipped, otherwise returns a CandidateString
+ * with a confidence score.
+ *
+ * When a custom scorer is provided via `config.extract.instrumentScorer`, it is
+ * called after the built-in skip checks. The scorer can:
+ * - Return a number (0-1) to override the confidence score
+ * - Return `null` to force-skip the candidate
+ * - Return `undefined` to fall back to the built-in heuristic
+ *
+ * **Important:** This uses heuristic-based detection and will not catch 100% of cases.
+ * False positives and false negatives are expected. The results serve as a starting point
+ * for manual review and refinement. Always review the generated transformations before
+ * committing them to your codebase.
+ *
+ * @param content - The string content to evaluate
+ * @param offset - Byte offset in file (normalized)
+ * @param endOffset - End byte offset in file
+ * @param file - Source file path
+ * @param code - Full source code for context
+ * @param config - Toolkit configuration
+ * @returns CandidateString with confidence score, or null if should be skipped
+ */
+function detectCandidate(content, offset, endOffset, file, code, config) {
+    const skipReason = shouldSkip(content, file, code, offset, endOffset);
+    if (skipReason) {
+        return null;
+    }
+    const position = lineColumnFromOffset(code, offset) ?? { line: 0, column: 0 };
+    const { line, column } = position;
+    // If a custom scorer is provided, call it first
+    const customScorer = config.extract?.instrumentScorer;
+    if (customScorer) {
+        const beforeContext = code.substring(Math.max(0, offset - 100), offset);
+        const afterContext = code.substring(endOffset, Math.min(code.length, endOffset + 100));
+        const customResult = customScorer(content, { file, offset, code, beforeContext, afterContext });
+        if (customResult === null) {
+            return null; // Custom scorer says skip
+        }
+        if (typeof customResult === 'number') {
+            return {
+                content,
+                confidence: Math.max(0, Math.min(1, customResult)),
+                offset,
+                endOffset,
+                type: 'string-literal',
+                file,
+                line,
+                column
+            };
+        }
+        // customResult === undefined → fall through to built-in heuristic
+    }
+    const confidence = calculateConfidence(content, code, offset);
+    return {
+        content,
+        confidence,
+        offset,
+        endOffset,
+        type: 'string-literal',
+        file,
+        line,
+        column
+    };
+}
+/**
+ * Determines if a string should be skipped from instrumentation.
+ *
+ * @returns Skip reason if should be skipped, null otherwise
+ */
+function shouldSkip(content, file, code, offset, endOffset, config) {
+    // Skip test files
+    if (file.match(/\.(test|spec)\.(ts|tsx|js|jsx)$/i)) {
+        return 'Test file';
+    }
+    // Skip empty strings and single characters
+    if (!content || content.length <= 1) {
+        return 'Empty or single character';
+    }
+    // Skip pure whitespace
+    if (/^\s+$/.test(content)) {
+        return 'Whitespace only';
+    }
+    // Skip pure numbers (including decimals and negative numbers)
+    if (/^-?\d+(\.\d+)?$/.test(content)) {
+        return 'Pure number';
+    }
+    // Skip URL-like strings
+    if (isURLLike(content)) {
+        return 'URL or path';
+    }
+    // Skip technical strings: attribute values, class names, technical IDs
+    if (isTechnicalString(content)) {
+        return 'Technical string';
+    }
+    // Skip developer-facing error codes (all-caps, underscore-delimited)
+    if (isErrorCode(content)) {
+        return 'Error code pattern';
+    }
+    // Skip strings that are already wrapped in t() or Trans components
+    if (isAlreadyInstrumented(code, offset, endOffset)) {
+        return 'Already instrumented';
+    }
+    // Skip console.log/warn/error arguments
+    if (isConsoleArgument(code, offset)) {
+        return 'Console argument';
+    }
+    // Skip HTML/JSX attribute values that are clearly technical
+    if (isAttributeValue(code, offset)) {
+        return 'HTML attribute value';
+    }
+    return null;
+}
+/**
+ * Checks if a string looks like a URL or file path.
+ */
+function isURLLike(str) {
+    // URLs: http://, https://, ftp://, file://, mailto:, etc.
+    if (/^(https?|ftp|file|mailto|data):/.test(str))
+        return true;
+    // File paths: ./path, ../path, /absolute/path, C:\windows\path
+    if (/^(\.\.?\/|\/|[A-Za-z]:\\)/.test(str))
+        return true;
+    // Import paths (common patterns) — must have no spaces to avoid false positives on sentences
+    if (/^['"]?[@a-z][\w-]*/.test(str.toLowerCase()) && !str.includes(' ') && (str.includes('/') || str.includes('.'))) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks if a string is technical (class name, HTML attribute, IDs, etc).
+ */
+function isTechnicalString(str) {
+    // kebab-case or camelCase all lowercase suggests CSS class or technical ID
+    if (/^[a-z0-9-_]+$/.test(str) && str.length < 30) {
+        return true;
+    }
+    // HTML attribute patterns like type="text", role="button", etc.
+    if (/^(type|role|aria-|data-|href|src|id|class|name)$/i.test(str)) {
+        return true;
+    }
+    // Very short all-uppercase abbreviations (CSS, DOM, API, URL, etc.)
+    if (/^[A-Z]{2,3}$/.test(str)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks if a string looks like a developer-facing error code.
+ * Examples: ERROR_NOT_FOUND, ERR_INVALID_TOKEN, etc.
+ */
+function isErrorCode(str) {
+    // All uppercase with underscores, typically error codes
+    if (/^[A-Z][A-Z0-9_]*$/.test(str) && str.includes('_') && str.length > 3) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks if a string is already wrapped in a t() call or Trans component.
+ */
+function isAlreadyInstrumented(code, offset, endOffset) {
+    // Look backwards for t( — use 20 chars to cover patterns like `i18next.t(`
+    const beforeStr = code.substring(Math.max(0, offset - 20), offset);
+    if (beforeStr.includes('t(') || beforeStr.includes('.t(')) {
+        return true;
+    }
+    // Look forward for ) or Trans opening
+    const afterStr = code.substring(endOffset, Math.min(code.length, endOffset + 20));
+    if (afterStr.startsWith(')') || afterStr.includes('Trans')) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks if this string is inside a console.log/warn/error call.
+ */
+function isConsoleArgument(code, offset) {
+    const beforeStr = code.substring(Math.max(0, offset - 100), offset);
+    return /console\.(log|warn|error|info|debug|trace)\s*\(\s*["']?\s*$/.test(beforeStr);
+}
+// Translatable attribute and property sets are defined in
+// utils/jsx-attributes.ts and shared with the linter.
+const TRANSLATABLE_ATTRIBUTES = translatableAttributeSet;
+const TRANSLATABLE_PROPERTIES = translatablePropertySet;
+/**
+ * Checks if the string appears to be an HTML/JSX attribute value.
+ * Returns true only for *technical* attribute values that should be skipped.
+ * Translatable attributes (placeholder, title, alt, aria-label, etc.) are
+ * allowed through so they can be instrumented.
+ */
+function isAttributeValue(code, offset) {
+    // Note: offset points at the opening quote character, so beforeStr goes up to
+    // (but does not include) that quote. We check for `attr=` at the end.
+    const beforeStr = code.substring(Math.max(0, offset - 50), offset);
+    // Pattern: attributeName="..." or attributeName='...'
+    // Require `=` immediately before the quote (no trailing space) to
+    // distinguish JSX attributes (`placeholder="..."`  — no space) from JS
+    // variable assignments (`const x = "..."`  — space before quote).
+    const match = beforeStr.match(/([\w-]+)\s*=$/);
+    if (match) {
+        const attrName = match[1].toLowerCase();
+        // Allow translatable attributes to pass through
+        if (TRANSLATABLE_ATTRIBUTES.has(attrName)) {
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Calculates a confidence score (0-1) for a candidate string.
+ * Higher scores indicate higher likelihood of being user-facing content.
+ *
+ * **Note:** This is a heuristic-based approach and won't be 100% accurate.
+ * High-confidence strings should still be reviewed by developers before final deployment.
+ * Use this as a first pass to identify candidates, not as an authoritative decision.
+ */
+function calculateConfidence(content, code, offset) {
+    let confidence = 0.5; // Base confidence
+    // Longer sentences are more likely to be translatable
+    const wordCount = content.split(/\s+/).length;
+    if (wordCount >= 3) {
+        confidence += 0.2;
+    }
+    else if (wordCount === 2) {
+        confidence += 0.1;
+    }
+    // Contains common sentence starters (user-facing)
+    if (/^(the|a|an|you|your|we|our|hello|welcome|please|thank|sorry)/i.test(content)) {
+        confidence += 0.15;
+    }
+    // Contains punctuation (sentences)
+    if (/[.!?]$/.test(content)) {
+        confidence += 0.1;
+    }
+    // Contains mixed case (likely English, not technical)
+    if (/[A-Z].*[a-z].*[A-Z]/.test(content) || /[a-z].*[A-Z]/.test(content)) {
+        confidence += 0.05;
+    }
+    // Contains numbers mixed with words (like "Step 1")
+    if (/\d.*[a-z]|[a-z].*\d/i.test(content)) {
+        confidence += 0.05;
+    }
+    // Contains action verb (likely a button or instruction)
+    if (/^(click|save|delete|create|update|submit|continue|back|next|yes|no|ok|close|open|download|upload|add|edit|remove|cancel|confirm|send|search|find|apply|reset|clear|done|finish|start|stop|retry|sign|log)/i.test(content)) {
+        confidence += 0.1;
+    }
+    // Reduce confidence if appears in specific technical contexts
+    const beforeContext = code.substring(Math.max(0, offset - 40), offset);
+    const afterContext = code.substring(offset, Math.min(code.length, offset + 20));
+    // Import paths, requires, etc.
+    if (/from\s+$|require\s*\(\s*$|import\s+$/.test(beforeContext)) {
+        confidence -= 0.3;
+    }
+    // HTML/JSX attribute values (offset is at opening quote, so beforeContext ends with `=`)
+    const attrCtxMatch = beforeContext.match(/([\w-]+)\s*=$/);
+    if (attrCtxMatch) {
+        const attrName = attrCtxMatch[1].toLowerCase();
+        if (TRANSLATABLE_ATTRIBUTES.has(attrName)) {
+            confidence += 0.15; // Translatable attribute — boost
+        }
+        else {
+            confidence -= 0.2;
+        }
+    }
+    // Object-property context:  { label: 'All', description: 'Some text' }
+    // When the property name is a translatable-sounding key, boost confidence
+    const propMatch = beforeContext.match(/(\w+)\s*:\s*$/);
+    if (propMatch && !attrCtxMatch) {
+        const propName = propMatch[1].toLowerCase();
+        if (TRANSLATABLE_PROPERTIES.has(propName)) {
+            confidence += 0.25;
+        }
+    }
+    // Regular expressions or patterns
+    if (/\//.test(content) && /regex|pattern|match|search/i.test(beforeContext + afterContext)) {
+        confidence -= 0.15;
+    }
+    // Clamp to [0, 1]
+    return Math.max(0, Math.min(1, confidence));
+}
+
+export { detectCandidate };

package/dist/esm/instrumenter/core/transformer.js

@@ -0,0 +1,336 @@
+import MagicString from 'magic-string';
+import { generateKeyFromContent } from './key-generator.js';
+
+/**
+ * Transforms a source file, replacing candidate strings with instrumented code.
+ * Also injects useTranslation() hooks into React function components that
+ * contain transformed strings.
+ *
+ * @param content - Original source code
+ * @param file - File path
+ * @param candidates - Candidate strings to transform
+ * @param options - Transformation options
+ * @returns TransformResult with modified content and diff
+ */
+function transformFile(content, file, candidates, options) {
+    const s = new MagicString(content);
+    const errors = [];
+    const warnings = [];
+    let transformCount = 0;
+    const injections = {
+        importAdded: false,
+        hookInjected: false
+    };
+    // Filter high-confidence candidates
+    const highConfidenceCandidates = candidates.filter(c => c.confidence >= 0.7);
+    // Track which components have transformed candidates
+    const transformedComponents = new Set();
+    let hasComponentCandidates = false;
+    let hasNonComponentCandidates = false;
+    // ── Language-change site injections ────────────────────────────────────
+    const languageChangeSites = options.languageChangeSites || [];
+    // Track components that need `i18n` from useTranslation()
+    const componentsNeedingI18n = new Set();
+    let languageChangeCount = 0;
+    // Apply language-change injections in reverse order (to preserve offsets)
+    const sortedSites = [...languageChangeSites].sort((a, b) => b.callStart - a.callStart);
+    for (const site of sortedSites) {
+        try {
+            const changeCall = site.insideComponent
+                ? `i18n.changeLanguage(${site.languageExpression})`
+                : `i18next.changeLanguage(${site.languageExpression})`;
+            // Check if the call is the expression body of an arrow function (no braces):
+            //   () => updateSettings({ language: code })
+            // We need to wrap it:
+            //   () => { i18n.changeLanguage(code); updateSettings({ language: code }); }
+            const beforeCall = content.slice(0, site.callStart);
+            const arrowMatch = beforeCall.match(/=>\s*$/);
+            if (arrowMatch) {
+                // Arrow function expression body → wrap in block
+                const originalCall = content.slice(site.callStart, site.callEnd);
+                s.overwrite(site.callStart, site.callEnd, `{ ${changeCall}; ${originalCall}; }`);
+            }
+            else {
+                // Already in a block → prepend as a statement
+                s.appendLeft(site.callStart, `${changeCall}; `);
+            }
+            languageChangeCount++;
+            if (site.insideComponent) {
+                componentsNeedingI18n.add(site.insideComponent);
+                transformedComponents.add(site.insideComponent);
+                hasComponentCandidates = true;
+            }
+            else {
+                hasNonComponentCandidates = true;
+            }
+        }
+        catch (err) {
+            errors.push(`Failed to inject changeLanguage at offset ${site.callStart}: ${err}`);
+        }
+    }
+    // Apply transformations in reverse order (to maintain correct offsets)
+    for (let i = highConfidenceCandidates.length - 1; i >= 0; i--) {
+        const candidate = highConfidenceCandidates[i];
+        try {
+            const key = candidate.key || generateKeyFromContent(candidate.content);
+            const useHookStyle = !!candidate.insideComponent;
+            const defaultNS = options.config.extract?.defaultNS ?? 'translation';
+            const nsForReplacement = (options.namespace && options.namespace !== defaultNS) ? options.namespace : undefined;
+            const replacement = buildReplacement(candidate, key, useHookStyle, nsForReplacement);
+            if (replacement) {
+                s.overwrite(candidate.offset, candidate.endOffset, replacement);
+                transformCount++;
+                if (candidate.insideComponent) {
+                    transformedComponents.add(candidate.insideComponent);
+                    hasComponentCandidates = true;
+                }
+                else {
+                    hasNonComponentCandidates = true;
+                }
+            }
+        }
+        catch (err) {
+            errors.push(`Failed to transform candidate at offset ${candidate.offset}: ${err}`);
+        }
+    }
+    // Add necessary imports and hooks if any transformations were made
+    if (transformCount > 0 || languageChangeCount > 0) {
+        const components = options.components || [];
+        // Inject useTranslation() hooks into affected React components
+        if (options.hasReact && transformedComponents.size > 0) {
+            // Process components in reverse order of bodyStart to avoid offset shifts
+            const affectedComponents = components
+                .filter(c => transformedComponents.has(c.name) && !c.hasUseTranslation)
+                .sort((a, b) => b.bodyStart - a.bodyStart);
+            for (const comp of affectedComponents) {
+                const indent = detectIndent(content, comp.bodyStart);
+                const defaultNS = options.config.extract?.defaultNS ?? 'translation';
+                const nsArg = (options.namespace && options.namespace !== defaultNS) ? `'${options.namespace}'` : '';
+                // Build destructuring: include `t` if the component has string candidates,
+                // include `i18n` if the component has language-change sites.
+                const needsT = highConfidenceCandidates.some(c => c.insideComponent === comp.name);
+                const needsI18n = componentsNeedingI18n.has(comp.name);
+                const parts = [];
+                if (needsT)
+                    parts.push('t');
+                if (needsI18n)
+                    parts.push('i18n');
+                if (parts.length === 0)
+                    parts.push('t'); // fallback
+                const destructured = `{ ${parts.join(', ')} }`;
+                s.appendRight(comp.bodyStart + 1, `\n${indent}const ${destructured} = useTranslation(${nsArg})`);
+                injections.hookInjected = true;
+            }
+            // For components that already have useTranslation but need i18n added,
+            // try to upgrade `const { t } = useTranslation(...)` → `const { t, i18n } = useTranslation(...)`
+            if (componentsNeedingI18n.size > 0) {
+                const compsWithExistingHook = components.filter(c => componentsNeedingI18n.has(c.name) && c.hasUseTranslation);
+                for (const comp of compsWithExistingHook) {
+                    // Search for the destructuring pattern within the component body
+                    const bodyText = content.slice(comp.bodyStart, comp.bodyEnd);
+                    // Skip if i18n is already destructured
+                    if (/const\s*\{[^}]*\bi18n\b[^}]*\}\s*=\s*useTranslation/.test(bodyText))
+                        continue;
+                    // Match `{ t }` or `{ t, ... }` in `const { t } = useTranslation`
+                    const hookRe = /const\s*\{\s*t\s*\}\s*=\s*useTranslation/;
+                    const hookMatch = hookRe.exec(bodyText);
+                    if (hookMatch) {
+                        const absStart = comp.bodyStart + hookMatch.index;
+                        const absEnd = absStart + hookMatch[0].length;
+                        const upgraded = hookMatch[0].replace(/\{\s*t\s*\}/, '{ t, i18n }');
+                        s.overwrite(absStart, absEnd, upgraded);
+                    }
+                }
+            }
+        }
+        // Add import statements
+        addImportStatements(s, content, {
+            needsUseTranslation: hasComponentCandidates && options.hasReact,
+            needsI18next: hasNonComponentCandidates || !options.hasReact
+        });
+        injections.importAdded = true;
+    }
+    // Warn when i18next.t() is used in React projects (translations may not be loaded yet)
+    if (options.hasReact && hasNonComponentCandidates && transformCount > 0) {
+        warnings.push(`${file}: i18next.t() was added outside of a React component. ` +
+            'If translation resources are loaded asynchronously, i18next.t() may return the key instead of the translation. ' +
+            'Consider moving this text into a component and using the useTranslation() hook, or ensure i18next is fully initialized before this code runs. ' +
+            'See: https://www.locize.com/blog/how-to-use-i18next-t-outside-react-components/');
+    }
+    const newContent = s.toString();
+    const diff = generateDiff(content, newContent, file);
+    const totalChanges = transformCount + languageChangeCount;
+    return {
+        modified: totalChanges > 0,
+        newContent: !options.isDryRun ? newContent : undefined,
+        diff,
+        errors,
+        warnings,
+        transformCount,
+        languageChangeCount,
+        injections
+    };
+}
+/**
+ * Builds the replacement code for a candidate string.
+ *
+ * @param candidate - The candidate to replace
+ * @param key - The i18n key to use
+ * @param useHookStyle - If true, uses t() (from useTranslation hook); otherwise uses i18next.t()
+ * @param namespace - Optional namespace (only set when different from defaultNS)
+ */
+function buildReplacement(candidate, key, useHookStyle, namespace) {
+    const tFunc = useHookStyle ? 't' : 'i18next.t';
+    const escapedContent = escapeString(candidate.content);
+    // ── Plural form: t('key', { defaultValue_zero: '…', …, count: expr }) ──
+    if (candidate.pluralForms) {
+        const pf = candidate.pluralForms;
+        const optionEntries = [];
+        if (pf.zero !== undefined) {
+            optionEntries.push(`defaultValue_zero: '${escapeString(pf.zero)}'`);
+        }
+        if (pf.one !== undefined) {
+            optionEntries.push(`defaultValue_one: '${escapeString(pf.one)}'`);
+        }
+        optionEntries.push(`defaultValue_other: '${escapeString(pf.other)}'`);
+        optionEntries.push(`count: ${pf.countExpression}`);
+        if (!useHookStyle && namespace) {
+            optionEntries.push(`ns: '${namespace}'`);
+        }
+        const tCall = `${tFunc}('${key}', { ${optionEntries.join(', ')} })`;
+        switch (candidate.type) {
+            case 'jsx-text':
+            case 'jsx-attribute':
+                return `{${tCall}}`;
+            default:
+                return tCall;
+        }
+    }
+    // Build the optional third argument: { interpolationVars..., ns? }
+    const optionEntries = [];
+    if (candidate.interpolations?.length) {
+        for (const interp of candidate.interpolations) {
+            optionEntries.push(interp.name === interp.expression ? interp.name : `${interp.name}: ${interp.expression}`);
+        }
+    }
+    if (!useHookStyle && namespace) {
+        optionEntries.push(`ns: '${namespace}'`);
+    }
+    const optionsArg = optionEntries.length > 0 ? `, { ${optionEntries.join(', ')} }` : '';
+    const tCall = `${tFunc}('${key}', '${escapedContent}'${optionsArg})`;
+    switch (candidate.type) {
+        case 'jsx-text':
+        case 'jsx-attribute':
+            return `{${tCall}}`;
+        case 'jsx-mixed':
+            if (useHookStyle) {
+                return `<Trans i18nKey="${key}">${candidate.content}</Trans>`;
+            }
+            return candidate.content;
+        case 'template-literal':
+        case 'string-literal':
+        default:
+            return tCall;
+    }
+}
+/**
+ * Escapes a string for use in generated code.
+ */
+function escapeString(str) {
+    return str
+        .replace(/\\/g, '\\\\') // Escape backslashes first
+        .replace(/'/g, "\\'") // Escape single quotes
+        .replace(/\n/g, '\\n') // Escape newlines
+        .replace(/\r/g, '\\r') // Escape carriage returns
+        .replace(/\t/g, '\\t'); // Escape tabs
+}
+/**
+ * Checks if an import statement for a module already exists.
+ */
+function hasImport(content, moduleName) {
+    const importRegex = new RegExp(`import\\s+.*from\\s+['"]${moduleName}['"]`, 'g');
+    const requireRegex = new RegExp(`require\\(['"]${moduleName}['"]\\)`, 'g');
+    return importRegex.test(content) || requireRegex.test(content);
+}
+/**
+ * Detects the indentation level used after an opening brace.
+ * Skips blank lines and reads the whitespace of the first line that has actual content.
+ */
+function detectIndent(content, braceOffset) {
+    let searchFrom = braceOffset;
+    while (searchFrom < content.length) {
+        const newlinePos = content.indexOf('\n', searchFrom);
+        if (newlinePos === -1)
+            return '  ';
+        let indent = '';
+        let i = newlinePos + 1;
+        while (i < content.length && (content[i] === ' ' || content[i] === '\t')) {
+            indent += content[i];
+            i++;
+        }
+        // If this line has actual content (not just empty / blank), use its indentation
+        if (i < content.length && content[i] !== '\n' && content[i] !== '\r') {
+            return indent || '  ';
+        }
+        // Empty line — continue looking at the next line
+        searchFrom = i;
+    }
+    return '  ';
+}
+/**
+ * Adds necessary import statements (useTranslation and/or i18next).
+ */
+function addImportStatements(s, content, needs) {
+    let importStatement = '';
+    if (needs.needsUseTranslation && !hasImport(content, 'react-i18next')) {
+        importStatement += "import { useTranslation } from 'react-i18next'\n";
+    }
+    if (needs.needsI18next && !hasImport(content, 'i18next')) {
+        importStatement += "import i18next from 'i18next'\n";
+    }
+    if (!importStatement)
+        return;
+    // Insert after the last existing import statement, or at the top of the file
+    let insertPos = 0;
+    // Skip shebang if present
+    if (content.startsWith('#!')) {
+        insertPos = content.indexOf('\n') + 1;
+    }
+    // Find the end of the last import statement
+    const importRegex = /^import\s.+$/gm;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+        const endOfImport = match.index + match[0].length;
+        if (endOfImport > insertPos) {
+            const nextNewline = content.indexOf('\n', endOfImport);
+            insertPos = nextNewline !== -1 ? nextNewline + 1 : endOfImport;
+        }
+    }
+    s.appendRight(insertPos, importStatement);
+}
+/**
+ * Generates a unified diff showing what changed.
+ */
+function generateDiff(original, modified, filePath) {
+    if (original === modified) {
+        return '';
+    }
+    const originalLines = original.split('\n');
+    const modifiedLines = modified.split('\n');
+    let diff = `--- a/${filePath}\n`;
+    diff += `+++ b/${filePath}\n`;
+    // Simple line-by-line diff
+    for (let i = 0; i < Math.max(originalLines.length, modifiedLines.length); i++) {
+        if (originalLines[i] !== modifiedLines[i]) {
+            if (originalLines[i] !== undefined) {
+                diff += `-${originalLines[i]}\n`;
+            }
+            if (modifiedLines[i] !== undefined) {
+                diff += `+${modifiedLines[i]}\n`;
+            }
+        }
+    }
+    return diff;
+}
+
+export { generateDiff, transformFile };