@babelize/engine 0.0.0-stage → 0.1.0

package/dist/injection/strategies/NextIntlStrategy.d.ts

@@ -0,0 +1,25 @@
+import * as t from '@babel/types';
+import { InjectionStrategy, InjectionContext, MessageRendering } from '../InjectionStrategy';
+import { type JsxMessage } from '../../utils/jsx-message';
+export declare class NextIntlStrategy implements InjectionStrategy {
+    id: string;
+    hasImport(ast: t.File): boolean;
+    createImport(context: InjectionContext): t.ImportDeclaration;
+    hasHook(componentPath: any): boolean;
+    createHook(context: InjectionContext): t.Statement[];
+    getTranslationFunctionName(): string;
+    /**
+     * `{t("key", { user })}`, or with inline elements
+     * `{t.rich("key", { user, link: (chunks) => <Link href="/x">{chunks}</Link> })}`
+     * for the message "Hi {user}, read the <link>terms</link>". Works with both
+     * useTranslations() and await getTranslations().
+     */
+    createMessage(key: string, message: JsxMessage): MessageRendering;
+    /**
+     * Never. An async component can't be rendered by a Client Component, and
+     * shared UI components often are. `useTranslations()` works in Server
+     * Components and client/shared ones as long as they aren't async, so only
+     * components that are already async get `await getTranslations()`.
+     */
+    requiresAsyncComponent(_context?: InjectionContext): boolean;
+}

package/dist/injection/strategies/NextIntlStrategy.js

@@ -0,0 +1,141 @@
+"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.NextIntlStrategy = void 0;
+const t = __importStar(require("@babel/types"));
+const jsx_message_1 = require("../../utils/jsx-message");
+/** `await getTranslations()` only for components that are already async (and not in a 'use client' file). */
+function usesServerApi(context) {
+    return !!context && !context.hasUseClient && context.isAsyncComponent === true;
+}
+class NextIntlStrategy {
+    constructor() {
+        this.id = 'next-intl';
+    }
+    hasImport(ast) {
+        let found = false;
+        for (const node of ast.program.body) {
+            if (t.isImportDeclaration(node) && (node.source.value === 'next-intl' || node.source.value === 'next-intl/server')) {
+                const hasSpecifier = node.specifiers.some(spec => t.isImportSpecifier(spec) &&
+                    t.isIdentifier(spec.imported) &&
+                    (spec.imported.name === 'useTranslations' || spec.imported.name === 'getTranslations'));
+                if (hasSpecifier) {
+                    found = true;
+                    break;
+                }
+            }
+        }
+        return found;
+    }
+    createImport(context) {
+        const server = usesServerApi(context);
+        const importName = server ? 'getTranslations' : 'useTranslations';
+        const importSource = server ? 'next-intl/server' : 'next-intl';
+        return t.importDeclaration([t.importSpecifier(t.identifier(importName), t.identifier(importName))], t.stringLiteral(importSource));
+    }
+    hasHook(componentPath) {
+        let found = false;
+        componentPath.traverse({
+            VariableDeclarator(path) {
+                if (path.node.init &&
+                    ((t.isCallExpression(path.node.init) &&
+                        t.isIdentifier(path.node.init.callee) &&
+                        path.node.init.callee.name === 'useTranslations') ||
+                        (t.isAwaitExpression(path.node.init) &&
+                            t.isCallExpression(path.node.init.argument) &&
+                            t.isIdentifier(path.node.init.argument.callee) &&
+                            path.node.init.argument.callee.name === 'getTranslations'))) {
+                    found = true;
+                    path.stop();
+                }
+            }
+        });
+        return found;
+    }
+    createHook(context) {
+        if (!usesServerApi(context)) {
+            // const t = useTranslations();
+            return [
+                t.variableDeclaration('const', [
+                    t.variableDeclarator(t.identifier('t'), t.callExpression(t.identifier('useTranslations'), []))
+                ])
+            ];
+        }
+        else {
+            // const t = await getTranslations();
+            return [
+                t.variableDeclaration('const', [
+                    t.variableDeclarator(t.identifier('t'), t.awaitExpression(t.callExpression(t.identifier('getTranslations'), [])))
+                ])
+            ];
+        }
+    }
+    getTranslationFunctionName() {
+        return 't';
+    }
+    /**
+     * `{t("key", { user })}`, or with inline elements
+     * `{t.rich("key", { user, link: (chunks) => <Link href="/x">{chunks}</Link> })}`
+     * for the message "Hi {user}, read the <link>terms</link>". Works with both
+     * useTranslations() and await getTranslations().
+     */
+    createMessage(key, message) {
+        if (!(0, jsx_message_1.hasTags)(message))
+            return { node: t.jsxExpressionContainer((0, jsx_message_1.createMessageTCall)(key, message)) };
+        const values = (0, jsx_message_1.placeholderValues)(message);
+        const props = [];
+        for (const entry of message.entries) {
+            if (entry.kind === 'placeholder')
+                props.push(values.shift());
+            else
+                props.push((0, jsx_message_1.richTagValue)(entry));
+        }
+        const call = t.callExpression(t.memberExpression(t.identifier('t'), t.identifier('rich')), [
+            t.stringLiteral(key),
+            t.objectExpression(props),
+        ]);
+        return { node: t.jsxExpressionContainer(call) };
+    }
+    /**
+     * Never. An async component can't be rendered by a Client Component, and
+     * shared UI components often are. `useTranslations()` works in Server
+     * Components and client/shared ones as long as they aren't async, so only
+     * components that are already async get `await getTranslations()`.
+     */
+    requiresAsyncComponent(_context) {
+        return false;
+    }
+}
+exports.NextIntlStrategy = NextIntlStrategy;

