@babelize/engine 0.1.2 → 0.2.0

package/dist/modules/finalization/react-native-finalize.d.ts

@@ -0,0 +1,45 @@
+import type { WorkspaceInfo } from '../../runtime/types';
+import { FinalizationWriter } from './writes';
+interface PackageJson {
+    main?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}
+export declare function isExpoProject(pkg: PackageJson | undefined): boolean;
+/** The Expo SDK major from the `expo` dependency range (`~57.0.30` → 57). */
+export declare function expoSdkMajor(range: string | undefined): number | null;
+/** expo-localization range for an Expo SDK; null when the SDK can't be read. */
+export declare function expoLocalizationFor(expoRange: string | undefined): string | null;
+/** Dependencies a React Native app needs, and a warning when a version is a guess. */
+export declare function reactNativeDependencies(pkg: PackageJson | undefined): {
+    deps: Record<string, string>;
+    warning?: string;
+};
+/** `<locales>/index.(ts|js)`: every bundled locale, source first. */
+export declare function buildLocalesIndex(locales: string[], sourceLocale: string): string;
+/** `i18n.(ts|js)`: i18next with the bundled resources and the device's language. */
+export declare function buildReactNativeConfig(options: {
+    sourceLocale: string;
+    localeModule: string;
+    localesImport: string;
+    typescript: boolean;
+}): string;
+/**
+ * The module that runs first:
+ *  - Expo Router (`main: "expo-router/entry"`): the root layout, `app/_layout`;
+ *  - `main` pointing at a file (classic Expo `index.ts`, custom entries): that file;
+ *  - bare React Native (Metro defaults to `index.js`): `index.*`, then `App.*`.
+ */
+export declare function entryPointCandidates(pkg: PackageJson | undefined): string[];
+export interface ReactNativeFinalizeResult {
+    configFileCreated: boolean;
+    entryPointModified: boolean;
+    /** The project initializes i18next itself: Babelize wrote no config. */
+    userOwnsInit: boolean;
+    warnings: string[];
+}
+export declare function finalizeReactNative(workspace: WorkspaceInfo, options: {
+    sourceLocale?: string;
+    targetLocales?: string[];
+}, writer: FinalizationWriter): Promise<ReactNativeFinalizeResult>;
+export {};

package/dist/modules/finalization/react-native-finalize.js

