@babelize/engine 0.1.2 → 0.2.0

package/dist/modules/injection/inject.js

@@ -46,6 +46,8 @@ const html_injector_1 = require("../../injection/html/html-injector");
 const inject_file_1 = require("../../django/inject-file");
 const types_2 = require("../../runtime/types");
 const file_utils_1 = require("../../utils/file-utils");
+const i18n_config_path_1 = require("../../utils/i18n-config-path");
+const i18next_icu_1 = require("../../utils/i18next-icu");
 const string_utils_1 = require("../../utils/string-utils");
 const ast_helpers_1 = require("../../utils/ast-helpers");
 /**
@@ -119,14 +121,21 @@ function transLocalName(ast, content) {
 }
 /**
  * `<p> {t(…)} </p>`: keep the spaces at the edges of the children that JSX
- * renders (no line break), as the fragment path does.
+ * renders (no line break), as the fragment path does. Edges with a line break
+ * render nothing and are kept as written, so the element keeps its layout.
  */
 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 leadLayout = !lead && ast_helpers_1.t.isJSXText(first) ? (first.value.match(/^\s*[\r\n]\s*/)?.[0] ?? '') : '';
+    const trailLayout = !trail && ast_helpers_1.t.isJSXText(last) ? (last.value.match(/\s*[\r\n]\s*$/)?.[0] ?? '') : '';
+    return [
+        ...(lead ? [ast_helpers_1.t.jsxText(' ')] : leadLayout ? [ast_helpers_1.t.jsxText(leadLayout)] : []),
+        node,
+        ...(trail ? [ast_helpers_1.t.jsxText(' ')] : trailLayout ? [ast_helpers_1.t.jsxText(trailLayout)] : []),
+    ];
 }
 const HOOK_CALLEES = new Set(['useTranslations', 'getTranslations', 'useTranslation']);
 /** `const t = useTranslations()`, `const t = await getTranslations()`, `const { t } = useTranslation()`. */
@@ -242,18 +251,97 @@ function replaceJSXTextKeepingSpaces(path, tCall) {
     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) {
+    // A line break with its indentation renders nothing, so it stays as written:
+    // `>\n  Decline\n</Text>` becomes `>\n  {t("…")}\n</Text>`, not `>{t("…")}</Text>`.
+    const layoutLeading = !keepLeading && leading.includes('\n') ? leading : '';
+    const layoutTrailing = !keepTrailing && trailing.includes('\n') && trailing.length < raw.length ? trailing : '';
+    if (!keepLeading && !keepTrailing && !layoutLeading && !layoutTrailing) {
         path.replaceWith(tCall);
         return;
     }
     const nodes = [];
     if (keepLeading)
         nodes.push(ast_helpers_1.t.jsxText(' '));
+    else if (layoutLeading)
+        nodes.push(ast_helpers_1.t.jsxText(layoutLeading));
     nodes.push(tCall);
     if (keepTrailing)
         nodes.push(ast_helpers_1.t.jsxText(' '));
+    else if (layoutTrailing)
+        nodes.push(ast_helpers_1.t.jsxText(layoutTrailing));
     path.replaceWithMultiple(nodes);
 }