package/dist/injection/strategies/ReactI18nextStrategy.d.ts

@@ -0,0 +1,19 @@
+import * as t from '@babel/types';
+import { InjectionStrategy, InjectionContext, MessageOptions, MessageRendering } from '../InjectionStrategy';
+import { type JsxMessage } from '../../utils/jsx-message';
+export declare class ReactI18nextStrategy implements InjectionStrategy {
+    id: string;
+    hasImport(ast: t.File): boolean;
+    createImport(): t.ImportDeclaration;
+    hasHook(componentPath: any): boolean;
+    createHook(_context: InjectionContext): t.Statement[];
+    getTranslationFunctionName(): string;
+    requiresAsyncComponent(_context: InjectionContext): boolean;
+    /**
+     * `{t("key", { user })}`, or with inline elements
+     * `<Trans i18nKey="key" t={t} values={{ user }} components={{ link: <Link href="/x" /> }} />`
+     * for the message "Hi {user}, read the <link>terms</link>" (named Trans
+     * components; placeholders are ICU arguments, rendered by i18next-icu).
+     */
+    createMessage(key: string, message: JsxMessage, options?: MessageOptions): MessageRendering;
+}

package/dist/injection/strategies/ReactI18nextStrategy.js

@@ -0,0 +1,116 @@
+"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.ReactI18nextStrategy = void 0;
+const t = __importStar(require("@babel/types"));
+const jsx_message_1 = require("../../utils/jsx-message");
+class ReactI18nextStrategy {
+    constructor() {
+        this.id = 'react-i18next';
+    }
+    hasImport(ast) {
+        let found = false;
+        // We cannot use traverse easily here without passing it or doing manual loop.
+        // It's better to implement this using a basic AST scan. Let's rely on standard search
+        for (const node of ast.program.body) {
+            if (t.isImportDeclaration(node) && node.source.value === 'react-i18next') {
+                const hasSpecifier = node.specifiers.some(spec => t.isImportSpecifier(spec) &&
+                    t.isIdentifier(spec.imported) &&
+                    spec.imported.name === 'useTranslation');
+                if (hasSpecifier) {
+                    found = true;
+                    break;
+                }
+            }
+        }
+        return found;
+    }
+    createImport() {
+        return t.importDeclaration([t.importSpecifier(t.identifier('useTranslation'), t.identifier('useTranslation'))], t.stringLiteral('react-i18next'));
+    }
+    hasHook(componentPath) {
+        let found = false;
+        componentPath.traverse({
+            VariableDeclarator(path) {
+                if (path.node.init &&
+                    t.isCallExpression(path.node.init) &&
+                    t.isIdentifier(path.node.init.callee) &&
+                    path.node.init.callee.name === 'useTranslation') {
+                    found = true;
+                    path.stop();
+                }
+            }
+        });
+        return found;
+    }
+    createHook(_context) {
+        return [
+            t.variableDeclaration('const', [
+                t.variableDeclarator(t.objectPattern([
+                    t.objectProperty(t.identifier('t'), t.identifier('t'), false, true)
+                ]), t.callExpression(t.identifier('useTranslation'), []))
+            ])
+        ];
+    }
+    getTranslationFunctionName() {
+        return 't';
+    }
+    requiresAsyncComponent(_context) {
+        return false;
+    }
+    /**
+     * `{t("key", { user })}`, or with inline elements
+     * `<Trans i18nKey="key" t={t} values={{ user }} components={{ link: <Link href="/x" /> }} />`
+     * for the message "Hi {user}, read the <link>terms</link>" (named Trans
+     * components; placeholders are ICU arguments, rendered by i18next-icu).
+     */
+    createMessage(key, message, options = {}) {
+        const transName = options.transName ?? 'Trans';
+        if (!(0, jsx_message_1.hasTags)(message))
+            return { node: t.jsxExpressionContainer((0, jsx_message_1.createMessageTCall)(key, message)) };
+        const values = (0, jsx_message_1.placeholderValues)(message);
+        const components = message.entries.flatMap((e) => (e.kind === 'tag' ? [(0, jsx_message_1.transComponent)(e)] : []));
+        const attrs = [
+            t.jsxAttribute(t.jsxIdentifier('i18nKey'), t.stringLiteral(key)),
+            t.jsxAttribute(t.jsxIdentifier('t'), t.jsxExpressionContainer(t.identifier('t'))),
+        ];
+        if (values.length > 0)
+            attrs.push(t.jsxAttribute(t.jsxIdentifier('values'), t.jsxExpressionContainer(t.objectExpression(values))));
+        attrs.push(t.jsxAttribute(t.jsxIdentifier('components'), t.jsxExpressionContainer(t.objectExpression(components))));
+        const node = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(transName), attrs, true), null, [], true);
+        return { node, imports: [{ source: 'react-i18next', name: 'Trans', local: transName }] };
+    }
+}
+exports.ReactI18nextStrategy = ReactI18nextStrategy;

