@babelize/engine 0.1.3 → 0.2.0

package/dist/modules/sync-detector/sync-detector.js

@@ -40,7 +40,9 @@ const logger_1 = require("../../utils/logger");
 const extract_1 = require("../extractor/extract");
 const lockfile_manager_1 = require("../lockfile/lockfile-manager");
 const types_1 = require("../../runtime/types");
+const types_2 = require("@babelize/types");
 const extraction_options_1 = require("../../utils/extraction-options");
+const validate_1 = require("../workspace/validate");
 /**
  * Extraction options the project's engine runs use (sentence grouping, ICU
  * plurals, data-literal rules), so a sync check compares like with like and
@@ -55,7 +57,8 @@ async function runExtractionOptions(workspacePath, options) {
         packageJson = undefined;
     }
     const deps = { ...packageJson?.dependencies, ...packageJson?.devDependencies };
-    const framework = options.framework ?? (deps.next ? 'nextjs' : deps.react ? 'react' : deps.vue ? 'vue' : 'unknown');
+    const framework = options.framework ??
+        (deps.next ? 'nextjs' : (0, validate_1.isReactNativePackage)(packageJson) ? 'react-native' : deps.react ? 'react' : deps.vue ? 'vue' : 'unknown');
     const workspace = {
         path: workspacePath, framework, sourceDirs: ['.'], hasLocalesDir: false, existingLocales: [], publicDir: 'public',
         localeFormat: 'json', packageJson,
@@ -112,10 +115,13 @@ const SYNC_IGNORE_PATTERNS = [
  * Check if a file path matches supported source extensions
  * and is not excluded by ignore patterns.
  */
