versacompiler 2.1.0 → 2.2.0

package/dist/compiler/typescript-compiler.js

@@ -1,2 +1,172 @@
-import e from"node:fs";import i from"node:path";import*as a from"node:process";import{env as o}from"node:process";import*as s from"typescript";import{createUnifiedErrorMessage as c,parseTypeScriptErrors as l}from"./typescript-error-parser.js";import{validateTypesWithLanguageService as u}from"./typescript-sync-validator.js";import{TypeScriptWorkerManager as d}from"./typescript-worker.js";let f={};export const loadTypeScriptConfig=o=>{let c=i.dirname(o),l=s.findConfigFile(c,s.sys.fileExists,`tsconfig.json`)||i.resolve(a.cwd(),`tsconfig.json`);if(f.path===l&&f.options)return f.options;let u;if(l&&e.existsSync(l))try{let{config:e,error:a}=s.readConfigFile(l,s.sys.readFile);if(!a)u=s.parseJsonConfigFileContent(e,s.sys,i.dirname(l)).options;else throw Error(`Error al leer tsconfig.json: ${a.messageText}`)}catch(e){console.warn(`[loadTypeScriptConfig] Error cargando ${l}:`,e),u=p()}else u=p();return f={path:l,options:u},u};const p=()=>({target:s.ScriptTarget.ES2020,module:s.ModuleKind.ES2020,lib:[`es2020`,`dom`,`dom.iterable`],strict:!1,skipLibCheck:!0,allowJs:!0,esModuleInterop:!0,allowSyntheticDefaultImports:!0,isolatedModules:!0}),m=e=>({...e,declaration:!1,sourceMap:!1});export const validateVueTypes=(e,i)=>u(i,e,loadTypeScriptConfig(i));export const preCompileTS=async(e,i)=>{try{if(!e.trim())return{error:null,data:e,lang:`ts`};let a=loadTypeScriptConfig(i),u=s.transpileModule(e,{compilerOptions:{...a,noLib:!0,skipLibCheck:!0,isolatedModules:!0},fileName:i,reportDiagnostics:!0});if(u.diagnostics?.length){let a=u.diagnostics.filter(e=>{if(e.category!==s.DiagnosticCategory.Error)return!1;let i=s.flattenDiagnosticMessageText(e.messageText,`
-`);return!i.includes(`Cannot find module`)&&!i.includes(`Could not find source file`)&&e.code!==2307&&e.code!==6059});if(a.length>0){let o=c(l(a,i,e));return{error:Error(o),data:null,lang:`ts`}}}if(o.typeCheck===`true`)try{let o=d.getInstance(),s=m(a),u=await o.typeCheck(i,e,s);if(u.hasErrors){let a=c(l(u.diagnostics,i,e));return{error:Error(a),data:null,lang:`ts`}}}catch(e){console.warn(`[preCompileTS] Type checking failed:`,e)}let f=u.outputText;return f.trim()===`export {};`?{error:null,data:``,lang:`ts`}:{error:null,data:f,lang:`ts`}}catch(e){return{error:e instanceof Error?e:Error(`Error desconocido`),data:null,lang:`ts`}}};
+import fs from 'node:fs';
+import path from 'node:path';
+import * as process from 'node:process';
+import { env } from 'node:process';
+import * as typescript from 'typescript';
+import { createUnifiedErrorMessage, parseTypeScriptErrors, } from './typescript-error-parser.js';
+import { validateTypesWithLanguageService } from './typescript-sync-validator.js';
+import { TypeScriptWorkerManager } from './typescript-worker.js';
+/**
+ * Cache para la configuración de TypeScript para evitar lecturas repetidas
+ */
+let configCache = {};
+/**
+ * Carga la configuración de TypeScript desde tsconfig.json
+ * @param fileName - Nombre del archivo para buscar el tsconfig.json relativo
+ * @returns Opciones del compilador TypeScript
+ */
+export const loadTypeScriptConfig = (fileName) => {
+    const fileDir = path.dirname(fileName);
+    const configPath = typescript.findConfigFile(fileDir, typescript.sys.fileExists, 'tsconfig.json') || path.resolve(process.cwd(), 'tsconfig.json');
+    // Usar cache si el path no ha cambiado
+    if (configCache.path === configPath && configCache.options) {
+        return configCache.options;
+    }
+    let compilerOptions;
+    if (configPath && fs.existsSync(configPath)) {
+        try {
+            const { config, error: configError } = typescript.readConfigFile(configPath, typescript.sys.readFile);
+            if (!configError) {
+                const parsedConfig = typescript.parseJsonConfigFileContent(config, typescript.sys, path.dirname(configPath)); // Usar exactamente la configuración del tsconfig.json del usuario
+                compilerOptions = parsedConfig.options;
+            }
+            else {
+                throw new Error(`Error al leer tsconfig.json: ${configError.messageText}`);
+            }
+        }
+        catch (error) {
+            console.warn(`[loadTypeScriptConfig] Error cargando ${configPath}:`, error);
+            // Fallback a opciones por defecto
+            compilerOptions = getDefaultCompilerOptions();
+        }
+    }
+    else {
+        // Opciones por defecto si no se encuentra tsconfig.json
+        compilerOptions = getDefaultCompilerOptions();
+    }
+    // Guardar en cache
+    configCache = { path: configPath, options: compilerOptions };
+    return compilerOptions;
+};
+/**
+ * Obtiene las opciones por defecto del compilador TypeScript
+ */
+const getDefaultCompilerOptions = () => ({
+    target: typescript.ScriptTarget.ES2020,
+    module: typescript.ModuleKind.ES2020,
+    lib: ['es2020', 'dom', 'dom.iterable'],
+    strict: false,
+    skipLibCheck: true,
+    allowJs: true,
+    esModuleInterop: true,
+    allowSyntheticDefaultImports: true,
+    isolatedModules: true,
+});
+/**
+ * Crea una versión optimizada y serializable de las opciones del compilador typescript.
+ * @param options - Opciones originales del compilador
+ * @returns Opciones serializables seguras para workers
+ */
+const createSerializableCompilerOptions = (options) => {
+    // Respetar completamente la configuración del usuario del tsconfig.json
+    return {
+        ...options,
+        // NO modificar configuraciones del usuario - solo optimizaciones internas del worker que no afectan la validación
+        declaration: false, // No necesitamos declaraciones en el worker
+        sourceMap: false, // No necesitamos source maps en el worker
+    };
+};
+/**
+ * Valida tipos en archivos Vue antes de la compilación
+ * @param vueContent - Contenido del archivo Vue
+ * @param fileName - Nombre del archivo Vue
+ * @returns Resultado de la validación de tipos
+ */
+export const validateVueTypes = (vueContent, fileName) => {
+    const compilerOptions = loadTypeScriptConfig(fileName);
+    return validateTypesWithLanguageService(fileName, vueContent, compilerOptions);
+};
+/**
+ * Precompila el código TypeScript con pipeline optimizado para máxima performance.
+ * @param {string} data - El código TypeScript a precompilar.
+ * @param {string} fileName - El nombre del archivo que contiene el código typescript.
+ * @returns {Promise<CompileResult>} - Un objeto con el código precompilado o un error.
+ */
+export const preCompileTS = async (data, fileName) => {
+    try {
+        // Validación temprana: contenido vacío
+        if (!data.trim()) {
+            return { error: null, data: data, lang: 'ts' };
+        }
+        // Cargar configuración de TypeScript desde tsconfig.json
+        const compilerOptions = loadTypeScriptConfig(fileName); // PASO 1: Transpilación rápida con detección de errores críticos
+        const transpileResult = typescript.transpileModule(data, {
+            compilerOptions: {
+                ...compilerOptions,
+                noLib: true,
+                skipLibCheck: true,
+                isolatedModules: true,
+            },
+            fileName,
+            reportDiagnostics: true,
+        });
+        // const transpileResult = traspileTStoJS(
+        //     fileName,data)
+        // Verificar errores críticos de sintaxis
+        if (transpileResult.diagnostics?.length) {
+            const criticalErrors = transpileResult.diagnostics.filter((diag) => {
+                if (diag.category !== typescript.DiagnosticCategory.Error)
+                    return false;
+                const messageText = typescript.flattenDiagnosticMessageText(diag.messageText, '\n');
+                // Ignorar errores de módulo no encontrado
+                return (!messageText.includes('Cannot find module') &&
+                    !messageText.includes('Could not find source file') &&
+                    diag.code !== 2307 &&
+                    diag.code !== 6059);
+            });
+            if (criticalErrors.length > 0) {
+                const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(criticalErrors, fileName, data));
+                return {
+                    error: new Error(errorMessage),
+                    data: null,
+                    lang: 'ts',
+                };
+            }
+        }
+        // PASO 2: Type checking opcional (solo si está habilitado)
+        if (env.typeCheck === 'true') {
+            try {
+                const workerManager = TypeScriptWorkerManager.getInstance();
+                const serializableOptions = createSerializableCompilerOptions(compilerOptions);
+                const typeCheckResult = await workerManager.typeCheck(fileName, data, serializableOptions);
+                if (typeCheckResult.hasErrors) {
+                    const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(typeCheckResult.diagnostics, fileName, data));
+                    return {
+                        error: new Error(errorMessage),
+                        data: null,
+                        lang: 'ts',
+                    };
+                }
+            }
+            catch (typeCheckError) {
+                // Type checking falla, pero continuar con transpilación
+                console.warn('[preCompileTS] Type checking failed:', typeCheckError);
+            }
+        }
+        // PASO 3: Devolver resultado optimizado
+        const output = transpileResult.outputText;
+        // Limpiar output vacío
+        if (output.trim() === 'export {};') {
+            return { error: null, data: '', lang: 'ts' };
+        }
+        return { error: null, data: output, lang: 'ts' };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error : new Error('Error desconocido'),
+            data: null,
+            lang: 'ts',
+        };
+    }
+};
+//# sourceMappingURL=typescript-compiler.js.map

