@babelize/engine 0.0.0-stage → 0.1.0

package/dist/utils/file-utils.js

@@ -0,0 +1,262 @@
+"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.clearFindFilesCache = clearFindFilesCache;
+exports.readFile = readFile;
+exports.writeFile = writeFile;
+exports.pathExists = pathExists;
+exports.isDirectory = isDirectory;
+exports.findFiles = findFiles;
+exports.getRelativePath = getRelativePath;
+exports.readJsonFile = readJsonFile;
+exports.writeJsonFile = writeJsonFile;
+exports.localeExtension = localeExtension;
+exports.localeFilePath = localeFilePath;
+exports.ensureDir = ensureDir;
+exports.copyFile = copyFile;
+exports.deleteFile = deleteFile;
+exports.readDir = readDir;
+exports.concurrentMap = concurrentMap;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const string_utils_1 = require("./string-utils");
+/**
+ * Engine v2 file utils.
+ *
+ * This is a direct carry-over of the v1 utilities to preserve behavior.
+ */
+const findFilesCache = new Map();
+function clearFindFilesCache() {
+    findFilesCache.clear();
+}
+function findFilesCacheKey(dir, extensions, excludePatterns) {
+    return `${dir}::${extensions.sort().join(',')}::${excludePatterns.sort().join(',')}`;
+}
+async function readFile(filePath) {
+    return fs.promises.readFile(filePath, 'utf-8');
+}
+async function writeFile(filePath, content, allowedBaseDir) {
+    const resolved = path.resolve(filePath);
+    if (allowedBaseDir && !resolved.startsWith(path.resolve(allowedBaseDir))) {
+        throw new Error(`Path traversal detected: ${filePath} is outside ${allowedBaseDir}`);
+    }
+    const dir = path.dirname(resolved);
+    await fs.promises.mkdir(dir, { recursive: true });
+    // Atomic write: write to tmp, then rename to prevent partial/corrupt files on crash
+    const tmpPath = resolved + '.tmp';
+    await fs.promises.writeFile(tmpPath, content, 'utf-8'); // codeql[js/http-to-file-access] — engine writes translation output to workspace; callers authenticate + authorize
+    await fs.promises.rename(tmpPath, resolved);
+}
+async function pathExists(filePath) {
+    try {
+        await fs.promises.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(filePath) {
+    try {
+        const stats = await fs.promises.stat(filePath);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function findFiles(dir, extensions, excludePatterns = []) {
+    const key = findFilesCacheKey(dir, extensions, excludePatterns);
+    const cached = findFilesCache.get(key);
+    if (cached)
+        return cached;
+    const promise = findFilesUncached(dir, extensions, excludePatterns);
+    findFilesCache.set(key, promise);
+    return promise;
+}
+/** Exclusion names that usually mean generated output (but not inside SOURCE_TREE_DIRS). */
+const OUTPUT_DIR_NAMES = new Set(['build', 'dist', 'coverage', 'lib', 'libs', 'vendor']);
+/** Directories whose subdirectories are routes or components, never build output. */
+const SOURCE_TREE_DIRS = new Set(['app', 'pages', 'components']);
+function isInsideSourceTree(walkRoot, relativePath) {
+    const ancestors = [path.basename(walkRoot), ...relativePath.split(path.sep).slice(0, -1)];
+    return ancestors.some((segment) => SOURCE_TREE_DIRS.has(segment));
+}
+async function findFilesUncached(dir, extensions, excludePatterns = []) {
+    const results = [];
+    async function walk(currentDir) {
+        const entries = await fs.promises.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            const relativePath = path.relative(dir, fullPath);
+            const shouldExclude = excludePatterns.some((pattern) => {
+                if (pattern.includes('*')) {
+                    const escaped = (0, string_utils_1.escapeRegex)(pattern).replace(/\*/g, '.*');
+                    const regex = new RegExp(escaped);
+                    return regex.test(entry.name) || regex.test(relativePath);
+                }
+                // Whole path segments only: a substring match excluded files like
+                // `components/Calibrate.tsx` ("lib") or `app/distance/page.tsx` ("dist").
+                if (pattern.includes('/')) {
+                    const rel = relativePath.split(path.sep).join('/');
+                    return rel === pattern || rel.startsWith(`${pattern}/`);
+                }
+                if (entry.name !== pattern)
+                    return false;
+                // Build-output names are real source inside routing/component trees
+                // (a Next.js route `app/build/page.tsx`); output never lives there.
+                if (OUTPUT_DIR_NAMES.has(pattern) && isInsideSourceTree(dir, relativePath))
+                    return false;
+                return true;
+            });
+            if (shouldExclude)
+                continue;
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name).toLowerCase();
+                if (extensions.includes(ext)) {
+                    results.push(fullPath);
+                }
+            }
+        }
+    }
+    await walk(dir);
+    return results;
+}
+function getRelativePath(workspacePath, filePath) {
+    return path.relative(workspacePath, filePath).replace(/\\/g, '/');
+}
+async function readJsonFile(filePath) {
+    try {
+        const content = await readFile(filePath);
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeJsonFile(filePath, data, sortKeys = true) {
+    let content;
+    if (sortKeys && typeof data === 'object' && data !== null) {
+        content = JSON.stringify(sortObjectKeys(data), null, 2);
+    }
+    else {
+        content = JSON.stringify(data, null, 2);
+    }
+    await writeFile(filePath, content + '\n');
+}
+function sortObjectKeys(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(sortObjectKeys);
+    }
+    if (typeof obj === 'object' && obj !== null) {
+        const sorted = {};
+        const keys = Object.keys(obj).sort();
+        for (const key of keys) {
+            sorted[key] = sortObjectKeys(obj[key]);
+        }
+        return sorted;
+    }
+    return obj;
+}
+function localeExtension(format) {
+    return format === 'po' ? '.po' : '.json';
+}
+/**
+ * Compute the locale directory and file path for a given target locale.
+ * Django uses `locale/<lang>/LC_MESSAGES/django.po`,
+ * other frameworks use `<publicDir>/locales/<lang>.json`.
+ */
+function localeFilePath(workspacePath, publicDir, localeFormat, targetLocale) {
+    if (localeFormat === 'po') {
+        const dir = path.join(workspacePath, 'locale', targetLocale, 'LC_MESSAGES');
+        const file = path.join(dir, 'django.po');
+        const relativeFile = path.join('locale', targetLocale, 'LC_MESSAGES', 'django.po');
+        return { dir, file, relativeFile };
+    }
+    const ext = localeExtension(localeFormat);
+    const dir = path.join(workspacePath, publicDir, 'locales');
+    const file = path.join(dir, `${targetLocale}${ext}`);
+    const relativeFile = path.join(publicDir, 'locales', `${targetLocale}${ext}`);
+    return { dir, file, relativeFile };
+}
+async function ensureDir(dirPath) {
+    await fs.promises.mkdir(dirPath, { recursive: true });
+}
+async function copyFile(src, dest) {
+    await ensureDir(path.dirname(dest));
+    await fs.promises.copyFile(src, dest);
+}
+async function deleteFile(filePath) {
+    try {
+        await fs.promises.unlink(filePath);
+    }
+    catch {
+        // ignore
+    }
+}
+async function readDir(dirPath) {
+    try {
+        return await fs.promises.readdir(dirPath);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Process items with bounded concurrency.
+ * Unlike Promise.all, this limits the number of concurrent operations.
+ * Errors are collected and returned alongside results.
+ */
+async function concurrentMap(items, fn, concurrency) {
+    const results = new Array(items.length);
+    const errors = [];
+    let nextIndex = 0;
+    const worker = async () => {
+        while (nextIndex < items.length) {
+            const i = nextIndex++;
+            try {
+                results[i] = await fn(items[i], i);
+            }
+            catch (err) {
+                errors.push(err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+    return { results, errors };
+}

package/dist/utils/glossary-match.d.ts

@@ -0,0 +1,9 @@
+/** Shared by the translate phase and locale QA so both judge glossary use the same way. */
+/**
+ * Whether the required glossary translation appears in the output, allowing
+ * for inflection: each of its words must match a word in the output on a
+ * shared stem (Polish "obszar roboczy" → "obszarem roboczym", German
+ * "Arbeitsbereich" → "Arbeitsbereichs"). Scripts without spaces fall back to a
+ * substring check.
+ */
+export declare function containsGlossaryTranslation(translated: string, required: string): boolean;

package/dist/utils/glossary-match.js

@@ -0,0 +1,25 @@
+"use strict";
+/** Shared by the translate phase and locale QA so both judge glossary use the same way. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsGlossaryTranslation = containsGlossaryTranslation;
+/**
+ * Whether the required glossary translation appears in the output, allowing
+ * for inflection: each of its words must match a word in the output on a
+ * shared stem (Polish "obszar roboczy" → "obszarem roboczym", German
+ * "Arbeitsbereich" → "Arbeitsbereichs"). Scripts without spaces fall back to a
+ * substring check.
+ */
+function containsGlossaryTranslation(translated, required) {
+    const out = translated.toLowerCase();
+    const want = required.toLowerCase();
+    if (out.includes(want))
+        return true;
+    const outWords = out.split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+    const wantWords = want.split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+    if (wantWords.length === 0)
+        return true;
+    return wantWords.every((w) => {
+        const stem = w.slice(0, Math.max(3, w.length - 3));
+        return outWords.some((o) => o.startsWith(stem));
+    });
+}

package/dist/utils/html-extractor.d.ts

@@ -0,0 +1,8 @@
+import type { ExtractedString, Warning } from '../runtime/types';
+import type { Node } from 'node-html-parser';
+export declare function extractStringsFromHtml(content: string, filePath: string, detectFormats?: boolean): Promise<{
+    strings: ExtractedString[];
+    warnings: Warning[];
+}>;
+export declare function isTextNode(node: Node): boolean;
+export declare function isElementNode(node: Node): boolean;

package/dist/utils/html-extractor.js

@@ -0,0 +1,317 @@
+"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.extractStringsFromHtml = extractStringsFromHtml;
+exports.isTextNode = isTextNode;
+exports.isElementNode = isElementNode;
+const string_utils_1 = require("./string-utils");
+const detect_format_1 = require("./detect-format");
+// Void elements that can't have text content
+const VOID_ELEMENTS = new Set([
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+    'link', 'meta', 'param', 'source', 'track', 'wbr',
+]);
+// Tags to skip entirely (already handled by SKIP_TAGS + void elements)
+// Everything else is considered potentially translatable
+const TRANSLATABLE_ATTRS = new Set([
+    'alt', 'title', 'placeholder', 'aria-label', 'aria-description',
+]);
+async function extractStringsFromHtml(content, filePath, detectFormats) {
+    const { parse } = await Promise.resolve().then(() => __importStar(require('node-html-parser')));
+    const ctx = {
+        filePath,
+        fileContent: content,
+        strings: [],
+        seenTexts: new Set(),
+    };
+    const warnings = [];
+    const root = parse(content, {
+        comment: false,
+        blockTextElements: { script: true, style: true, noscript: true, pre: true },
+    });
+    walkNode(root, ctx, 1, warnings, detectFormats);
+    extractHeadStrings(root, ctx, warnings);
+    return { strings: ctx.strings, warnings };
+}
+function isTextNode(node) {
+    return node.nodeType === 3;
+}
+function isElementNode(node) {
+    return node.nodeType === 1;
+}
+function asElement(node) {
+    return node.nodeType === 1 ? node : null;
+}
+/**
+ * Whether any element at or above `node` carries a `data-i18n` attribute.
+ * `node` is the parent of the text node being considered.
+ */
+function hasDataI18nAncestor(node) {
+    let current = node;
+    while (current) {
+        if (isElementNode(current)) {
+            const el = asElement(current);
+            if (el && el.getAttribute('data-i18n'))
+                return true;
+        }
+        current = current.parentNode;
+    }
+    return false;
+}
+function walkNode(node, ctx, depth, warnings, detectFormats) {
+    if (depth > 100)
+        return;
+    if (isTextNode(node)) {
+        const text = node.text.trim();
+        if (!text || text.length < 2)
+            return;
+        const parent = node.parentNode;
+        if (!parent || !isElementNode(parent))
+            return;
+        // Honor data-i18n on ANY ancestor, not just the direct parent — an
+        // ancestor `<div data-i18n="k"><p>Text</p></div>` must not re-extract.
+        if (hasDataI18nAncestor(parent))
+            return;
+        const parentRaw = parent.rawTagName;
+        if (!parentRaw)
+            return;
+        const parentTagName = parentRaw.toLowerCase();
+        if (string_utils_1.SKIP_TAGS.has(parentTagName) || VOID_ELEMENTS.has(parentTagName))
+            return;
+        const hasCurrency = (0, string_utils_1.matchesCurrencyPattern)(text);
+        const hasDate = (0, string_utils_1.matchesDatePattern)(text);
+        const isDateOrCurrencyValue = (hasCurrency || hasDate) && text.length >= 3;
+        const format = detectFormats ? (0, detect_format_1.detectFormat)(text) : null;
+        if (!(0, string_utils_1.isTranslatableText)(text) && !isDateOrCurrencyValue && !format)
+            return;
+        if ((0, string_utils_1.containsPII)(text))
+            return;
+        if (format) {
+            warnings.push({
+                type: 'ambiguous-format',
+                file: ctx.filePath,
+                line: findLineNumber(node, ctx.fileContent),
+                message: `Detected ${format.class} format: "${text}". Will be replaced with Intl.* API call.`,
+                severity: 'warning',
+                dismissible: true,
+            });
+        }
+        else {
+            if (hasCurrency) {
+                warnings.push({
+                    type: 'hardcoded-currency',
+                    file: ctx.filePath,
+                    line: findLineNumber(node, ctx.fileContent),
+                    message: 'Hardcoded currency/number format detected. Use Intl.NumberFormat.',
+                });
+            }
+            if (hasDate) {
+                warnings.push({
+                    type: 'hardcoded-date',
+                    file: ctx.filePath,
+                    line: findLineNumber(node, ctx.fileContent),
+                    message: 'Hardcoded date format detected. Use Intl.DateTimeFormat.',
+                });
+            }
+        }
+        const isDateOrCurrencyOnly = isDateOrCurrencyValue && !(0, string_utils_1.isTranslatableText)(text);
+        let context = 'jsx-text';
+        if (format) {
+            context = 'format-string';
+        }
+        else if (isDateOrCurrencyOnly) {
+            context = hasCurrency ? 'hardcoded-currency' : 'hardcoded-date';
+        }
+        const line = findLineNumber(node, ctx.fileContent);
+        const contentKey = `${ctx.filePath}:${(0, string_utils_1.hashString)(text)}`;
+        if (!ctx.seenTexts.has(contentKey)) {
+            const id = `${ctx.filePath}:${line}:${(0, string_utils_1.hashString)(text)}`;
+            ctx.seenTexts.add(contentKey);
+            ctx.strings.push({
+                text,
+                file: ctx.filePath,
+                line,
+                column: 0,
+                context,
+                id,
+                detectedFormat: format ?? undefined,
+            });
+        }
+        return;
+    }
+    const element = asElement(node);
+    if (element) {
+        const raw = element.rawTagName;
+        if (!raw) {
+            for (const child of element.childNodes) {
+                if (isTextNode(child) || asElement(child)) {
+                    walkNode(child, ctx, depth + 1, warnings, detectFormats);
+                }
+            }
+            return;
+        }
+        const tagName = raw.toLowerCase();
+        for (const attr of TRANSLATABLE_ATTRS) {
+            const value = element.getAttribute(attr);
+            if (value && (0, string_utils_1.isTranslatableText)(value) && !(0, string_utils_1.containsPII)(value)) {
+                const line = findLineNumber(element, ctx.fileContent);
+                const contentKey = `${ctx.filePath}:${(0, string_utils_1.hashString)(value)}`;
+                if (!ctx.seenTexts.has(contentKey)) {
+                    const id = `${ctx.filePath}:${line}:${(0, string_utils_1.hashString)(value)}`;
+                    ctx.seenTexts.add(contentKey);
+                    ctx.strings.push({
+                        text: value,
+                        file: ctx.filePath,
+                        line,
+                        column: 0,
+                        context: 'jsx-attr',
+                        id,
+                    });
+                }
+            }
+        }
+        // Extract value attribute from <input type="button|submit|reset"> and <option>
+        if (tagName === 'input') {
+            const type = element.getAttribute('type')?.toLowerCase();
+            if (type === 'button' || type === 'submit' || type === 'reset') {
+                const value = element.getAttribute('value');
+                if (value && value.trim().length >= 2 && !(0, string_utils_1.containsPII)(value) && (0, string_utils_1.isTranslatableText)(value)) {
+                    const line = findLineNumber(element, ctx.fileContent);
+                    const contentKey = `${ctx.filePath}:${(0, string_utils_1.hashString)(value)}`;
+                    if (!ctx.seenTexts.has(contentKey)) {
+                        const id = `${ctx.filePath}:${line}:${(0, string_utils_1.hashString)(value)}`;
+                        ctx.seenTexts.add(contentKey);
+                        ctx.strings.push({
+                            text: value,
+                            file: ctx.filePath,
+                            line,
+                            column: 0,
+                            context: 'jsx-attr',
+                            id,
+                        });
+                    }
+                }
+            }
+        }
+        if (tagName === 'option') {
+            const value = element.getAttribute('value');
+            if (value && value.trim().length >= 2 && !(0, string_utils_1.containsPII)(value) && (0, string_utils_1.isTranslatableText)(value)) {
+                // Only extract if value differs from text content (avoid duplicates)
+                const textContent = element.textContent?.trim();
+                if (textContent && value !== textContent) {
+                    const line = findLineNumber(element, ctx.fileContent);
+                    const contentKey = `${ctx.filePath}:${(0, string_utils_1.hashString)(value)}`;
+                    if (!ctx.seenTexts.has(contentKey)) {
+                        const id = `${ctx.filePath}:${line}:${(0, string_utils_1.hashString)(value)}`;
+                        ctx.seenTexts.add(contentKey);
+                        ctx.strings.push({
+                            text: value,
+                            file: ctx.filePath,
+                            line,
+                            column: 0,
+                            context: 'jsx-attr',
+                            id,
+                        });
+                    }
+                }
+            }
+        }
+        if (string_utils_1.SKIP_TAGS.has(tagName) || VOID_ELEMENTS.has(tagName))
+            return;
+        for (const child of element.childNodes) {
+            if (isTextNode(child) || asElement(child)) {
+                walkNode(child, ctx, depth + 1, warnings, detectFormats);
+            }
+        }
+    }
+}
+function findLineNumber(node, fileContent) {
+    if (node.range) {
+        return (fileContent.slice(0, node.range[0]).match(/\n/g) || []).length + 1;
+    }
+    const raw = node.rawText || node.text || '';
+    if (!raw)
+        return 0;
+    const idx = fileContent.indexOf(raw);
+    if (idx === -1)
+        return 0;
+    return (fileContent.slice(0, idx).match(/\n/g) || []).length + 1;
+}
+function extractHeadStrings(root, ctx, _warnings) {
+    // <title>
+    const title = root.querySelector('title');
+    if (title) {
+        const text = title.textContent?.trim();
+        if (text && text.length >= 2 && !ctx.seenTexts.has(text)) {
+            const contentKey = `${ctx.filePath}:${(0, string_utils_1.hashString)(text)}`;
+            if (!ctx.seenTexts.has(contentKey)) {
+                const id = `${ctx.filePath}:title:${(0, string_utils_1.hashString)(text)}`;
+                ctx.seenTexts.add(contentKey);
+                ctx.strings.push({
+                    text,
+                    file: ctx.filePath,
+                    line: 0,
+                    column: 0,
+                    context: 'jsx-attr',
+                    id,
+                });
+            }
+        }
+    }
+    // Meta tags with content attribute
+    const metaTags = root.querySelectorAll('meta[name],meta[property]');
+    const seoAttrs = ['description', 'og:title', 'og:description', 'og:site_name', 'twitter:title', 'twitter:description'];
+    for (const meta of metaTags) {
+        const name = meta.getAttribute('name') || meta.getAttribute('property');
+        if (name && seoAttrs.includes(name)) {
+            const content = meta.getAttribute('content');
+            if (content && content.trim().length >= 2 && !ctx.seenTexts.has(content)) {
+                const contentKey = `${ctx.filePath}:${(0, string_utils_1.hashString)(content)}`;
+                if (!ctx.seenTexts.has(contentKey)) {
+                    const id = `${ctx.filePath}:meta:${(0, string_utils_1.hashString)(content)}`;
+                    ctx.seenTexts.add(contentKey);
+                    ctx.strings.push({
+                        text: content,
+                        file: ctx.filePath,
+                        line: 0,
+                        column: 0,
+                        context: 'jsx-attr',
+                        id,
+                    });
+                }
+            }
+        }
+    }
+}

package/dist/utils/i18next-icu.d.ts

@@ -0,0 +1,38 @@
+import type { WorkspaceInfo } from '../runtime/types';
+/** Libraries that call i18next's init themselves (the config is inside the library). */
+export declare const I18NEXT_WRAPPERS: string[];
+/** First line of i18n configs Babelize writes; Babelize may update a file that has it. */
+export declare const GENERATED_I18N_CONFIG_MARKER = "// @babelize-generated i18n config";
+/**
+ * Whether an i18next config was written by Babelize: the marker, or the
+ * signature of the template from before the marker existed.
+ */
+export declare function isGeneratedI18nConfig(content: string): boolean;
+export interface I18nextIcuStatus {
+    /** ICU messages ("Hello {name}", plurals) will be formatted at runtime. */
+    available: boolean;
+    /** The project initializes i18next itself (its own config, or a wrapper like next-i18next): Babelize must not add a second config. */
+    userOwnsInit: boolean;
+    /** A config the user owns that doesn't load i18next-icu (relative path). */
+    userConfig?: string;
+    /** Wrapper library that owns i18next's init, when that's how the project is set up. */
+    wrapper?: string;
+    /** Babelize-generated configs that don't load i18next-icu yet (relative paths); finalization adds it. */
+    generatedWithoutIcu: string[];
+}
+/**
+ * Can a react-i18next project format ICU messages at runtime? Decided by the
+ * config that actually initializes i18next — the files calling
+ * `.use(initReactI18next)` / `i18n.init(…)`:
+ *  - a config the user owns: only if it loads i18next-icu;
+ *  - Babelize's own config: yes (finalization adds i18next-icu to older ones);
+ *  - a wrapper that owns init (next-i18next, …): only if its config loads i18next-icu;
+ *  - nothing yet: yes, Babelize will generate the config.
+ * Without ICU, placeholders would show as raw `{user}`, so sentences stay
+ * fragments until the user adds i18next-icu.
+ */
+export declare function detectI18nextIcu(workspace: WorkspaceInfo): Promise<I18nextIcuStatus>;
+/** Add i18next-icu to a Babelize-generated config (idempotent). */
+export declare function addIcuToGeneratedConfig(content: string): string;
+/** The note shown when sentences stay fragments because the runtime can't format ICU. */
+export declare function missingIcuNote(status: I18nextIcuStatus): string | null;