@babelize/engine 0.1.3 → 0.2.1

package/dist/modules/finalization/finalize.js

@@ -45,43 +45,22 @@ const static_runtime_1 = require("./static-runtime");
 const django_finalize_1 = require("./django-finalize");
 const nextjs_finalize_1 = require("./nextjs-finalize");
 const writes_1 = require("./writes");
+const react_native_finalize_1 = require("./react-native-finalize");
+const dependencies_1 = require("./dependencies");
+const i18n_config_path_1 = require("../../utils/i18n-config-path");
 const i18next_icu_1 = require("../../utils/i18next-icu");
 const DEPENDENCIES_BY_FRAMEWORK = {
-    react: {
-        'i18next': '^24.0.0',
-        'react-i18next': '^14.0.0',
-        'i18next-http-backend': '^2.0.2',
-        'i18next-browser-languagedetector': '^8.0.0',
-        // Messages are ICU ("Welcome back, {user}", plurals): i18next-icu formats them.
-        'i18next-icu': '^2.5.0',
-        'intl-messageformat': '^10.7.0',
-    },
+    react: dependencies_1.I18NEXT_WEB_DEPENDENCIES,
     // Next.js projects that already use react-i18next keep it (injection picks
     // ReactI18nextStrategy for them). Everything else gets next-intl — see
     // NEXT_INTL_DEPENDENCIES and finalizeNextIntl().
-    nextjs: {
-        'i18next': '^24.0.0',
-        'react-i18next': '^14.0.0',
-        'i18next-http-backend': '^2.0.2',
-        'i18next-browser-languagedetector': '^8.0.0',
-        // Messages are ICU ("Welcome back, {user}", plurals): i18next-icu formats them.
-        'i18next-icu': '^2.5.0',
-        'intl-messageformat': '^10.7.0',
-    },
+    nextjs: dependencies_1.I18NEXT_WEB_DEPENDENCIES,
     vue: {
         'vue-i18n': '^10.0.0',
     },
     static: {},
     django: {},
-    unknown: {
-        'i18next': '^24.0.0',
-        'react-i18next': '^14.0.0',
-        'i18next-http-backend': '^2.0.2',
-        'i18next-browser-languagedetector': '^8.0.0',
-        // Messages are ICU ("Welcome back, {user}", plurals): i18next-icu formats them.
-        'i18next-icu': '^2.5.0',
-        'intl-messageformat': '^10.7.0',
-    },
+    unknown: dependencies_1.I18NEXT_WEB_DEPENDENCIES,
 };
 const I18N_CONFIG_TEMPLATES = {
     react: `${i18next_icu_1.GENERATED_I18N_CONFIG_MARKER}
@@ -101,7 +80,8 @@ i18n
   .init({
     fallbackLng: 'en',
     defaultNS: 'translation',
-    debug: process.env.NODE_ENV !== 'production',
+    // No process.env here: Vite and other browser builds don't define it (or its types).
+    debug: false,
     interpolation: {
       escapeValue: false,
     },
@@ -198,7 +178,7 @@ i18n
   .init({
     fallbackLng: 'en',
     defaultNS: 'translation',
-    debug: process.env.NODE_ENV !== 'production',
+    debug: false,
     interpolation: {
       escapeValue: false,
     },
@@ -250,12 +230,15 @@ async function finalizeProject(workspace, dryRun, options = {}) {
     const framework = types_1.FRAMEWORKS.includes(workspace.framework)
         ? workspace.framework
         : 'unknown';
-    let requiredDeps = DEPENDENCIES_BY_FRAMEWORK[framework];
+    let requiredDeps = DEPENDENCIES_BY_FRAMEWORK[framework] ?? {};
     // Mirrors StrategyFactory: a Next.js project that already has react-i18next
     // is injected with react-i18next; every other Next.js project gets next-intl.
     let useNextIntl = framework === 'nextjs';
     if (!['static', 'django'].includes(framework)) {
-        const packageJsonPath = path.join(workspace.path, 'package.json');
+        // The app's package.json (apps/mobile in a monorepo); the install below
+        // still runs at the root, where workspaces install and the lockfile lives.
+        const appRoot = path.join(workspace.path, workspace.appDir ?? '.');
+        const packageJsonPath = path.join(appRoot, 'package.json');
         if (await (0, file_utils_1.pathExists)(packageJsonPath)) {
             const pkg = await (0, file_utils_1.readJsonFile)(packageJsonPath);
             if (pkg) {
@@ -264,6 +247,13 @@ async function finalizeProject(workspace, dryRun, options = {}) {
                     useNextIntl = false;
                 if (useNextIntl)
                     requiredDeps = nextjs_finalize_1.NEXT_INTL_DEPENDENCIES;
+                if (framework === 'react-native') {
+                    // expo-localization pinned to the app's Expo SDK, or react-native-localize.
+                    const rn = (0, react_native_finalize_1.reactNativeDependencies)(pkg);
+                    requiredDeps = rn.deps;
+                    if (rn.warning)
+                        warnings.push(rn.warning);
+                }
                 const missingDeps = Object.keys(requiredDeps).filter((d) => !deps[d]);
                 if (missingDeps.length > 0) {
                     pkg.dependencies = pkg.dependencies || {};
@@ -334,7 +324,7 @@ async function finalizeProject(workspace, dryRun, options = {}) {
             }
         }
     }
-    const srcDir = workspace.sourceDirs.find((d) => d.includes('src')) || workspace.sourceDirs[0] || '.';
+    const srcDir = (0, i18n_config_path_1.i18nConfigDir)(workspace);
     if (framework === 'static') {
         const i18nJsPath = path.join(workspace.path, 'i18n.js');
         const existingContent = await (0, file_utils_1.pathExists)(i18nJsPath) ? await (0, file_utils_1.readFile)(i18nJsPath) : null;
@@ -344,10 +334,12 @@ async function finalizeProject(workspace, dryRun, options = {}) {
         }
         else {
             // 'missing' or 'ours' — write/overwrite
-            const runtimeContent = (0, static_runtime_1.buildStaticRuntime)({
-                sourceLocale: workspace.sourceDirs[0] || 'en',
-                targetLocales: workspace.existingLocales || [],
-            });
+            // sourceDirs[0] is the scan root ("."), not a locale. Targets: this run's plus any
+            // locale files already on disk, so the switcher lists every language.
+            const sourceLocale = options.sourceLocale || 'en';
+            const targetLocales = [...new Set([...(options.targetLocales ?? []), ...(workspace.existingLocales ?? [])])]
+                .filter((l) => l && l !== sourceLocale && /^[A-Za-z]{2,3}([-_][A-Za-z0-9]+)*$/.test(l));
+            const runtimeContent = (0, static_runtime_1.buildStaticRuntime)({ sourceLocale, targetLocales });
             await writer.write(i18nJsPath, runtimeContent);
             configFileCreated = true;
             if (regenerationStatus === 'ours') {
@@ -379,6 +371,16 @@ async function finalizeProject(workspace, dryRun, options = {}) {
             }
         }
     }
+    else if (framework === 'react-native') {
+        const rn = await (0, react_native_finalize_1.finalizeReactNative)(workspace, {
+            sourceLocale: options.sourceLocale,
+            targetLocales: options.targetLocales,
+        }, writer);
+        warnings.push(...rn.warnings);
+        userOwnsInit = rn.userOwnsInit;
+        configFileCreated = configFileCreated || rn.configFileCreated;
+        entryPointModified = entryPointModified || rn.entryPointModified;
+    }
     else if (useNextIntl) {
         const nextIntl = await (0, nextjs_finalize_1.finalizeNextIntl)(workspace, dryRun, {
             sourceLocale: options.sourceLocale,
@@ -412,7 +414,7 @@ async function finalizeProject(workspace, dryRun, options = {}) {
         userOwnsInit = icu.userOwnsInit;
         if (!userOwnsInit && !(await (0, file_utils_1.pathExists)(i18nPath)) && !(await (0, file_utils_1.pathExists)(i18nJsPath))) {
             const isTS = workspace.sourceDirs.some((d) => d.endsWith('ts') || d.endsWith('tsx')) ||
-                (await (0, file_utils_1.pathExists)(path.join(workspace.path, 'tsconfig.json')));
+                (await (0, file_utils_1.pathExists)(path.join(workspace.path, workspace.appDir ?? '.', 'tsconfig.json')));
             const targetPath = isTS ? i18nPath : i18nJsPath;
             const template = I18N_CONFIG_TEMPLATES[framework] || I18N_CONFIG_TEMPLATES['unknown'];
             await writer.write(targetPath, template);
@@ -450,7 +452,7 @@ async function finalizeProject(workspace, dryRun, options = {}) {
     ];
     if (framework === 'vue') {
         for (const entry of entryPoints) {
-            const entryPath = path.join(workspace.path, entry);
+            const entryPath = path.join(workspace.path, workspace.appDir ?? '.', entry);
             if (await (0, file_utils_1.pathExists)(entryPath)) {
                 const content = await (0, file_utils_1.readFile)(entryPath);
                 const entryDir = path.dirname(entryPath);
@@ -468,9 +470,9 @@ async function finalizeProject(workspace, dryRun, options = {}) {
             }
         }
     }
-    else if (!['static', 'django'].includes(framework) && !useNextIntl && !userOwnsInit) {
+    else if (!['static', 'django', 'react-native'].includes(framework) && !useNextIntl && !userOwnsInit) {
         for (const entry of entryPoints) {
-            const entryPath = path.join(workspace.path, entry);
+            const entryPath = path.join(workspace.path, workspace.appDir ?? '.', entry);
             if (await (0, file_utils_1.pathExists)(entryPath)) {
                 const content = await (0, file_utils_1.readFile)(entryPath);
                 const entryDir = path.dirname(entryPath);
@@ -515,7 +517,7 @@ function modifyNextjsLayout(content, relativeI18nPath) {
     const providerImportPath = relativeI18nPath.replace(/i18n(\.(ts|js))?$/, 'I18nProvider');
     const isTS = content.includes(': Readonly') || content.includes(': React.ReactNode');
     try {
-        const ast = (0, ast_helpers_1.parseCode)(content, { isTypeScript: isTS });
+        const ast = (0, ast_helpers_1.parseCode)(content, { isTypeScript: isTS, preserveFormat: true });
         let modified = false;
         let wrapped = false;
         const sideEffectImports = [
@@ -596,7 +598,7 @@ function modifyNextjsLayoutFallback(content, providerImportPath) {
 function modifyVueEntryPoint(content, relativeI18nPath) {
     const isTS = /\.tsx?$/.test(relativeI18nPath) || /\bfrom\s+['"]vue['"]/.test(content) || /:\s*(?:string|number|boolean|Ref|ComputedRef)/.test(content);
     try {
-        const ast = (0, ast_helpers_1.parseCode)(content, { isTypeScript: isTS });
+        const ast = (0, ast_helpers_1.parseCode)(content, { isTypeScript: isTS, preserveFormat: true });
         let hasExistingImport = false;
         let modified = false;
         for (const node of ast.program.body) {
@@ -739,7 +741,9 @@ function i18nRuntimeFor(framework, pkg) {
         return { library: 'Django gettext', required: [], missing: [] };
     const deps = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
     const nextIntl = fw === 'nextjs' && !deps['react-i18next'];
-    const required = Object.keys(nextIntl ? nextjs_finalize_1.NEXT_INTL_DEPENDENCIES : DEPENDENCIES_BY_FRAMEWORK[fw]);
+    const required = Object.keys(nextIntl ? nextjs_finalize_1.NEXT_INTL_DEPENDENCIES
+        : fw === 'react-native' ? (0, react_native_finalize_1.reactNativeDependencies)(pkg ?? undefined).deps
+            : DEPENDENCIES_BY_FRAMEWORK[fw] ?? {});
     const library = nextIntl ? 'next-intl' : fw === 'vue' ? 'vue-i18n' : 'react-i18next';
     return { library, required, missing: required.filter((d) => !(pkg?.dependencies ?? {})[d]) };
 }

package/dist/modules/finalization/nextjs-finalize.js

@@ -241,7 +241,8 @@ writer = new writes_1.FinalizationWriter(workspace.path, dryRun)) {
     const warnings = [];
     let configFileCreated = false;
     let entryPointModified = false;
-    const root = workspace.path;
+    // The app's folder: the repo root, or apps/web in a monorepo.
+    const root = path.join(workspace.path, workspace.appDir ?? '.');
     const typescript = await (0, file_utils_1.pathExists)(path.join(root, 'tsconfig.json'));
     const appDir = (await (0, file_utils_1.pathExists)(path.join(root, 'app')))
         ? path.join(root, 'app')

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/finalization/static-runtime.d.ts

@@ -1,5 +1,5 @@
-export declare const STATIC_RUNTIME_VERSION = "1.0.0";
-export declare const RUNTIME_HEADER = "/* babelize:static-runtime v1.0.0 */";
+export declare const STATIC_RUNTIME_VERSION = "1.1.0";
+export declare const RUNTIME_HEADER = "/* babelize:static-runtime v1.1.0 */";
 export declare function buildStaticRuntime(config: {
     sourceLocale: string;
     targetLocales: string[];

package/dist/modules/finalization/static-runtime.js

@@ -4,8 +4,9 @@ exports.RUNTIME_HEADER = exports.STATIC_RUNTIME_VERSION = void 0;
 exports.buildStaticRuntime = buildStaticRuntime;
 exports.buildSwitcherPlaceholder = buildSwitcherPlaceholder;
 exports.checkRuntimeNeedsRegeneration = checkRuntimeNeedsRegeneration;
-exports.STATIC_RUNTIME_VERSION = '1.0.0';
-exports.RUNTIME_HEADER = `/* babelize:static-runtime v${exports.STATIC_RUNTIME_VERSION} */`;
+exports.STATIC_RUNTIME_VERSION = '1.1.0';
+const RUNTIME_MARKER = '/* babelize:static-runtime v';
+exports.RUNTIME_HEADER = `${RUNTIME_MARKER}${exports.STATIC_RUNTIME_VERSION} */`;
 function buildStaticRuntime(config) {
     const locales = JSON.stringify([config.sourceLocale, ...config.targetLocales]);
     const baseDir = config.baseDir ? JSON.stringify(config.baseDir) : 'null';
@@ -113,8 +114,9 @@ function buildStaticRuntime(config) {
   }
 
   function applyTranslations() {
+    // The whole document, so <title> and SEO <meta> tags in <head> are translated too.
     var walk = document.createTreeWalker(
-      document.body,
+      document.documentElement,
       NodeFilter.SHOW_ELEMENT,
       null,
       false
@@ -150,7 +152,7 @@ function buildStaticRuntime(config) {
           }
         }
       }
-      var attrNames = ['alt', 'title', 'placeholder', 'aria-label', 'aria-description'];
+      var attrNames = ['alt', 'title', 'placeholder', 'aria-label', 'aria-description', 'content'];
       for (var a = 0; a < attrNames.length; a++) {
         var attrKey = node.getAttribute('data-i18n-' + attrNames[a]);
         if (attrKey) {
@@ -162,6 +164,8 @@ function buildStaticRuntime(config) {
   }
 
   function updateHtmlAttributes() {
+    var select = document.querySelector('[data-babelize-switcher-select]');
+    if (select) select.value = lang;
     var meta = (loadedLocales[lang] || {})._meta;
     if (!meta) return;
     var html = document.documentElement;
@@ -254,7 +258,8 @@ function checkRuntimeNeedsRegeneration(existingContent) {
     if (!existingContent || existingContent.trim().length === 0) {
         return 'missing';
     }
-    if (existingContent.includes(exports.RUNTIME_HEADER)) {
+    // Any version we generated, so older runtimes get upgraded rather than treated as hand-written.
+    if (existingContent.includes(RUNTIME_MARKER)) {
         return 'ours';
     }
     return 'user';