package/dist/compiler/typescript-error-parser.js

@@ -1,10 +1,281 @@
-import*as e from"typescript";export function parseTypeScriptErrors(t,n,i){return t.map(t=>{let a=r(t,n,i),o;switch(t.category){case e.DiagnosticCategory.Error:o=`error`;break;case e.DiagnosticCategory.Warning:o=`warning`;break;default:o=`info`;break}let s=`Código TS${t.code}`;if(t.file&&t.start!==void 0){let e=t.file;if(typeof e.getLineAndCharacterOfPosition==`function`)try{let n=e.getLineAndCharacterOfPosition(t.start);s+=` | Línea ${n.line+1}, Columna ${n.character+1}`}catch{s+=` | Posición ${t.start}`}else s+=` | Posición ${t.start}`}return{file:n,message:a,severity:o,help:s}})}function n(e){return e.replace(/^error TS\d+:\s*/i,``).replace(/^.*\.ts\(\d+,\d+\):\s*/,``).replace(/\s+/g,` `).trim()}function r(t,r,a){let o=n(typeof t.messageText==`string`?t.messageText:e.flattenDiagnosticMessageText(t.messageText,`
-`)),s=`Código TS${t.code}`,c=``;if(t.file&&t.start!==void 0){let e=t.file;if(typeof e.getLineAndCharacterOfPosition==`function`)try{let n=e.getLineAndCharacterOfPosition(t.start);s=`Línea ${n.line+1}, Columna ${n.character+1} | Código TS${t.code}`}catch{s=`Posición ${t.start} | Código TS${t.code}`}else s=`Posición ${t.start} | Código TS${t.code}`;if((a||e.text)&&typeof e.getLineAndCharacterOfPosition==`function`)try{let n=e.getLineAndCharacterOfPosition(t.start),r=(a||e.text).split(`
-`);if(r[n.line]){let e=Math.max(0,n.line-2),t=Math.min(r.length-1,n.line+2);c=`
-
-📝 Contexto del código:
-`;for(let i=e;i<=t;i++){let e=i+1,t=r[i]||``;if(i===n.line){c+=`  ${e.toString().padStart(3,` `)} ❌ ${t}\n`;let r=` `.repeat(6+n.character+1)+`^^^`;c+=`       ${r}\n`}else c+=`  ${e.toString().padStart(3,` `)}    ${t}\n`}}}catch{}}let l=i(t.code,o),u=l.length>0?`\n\n💡 Sugerencias:\n${l.map(e=>`   • ${e}`).join(`
-`)}`:``;return`${o}\n   📍 ${s}${c}${u}`}function i(e,t){let n=[];switch(e){case 2304:n.push(`Verifica que la variable esté declarada`),n.push(`Asegúrate de importar el módulo correspondiente`),n.push(`Revisa la ortografía del nombre`);break;case 2322:n.push(`Verifica que los tipos sean compatibles`),n.push(`Considera usar type assertion: valor as TipoEsperado`);break;case 2307:n.push(`Verifica que el archivo exista en la ruta especificada`),n.push(`Revisa las rutas en tsconfig.json`),n.push(`Asegúrate de que el paquete esté instalado`);break;case 2451:n.push(`Cambia el nombre de la variable`),n.push(`Usa un scope diferente (function, block)`);break;case 7006:n.push(`Agrega tipos explícitos a los parámetros`),n.push(`Considera habilitar "noImplicitAny": false en tsconfig.json`);break;case 1155:n.push(`Agrega un valor inicial: const variable = valor;`),n.push(`O cambia a "let" si quieres asignar después`);break;case 2339:n.push(`Verifica que la propiedad exista en el tipo`),n.push(`Considera usar optional chaining: objeto?.propiedad`);break;default:t.includes(`Cannot find`)&&n.push(`Verifica que el elemento exista y esté importado`),t.includes(`Type`)&&n.push(`Revisa la compatibilidad de tipos`),t.includes(`missing`)&&n.push(`Agrega el elemento faltante`);break}return n}export function createUnifiedErrorMessage(e){if(e.length===0)return`Error de TypeScript desconocido`;if(e.length===1){let t=e[0];return t?`${t.message}\n  └─ ${t.help}`:`Error de TypeScript desconocido`}let t=e.filter(e=>e.severity===`error`).length,n=e.filter(e=>e.severity===`warning`).length,r=e.slice(0,10),i=e.length>10,a=``,o=``;if(t>0&&(o+=`${t} error${t>1?`es`:``}`),n>0&&(o&&(o+=`, `),o+=`${n} advertencia${n>1?`s`:``}`),a+=`TypeScript: ${o} encontrado${t+n>1?`s`:``}:\n\n`,r.forEach((e,t)=>{let n=e.severity===`error`?`❌`:e.severity===`warning`?`⚠️`:`ℹ️`;a+=`${n} ${e.message}\n`,a+=`   └─ ${e.help}\n`,t<r.length-1&&(a+=`
-`)}),i){let t=e.length-10;a+=`\n... y ${t} error${t>1?`es`:``} más`}return a}export function createSimpleErrorMessage(t,n){if(t.length===0)return``;let r=t[0];if(!r)return``;let i=e.flattenDiagnosticMessageText(r.messageText,`
-`).split(`
-`)[0],a=``;if(r.file&&r.start!==void 0){let e=r.file;if(typeof e.getLineAndCharacterOfPosition==`function`)try{a=` (línea ${e.getLineAndCharacterOfPosition(r.start).line+1})`}catch{}}let o=t.length,s=o>1?` (+${o-1} más)`:``;return`${i}${a}${s}`}export function createDetailedErrorMessage(e,n,r){return createUnifiedErrorMessage(parseTypeScriptErrors(e,n,r))}export function registerCleanTypeScriptErrors(e,n,r){parseTypeScriptErrors(e,n).forEach(e=>{r(e.file,e.message,e.severity,e.help)})}
+import * as typescript from 'typescript';
+/**
+ * Parsea errores de TypeScript y los convierte a un formato limpio
+ * que incluye solo: archivo, mensaje, severidad y ubicación como ayuda
+ */
+export function parseTypeScriptErrors(diagnostics, fileName, sourceCode) {
+    return diagnostics.map(diagnostic => {
+        // Usar el mejorador de errores para obtener mensaje detallado
+        const enhancedMessage = enhanceErrorMessage(diagnostic, fileName, sourceCode); // Determinar la severidad
+        let severity;
+        switch (diagnostic.category) {
+            case typescript.DiagnosticCategory.Error:
+                severity = 'error';
+                break;
+            case typescript.DiagnosticCategory.Warning:
+                severity = 'warning';
+                break;
+            default:
+                severity = 'info';
+                break;
+        } // Construir información de ubicación limpia
+        let help = `Código TS${diagnostic.code}`;
+        if (diagnostic.file && diagnostic.start !== undefined) {
+            const sourceFile = diagnostic.file;
+            // Verificar que el método getLineAndCharacterOfPosition existe (para compatibilidad con mocks)
+            if (typeof sourceFile.getLineAndCharacterOfPosition === 'function') {
+                try {
+                    const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
+                    help += ` | Línea ${lineAndChar.line + 1}, Columna ${lineAndChar.character + 1}`;
+                }
+                catch {
+                    // Si falla, solo mostrar la posición de carácter
+                    help += ` | Posición ${diagnostic.start}`;
+                }
+            }
+            else {
+                // Fallback para cuando no está disponible el método (como en tests)
+                help += ` | Posición ${diagnostic.start}`;
+            }
+        }
+        return {
+            file: fileName,
+            message: enhancedMessage,
+            severity,
+            help,
+        };
+    });
+}
+/**
+ * Limpia el mensaje de error eliminando información redundante
+ */
+function cleanErrorMessage(message) {
+    return (message
+        // Remover prefijos verbosos
+        .replace(/^error TS\d+:\s*/i, '')
+        // Remover información de archivo duplicada al inicio
+        .replace(/^.*\.ts\(\d+,\d+\):\s*/, '')
+        // Limpiar espacios múltiples
+        .replace(/\s+/g, ' ')
+        .trim());
+}
+/**
+ * Mejora significativamente el mensaje de error TypeScript con contexto visual
+ */
+function enhanceErrorMessage(diagnostic, fileName, sourceCode) {
+    // Extraer el mensaje del error
+    const message = typeof diagnostic.messageText === 'string'
+        ? diagnostic.messageText
+        : typescript.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+    const enhancedMessage = cleanErrorMessage(message); // Información de ubicación
+    let location = `Código TS${diagnostic.code}`;
+    let codeContext = '';
+    if (diagnostic.file && diagnostic.start !== undefined) {
+        const sourceFile = diagnostic.file;
+        // Verificar que el método getLineAndCharacterOfPosition existe (para compatibilidad con mocks)
+        if (typeof sourceFile.getLineAndCharacterOfPosition === 'function') {
+            try {
+                const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
+                const line = lineAndChar.line + 1;
+                const column = lineAndChar.character + 1;
+                location = `Línea ${line}, Columna ${column} | Código TS${diagnostic.code}`;
+            }
+            catch {
+                // Si falla, solo mostrar la posición de carácter
+                location = `Posición ${diagnostic.start} | Código TS${diagnostic.code}`;
+            }
+        }
+        else {
+            // Fallback para cuando no está disponible el método (como en tests)
+            location = `Posición ${diagnostic.start} | Código TS${diagnostic.code}`;
+        } // Agregar contexto del código si está disponible
+        if ((sourceCode || sourceFile.text) &&
+            typeof sourceFile.getLineAndCharacterOfPosition === 'function') {
+            try {
+                const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
+                const text = sourceCode || sourceFile.text;
+                const lines = text.split('\n');
+                const errorLine = lines[lineAndChar.line];
+                if (errorLine) {
+                    // Mostrar hasta 2 líneas antes y después para contexto
+                    const startLine = Math.max(0, lineAndChar.line - 2);
+                    const endLine = Math.min(lines.length - 1, lineAndChar.line + 2);
+                    codeContext = '\n\n📝 Contexto del código:\n';
+                    for (let i = startLine; i <= endLine; i++) {
+                        const currentLine = i + 1;
+                        const lineContent = lines[i] || '';
+                        const isErrorLine = i === lineAndChar.line;
+                        if (isErrorLine) {
+                            codeContext += `  ${currentLine.toString().padStart(3, ' ')} ❌ ${lineContent}\n`;
+                            // Agregar flecha apuntando al error
+                            const arrow = ' '.repeat(6 + lineAndChar.character + 1) +
+                                '^^^';
+                            codeContext += `       ${arrow}\n`;
+                        }
+                        else {
+                            codeContext += `  ${currentLine.toString().padStart(3, ' ')}    ${lineContent}\n`;
+                        }
+                    }
+                }
+            }
+            catch {
+                // Si falla obtener el contexto, continuar sin él
+            }
+        }
+    }
+    // Agregar sugerencias basadas en el tipo de error
+    const suggestions = getErrorSuggestions(diagnostic.code, enhancedMessage);
+    const suggestionsText = suggestions.length > 0
+        ? `\n\n💡 Sugerencias:\n${suggestions.map(s => `   • ${s}`).join('\n')}`
+        : '';
+    return `${enhancedMessage}\n   📍 ${location}${codeContext}${suggestionsText}`;
+}
+/**
+ * Proporciona sugerencias específicas basadas en el código de error TypeScript
+ */
+function getErrorSuggestions(errorCode, message) {
+    const suggestions = [];
+    switch (errorCode) {
+        case 2304: // Cannot find name
+            suggestions.push('Verifica que la variable esté declarada');
+            suggestions.push('Asegúrate de importar el módulo correspondiente');
+            suggestions.push('Revisa la ortografía del nombre');
+            break;
+        case 2322: // Type assignment error
+            suggestions.push('Verifica que los tipos sean compatibles');
+            suggestions.push('Considera usar type assertion: valor as TipoEsperado');
+            break;
+        case 2307: // Cannot find module
+            suggestions.push('Verifica que el archivo exista en la ruta especificada');
+            suggestions.push('Revisa las rutas en tsconfig.json');
+            suggestions.push('Asegúrate de que el paquete esté instalado');
+            break;
+        case 2451: // Cannot redeclare block-scoped variable
+            suggestions.push('Cambia el nombre de la variable');
+            suggestions.push('Usa un scope diferente (function, block)');
+            break;
+        case 7006: // Parameter implicitly has 'any' type
+            suggestions.push('Agrega tipos explícitos a los parámetros');
+            suggestions.push('Considera habilitar "noImplicitAny": false en tsconfig.json');
+            break;
+        case 1155: // 'const' declarations must be initialized
+            suggestions.push('Agrega un valor inicial: const variable = valor;');
+            suggestions.push('O cambia a "let" si quieres asignar después');
+            break;
+        case 2339: // Property does not exist
+            suggestions.push('Verifica que la propiedad exista en el tipo');
+            suggestions.push('Considera usar optional chaining: objeto?.propiedad');
+            break;
+        default:
+            // Sugerencias genéricas basadas en el mensaje
+            if (message.includes('Cannot find')) {
+                suggestions.push('Verifica que el elemento exista y esté importado');
+            }
+            if (message.includes('Type')) {
+                suggestions.push('Revisa la compatibilidad de tipos');
+            }
+            if (message.includes('missing')) {
+                suggestions.push('Agrega el elemento faltante');
+            }
+            break;
+    }
+    return suggestions;
+}
+/**
+ * Crea un mensaje de error unificado para errores múltiples
+ */
+export function createUnifiedErrorMessage(errors) {
+    if (errors.length === 0) {
+        return 'Error de TypeScript desconocido';
+    }
+    if (errors.length === 1) {
+        const error = errors[0];
+        if (error) {
+            return `${error.message}\n  └─ ${error.help}`;
+        }
+        return 'Error de TypeScript desconocido';
+    }
+    const errorCount = errors.filter(e => e.severity === 'error').length;
+    const warningCount = errors.filter(e => e.severity === 'warning').length;
+    // Mostrar hasta los primeros 10 errores con detalles
+    const maxErrorsToShow = 10;
+    const errorsToShow = errors.slice(0, maxErrorsToShow);
+    const hasMoreErrors = errors.length > maxErrorsToShow;
+    let result = '';
+    // Agregar resumen
+    let summary = '';
+    if (errorCount > 0) {
+        summary += `${errorCount} error${errorCount > 1 ? 'es' : ''}`;
+    }
+    if (warningCount > 0) {
+        if (summary)
+            summary += ', ';
+        summary += `${warningCount} advertencia${warningCount > 1 ? 's' : ''}`;
+    }
+    result += `TypeScript: ${summary} encontrado${errorCount + warningCount > 1 ? 's' : ''}:\n\n`;
+    // Agregar detalles de cada error
+    errorsToShow.forEach((error, index) => {
+        const icon = error.severity === 'error'
+            ? '❌'
+            : error.severity === 'warning'
+                ? '⚠️'
+                : 'ℹ️';
+        result += `${icon} ${error.message}\n`;
+        result += `   └─ ${error.help}\n`;
+        if (index < errorsToShow.length - 1)
+            result += '\n';
+    });
+    // Si hay más errores, indicarlo
+    if (hasMoreErrors) {
+        const remainingCount = errors.length - maxErrorsToShow;
+        result += `\n... y ${remainingCount} error${remainingCount > 1 ? 'es' : ''} más`;
+    }
+    return result;
+}
+/**
+ * Crea un mensaje de error simplificado para modo normal
+ */
+export function createSimpleErrorMessage(diagnostics, _fileName) {
+    if (diagnostics.length === 0)
+        return '';
+    const firstDiagnostic = diagnostics[0];
+    if (!firstDiagnostic)
+        return '';
+    const message = typescript.flattenDiagnosticMessageText(firstDiagnostic.messageText, '\n');
+    // Extraer solo la primera línea del mensaje para simplicidad
+    const simplifiedMessage = message.split('\n')[0];
+    let location = '';
+    if (firstDiagnostic.file && firstDiagnostic.start !== undefined) {
+        const sourceFile = firstDiagnostic.file;
+        // Verificar que el método getLineAndCharacterOfPosition existe (para compatibilidad con mocks)
+        if (typeof sourceFile.getLineAndCharacterOfPosition === 'function') {
+            try {
+                const lineAndChar = sourceFile.getLineAndCharacterOfPosition(firstDiagnostic.start);
+                location = ` (línea ${lineAndChar.line + 1})`;
+            }
+            catch {
+                // Si falla, continuar sin información de ubicación
+            }
+        }
+    }
+    const errorCount = diagnostics.length;
+    const countText = errorCount > 1 ? ` (+${errorCount - 1} más)` : '';
+    return `${simplifiedMessage}${location}${countText}`;
+}
+/**
+ * Crea un mensaje de error detallado para modo verbose
+ */
+export function createDetailedErrorMessage(diagnostics, fileName, sourceCode) {
+    const cleanErrors = parseTypeScriptErrors(diagnostics, fileName, sourceCode);
+    return createUnifiedErrorMessage(cleanErrors);
+}
+/**
+ * Registra errores de TypeScript en el inventario usando el parser limpio
+ */
+export function registerCleanTypeScriptErrors(diagnostics, fileName, registerInventoryError) {
+    const cleanErrors = parseTypeScriptErrors(diagnostics, fileName);
+    cleanErrors.forEach(error => {
+        registerInventoryError(error.file, error.message, error.severity, error.help);
+    });
+}
+//# sourceMappingURL=typescript-error-parser.js.map