@babelize/engine 0.0.0-stage → 0.1.2

package/dist/modules/finalization/finalize.js

@@ -0,0 +1,745 @@
+"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.finalizeProject = finalizeProject;
+exports.i18nRuntimeFor = i18nRuntimeFor;
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const types_1 = require("@babelize/types");
+const file_utils_1 = require("../../utils/file-utils");
+const ast_helpers_1 = require("../../utils/ast-helpers");
+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 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',
+    },
+    // 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',
+    },
+    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',
+    },
+};
+const I18N_CONFIG_TEMPLATES = {
+    react: `${i18next_icu_1.GENERATED_I18N_CONFIG_MARKER}
+"use client";
+import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+
+import Backend from 'i18next-http-backend';
+import LanguageDetector from 'i18next-browser-languagedetector';
+import ICU from 'i18next-icu';
+
+i18n
+  .use(Backend)
+  .use(LanguageDetector)
+  .use(ICU)
+  .use(initReactI18next)
+  .init({
+    fallbackLng: 'en',
+    defaultNS: 'translation',
+    debug: process.env.NODE_ENV !== 'production',
+    interpolation: {
+      escapeValue: false,
+    },
+    react: {
+      useSuspense: false,
+      bindI18n: 'languageChanged loaded',
+      bindI18nStore: 'added removed',
+    },
+    backend: {
+      loadPath: '/locales/{{lng}}.json',
+    },
+  });
+
+export const t = i18n.t.bind(i18n);
+export default i18n;
+`,
+    nextjs: `${i18next_icu_1.GENERATED_I18N_CONFIG_MARKER}
+"use client";
+import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+
+import Backend from 'i18next-http-backend';
+import LanguageDetector from 'i18next-browser-languagedetector';
+import ICU from 'i18next-icu';
+
+i18n
+  .use(Backend)
+  .use(LanguageDetector)
+  .use(ICU)
+  .use(initReactI18next)
+  .init({
+    fallbackLng: 'en',
+    defaultNS: 'translation',
+    debug: process.env.NODE_ENV !== 'production',
+    interpolation: {
+      escapeValue: false,
+    },
+    react: {
+      useSuspense: false,
+      bindI18n: 'languageChanged loaded',
+      bindI18nStore: 'added removed',
+    },
+    backend: {
+      loadPath: '/locales/{{lng}}.json',
+    },
+  });
+
+export const t = i18n.t.bind(i18n);
+export default i18n;
+`,
+    vue: `/* babelize:i18n-config v2 */
+import { createI18n } from 'vue-i18n';
+
+const i18n = createI18n({
+  legacy: false,
+  globalInjection: true,
+  locale: 'en',
+  fallbackLocale: 'en',
+  messages: {},
+});
+
+export async function loadLocale(locale) {
+  try {
+    const response = await fetch(\`/locales/\${locale}.json\`);
+    if (!response.ok) return;
+    const data = await response.json();
+    // Strip _meta key if present
+    const { _meta, ...messages } = data;
+    i18n.global.setLocaleMessage(locale, messages);
+  } catch (e) {
+    console.warn(\`[babelize] Failed to load locale \${locale}\`, e);
+  }
+}
+
+// Pre-load default locale
+await loadLocale('en');
+
+export default i18n;
+`,
+    unknown: `${i18next_icu_1.GENERATED_I18N_CONFIG_MARKER}
+"use client";
+import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+
+import Backend from 'i18next-http-backend';
+import LanguageDetector from 'i18next-browser-languagedetector';
+import ICU from 'i18next-icu';
+
+i18n
+  .use(Backend)
+  .use(LanguageDetector)
+  .use(ICU)
+  .use(initReactI18next)
+  .init({
+    fallbackLng: 'en',
+    defaultNS: 'translation',
+    debug: process.env.NODE_ENV !== 'production',
+    interpolation: {
+      escapeValue: false,
+    },
+    react: {
+      useSuspense: false,
+      bindI18n: 'languageChanged loaded',
+      bindI18nStore: 'added removed',
+    },
+    backend: {
+      loadPath: '/locales/{{lng}}.json',
+    },
+  });
+
+export const t = i18n.t.bind(i18n);
+export default i18n;
+`,
+};
+const I18N_PROVIDER_TEMPLATE = `"use client";
+
+import { I18nextProvider } from 'react-i18next';
+import i18n from './i18n';
+
+export default function I18nProvider({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return <I18nextProvider i18n={i18n}>{children}</I18nextProvider>;
+}
+`;
+async function finalizeProject(workspace, dryRun, options = {}) {
+    const warnings = [];
+    let dependenciesInvalid = false;
+    let configFileCreated = false;
+    let entryPointModified = false;
+    let packagesInstalled = false;
+    let userOwnsInit = false;
+    /**
+     * Every file finalization writes goes through this recorder, so hosts can
+     * ship all of them with the run (the PR, the ZIP, the CLI diff) — including
+     * files it creates.
+     */
+    const writer = new writes_1.FinalizationWriter(workspace.path, dryRun);
+    // Coerced against FRAMEWORKS, not SUPPORTED_FRAMEWORKS. SUPPORTED_FRAMEWORKS
+    // omits 'django', so a Django project used to collapse to 'unknown' here —
+    // which made the two `framework === 'django'` branches below unreachable and
+    // put this function on the path to writing i18next dependencies into a Django
+    // project that happened to carry a package.json.
+    const framework = types_1.FRAMEWORKS.includes(workspace.framework)
+        ? workspace.framework
+        : 'unknown';
+    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');
+        if (await (0, file_utils_1.pathExists)(packageJsonPath)) {
+            const pkg = await (0, file_utils_1.readJsonFile)(packageJsonPath);
+            if (pkg) {
+                const deps = pkg.dependencies || {};
+                if (useNextIntl && { ...deps, ...(pkg.devDependencies || {}) }['react-i18next'])
+                    useNextIntl = false;
+                if (useNextIntl)
+                    requiredDeps = nextjs_finalize_1.NEXT_INTL_DEPENDENCIES;
+                const missingDeps = Object.keys(requiredDeps).filter((d) => !deps[d]);
+                if (missingDeps.length > 0) {
+                    pkg.dependencies = pkg.dependencies || {};
+                    for (const dep of missingDeps) {
+                        pkg.dependencies[dep] = requiredDeps[dep];
+                    }
+                    // Keep the user's key order (a sorted package.json is an unreviewable
+                    // diff); only the dependency map is sorted, as npm does.
+                    pkg.dependencies = Object.fromEntries(Object.entries(pkg.dependencies).sort(([a], [b]) => a.localeCompare(b)));
+                    await writer.write(packageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`);
+                    if (!dryRun) {
+                        // A committed lockfile must move with package.json, or `npm ci` /
+                        // `--frozen-lockfile` fails on the merged PR. Snapshot it so the
+                        // install's update is recorded (and shipped) like any other write.
+                        const lockfilesBefore = await readLockfiles(workspace.path);
+                        if (options.installDependencies !== false) {
+                            try {
+                                const pkgManager = detectPackageManager(workspace.path);
+                                await new Promise((resolve, reject) => {
+                                    const child = (0, child_process_1.spawn)(pkgManager, ['install'], {
+                                        cwd: workspace.path,
+                                        stdio: 'pipe',
+                                        timeout: 120000,
+                                    });
+                                    let stderr = '';
+                                    let stdout = '';
+                                    child.stdout?.on('data', (data) => { stdout += data.toString(); });
+                                    child.stderr?.on('data', (data) => { stderr += data.toString(); });
+                                    child.on('close', (code) => {
+                                        if (code === 0) {
+                                            packagesInstalled = true;
+                                            resolve();
+                                        }
+                                        else {
+                                            reject(new Error(`Exit code ${code}: ${stderr || stdout}`));
+                                        }
+                                    });
+                                    child.on('error', reject);
+                                });
+                            }
+                            catch {
+                                warnings.push(`Added dependencies to package.json but auto-install failed. Please run your package manager to install: ${missingDeps.join(', ')}`);
+                            }
+                        }
+                        const lockfilesAfter = await readLockfiles(workspace.path);
+                        for (const [name, before] of lockfilesBefore) {
+                            const after = lockfilesAfter.get(name);
+                            if (after !== undefined && after !== before) {
+                                writer.record(path.join(workspace.path, name), before, after);
+                            }
+                            else {
+                                warnings.push(`${name} was not updated for the new dependencies (${missingDeps.join(', ')}). ` +
+                                    `Run your package manager's install and commit ${name} before merging, or frozen-lockfile installs (npm ci) will fail.`);
+                            }
+                        }
+                    }
+                    dependenciesInvalid = true;
+                    if (packagesInstalled) {
+                        warnings.push(`Installed missing dependencies: ${missingDeps.join(', ')}.`);
+                    }
+                    else if (!dryRun) {
+                        warnings.push(`Added missing dependencies: ${missingDeps.join(', ')}. Please run your package manager install.`);
+                    }
+                    else {
+                        warnings.push(`Added missing dependencies: ${missingDeps.join(', ')}. Run again without --dry-run to install.`);
+                    }
+                }
+            }
+        }
+    }
+    const srcDir = workspace.sourceDirs.find((d) => d.includes('src')) || workspace.sourceDirs[0] || '.';
+    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;
+        const regenerationStatus = existingContent ? (0, static_runtime_1.checkRuntimeNeedsRegeneration)(existingContent) : 'missing';
+        if (regenerationStatus === 'user') {
+            warnings.push('WARNING: i18n.js exists but is not generated by Babelize. Leaving it untouched. The static runtime will not be updated.');
+        }
+        else {
+            // 'missing' or 'ours' — write/overwrite
+            const runtimeContent = (0, static_runtime_1.buildStaticRuntime)({
+                sourceLocale: workspace.sourceDirs[0] || 'en',
+                targetLocales: workspace.existingLocales || [],
+            });
+            await writer.write(i18nJsPath, runtimeContent);
+            configFileCreated = true;
+            if (regenerationStatus === 'ours') {
+                warnings.push('Updated i18n.js (new version available).');
+            }
+            else {
+                warnings.push('Created i18n.js for static HTML site. No npm packages required.');
+            }
+        }
+    }
+    else if (framework === 'django') {
+        // No JS runtime — the .po files are the locale output. What Django does need
+        // is settings.py opting in, otherwise the .po files are simply never loaded
+        // and the site stays in the source language.
+        const django = await (0, django_finalize_1.finalizeDjangoSettings)(workspace.path, {
+            targetLocales: options.targetLocales,
+            sourceLocale: options.sourceLocale,
+            dryRun,
+            djangoRoot: workspace.djangoRoot,
+            localeDir: workspace.publicDir,
+        });
+        warnings.push(...django.warnings);
+        if (django.changes.length > 0) {
+            configFileCreated = true;
+            warnings.push(`Configured ${path.basename(django.settingsPath ?? 'settings.py')}: ${django.changes.join('; ')}.`);
+            if (django.settingsPath && django.original !== undefined && django.updated !== undefined) {
+                // finalizeDjangoSettings writes settings.py itself (it needs the parse); record it here.
+                writer.record(django.settingsPath, django.original, django.updated);
+            }
+        }
+    }
+    else if (useNextIntl) {
+        const nextIntl = await (0, nextjs_finalize_1.finalizeNextIntl)(workspace, dryRun, {
+            sourceLocale: options.sourceLocale,
+            targetLocales: options.targetLocales,
+        }, writer);
+        warnings.push(...nextIntl.warnings);
+        configFileCreated = configFileCreated || nextIntl.configFileCreated;
+        entryPointModified = entryPointModified || nextIntl.entryPointModified;
+    }
+    else {
+        const i18nPath = path.join(workspace.path, srcDir, 'i18n.ts');
+        const i18nJsPath = path.join(workspace.path, srcDir, 'i18n.js');
+        // JSX sentences are ICU messages ("Hello {name}", plurals): make sure
+        // i18next-icu formats them. Babelize's own configs are updated; a config
+        // the user owns is left alone (extraction kept fragments for it).
+        const icu = await (0, i18next_icu_1.detectI18nextIcu)(workspace);
+        for (const rel of icu.generatedWithoutIcu) {
+            const abs = path.join(workspace.path, rel);
+            const content = await (0, file_utils_1.readFile)(abs);
+            const updated = (0, i18next_icu_1.addIcuToGeneratedConfig)(content);
+            if (updated !== content) {
+                await writer.write(abs, updated);
+                warnings.push(`Added i18next-icu to ${rel} (needed for messages with placeholders and plurals).`);
+            }
+        }
+        const note = (0, i18next_icu_1.missingIcuNote)(icu);
+        if (note)
+            warnings.push(note);
+        // The project initializes i18next itself (its own config elsewhere, or
+        // next-i18next): a second, Babelize config would be a second i18next.
+        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')));
+            const targetPath = isTS ? i18nPath : i18nJsPath;
+            const template = I18N_CONFIG_TEMPLATES[framework] || I18N_CONFIG_TEMPLATES['unknown'];
+            await writer.write(targetPath, template);
+            configFileCreated = true;
+        }
+        if (framework === 'nextjs' && !userOwnsInit) {
+            const providerPath = path.join(workspace.path, srcDir, 'I18nProvider.tsx');
+            if (!(await (0, file_utils_1.pathExists)(providerPath))) {
+                await writer.write(providerPath, I18N_PROVIDER_TEMPLATE);
+                configFileCreated = true;
+            }
+        }
+    }
+    const entryPoints = [
+        'src/main.tsx',
+        'src/main.jsx',
+        'src/main.ts',
+        'src/main.js',
+        'src/index.tsx',
+        'src/index.jsx',
+        'src/index.ts',
+        'src/index.js',
+        'src/App.tsx',
+        'src/App.jsx',
+        'src/App.ts',
+        'src/App.js',
+        'src/pages/_app.tsx',
+        'src/pages/_app.jsx',
+        'pages/_app.tsx',
+        'pages/_app.jsx',
+        'app/layout.tsx',
+        'app/layout.jsx',
+        'src/app/layout.tsx',
+        'src/app/layout.jsx',
+    ];
+    if (framework === 'vue') {
+        for (const entry of entryPoints) {
+            const entryPath = path.join(workspace.path, entry);
+            if (await (0, file_utils_1.pathExists)(entryPath)) {
+                const content = await (0, file_utils_1.readFile)(entryPath);
+                const entryDir = path.dirname(entryPath);
+                const i18nTargetAbs = path.join(workspace.path, srcDir, 'i18n');
+                let relativeI18nPath = path.relative(entryDir, i18nTargetAbs).split(path.sep).join('/');
+                if (!relativeI18nPath.startsWith('.')) {
+                    relativeI18nPath = './' + relativeI18nPath;
+                }
+                const modified = modifyVueEntryPoint(content, relativeI18nPath);
+                if (modified !== null) {
+                    await writer.write(entryPath, modified);
+                    entryPointModified = true;
+                }
+                break;
+            }
+        }
+    }
+    else if (!['static', 'django'].includes(framework) && !useNextIntl && !userOwnsInit) {
+        for (const entry of entryPoints) {
+            const entryPath = path.join(workspace.path, entry);
+            if (await (0, file_utils_1.pathExists)(entryPath)) {
+                const content = await (0, file_utils_1.readFile)(entryPath);
+                const entryDir = path.dirname(entryPath);
+                const i18nTargetAbs = path.join(workspace.path, srcDir, 'i18n');
+                let relativeI18nPath = path.relative(entryDir, i18nTargetAbs).split(path.sep).join('/');
+                if (!relativeI18nPath.startsWith('.')) {
+                    relativeI18nPath = './' + relativeI18nPath;
+                }
+                const isNextLayout = framework === 'nextjs' &&
+                    (entry.endsWith('app/layout.tsx') || entry.endsWith('app/layout.jsx'));
+                if (isNextLayout) {
+                    const modified = modifyNextjsLayout(content, relativeI18nPath);
+                    if (modified !== null) {
+                        await writer.write(entryPath, modified);
+                        entryPointModified = true;
+                    }
+                    break;
+                }
+                const hasImport = content.includes(`import '${relativeI18nPath}'`) ||
+                    content.includes(`import "${relativeI18nPath}"`) ||
+                    content.includes(`import '${relativeI18nPath}.js'`) ||
+                    content.includes(`import "${relativeI18nPath}.js"`) ||
+                    content.includes(`import '${relativeI18nPath}.ts'`) ||
+                    content.includes(`import "${relativeI18nPath}.ts"`) ||
+                    content.includes("import '@/i18n'");
+                if (!hasImport) {
+                    await writer.write(entryPath, `import '${relativeI18nPath}';\n${content}`);
+                    entryPointModified = true;
+                }
+                break;
+            }
+        }
+    }
+    const changedFiles = writer.changes;
+    return { finalization: { dependenciesInvalid, configFileCreated, entryPointModified, packagesInstalled, warnings, changedFiles } };
+}
+/**
+ * Wire Next.js App Router layouts through a client I18nProvider so i18n
+ * initializes in the browser and translation loads trigger re-renders.
+ */
+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 });
+        let modified = false;
+        let wrapped = false;
+        const sideEffectImports = [
+            relativeI18nPath,
+            `${relativeI18nPath}.js`,
+            `${relativeI18nPath}.ts`,
+            './i18n',
+            './i18n.js',
+            './i18n.ts',
+        ];
+        for (let i = ast.program.body.length - 1; i >= 0; i--) {
+            const node = ast.program.body[i];
+            if (ast_helpers_1.t.isImportDeclaration(node) &&
+                sideEffectImports.includes(node.source.value) &&
+                node.specifiers.length === 0) {
+                ast.program.body.splice(i, 1);
+                modified = true;
+            }
+        }
+        const hasProviderImport = ast.program.body.some((node) => ast_helpers_1.t.isImportDeclaration(node) &&
+            (node.source.value === providerImportPath ||
+                node.source.value === './I18nProvider' ||
+                node.source.value === './I18nProvider.tsx'));
+        if (!hasProviderImport) {
+            ast.program.body.unshift(ast_helpers_1.t.importDeclaration([ast_helpers_1.t.importDefaultSpecifier(ast_helpers_1.t.identifier('I18nProvider'))], ast_helpers_1.t.stringLiteral(providerImportPath)));
+            modified = true;
+        }
+        (0, ast_helpers_1.traverse)(ast, {
+            JSXElement(path) {
+                const opening = path.node.openingElement;
+                if (ast_helpers_1.t.isJSXIdentifier(opening.name) &&
+                    opening.name.name === 'body' &&
+                    path.node.children.length === 1 &&
+                    ast_helpers_1.t.isJSXExpressionContainer(path.node.children[0]) &&
+                    ast_helpers_1.t.isIdentifier(path.node.children[0].expression) &&
+                    path.node.children[0].expression.name === 'children') {
+                    path.node.children = [
+                        ast_helpers_1.t.jsxText('\n        '),
+                        ast_helpers_1.t.jsxElement(ast_helpers_1.t.jsxOpeningElement(ast_helpers_1.t.jsxIdentifier('I18nProvider'), [], false), ast_helpers_1.t.jsxClosingElement(ast_helpers_1.t.jsxIdentifier('I18nProvider')), [ast_helpers_1.t.jsxExpressionContainer(ast_helpers_1.t.identifier('children'))], false),
+                        ast_helpers_1.t.jsxText('\n      '),
+                    ];
+                    wrapped = true;
+                    modified = true;
+                    path.stop();
+                }
+            },
+        });
+        if (!modified)
+            return null;
+        if (wrapped)
+            return (0, ast_helpers_1.generateCode)(ast);
+    }
+    catch {
+        /* fall through to fallback */
+    }
+    return modifyNextjsLayoutFallback(content, providerImportPath);
+}
+function modifyNextjsLayoutFallback(content, providerImportPath) {
+    let updated = content
+        .replace(/import\s+['"](?:.*\/)?i18n(?:\.(?:ts|js))?['"];\s*\n?/g, '')
+        .replace(/<body([^>]*)>\s*\{children\}\s*<\/body>/, '<body$1>\n        <I18nProvider>{children}</I18nProvider>\n      </body>');
+    if (!updated.includes('I18nProvider')) {
+        updated = `import I18nProvider from '${providerImportPath}';\n${updated}`;
+    }
+    else if (!updated.includes(`from '${providerImportPath}'`) && !updated.includes('from "./I18nProvider"')) {
+        updated = `import I18nProvider from '${providerImportPath}';\n${updated}`;
+    }
+    if (updated === content)
+        return null;
+    return updated;
+}
+/**
+ * Modify a Vue entry point (main.ts) to import and use vue-i18n.
+ * Adds `import i18n from './i18n'` and inserts `.use(i18n)` in the
+ * `createApp(...)` chain. Returns the modified content, or null if
+ * no changes were needed.
+ */
+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 });
+        let hasExistingImport = false;
+        let modified = false;
+        for (const node of ast.program.body) {
+            if (ast_helpers_1.t.isImportDeclaration(node) &&
+                (node.source.value === relativeI18nPath ||
+                    node.source.value === relativeI18nPath + '.js' ||
+                    node.source.value === relativeI18nPath + '.ts' ||
+                    node.source.value === '@/i18n' ||
+                    node.source.value === './i18n')) {
+                hasExistingImport = true;
+                break;
+            }
+        }
+        if (!hasExistingImport) {
+            const importDecl = ast_helpers_1.t.importDeclaration([ast_helpers_1.t.importDefaultSpecifier(ast_helpers_1.t.identifier('i18n'))], ast_helpers_1.t.stringLiteral(relativeI18nPath));
+            ast.program.body.unshift(importDecl);
+            modified = true;
+        }
+        (0, ast_helpers_1.traverse)(ast, {
+            CallExpression(path) {
+                if (ast_helpers_1.t.isIdentifier(path.node.callee) &&
+                    path.node.callee.name === 'createApp') {
+                    let topPath = path;
+                    while (topPath.parentPath &&
+                        topPath.parentPath.isMemberExpression() &&
+                        topPath.parentPath.parentPath &&
+                        topPath.parentPath.parentPath.isCallExpression()) {
+                        topPath = topPath.parentPath.parentPath;
+                    }
+                    const topCall = topPath.node;
+                    let current = topCall.callee;
+                    while (current) {
+                        if (ast_helpers_1.t.isMemberExpression(current)) {
+                            if (ast_helpers_1.t.isIdentifier(current.property) &&
+                                current.property.name === 'use') {
+                                return;
+                            }
+                            current = current.object;
+                        }
+                        else if (ast_helpers_1.t.isCallExpression(current)) {
+                            current = current.callee;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    if (ast_helpers_1.t.isMemberExpression(topCall.callee)) {
+                        const callee = topCall.callee;
+                        const useCall = ast_helpers_1.t.callExpression(ast_helpers_1.t.memberExpression(callee.object, ast_helpers_1.t.identifier('use')), [ast_helpers_1.t.identifier('i18n')]);
+                        topCall.callee = ast_helpers_1.t.memberExpression(useCall, callee.property);
+                        modified = true;
+                    }
+                }
+            },
+        });
+        if (!modified) {
+            (0, ast_helpers_1.traverse)(ast, {
+                VariableDeclarator(path) {
+                    if (ast_helpers_1.t.isIdentifier(path.node.id) &&
+                        path.node.init &&
+                        ast_helpers_1.t.isCallExpression(path.node.init) &&
+                        ast_helpers_1.t.isIdentifier(path.node.init.callee) &&
+                        path.node.init.callee.name === 'createApp') {
+                        const varName = path.node.id.name;
+                        let hasUse = false;
+                        const parentContainer = path.parentPath?.parentPath?.node;
+                        const parentBody = parentContainer?.body || ast.program.body;
+                        const declStmt = path.parentPath?.node;
+                        const stmtIndex = parentBody.indexOf(declStmt);
+                        if (stmtIndex !== -1) {
+                            for (let i = stmtIndex + 1; i < parentBody.length; i++) {
+                                const node = parentBody[i];
+                                if (ast_helpers_1.t.isExpressionStatement(node) &&
+                                    ast_helpers_1.t.isCallExpression(node.expression) &&
+                                    ast_helpers_1.t.isMemberExpression(node.expression.callee) &&
+                                    ast_helpers_1.t.isIdentifier(node.expression.callee.object) &&
+                                    node.expression.callee.object.name === varName &&
+                                    ast_helpers_1.t.isIdentifier(node.expression.callee.property) &&
+                                    node.expression.callee.property.name === 'use') {
+                                    hasUse = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if (!hasUse) {
+                            const useStmt = ast_helpers_1.t.expressionStatement(ast_helpers_1.t.callExpression(ast_helpers_1.t.memberExpression(ast_helpers_1.t.identifier(varName), ast_helpers_1.t.identifier('use')), [ast_helpers_1.t.identifier('i18n')]));
+                            path.parentPath?.insertAfter(useStmt);
+                            modified = true;
+                            path.stop();
+                        }
+                    }
+                },
+            });
+        }
+        if (!modified)
+            return null;
+        return (0, ast_helpers_1.generateCode)(ast, content);
+    }
+    catch {
+        const hasImport = content.includes(`import i18n from '${relativeI18nPath}'`) ||
+            content.includes(`import i18n from "${relativeI18nPath}"`) ||
+            content.includes("import i18n from '@/i18n'");
+        if (hasImport)
+            return null;
+        return `import i18n from '${relativeI18nPath}';\n${content}`;
+    }
+}
+/** Text lockfiles a package manager rewrites on install (bun.lockb is binary and left to the user). */
+const TEXT_LOCKFILES = ['package-lock.json', 'npm-shrinkwrap.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lock'];
+async function readLockfiles(workspacePath) {
+    const found = new Map();
+    for (const name of TEXT_LOCKFILES) {
+        const abs = path.join(workspacePath, name);
+        if (await (0, file_utils_1.pathExists)(abs))
+            found.set(name, await (0, file_utils_1.readFile)(abs));
+    }
+    return found;
+}
+function detectPackageManager(workspacePath) {
+    if ((0, fs_1.existsSync)(path.join(workspacePath, 'bun.lock')))
+        return 'bun';
+    if ((0, fs_1.existsSync)(path.join(workspacePath, 'bun.lockb')))
+        return 'bun';
+    if ((0, fs_1.existsSync)(path.join(workspacePath, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if ((0, fs_1.existsSync)(path.join(workspacePath, 'yarn.lock')))
+        return 'yarn';
+    return 'npm';
+}
+/**
+ * The i18n runtime the engine wires a project to, and which of its packages
+ * package.json doesn't list yet. Same choice as finalizeProject: Next.js gets
+ * next-intl unless it already uses react-i18next.
+ */
+function i18nRuntimeFor(framework, pkg) {
+    const fw = types_1.FRAMEWORKS.includes(framework) ? framework : 'unknown';
+    if (fw === 'static')
+        return { library: 'Babelize static runtime (i18n.js)', required: [], missing: [] };
+    if (fw === 'django')
+        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 library = nextIntl ? 'next-intl' : fw === 'vue' ? 'vue-i18n' : 'react-i18next';
+    return { library, required, missing: required.filter((d) => !(pkg?.dependencies ?? {})[d]) };
+}