+/** `NICHES` → `NICHES_KEYS`, `PLANS` + `label` → `PLANS_LABEL_KEYS`, `tabs` + `label` → `tabsLabelKeys`. */
+function labelMapName(constant, field) {
+    if (/^[A-Z0-9_]+$/.test(constant))
+        return `${constant}${field ? `_${field.replace(/([a-z])([A-Z])/g, '$1_$2').toUpperCase()}` : ''}_KEYS`;
+    const cap = (x) => x.charAt(0).toUpperCase() + x.slice(1);
+    return `${constant}${cap(field)}Keys`;
+}
+/**
+ * The value → key map of each rendered field of a constant that is also data,
+ * declared right after it (`const NICHES_KEYS: Record<string, string> = { "Fashion": "…" }`).
+ * A map an earlier run added is reused, with any new values added to it.
+ */
+function addLabelMaps(plan, keys, isTypeScript, usedNames) {
+    const entries = new Map();
+    plan.literals.forEach((lit, i) => {
+        const field = plan.literalFields[i];
+        const values = entries.get(field) ?? new Map();
+        if (!values.has(lit.node.value))
+            values.set(lit.node.value, keys[i]);
+        entries.set(field, values);
+    });
+    const maps = new Map(plan.labelMaps);
+    const scope = plan.anchor.scope;
+    const added = [];
+    for (const [field, values] of entries) {
+        const existing = maps.get(field);
+        if (existing) {
+            const init = scope.getBinding(existing)?.path.node;
+            if (ast_helpers_1.t.isVariableDeclarator(init) && ast_helpers_1.t.isObjectExpression(init.init)) {
+                const obj = init.init;
+                const has = new Set(obj.properties.flatMap((p) => (ast_helpers_1.t.isObjectProperty(p) && ast_helpers_1.t.isStringLiteral(p.key) ? [p.key.value] : [])));
+                for (const [value, key] of values) {
+                    if (!has.has(value))
+                        obj.properties.push(ast_helpers_1.t.objectProperty(ast_helpers_1.t.stringLiteral(value), ast_helpers_1.t.stringLiteral(key)));
+                }
+            }
+            continue;
+        }
+        // Maps added for earlier lists in this file aren't scope bindings yet.
+        const taken = (x) => scope.hasBinding(x) || usedNames.has(x) || [...maps.values()].includes(x);
+        let name = labelMapName(plan.name, field);
+        for (let n = 2; taken(name); n++)
+            name = `${labelMapName(plan.name, field)}${n}`;
+        const id = ast_helpers_1.t.identifier(name);
+        if (isTypeScript) {
+            id.typeAnnotation = ast_helpers_1.t.tsTypeAnnotation(ast_helpers_1.t.tsTypeReference(ast_helpers_1.t.identifier('Record'), ast_helpers_1.t.tsTypeParameterInstantiation([ast_helpers_1.t.tsStringKeyword(), ast_helpers_1.t.tsStringKeyword()])));
+        }
+        const object = ast_helpers_1.t.objectExpression([...values].map(([value, key]) => ast_helpers_1.t.objectProperty(ast_helpers_1.t.stringLiteral(value), ast_helpers_1.t.stringLiteral(key))));
+        added.push(ast_helpers_1.t.variableDeclaration('const', [ast_helpers_1.t.variableDeclarator(id, object)]));
+        maps.set(field, name);
+        usedNames.add(name);
+    }
+    if (added.length > 0) {
+        if (plan.insert === 'after')
+            plan.anchor.insertAfter(added);
+        else
+            plan.anchor.insertBefore(added);
+    }
+    return maps;
+}
+/** Whether `p` sits in the parameters (a default value) of the function whose body is `body`. */
+function isInComponentParams(p, body) {
+    const fn = body.parentPath;
+    if (!fn?.isFunction())
+        return false;
+    for (let cur = p; cur && cur !== fn; cur = cur.parentPath) {
+        if (cur.listKey === 'params' && cur.parentPath === fn)
+            return true;
+    }
+    return false;
+}
 /**
  * Phase 5: Injection
  *
@@ -273,9 +361,23 @@ positions) {
     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);
+        const files = await (0, file_utils_1.findFiles)(dirPath, extensions, (0, types_2.workspaceExcludes)(workspace));
         sourceFiles.push(...files);
     }
+    // react-i18next projects get Babelize's config, which exports a module-level
+    // `t`: strings outside any component the hook can go in use it. A config
+    // the user owns may not export `t`, so those strings stay as they are.
+    const deps = { ...workspace.packageJson?.dependencies, ...workspace.packageJson?.devDependencies };
+    const library = StrategyFactory_1.StrategyFactory.getStrategy(workspace.framework, deps).id;
+    let babelizeOwnsConfig = false;
+    // `t(key, { total })` fills "{total}" only where messages are ICU:
+    // next-intl always, react-i18next with i18next-icu (Babelize's configs load it).
+    let placeholders = library === 'next-intl';
+    if (library === 'react-i18next') {
+        const status = await (0, i18next_icu_1.detectI18nextIcu)(workspace).catch(() => null);
+        babelizeOwnsConfig = status ? !status.userOwnsInit : false;
+        placeholders = status?.available ?? false;
+    }
     // Collect keys by file for efficient lookup
     const keysByFile = new Map();
     Array.from(keyMapping.entries()).forEach(([extractionId, key]) => {
@@ -315,7 +417,8 @@ positions) {
             }
             else {
                 const existingDeps = { ...workspace.packageJson?.dependencies, ...workspace.packageJson?.devDependencies };
-                result = injectIntoFile(originalContent, relativePath, fileKeys, confidenceThreshold, workspace.framework, existingDeps, undefined, positions);
+                const moduleTranslator = babelizeOwnsConfig ? (0, i18n_config_path_1.i18nImportPath)(workspace, relativePath) : undefined;
+                result = injectIntoFile(originalContent, relativePath, fileKeys, confidenceThreshold, workspace.framework, existingDeps, undefined, positions, { moduleTranslator, placeholders });
             }
             if (result.injections.length > 0) {
                 modifiedFiles.push(result);
@@ -342,6 +445,7 @@ positions) {
 }
 const ALLOWED_PARENT_TYPES = [
     'ObjectProperty',
+    'AssignmentPattern',
     'ArrayExpression',
     'VariableDeclarator',
     'AssignmentExpression',
@@ -357,7 +461,8 @@ const ALLOWED_PARENT_TYPES = [
  */
 function injectIntoFile(content, filePath, keyMapping, confidenceThreshold, framework, existingDeps, forceTypeScript, 
 /** extractionId → source offsets of the nodes extraction selected (see ExtractedString.offsets). */
-positions) {
+positions, options = {}) {
+    const { moduleTranslator, placeholders = false } = options;
     const injections = [];
     let importAdded = false;
     let hookAdded = false;
@@ -371,11 +476,13 @@ positions) {
         }
     }
     const isTypeScript = forceTypeScript || filePath.endsWith('.ts') || filePath.endsWith('.tsx');