package/dist/injection/strategies/VanillaStrategy.d.ts

@@ -0,0 +1,11 @@
+import * as t from '@babel/types';
+import { InjectionStrategy, InjectionContext } from '../InjectionStrategy';
+export declare class VanillaStrategy implements InjectionStrategy {
+    id: string;
+    hasImport(ast: t.File): boolean;
+    createImport(): t.ImportDeclaration;
+    hasHook(_componentPath: any): boolean;
+    createHook(_context: InjectionContext): t.Statement[];
+    getTranslationFunctionName(): string;
+    requiresAsyncComponent(_context: InjectionContext): boolean;
+}

package/dist/injection/strategies/VanillaStrategy.js

@@ -0,0 +1,73 @@
+"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.VanillaStrategy = void 0;
+const t = __importStar(require("@babel/types"));
+class VanillaStrategy {
+    constructor() {
+        this.id = 'vanilla';
+    }
+    hasImport(ast) {
+        let found = false;
+        for (const node of ast.program.body) {
+            if (t.isImportDeclaration(node) && node.source.value === '@/i18n') {
+                const hasSpecifier = node.specifiers.some(spec => t.isImportSpecifier(spec) &&
+                    t.isIdentifier(spec.imported) &&
+                    spec.imported.name === 't');
+                if (hasSpecifier) {
+                    found = true;
+                    break;
+                }
+            }
+        }
+        return found;
+    }
+    createImport() {
+        return t.importDeclaration([t.importSpecifier(t.identifier('t'), t.identifier('t'))], t.stringLiteral('@/i18n'));
+    }
+    hasHook(_componentPath) {
+        return true; // No hook needed for vanilla JS
+    }
+    createHook(_context) {
+        return []; // No hook needed
+    }
+    getTranslationFunctionName() {
+        return 't';
+    }
+    requiresAsyncComponent(_context) {
+        return false;
+    }
+}
+exports.VanillaStrategy = VanillaStrategy;

