@babelize/engine 0.0.0-stage → 0.1.2

package/dist/runtime/types.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Engine v2 runtime types (backend-facing).
+ *
+ * This file intentionally keeps the operational contract that the backend
+ * workers/controllers already rely on (stats/locales/injections/diffs), while
+ * allowing the v2 engine to add richer metrics needed for Target.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSX_TRANSLATABLE_ATTRS = exports.EXCLUDED_PATTERNS = exports.SUPPORTED_EXTENSIONS = void 0;
+// ============ Constants ============
+exports.SUPPORTED_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx', '.vue', '.html'];
+exports.EXCLUDED_PATTERNS = [
+    'node_modules',
+    '.git',
+    '.next',
+    'dist',
+    'build',
+    'coverage',
+    '__tests__',
+    'vendor',
+    'lib',
+    'libs',
+    '*.test.*',
+    '*.spec.*',
+    '*.d.ts',
+    '*.min.js',
+    '*.min.css',
+];
+exports.JSX_TRANSLATABLE_ATTRS = [
+    'title',
+    'placeholder',
+    'alt',
+    'aria-label',
+    'aria-description',
+    'label',
+    'description',
+];

package/dist/types.d.ts

@@ -0,0 +1,134 @@
+import type { z } from 'zod';
+import type { Framework } from '@babelize/types';
+export declare const ISO639_1_REGEX: RegExp;
+export interface BabelizeConfig {
+    /** Workspace path */
+    workspacePath: string;
+    /** Source locale (ISO 639-1) */
+    sourceLocale: string;
+    /** Target locales (ISO 639-1) */
+    targetLocales: string[];
+    /** Optional framework hint (otherwise auto-detected by extractor later) */
+    framework?: Framework;
+    /** If true, do not write files or open PRs */
+    dryRun?: boolean;
+    /** Project id (used for translation memory scoping) */
+    projectId?: string;
+    /** Optional path overrides */
+    sourceDir?: string;
+    localesDir?: string;
+    /** Glossary */
+    glossary?: GlossaryConfig;
+    /** Lockfile path */
+    lockfilePath?: string;
+}
+export type BabelizeConfigSchema = z.ZodType<BabelizeConfig>;
+export interface GlossaryConfig {
+    neverTranslate?: string[];
+    alwaysTranslateAs?: Array<{
+        term: string;
+        translations: Record<string, string>;
+    }>;
+}
+export type ExtractedStringContext = 'jsx-text' | 'jsx-attr' | 'string-literal' | 'template-literal' | 'hardcoded-date' | 'hardcoded-currency';
+export interface ExtractedString {
+    id: string;
+    text: string;
+    filePath: string;
+    line: number;
+    column: number;
+    context: ExtractedStringContext;
+}
+export interface TranslationUnit {
+    sourceText: string;
+    sourceLocale: string;
+    targetLocale: string;
+    /** Masked text sent to model (after glossary masking), if applicable */
+    maskedSourceText?: string;
+}
+export interface TranslationResult {
+    sourceText: string;
+    sourceLocale: string;
+    targetLocale: string;
+    translatedText: string;
+    /** "memory" | "hf" | "lockfile" */
+    provider: 'memory' | 'hf' | 'lockfile';
+    model?: string;
+}
+export interface BabelRunStats {
+    stringsExtracted: number;
+    stringsNeedingTranslation: number;
+    translationsFromMemory: number;
+    translationsFromLockfile: number;
+    translationsFromHF: number;
+}
+export interface BabelRunResult {
+    success: boolean;
+    error?: string;
+    stats: BabelRunStats;
+    warnings: any[];
+}
+export interface FileSystem {
+    readFile(filePath: string): Promise<string>;
+    writeFile(filePath: string, contents: string): Promise<void>;
+    exists(filePath: string): Promise<boolean>;
+    listDir(dirPath: string): Promise<string[]>;
+    mkdir(dirPath: string): Promise<void>;
+    deleteFile(filePath: string): Promise<void>;
+}
+export interface Cache {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    invalidate(prefix: string): Promise<void>;
+}
+export interface GitHubProvider {
+    openPR(params: {
+        title: string;
+        body: string;
+        head: string;
+        base: string;
+    }): Promise<string>;
+}
+export interface TranslatorClient {
+    health(): Promise<boolean>;
+    warmup(): Promise<boolean>;
+    translate(req: HFTranslateRequest): Promise<HFTranslateResponse>;
+}
+export interface BabelizeEngineDependencies {
+    fs: FileSystem;
+    translatorClient: TranslatorClient;
+    cache?: Cache;
+    github?: GitHubProvider;
+}
+export interface HFTranslateRequest {
+    entries: Array<{
+        key: string;
+        value: string;
+        context?: string;
+        extractionContext?: string;
+    }>;
+    sourceLang: string;
+    targetLang: string;
+    /** Optional brand voice guideline for BYOK LLM providers */
+    brandVoice?: string;
+    /** Target locale as ISO code (keeps regional variants such as pt-BR). */
+    targetLocale?: string;
+    /** Required terminology: source term → translation. */
+    glossary?: Array<{
+        term: string;
+        translation: string;
+    }>;
+    /** Per-key notes for a repair attempt. */
+    hints?: Record<string, string>;
+}
+export interface HFTranslateResponse {
+    translations: Array<{
+        key?: string;
+        value: string;
+    }>;
+    model?: string;
+    metadata?: any;
+}
+export type { Phase7Result } from './runtime/types';
+export { SUPPORTED_EXTENSIONS, EXCLUDED_PATTERNS, JSX_TRANSLATABLE_ATTRS, } from './runtime/types';

