@babelize/engine 0.0.0-stage → 0.1.2

package/dist/modules/extractor/index.d.ts

@@ -0,0 +1,2 @@
+import type { BabelizeConfig, ExtractedString } from '../../types';
+export declare function extract(config: BabelizeConfig): Promise<ExtractedString[]>;

package/dist/modules/extractor/index.js

@@ -0,0 +1,63 @@
+"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.extract = extract;
+const path = __importStar(require("path"));
+const file_utils_1 = require("../../utils/file-utils");
+const types_1 = require("../../runtime/types");
+const extract_1 = require("./extract");
+async function extract(config) {
+    // For v2 bootstrapping we reuse existing phase1 extractor logic to guarantee
+    // identical behavior, while we later refactor adapters + parser in place.
+    const workspacePath = config.workspacePath;
+    const sourceDir = config.sourceDir ?? 'apps/frontend/app';
+    const dirPath = path.join(workspacePath, sourceDir);
+    const files = await (0, file_utils_1.findFiles)(dirPath, types_1.SUPPORTED_EXTENSIONS, types_1.EXCLUDED_PATTERNS);
+    const all = [];
+    for (const filePath of files) {
+        const rel = (0, file_utils_1.getRelativePath)(workspacePath, filePath);
+        const content = await (0, file_utils_1.readFile)(filePath);
+        const { strings } = await (0, extract_1.extractStringsFromFile)(content, rel);
+        all.push(...strings.map((s) => ({
+            id: s.id,
+            text: s.text,
+            filePath: s.file,
+            line: s.line,
+            column: s.column,
+            context: s.context,
+        })));
+    }
+    return all;
+}

package/dist/modules/finalization/django-finalize.d.ts

@@ -0,0 +1,28 @@
+export interface DjangoFinalizeResult {
+    /** Absolute path to the settings file, or null when none could be resolved. */
+    settingsPath: string | null;
+    /** Human-readable description of each edit applied. */
+    changes: string[];
+    warnings: string[];
+    /** Settings file content before and after, when it changed. */
+    original?: string;
+    updated?: string;
+}
+export declare function resolveSettingsPath(workspacePath: string): Promise<string | null>;
+/**
+ * The locale directory Django reads (LOCALE_PATHS[0]), relative to the
+ * workspace, '/'-separated. Falls back to <BASE_DIR>/locale — what finalize
+ * adds — when LOCALE_PATHS is absent or not a plain BASE_DIR path.
+ */
+export declare function resolveDjangoLocaleDir(workspacePath: string, djangoRoot: string): Promise<string>;
+/** First LOCALE_PATHS entry as a path relative to BASE_DIR, if it is one. */
+export declare function parseLocalePaths(source: string): string | null;
+export declare function finalizeDjangoSettings(workspacePath: string, options?: {
+    targetLocales?: string[];
+    sourceLocale?: string;
+    dryRun?: boolean;
+    /** Django project root (BASE_DIR), relative to the workspace. */
+    djangoRoot?: string;
+    /** Locale directory the catalogues were written to, relative to the workspace. */
+    localeDir?: string;
+}): Promise<DjangoFinalizeResult>;

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