package/dist/injection/strategies/VueI18nStrategy.d.ts

@@ -0,0 +1,11 @@
+import * as t from '@babel/types';
+import { InjectionStrategy, InjectionContext } from '../InjectionStrategy';
+export declare class VueI18nStrategy implements InjectionStrategy {
+    id: string;
+    hasImport(ast: t.File): boolean;
+    createImport(): t.ImportDeclaration;
+    hasHook(componentPath: any): boolean;
+    createHook(_context: InjectionContext): t.Statement[];
+    getTranslationFunctionName(): string;
+    requiresAsyncComponent(_context: InjectionContext): boolean;
+}

package/dist/injection/strategies/VueI18nStrategy.js

@@ -0,0 +1,84 @@
+"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.VueI18nStrategy = void 0;
+const t = __importStar(require("@babel/types"));
+class VueI18nStrategy {
+    constructor() {
+        this.id = 'vue-i18n';
+    }
+    hasImport(ast) {
+        for (const node of ast.program.body) {
+            if (t.isImportDeclaration(node) && node.source.value === 'vue-i18n') {
+                return true;
+            }
+        }
+        return false;
+    }
+    createImport() {
+        return t.importDeclaration([t.importSpecifier(t.identifier('useI18n'), t.identifier('useI18n'))], t.stringLiteral('vue-i18n'));
+    }
+    hasHook(componentPath) {
+        let found = false;
+        componentPath.traverse({
+            VariableDeclarator(path) {
+                if (path.node.init &&
+                    t.isCallExpression(path.node.init) &&
+                    t.isIdentifier(path.node.init.callee) &&
+                    path.node.init.callee.name === 'useI18n') {
+                    found = true;
+                    path.stop();
+                }
+            }
+        });
+        return found;
+    }
+    createHook(_context) {
+        return [
+            t.variableDeclaration('const', [
+                t.variableDeclarator(t.objectPattern([
+                    t.objectProperty(t.identifier('t'), t.identifier('t'), false, true)
+                ]), t.callExpression(t.identifier('useI18n'), []))
+            ])
+        ];
+    }
+    getTranslationFunctionName() {
+        return 't';
+    }
+    requiresAsyncComponent(_context) {
+        return false;
+    }
+}
+exports.VueI18nStrategy = VueI18nStrategy;

package/dist/local/formatter.d.ts

@@ -0,0 +1,26 @@
+export type FormatterName = 'prettier' | 'biome';
+export interface FormatResult {
+    tool: FormatterName;
+    /** Files handed to the formatter (relative to the project root). */
+    files: string[];
+    ok: boolean;
+    /** Why formatting was skipped or failed. */
+    message?: string;
+}
+declare const FORMATTERS: Array<{
+    name: FormatterName;
+    packages: string[];
+    args: (files: string[]) => string[];
+}>;
+/** The formatter the project declares in package.json (prettier first), or null. */
+export declare function detectFormatter(projectRoot: string): Promise<(typeof FORMATTERS)[number] | null>;
+/**
+ * Run the project's own prettier/biome on the files the engine changed, in
+ * the temp copy, using the binary from the project's node_modules (with the
+ * project's config, which was copied). Best effort: any problem is returned
+ * as a message and the run carries on with unformatted output.
+ */
+export declare function formatChangedFiles(projectDir: string, workDir: string, changedFiles: string[], opts?: {
+    timeoutMs?: number;
+}): Promise<FormatResult | null>;
+export {};

package/dist/local/formatter.js