-    const ast = (0, ast_helpers_1.parseCode)(content, { isTypeScript });
+    const ast = (0, ast_helpers_1.parseCode)(content, { isTypeScript, preserveFormat: true });
     // Track components that need the hook
     const componentsNeedingHook = new Set();
-    let activeStrategy = StrategyFactory_1.StrategyFactory.getStrategy(framework, existingDeps);
+    let activeStrategy = StrategyFactory_1.StrategyFactory.getStrategy(framework, existingDeps, moduleTranslator);
     let hasNonComponentInjections = false;
+    // Plain t() for code outside any component the hook can go in.
+    const moduleStrategy = StrategyFactory_1.StrategyFactory.getStrategy('vanilla', undefined, moduleTranslator);
     // 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
@@ -384,7 +491,11 @@ positions) {
     // 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));
+        if (!starts)
+            return true;
+        // Where the node starts in the file as written, which is what extraction recorded.
+        const start = (0, ast_helpers_1.sourceOffset)(ast, node);
+        return typeof start === 'number' && starts.has(start);
     };
     const hasKey = (text, node) => {
         const id = `${filePath}:${node.loc?.start.line || 0}:${(0, string_utils_1.hashString)(text)}`;
@@ -445,10 +556,31 @@ positions) {
     // 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();
+    /**
+     * The function body the translation hook goes in. Lowercase render helpers
+     * get it only when there is no module-level t to use instead (next-intl, a
+     * config the user owns): a hook there runs at render time, while skipping
+     * would leave a string that was extracted and translated hardcoded.
+     */
+    const hookBody = (p) => (0, ast_helpers_1.findComponentBody)(p) ?? (moduleTranslator ? null : (0, ast_helpers_1.findComponentBody)(p, { renderHelpers: true }));
+    /** Pre-scan: where a string the main pass will replace gets its t() from. */
+    const noteSite = (p) => {
+        const isComponent = (0, ast_helpers_1.isInsideComponent)(p);
+        const body = isComponent ? hookBody(p) : null;
+        if (body && !isInComponentParams(p, body))
+            componentsNeedingHook.add(body);
+        else if (!isComponent || moduleTranslator)
+            hasNonComponentInjections = true;
+    };
     const moduleRewrites = [];
+    const labelRewrites = [];
     if (activeStrategy.id !== 'vanilla') {
         for (const plan of (0, module_constants_1.analyzeModuleConstants)(ast)) {
+            // Values that are also data are never translated in place, wired or not.
             if (!plan.provable)
+                for (const lit of plan.literals)
+                    moduleLiterals.add(lit.node);
+            if (!plan.provable && !plan.labels)
                 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())}`;
@@ -457,30 +589,72 @@ positions) {
             });
             if (keys.some((k) => !k) || confidenceThreshold > 100)
                 continue;
+            // Every render site needs a t(): its component's hook, or the config's module-level t.
+            if (!moduleTranslator && plan.renderSites.some((site) => !hookBody(site)))
+                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);
+                const body = hookBody(site);
                 if (body)
                     componentsNeedingHook.add(body);
             }
-            moduleRewrites.push({ plan, keys: keys });
+            (plan.provable ? moduleRewrites : labelRewrites).push({ plan, keys: keys });
         }
     }
+    /**
+     * A template literal or `+` concatenation extraction selected:
+     * `\`Charged ${total}\`` → key + `{ total }`. Null when it isn't one, the
+     * runtime can't fill placeholders, or two placeholders share a name.
+     */
+    const placeholderMessage = (path) => {
+        if (!placeholders)
+            return null;
+        if (path.isBinaryExpression() && path.node.operator !== '+')
+            return null;
+        if (!path.isTemplateLiteral() && !path.isBinaryExpression())
+            return null;
+        const names = [];
+        const exprs = [];
+        const text = (0, ast_helpers_1.extractExpressionContent)(path.node, names, exprs)?.trim();
+        if (!text)
+            return null;
+        const extractionId = `${filePath}:${path.node.loc?.start.line || 0}:${(0, string_utils_1.hashString)(text)}`;
+        const key = keyMapping.get(extractionId);
+        if (!key || !selected(extractionId, path.node) || confidenceThreshold > 100)
+            return null;
+        if ((0, ast_helpers_1.isNonTranslatableContext)(path))
+            return null;
+        const byName = new Map();
+        for (let i = 0; i < names.length; i++) {
+            const prev = byName.get(names[i]);
+            if (prev && !ast_helpers_1.t.isNodesEquivalent(prev, exprs[i]))
+                return null;
+            byName.set(names[i], exprs[i]);
+        }
+        if (byName.size === 0)
+            return { key, values: null };
+        const props = [...byName].map(([name, expr]) => {
+            const shorthand = ast_helpers_1.t.isIdentifier(expr) && expr.name === name;
+            const keyNode = ast_helpers_1.t.isValidIdentifier(name) ? ast_helpers_1.t.identifier(name) : ast_helpers_1.t.stringLiteral(name);
+            // The original node, not a clone: a clone loses its source offset, so a
+            // fallback string inside (`name || 'your business'`) couldn't be wired.
+            return ast_helpers_1.t.objectProperty(keyNode, expr, false, shorthand);
+        });
+        return { key, values: ast_helpers_1.t.objectExpression(props) };
+    };
     // Pre-scan to determine if we should fall back to vanilla strategy and identify hooks needed
     (0, ast_helpers_1.traverse)(ast, {
+        'TemplateLiteral|BinaryExpression'(path) {
+            if (!placeholderMessage(path))
+                return;
+            noteSite(path);
+        },
         '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;
-            }
+            noteSite(path);
         },
         JSXText(path) {
             const text = (0, ast_helpers_1.extractJSXTextContent)(path.node);
@@ -500,24 +674,7 @@ positions) {
                 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;
-            }
+            noteSite(path);
         },
         JSXAttribute(attributes) {
             const name = attributes.node.name;
@@ -543,24 +700,7 @@ positions) {
                 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;
-            }
+            noteSite(attributes);
         },
         StringLiteral(path) {
             if (moduleLiterals.has(path.node))
@@ -597,31 +737,16 @@ positions) {
                 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;
-            }
+            noteSite(path);
         }
     });
     // 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');
