@babelize/engine 0.0.0-stage → 0.1.0

package/dist/modules/extractor/extract.js

@@ -0,0 +1,701 @@
+"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.extractStrings = extractStrings;
+exports.extractStringsFromFile = extractStringsFromFile;
+const path = __importStar(require("path"));
+const types_1 = require("../../runtime/types");
+const html_extractor_1 = require("../../utils/html-extractor");
+const ast_helpers_1 = require("../../utils/ast-helpers");
+const file_utils_1 = require("../../utils/file-utils");
+const string_utils_1 = require("../../utils/string-utils");
+const detect_format_1 = require("../../utils/detect-format");
+const dtl_mask_1 = require("../../utils/dtl-mask");
+const py_extractor_1 = require("../../utils/py-extractor");
+const jsx_message_1 = require("../../utils/jsx-message");
+const ui_copy_1 = require("../../utils/ui-copy");
+const module_constants_1 = require("../../utils/module-constants");
+/** Frameworks whose injection strategies can render a JSX sentence as one message. */
+const SENTENCE_FRAMEWORKS = new Set(['react', 'nextjs']);
+async function extractStrings(workspace, filesToProcess, extractOptions = {}) {
+    const detectFormats = !!workspace.formatConfig?.enabled;
+    const strings = [];
+    const filesAnalyzed = [];
+    const skippedFiles = [];
+    const warnings = [];
+    const notInjected = [];
+    const sourceFiles = [];
+    if (filesToProcess && filesToProcess.length > 0) {
+        // If specific files are provided, only scan those
+        for (const relPath of filesToProcess) {
+            sourceFiles.push(path.join(workspace.path, relPath));
+        }
+    }
+    else {
+        // Otherwise scan all source directories
+        for (const sourceDir of workspace.sourceDirs) {
+            const dirPath = path.join(workspace.path, sourceDir);
+            const files = await (0, file_utils_1.findFiles)(dirPath, types_1.SUPPORTED_EXTENSIONS, types_1.EXCLUDED_PATTERNS);
+            sourceFiles.push(...files);
+        }
+    }
+    const raw = process.env.BABELIZE_EXTRACT_CONCURRENCY;
+    const EXTRACTION_CONCURRENCY = raw ? Math.max(1, parseInt(raw, 10) || 1) : 10;
+    const { results: extractedResults, errors: extractionErrors } = await (0, file_utils_1.concurrentMap)(sourceFiles, async (filePath) => {
+        const relativePath = (0, file_utils_1.getRelativePath)(workspace.path, filePath);
+        try {
+            const content = await (0, file_utils_1.readFile)(filePath);
+            const extracted = await extractStringsFromFile(content, relativePath, detectFormats, { framework: workspace.framework, ...extractOptions });
+            return { relativePath, extracted };
+        }
+        catch (error) {
+            throw Object.assign(error instanceof Error ? error : new Error(String(error)), { relativePath });
+        }
+    }, EXTRACTION_CONCURRENCY);
+    for (const result of extractedResults) {
+        if (!result)
+            continue;
+        const { relativePath, extracted } = result;
+        strings.push(...extracted.strings);
+        warnings.push(...extracted.warnings);
+        if (extracted.notInjected)
+            notInjected.push(...extracted.notInjected);
+        filesAnalyzed.push(relativePath);
+    }
+    for (const err of extractionErrors) {
+        skippedFiles.push({
+            file: err.relativePath || 'unknown',
+            reason: 'parse-error',
+            details: err.message,
+        });
+    }
+    const extraction = { strings, filesAnalyzed, skippedFiles, warnings, notInjected };
+    return { extraction };
+}
+async function extractStringsFromFile(content, filePath, detectFormats, options) {
+    // Django template handling
+    if (options?.framework === 'django' && (filePath.endsWith('.html') || filePath.endsWith('.htm'))) {
+        const { masked } = (0, dtl_mask_1.maskTemplateTags)(content);
+        const result = await (0, html_extractor_1.extractStringsFromHtml)(masked, filePath, detectFormats);
+        // Don't restore — we extract from the masked version, the restore happens at inject time
+        return result;
+    }
+    // Python file handling
+    if (filePath.endsWith('.py')) {
+        return (0, py_extractor_1.extractStringsFromPython)(content, filePath);
+    }
+    if (filePath.endsWith('.html') || filePath.endsWith('.htm')) {
+        return (0, html_extractor_1.extractStringsFromHtml)(content, filePath, detectFormats);
+    }
+    if (filePath.endsWith('.vue')) {
+        return extractStringsFromVueSfc(content, filePath, detectFormats);
+    }
+    const strings = [];
+    const warnings = [];
+    const seenTexts = new Set();
+    // Every node each extraction id stands for (identical text on one line is
+    // one id): injection replaces exactly these nodes, never others that
+    // merely have the same text, like `{ value: 'Active', label: 'Active' }`.
+    const offsetsById = new Map();
+    const noteOffset = (id, start) => {
+        if (typeof start !== 'number')
+            return;
+        const list = offsetsById.get(id) ?? [];
+        if (!list.includes(start))
+            list.push(start);
+        offsetsById.set(id, list);
+    };
+    // Group JSX sentences into one message (React / Next.js, and direct calls
+    // that don't name a framework). Other frameworks keep per-text extraction.
+    const groupSentences = options?.sentences !== false && (!options?.framework || SENTENCE_FRAMEWORKS.has(options.framework));
+    // Text nodes, literal `{" "}` children and inline elements already folded
+    // into a sentence message — not extracted again on their own.
+    const consumed = new WeakSet();
+    const unwired = [];
+    const isTypeScript = filePath.endsWith('.ts') || filePath.endsWith('.tsx');
+    try {
+        const ast = (0, ast_helpers_1.parseCode)(content, { isTypeScript });
+        // UI copy in module-level constants rendered by components (#248): keys
+        // when every use is a render, otherwise reported — never silently skipped.
+        if (!options?.framework || SENTENCE_FRAMEWORKS.has(options.framework)) {
+            for (const plan of (0, module_constants_1.analyzeModuleConstants)(ast)) {
+                for (const lit of plan.literals) {
+                    const text = lit.node.value.trim();
+                    const line = lit.node.loc?.start.line || 0;
+                    if (!plan.provable) {
+                        unwired.push({
+                            file: filePath,
+                            key: '',
+                            text,
+                            reason: `module-level constant ${plan.name} (${plan.reason}): move it inside the component or translate where it's rendered`,
+                        });
+                        continue;
+                    }
+                    consumed.add(lit.node);
+                    const id = `${filePath}:${line}:${(0, string_utils_1.hashString)(text)}`;
+                    noteOffset(id, lit.node.start);
+                    if (seenTexts.has(id))
+                        continue;
+                    seenTexts.add(id);
+                    strings.push({ text, file: filePath, line, column: lit.node.loc?.start.column || 0, context: 'string-literal', id });
+                }
+            }
+        }
+        const processExtractedText = (text, path, variables = []) => {
+            if (typeof text !== 'string' || !text) {
+                if (text !== null && text !== undefined && typeof text !== 'string') {
+                    warnings.push({
+                        type: 'malformed-ast',
+                        file: filePath,
+                        line: path.node?.loc?.start?.line,
+                        message: `Extraction produced non-string value: ${String(text)}. Skipping.`,
+                        severity: 'warning',
+                        dismissible: true,
+                    });
+                }
+                return;
+            }
+            text = text.trim();
+            if (consumed.has(path.node))
+                return;
+            if (!options?.relaxComponentGuard && !isInJSXContext(path) && !(0, ast_helpers_1.isInsideComponent)(path))
+                return;
+            if ((0, ast_helpers_1.isNonTranslatableContext)(path))
+                return;
+            if (path.parentPath && path.parentPath.isCallExpression() && path.parentPath.node.arguments.includes(path.node)) {
+                return;
+            }
+            // Program data in initializers (`{ name: "Ada" }`, `href: "/"`) is not UI copy.
+            if (!(0, string_utils_1.matchesCurrencyPattern)(text) && !(0, string_utils_1.matchesDatePattern)(text) && !(0, ui_copy_1.isUiCopyLiteral)(path.node, path.parent, text))
+                return;
+            const format = detectFormats ? (0, detect_format_1.detectFormat)(text) : null;
+            if (format) {
+                warnings.push({
+                    type: 'ambiguous-format',
+                    file: filePath,
+                    line: path.node.loc?.start.line,
+                    message: `Detected ${format.class} format: "${text}". Will be replaced with Intl.* API call.`,
+                    severity: 'warning',
+                    dismissible: true,
+                });
+            }
+            else {
+                if (/[€$£¥]/.test(text) || /\d[.,]\d{2}\b/.test(text) || /\b\d{1,3}(,\d{3})+\b/.test(text)) {
+                    warnings.push({
+                        type: 'hardcoded-currency',
+                        file: filePath,
+                        line: path.node.loc?.start.line,
+                        message: 'Hardcoded currency/number format detected. Use Intl.NumberFormat.',
+                    });
+                }
+                if (/(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20)\d\d/.test(text) ||
+                    /\b(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])\b/.test(text)) {
+                    warnings.push({
+                        type: 'hardcoded-date',
+                        file: filePath,
+                        line: path.node.loc?.start.line,
+                        message: 'Hardcoded date format detected. Use Intl.DateTimeFormat.',
+                    });
+                }
+            }
+            if ((0, string_utils_1.isLikelyPlural)(text, variables)) {
+                warnings.push({
+                    type: 'hardcoded-plural',
+                    file: filePath,
+                    line: path.node.loc?.start.line,
+                    message: 'Hardcoded plural structure detected. Consider using structured plural keys (key_one, key_other).',
+                });
+            }
+            let parent = path.parentPath;
+            while (parent) {
+                if (parent.isJSXAttribute()) {
+                    const nameNode = parent.node.name;
+                    if (ast_helpers_1.t.isJSXIdentifier(nameNode) && !types_1.JSX_TRANSLATABLE_ATTRS.includes(nameNode.name)) {
+                        return;
+                    }
+                    break;
+                }
+                if (parent.isJSXElement() || parent.isJSXFragment())
+                    break;
+                parent = parent.parentPath;
+            }
+            if ((0, ast_helpers_1.isAlreadyTranslated)(path.node, path))
+                return;
+            const hasCurrency = (0, string_utils_1.matchesCurrencyPattern)(text);
+            const hasDate = (0, string_utils_1.matchesDatePattern)(text);
+            const isDateOrCurrencyValue = (hasCurrency || hasDate) && text.length >= 3 && !(0, string_utils_1.containsPII)(text);
+            if (!(0, string_utils_1.isTranslatableText)(text) || (0, string_utils_1.containsPII)(text) || text.length < 3) {
+                if (!isDateOrCurrencyValue && !format)
+                    return;
+            }
+            const id = `${filePath}:${path.node.loc?.start.line}:${(0, string_utils_1.hashString)(text)}`;
+            let context = 'string-literal';
+            if (format) {
+                context = 'format-string';
+            }
+            else if (isDateOrCurrencyValue && !(0, string_utils_1.isTranslatableText)(text)) {
+                context = hasCurrency ? 'hardcoded-currency' : 'hardcoded-date';
+            }
+            noteOffset(id, path.node.start);
+            if (!seenTexts.has(id)) {
+                seenTexts.add(id);
+                strings.push({
+                    text,
+                    file: filePath,
+                    line: path.node.loc?.start.line || 0,
+                    column: path.node.loc?.start.column || 0,
+                    context,
+                    id,
+                    detectedFormat: format ?? undefined,
+                });
+            }
+        };
+        (0, ast_helpers_1.traverse)(ast, {
+            'JSXElement|JSXFragment'(path) {
+                if (!groupSentences || consumed.has(path.node))
+                    return;
+                if ((0, ast_helpers_1.isAlreadyTranslated)(path.node, path))
+                    return;
+                const result = (0, jsx_message_1.buildJsxMessage)(path.node, { plurals: options?.plurals !== false });
+                if (result.kind === 'none')
+                    return;
+                // Rich text needs a component (t.rich / <Trans>); module-level JSX only
+                // gets the plain t() of the vanilla strategy, so keep its fragments.
+                if (result.kind === 'message' && (0, jsx_message_1.hasTags)(result.message) && !(0, ast_helpers_1.isInsideComponent)(path))
+                    return;
+                const line = path.node.loc?.start.line || 0;
+                if (result.kind === 'unsafe') {
+                    warnings.push({
+                        type: 'complex-expression',
+                        file: filePath,
+                        line,
+                        message: `Sentence kept as separate fragments: ${result.reason}. Translations can't reorder words around it.`,
+                        severity: 'warning',
+                        dismissible: true,
+                    });
+                    return;
+                }
+                const { message } = result;
+                for (const node of message.consumed)
+                    consumed.add(node);
+                const id = `${filePath}:${line}:${(0, string_utils_1.hashString)(message.text)}`;
+                noteOffset(id, path.node.start);
+                if (seenTexts.has(id))
+                    return;
+                seenTexts.add(id);
+                strings.push({
+                    text: message.text,
+                    file: filePath,
+                    line,
+                    column: path.node.loc?.start.column || 0,
+                    context: 'jsx-text',
+                    id,
+                    variables: message.entries.filter((e) => e.kind === 'placeholder').map((e) => e.name),
+                    icuMessage: true,
+                });
+            },
+            JSXText(path) {
+                if (consumed.has(path.node))
+                    return;
+                const text = (0, ast_helpers_1.extractJSXTextContent)(path.node);
+                if (!text || (0, string_utils_1.containsPII)(text))
+                    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 (format) {
+                    warnings.push({
+                        type: 'ambiguous-format',
+                        file: filePath,
+                        line: path.node.loc?.start.line,
+                        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: filePath,
+                            line: path.node.loc?.start.line,
+                            message: 'Hardcoded currency/number format detected. Use Intl.NumberFormat.',
+                        });
+                    }
+                    if (hasDate) {
+                        warnings.push({
+                            type: 'hardcoded-date',
+                            file: filePath,
+                            line: path.node.loc?.start.line,
+                            message: 'Hardcoded date format detected. Use Intl.DateTimeFormat.',
+                        });
+                    }
+                }
+                if ((0, ast_helpers_1.isAlreadyTranslated)(path.node, path))
+                    return;
+                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 ctx = (0, ast_helpers_1.getParentContext)(path);
+                const id = `${filePath}:${path.node.loc?.start.line}:${(0, string_utils_1.hashString)(text)}`;
+                // Dedup by location, not by text: identical labels rendered at
+                // different lines must all be extracted so every occurrence is
+                // injected, not just the first.
+                noteOffset(id, path.node.start);
+                if (!seenTexts.has(id)) {
+                    seenTexts.add(id);
+                    strings.push({
+                        text,
+                        file: filePath,
+                        line: path.node.loc?.start.line || 0,
+                        column: path.node.loc?.start.column || 0,
+                        context,
+                        id,
+                        parentContext: ctx?.parentContext,
+                        siblingGroupId: ctx?.siblingGroupId,
+                        detectedFormat: format ?? undefined,
+                    });
+                }
+            },
+            JSXAttribute(path) {
+                const name = path.node.name;
+                if (!ast_helpers_1.t.isJSXIdentifier(name))
+                    return;
+                if (!types_1.JSX_TRANSLATABLE_ATTRS.includes(name.name))
+                    return;
+                const value = path.node.value;
+                if (!ast_helpers_1.t.isStringLiteral(value))
+                    return;
+                const text = value.value.trim();
+                if (!text || !(0, string_utils_1.isTranslatableText)(text) || (0, string_utils_1.containsPII)(text))
+                    return;
+                if ((0, ast_helpers_1.isAlreadyTranslated)(path.node, path))
+                    return;
+                const id = `${filePath}:${path.node.loc?.start.line}:${(0, string_utils_1.hashString)(text)}`;
+                noteOffset(id, path.node.start);
+                if (!seenTexts.has(id)) {
+                    seenTexts.add(id);
+                    strings.push({
+                        text,
+                        file: filePath,
+                        line: path.node.loc?.start.line || 0,
+                        column: path.node.loc?.start.column || 0,
+                        context: 'jsx-attr',
+                        id,
+                    });
+                }
+            },
+            ObjectProperty(path) {
+                if (filePath.endsWith('.jsx') || filePath.endsWith('.tsx'))
+                    return;
+                if (!ast_helpers_1.t.isStringLiteral(path.node.value))
+                    return;
+                if (isInJSXContext(path))
+                    return;
+                if ((0, ast_helpers_1.isNonTranslatableContext)(path))
+                    return;
+                const text = path.node.value.value.trim();
+                if (!(0, string_utils_1.matchesCurrencyPattern)(text) && !(0, string_utils_1.matchesDatePattern)(text) && !(0, ui_copy_1.isUiCopyLiteral)(path.node.value, path.node, text))
+                    return;
+                const hasCurrency = (0, string_utils_1.matchesCurrencyPattern)(text);
+                const hasDate = (0, string_utils_1.matchesDatePattern)(text);
+                const isDateOrCurrencyValue = (hasCurrency || hasDate) && text.length >= 3 && !(0, string_utils_1.containsPII)(text);
+                const format = detectFormats ? (0, detect_format_1.detectFormat)(text) : null;
+                if (!(0, string_utils_1.isTranslatableText)(text) || (0, string_utils_1.containsPII)(text) || text.length < 3) {
+                    if (!isDateOrCurrencyValue && !format)
+                        return;
+                }
+                if (format) {
+                    warnings.push({
+                        type: 'ambiguous-format',
+                        file: filePath,
+                        line: path.node.loc?.start.line,
+                        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: filePath,
+                            line: path.node.loc?.start.line,
+                            message: 'Hardcoded currency/number format detected. Use Intl.NumberFormat.',
+                        });
+                    }
+                    if (hasDate) {
+                        warnings.push({
+                            type: 'hardcoded-date',
+                            file: filePath,
+                            line: path.node.loc?.start.line,
+                            message: 'Hardcoded date format detected. Use Intl.DateTimeFormat.',
+                        });
+                    }
+                }
+                if ((0, string_utils_1.isLikelyPlural)(text, [])) {
+                    warnings.push({
+                        type: 'hardcoded-plural',
+                        file: filePath,
+                        line: path.node.loc?.start.line,
+                        message: 'Hardcoded plural structure detected. Consider using structured plural keys (key_one, key_other).',
+                    });
+                }
+                if ((0, ast_helpers_1.isAlreadyTranslated)(path.node, path))
+                    return;
+                const id = `${filePath}:${path.node.loc?.start.line}:${(0, string_utils_1.hashString)(text)}`;
+                let context = 'string-literal';
+                if (format) {
+                    context = 'format-string';
+                }
+                else if (isDateOrCurrencyValue && !(0, string_utils_1.isTranslatableText)(text)) {
+                    context = hasCurrency ? 'hardcoded-currency' : 'hardcoded-date';
+                }
+                noteOffset(id, path.node.value.start);
+                if (!seenTexts.has(id)) {
+                    seenTexts.add(id);
+                    strings.push({
+                        text,
+                        file: filePath,
+                        line: path.node.loc?.start.line || 0,
+                        column: path.node.loc?.start.column || 0,
+                        context,
+                        id,
+                        detectedFormat: format ?? undefined,
+                    });
+                }
+            },
+            StringLiteral(path) {
+                processExtractedText(path.node.value, path);
+            },
+            TemplateLiteral(path) {
+                const variables = [];
+                const text = (0, ast_helpers_1.extractExpressionContent)(path.node, variables);
+                processExtractedText(text, path, variables);
+            },
+            BinaryExpression(path) {
+                if (path.node.operator === '+') {
+                    const variables = [];
+                    const text = (0, ast_helpers_1.extractExpressionContent)(path.node, variables);
+                    if (text && text.length > 2)
+                        processExtractedText(text, path, variables);
+                }
+            },
+            ConditionalExpression(path) {
+                const content = (0, ast_helpers_1.extractConditionalContent)(path.node);
+                if (content.consequent)
+                    processExtractedText(content.consequent, path.get('consequent'));
+                if (content.alternate)
+                    processExtractedText(content.alternate, path.get('alternate'));
+            },
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    for (const s of strings) {
+        const offsets = offsetsById.get(s.id);
+        if (offsets)
+            s.offsets = offsets;
+    }
+    return { strings, warnings, notInjected: unwired };
+}
+/**
+ * Extract strings from a Vue Single File Component (SFC).
+ * Splits the SFC into template and script sections, extracts strings
+ * from each using the appropriate extractor, and merges results.
+ */
+async function extractStringsFromVueSfc(content, filePath, detectFormats) {
+    const allStrings = [];
+    const allWarnings = [];
+    const seenSources = new Set();
+    const templateMatch = (0, string_utils_1.extractBalancedTag)(content, 'template', true);
+    const scriptMatch = content.match(/<script([^>]*)>([\s\S]*?)<\/script>/);
+    // Extract from template section
+    if (templateMatch) {
+        const templateContent = templateMatch.body;
+        const lines = templateContent.split('\n');
+        const templateResult = extractVueTemplateStrings(lines, filePath, seenSources, detectFormats);
+        allStrings.push(...templateResult.strings);
+        allWarnings.push(...templateResult.warnings);
+    }
+    // Extract from script section
+    if (scriptMatch) {
+        const scriptAttrs = scriptMatch[1];
+        const scriptContent = scriptMatch[2];
+        const hasTs = /\blang\s*=\s*["'](?:ts|typescript)["']/.test(scriptAttrs);
+        const virtualPath = filePath.replace(/\.vue$/, hasTs ? '.ts' : '.js');
+        // Wrap script content in a component function so the component guard
+        // correctly identifies top-level declarations as component-scoped.
+        const result = await extractStringsFromFile(scriptContent, virtualPath, detectFormats, { relaxComponentGuard: true });
+        for (const s of result.strings) {
+            const vueId = s.id.replace(virtualPath, filePath);
+            if (!seenSources.has(vueId)) {
+                seenSources.add(vueId);
+                allStrings.push({ ...s, file: filePath, id: vueId });
+            }
+        }
+        allWarnings.push(...result.warnings);
+    }
+    return { strings: allStrings, warnings: allWarnings };
+}
+const HTML_TEXT_RE = /<([a-zA-Z][a-zA-Z0-9]*)(?:\s[^>]*)?>([^<]+?)<\/\1>/gs;
+const HTML_ATTR_RE = /\b(alt|title|placeholder|aria-label|aria-description)\s*=\s*"([^"]*?)"/g;
+const VUE_INTERPOLATION_SQ_RE = /{{\s*'([^']+)'\s*}}/g;
+const VUE_INTERPOLATION_DQ_RE = /{{\s*"([^"]+)"\s*}}/g;
+const VUE_MUSTACHE_RE = /{{\s*([^}]+?)\s*}}/g;
+const SKIP_TAGS = new Set(['script', 'style', 'noscript', 'code', 'pre', 'svg']);
+function extractVueTemplateStrings(lines, filePath, seenSources, detectFormats) {
+    const strings = [];
+    const warnings = [];
+    const addString = (text, lineOffset, context) => {
+        const trimmed = text.trim();
+        if (!trimmed || trimmed.length < 2)
+            return;
+        if (!(0, string_utils_1.isTranslatableText)(trimmed))
+            return;
+        if ((0, string_utils_1.containsPII)(trimmed))
+            return;
+        const hasCurrency = (0, string_utils_1.matchesCurrencyPattern)(trimmed);
+        const hasDate = (0, string_utils_1.matchesDatePattern)(trimmed);
+        const isDateOrCurrencyValue = (hasCurrency || hasDate) && trimmed.length >= 3;
+        const format = detectFormats ? (0, detect_format_1.detectFormat)(trimmed) : null;
+        if (!(0, string_utils_1.isTranslatableText)(trimmed) && !isDateOrCurrencyValue && !format)
+            return;
+        if (format) {
+            warnings.push({
+                type: 'ambiguous-format',
+                file: filePath,
+                line: lineOffset,
+                message: `Detected ${format.class} format: "${trimmed}". Will be replaced with Intl.* API call.`,
+                severity: 'warning',
+                dismissible: true,
+            });
+        }
+        else {
+            if (hasCurrency) {
+                warnings.push({
+                    type: 'hardcoded-currency',
+                    file: filePath,
+                    line: lineOffset,
+                    message: 'Hardcoded currency/number format detected. Use Intl.NumberFormat.',
+                });
+            }
+            if (hasDate) {
+                warnings.push({
+                    type: 'hardcoded-date',
+                    file: filePath,
+                    line: lineOffset,
+                    message: 'Hardcoded date format detected. Use Intl.DateTimeFormat.',
+                });
+            }
+        }
+        const contentKey = `${filePath}:${(0, string_utils_1.hashString)(trimmed)}`;
+        if (seenSources.has(contentKey))
+            return;
+        seenSources.add(contentKey);
+        const id = `${filePath}:${lineOffset}:${(0, string_utils_1.hashString)(trimmed)}`;
+        let effectiveContext = context;
+        if (format) {
+            effectiveContext = 'format-string';
+        }
+        else if (isDateOrCurrencyValue && !(0, string_utils_1.isTranslatableText)(trimmed)) {
+            effectiveContext = hasCurrency ? 'hardcoded-currency' : 'hardcoded-date';
+        }
+        strings.push({ text: trimmed, file: filePath, line: lineOffset, column: 0, context: effectiveContext, id, detectedFormat: format ?? undefined });
+    };
+    const content = lines.join('\n');
+    let match;
+    HTML_TEXT_RE.lastIndex = 0;
+    while ((match = HTML_TEXT_RE.exec(content)) !== null) {
+        const tagName = match[1].toLowerCase();
+        if (SKIP_TAGS.has(tagName))
+            continue;
+        // Normalize {{ var }} interpolations to {var} so translators see a
+        // placeholder instead of raw Mustache syntax.
+        const normalized = match[2].replace(VUE_MUSTACHE_RE, (_, name) => `{${name.trim()}}`);
+        const text = normalized.trim();
+        if (text) {
+            const line = content.substring(0, match.index).split('\n').length;
+            addString(text, line, 'jsx-text');
+        }
+    }
+    HTML_ATTR_RE.lastIndex = 0;
+    while ((match = HTML_ATTR_RE.exec(content)) !== null) {
+        const text = match[2].trim();
+        if (text) {
+            const line = content.substring(0, match.index).split('\n').length;
+            addString(text, line, 'jsx-attr');
+        }
+    }
+    VUE_INTERPOLATION_SQ_RE.lastIndex = 0;
+    while ((match = VUE_INTERPOLATION_SQ_RE.exec(content)) !== null) {
+        const text = match[1].trim();
+        if (text) {
+            const line = content.substring(0, match.index).split('\n').length;
+            addString(text, line, 'jsx-text');
+        }
+    }
+    VUE_INTERPOLATION_DQ_RE.lastIndex = 0;
+    while ((match = VUE_INTERPOLATION_DQ_RE.exec(content)) !== null) {
+        const text = match[1].trim();
+        if (text) {
+            const line = content.substring(0, match.index).split('\n').length;
+            addString(text, line, 'jsx-text');
+        }
+    }
+    return { strings, warnings };
+}
+function isInJSXContext(path) {
+    let current = path.parentPath;
+    while (current) {
+        if (current.isJSXElement() ||
+            current.isJSXFragment() ||
+            current.isJSXExpressionContainer() ||
+            current.isJSXAttribute()) {
+            return true;
+        }
+        current = current.parentPath;
+    }
+    return false;
+}