@babelize/engine 0.0.0-stage → 0.1.0

package/dist/modules/injection/inject.js

@@ -0,0 +1,1066 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectTranslations = injectTranslations;
+exports.injectIntoFile = injectIntoFile;
+exports.injectIntoVueFile = injectIntoVueFile;
+exports.checkIdempotency = checkIdempotency;
+const path = __importStar(require("path"));
+const types_1 = require("@babelize/types");
+const StrategyFactory_1 = require("../../injection/StrategyFactory");
+const jsx_message_1 = require("../../utils/jsx-message");
+const module_constants_1 = require("../../utils/module-constants");
+const html_injector_1 = require("../../injection/html/html-injector");
+const django_template_injector_1 = require("../../injection/django/django-template-injector");
+const dtl_mask_1 = require("../../utils/dtl-mask");
+const types_2 = require("../../runtime/types");
+const file_utils_1 = require("../../utils/file-utils");
+const string_utils_1 = require("../../utils/string-utils");
+const ast_helpers_1 = require("../../utils/ast-helpers");
+/**
+ * An arrow function that defines a component: assigned to a capitalized name
+ * (`const Button = …`), possibly through memo()/forwardRef(), or the default
+ * export. Inline callbacks (`items.map(i => <li/>)`) are not components.
+ */
+function isComponentDefinition(arrow) {
+    let parent = arrow.parentPath;
+    while (parent?.isCallExpression() &&
+        /^(?:React\.)?(?:memo|forwardRef)$/.test(ast_helpers_1.t.isMemberExpression(parent.node.callee) && ast_helpers_1.t.isIdentifier(parent.node.callee.property)
+            ? `React.${parent.node.callee.property.name}`
+            : ast_helpers_1.t.isIdentifier(parent.node.callee) ? parent.node.callee.name : '')) {
+        parent = parent.parentPath;
+    }
+    if (!parent)
+        return false;
+    if (parent.isExportDefaultDeclaration())
+        return true;
+    return parent.isVariableDeclarator() && ast_helpers_1.t.isIdentifier(parent.node.id) && /^[A-Z]/.test(parent.node.id.name);
+}
+function importSignature(decl) {
+    const names = decl.specifiers.map((sp) => (ast_helpers_1.t.isImportSpecifier(sp) && ast_helpers_1.t.isIdentifier(sp.imported) ? sp.imported.name : sp.local.name));
+    return `${decl.source.value}|${names.sort().join(',')}`;
+}
+/** True when every specifier of `decl` is already imported from the same module. */
+function hasImportSpecifiers(ast, decl) {
+    const wanted = decl.specifiers.map((sp) => sp.local.name);
+    const have = new Set();
+    for (const node of ast.program.body) {
+        if (ast_helpers_1.t.isImportDeclaration(node) && node.source.value === decl.source.value) {
+            for (const sp of node.specifiers)
+                have.add(sp.local.name);
+        }
+    }
+    return wanted.length > 0 ? wanted.every((n) => have.has(n)) : have.size > 0;
+}
+/** Make sure `name` is imported from `source` as `local`, adding to an existing import of that module if there is one. */
+function ensureNamedImport(ast, source, name, local = name) {
+    const decls = ast.program.body.filter((n) => ast_helpers_1.t.isImportDeclaration(n) && n.source.value === source && n.importKind !== 'type');
+    for (const decl of decls) {
+        if (decl.specifiers.some((sp) => ast_helpers_1.t.isImportSpecifier(sp) && ast_helpers_1.t.isIdentifier(sp.imported) && sp.imported.name === name && sp.local.name === local))
+            return false;
+    }
+    const specifier = ast_helpers_1.t.importSpecifier(ast_helpers_1.t.identifier(local), ast_helpers_1.t.identifier(name));
+    const target = decls.find((d) => !d.specifiers.some((sp) => ast_helpers_1.t.isImportNamespaceSpecifier(sp)));
+    if (target) {
+        target.specifiers.push(specifier);
+    }
+    else {
+        ast.program.body.unshift(ast_helpers_1.t.importDeclaration([specifier], ast_helpers_1.t.stringLiteral(source)));
+    }
+    return true;
+}
+/**
+ * The local name to use for react-i18next's Trans: the one already imported
+ * from react-i18next, else `Trans` — or `BabelizeTrans` when the file
+ * already uses the name `Trans` for something else (next-i18next, Lingui, a
+ * local component), which a second `Trans` import would redeclare.
+ */
+function transLocalName(ast, content) {
+    for (const node of ast.program.body) {
+        if (!ast_helpers_1.t.isImportDeclaration(node) || node.source.value !== 'react-i18next')
+            continue;
+        for (const sp of node.specifiers) {
+            if (ast_helpers_1.t.isImportSpecifier(sp) && ast_helpers_1.t.isIdentifier(sp.imported) && sp.imported.name === 'Trans')
+                return sp.local.name;
+        }
+    }
+    return /\bTrans\b/.test(content) ? 'BabelizeTrans' : 'Trans';
+}
+/**
+ * `<p> {t(…)} </p>`: keep the spaces at the edges of the children that JSX
+ * renders (no line break), as the fragment path does.
+ */
+function withEdgeSpaces(children, node) {
+    const first = children[0];
+    const last = children[children.length - 1];
+    const lead = ast_helpers_1.t.isJSXText(first) && /^[ \t]+/.test(first.value) && !/^[ \t]*[\r\n]/.test(first.value);
+    const trail = ast_helpers_1.t.isJSXText(last) && /[ \t]+$/.test(last.value) && !/[\r\n][ \t]*$/.test(last.value);
+    return [...(lead ? [ast_helpers_1.t.jsxText(' ')] : []), node, ...(trail ? [ast_helpers_1.t.jsxText(' ')] : [])];
+}
+const HOOK_CALLEES = new Set(['useTranslations', 'getTranslations', 'useTranslation']);
+/** `const t = useTranslations()`, `const t = await getTranslations()`, `const { t } = useTranslation()`. */
+function isTranslationHookDeclarator(path) {
+    if (!path.isVariableDeclarator())
+        return false;
+    let init = path.node.init;
+    if (ast_helpers_1.t.isAwaitExpression(init))
+        init = init.argument;
+    return ast_helpers_1.t.isCallExpression(init) && ast_helpers_1.t.isIdentifier(init.callee) && HOOK_CALLEES.has(init.callee.name);
+}
+/**
+ * Name for the translation function in a component. Normally `t`; when the
+ * component (or a callback inside it, e.g. `items.map((t) => …)`) binds `t`
+ * to something else, an injected `t("key")` there would call that value, so
+ * the component gets its own hook under a free name (`tr`, `tr2`, …).
+ */
+function translatorNameFor(body) {
+    const fn = body.parentPath;
+    if (!fn)
+        return 't';
+    const names = new Set();
+    let shadowed = false;
+    const visitScope = (scope) => {
+        for (const [name, binding] of Object.entries(scope.bindings)) {
+            names.add(name);
+            if (name === 't' && !isTranslationHookDeclarator(binding.path))
+                shadowed = true;
+        }
+    };
+    visitScope(fn.scope);
+    fn.traverse({
+        Scopable(p) {
+            visitScope(p.scope);
+        },
+        // References to outer names count too: the alias must not hide them.
+        Identifier(p) {
+            names.add(p.node.name);
+        },
+    });
+    if (!shadowed)
+        return 't';
+    // A hook added under an alias by an earlier run: reuse it.
+    for (const [name, binding] of Object.entries(fn.scope.bindings)) {
+        if (name !== 't' && /^tr\d*$/.test(name) && isTranslationHookDeclarator(binding.path))
+            return name;
+    }
+    let alias = 'tr';
+    for (let n = 2; names.has(alias) || fn.scope.hasBinding(alias); n++)
+        alias = `tr${n}`;
+    return alias;
+}
+/** Point an injected `t(…)` / `t.rich(…)` / `<Trans t={t}>` at `name` (user expressions inside are left alone). */
+function useTranslatorName(node, name) {
+    if (name === 't')
+        return node;
+    const call = ast_helpers_1.t.isJSXExpressionContainer(node) ? node.expression : node;
+    if (ast_helpers_1.t.isCallExpression(call)) {
+        if (ast_helpers_1.t.isIdentifier(call.callee, { name: 't' }))
+            call.callee = ast_helpers_1.t.identifier(name);
+        else if (ast_helpers_1.t.isMemberExpression(call.callee) && ast_helpers_1.t.isIdentifier(call.callee.object, { name: 't' }))
+            call.callee.object = ast_helpers_1.t.identifier(name);
+    }
+    else if (ast_helpers_1.t.isJSXElement(node)) {
+        for (const attr of node.openingElement.attributes) {
+            if (ast_helpers_1.t.isJSXAttribute(attr) && ast_helpers_1.t.isJSXIdentifier(attr.name, { name: 't' }) && ast_helpers_1.t.isJSXExpressionContainer(attr.value) && ast_helpers_1.t.isIdentifier(attr.value.expression, { name: 't' })) {
+                attr.value.expression = ast_helpers_1.t.identifier(name);
+            }
+        }
+    }
+    return node;
+}
+/** The hook statements, declaring the translator as `name` instead of `t`. */
+function renameHookBinding(statements, name) {
+    if (name === 't')
+        return statements;
+    for (const st of statements) {
+        if (!ast_helpers_1.t.isVariableDeclaration(st))
+            continue;
+        for (const decl of st.declarations) {
+            if (ast_helpers_1.t.isIdentifier(decl.id, { name: 't' }))
+                decl.id = ast_helpers_1.t.identifier(name);
+            else if (ast_helpers_1.t.isObjectPattern(decl.id)) {
+                for (const prop of decl.id.properties) {
+                    if (ast_helpers_1.t.isObjectProperty(prop) && ast_helpers_1.t.isIdentifier(prop.key, { name: 't' })) {
+                        prop.value = ast_helpers_1.t.identifier(name);
+                        prop.shorthand = false;
+                    }
+                }
+            }
+        }
+    }
+    return statements;
+}
+/** The strategy's rendering of a sentence, or plain `t(key, values)` when it has no rich-text API. */
+function renderMessage(strategy, key, message, options) {
+    if (strategy.createMessage)
+        return strategy.createMessage(key, message, options);
+    if ((0, jsx_message_1.hasTags)(message))
+        return null;
+    return { node: ast_helpers_1.t.jsxExpressionContainer((0, jsx_message_1.createMessageTCall)(key, message)) };
+}
+/**
+ * Replace a JSXText node with `{t(...)}` without changing the rendered
+ * spacing. In JSX, whitespace at the edge of a text node is significant when
+ * it doesn't contain a line break: `<p>You clicked {count} times</p>` renders
+ * "You clicked 0 times". Replacing the text with a bare t() call would drop
+ * those spaces ("You clicked0times"), so they are kept as their own text node.
+ */
+function replaceJSXTextKeepingSpaces(path, tCall) {
+    const raw = path.node.value;
+    const leading = raw.match(/^\s*/)?.[0] ?? '';
+    const trailing = raw.match(/\s*$/)?.[0] ?? '';
+    const keepLeading = leading.length > 0 && !leading.includes('\n');
+    const keepTrailing = trailing.length > 0 && !trailing.includes('\n') && trailing.length < raw.length;
+    if (!keepLeading && !keepTrailing) {
+        path.replaceWith(tCall);
+        return;
+    }
+    const nodes = [];
+    if (keepLeading)
+        nodes.push(ast_helpers_1.t.jsxText(' '));
+    nodes.push(tCall);
+    if (keepTrailing)
+        nodes.push(ast_helpers_1.t.jsxText(' '));
+    path.replaceWithMultiple(nodes);
+}
+/**
+ * Phase 5: Injection
+ *
+ * Injects i18n into source files — JS/TS gets Babel AST injection,
+ * HTML files get DOM-based data-i18n attribute injection.
+ */
+async function injectTranslations(workspace, keyMapping, // extractionId -> key
+confidenceThreshold = 80, dryRun = false, 
+/** extractionId → source offsets of the nodes extraction selected. */
+positions) {
+    const modifiedFiles = [];
+    const skippedFiles = [];
+    let totalInjections = 0;
+    // Find all source files
+    const frameworkConfig = types_1.FRAMEWORK_CONFIGS[workspace.framework] || types_1.FRAMEWORK_CONFIGS['unknown'];
+    const extensions = [...(frameworkConfig.extensions || types_2.SUPPORTED_EXTENSIONS)];
+    const sourceFiles = [];
+    for (const sourceDir of workspace.sourceDirs) {
+        const dirPath = path.join(workspace.path, sourceDir);
+        const files = await (0, file_utils_1.findFiles)(dirPath, extensions, types_2.EXCLUDED_PATTERNS);
+        sourceFiles.push(...files);
+    }
+    // Collect keys by file for efficient lookup
+    const keysByFile = new Map();
+    Array.from(keyMapping.entries()).forEach(([extractionId, key]) => {
+        const [filePath] = extractionId.split(':');
+        if (!keysByFile.has(filePath)) {
+            keysByFile.set(filePath, new Map());
+        }
+        keysByFile.get(filePath).set(extractionId, key);
+    });
+    // Process each file that has keys
+    for (const filePath of sourceFiles) {
+        const relativePath = (0, file_utils_1.getRelativePath)(workspace.path, filePath);
+        const fileKeys = keysByFile.get(relativePath);
+        if (!fileKeys || fileKeys.size === 0) {
+            continue; // No keys for this file
+        }
+        try {
+            const originalContent = await (0, file_utils_1.readFile)(filePath);
+            let result;
+            if (relativePath.endsWith('.html') || relativePath.endsWith('.htm')) {
+                if (workspace.framework === 'django') {
+                    // Django: mask tags, run HTML injection, convert data-i18n to {% trans %}
+                    const { masked, restore } = (0, dtl_mask_1.maskTemplateTags)(originalContent);
+                    const maskedResult = await (0, html_injector_1.injectHtml)({
+                        content: masked,
+                        filePath: relativePath,
+                        keyMapping: fileKeys,
+                        injectSwitcher: false, // Django doesn't use JS switcher
+                    });
+                    result = await (0, django_template_injector_1.injectDjangoTemplates)({
+                        maskedContent: maskedResult.modifiedContent,
+                        restore,
+                        filePath: relativePath,
+                        keyMapping: fileKeys,
+                        sourceContent: originalContent,
+                    });
+                }
+                else {
+                    result = await (0, html_injector_1.injectHtml)({
+                        content: originalContent,
+                        filePath: relativePath,
+                        keyMapping: fileKeys,
+                        injectSwitcher: workspace.framework === 'static',
+                        targetLocales: workspace.existingLocales,
+                        sourceLocale: workspace.sourceDirs[0],
+                    });
+                }
+            }
+            else if (relativePath.endsWith('.vue')) {
+                const existingDeps = { ...workspace.packageJson?.dependencies, ...workspace.packageJson?.devDependencies };
+                result = await injectIntoVueFile(originalContent, relativePath, fileKeys, confidenceThreshold, workspace.framework, existingDeps);
+            }
+            else {
+                const existingDeps = { ...workspace.packageJson?.dependencies, ...workspace.packageJson?.devDependencies };
+                result = injectIntoFile(originalContent, relativePath, fileKeys, confidenceThreshold, workspace.framework, existingDeps, undefined, positions);
+            }
+            if (result.injections.length > 0) {
+                modifiedFiles.push(result);
+                totalInjections += result.injections.length;
+                // Write modified file
+                if (!dryRun) {
+                    await (0, file_utils_1.writeFile)(filePath, result.modifiedContent);
+                }
+            }
+        }
+        catch (error) {
+            skippedFiles.push({
+                file: relativePath,
+                reason: 'parse-error',
+                details: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return {
+        modifiedFiles,
+        skippedFiles,
+        totalInjections,
+    };
+}
+const ALLOWED_PARENT_TYPES = [
+    'ObjectProperty',
+    'ArrayExpression',
+    'VariableDeclarator',
+    'AssignmentExpression',
+    'JSXExpressionContainer',
+    'ReturnStatement',
+    'ConditionalExpression',
+    'LogicalExpression',
+    'BinaryExpression',
+    'CallExpression'
+];
+/**
+ * Inject translations into a single file
+ */
+function injectIntoFile(content, filePath, keyMapping, confidenceThreshold, framework, existingDeps, forceTypeScript, 
+/** extractionId → source offsets of the nodes extraction selected (see ExtractedString.offsets). */
+positions) {
+    const injections = [];
+    let importAdded = false;
+    let hookAdded = false;
+    let needsHook = false;
+    // Skip minified third-party libraries that have no existing imports
+    if (filePath.endsWith('.js') || filePath.endsWith('.ts') || filePath.endsWith('.jsx') || filePath.endsWith('.tsx')) {
+        const hasImports = /\b(import|export)\b/.test(content);
+        const isMinified = content.split('\n').length <= 3 && content.length > 5000;
+        if (!hasImports && isMinified) {
+            return { file: filePath, originalContent: content, modifiedContent: content, injections, importAdded, hookAdded: false };
+        }
+    }
+    const isTypeScript = forceTypeScript || filePath.endsWith('.ts') || filePath.endsWith('.tsx');
+    const ast = (0, ast_helpers_1.parseCode)(content, { isTypeScript });
+    // Track components that need the hook
+    const componentsNeedingHook = new Set();
+    let activeStrategy = StrategyFactory_1.StrategyFactory.getStrategy(framework, existingDeps);
+    let hasNonComponentInjections = false;
+    // Concise-body arrow components (`const Button = () => <button …/>`) have no
+    // body to put the translation hook in. Give the ones that hold a string to
+    // inject a block body (`=> { return …; }`) so they can be wired like any
+    // other component instead of being silently skipped.
+    // Only the nodes extraction picked for an id (by source offset), never
+    // another node that happens to have the same text on the same line.
+    const selected = (id, node) => {
+        const starts = positions?.get(id);
+        return !starts || (typeof node.start === 'number' && starts.has(node.start));
+    };
+    const hasKey = (text, node) => {
+        const id = `${filePath}:${node.loc?.start.line || 0}:${(0, string_utils_1.hashString)(text)}`;
+        return !!text && keyMapping.has(id) && selected(id, node);
+    };
+    // A JSX sentence extracted as one message: same message, same id as the extractor.
+    const sentenceFor = (p) => {
+        if (p.node.children.length < 2 || (0, ast_helpers_1.isAlreadyTranslated)(p.node, p))
+            return null;
+        const line = p.node.loc?.start.line || 0;
+        // The extractor generates plurals only with an LLM translator; try both forms.
+        for (const plurals of [true, false]) {
+            const built = (0, jsx_message_1.buildJsxMessage)(p.node, { plurals });
+            if (built.kind !== 'message')
+                return null;
+            const id = `${filePath}:${line}:${(0, string_utils_1.hashString)(built.message.text)}`;
+            const key = keyMapping.get(id);
+            if (key && selected(id, p.node))
+                return { key, message: built.message, line };
+            if (!built.message.plural)
+                return null;
+        }
+        return null;
+    };
+    (0, ast_helpers_1.traverse)(ast, {
+        ArrowFunctionExpression(arrow) {
+            if (ast_helpers_1.t.isBlockStatement(arrow.node.body) || !isComponentDefinition(arrow))
+                return;
+            let needsHook = false;
+            arrow.traverse({
+                'JSXElement|JSXFragment'(visited) {
+                    const p = visited;
+                    if (sentenceFor(p))
+                        needsHook = true;
+                },
+                JSXText(p) {
+                    if (hasKey((0, ast_helpers_1.extractJSXTextContent)(p.node), p.node))
+                        needsHook = true;
+                },
+                JSXAttribute(p) {
+                    const value = p.node.value;
+                    if (ast_helpers_1.t.isStringLiteral(value) && hasKey(value.value.trim(), p.node))
+                        needsHook = true;
+                },
+                StringLiteral(p) {
+                    if (!p.parentPath.isJSXAttribute() && hasKey(p.node.value.trim(), p.node))
+                        needsHook = true;
+                },
+            });
+            if (needsHook) {
+                const ensureBlock = arrow.ensureBlock.bind(arrow);
+                ensureBlock();
+            }
+        },
+    });
+    // Module-level UI constants rendered by components (#248): when extraction
+    // keyed their strings (every use is a render), the strings become keys and
+    // each render becomes t(…). Their literals are left to this, not to the
+    // StringLiteral visitors (which would put a module-level t() call there).
+    const moduleLiterals = new WeakSet();
+    const moduleRewrites = [];
+    if (activeStrategy.id !== 'vanilla') {
+        for (const plan of (0, module_constants_1.analyzeModuleConstants)(ast)) {
+            if (!plan.provable)
+                continue;
+            const keys = plan.literals.map((lit) => {
+                const id = `${filePath}:${lit.node.loc?.start.line || 0}:${(0, string_utils_1.hashString)(lit.node.value.trim())}`;
+                const key = keyMapping.get(id);
+                return key && selected(id, lit.node) ? key : null;
+            });
+            if (keys.some((k) => !k) || confidenceThreshold > 100)
+                continue;
+            for (const lit of plan.literals)
+                moduleLiterals.add(lit.node);
+            for (const site of plan.renderSites) {
+                const body = (0, ast_helpers_1.findComponentBody)(site);
+                if (body)
+                    componentsNeedingHook.add(body);
+            }
+            moduleRewrites.push({ plan, keys: keys });
+        }
+    }
+    // Pre-scan to determine if we should fall back to vanilla strategy and identify hooks needed
+    (0, ast_helpers_1.traverse)(ast, {
+        'JSXElement|JSXFragment'(visited) {
+            const path = visited;
+            if (!sentenceFor(path) || confidenceThreshold > 100)
+                return;
+            if ((0, ast_helpers_1.isInsideComponent)(path)) {
+                const componentPath = (0, ast_helpers_1.findComponentBody)(path);
+                if (componentPath)
+                    componentsNeedingHook.add(componentPath);
+            }
+            else {
+                hasNonComponentInjections = true;
+            }
+        },
+        JSXText(path) {
+            const text = (0, ast_helpers_1.extractJSXTextContent)(path.node);
+            if (!text)
+                return;
+            const hasCurrency = (0, string_utils_1.matchesCurrencyPattern)(text);
+            const hasDate = (0, string_utils_1.matchesDatePattern)(text);
+            const isDateOrCurrencyValue = (hasCurrency || hasDate) && text.length >= 3;
+            if (!(0, string_utils_1.isTranslatableText)(text) && !isDateOrCurrencyValue)
+                return;
+            if ((0, ast_helpers_1.isAlreadyTranslated)(path.node, path))
+                return;
+            const line = path.node.loc?.start.line || 0;
+            const extractionId = `${filePath}:${line}:${(0, string_utils_1.hashString)(text)}`;
+            const key = keyMapping.get(extractionId);
+            if (!key || !selected(extractionId, path.node))
+                return;
+            if (confidenceThreshold > 100)
+                return;
+            const isComponent = (0, ast_helpers_1.isInsideComponent)(path);
+            if (isComponent) {
+                if (activeStrategy.id !== 'vanilla') {
+                    const componentPath = (0, ast_helpers_1.findComponentBody)(path);
+                    if (!componentPath)
+                        return;
+                    componentsNeedingHook.add(componentPath);
+                }
+                else {
+                    const componentPath = (0, ast_helpers_1.findComponentBody)(path);
+                    if (componentPath) {
+                        componentsNeedingHook.add(componentPath);
+                    }
+                }
+            }
+            else {
+                hasNonComponentInjections = true;
+            }
+        },
+        JSXAttribute(attributes) {
+            const name = attributes.node.name;
+            if (!ast_helpers_1.t.isJSXIdentifier(name))
+                return;
+            const value = attributes.node.value;
+            if (!ast_helpers_1.t.isStringLiteral(value))
+                return;
+            const text = value.value.trim();
+            if (!text)
+                return;
+            const hasCurrency = (0, string_utils_1.matchesCurrencyPattern)(text);
+            const hasDate = (0, string_utils_1.matchesDatePattern)(text);
+            const isDateOrCurrencyValue = (hasCurrency || hasDate) && text.length >= 3;
+            if (!(0, string_utils_1.isTranslatableText)(text) && !isDateOrCurrencyValue)
+                return;
+            if ((0, ast_helpers_1.isAlreadyTranslated)(attributes.node, attributes))
+                return;
+            const line = attributes.node.loc?.start.line || 0;
+            const extractionId = `${filePath}:${line}:${(0, string_utils_1.hashString)(text)}`;
+            const key = keyMapping.get(extractionId);
+            if (!key || !selected(extractionId, attributes.node))
+                return;
+            if (confidenceThreshold > 100)
+                return;
+            const isComponent = (0, ast_helpers_1.isInsideComponent)(attributes);
+            if (isComponent) {
+                if (activeStrategy.id !== 'vanilla') {
+                    const componentPath = (0, ast_helpers_1.findComponentBody)(attributes);
+                    if (!componentPath)
+                        return;
+                    componentsNeedingHook.add(componentPath);
+                }
+                else {
+                    const componentPath = (0, ast_helpers_1.findComponentBody)(attributes);
+                    if (componentPath) {
+                        componentsNeedingHook.add(componentPath);
+                    }
+                }
+            }
+            else {
+                hasNonComponentInjections = true;
+            }
+        },
+        StringLiteral(path) {
+            if (moduleLiterals.has(path.node))
+                return;
+            const parent = path.parentPath;
+            if (!parent)
+                return;
+            if (parent.isJSXAttribute())
+                return;
+            if (!ALLOWED_PARENT_TYPES.includes(parent.node.type))
+                return;
+            if (parent.isObjectProperty() && parent.node.key === path.node)
+                return;
+            if (parent.isConditionalExpression() && parent.node.test === path.node)
+                return;
+            if (parent.isCallExpression() && parent.node.callee === path.node)
+                return;
+            const text = path.node.value.trim();
+            if (!text)
+                return;
+            const hasCurrency = (0, string_utils_1.matchesCurrencyPattern)(text);
+            const hasDate = (0, string_utils_1.matchesDatePattern)(text);
+            const isDateOrCurrencyValue = (hasCurrency || hasDate) && text.length >= 3;
+            if (!(0, string_utils_1.isTranslatableText)(text) && !isDateOrCurrencyValue)
+                return;
+            if ((0, ast_helpers_1.isAlreadyTranslated)(path.node, path))
+                return;
+            if ((0, ast_helpers_1.isNonTranslatableContext)(path))
+                return;
+            const line = path.node.loc?.start.line || 0;
+            const extractionId = `${filePath}:${line}:${(0, string_utils_1.hashString)(text)}`;
+            const key = keyMapping.get(extractionId);
+            if (!key || !selected(extractionId, path.node))
+                return;
+            if (confidenceThreshold > 100)
+                return;
+            const isComponent = (0, ast_helpers_1.isInsideComponent)(path);
+            if (isComponent) {
+                if (activeStrategy.id !== 'vanilla') {
+                    const componentPath = (0, ast_helpers_1.findComponentBody)(path);
+                    if (!componentPath)
+                        return;
+                    componentsNeedingHook.add(componentPath);
+                }
+                else {
+                    const componentPath = (0, ast_helpers_1.findComponentBody)(path);
+                    if (componentPath) {
+                        componentsNeedingHook.add(componentPath);
+                    }
+                }
+            }
+            else {
+                hasNonComponentInjections = true;
+            }
+        }
+    });
+    // Determine active strategy based on pre-scan results.
+    // If there are ONLY non-component injections (no components needing hooks),
+    // fall back to vanilla strategy which doesn't require React hooks.
+    if (hasNonComponentInjections && componentsNeedingHook.size === 0 && activeStrategy.id !== 'vanilla') {
+        activeStrategy = StrategyFactory_1.StrategyFactory.getStrategy('vanilla');
+    }
+    // Compute hasUseClient AFTER strategy selection — the strategy may have fallen back
+    // to vanilla, which doesn't care about use client directives.
+    // Before this point the AST hasn't been modified, so the result is the same as
+    // if we had computed it pre-scan.
+    const hasUseClient = (0, ast_helpers_1.hasUseClientDirective)(ast);
+    const extraImports = [];
+    // Translator name per component body (`t`, or an alias where `t` is shadowed).
+    const translatorNames = new Map();
+    const nameFor = (p) => {
+        if (activeStrategy.id === 'vanilla')
+            return 't';
+        const body = (0, ast_helpers_1.findComponentBody)(p);
+        if (!body)
+            return 't';
+        if (!translatorNames.has(body.node))
+            translatorNames.set(body.node, translatorNameFor(body));
+        return translatorNames.get(body.node);
+    };
+    for (const { plan, keys } of moduleRewrites) {
+        plan.literals.forEach((lit, i) => {
+            injections.push({
+                file: filePath,
+                line: lit.node.loc?.start.line || 0,
+                column: lit.node.loc?.start.column || 0,
+                original: lit.node.value,
+                replacement: JSON.stringify(keys[i]),
+                key: keys[i],
+                confidence: 100,
+            });
+            lit.replaceWith(ast_helpers_1.t.stringLiteral(keys[i]));
+        });
+        for (const site of plan.renderSites) {
+            site.replaceWith(ast_helpers_1.t.callExpression(ast_helpers_1.t.identifier(nameFor(site)), [site.node]));
+        }
+        needsHook = true;
+    }
+    const messageOptions = { transName: transLocalName(ast, content) };
+    // Second pass: identify and replace strings
+    (0, ast_helpers_1.traverse)(ast, {
+        // A whole JSX sentence → one t() / t.rich() / <Trans> replacing the children.
+        'JSXElement|JSXFragment'(visited) {
+            const path = visited;
+            const sentence = sentenceFor(path);
+            if (!sentence)
+                return;
+            const confidence = 100;
+            if (confidence < confidenceThreshold)
+                return;
+            const isComponent = (0, ast_helpers_1.isInsideComponent)(path);
+            if (isComponent && activeStrategy.id !== 'vanilla' && !(0, ast_helpers_1.findComponentBody)(path))
+                return;
+            // Outside a component there is no hook: only the plain t() call works.
+            const strategy = isComponent || activeStrategy.id === 'vanilla' ? activeStrategy : StrategyFactory_1.StrategyFactory.getStrategy('vanilla');
+            const rendering = renderMessage(strategy, sentence.key, sentence.message, messageOptions);
+            if (!rendering)
+                return;
+            path.node.children = withEdgeSpaces(path.node.children, isComponent ? useTranslatorName(rendering.node, nameFor(path)) : rendering.node);
+            extraImports.push(...(rendering.imports ?? []));
+            injections.push({
+                file: filePath,
+                line: sentence.line,
+                column: path.node.loc?.start.column || 0,
+                original: sentence.message.text,
+                replacement: (0, ast_helpers_1.generate)(rendering.node, { compact: false }).code,
+                key: sentence.key,
+                confidence,
+            });
+            needsHook = true;
+        },
+        // Handle JSXText
+        JSXText(path) {
+            const text = (0, ast_helpers_1.extractJSXTextContent)(path.node);
+            if (!text)
+                return;
+            const hasCurrency = (0, string_utils_1.matchesCurrencyPattern)(text);
+            const hasDate = (0, string_utils_1.matchesDatePattern)(text);
+            const isDateOrCurrencyValue = (hasCurrency || hasDate) && text.length >= 3;
+            if (!(0, string_utils_1.isTranslatableText)(text) && !isDateOrCurrencyValue)
+                return;
+            if ((0, ast_helpers_1.isAlreadyTranslated)(path.node, path))
+                return;
+            const line = path.node.loc?.start.line || 0;
+            const column = path.node.loc?.start.column || 0;
+            const extractionId = `${filePath}:${line}:${(0, string_utils_1.hashString)(text)}`;
+            const key = keyMapping.get(extractionId);
+            if (!key || !selected(extractionId, path.node))
+                return;
+            const confidence = 100;
+            if (confidence < confidenceThreshold)
+                return;
+            const isComponent = (0, ast_helpers_1.isInsideComponent)(path);
+            const isSetupSafe = isComponent || activeStrategy.id === 'vanilla';
+            // Skip injection entirely when isComponent is true but componentPath is null and the activeStrategy requires hooks
+            if (isComponent && activeStrategy.id !== 'vanilla') {
+                const componentPath = (0, ast_helpers_1.findComponentBody)(path);
+                if (!componentPath)
+                    return;
+            }
+            // Fallback for non-component JSX text: use vanilla t() call instead of silently skipping
+            if (!isSetupSafe) {
+                const tCall = (0, ast_helpers_1.createJSXTCall)(key);
+                replaceJSXTextKeepingSpaces(path, tCall);
+                injections.push({
+                    file: filePath,
+                    line,
+                    column,
+                    original: text,
+                    replacement: `{t('${key}')}`,
+                    key,
+                    confidence,
+                });
+                needsHook = true;
+                return;
+            }
+            const tFunctionName = nameFor(path);
+            const tCall = useTranslatorName((0, ast_helpers_1.createJSXTCall)(key), tFunctionName);
+            replaceJSXTextKeepingSpaces(path, tCall);
+            injections.push({
+                file: filePath,
+                line,
+                column,
+                original: text,
+                replacement: `{${tFunctionName}('${key}')}`,
+                key,
+                confidence,
+            });
+            needsHook = true;
+        },
+        // Handle JSX attribute strings
+        JSXAttribute(attributes) {
+            const name = attributes.node.name;
+            if (!ast_helpers_1.t.isJSXIdentifier(name))
+                return;
+            const value = attributes.node.value;
+            if (!ast_helpers_1.t.isStringLiteral(value))
+                return;
+            const text = value.value.trim();
+            if (!text)
+                return;
+            const hasCurrency = (0, string_utils_1.matchesCurrencyPattern)(text);
+            const hasDate = (0, string_utils_1.matchesDatePattern)(text);
+            const isDateOrCurrencyValue = (hasCurrency || hasDate) && text.length >= 3;
+            if (!(0, string_utils_1.isTranslatableText)(text) && !isDateOrCurrencyValue)
+                return;
+            if ((0, ast_helpers_1.isAlreadyTranslated)(attributes.node, attributes))
+                return;
+            const line = attributes.node.loc?.start.line || 0;
+            const extractionId = `${filePath}:${line}:${(0, string_utils_1.hashString)(text)}`;
+            const key = keyMapping.get(extractionId);
+            if (!key || !selected(extractionId, attributes.node))
+                return;
+            const confidence = 100;
+            if (confidence < confidenceThreshold)
+                return;
+            const isComponent = (0, ast_helpers_1.isInsideComponent)(attributes);
+            const isSetupSafe = isComponent || activeStrategy.id === 'vanilla';
+            // Skip injection entirely when isComponent is true but componentPath is null and the activeStrategy requires hooks
+            if (isComponent && activeStrategy.id !== 'vanilla') {
+                const componentPath = (0, ast_helpers_1.findComponentBody)(attributes);
+                if (!componentPath)
+                    return;
+            }
+            // Fallback for non-component JSX attributes: use vanilla t() call
+            if (!isSetupSafe) {
+                const tFunctionName = 't';
+                attributes.node.value = ast_helpers_1.t.jsxExpressionContainer((0, ast_helpers_1.createTCall)(key));
+                injections.push({
+                    file: filePath,
+                    line,
+                    column: attributes.node.loc?.start.column || 0,
+                    original: text,
+                    replacement: `{${tFunctionName}('${key}')}`,
+                    key,
+                    confidence,
+                });
+                needsHook = true;
+                return;
+            }
+            const tFunctionName = nameFor(attributes);
+            attributes.node.value = ast_helpers_1.t.jsxExpressionContainer(useTranslatorName((0, ast_helpers_1.createTCall)(key), tFunctionName));
+            injections.push({
+                file: filePath,
+                line,
+                column: attributes.node.loc?.start.column || 0,
+                original: text,
+                replacement: `{${tFunctionName}('${key}')}`,
+                key,
+                confidence,
+            });
+            needsHook = true;
+        },
+        // Handle string literals in safe contexts (ObjectProperty, ArrayExpression, VariableDeclarator, etc.)
+        StringLiteral(path) {
+            if (moduleLiterals.has(path.node))
+                return;
+            const parent = path.parentPath;
+            if (!parent)
+                return;
+            // Skip if parent is JSXAttribute since JSXAttribute is handled by its own visitor
+            if (parent.isJSXAttribute())
+                return;
+            const parentType = parent.node.type;
+            if (!ALLOWED_PARENT_TYPES.includes(parentType))
+                return;
+            // Specific checks to ensure the string literal is in a value/translatable position
+            if (parent.isObjectProperty() && parent.node.key === path.node)
+                return;
+            if (parent.isConditionalExpression() && parent.node.test === path.node)
+                return;
+            if (parent.isCallExpression() && parent.node.callee === path.node)
+                return;
+            const text = path.node.value.trim();
+            if (!text)
+                return;
+            const hasCurrency = (0, string_utils_1.matchesCurrencyPattern)(text);
+            const hasDate = (0, string_utils_1.matchesDatePattern)(text);
+            const isDateOrCurrencyValue = (hasCurrency || hasDate) && text.length >= 3;
+            if (!(0, string_utils_1.isTranslatableText)(text) && !isDateOrCurrencyValue)
+                return;
+            if ((0, ast_helpers_1.isAlreadyTranslated)(path.node, path))
+                return;
+            if ((0, ast_helpers_1.isNonTranslatableContext)(path))
+                return;
+            const line = path.node.loc?.start.line || 0;
+            const extractionId = `${filePath}:${line}:${(0, string_utils_1.hashString)(text)}`;
+            const key = keyMapping.get(extractionId);
+            if (!key || !selected(extractionId, path.node))
+                return;
+            if (confidenceThreshold > 100)
+                return;
+            const isComponent = (0, ast_helpers_1.isInsideComponent)(path);
+            const isSetupSafe = isComponent || activeStrategy.id === 'vanilla';
+            // Skip injection entirely when isComponent is true but componentPath is null and the activeStrategy requires hooks
+            if (isComponent && activeStrategy.id !== 'vanilla') {
+                const componentPath = (0, ast_helpers_1.findComponentBody)(path);
+                if (!componentPath)
+                    return;
+            }
+            // Fallback for non-component string literals: use vanilla t() call directly
+            if (!isSetupSafe) {
+                path.replaceWith((0, ast_helpers_1.createTCall)(key));
+                injections.push({
+                    file: filePath,
+                    line,
+                    column: path.node.loc?.start.column || 0,
+                    original: text,
+                    replacement: `t('${key}')`,
+                    key,
+                    confidence: 100,
+                });
+                needsHook = true;
+                return;
+            }
+            const tFunctionName = nameFor(path);
+            path.replaceWith(useTranslatorName((0, ast_helpers_1.createTCall)(key), tFunctionName));
+            injections.push({
+                file: filePath,
+                line,
+                column: path.node.loc?.start.column || 0,
+                original: text,
+                replacement: `${tFunctionName}('${key}')`,
+                key,
+                confidence: 100,
+            });
+            needsHook = true;
+        },
+    });
+    // Second pass: add import and hooks if needed
+    const insertedStatements = new Set();
+    if (needsHook || injections.length > 0) {
+        const fileContext = {
+            filePath,
+            isComponent: componentsNeedingHook.size > 0,
+            hasUseClient
+        };
+        // Add setup hooks to each component that needs it. The hook (and so the
+        // import) can differ per component — next-intl uses `await
+        // getTranslations()` only in components that are already async — so
+        // imports are collected from the hooks actually added.
+        const neededImports = new Map();
+        Array.from(componentsNeedingHook).forEach((componentBody) => {
+            const translatorName = translatorNames.get(componentBody.node) ?? 't';
+            if (translatorName === 't' && activeStrategy.hasHook(componentBody.parentPath))
+                return;
+            const aliasBinding = translatorName === 't' ? undefined : componentBody.parentPath?.scope.getBinding(translatorName);
+            if (aliasBinding && isTranslationHookDeclarator(aliasBinding.path))
+                return;
+            const fnNode = componentBody.parentPath?.node;
+            const componentContext = { ...fileContext, isAsyncComponent: fnNode?.async === true };
+            const statements = renameHookBinding(activeStrategy.createHook(componentContext), translatorName);
+            if (!componentBody.node?.body || statements.length === 0)
+                return;
+            if (activeStrategy.requiresAsyncComponent(componentContext) && fnNode && 'async' in fnNode && !fnNode.async) {
+                fnNode.async = true;
+                componentContext.isAsyncComponent = true;
+            }
+            const body = componentBody.node.body;
+            body.unshift(...statements);
+            for (const statement of statements) {
+                insertedStatements.add((0, ast_helpers_1.generate)(statement, { compact: false }).code);
+            }
+            hookAdded = true;
+            const decl = activeStrategy.createImport(componentContext);
+            neededImports.set(importSignature(decl), decl);
+        });
+        if (neededImports.size === 0 && !activeStrategy.hasImport(ast)) {
+            const decl = activeStrategy.createImport(fileContext);
+            neededImports.set(importSignature(decl), decl);
+        }
+        for (const decl of [...neededImports.values()].reverse()) {
+            if (hasImportSpecifiers(ast, decl))
+                continue;
+            ast.program.body.unshift(decl);
+            importAdded = true;
+        }
+        for (const { source, name, local } of extraImports) {
+            if (ensureNamedImport(ast, source, name, local))
+                importAdded = true;
+        }
+    }
+    const modifiedContent = (0, ast_helpers_1.placeStatementsOnOwnLines)((0, ast_helpers_1.generateCode)(ast, content), [...insertedStatements]);
+    return {
+        file: filePath,
+        originalContent: content,
+        modifiedContent,
+        injections,
+        importAdded,
+        hookAdded,
+    };
+}
+/**
+ * Inject translations into a Vue SFC file.
+ * Uses @vue/compiler-sfc to parse, vue/template-scan to find translatable
+ * units, vue/template-rewrite to inject $t() calls, and vue/script-inject
+ * to add useI18n() in <script setup>.
+ */
+async function injectIntoVueFile(content, filePath, keyMapping, _confidenceThreshold, _framework, _existingDeps) {
+    const { parseSfc } = await Promise.resolve().then(() => __importStar(require('../vue/sfc')));
+    const { scanTemplate } = await Promise.resolve().then(() => __importStar(require('../vue/template-scan')));
+    const { rewriteTemplate } = await Promise.resolve().then(() => __importStar(require('../vue/template-rewrite')));
+    const { injectVueScript } = await Promise.resolve().then(() => __importStar(require('../vue/script-inject')));
+    const { hashString } = await Promise.resolve().then(() => __importStar(require('../../utils/string-utils')));
+    const sfc = parseSfc(content);
+    if (!sfc) {
+        return { file: filePath, originalContent: content, modifiedContent: content, injections: [], importAdded: false, hookAdded: false };
+    }
+    const originalContent = content;
+    const injections = [];
+    let importAdded = false;
+    let hookAdded = false;
+    // 1. Scan template for translatable units
+    if (sfc.descriptor.template) {
+        const templateContent = sfc.descriptor.template.content;
+        const scanResult = scanTemplate(templateContent, filePath, sfc.templateOffset, hashString);
+        // 2. Rewrite template with $t() calls
+        const rewriteResult = rewriteTemplate(content, templateContent, sfc.templateOffset, scanResult.units, keyMapping, filePath);
+        if (rewriteResult.parseFailed) {
+            return { file: filePath, originalContent, modifiedContent: content, injections: [], importAdded: false, hookAdded: false };
+        }
+        injections.push(...rewriteResult.injections);
+        content = rewriteResult.content;
+    }
+    // 3. Inject into script (only for <script setup>)
+    if (sfc.scriptBlock === 'setup' && sfc.descriptor.scriptSetup) {
+        const scriptResult = injectVueScript({
+            scriptContent: sfc.descriptor.scriptSetup.content,
+            filePath,
+            templateOffset: sfc.scriptOffset,
+            isSetup: true,
+            hasTs: 'lang' in sfc.descriptor.scriptSetup.attrs && /(?:ts|typescript)/.test(String(sfc.descriptor.scriptSetup.attrs.lang)),
+            hasI18nImport: false,
+            hasUseI18n: false,
+        });
+        if (scriptResult.importAdded)
+            importAdded = true;
+        if (scriptResult.hookAdded)
+            hookAdded = true;
+        injections.push(...scriptResult.injections);
+        // Replace the script content in the file
+        if (scriptResult.content !== sfc.descriptor.scriptSetup.content) {
+            const scriptStart = content.indexOf(sfc.descriptor.scriptSetup.content);
+            if (scriptStart !== -1) {
+                content = content.substring(0, scriptStart) + scriptResult.content + content.substring(scriptStart + sfc.descriptor.scriptSetup.content.length);
+            }
+            else {
+                // Padded content (from @vue/compiler-sfc pad:'line') not found in original file.
+                // Find the script section by tags and replace its body.
+                const scriptEndTag = '</script>';
+                const scriptEndIndex = content.lastIndexOf(scriptEndTag);
+                if (scriptEndIndex !== -1) {
+                    const beforeScript = content.substring(0, scriptEndIndex);
+                    const scriptTagIndex = beforeScript.lastIndexOf('<script');
+                    if (scriptTagIndex !== -1) {
+                        const tagEnd = content.indexOf('>', scriptTagIndex) + 1;
+                        const stripped = scriptResult.content.replace(/^\/\/[^\n]*\n/gm, '').replace(/^\n+/, '');
+                        content = content.substring(0, tagEnd) + '\n' + stripped + '\n' + content.substring(scriptEndIndex);
+                    }
+                }
+            }
+        }
+    }
+    return {
+        file: filePath,
+        originalContent,
+        modifiedContent: content,
+        injections,
+        importAdded,
+        hookAdded,
+    };
+}
+/**
+ * Check if injection would be idempotent
+ * (running again would produce the same output)
+ */
+function checkIdempotency(originalContent, modifiedContent, filePath, keyMapping, framework = 'unknown') {
+    try {
+        // Try to inject again into the modified content
+        const result = injectIntoFile(modifiedContent, filePath, keyMapping, 80, framework, undefined);
+        // If no new injections, it's idempotent
+        return result.injections.length === 0;
+    }
+    catch {
+        return false;
+    }
+}