package/dist/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSX_TRANSLATABLE_ATTRS = exports.EXCLUDED_PATTERNS = exports.SUPPORTED_EXTENSIONS = exports.ISO639_1_REGEX = void 0;
+// ─────────────────────────────────────────────────────────────
+// Config
+// ─────────────────────────────────────────────────────────────
+exports.ISO639_1_REGEX = /^[a-z]{2}$/;
+// Re-export constants from runtime/types (single source of truth)
+var types_1 = require("./runtime/types");
+Object.defineProperty(exports, "SUPPORTED_EXTENSIONS", { enumerable: true, get: function () { return types_1.SUPPORTED_EXTENSIONS; } });
+Object.defineProperty(exports, "EXCLUDED_PATTERNS", { enumerable: true, get: function () { return types_1.EXCLUDED_PATTERNS; } });
+Object.defineProperty(exports, "JSX_TRANSLATABLE_ATTRS", { enumerable: true, get: function () { return types_1.JSX_TRANSLATABLE_ATTRS; } });

package/dist/utils/ast-helpers.d.ts

@@ -0,0 +1,57 @@
+import type { NodePath } from '@babel/traverse';
+import generate from '@babel/generator';
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+/**
+ * Engine v2 AST helpers.
+ *
+ * Copied from v1 to preserve parsing/transformation behavior while v2 is
+ * stabilized.
+ */
+export interface ParseOptions {
+    sourceType?: 'module' | 'script' | 'unambiguous';
+    isTypeScript?: boolean;
+    isJSX?: boolean;
+    filename?: string;
+}
+export declare function parseCode(code: string, options?: ParseOptions): t.File;
+export declare function generateCode(ast: t.File, originalCode?: string): string;
+/**
+ * With `retainLines`, statements the injector adds (which have no source
+ * location) are printed on the line of the preceding token, e.g.
+ * `function Page() {const t = useTranslations();`. Move each such statement
+ * that directly follows a `{` onto its own line, indented like the body.
+ */
+export declare function placeStatementsOnOwnLines(code: string, statements: string[]): string;
+export declare function isJSXText(node: t.Node): node is t.JSXText;
+export declare function isAlreadyTranslated(node: t.Node, path: NodePath): boolean;
+export declare function isNonTranslatableContext(path: NodePath): boolean;
+export declare function getComponentName(path: NodePath): string | null;
+export declare function isInsideComponent(path: NodePath): boolean;
+/**
+ * The block body of the component `path` is in — where the translation hook
+ * goes. Skips callbacks (a hook inside `.map(…)` breaks the rules of hooks);
+ * null when there's no component with a block body.
+ */
+export declare function findComponentBody(path: NodePath): NodePath | null;
+export declare function hasTranslationImport(ast: t.File): boolean;
+export declare function hasTranslationHook(functionPath: NodePath): boolean;
+export declare function createTranslationImport(): t.ImportDeclaration;
+export declare function createTranslationHook(): t.VariableDeclaration;
+export declare function createTCall(key: string): t.CallExpression;
+export declare function createJSXTCall(key: string): t.JSXExpressionContainer;
+export declare function extractJSXTextContent(node: t.JSXText): string;
+export declare function getParentContext(path: NodePath): {
+    parentContext: string;
+    siblingGroupId: string;
+} | null;
+export declare function extractExpressionContent(node: t.Node, variables?: string[]): string | null;
+export declare function extractConditionalContent(node: t.ConditionalExpression): {
+    consequent: string | null;
+    alternate: string | null;
+};
+/**
+ * Check if the file has a 'use client' directive
+ */
+export declare function hasUseClientDirective(ast: t.File): boolean;
+export { generate, t, traverse };