-function isSourceFile(filePath) {
+function isSourceFile(filePath, frameworkExcludes = []) {
     const ext = path.extname(filePath).toLowerCase();
     if (!types_1.SUPPORTED_EXTENSIONS.includes(ext))
         return false;
+    // What runs never scan for this framework (React Native's ios/android projects, scripts/).
+    if ((0, types_1.isExcludedPath)(filePath, frameworkExcludes))
+        return false;
     for (const pattern of SYNC_IGNORE_PATTERNS) {
         if (pattern.test(filePath))
             return false;
@@ -140,9 +146,11 @@ async function detectSyncIssues(projectId, workspacePath, changedFiles, commitSh
     const filesChecked = [];
     const filesSkipped = [];
     // 1. Filter changed files to only source files
+    const extractOptions = await runExtractionOptions(workspacePath, options);
+    const frameworkExcludes = types_2.FRAMEWORK_CONFIGS[extractOptions.framework]?.excludedPatterns ?? [];
     const sourceFiles = [];
     for (const file of changedFiles) {
-        if (isSourceFile(file)) {
+        if (isSourceFile(file, frameworkExcludes)) {
             sourceFiles.push(file);
         }
         else {
@@ -168,7 +176,6 @@ async function detectSyncIssues(projectId, workspacePath, changedFiles, commitSh
     }
     // 2. Extract strings from changed source files, the way runs do
     const extractedStrings = {};
-    const extractOptions = await runExtractionOptions(workspacePath, options);
     for (const relativePath of sourceFiles) {
         const absolutePath = path.join(workspacePath, relativePath);
         try {

package/dist/modules/translator/line-breaks.d.ts

@@ -0,0 +1,8 @@
+import type { TranslationProvider } from '../../providers/types';
+/**
+ * A plain-text translator (NLLB) works sentence by sentence and drops line
+ * breaks: "…is running.\n\nDetails: {x}" came back as one line. Messages with
+ * line breaks go line by line, and are put back together with the source's
+ * breaks before the usual checks.
+ */
+export declare function translateLineByLine(provider: TranslationProvider): TranslationProvider;

package/dist/modules/translator/line-breaks.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateLineByLine = translateLineByLine;
+const BREAK = /([ \t]*\r?\n[\s]*)/;
+/** The translator service's batch limit (apps/translator `max_batch_size`). */
+const MAX_BATCH = 50;
+/**
+ * A plain-text translator (NLLB) works sentence by sentence and drops line
+ * breaks: "…is running.\n\nDetails: {x}" came back as one line. Messages with
+ * line breaks go line by line, and are put back together with the source's
+ * breaks before the usual checks.
+ */
+function translateLineByLine(provider) {
+    return {
+        pseudo: provider.pseudo,
+        plainText: provider.plainText,
+        async translateBatch(request, options) {
+            const split = new Map();
+            const entries = [];
+            for (const entry of request.entries) {
+                const parts = entry.value.split(BREAK);
+                if (parts.length === 1) {
+                    entries.push(entry);
+                    continue;
+                }
+                split.set(entry.key, parts);
+                // Odd indexes are the breaks; empty lines have nothing to translate.
+                parts.forEach((part, i) => {
+                    if (i % 2 === 0 && part.trim())
+                        entries.push({ ...entry, key: `${entry.key}#line${i}`, value: part });
+                });
+            }
+            if (split.size === 0)
+                return provider.translateBatch(request, options);
+            // Lines add entries: keep each request within the translator's batch limit.
+            const results = new Map();
+            for (let i = 0; i < entries.length; i += MAX_BATCH) {
+                const part = await provider.translateBatch({ ...request, entries: entries.slice(i, i + MAX_BATCH) }, options);
+                for (const r of part)
+                    results.set(r.key, r);
+            }
+            return request.entries.map((entry) => {
+                const parts = split.get(entry.key);
+                if (!parts)
+                    return results.get(entry.key) ?? { key: entry.key, status: 'failed', reason: 'missing_from_response', retryable: true };
+                let value = '';
+                for (let i = 0; i < parts.length; i++) {
+                    if (i % 2 === 1 || !parts[i].trim()) {
+                        value += parts[i];
+                        continue;
+                    }
+                    const line = results.get(`${entry.key}#line${i}`);
+                    if (!line)
+                        return { key: entry.key, status: 'failed', reason: 'missing_from_response', retryable: true };
+                    if (line.status !== 'ok')
+                        return { ...line, key: entry.key };
+                    value += line.value;
+                }
+                return { key: entry.key, status: 'ok', value };
+            });
+        },
+    };
+}

package/dist/modules/translator/translate.js

@@ -9,6 +9,7 @@ const untranslated_1 = require("../../utils/untranslated");
 const logger_1 = require("../../utils/logger");
 const translation_quality_1 = require("../../utils/translation-quality");
 const file_utils_1 = require("../../utils/file-utils");
+const line_breaks_1 = require("./line-breaks");
 const placeholder_protection_1 = require("../../utils/placeholder-protection");
 const icu_message_1 = require("../../utils/icu-message");
 const keygen_1 = require("../keygen");
@@ -549,6 +550,8 @@ async function translateEntries(entries, sourceLang, targetLang, projectId, onPr
     // service translates plain text only: ICU messages go branch by branch
     // (./icu-branches), and mixed-script text fails up front.
     const isLlm = !!byokConfig || (!!providers.translator && !providers.translator.plainText);
+    // A plain-text translator drops line breaks: it gets one line at a time.
+    const sender = isLlm ? translator : (0, line_breaks_1.translateLineByLine)(translator);
     // Scripts FLORES-200 lacks (sr-Latn, uz-Cyrl) only work with an LLM.
     const nllbTarget = !targetLocale || !(0, language_codes_1.isSupported)(targetLocale) || (0, language_codes_1.isNllbSupported)(targetLocale);
     if (uncachedEntries.length > 0) {
@@ -679,7 +682,7 @@ async function translateEntries(entries, sourceLang, targetLang, projectId, onPr
                     .filter((t) => batch.some((b) => b.icu && (0, glossary_1.sourceHasTerm)(b.value, t)))
                     .map((t) => ({ term: t, translation: t })),
             ];
-            const keyResults = await translator.translateBatch({
+            const keyResults = await sender.translateBatch({
                 entries: batch.map((b) => ({
                     key: b.key,
                     value: b.sendText,
@@ -800,7 +803,7 @@ async function translateEntries(entries, sourceLang, targetLang, projectId, onPr
         await runBatches(chunk(prepared.filter((b) => !viaBranches.has(b.key)), BATCH_SIZE), isLlm ? firstPassHint : undefined);
         if (viaBranches.size > 0) {
             const branchEntries = prepared.filter((b) => viaBranches.has(b.key));
-            for (const [key, o] of await translateByBranches(branchEntries, translator))
+            for (const [key, o] of await translateByBranches(branchEntries, sender))
                 outcomes.set(key, o);
             // A count whose plural forms couldn't be built is translated as the
             // plain message it is (as before target-side plurals), and says so.

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

@@ -1,10 +1,22 @@
-import type { EngineConfigV2, Phase0Result } from '../../runtime/types';
+import type { EngineConfigV2, Phase0Result, WorkspaceInfo } from '../../runtime/types';
 interface PackageJson {
     dependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;
     [key: string]: unknown;
 }
 export declare function validateWorkspace(config: EngineConfigV2): Promise<Phase0Result>;
+/** Expo (Router or classic) or bare React Native. */
+export declare function isReactNativePackage(packageJson: PackageJson | null | undefined): boolean;
+/**
+ * The app inside a monorepo: the first workspace package (package.json
+ * `workspaces`), or else the first top-level folder, whose package.json is
+ * a framework Babelize supports. `dir` is relative to the repo root.
+ */
+export declare function findWorkspaceApp(workspacePath: string, rootPackageJson: PackageJson | null | undefined): Promise<{
+    dir: string;
+    packageJson: PackageJson;
+    framework: WorkspaceInfo['framework'];
+} | null>;
 export declare function checkI18nDependencies(packageJson: PackageJson, framework?: string): Promise<{
     hasReactI18next: boolean;
     hasI18next: boolean;

package/dist/modules/workspace/validate.js

@@ -37,6 +37,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateWorkspace = validateWorkspace;
+exports.isReactNativePackage = isReactNativePackage;
+exports.findWorkspaceApp = findWorkspaceApp;
 exports.checkI18nDependencies = checkI18nDependencies;
 const path = __importStar(require("path"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
@@ -70,7 +72,7 @@ async function detectDjangoRoot(workspacePath, rootJsFramework) {
     }
     return null;
 }
-const SUPPORTED_LIST = 'React, Next.js, Vue, Django and plain HTML/CSS/JS';
+const SUPPORTED_LIST = stack_1.SUPPORTED_SUMMARY;
 /** The clearest "not supported" message for a workspace we couldn't classify. */
 async function unsupportedMessage(workspacePath, fallback) {
     try {
@@ -137,44 +139,21 @@ async function validateWorkspace(config) {
     else if (framework === 'unknown' && packageJson) {
         framework = detectFramework(packageJson);
     }
-    if (framework === 'unknown' && !isStatic) {
-        const workspacePatterns = getWorkspacePatterns(packageJson);
-        if (workspacePatterns.length > 0) {
-            const matchedDirs = await (0, fast_glob_1.default)(workspacePatterns, { cwd: workspacePath, onlyDirectories: true, deep: 3, absolute: true });
-            for (const dir of matchedDirs) {
-                const subPkgPath = path.join(dir, 'package.json');
-                const subPkg = await (0, file_utils_1.readJsonFile)(subPkgPath);
-                if (subPkg) {
-                    const subFramework = detectFramework(subPkg);
-                    if (subFramework !== 'unknown') {
-                        framework = subFramework;
-                        packageJson = subPkg;
-                        logger_1.engineLogger.info('Framework detected in workspace', { workspaceDir: path.relative(workspacePath, dir), framework });
-                        break;
-                    }
-                }
-            }
-        }
-        if (framework === 'unknown' && !isStatic) {
-            const entries = await (0, file_utils_1.readDir)(workspacePath);
-            for (const entry of entries) {
-                if (entry.startsWith('.'))
-                    continue;
-                const subDirPath = path.join(workspacePath, entry);
-                if (await (0, file_utils_1.isDirectory)(subDirPath)) {
-                    const subPkgPath = path.join(subDirPath, 'package.json');
-                    const subPkg = await (0, file_utils_1.readJsonFile)(subPkgPath);
-                    if (subPkg) {
-                        const subFramework = detectFramework(subPkg);
-                        if (subFramework !== 'unknown') {
-                            framework = subFramework;
-                            packageJson = subPkg;
-                            logger_1.engineLogger.info('Framework detected in subdirectory', { subDir: entry, framework });
-                            break;
-                        }
-                    }
-                }
-            }
+    // A monorepo: the app is a workspace package (apps/mobile) or a top-level
+    // folder. Everything app-specific — sources, locales, the i18n config, the
+    // package.json that gets the dependencies — lives in that folder.
+    // Also with an explicit framework (the CLI and the dashboard pass the one
+    // they detected): the root package.json isn't the app, so find the package
+    // that is, or every path below would point at the repo root.
+    let appDir = '.';
+    const rootIsApp = !!packageJson && detectFramework(packageJson) !== 'unknown';
+    if (!isStatic && framework !== 'django' && !rootIsApp) {
+        const app = await findWorkspaceApp(workspacePath, packageJson);
+        if (app && (framework === 'unknown' || app.framework === framework)) {
+            framework = app.framework;
+            packageJson = app.packageJson;
+            appDir = app.dir;
+            logger_1.engineLogger.info('Framework detected in workspace', { workspaceDir: app.dir, framework });
         }
     }
     if (!types_1.SUPPORTED_FRAMEWORKS.includes(framework)) {
@@ -186,14 +165,38 @@ async function validateWorkspace(config) {
         if (stack?.unsupported)
             throw new Error(stack.message);
     }
-    // Django: the whole project is scanned (templates/ and apps live anywhere).
-    const sourceDirs = framework === 'django' ? ['.'] : await findSourceDirectories(workspacePath);
+    // Django and React Native scan the whole project (templates/ and apps live
+    // anywhere; RN keeps App.tsx at the root next to screens/, navigation/,
+    // hooks/); their excludedPatterns skip virtualenvs and native projects.
+    const sourceDirs = types_1.FRAMEWORK_CONFIGS[framework]?.scanRoot
+        ? [appDir]
+        : (await findSourceDirectories(path.join(workspacePath, appDir))).map((d) => path.join(appDir, d));
     if (sourceDirs.length === 0) {
-        logger_1.engineLogger.info('No standard source directories found, defaulting to root');
-        sourceDirs.push('.');
+        logger_1.engineLogger.info('No standard source directories found, defaulting to the app root', { appDir });
+        sourceDirs.push(appDir);
     }
     const frameworkConfig = types_1.FRAMEWORK_CONFIGS[framework] || types_1.FRAMEWORK_CONFIGS['unknown'];
     const localeFormat = frameworkConfig.localeFormat;
+    let publicDir = appDir === '.' ? 'public' : path.join(appDir, 'public');
+    if (appDir === '.' && sourceDirs.length > 0 && sourceDirs[0] !== '.') {
+        const firstSourceDir = sourceDirs[0];
+        const parts = firstSourceDir.split(/[\\/]/);
+        if (parts.length > 1) {
+            parts.pop();
+            publicDir = path.join(...parts, 'public');
+        }
+    }
+    if (framework === 'static') {
+        sourceDirs.length = 0;
+        sourceDirs.push('.');
+        publicDir = '.';
+    }
+    if (framework === 'react-native') {
+        // Translations are bundled with the app (imported by i18n.ts), not served:
+        // src/locales when the app has src/, else locales/ — never app/, which
+        // Expo Router treats as routes.
+        publicDir = (await (0, file_utils_1.isDirectory)(path.join(workspacePath, appDir, 'src'))) ? path.join(appDir, 'src') : appDir;
+    }
     const existingLocales = [];
     let hasLocalesDir = false;
     let localeDirRel = '';
@@ -213,7 +216,8 @@ async function validateWorkspace(config) {
         }
     }
     else {
-        const localesDir = path.join(workspacePath, 'locales');
+        // Where localeFilePath() writes them: <publicDir>/locales/<locale>.json.
+        const localesDir = path.join(workspacePath, publicDir, 'locales');
         hasLocalesDir = await (0, file_utils_1.isDirectory)(localesDir);
         const localeExt = (0, file_utils_1.localeExtension)(localeFormat);
         if (hasLocalesDir) {
@@ -224,20 +228,6 @@ async function validateWorkspace(config) {
             }
         }
     }
-    let publicDir = 'public';
-    if (sourceDirs.length > 0 && sourceDirs[0] !== '.') {
-        const firstSourceDir = sourceDirs[0];
-        const parts = firstSourceDir.split(/[\\/]/);
-        if (parts.length > 1) {
-            parts.pop();
-            publicDir = path.join(...parts, 'public');
-        }
-    }
-    if (framework === 'static') {
-        sourceDirs.length = 0;
-        sourceDirs.push('.');
-        publicDir = '.';
-    }
     if (localeFormat === 'po') {
         // For gettext projects publicDir is the locale directory.
         publicDir = localeDirRel;
@@ -252,6 +242,8 @@ async function validateWorkspace(config) {
         hasLocalesDir,
         existingLocales,
         publicDir,
+        ...(appDir !== '.' ? { appDir } : {}),
+        ...(frameworkConfig.excludedPatterns ? { excludedPatterns: frameworkConfig.excludedPatterns } : {}),
         packageJson: (packageJson ?? {}),
         formatConfig: config.formatConfig,
         ...(framework === 'django' ? { djangoRoot: djangoRoot ?? '.' } : {}),
@@ -270,6 +262,10 @@ function detectFramework(packageJson) {
     const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
     if (deps['next'])
         return 'nextjs';
+    // Before react: every Expo / React Native app also depends on react (and
+    // Expo Router apps on react-dom for the web target).
+    if (isReactNativePackage(packageJson))
+        return 'react-native';
     if (deps['nuxt'])
         return 'vue';
     if (deps['vue'])
@@ -296,6 +292,40 @@ function detectFramework(packageJson) {
         return 'react';
     return 'unknown';
 }
+/** Expo (Router or classic) or bare React Native. */
+function isReactNativePackage(packageJson) {
+    const deps = { ...packageJson?.dependencies, ...packageJson?.devDependencies };
+    return Boolean(deps['expo'] || deps['react-native']);
+}
+/**
+ * The app inside a monorepo: the first workspace package (package.json
+ * `workspaces`), or else the first top-level folder, whose package.json is
+ * a framework Babelize supports. `dir` is relative to the repo root.
+ */
+async function findWorkspaceApp(workspacePath, rootPackageJson) {
+    const candidates = [];
+    const workspacePatterns = getWorkspacePatterns(rootPackageJson);
+    if (workspacePatterns.length > 0) {
+        candidates.push(...(await (0, fast_glob_1.default)(workspacePatterns, { cwd: workspacePath, onlyDirectories: true, deep: 3, absolute: true })).sort());
+    }
+    for (const entry of await (0, file_utils_1.readDir)(workspacePath)) {
+        if (entry.startsWith('.') || entry === 'node_modules')
+            continue;
+        const dir = path.join(workspacePath, entry);
+        if (await (0, file_utils_1.isDirectory)(dir))
+            candidates.push(dir);
+    }
+    for (const dir of candidates) {
+        const subPkg = await (0, file_utils_1.readJsonFile)(path.join(dir, 'package.json'));
+        if (!subPkg)
+            continue;
+        const framework = detectFramework(subPkg);
+        if (framework !== 'unknown') {
+            return { dir: path.relative(workspacePath, dir).split(path.sep).join('/'), packageJson: subPkg, framework };
+        }
+    }
+    return null;
+}
 async function findSourceDirectories(workspacePath) {
     const possibleDirs = ['src', 'app', 'pages', 'components', 'features', 'modules', 'lib'];
     const foundDirs = [];
@@ -322,6 +352,13 @@ async function checkI18nDependencies(packageJson, framework) {
         if (!deps['vue-i18n'])
             recommendation = 'Run: bun install vue-i18n';
     }
+    else if (framework === 'react-native') {
+        if (!hasI18next || !hasReactI18next) {
+            recommendation = deps['expo']
+                ? 'Run: npx expo install i18next react-i18next expo-localization'
+                : 'Run: npm install i18next react-i18next react-native-localize';
+        }
+    }
     else {
         // React / vanilla / unknown
         if (!hasI18next)

package/dist/runtime/types.d.ts

@@ -87,6 +87,14 @@ export interface WorkspaceInfo {
     hasLocalesDir: boolean;
     existingLocales: string[];
     publicDir: string;
+    /**
+     * The app's folder in a monorepo (`apps/mobile`), relative to the
+     * workspace; unset when the app is the repository root. Its package.json,
+     * tsconfig and entry points are the app's; installs still run at the root.
+     */
+    appDir?: string;
+    /** Framework-specific scan exclusions (FrameworkConfig.excludedPatterns); see workspaceExcludes(). */
+    excludedPatterns?: readonly string[];
     packageJson?: Record<string, any>;
     /** Output locale file format (e.g., 'json' for React, 'po' for Django) */
     localeFormat: 'json' | 'po' | 'arb';
@@ -424,4 +432,18 @@ export interface Phase7Result {
 }
 export declare const SUPPORTED_EXTENSIONS: string[];
 export declare const EXCLUDED_PATTERNS: string[];
+/**
+ * Exclusions for scanning a workspace's sources: the engine defaults plus the
+ * framework's own (virtualenvs for Django, the native ios/android projects for
+ * React Native). Every source scan goes through this so they can't disagree.
+ */
+export declare function workspaceExcludes(workspace: {
+    excludedPatterns?: readonly string[];
+}): string[];
+/**
+ * Whether a workspace-relative path falls under one of `patterns`, read the
+ * way findFiles reads them: a leading `/` anchors to the root (`/ios`), other
+ * names match any path segment (`Pods`), `*` globs match file names.
+ */
+export declare function isExcludedPath(relPath: string, patterns: readonly string[]): boolean;
 export declare const JSX_TRANSLATABLE_ATTRS: string[];

package/dist/runtime/types.js

@@ -8,6 +8,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JSX_TRANSLATABLE_ATTRS = exports.EXCLUDED_PATTERNS = exports.SUPPORTED_EXTENSIONS = void 0;
+exports.workspaceExcludes = workspaceExcludes;
+exports.isExcludedPath = isExcludedPath;
 // ============ Constants ============
 exports.SUPPORTED_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx', '.vue', '.html'];
 exports.EXCLUDED_PATTERNS = [
@@ -27,12 +29,43 @@ exports.EXCLUDED_PATTERNS = [
     '*.min.js',
     '*.min.css',
 ];
+/**
+ * Exclusions for scanning a workspace's sources: the engine defaults plus the
+ * framework's own (virtualenvs for Django, the native ios/android projects for
+ * React Native). Every source scan goes through this so they can't disagree.
+ */
+function workspaceExcludes(workspace) {
+    return [...exports.EXCLUDED_PATTERNS, ...(workspace.excludedPatterns ?? [])];
+}
+/**
+ * Whether a workspace-relative path falls under one of `patterns`, read the
+ * way findFiles reads them: a leading `/` anchors to the root (`/ios`), other
+ * names match any path segment (`Pods`), `*` globs match file names.
+ */
+function isExcludedPath(relPath, patterns) {
+    const segments = relPath.split(/[\\/]/).filter(Boolean);
+    const rel = segments.join('/');
+    return patterns.some((pattern) => {
+        if (pattern.includes('*')) {
+            const re = new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`);
+            return segments.some((segment) => re.test(segment));
+        }
+        if (pattern.includes('/')) {
+            const anchored = pattern.startsWith('/') ? pattern.slice(1) : pattern;
+            return rel === anchored || rel.startsWith(`${anchored}/`);
+        }
+        return segments.includes(pattern);
+    });
+}
 exports.JSX_TRANSLATABLE_ATTRS = [
     'title',
     'placeholder',
     'alt',
     'aria-label',
     'aria-description',
+    // React Native's screen-reader props (the web uses aria-*).
+    'accessibilityLabel',
+    'accessibilityHint',
     'label',
     'description',
 ];

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

@@ -13,7 +13,18 @@ export interface ParseOptions {
     isTypeScript?: boolean;
     isJSX?: boolean;
     filename?: string;
+    /**
+     * Parse for rewriting: `generateCode` then reprints only the nodes that
+     * changed and keeps every other line of the file exactly as written.
+     */
+    preserveFormat?: boolean;
 }
+/**
+ * Where a node starts in the file as written. Recast hands the parser a
+ * normalized copy (`\n` line endings, leading tabs expanded), so the node's
+ * own offset can differ from the source offsets extraction recorded.
+ */
+export declare function sourceOffset(ast: t.File, node: t.Node): number | undefined;
 export declare function parseCode(code: string, options?: ParseOptions): t.File;
 export declare function generateCode(ast: t.File, originalCode?: string): string;
 /**
@@ -26,6 +37,11 @@ export declare function placeStatementsOnOwnLines(code: string, statements: stri
 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;
+/**
+ * Expressions a value passes through unchanged on its way to its slot:
+ * `a ? 'x' : b`, `k ?? 'x'`, `('x' as K)`, `x!`.
+ */
+export declare function isValuePassthrough(node: t.Node, child: t.Node): boolean;
 export declare function getComponentName(path: NodePath): string | null;
 export declare function isInsideComponent(path: NodePath): boolean;
 /**
@@ -33,7 +49,11 @@ export declare function isInsideComponent(path: NodePath): boolean;
  * 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 findComponentBody(path: NodePath, 
+/** Also lowercase functions returning JSX (render helpers), for when there is no module-level t. */
+options?: {
+    renderHelpers?: boolean;
+}): NodePath | null;
 export declare function hasTranslationImport(ast: t.File): boolean;
 export declare function hasTranslationHook(functionPath: NodePath): boolean;
 export declare function createTranslationImport(): t.ImportDeclaration;
@@ -45,7 +65,13 @@ export declare function getParentContext(path: NodePath): {
     parentContext: string;
     siblingGroupId: string;
 } | null;
-export declare function extractExpressionContent(node: t.Node, variables?: string[]): string | null;
+/**
+ * A string-building expression as one message: `\`Hi ${user.name}\`` and
+ * `'Hi ' + name` → "Hi {name}". `variables` receives the placeholder names
+ * and, when given, `expressions` the expression behind each one (same order),
+ * so injection can rebuild the message as `t(key, { name: user.name })`.
+ */
+export declare function extractExpressionContent(node: t.Node, variables?: string[], expressions?: t.Expression[]): string | null;
 export declare function extractConditionalContent(node: t.ConditionalExpression): {
     consequent: string | null;
     alternate: string | null;
@@ -55,3 +81,5 @@ export declare function extractConditionalContent(node: t.ConditionalExpression)
  */
 export declare function hasUseClientDirective(ast: t.File): boolean;
 export { generate, t, traverse };
+/** A top-level import or declaration already binds `name` (e.g. `t` from an earlier run's `@/i18n` import). */
+export declare function bindsTopLevel(ast: t.File, name: string): boolean;