@babelize/engine 0.0.0-stage → 0.1.2

package/dist/modules/vue/migrate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Migrate legacy data-i18n attributes to $t() calls in Vue templates.
+ * Runs on raw text before parsing (malformed data-i18n won't parse).
+ *
+ * Converts:
+ * - data-i18n="key" → {{ $t('key') }} (for text content)
+ * - data-i18n-alt="key" → :alt="$t('key')" (for attributes)
+ * - data-i18n-title="key" → :title="$t('key')"
+ * - data-i18n-placeholder="key" → :placeholder="$t('key')"
+ *
+ * Reuses existing keys so translations survive the migration.
+ */
+export declare function migrateLegacyDataI18n(content: string): string;

package/dist/modules/vue/migrate.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateLegacyDataI18n = migrateLegacyDataI18n;
+/**
+ * Migrate legacy data-i18n attributes to $t() calls in Vue templates.
+ * Runs on raw text before parsing (malformed data-i18n won't parse).
+ *
+ * Converts:
+ * - data-i18n="key" → {{ $t('key') }} (for text content)
+ * - data-i18n-alt="key" → :alt="$t('key')" (for attributes)
+ * - data-i18n-title="key" → :title="$t('key')"
+ * - data-i18n-placeholder="key" → :placeholder="$t('key')"
+ *
+ * Reuses existing keys so translations survive the migration.
+ */
+function migrateLegacyDataI18n(content) {
+    // Only process if legacy attributes are present
+    if (!/data-i18n(?:-\w+)?=/.test(content))
+        return content;
+    let result = content;
+    // Migrate data-i18n="key" on elements with only text content
+    // This is a regex-based migration — safe because it only touches
+    // attribute patterns that the old engine wrote
+    result = result.replace(/<(\w+)([^>]*)\s+data-i18n="([^"]+)"([^>]*)>([^<]*)<\/\1>/g, (match, tag, before, key, after, text) => {
+        // If the element has only text content, replace with $t()
+        if (text.trim() && !/<\//.test(text)) {
+            return `<${tag}${before}${after}>{{ $t('${key}') }}</${tag}>`;
+        }
+        return match; // Leave complex content alone
+    });
+    // Migrate data-i18n-attr="key" → :attr="$t('key')"
+    const attrs = ['alt', 'title', 'placeholder', 'aria-label', 'aria-description'];
+    for (const attr of attrs) {
+        const regex = new RegExp(`data-i18n-${attr}="([^"]+)"`, 'g');
+        result = result.replace(regex, (match, key) => {
+            return `:${attr}="$t('${key}')"`;
+        });
+    }
+    return result;
+}

package/dist/modules/vue/script-inject.d.ts

@@ -0,0 +1,16 @@
+import type { InjectionLocation } from '../../runtime/types';
+export interface VueScriptInjectOptions {
+    scriptContent: string;
+    filePath: string;
+    templateOffset: number;
+    isSetup: boolean;
+    hasTs: boolean;
+    hasI18nImport: boolean;
+    hasUseI18n: boolean;
+}
+export declare function injectVueScript(options: VueScriptInjectOptions): {
+    content: string;
+    injections: InjectionLocation[];
+    importAdded: boolean;
+    hookAdded: boolean;
+};

package/dist/modules/vue/script-inject.js

