@babelize/engine 0.0.0-stage → 0.1.2

package/dist/detection/stack.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * What a repository is built with — framework and package manager — from its
+ * file list and a few small files. Works on a local directory and on a
+ * remote listing (the GitHub tree API), so the dashboard can refuse an
+ * unsupported repository before a project is created instead of letting the
+ * first run fail.
+ *
+ * Supported signals always win over unsupported ones (a Laravel app whose UI
+ * is React is a React project for Babelize). An unsupported stack is only
+ * reported when nothing Babelize can translate was found.
+ */
+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.FRAMEWORK_DISPLAY_NAMES = void 0;
+exports.mentionsPythonPackage = mentionsPythonPackage;
+exports.detectPackageManagers = detectPackageManagers;
+exports.detectStack = detectStack;
+exports.localRepoFiles = localRepoFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+exports.FRAMEWORK_DISPLAY_NAMES = {
+    react: 'React', nextjs: 'Next.js', vue: 'Vue', static: 'HTML/CSS/JS', django: 'Django', unknown: 'Unknown',
+};
+const IGNORED_DIR = /(?:^|\/)(?:node_modules|\.git|venv|\.venv|env|site-packages|vendor|dist|build|\.next|__pycache__)\//;
+function depth(p) {
+    return p.split('/').length - 1;
+}
+/** Does a Python dependency file list Django itself (not just django-* add-ons)? */
+function mentionsPythonPackage(content, pkg) {
+    const name = pkg.replace(/[-_]/g, '[-_]');
+    // requirements.txt lines, pyproject/Pipfile/setup.py entries: django>=4, "Django (>=4)", django = "*"
+    const re = new RegExp(`(?:^|["'\\s,\\[(])${name}\\s*(?:\\[[^\\]]*\\])?\\s*(?:[<>=~!;"',)\\]]|\\(|$)`, 'im');
+    return re.test(content);
+}
+function jsFramework(pkg) {
+    if (!pkg)
+        return { id: 'unknown' };
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps['next'])
+        return { id: 'nextjs' };
+    if (deps['nuxt'] || deps['vue'])
+        return { id: 'vue' };
+    if (deps['react'] || deps['gatsby'] || deps['@remix-run/react'] || deps['astro'] || deps['react-dom'] || deps['react-scripts'])
+        return { id: 'react' };
+    if (deps['@angular/core'])
+        return { id: 'angular' };
+    if (deps['svelte'] || deps['@sveltejs/kit'])
+        return { id: 'svelte' };
+    if (deps['solid-js'])
+        return { id: 'solid' };
+    if (deps['ember-source'] || deps['ember-cli'])
+        return { id: 'ember' };
+    return { id: 'unknown' };
+}
+const UNSUPPORTED_NAMES = {
+    angular: 'Angular', svelte: 'Svelte', solid: 'SolidJS', ember: 'Ember', laravel: 'Laravel', symfony: 'Symfony',
+    wordpress: 'WordPress', php: 'PHP', rails: 'Ruby on Rails', jekyll: 'Jekyll', ruby: 'Ruby', flutter: 'Flutter',
+    dart: 'Dart', flask: 'Flask', fastapi: 'FastAPI', python: 'Python', go: 'Go', rust: 'Rust', android: 'Android',
+    java: 'Java', kotlin: 'Kotlin', dotnet: '.NET', ios: 'iOS (Swift)', elixir: 'Elixir/Phoenix', hugo: 'Hugo',
+};
+async function readJson(files, p) {
+    const raw = await files.read(p);
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function detectPackageManagers(paths, pyproject, preferPython) {
+    const js = [];
+    if (paths.has('bun.lockb') || paths.has('bun.lock'))
+        js.push('bun');
+    if (paths.has('pnpm-lock.yaml'))
+        js.push('pnpm');
+    if (paths.has('yarn.lock'))
+        js.push('yarn');
+    if (paths.has('package-lock.json'))
+        js.push('npm');
+    if (js.length === 0 && paths.has('package.json'))
+        js.push('npm');
+    const py = [];
+    if (paths.has('uv.lock'))
+        py.push('uv');
+    if (paths.has('poetry.lock') || (pyproject && /^\s*\[tool\.poetry\]/m.test(pyproject)))
+        py.push('poetry');
+    if (paths.has('Pipfile') || paths.has('Pipfile.lock'))
+        py.push('pipenv');
+    if (paths.has('pdm.lock'))
+        py.push('pdm');
+    const hasRequirements = [...paths].some((p) => /^requirements[^/]*\.txt$/.test(p) || /^requirements\/[^/]+\.txt$/.test(p));
+    if (hasRequirements || ((paths.has('pyproject.toml') || paths.has('setup.py') || paths.has('setup.cfg')) && py.length === 0))
+        py.push('pip');
+    return preferPython ? [...py, ...js] : [...js, ...py];
+}
+async function detectStack(files) {
+    const paths = files.paths.filter((p) => !IGNORED_DIR.test(`${p}`));
+    const set = new Set(paths);
+    const has = (p) => set.has(p);
+    const pyproject = has('pyproject.toml') ? await files.read('pyproject.toml') : null;
+    const result = (framework, preferPython = false) => ({
+        framework,
+        name: exports.FRAMEWORK_DISPLAY_NAMES[framework],
+        supported: framework !== 'unknown',
+        packageManagers: detectPackageManagers(set, pyproject, preferPython),
+    });
+    const unsupported = (id, preferPython = false) => {
+        const name = UNSUPPORTED_NAMES[id] ?? id;
+        return {
+            framework: 'unknown',
+            name,
+            supported: false,
+            unsupported: { id, name },
+            packageManagers: detectPackageManagers(set, pyproject, preferPython),
+            message: `${name} isn't supported yet. Babelize supports React, Next.js, Vue, Django and plain HTML/CSS/JS projects.`,
+        };
+    };
+    // 1. Django at the root.
+    if (has('manage.py'))
+        return result('django', true);
+    // 2. A JS framework at the root.
+    const rootPkg = has('package.json') ? await readJson(files, 'package.json') : null;
+    const rootJs = jsFramework(rootPkg);
+    if (rootJs.id === 'nextjs' || rootJs.id === 'vue' || rootJs.id === 'react')
+        return result(rootJs.id);
+    // 3. Django deeper in the tree, or declared as a dependency.
+    const pyDepFiles = ['requirements.txt', 'requirements/base.txt', 'requirements/prod.txt', 'requirements/production.txt', 'Pipfile', 'setup.py', 'setup.cfg']
+        .filter(has);
+    const pyDeps = [pyproject ?? '', ...(await Promise.all(pyDepFiles.map((p) => files.read(p)))).map((c) => c ?? '')].join('\n');
+    const managePy = paths.filter((p) => p.endsWith('/manage.py') && depth(p) <= 3).sort((a, b) => depth(a) - depth(b));
+    if (managePy.length > 0 || mentionsPythonPackage(pyDeps, 'django'))
+        return result('django', true);
+    // 4. A JS framework in a workspace package or first-level subdirectory.
+    const subPkgs = paths.filter((p) => p.endsWith('/package.json') && depth(p) <= 2).slice(0, 25);
+    for (const p of subPkgs) {
+        const sub = jsFramework(await readJson(files, p));
+        if (sub.id === 'nextjs' || sub.id === 'vue' || sub.id === 'react')
+            return result(sub.id);
+    }
+    // 5. Unsupported stacks with a clear signal.
+    if (rootJs.id !== 'unknown')
+        return unsupported(rootJs.id);
+    for (const p of subPkgs) {
+        const sub = jsFramework(await readJson(files, p));
+        if (sub.id !== 'unknown')
+            return unsupported(sub.id);
+    }
+    if (has('artisan'))
+        return unsupported('laravel');
+    if (has('composer.json')) {
+        const composer = (await files.read('composer.json')) ?? '';
+        if (/laravel\/framework/.test(composer))
+            return unsupported('laravel');
+        if (/symfony\/(?:framework-bundle|symfony)/.test(composer))
+            return unsupported('symfony');
+    }
+    if (has('wp-config.php') || has('wp-config-sample.php') || paths.some((p) => p.startsWith('wp-content/')))
+        return unsupported('wordpress');
+    if (has('Gemfile')) {
+        const gemfile = (await files.read('Gemfile')) ?? '';
+        if (/gem\s+['"]rails['"]/.test(gemfile) || has('config/routes.rb'))
+            return unsupported('rails');
+        if (/gem\s+['"]jekyll['"]/.test(gemfile))
+            return unsupported('jekyll');
+    }
+    if (has('pubspec.yaml')) {
+        const pubspec = (await files.read('pubspec.yaml')) ?? '';
+        return unsupported(/^\s*flutter\s*:/m.test(pubspec) ? 'flutter' : 'dart');
+    }
+    if (mentionsPythonPackage(pyDeps, 'flask'))
+        return unsupported('flask', true);
+    if (mentionsPythonPackage(pyDeps, 'fastapi'))
+        return unsupported('fastapi', true);
+    if (paths.some((p) => /(?:^|\/)AndroidManifest\.xml$/.test(p)))
+        return unsupported('android');
+    if (has('Package.swift') || paths.some((p) => /\.xcodeproj\//.test(p)))
+        return unsupported('ios');
+    if (has('hugo.toml') || (has('config.toml') && paths.some((p) => p.startsWith('layouts/'))))
+        return unsupported('hugo');
+    // 6. Plain HTML — unless every page is a server template.
+    const html = paths.filter((p) => /\.html?$/i.test(p) && depth(p) <= 6);
+    if (html.length > 0) {
+        const sample = await Promise.all(html.slice(0, 10).map((p) => files.read(p)));
+        if (!sample.some((c) => c && /\{%|<\?php|<%=/.test(c)))
+            return result('static');
+    }
+    // 7. Other languages (a static site served by them would have matched above).
+    if (has('Gemfile'))
+        return unsupported('ruby');
+    if (has('mix.exs'))
+        return unsupported('elixir');
+    if (has('go.mod'))
+        return unsupported('go');
+    if (has('Cargo.toml'))
+        return unsupported('rust');
+    if (paths.some((p) => /\.(?:csproj|sln|fsproj)$/.test(p)))
+        return unsupported('dotnet');
+    if (has('pom.xml') || has('build.gradle') || has('build.gradle.kts'))
+        return unsupported(has('build.gradle.kts') ? 'kotlin' : 'java');
+    if (has('composer.json') || paths.some((p) => p.endsWith('.php')))
+        return unsupported('php');
+    if (pyDeps.trim() || paths.some((p) => p.endsWith('.py')))
+        return unsupported('python', true);
+    return {
+        framework: 'unknown',
+        name: 'Unknown',
+        supported: false,
+        packageManagers: detectPackageManagers(set, pyproject, false),
+        message: files.truncated
+            ? "This repository is too large to inspect before creating the project."
+            : 'No React, Next.js, Vue, Django or HTML files were found in this repository.',
+    };
+}
+/** RepoFiles for a local directory. */
+async function localRepoFiles(dir) {
+    const paths = await (0, fast_glob_1.default)('**/*', {
+        cwd: dir,
+        onlyFiles: true,
+        dot: true,
+        deep: 7,
+        ignore: ['**/node_modules/**', '**/.git/**', '**/venv/**', '**/.venv/**', '**/site-packages/**', '**/__pycache__/**'],
+    });
+    return {
+        paths,
+        read: async (rel) => {
+            try {
+                const full = path.join(dir, rel);
+                const stat = await fs.promises.stat(full);
+                if (stat.size > 512 * 1024)
+                    return null;
+                return await fs.promises.readFile(full, 'utf8');
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}

package/dist/django/catalog.d.ts

@@ -0,0 +1,92 @@
+/**
+ * The gettext catalogue of a Django run: which messages the code uses, the
+ * existing translations in the project's .po files, and the merged .po (and,
+ * when the project commits them, .mo) files the run writes.
+ *
+ * Existing translations are the project's: a complete, non-fuzzy msgstr is
+ * never overwritten and never re-translated (it seeds the lockfile instead).
+ * Fuzzy entries are left for review. Only missing or empty entries are
+ * filled. Untouched entries are written back byte-for-byte.
+ */
+import type { ExtractedString, GeneratedKey, GettextInfo, InjectionResult, LocaleFile, TranslationResult, WorkspaceInfo } from '../runtime/types';
+import type { LockfileData } from '../modules/lockfile/schema';
+export interface CatalogEntry {
+    message: GettextInfo;
+    references: string[];
+    /** Engine keys by form. */
+    keys: {
+        single?: string;
+        icu?: string;
+        singular?: string;
+        plural?: string;
+    };
+}
+export interface GettextWriteResult {
+    locales: LocaleFile[];
+    notes: string[];
+}
+/**
+ * Why a translated form would fail `msgfmt --check-format` (and break
+ * `compilemessages`), or null if it's fine.
+ */
+export declare function formatProblem(source: string, translated: string, flags: string[], allowDroppingCount: boolean, union?: string): string | null;
+export declare class GettextCatalog {
+    private readonly workspace;
+    readonly entries: CatalogEntry[];
+    private readonly byKey;
+    private readonly states;
+    private constructor();
+    /** Build the run's catalogue and read the existing .po file of every target locale. */
+    static create(workspace: WorkspaceInfo, strings: ExtractedString[], keys: GeneratedKey[], targetLocales: string[]): Promise<GettextCatalog>;
+    /** The Django project's name: the package of its settings module (from manage.py). */
+    private projectName;
+    private loadLocale;
+    private existingEntry;
+    /**
+     * Translations already in the .po files, by engine key: they count as done
+     * (seeded into the lockfile) so they are neither re-translated nor billed.
+     */
+    existingTranslations(locale: string): Record<string, string>;
+    /**
+     * For each ICU-plural key: the placeholder that shows the count in its
+     * branches (`%(count)d`, or a lone `%d`). A plain-text translator gets a
+     * number of each plural category in its place, so every gettext form is
+     * inflected for its own numbers.
+     */
+    pluralValuePlaceholders(): Record<string, string>;
+    /** Put existing .po translations into the lockfile (they win over its cached values). */
+    seedLockfile(lockfile: LockfileData, flatKeys: Record<string, string>): LockfileData;
+    /**
+     * msgstr forms for an entry from the run's translations, or a reason it
+     * can't have them yet (null when simply untranslated).
+     */
+    formsFor(entry: CatalogEntry, locale: string, values: Record<string, string>): {
+        forms: string[];
+    } | {
+        problem: string;
+        key: string;
+    } | null;
+    /**
+     * Check every fresh translation can go into a .po file that compiles:
+     * placeholders must match the source (msgfmt --check-format), plurals must
+     * map onto the language's forms. Bad values are removed and reported as
+     * failures (and retried next run) — never shipped, never replaced by the
+     * source text.
+     */
+    validate(translation: TranslationResult, sourceValues: Record<string, string>): void;
+    /** Point references at where strings are after injection (lines move when imports/tags are added). */
+    refreshReferences(injection: InjectionResult): void;
+    /**
+     * Merge the run's translations into each target locale's .po file.
+     * Returns LocaleFiles carrying the exact content (and .mo when the project
+     * commits compiled catalogues); writes them unless `dryRun`.
+     */
+    write(targetLocales: string[], valuesByLocale: Record<string, Record<string, string>>, options: {
+        dryRun: boolean;
+        pseudo: boolean;
+        now?: Date;
+        projectName?: string;
+    }): Promise<GettextWriteResult>;
+}
+/** PO date format: 2026-10-10 14:03+0000 */
+export declare function formatPoDate(d: Date): string;