+    // Only with a real module-level t: without one (next-intl, a config the user
+    // owns) such strings are left as they are rather than importing `@/i18n`.
+    if (hasNonComponentInjections && componentsNeedingHook.size === 0 && activeStrategy.id !== 'vanilla' && moduleTranslator) {
+        activeStrategy = moduleStrategy;
     }
     // Compute hasUseClient AFTER strategy selection — the strategy may have fallen back
     // to vanilla, which doesn't care about use client directives.
@@ -634,13 +759,33 @@ positions) {
     const nameFor = (p) => {
         if (activeStrategy.id === 'vanilla')
             return 't';
-        const body = (0, ast_helpers_1.findComponentBody)(p);
+        const body = hookBody(p);
         if (!body)
             return 't';
         if (!translatorNames.has(body.node))
             translatorNames.set(body.node, translatorNameFor(body));
         return translatorNames.get(body.node);
     };
+    const translatorFor = (p) => {
+        if (activeStrategy.id === 'vanilla')
+            return 'module';
+        const body = (0, ast_helpers_1.isInsideComponent)(p) ? hookBody(p) : null;
+        // A default value (`({ title = 'Untitled' }) =>`) runs before the body's hook.
+        if (body && !isInComponentParams(p, body))
+            return 'hook';
+        return moduleTranslator ? 'module' : null;
+    };
+    let moduleTranslatorUsed = false;
+    let hookTranslatorUsed = false;
+    /** The t() expression for a replacement, recording which import it needs. */
+    const pickTranslator = (p, source) => {
+        if (source === 'module') {
+            moduleTranslatorUsed = true;
+            return 't';
+        }
+        hookTranslatorUsed = true;
+        return nameFor(p);
+    };
     for (const { plan, keys } of moduleRewrites) {
         plan.literals.forEach((lit, i) => {
             injections.push({
@@ -655,10 +800,37 @@ positions) {
             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]));
+            const name = pickTranslator(site, hookBody(site) ? 'hook' : 'module');
+            site.replaceWith(ast_helpers_1.t.callExpression(ast_helpers_1.t.identifier(name), [site.node]));
         }
         needsHook = true;
     }
+    const labelMapNames = new Set();
+    for (const { plan, keys } of labelRewrites) {
+        const maps = addLabelMaps(plan, keys, isTypeScript, labelMapNames);
+        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: `${maps.get(plan.literalFields[i])}[…]`,
+                key: keys[i],
+                confidence: 100,
+            });
+        });
+        plan.renderSites.forEach((site, i) => {
+            const name = pickTranslator(site, hookBody(site) ? 'hook' : 'module');
+            const field = plan.renderFields[i];
+            const lookup = () => ast_helpers_1.t.memberExpression(ast_helpers_1.t.identifier(maps.get(field)), ast_helpers_1.t.cloneNode(site.node, true, true), true);
+            // Values not in the map (not copy) are shown as they are, never looked up as keys.
+            site.replaceWith(plan.partialFields.has(field)
+                ? ast_helpers_1.t.conditionalExpression(lookup(), ast_helpers_1.t.callExpression(ast_helpers_1.t.identifier(name), [lookup()]), site.node)
+                : ast_helpers_1.t.callExpression(ast_helpers_1.t.identifier(name), [ast_helpers_1.t.logicalExpression('??', lookup(), site.node)]));
+        });
+        if (plan.renderSites.length > 0)
+            needsHook = true;
+    }
     const messageOptions = { transName: transLocalName(ast, content) };
     // Second pass: identify and replace strings
     (0, ast_helpers_1.traverse)(ast, {
@@ -671,15 +843,17 @@ positions) {
             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))