@@ -0,0 +1,412 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSettingsPath = resolveSettingsPath;
+exports.resolveDjangoLocaleDir = resolveDjangoLocaleDir;
+exports.parseLocalePaths = parseLocalePaths;
+exports.finalizeDjangoSettings = finalizeDjangoSettings;
+const path = __importStar(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const file_utils_1 = require("../../utils/file-utils");
+const logger_1 = require("../../utils/logger");
+const locale_names_1 = require("../../django/locale-names");
+/**
+ * Django settings.py auto-configuration.
+ *
+ * Translating a Django project produces .po files under locale/<lang>/LC_MESSAGES/,
+ * but Django will not load them unless settings.py opts in: USE_I18N, LocaleMiddleware
+ * in the right position, LOCALE_PATHS pointing at the locale directory, and LANGUAGES
+ * listing what was translated. Without this the run "succeeds" and the site stays in
+ * English, which looks like a translation bug rather than a missing setting.
+ *
+ * settings.py is Python, and we have no Python parser here, so every edit is
+ * deliberately conservative:
+ *
+ *   - Nothing is ever reordered or rewritten. We append settings that are absent and
+ *     insert exactly one middleware line.
+ *   - A setting the user has already written is left alone, even when its value differs
+ *     from what we would have chosen. Their file, their call.
+ *   - Anything we cannot do safely becomes a warning rather than a guess.
+ *
+ * Re-running is a no-op: every step checks for what it is about to add.
+ */
+const LOCALE_MIDDLEWARE = 'django.middleware.locale.LocaleMiddleware';
+const SESSION_MIDDLEWARE = 'django.contrib.sessions.middleware.SessionMiddleware';
+const COMMON_MIDDLEWARE = 'django.middleware.common.CommonMiddleware';
+const MANAGED_BLOCK_HEADER = '# --- Added by Babelize ---';
+/** Is this settings file using pathlib (Django >= 3.1) or os.path? */
+function usesPathlibBaseDir(source) {
+    return /BASE_DIR\s*=\s*Path\s*\(/.test(source);
+}
+/**
+ * Does this setting already exist as a top-level assignment?
+ *
+ * Anchored to the start of a line so a mention inside a comment, a string, or a
+ * nested dict does not count as a definition.
+ */
+function hasSetting(source, name) {
+    return new RegExp(`^${name}\\s*=`, 'm').test(source);
+}
+/**
+ * Find settings.py by reading DJANGO_SETTINGS_MODULE out of manage.py.
+ *
+ * That is the project's own declaration of which settings module is real, which
+ * matters when a repo carries several (settings/base.py, settings/prod.py, or a
+ * second vendored Django app).
+ */
+async function resolveViaManagePy(workspacePath) {
+    const managePaths = await (0, fast_glob_1.default)('**/manage.py', {
+        cwd: workspacePath,
+        onlyFiles: true,
+        deep: 3,
+        ignore: ['**/node_modules/**', '**/.venv/**', '**/venv/**', '**/site-packages/**'],
+    });
+    for (const rel of managePaths) {
+        const source = await (0, file_utils_1.readFile)(path.join(workspacePath, rel)).catch(() => '');
+        // os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')
+        const match = source.match(/DJANGO_SETTINGS_MODULE['"]\s*,\s*['"]([\w.]+)['"]/);
+        if (!match)
+            continue;
+        const moduleParts = match[1].split('.');
+        const manageDir = path.dirname(path.join(workspacePath, rel));
+        // A settings module is either a file (pkg/settings.py) or a package
+        // (pkg/settings/__init__.py). Try both, relative to manage.py.
+        const candidates = [
+            path.join(manageDir, ...moduleParts) + '.py',
+            path.join(manageDir, ...moduleParts, '__init__.py'),
+        ];
+        for (const candidate of candidates) {
+            if (await (0, file_utils_1.pathExists)(candidate))
+                return candidate;
+        }
+        logger_1.engineLogger.warn('DJANGO_SETTINGS_MODULE did not resolve to a file', {
+            module: match[1],
+            managePath: rel,
+        });
+    }
+    return null;
+}
+/** Fall back to the shallowest settings.py in the tree. */
+async function resolveByGlob(workspacePath) {
+    const found = await (0, fast_glob_1.default)('**/settings.py', {
+        cwd: workspacePath,
+        onlyFiles: true,
+        deep: 4,
+        ignore: ['**/node_modules/**', '**/.venv/**', '**/venv/**', '**/site-packages/**'],
+    });
+    if (found.length === 0)
+        return null;
+    // Shallowest wins: a vendored or example settings.py is usually deeper than
+    // the project's own.
+    const shallowest = found.sort((a, b) => a.split('/').length - b.split('/').length || a.localeCompare(b))[0];
+    return path.join(workspacePath, shallowest);
+}
+async function resolveSettingsPath(workspacePath) {
+    const resolved = (await resolveViaManagePy(workspacePath)) ?? (await resolveByGlob(workspacePath));
+    if (!resolved)
+        return null;
+    // settings/dev.py with `from .base import *`: the shared settings live in base.py,
+    // and editing only dev.py would leave production without i18n.
+    const source = await (0, file_utils_1.readFile)(resolved).catch(() => '');
+    if (!/^MIDDLEWARE\s*=/m.test(source)) {
+        for (const m of source.matchAll(/^from\s+\.(\w+)\s+import\s+\*/gm)) {
+            const sibling = path.join(path.dirname(resolved), `${m[1]}.py`);
+            const siblingSource = await (0, file_utils_1.readFile)(sibling).catch(() => '');
+            if (/^MIDDLEWARE\s*=/m.test(siblingSource))
+                return sibling;
+        }
+    }
+    return resolved;
+}
+/**
+ * The locale directory Django reads (LOCALE_PATHS[0]), relative to the
+ * workspace, '/'-separated. Falls back to <BASE_DIR>/locale — what finalize
+ * adds — when LOCALE_PATHS is absent or not a plain BASE_DIR path.
+ */
+async function resolveDjangoLocaleDir(workspacePath, djangoRoot) {
+    const fallback = path.posix.join(djangoRoot, 'locale');
+    const settingsPath = await resolveSettingsPath(workspacePath);
+    if (!settingsPath)
+        return fallback;
+    const source = await (0, file_utils_1.readFile)(settingsPath).catch(() => '');
+    const rel = parseLocalePaths(source);
+    return rel ? path.posix.normalize(path.posix.join(djangoRoot, rel)) : fallback;
+}
+/** First LOCALE_PATHS entry as a path relative to BASE_DIR, if it is one. */
+function parseLocalePaths(source) {
+    const m = /^LOCALE_PATHS\s*=\s*[[(]/m.exec(source);
+    if (!m)
+        return null;
+    // First element of the list: up to the first comma outside brackets.
+    let depth = 0;
+    let first = '';
+    for (let i = m.index + m[0].length; i < source.length; i++) {
+        const ch = source[i];
+        if (ch === '(' || ch === '[')
+            depth++;
+        else if (ch === ')' || ch === ']') {
+            if (depth === 0)
+                break;
+            depth--;
+        }
+        else if (ch === ',' && depth === 0)
+            break;
+        first += ch;
+    }
+    first = first.trim();
+    const strings = (t) => [...t.matchAll(/['"]([^'"]+)['"]/g)].map((x) => x[1]);
+    // BASE_DIR / 'a' / 'b'   str(BASE_DIR / 'a')
+    if (/^(?:str\()?\s*BASE_DIR\s*\//.test(first))
+        return path.posix.join(...strings(first));
+    // os.path.join(BASE_DIR, 'a', 'b')   BASE_DIR.joinpath('a')   Path(BASE_DIR, 'a')
+    if (/^(?:os\.path\.join|Path)\(\s*BASE_DIR\s*,/.test(first) || /^BASE_DIR\.joinpath\(/.test(first)) {
+        const parts = strings(first);
+        return parts.length ? path.posix.join(...parts) : null;
+    }
+    return null;
+}
+/** LANGUAGES entries for the source and target locales: ('pt-br', 'Brazilian Portuguese'). */
+function languageEntries(locales) {
+    const seen = new Set();
+    const out = [];
+    for (const l of locales) {
+        const code = (0, locale_names_1.djangoLanguageCode)(l);
+        if (!l || seen.has(code))
+            continue;
+        seen.add(code);
+        out.push({ code, name: (0, locale_names_1.languageName)(l) });
+    }
+    return out;
+}
+/** Language codes listed in a LANGUAGES setting. */
+function listedLanguages(source) {
+    const m = /^LANGUAGES\s*=\s*[[(]/m.exec(source);
+    if (!m)
+        return null;
+    let depth = 0;
+    let end = -1;
+    for (let i = m.index + m[0].length - 1; i < source.length; i++) {
+        const ch = source[i];
+        if (ch === '[' || ch === '(')
+            depth++;
+        else if (ch === ']' || ch === ')') {
+            depth--;
+            if (depth === 0) {
+                end = i + 1;
+                break;
+            }
+        }
+    }
+    if (end === -1)
+        return null;
+    const body = source.slice(m.index, end);
+    const codes = [...body.matchAll(/[[(,]\s*\(\s*['"]([\w-]+)['"]\s*,/g)].map((x) => x[1].toLowerCase());
+    return { codes, start: m.index, end };
+}
+/**
+ * Insert LocaleMiddleware into the MIDDLEWARE list.
+ *
+ * Django requires it after SessionMiddleware (it reads the session for the active
+ * language) and before CommonMiddleware (which performs locale-aware URL redirects).
+ * Getting the order wrong fails quietly — language selection simply stops working.
+ */
+function insertLocaleMiddleware(source) {
+    if (source.includes(LOCALE_MIDDLEWARE)) {
+        return { source };
+    }
+    const middlewareMatch = source.match(/^MIDDLEWARE\s*=\s*\[/m);
+    if (!middlewareMatch) {
+        return {
+            source,
+            warning: 'Could not find a MIDDLEWARE list in settings.py — add ' +
+                `'${LOCALE_MIDDLEWARE}' after SessionMiddleware and before CommonMiddleware yourself.`,
+        };
+    }
+    const listStart = middlewareMatch.index + middlewareMatch[0].length;
+    const listEnd = source.indexOf(']', listStart);
+    if (listEnd === -1) {
+        return { source, warning: 'MIDDLEWARE list in settings.py is not closed — left unchanged.' };
+    }
+    const list = source.slice(listStart, listEnd);
+    const lines = list.split('\n');
+    // Match the indentation and quote style already in the file.
+    const entryLine = lines.find((l) => l.trim().startsWith("'") || l.trim().startsWith('"'));
+    const indent = entryLine?.match(/^(\s*)/)?.[1] ?? '    ';
+    const quote = entryLine?.trim().startsWith('"') ? '"' : "'";
+    const newEntry = `${indent}${quote}${LOCALE_MIDDLEWARE}${quote},${source.includes('\r\n') ? '\r' : ''}`;
+    const sessionIdx = lines.findIndex((l) => l.includes(SESSION_MIDDLEWARE));
+    const commonIdx = lines.findIndex((l) => l.includes(COMMON_MIDDLEWARE));
+    let insertAt;
+    if (sessionIdx !== -1) {
+        insertAt = sessionIdx + 1;
+    }
+    else if (commonIdx !== -1) {
+        insertAt = commonIdx;
+    }
+    else {
+        // Neither neighbour present. Append rather than guess a position.
+        insertAt = lines.length - 1;
+    }
+    // Appending after Session must still land before Common.
+    if (commonIdx !== -1 && insertAt > commonIdx) {
+        insertAt = commonIdx;
+    }
+    lines.splice(insertAt, 0, newEntry);
+    const updated = source.slice(0, listStart) + lines.join('\n') + source.slice(listEnd);
+    const position = sessionIdx !== -1 ? 'after SessionMiddleware' : commonIdx !== -1 ? 'before CommonMiddleware' : 'at the end of MIDDLEWARE';
+    return { source: updated, change: `Added LocaleMiddleware ${position}` };
+}
+async function finalizeDjangoSettings(workspacePath, options = {}) {
+    const { targetLocales = [], sourceLocale = 'en', dryRun = false } = options;
+    const djangoRoot = options.djangoRoot ?? '.';
+    const localeRel = path.posix.relative(djangoRoot === '.' ? '' : djangoRoot, options.localeDir ?? path.posix.join(djangoRoot, 'locale')) || 'locale';
+    const changes = [];
+    const warnings = [];
+    const settingsPath = await resolveSettingsPath(workspacePath);
+    if (!settingsPath) {
+        warnings.push('Could not find settings.py — configure USE_I18N, LocaleMiddleware, LOCALE_PATHS and LANGUAGES manually.');
+        return { settingsPath: null, changes, warnings };
+    }
+    const original = await (0, file_utils_1.readFile)(settingsPath).catch(() => null);
+    if (original === null) {
+        warnings.push(`Found ${path.basename(settingsPath)} but could not read it — left unchanged.`);
+        return { settingsPath, changes, warnings };
+    }
+    let source = original;
+    const nl = original.includes('\r\n') ? '\r\n' : '\n';
+    // ── USE_I18N ────────────────────────────────────────────────
+    // Only flip an explicit False. Anything else the user wrote stays.
+    if (hasSetting(source, 'USE_I18N')) {
+        const falseRe = /^USE_I18N[ \t]*=[ \t]*False\b/m;
+        if (falseRe.test(source)) {
+            source = source.replace(falseRe, 'USE_I18N = True');
+            changes.push('Set USE_I18N = True (was False)');
+        }
+    }
+    else {
+        source = appendSetting(source, 'USE_I18N = True');
+        changes.push('Added USE_I18N = True');
+    }
+    // ── LocaleMiddleware ────────────────────────────────────────
+    const middlewareResult = insertLocaleMiddleware(source);
+    source = middlewareResult.source;
+    if (middlewareResult.change)
+        changes.push(middlewareResult.change);
+    if (middlewareResult.warning)
+        warnings.push(middlewareResult.warning);
+    // ── LOCALE_PATHS ────────────────────────────────────────────
+    // Must match where the locale builder writes: <workspace>/locale/<lang>/LC_MESSAGES/
+    if (!hasSetting(source, 'LOCALE_PATHS')) {
+        const segments = localeRel.split('/').filter(Boolean);
+        const value = usesPathlibBaseDir(source)
+            ? `LOCALE_PATHS = [BASE_DIR / ${segments.map((p) => `'${p}'`).join(' / ')}]`
+            : `LOCALE_PATHS = [os.path.join(BASE_DIR, ${segments.map((p) => `'${p}'`).join(', ')})]`;
+        source = appendSetting(source, value, nl);
+        changes.push('Added LOCALE_PATHS');
+    }
+    else {
+        const configured = parseLocalePaths(source);
+        if (configured === null) {
+            warnings.push(`LOCALE_PATHS in ${path.basename(settingsPath)} isn't a plain BASE_DIR path — make sure it includes ${localeRel}/ (where the .po files were written).`);
+        }
+    }
+    // ── LANGUAGE_CODE ───────────────────────────────────────────
+    // Only added when missing; an existing value is a deliberate choice.
+    if (!hasSetting(source, 'LANGUAGE_CODE')) {
+        source = appendSetting(source, `LANGUAGE_CODE = '${(0, locale_names_1.djangoLanguageCode)(sourceLocale)}'`, nl);
+        changes.push(`Added LANGUAGE_CODE = '${(0, locale_names_1.djangoLanguageCode)(sourceLocale)}'`);
+    }
+    // ── LANGUAGES ───────────────────────────────────────────────
+    // Django only activates languages listed here. Ours live in the Babelize
+    // block and grow with new target locales; a list the user wrote is theirs —
+    // we only point out what it is missing.
+    const wanted = languageEntries([sourceLocale, ...targetLocales]);
+    const listed = listedLanguages(source);
+    if (!listed && targetLocales.length > 0) {
+        const entries = wanted.map((e) => `    ('${e.code}', '${e.name.replace(/'/g, "\\'")}'),`).join(nl);
+        source = appendSetting(source, `LANGUAGES = [${nl}${entries}${nl}]`, nl);
+        changes.push(`Added LANGUAGES (${wanted.length} locales)`);
+    }
+    else if (listed) {
+        const missing = wanted.filter((e) => !listed.codes.includes(e.code) && !listed.codes.includes(e.code.split('-')[0]));
+        const managedAt = source.indexOf(MANAGED_BLOCK_HEADER);
+        if (missing.length > 0 && managedAt !== -1 && listed.start > managedAt) {
+            const body = source.slice(listed.start, listed.end);
+            const close = body.lastIndexOf(']');
+            if (close !== -1) {
+                const indent = /\n([ \t]+)\(/.exec(body)?.[1] ?? '    ';
+                const before = body.slice(0, close).replace(/\s*$/, '');
+                const sep = before.endsWith(',') || before.endsWith('[') ? '' : ',';
+                const added = missing.map((e) => `${indent}('${e.code}', '${e.name.replace(/'/g, "\\'")}'),`).join(nl);
+                const next = `${before}${sep}${nl}${added}${nl}${body.slice(close)}`;
+                source = source.slice(0, listed.start) + next + source.slice(listed.end);
+                changes.push(`Added ${missing.map((e) => e.code).join(', ')} to LANGUAGES`);
+            }
+        }
+        else if (missing.length > 0) {
+            warnings.push(`LANGUAGES in ${path.basename(settingsPath)} doesn't list ${missing.map((e) => `'${e.code}'`).join(', ')} — ` +
+                'Django will not switch to those languages until you add them.');
+        }
+    }
+    if (changes.length === 0) {
+        logger_1.engineLogger.info('Django settings already configured for i18n', { settingsPath });
+        return { settingsPath, changes, warnings };
+    }
+    if (!dryRun) {
+        await (0, file_utils_1.writeFile)(settingsPath, source);
+    }
+    logger_1.engineLogger.info('Django settings finalized', {
+        settingsPath,
+        changes,
+        dryRun,
+    });
+    return { settingsPath, changes, warnings, original, updated: source };
+}
+/**
+ * Append a setting under a single Babelize block at the end of the file.
+ *
+ * Appending keeps every existing line exactly where the author put it — the
+ * alternative, inserting near related settings, means moving code around a file
+ * we cannot parse.
+ */
+function appendSetting(source, statement, nl = '\n') {
+    const withBlock = source.includes(MANAGED_BLOCK_HEADER)
+        ? source
+        : `${source.trimEnd()}${nl}${nl}${MANAGED_BLOCK_HEADER}${nl}`;
+    return `${withBlock.trimEnd()}${nl}${statement}${nl}`;
+}

package/dist/modules/finalization/finalize.d.ts

@@ -0,0 +1,38 @@
+import type { WorkspaceInfo } from '../../runtime/types';
+import { type FinalizationChange } from './writes';
+interface PackageJson {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    [key: string]: unknown;
+}
+export declare function finalizeProject(workspace: WorkspaceInfo, dryRun: boolean, options?: {
+    targetLocales?: string[];
+    sourceLocale?: string;
+    /**
+     * Run the package manager after adding missing i18n dependencies.
+     * Default true. Local runs (CLI on a temp copy) turn it off: installing
+     * into a throwaway copy is slow, runs install scripts, and the user's own
+     * install is what actually matters.
+     */
+    installDependencies?: boolean;
+}): Promise<{
+    finalization: {
+        dependenciesInvalid: boolean;
+        configFileCreated: boolean;
+        entryPointModified: boolean;
+        packagesInstalled: boolean;
+        warnings: string[];
+        changedFiles: FinalizationChange[];
+    };
+}>;
+/**
+ * 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.
+ */
+export declare function i18nRuntimeFor(framework: string, pkg: PackageJson | null | undefined): {
+    library: string;
+    required: string[];
+    missing: string[];
+};
+export {};