@babelize/engine 0.0.0-stage → 0.1.0

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,13 @@
+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[];
+}
+export declare function resolveSettingsPath(workspacePath: string): Promise<string | null>;
+export declare function finalizeDjangoSettings(workspacePath: string, options?: {
+    targetLocales?: string[];
+    sourceLocale?: string;
+    dryRun?: boolean;
+}): Promise<DjangoFinalizeResult>;

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

@@ -0,0 +1,275 @@
+"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.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");
+/**
+ * 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) {
+    return (await resolveViaManagePy(workspacePath)) ?? (await resolveByGlob(workspacePath));
+}
+/**
+ * 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},`;
+    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 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;
+    // ── USE_I18N ────────────────────────────────────────────────
+    // Only flip an explicit False. Anything else the user wrote stays.
+    if (hasSetting(source, 'USE_I18N')) {
+        const falseMatch = source.match(/^USE_I18N\s*=\s*False\s*$/m);
+        if (falseMatch) {
+            source = source.replace(/^USE_I18N\s*=\s*False\s*$/m, '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 value = usesPathlibBaseDir(source)
+            ? "LOCALE_PATHS = [BASE_DIR / 'locale']"
+            : "LOCALE_PATHS = [os.path.join(BASE_DIR, 'locale')]";
+        source = appendSetting(source, value);
+        changes.push('Added LOCALE_PATHS');
+    }
+    // ── LANGUAGE_CODE ───────────────────────────────────────────
+    // Only added when missing; an existing value is a deliberate choice.
+    if (!hasSetting(source, 'LANGUAGE_CODE')) {
+        source = appendSetting(source, `LANGUAGE_CODE = '${sourceLocale}'`);
+        changes.push(`Added LANGUAGE_CODE = '${sourceLocale}'`);
+    }
+    // ── LANGUAGES ───────────────────────────────────────────────
+    if (!hasSetting(source, 'LANGUAGES') && targetLocales.length > 0) {
+        const all = [sourceLocale, ...targetLocales].filter((l, i, arr) => l && arr.indexOf(l) === i);
+        const entries = all.map((l) => `    ('${l}', '${l}'),`).join('\n');
+        source = appendSetting(source, `LANGUAGES = [\n${entries}\n]`);
+        changes.push(`Added LANGUAGES (${all.length} locales)`);
+    }
+    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 };
+}
+/**
+ * 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) {
+    const withBlock = source.includes(MANAGED_BLOCK_HEADER)
+        ? source
+        : `${source.trimEnd()}\n\n${MANAGED_BLOCK_HEADER}\n`;
+    return `${withBlock.trimEnd()}\n${statement}\n`;
+}

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

@@ -0,0 +1,36 @@
+import type { WorkspaceInfo } from '../../runtime/types';
+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[];
+    };
+}>;
+/**
+ * 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 {};