@@ -0,0 +1,105 @@
+"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.detectFormatter = detectFormatter;
+exports.formatChangedFiles = formatChangedFiles;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+/** Files a JS formatter should touch; locale JSON and package.json are left as the engine wrote them. */
+const FORMATTABLE = /\.(?:[cm]?[jt]sx?|vue)$/;
+const FORMATTERS = [
+    { name: 'prettier', packages: ['prettier'], args: (files) => ['--write', ...files] },
+    { name: 'biome', packages: ['@biomejs/biome'], args: (files) => ['format', '--write', ...files] },
+];
+/** The formatter the project declares in package.json (prettier first), or null. */
+async function detectFormatter(projectRoot) {
+    try {
+        const pkg = JSON.parse(await (0, promises_1.readFile)(path.join(projectRoot, 'package.json'), 'utf8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        return FORMATTERS.find((f) => f.packages.some((p) => deps[p])) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Run the project's own prettier/biome on the files the engine changed, in
+ * the temp copy, using the binary from the project's node_modules (with the
+ * project's config, which was copied). Best effort: any problem is returned
+ * as a message and the run carries on with unformatted output.
+ */
+async function formatChangedFiles(projectDir, workDir, changedFiles, opts = {}) {
+    const formatter = await detectFormatter(workDir);
+    if (!formatter)
+        return null;
+    const files = changedFiles.filter((f) => FORMATTABLE.test(f));
+    if (files.length === 0)
+        return null;
+    const bin = path.join(projectDir, 'node_modules', '.bin', formatter.name);
+    if (!(await (0, promises_1.lstat)(bin).catch(() => null))) {
+        return {
+            tool: formatter.name,
+            files,
+            ok: false,
+            message: `${formatter.name} is in package.json but not installed, so changed files were not formatted. Run your package manager install, then ${formatter.name} on them.`,
+        };
+    }
+    // Let the formatter resolve its plugins/config packages from the project.
+    const link = path.join(workDir, 'node_modules');
+    const linked = !(await (0, promises_1.lstat)(link).catch(() => null));
+    if (linked)
+        await (0, promises_1.symlink)(path.join(projectDir, 'node_modules'), link, 'dir').catch(() => { });
+    try {
+        await execFileAsync(bin, formatter.args(files), {
+            cwd: workDir,
+            timeout: opts.timeoutMs ?? 60000,
+            maxBuffer: 16 * 1024 * 1024,
+            env: { ...process.env, NO_COLOR: '1' },
+        });
+        return { tool: formatter.name, files, ok: true };
+    }
+    catch (err) {
+        const e = err;
+        const detail = (e.stderr || e.message || String(err)).trim().split('\n')[0];
+        return { tool: formatter.name, files, ok: false, message: `${formatter.name} failed (${detail}); files were left unformatted.` };
+    }
+    finally {
+        if (linked)
+            await (0, promises_1.unlink)(link).catch(() => { });
+    }
+}

package/dist/local/git.d.ts

@@ -0,0 +1,23 @@
+/**
+ * True when `file` is a Babelize translate report: JSON whose first field is
+ * `"$schema": "https://babelize.co/schemas/translate-report.v…"`, wherever it
+ * was written (`--report <path>`). Identified by content, not by name.
+ */
+export declare function isBabelizeReportFile(file: string): Promise<boolean>;
+/** Whether `rel` (relative to `dir`) is git-ignored. */
+export declare function isGitIgnored(dir: string, rel: string): Promise<boolean>;
+export declare class GitError extends Error {
+    readonly code: 'not_a_repo' | 'git_missing' | 'dirty';
+    readonly dirtyFiles: string[];
+    constructor(message: string, code: 'not_a_repo' | 'git_missing' | 'dirty', dirtyFiles?: string[]);
+}
+/** Throws GitError('not_a_repo' | 'git_missing') unless `dir` is inside a git work tree. */
+export declare function assertGitRepo(dir: string): Promise<void>;
+/** Uncommitted changes under `dir` (tracked edits and untracked files), as porcelain lines. */
+export declare function getUncommittedChanges(dir: string): Promise<string[]>;
+/**
+ * Refuse to run on a dirty tree unless `force`: the result has to be reviewable
+ * as its own `git diff`, and a failed review has to be undoable with
+ * `git checkout . && git clean -fd` without losing the user's work.
+ */
+export declare function assertCleanTree(dir: string, force: boolean): Promise<string[]>;