+            const source = translatorFor(path);
+            if (!source)
                 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');
+            // Outside a component there is no hook: the plain t() call, or with
+            // react-i18next <Trans t={t}> on the config's module-level t.
+            const strategy = source === 'hook' || activeStrategy.id === 'react-i18next' ? activeStrategy : moduleStrategy;
             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);
+            const name = pickTranslator(path, source);
+            path.node.children = withEdgeSpaces(path.node.children, name === 't' ? rendering.node : useTranslatorName(rendering.node, name));
             extraImports.push(...(rendering.imports ?? []));
             injections.push({
                 file: filePath,
@@ -713,31 +887,10 @@ positions) {
             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;
+            const source = translatorFor(path);
+            if (!source)
                 return;
-            }
-            const tFunctionName = nameFor(path);
+            const tFunctionName = pickTranslator(path, source);
             const tCall = useTranslatorName((0, ast_helpers_1.createJSXTCall)(key), tFunctionName);
             replaceJSXTextKeepingSpaces(path, tCall);
             injections.push({
@@ -777,31 +930,10 @@ positions) {
             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;
+            const source = translatorFor(attributes);
+            if (!source)
                 return;
-            }
-            const tFunctionName = nameFor(attributes);
+            const tFunctionName = pickTranslator(attributes, source);
             attributes.node.value = ast_helpers_1.t.jsxExpressionContainer(useTranslatorName((0, ast_helpers_1.createTCall)(key), tFunctionName));
             injections.push({
                 file: filePath,
@@ -814,6 +946,36 @@ positions) {
             });
             needsHook = true;
         },
+        // `\`Charged ${total}\`` / `'Hi ' + name` → t(key, { total }). Visited
+        // before the string literals inside, which are then part of the message.
+        'TemplateLiteral|BinaryExpression'(path) {
+            const message = placeholderMessage(path);
+            if (!message)
+                return;
+            const source = translatorFor(path);
+            if (!source)
+                return;
+            const name = pickTranslator(path, source);
+            const args = [ast_helpers_1.t.stringLiteral(message.key)];
+            if (message.values)
+                args.push(message.values);
+            const call = ast_helpers_1.t.callExpression(ast_helpers_1.t.identifier(name), args);
+            const line = path.node.loc?.start.line || 0;
+            const column = path.node.loc?.start.column || 0;
+            const original = (0, ast_helpers_1.generate)(path.node).code;
+            path.replaceWith(call);
+            // Not skipped: the values are visited next, for copy inside them.
+            injections.push({
+                file: filePath,
+                line,
+                column,
+                original,
+                replacement: (0, ast_helpers_1.generate)(call).code,
+                key: message.key,
+                confidence: 100,
+            });
+            needsHook = true;
+        },
         // Handle string literals in safe contexts (ObjectProperty, ArrayExpression, VariableDeclarator, etc.)
         StringLiteral(path) {
             if (moduleLiterals.has(path.node))
@@ -830,6 +992,8 @@ positions) {
             // Specific checks to ensure the string literal is in a value/translatable position
             if (parent.isObjectProperty() && parent.node.key === path.node)
                 return;
+            if (parent.isAssignmentPattern() && parent.node.right !== path.node)
+                return;
             if (parent.isConditionalExpression() && parent.node.test === path.node)
                 return;
             if (parent.isCallExpression() && parent.node.callee === path.node)
@@ -853,30 +1017,10 @@ positions) {
                 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;
+            const source = translatorFor(path);
+            if (!source)
                 return;
-            }
-            const tFunctionName = nameFor(path);
+            const tFunctionName = pickTranslator(path, source);
             path.replaceWith(useTranslatorName((0, ast_helpers_1.createTCall)(key), tFunctionName));
             injections.push({
                 file: filePath,
@@ -928,10 +1072,19 @@ positions) {
             const decl = activeStrategy.createImport(componentContext);
             neededImports.set(importSignature(decl), decl);
         });
-        if (neededImports.size === 0 && !activeStrategy.hasImport(ast)) {
+        // A hook already in place (no new hook) still needs its import; vanilla
+        // files need the config's `t`. Module-level t() in a hook-strategy file
+        // imports `t` from the config next to the hook's import.
+        const strategyUsed = activeStrategy.id === 'vanilla' ? moduleTranslatorUsed : hookTranslatorUsed;
+        // A file that already binds `t` (an earlier run's `import { t } from '@/i18n'`) keeps it.
+        const tBound = (0, ast_helpers_1.bindsTopLevel)(ast, 't');
+        if (neededImports.size === 0 && strategyUsed && !activeStrategy.hasImport(ast) && !(activeStrategy.id === 'vanilla' && tBound)) {
             const decl = activeStrategy.createImport(fileContext);
             neededImports.set(importSignature(decl), decl);
         }
+        if (moduleTranslatorUsed && activeStrategy.id !== 'vanilla' && moduleTranslator && !tBound) {
+            extraImports.push({ source: moduleTranslator, name: 't' });
+        }
         for (const decl of [...neededImports.values()].reverse()) {
             if (hasImportSpecifiers(ast, decl))
                 continue;