@@ -0,0 +1,324 @@
+"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.isExpoProject = isExpoProject;
+exports.expoSdkMajor = expoSdkMajor;
+exports.expoLocalizationFor = expoLocalizationFor;
+exports.reactNativeDependencies = reactNativeDependencies;
+exports.buildLocalesIndex = buildLocalesIndex;
+exports.buildReactNativeConfig = buildReactNativeConfig;
+exports.entryPointCandidates = entryPointCandidates;
+exports.finalizeReactNative = finalizeReactNative;
+const path = __importStar(require("path"));
+const file_utils_1 = require("../../utils/file-utils");
+const i18next_icu_1 = require("../../utils/i18next-icu");
+const i18n_config_path_1 = require("../../utils/i18n-config-path");
+const dependencies_1 = require("./dependencies");
+/**
+ * React Native finalization (Expo Router, classic Expo, bare React Native).
+ *
+ * A native app can't fetch `/locales/<lng>.json` from a server, and has no
+ * browser language. So:
+ *  - translations are bundled: `<locales>/index.(ts|js)` imports every
+ *    `<locales>/<locale>.json` and is rewritten on every run (languages come
+ *    and go);
+ *  - `i18n.(ts|js)` initializes i18next from those resources with the
+ *    device's language (expo-localization, or react-native-localize in bare
+ *    React Native). It is written once; the user may edit it;
+ *  - the app's entry point imports `i18n` first, so i18next is ready before
+ *    any screen renders or module-level `t()` runs.
+ * Everything goes next to the locales (`src/` or the root), never in Expo
+ * Router's `app/`, where every file is a route.
+ */
+/**
+ * expo-localization for each Expo SDK, from `expo/bundledNativeModules.json`
+ * (what `npx expo install` picks). From SDK 55 the module versions follow the
+ * SDK's major version.
+ */
+const EXPO_LOCALIZATION_BY_SDK = {
+    50: '~14.8.4',
+    51: '~15.0.3',
+    52: '~16.0.1',
+    53: '~16.1.6',
+    54: '~17.0.9',
+};
+const FIRST_SDK_WITH_MATCHING_MAJORS = 55;
+const REACT_NATIVE_LOCALIZE = '^3.7.2';
+function allDeps(pkg) {
+    return { ...pkg?.dependencies, ...pkg?.devDependencies };
+}
+function isExpoProject(pkg) {
+    return Boolean(allDeps(pkg)['expo']);
+}
+/** The Expo SDK major from the `expo` dependency range (`~57.0.30` → 57). */
+function expoSdkMajor(range) {
+    const m = range?.match(/(\d+)\./);
+    return m ? Number(m[1]) : null;
+}
+/** expo-localization range for an Expo SDK; null when the SDK can't be read. */
+function expoLocalizationFor(expoRange) {
+    const sdk = expoSdkMajor(expoRange);
+    if (sdk === null)
+        return null;
+    if (sdk >= FIRST_SDK_WITH_MATCHING_MAJORS)
+        return `~${sdk}.0.0`;
+    return EXPO_LOCALIZATION_BY_SDK[sdk] ?? null;
+}
+/** Dependencies a React Native app needs, and a warning when a version is a guess. */
+function reactNativeDependencies(pkg) {
+    const deps = { ...dependencies_1.I18NEXT_CORE_DEPENDENCIES };
+    if (!isExpoProject(pkg)) {
+        deps['react-native-localize'] = REACT_NATIVE_LOCALIZE;
+        return { deps };
+    }
+    const expoRange = allDeps(pkg)['expo'];
+    const version = expoLocalizationFor(expoRange);
+    if (version) {
+        deps['expo-localization'] = version;
+        return { deps };
+    }
+    deps['expo-localization'] = '*';
+    return {
+        deps,
+        warning: `Couldn't tell the Expo SDK from "expo": "${expoRange}". Run \`npx expo install --fix\` so expo-localization matches your SDK.`,
+    };
+}
+/** Where the device language comes from. */
+function localeModule(pkg) {
+    return isExpoProject(pkg) ? 'expo-localization' : 'react-native-localize';
+}
+/** A valid identifier for a locale's messages: `pt-BR` → `ptBRMessages`. */
+function messagesIdentifier(locale) {
+    const camel = locale
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map((part, i) => (i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)))
+        .join('');
+    return `${/^[0-9]/.test(camel) ? `_${camel}` : camel}Messages`;
+}
+const LOCALES_INDEX_MARKER = '// @babelize-generated locale index';
+/** `<locales>/index.(ts|js)`: every bundled locale, source first. */
+function buildLocalesIndex(locales, sourceLocale) {
+    const ordered = [sourceLocale, ...locales.filter((l) => l !== sourceLocale).sort()];
+    const imports = ordered.map((l) => `import ${messagesIdentifier(l)} from './${l}.json';`);
+    const entries = ordered.map((l) => `  ${JSON.stringify(l)}: { translation: ${messagesIdentifier(l)} },`);
+    return [
+        `${LOCALES_INDEX_MARKER}: rewritten by Babelize on every run, edit the JSON files instead.`,
+        ...imports,
+        '',
+        'export const resources = {',
+        ...entries,
+        '};',
+        '',
+    ].join('\n');
+}
+/** `i18n.(ts|js)`: i18next with the bundled resources and the device's language. */
+function buildReactNativeConfig(options) {
+    const { sourceLocale, localeModule: from, localesImport, typescript } = options;
+    const ret = typescript ? ': string' : '';
+    return `${i18next_icu_1.GENERATED_I18N_CONFIG_MARKER}
+import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+import ICU from 'i18next-icu';
+import { getLocales } from '${from}';
+
+import { resources } from '${localesImport}';
+
+const SOURCE_LOCALE = ${JSON.stringify(sourceLocale)};
+
+/**
+ * The device's preferred language that has translations: the full tag
+ * (zh-Hant-TW), then shorter ones (zh-Hant), then any variant of the
+ * language (zh-Hans for zh).
+ */
+function deviceLanguage()${ret} {
+  const available = Object.keys(resources);
+  const find = (tag${ret}) => available.find((l) => l.toLowerCase() === tag.toLowerCase());
+  for (const locale of getLocales()) {
+    const parts = locale.languageTag.split('-');
+    for (let i = parts.length; i > 0; i--) {
+      const match = find(parts.slice(0, i).join('-'));
+      if (match) return match;
+    }
+    const sameLanguage = available.find((l) => l.split('-')[0].toLowerCase() === parts[0].toLowerCase());
+    if (sameLanguage) return sameLanguage;
+  }
+  return SOURCE_LOCALE;
+}
+
+i18n
+  .use(ICU)
+  .use(initReactI18next)
+  .init({
+    resources,
+    lng: deviceLanguage(),
+    fallbackLng: SOURCE_LOCALE,
+    // Translations are bundled: initialize synchronously so t() works before the first render.
+    initAsync: false,
+    interpolation: {
+      escapeValue: false,
+    },
+    react: {
+      useSuspense: false,
+    },
+  });
+
+export const t = i18n.t.bind(i18n);
+export default i18n;
+`;
+}
+const SOURCE_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js'];
+function withExtensions(base) {
+    return SOURCE_EXTENSIONS.map((ext) => `${base}${ext}`);
+}
+/**
+ * The module that runs first:
+ *  - Expo Router (`main: "expo-router/entry"`): the root layout, `app/_layout`;
+ *  - `main` pointing at a file (classic Expo `index.ts`, custom entries): that file;
+ *  - bare React Native (Metro defaults to `index.js`): `index.*`, then `App.*`.
+ */
+function entryPointCandidates(pkg) {
+    const main = pkg?.main?.replace(/^\.\//, '');
+    if (main && /^expo-router\//.test(main)) {
+        return [...withExtensions('src/app/_layout'), ...withExtensions('app/_layout')];
+    }
+    const candidates = [];
+    // A package's entry ("expo/AppEntry.js", classic Expo before SDK 49) isn't
+    // in the project (or is in node_modules): the app is App.* then.
+    if (main && !main.includes('node_modules')) {
+        candidates.push(...(path.extname(main) ? [main] : withExtensions(main)));
+    }
+    candidates.push(...withExtensions('index'), ...withExtensions('App'), ...withExtensions('src/App'));
+    return [...new Set(candidates)];
+}
+function importsConfig(content, specifier) {
+    const escaped = specifier.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+    return new RegExp(`(?:import|require)\\s*\\(?\\s*['"]${escaped}(?:\\.(?:[jt]sx?))?['"]`).test(content);
+}
+/** Every locale with a bundled JSON file, plus this run's. */
+async function bundledLocales(workspace, sourceLocale, targetLocales) {
+    const { dir } = (0, file_utils_1.localeFilePath)(workspace.path, workspace.publicDir, 'json', sourceLocale);
+    const onDisk = (await (0, file_utils_1.pathExists)(dir))
+        ? (await (0, file_utils_1.readDir)(dir)).filter((f) => f.endsWith('.json')).map((f) => f.slice(0, -'.json'.length))
+        : [];
+    return [...new Set([sourceLocale, ...targetLocales, ...onDisk])];
+}
+async function finalizeReactNative(workspace, options, writer) {
+    const warnings = [];
+    let configFileCreated = false;
+    let entryPointModified = false;
+    const pkg = workspace.packageJson;
+    const sourceLocale = options.sourceLocale || 'en';
+    // The app's folder: the repo root, or apps/mobile in a monorepo.
+    const appDir = (workspace.appDir ?? '.').split(path.sep).join('/');
+    const typescript = await (0, file_utils_1.pathExists)(path.join(workspace.path, appDir, 'tsconfig.json'));
+    const ext = typescript ? '.ts' : '.js';
+    const configDir = (0, i18n_config_path_1.i18nConfigDir)(workspace);
+    const { dir: localesDir } = (0, file_utils_1.localeFilePath)(workspace.path, workspace.publicDir, 'json', sourceLocale);
+    const localesRel = path.relative(workspace.path, localesDir).split(path.sep).join('/');
+    // The bundled resources: regenerated every run so added/removed languages are wired.
+    const locales = await bundledLocales(workspace, sourceLocale, options.targetLocales ?? []);
+    const indexPath = path.join(localesDir, `index${ext}`);
+    const existingIndex = await Promise.all(SOURCE_EXTENSIONS.map(async (e) => {
+        const p = path.join(localesDir, `index${e}`);
+        return (await (0, file_utils_1.pathExists)(p)) ? { path: p, content: await (0, file_utils_1.readFile)(p) } : null;
+    }));
+    const userIndex = existingIndex.find((f) => f && !f.content.startsWith(LOCALES_INDEX_MARKER));
+    if (userIndex) {
+        // Babelize's i18n config imports `resources` from this index: with the
+        // user's own index it would get undefined and crash at startup. Leave the
+        // whole setup to the user.
+        warnings.push(`${path.relative(workspace.path, userIndex.path)} isn't Babelize's, so Babelize didn't set up i18next. ` +
+            `Load the translations in ${localesRel}/*.json from your own i18next setup.`);
+        return { configFileCreated, entryPointModified, userOwnsInit: false, warnings };
+    }
+    else {
+        const ours = existingIndex.find((f) => f !== null);
+        await writer.write(ours?.path ?? indexPath, buildLocalesIndex(locales, sourceLocale));
+    }
+    const icu = await (0, i18next_icu_1.detectI18nextIcu)(workspace);
+    const note = (0, i18next_icu_1.missingIcuNote)(icu);
+    if (note)
+        warnings.push(note);
+    if (icu.userOwnsInit) {
+        warnings.push(`This app sets up i18next itself, so Babelize didn't add an i18n config. ` +
+            `Add the bundled translations (\`import { resources } from './${path.posix.relative(configDir, localesRel) || '.'}'\`) to your i18next.init().`);
+        return { configFileCreated, entryPointModified, userOwnsInit: true, warnings };
+    }
+    // i18n config: written once, next to the locales.
+    const configBase = path.join(workspace.path, configDir, 'i18n');
+    const existingConfig = SOURCE_EXTENSIONS.map((e) => `${configBase}${e}`);
+    let configExists = false;
+    for (const p of existingConfig)
+        if (await (0, file_utils_1.pathExists)(p))
+            configExists = true;
+    if (!configExists) {
+        let localesImport = path.posix.relative(configDir.split(path.sep).join('/'), localesRel);
+        localesImport = localesImport.startsWith('.') ? localesImport : `./${localesImport}`;
+        await writer.write(`${configBase}${ext}`, buildReactNativeConfig({
+            sourceLocale,
+            localeModule: localeModule(pkg),
+            localesImport,
+            typescript,
+        }));
+        configFileCreated = true;
+    }
+    // Entry point: import the config before anything else.
+    let entry = null;
+    for (const candidate of entryPointCandidates(pkg).map((c) => path.posix.join(appDir, c))) {
+        if (await (0, file_utils_1.pathExists)(path.join(workspace.path, candidate))) {
+            entry = candidate;
+            break;
+        }
+    }
+    if (!entry) {
+        warnings.push(`Couldn't find the app's entry point. Add \`import './${path.posix.join(configDir, 'i18n')}';\` ` +
+            `as the first line of it (app/_layout.tsx with Expo Router, otherwise index.js or App.tsx).`);
+        return { configFileCreated, entryPointModified, userOwnsInit: false, warnings };
+    }
+    const entryAbs = path.join(workspace.path, entry);
+    const content = await (0, file_utils_1.readFile)(entryAbs);
+    let specifier = path.posix.relative(path.posix.dirname(entry), path.posix.join(configDir.split(path.sep).join('/'), 'i18n'));
+    specifier = specifier.startsWith('.') ? specifier : `./${specifier}`;
+    if (!importsConfig(content, specifier)) {
+        // First line (after a leading comment block or directive): i18next must be
+        // initialized before other modules evaluate.
+        const directive = content.match(/^(?:\s*(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*\n|(['"])use [a-z]+\1;?\s*\n))*/);
+        const at = directive ? directive[0].length : 0;
+        await writer.write(entryAbs, `${content.slice(0, at)}import '${specifier}';\n${content.slice(at)}`);
+        entryPointModified = true;
+    }
+    return { configFileCreated, entryPointModified, userOwnsInit: false, warnings };
+}

package/dist/modules/format-injection/index.js

@@ -41,7 +41,19 @@ const inject_formats_1 = require("./inject-formats");
 const ast_helpers_1 = require("../../utils/ast-helpers");
 const file_utils_1 = require("../../utils/file-utils");
 const types_1 = require("../../runtime/types");
+const StrategyFactory_1 = require("../../injection/StrategyFactory");
 const generator_1 = require("@babel/generator");
+/** The local name of `import X from 'i18next'` in a file, if it has one. */
+function i18nextDefaultImport(ast) {
+    for (const node of ast.program.body) {
+        if (!t.isImportDeclaration(node) || node.source.value !== 'i18next')
+            continue;
+        const def = node.specifiers.find((s) => t.isImportDefaultSpecifier(s));
+        if (def)
+            return def.local.name;
+    }
+    return null;
+}
 /**
  * Run format injection for all format strings.
  *
@@ -66,13 +78,20 @@ async function injectFormats(workspace, formatStrings, formatConfig, dryRun = fa
         }
         stringsByFile.get(fileKey).push(s);
     }
-    // Build locale expression based on framework
-    const localeExpr = (0, inject_formats_1.buildLocaleExpression)(workspace.framework || 'unknown');
+    // The locale the formatted values follow. react-i18next (React, React
+    // Native, Next.js with react-i18next): the app's current language,
+    // `i18next.language` — React Native has no navigator.language, and on the
+    // web it ignored the language the user picked. Before init it is undefined,
+    // which Intl reads as the device default. Elsewhere the browser's language:
+    // next-intl's useLocale() and vue-i18n's composable only work in components.
+    const deps = { ...workspace.packageJson?.dependencies, ...workspace.packageJson?.devDependencies };
+    const followsI18next = StrategyFactory_1.StrategyFactory.getStrategy(workspace.framework || 'unknown', deps).id === 'react-i18next';
+    const browserLocaleExpr = (0, inject_formats_1.buildLocaleExpression)('browser');
     // Find all source files
     const sourceFiles = [];
     for (const sourceDir of workspace.sourceDirs) {
         const dirPath = path.join(workspace.path, sourceDir);
-        const files = await (0, file_utils_1.findFiles)(dirPath, types_1.SUPPORTED_EXTENSIONS, types_1.EXCLUDED_PATTERNS);
+        const files = await (0, file_utils_1.findFiles)(dirPath, types_1.SUPPORTED_EXTENSIONS, (0, types_1.workspaceExcludes)(workspace));
         sourceFiles.push(...files);
     }
     // Build a lookup of format strings by (relative file path, line)
@@ -93,11 +112,17 @@ async function injectFormats(workspace, formatStrings, formatConfig, dryRun = fa
         try {
             const originalContent = await (0, file_utils_1.readFile)(filePath);
             const isTypeScript = filePath.endsWith('.ts') || filePath.endsWith('.tsx');
-            const ast = (0, ast_helpers_1.parseCode)(originalContent, { isTypeScript });
+            const ast = (0, ast_helpers_1.parseCode)(originalContent, { isTypeScript, preserveFormat: true });
             const injections = [];
             const lineLookup = formatStringLookup.get(relativePath);
             if (!lineLookup)
                 continue;
+            const existingI18next = followsI18next ? i18nextDefaultImport(ast) : null;
+            // A name nothing else in the file binds (`import * as i18next from 'i18next'`, a local `i18next`).
+            const i18nextName = existingI18next ?? ((0, ast_helpers_1.bindsTopLevel)(ast, 'i18next') ? 'i18nextInstance' : 'i18next');
+            const fileLocaleExpr = followsI18next
+                ? t.memberExpression(t.identifier(i18nextName), t.identifier('language'))
+                : browserLocaleExpr;
             // Walk AST and replace matching string literals with Intl.* expressions
             (0, ast_helpers_1.traverse)(ast, {
                 StringLiteral(strPath) {
@@ -111,7 +136,7 @@ async function injectFormats(workspace, formatStrings, formatConfig, dryRun = fa
                     // Verify the text matches exactly (avoid false positives from partial matches)
                     if (node.value !== formatStr.text)
                         return;
-                    const astExpr = (0, inject_formats_1.buildFormatAstExpression)(formatStr.detectedFormat, formatConfig, localeExpr);
+                    const astExpr = (0, inject_formats_1.buildFormatAstExpression)(formatStr.detectedFormat, formatConfig, t.cloneNode(fileLocaleExpr));
                     if (!astExpr) {
                         skippedFiles.push({
                             file: relativePath,
@@ -144,7 +169,7 @@ async function injectFormats(workspace, formatStrings, formatConfig, dryRun = fa
                     const text = node.value.trim();
                     if (!text)
                         return;
-                    const astExpr = (0, inject_formats_1.buildFormatAstExpression)(formatStr.detectedFormat, formatConfig, localeExpr);
+                    const astExpr = (0, inject_formats_1.buildFormatAstExpression)(formatStr.detectedFormat, formatConfig, t.cloneNode(fileLocaleExpr));
                     if (!astExpr) {
                         skippedFiles.push({
                             file: relativePath,
@@ -170,6 +195,10 @@ async function injectFormats(workspace, formatStrings, formatConfig, dryRun = fa
             });
             if (injections.length === 0)
                 continue;
+            const importAdded = followsI18next && !existingI18next;
+            if (importAdded) {
+                ast.program.body.unshift(t.importDeclaration([t.importDefaultSpecifier(t.identifier(i18nextName))], t.stringLiteral('i18next')));
+            }
             const modifiedContent = (0, ast_helpers_1.generateCode)(ast, originalContent);
             if (!dryRun) {
                 await (0, file_utils_1.writeFile)(filePath, modifiedContent);
@@ -179,7 +208,7 @@ async function injectFormats(workspace, formatStrings, formatConfig, dryRun = fa
                 originalContent,
                 modifiedContent,
                 injections,
-                importAdded: false,
+                importAdded,
                 hookAdded: false,
             });
             totalInjections += injections.length;
@@ -196,7 +225,7 @@ async function injectFormats(workspace, formatStrings, formatConfig, dryRun = fa
     const htmlExtensions = ['.html', '.htm'];
     for (const sourceDir of workspace.sourceDirs) {
         const dirPath = path.join(workspace.path, sourceDir);
-        const files = await (0, file_utils_1.findFiles)(dirPath, htmlExtensions, types_1.EXCLUDED_PATTERNS);
+        const files = await (0, file_utils_1.findFiles)(dirPath, htmlExtensions, (0, types_1.workspaceExcludes)(workspace));
         for (const filePath of files) {
             const relativePath = (0, file_utils_1.getRelativePath)(workspace.path, filePath);
             const fileStrings = stringsByFile.get(relativePath);
@@ -213,7 +242,7 @@ async function injectFormats(workspace, formatStrings, formatConfig, dryRun = fa
                     const regex = new RegExp(escaped, 'g');
                     if (!regex.test(content))
                         continue;
-                    const astExpr = (0, inject_formats_1.buildFormatAstExpression)(formatStr.detectedFormat, formatConfig, localeExpr);
+                    const astExpr = (0, inject_formats_1.buildFormatAstExpression)(formatStr.detectedFormat, formatConfig, browserLocaleExpr);
                     if (!astExpr)
                         continue;
                     const replacementCode = (0, generator_1.generate)(astExpr).code;

package/dist/modules/format-injection/inject-formats.d.ts

@@ -26,6 +26,7 @@ export declare function buildFormatInjection(extracted: ExtractedString, formatC
  */
 export declare function buildFormatAstExpression(format: DetectedFormat, formatConfig: FormatLocaleConfig, localeExpr: t.Expression): t.Expression | null;
 /**
- * Build a locale expression based on the detected framework.
+ * Build a locale expression for an i18n library (an injection strategy id:
+ * 'react-i18next', 'next-intl'); anything else gets the browser's language.
  */
-export declare function buildLocaleExpression(framework: string): t.Expression;
+export declare function buildLocaleExpression(library: string): t.Expression;

package/dist/modules/format-injection/inject-formats.js

@@ -194,10 +194,11 @@ function buildNumberAstExpression(format, localeExpr) {
     return t.callExpression(t.memberExpression(nfNew, t.identifier('format')), [t.numericLiteral(numericValue)]);
 }
 /**
- * Build a locale expression based on the detected framework.
+ * Build a locale expression for an i18n library (an injection strategy id:
+ * 'react-i18next', 'next-intl'); anything else gets the browser's language.
  */
-function buildLocaleExpression(framework) {
-    switch (framework) {
+function buildLocaleExpression(library) {
+    switch (library) {
         case 'react-i18next':
             return t.memberExpression(t.identifier('i18n'), t.identifier('language'));
         case 'next-intl':

package/dist/modules/injection/inject.d.ts

@@ -14,7 +14,20 @@ positions?: Map<string, Set<number>>): Promise<InjectionResult>;
  */
 export declare function injectIntoFile(content: string, filePath: string, keyMapping: Map<string, string>, confidenceThreshold: number, framework: string, existingDeps?: Record<string, string>, forceTypeScript?: boolean, 
 /** extractionId → source offsets of the nodes extraction selected (see ExtractedString.offsets). */
-positions?: Map<string, Set<number>>): FileInjection;
+positions?: Map<string, Set<number>>, options?: {
+    /**
+     * Import path (relative to this file) of the i18n config's module-level `t`.
+     * Set when Babelize owns the react-i18next config: strings outside any
+     * component the hook can go in use it. Unset, they are left as they are.
+     */
+    moduleTranslator?: string;
+    /**
+     * Messages with placeholders are formatted at runtime (ICU): template
+     * literals and `+` concatenations become `t(key, { name })`. Off, they
+     * are left as they are.
+     */
+    placeholders?: boolean;
+}): FileInjection;
 /**
  * Inject translations into a Vue SFC file.
  * Uses @vue/compiler-sfc to parse, vue/template-scan to find translatable