@@ -0,0 +1,115 @@
+"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.injectVueScript = injectVueScript;
+const parser = __importStar(require("@babel/parser"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const t = __importStar(require("@babel/types"));
+function injectVueScript(options) {
+    const { scriptContent, isSetup, hasTs, hasI18nImport, hasUseI18n, } = options;
+    if (!isSetup) {
+        return {
+            content: scriptContent,
+            injections: [],
+            importAdded: false,
+            hookAdded: false,
+        };
+    }
+    const plugins = ['jsx'];
+    if (hasTs)
+        plugins.push('typescript');
+    plugins.push('decorators-legacy', 'classProperties', 'optionalChaining', 'objectRestSpread');
+    const ast = parser.parse(scriptContent, {
+        sourceType: 'module',
+        plugins,
+        errorRecovery: true,
+    });
+    let importAdded = false;
+    let hookAdded = false;
+    const injections = [];
+    let lastImportIndex = -1;
+    for (let i = 0; i < ast.program.body.length; i++) {
+        if (t.isImportDeclaration(ast.program.body[i])) {
+            lastImportIndex = i;
+        }
+    }
+    const needsI18nImport = !hasI18nImport && !hasUseI18n;
+    const needsHook = !hasUseI18n;
+    if (needsI18nImport) {
+        const importDecl = t.importDeclaration([t.importSpecifier(t.identifier('useI18n'), t.identifier('useI18n'))], t.stringLiteral('vue-i18n'));
+        if (lastImportIndex >= 0) {
+            ast.program.body.splice(lastImportIndex + 1, 0, importDecl);
+        }
+        else {
+            ast.program.body.unshift(importDecl);
+        }
+        importAdded = true;
+    }
+    if (needsHook) {
+        const hookDecl = t.variableDeclaration('const', [
+            t.variableDeclarator(t.objectPattern([
+                t.objectProperty(t.identifier('t'), t.identifier('t'), false, true),
+            ]), t.callExpression(t.identifier('useI18n'), [])),
+        ]);
+        let insertIndex;
+        if (needsI18nImport) {
+            insertIndex = lastImportIndex >= 0 ? lastImportIndex + 2 : 1;
+        }
+        else {
+            insertIndex = lastImportIndex >= 0 ? lastImportIndex + 1 : 0;
+        }
+        ast.program.body.splice(insertIndex, 0, hookDecl);
+        hookAdded = true;
+    }
+    const result = (0, generator_1.default)(ast, {
+        retainLines: true,
+        retainFunctionParens: true,
+        comments: true,
+        compact: false,
+    });
+    let code = result.code;
+    code = code.replace(/;import /g, ';\nimport ');
+    code = code.replace(/(^import .+;\n)([^i\n])/gm, '$1\n$2');
+    code = code.replace(/\n{3,}/g, '\n\n');
+    return {
+        content: code,
+        injections,
+        importAdded,
+        hookAdded,
+    };
+}

package/dist/modules/vue/sfc.d.ts

@@ -0,0 +1,11 @@
+import type { SFCDescriptor } from '@vue/compiler-sfc';
+export interface ParsedSfc {
+    descriptor: SFCDescriptor;
+    /** Absolute offset of <template> content start in the file */
+    templateOffset: number;
+    /** Absolute offset of <script> or <script setup> content start */
+    scriptOffset: number;
+    /** The script block chosen for injection (setup > regular) */
+    scriptBlock: 'setup' | 'regular' | null;
+}
+export declare function parseSfc(content: string): ParsedSfc | null;

package/dist/modules/vue/sfc.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSfc = parseSfc;
+const compiler_sfc_1 = require("@vue/compiler-sfc");
+function parseSfc(content) {
+    const result = (0, compiler_sfc_1.parse)(content, { pad: 'line' });
+    if (result.errors.length > 0) {
+        return null;
+    }
+    const { descriptor } = result;
+    let templateOffset = 0;
+    if (descriptor.template && typeof descriptor.template.loc?.start?.offset === 'number') {
+        const src = descriptor.template.loc.source;
+        if (src.startsWith('<template>')) {
+            const tagOpenLen = '<template>'.length;
+            const spaceAfterOpen = (src.match(/^<template>\s*\n?/) || [''])[0].length - tagOpenLen;
+            templateOffset = descriptor.template.loc.start.offset + tagOpenLen + spaceAfterOpen;
+        }
+        else {
+            templateOffset = descriptor.template.loc.start.offset;
+        }
+    }
+    let scriptOffset = 0;
+    let scriptBlock = null;
+    if (descriptor.scriptSetup) {
+        scriptBlock = 'setup';
+        if (typeof descriptor.scriptSetup.loc?.start?.offset === 'number') {
+            const src = descriptor.scriptSetup.loc.source;
+            const langMatch = src.match(/<script[^>]*>/);
+            if (langMatch) {
+                scriptOffset = descriptor.scriptSetup.loc.start.offset + langMatch[0].length;
+            }
+        }
+    }
+    else if (descriptor.script) {
+        scriptBlock = 'regular';
+        if (typeof descriptor.script.loc?.start?.offset === 'number') {
+            const src = descriptor.script.loc.source;
+            const langMatch = src.match(/<script[^>]*>/);
+            if (langMatch) {
+                scriptOffset = descriptor.script.loc.start.offset + langMatch[0].length;
+            }
+        }
+    }
+    return {
+        descriptor,
+        templateOffset,
+        scriptOffset,
+        scriptBlock,
+    };
+}

package/dist/modules/vue/template-rewrite.d.ts

@@ -0,0 +1,25 @@
+import type { TemplateUnit } from './template-scan';
+export interface RewriteInjections {
+    file: string;
+    line: number;
+    column: number;
+    original: string;
+    replacement: string;
+    key: string;
+    confidence: number;
+}
+export interface RewriteResult {
+    content: string;
+    injections: RewriteInjections[];
+    parseFailed: boolean;
+}
+/**
+ * Rewrite Vue template text using MagicString for offset-based edits.
+ *
+ * Uses one MagicString over the whole file with absolute offsets — no splicing,
+ * no drift, no String.replace hazard. The <template> tag is never rebuilt.
+ *
+ * Post-condition: re-parses the emitted file with @vue/compiler-dom.
+ * On any parse error, discards every edit and returns the original content.
+ */
+export declare function rewriteTemplate(fileContent: string, templateContent: string, templateOffset: number, units: TemplateUnit[], keyMapping: Map<string, string>, filePath: string): RewriteResult;

package/dist/modules/vue/template-rewrite.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewriteTemplate = rewriteTemplate;
+const magic_string_1 = __importDefault(require("magic-string"));
+const compiler_dom_1 = require("@vue/compiler-dom");
+/**
+ * Rewrite Vue template text using MagicString for offset-based edits.
+ *
+ * Uses one MagicString over the whole file with absolute offsets — no splicing,
+ * no drift, no String.replace hazard. The <template> tag is never rebuilt.
+ *
+ * Post-condition: re-parses the emitted file with @vue/compiler-dom.
+ * On any parse error, discards every edit and returns the original content.
+ */
+function rewriteTemplate(fileContent, templateContent, templateOffset, units, keyMapping, filePath) {
+    if (units.length === 0) {
+        return { content: fileContent, injections: [], parseFailed: false };
+    }
+    const s = new magic_string_1.default(fileContent);
+    const injections = [];
+    const sorted = [...units].sort((a, b) => b.offset - a.offset);
+    for (const unit of sorted) {
+        const key = keyMapping.get(unit.id);
+        if (!key)
+            continue;
+        const line = fileContent.substring(0, unit.offset).split('\n').length;
+        const lastNewline = fileContent.lastIndexOf('\n', unit.offset);
+        const column = unit.offset - (lastNewline === -1 ? 0 : lastNewline + 1);
+        if (unit.type === 'text') {
+            const replacement = `{{ $t('${key}') }}`;
+            s.overwrite(unit.offset, unit.end, replacement);
+            injections.push({
+                file: filePath,
+                line,
+                column,
+                original: unit.text,
+                replacement,
+                key,
+                confidence: unit.confidence,
+            });
+        }
+        else if (unit.type === 'attr') {
+            let replacement;
+            if (unit.attrBoundLiteral) {
+                replacement = `:${unit.attrName}="$t('${key}')"`;
+                s.overwrite(unit.offset, unit.end, replacement);
+            }
+            else {
+                const insertPos = unit.end;
+                const dataAttr = ` data-i18n-${unit.attrName}="${key}"`;
+                s.appendLeft(insertPos, dataAttr);
+                replacement = dataAttr;
+            }
+            injections.push({
+                file: filePath,
+                line,
+                column,
+                original: unit.text,
+                replacement,
+                key,
+                confidence: unit.confidence,
+            });
+        }
+    }
+    const rewritten = s.toString();
+    try {
+        (0, compiler_dom_1.parse)(rewritten);
+    }
+    catch {
+        return { content: fileContent, injections: [], parseFailed: true };
+    }
+    return { content: rewritten, injections, parseFailed: false };
+}

package/dist/modules/vue/template-scan.d.ts

@@ -0,0 +1,29 @@
+export interface TemplateUnit {
+    type: 'text' | 'attr' | 'v-text';
+    /** Original text content */
+    text: string;
+    /** File-absolute line number */
+    line: number;
+    /** Character offset from file start */
+    offset: number;
+    /** End offset (offset + length) */
+    end: number;
+    /** Length of the original text in the source */
+    length: number;
+    /** The extraction ID: ${filePath}:${line}:${hash(text)} */
+    id: string;
+    /** Confidence score for this extraction */
+    confidence: number;
+    /** If attr: the attribute name */
+    attrName?: string;
+    /** If attr: the tag name */
+    tagName?: string;
+    /** If bound attr (:attr="literal"): whether the value is a bound literal string */
+    attrBoundLiteral?: boolean;
+}
+export interface ScanResult {
+    units: TemplateUnit[];
+    /** Files that were skipped (v-pre, already translated, etc.) */
+    skippedElements: string[];
+}
+export declare function scanTemplate(templateContent: string, filePath: string, templateOffset: number, hashFn: (text: string) => string): ScanResult;

package/dist/modules/vue/template-scan.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanTemplate = scanTemplate;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const TRANSLATABLE_ATTRS = new Set([
+    'alt',
+    'title',
+    'placeholder',
+    'aria-label',
+    'aria-description',
+    'label',
+    'text',
+]);
+const ATTR_DENY_LIST = new Set([
+    'class',
+    'style',
+    'id',
+    'key',
+    'ref',
+    'src',
+    'href',
+    'to',
+    'target',
+    'rel',
+    'type',
+    'width',
+    'height',
+    'rows',
+    'cols',
+    'data-testid',
+    'role',
+    'as',
+    'name',
+    'value',
+    'disabled',
+    'required',
+    'checked',
+    'multiple',
+    'hidden',
+    'tabindex',
+    'autofocus',
+    'accesskey',
+    'contenteditable',
+    'draggable',
+    'translate',
+    'dir',
+    'lang',
+    'slot',
+    'is',
+]);
+function hasVPre(node) {
+    return node.props.some((p) => p.type === compiler_dom_1.NodeTypes.ATTRIBUTE && p.name === 'v-pre');
+}
+function hasVHtml(node) {
+    return node.props.some((p) => p.type === compiler_dom_1.NodeTypes.DIRECTIVE && p.name === 'html');
+}
+function isInsideI18nT(node, ancestors) {
+    return ancestors.some((a) => a.tag === 'i18n-t' && a.tagType === compiler_dom_1.ElementTypes.ELEMENT);
+}
+function hasDollarTBinding(node) {
+    return node.props.some((p) => p.type === compiler_dom_1.NodeTypes.ATTRIBUTE &&
+        p.value?.content.includes('$t('));
+}
+function locToOffset(loc, templateOffset) {
+    return templateOffset + loc.start.offset;
+}
+function locToLine(loc) {
+    return loc.start.line;
+}
+function isTranslatableAttr(name) {
+    if (ATTR_DENY_LIST.has(name))
+        return false;
+    if (TRANSLATABLE_ATTRS.has(name))
+        return true;
+    if (/^(aria-|data-)/.test(name))
+        return false;
+    return true;
+}
+function extractBoundLiteralString(dir) {
+    const exp = dir.exp;
+    if (!exp)
+        return null;
+    if (exp.type !== compiler_dom_1.NodeTypes.SIMPLE_EXPRESSION)
+        return null;
+    const raw = exp.content.trim();
+    // Matches: 'string' or "string"
+    const match = raw.match(/^['"](.*)['"]$/);
+    if (match)
+        return match[1];
+    return null;
+}
+function extractTextContent(node) {
+    if (node.type === compiler_dom_1.NodeTypes.TEXT) {
+        return node.content;
+    }
+    return null;
+}
+function isStaticAttribute(prop) {
+    return prop.type === compiler_dom_1.NodeTypes.ATTRIBUTE;
+}
+function processElement(node, templateContent, templateOffset, filePath, hashFn, ancestors, skippedElements) {
+    const units = [];
+    if (hasVPre(node)) {
+        skippedElements.push(`${node.tag}:v-pre`);
+        return units;
+    }
+    if (hasVHtml(node)) {
+        skippedElements.push(`${node.tag}:v-html`);
+        return units;
+    }
+    if (isInsideI18nT(node, ancestors)) {
+        skippedElements.push(`${node.tag}:inside-i18n-t`);
+        return units;
+    }
+    if (hasDollarTBinding(node)) {
+        skippedElements.push(`${node.tag}:already-translated`);
+        return units;
+    }
+    // Process text children — merge adjacent text nodes and interpolations
+    const textRuns = buildTextRuns(node);
+    for (const run of textRuns) {
+        const runText = run.map((n) => extractTextContent(n)).join('');
+        if (!runText.trim())
+            continue;
+        const firstNode = run[0];
+        const lastNode = run[run.length - 1];
+        const offset = locToOffset(firstNode.loc, templateOffset);
+        const length = locToOffset(lastNode.loc, templateOffset) +
+            lastNode.loc.source.length -
+            offset;
+        const line = locToLine(firstNode.loc);
+        const id = `${filePath}:${line}:${hashFn(runText)}`;
+        units.push({
+            type: 'text',
+            text: runText,
+            line,
+            offset,
+            end: offset + length,
+            length,
+            id,
+            confidence: 1.0,
+        });
+    }
+    // Process attributes
+    for (const prop of node.props) {
+        if (isStaticAttribute(prop)) {
+            const name = prop.name.toLowerCase();
+            if (!isTranslatableAttr(name))
+                continue;
+            if (!prop.value)
+                continue;
+            const text = prop.value.content;
+            if (!text.trim())
+                continue;
+            const offset = locToOffset(prop.value.loc, templateOffset);
+            const length = prop.value.loc.source.length;
+            const line = locToLine(prop.value.loc);
+            const id = `${filePath}:${line}:${hashFn(text)}`;
+            units.push({
+                type: 'attr',
+                text,
+                line,
+                offset,
+                end: offset + length,
+                length,
+                id,
+                confidence: 1.0,
+                attrName: prop.name,
+                tagName: node.tag,
+                attrBoundLiteral: false,
+            });
+        }
+        else if (prop.type === compiler_dom_1.NodeTypes.DIRECTIVE &&
+            prop.name === 'bind' &&
+            prop.arg &&
+            prop.arg.type === compiler_dom_1.NodeTypes.SIMPLE_EXPRESSION &&
+            prop.arg.isStatic &&
+            !prop.modifiers.length) {
+            const attrName = prop.arg.content;
+            if (!isTranslatableAttr(attrName))
+                continue;
+            const literal = extractBoundLiteralString(prop);
+            if (literal === null)
+                continue;
+            const offset = locToOffset(prop.loc, templateOffset);
+            const length = prop.loc.source.length;
+            const line = locToLine(prop.loc);
+            const id = `${filePath}:${line}:${hashFn(literal)}`;
+            units.push({
+                type: 'attr',
+                text: literal,
+                line,
+                offset,
+                end: offset + length,
+                length,
+                id,
+                confidence: 1.0,
+                attrName,
+                tagName: node.tag,
+                attrBoundLiteral: true,
+            });
+        }
+        else if (prop.type === compiler_dom_1.NodeTypes.DIRECTIVE &&
+            prop.name === 'text') {
+            // v-text is dynamic — skip
+            skippedElements.push(`${node.tag}:v-text`);
+        }
+    }
+    return units;
+}
+function buildTextRuns(node) {
+    const runs = [];
+    let currentRun = [];
+    for (const child of node.children) {
+        if (child.type === compiler_dom_1.NodeTypes.TEXT ||
+            child.type === compiler_dom_1.NodeTypes.INTERPOLATION ||
+            child.type === compiler_dom_1.NodeTypes.COMPOUND_EXPRESSION) {
+            currentRun.push(child);
+        }
+        else {
+            if (currentRun.length > 0) {
+                runs.push(currentRun);
+                currentRun = [];
+            }
+        }
+    }
+    if (currentRun.length > 0) {
+        runs.push(currentRun);
+    }
+    return runs;
+}
+function walkNode(node, templateContent, templateOffset, filePath, hashFn, units, skippedElements, ancestors) {
+    if (node.type === compiler_dom_1.NodeTypes.ELEMENT) {
+        const element = node;
+        ancestors.push(element);
+        const elementUnits = processElement(element, templateContent, templateOffset, filePath, hashFn, ancestors, skippedElements);
+        units.push(...elementUnits);
+        for (const child of element.children) {
+            walkNode(child, templateContent, templateOffset, filePath, hashFn, units, skippedElements, ancestors);
+        }
+        ancestors.pop();
+    }
+    else if (node.type === compiler_dom_1.NodeTypes.IF) {
+        for (const branch of node.branches) {
+            for (const child of branch.children) {
+                walkNode(child, templateContent, templateOffset, filePath, hashFn, units, skippedElements, ancestors);
+            }
+        }
+    }
+    else if (node.type === compiler_dom_1.NodeTypes.FOR) {
+        for (const child of node.children) {
+            walkNode(child, templateContent, templateOffset, filePath, hashFn, units, skippedElements, ancestors);
+        }
+    }
+}
+function scanTemplate(templateContent, filePath, templateOffset, hashFn) {
+    const units = [];
+    const skippedElements = [];
+    const root = (0, compiler_dom_1.parse)(templateContent);
+    for (const child of root.children) {
+        walkNode(child, templateContent, templateOffset, filePath, hashFn, units, skippedElements, []);
+    }
+    return { units, skippedElements };
+}

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

@@ -0,0 +1 @@
+export { validateWorkspace } from './validate';

package/dist/modules/workspace/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWorkspace = void 0;
+var validate_1 = require("./validate");
+Object.defineProperty(exports, "validateWorkspace", { enumerable: true, get: function () { return validate_1.validateWorkspace; } });

package/dist/modules/workspace/validate.d.ts

@@ -0,0 +1,13 @@
+import type { EngineConfigV2, Phase0Result } from '../../runtime/types';
+interface PackageJson {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    [key: string]: unknown;
+}
+export declare function validateWorkspace(config: EngineConfigV2): Promise<Phase0Result>;
+export declare function checkI18nDependencies(packageJson: PackageJson, framework?: string): Promise<{
+    hasReactI18next: boolean;
+    hasI18next: boolean;
+    recommendation: string | null;
+}>;
+export {};