versacompiler 1.0.4 → 2.0.0

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

@@ -0,0 +1,282 @@
+import * as ts 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 ts.DiagnosticCategory.Error:
+                severity = 'error';
+                break;
+            case ts.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
+        : ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+    let 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 = ts.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

package/dist/compiler/typescript-sync-validator.js

@@ -0,0 +1,230 @@
+/**
+ * TypeScript Sync Validator - Validación síncrona de tipos como fallback
+ * Contiene la lógica extraída del módulo principal para cuando el worker no está disponible
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as ts from 'typescript';
+/**
+ * Language Service Host para validación de tipos eficiente
+ */
+class TypeScriptLanguageServiceHost {
+    files = new Map();
+    compilerOptions;
+    constructor(compilerOptions) {
+        this.compilerOptions = compilerOptions;
+    }
+    addFile(fileName, content) {
+        const existing = this.files.get(fileName);
+        this.files.set(fileName, {
+            version: existing ? existing.version + 1 : 1,
+            content,
+        });
+    }
+    getCompilationSettings() {
+        return this.compilerOptions;
+    }
+    getScriptFileNames() {
+        return Array.from(this.files.keys());
+    }
+    getScriptVersion(fileName) {
+        const file = this.files.get(fileName);
+        return file ? file.version.toString() : '0';
+    }
+    getScriptSnapshot(fileName) {
+        const file = this.files.get(fileName);
+        if (file) {
+            return ts.ScriptSnapshot.fromString(file.content);
+        }
+        // Intentar leer el archivo del sistema de archivos para dependencias
+        if (fs.existsSync(fileName)) {
+            try {
+                const content = fs.readFileSync(fileName, 'utf-8');
+                return ts.ScriptSnapshot.fromString(content);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    getCurrentDirectory() {
+        return process.cwd();
+    }
+    getDefaultLibFileName(options) {
+        return ts.getDefaultLibFilePath(options);
+    }
+    fileExists(path) {
+        return this.files.has(path) || fs.existsSync(path);
+    }
+    readFile(path) {
+        const file = this.files.get(path);
+        if (file) {
+            return file.content;
+        }
+        if (fs.existsSync(path)) {
+            try {
+                return fs.readFileSync(path, 'utf-8');
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    getNewLine() {
+        return ts.sys.newLine;
+    }
+}
+/**
+ * Realiza validación de tipos usando TypeScript Language Service (versión síncrona)
+ * @param fileName - Nombre del archivo
+ * @param content - Contenido del archivo
+ * @param compilerOptions - Opciones del compilador
+ * @returns Resultado de la validación de tipos
+ */
+export const validateTypesWithLanguageService = (fileName, content, compilerOptions) => {
+    let actualFileName = fileName; // Declarar aquí para acceso en catch
+    try {
+        let scriptContent = content;
+        // Si el script está vacío o es solo espacios en blanco, no validar
+        if (!scriptContent.trim()) {
+            return { diagnostics: [], hasErrors: false };
+        }
+        // Crear Language Service Host
+        const host = new TypeScriptLanguageServiceHost(compilerOptions);
+        // Para archivos Vue, crear un archivo virtual .ts
+        if (fileName.endsWith('.vue')) {
+            // Usar ruta absoluta para el archivo virtual
+            const absolutePath = path.isAbsolute(fileName)
+                ? fileName
+                : path.resolve(fileName);
+            // Crear un nombre de archivo virtual único que no colisione
+            const virtualFileName = absolutePath.replace('.vue', '.vue.ts');
+            host.addFile(virtualFileName, scriptContent);
+            actualFileName = virtualFileName;
+        }
+        else {
+            // Para archivos virtuales, usar el nombre tal como viene (como en el worker)
+            host.addFile(fileName, scriptContent);
+            actualFileName = fileName;
+        }
+        // Agregar declaraciones básicas de tipos para Vue si es necesario
+        if (fileName.endsWith('.vue')) {
+            // Usar el directorio del archivo actual para las declaraciones
+            const projectDir = path.dirname(actualFileName);
+            const vueTypesPath = path.join(projectDir, 'vue-types.d.ts');
+            const vueTypesDeclaration = `// Declaraciones de tipos Vue para validación
+                declare global {
+                    function ref<T>(value: T): { value: T };
+                    function reactive<T extends object>(target: T): T;
+                    function computed<T>(getter: () => T): { value: T };
+                    function defineComponent<T>(options: T): T;
+                    function defineProps<T = {}>(): T;
+                    function defineEmits<T = {}>(): T;
+                    function onMounted(fn: () => void): void;
+                    function onUnmounted(fn: () => void): void;
+                    function watch<T>(source: () => T, callback: (newValue: T, oldValue: T) => void): void;
+                }
+                export {};            `;
+            host.addFile(vueTypesPath, vueTypesDeclaration);
+        }
+        // Crear Language Service
+        const languageService = ts.createLanguageService(host);
+        try {
+            // Verificar que el archivo existe en el host antes de solicitar diagnósticos
+            if (!host.fileExists(actualFileName)) {
+                return { diagnostics: [], hasErrors: false };
+            }
+            // Obtener diagnósticos de tipos con manejo de errores
+            let syntacticDiagnostics = [];
+            let semanticDiagnostics = [];
+            try {
+                syntacticDiagnostics =
+                    languageService.getSyntacticDiagnostics(actualFileName);
+            }
+            catch {
+                // Ignorar errores de diagnósticos sintácticos
+            }
+            try {
+                semanticDiagnostics =
+                    languageService.getSemanticDiagnostics(actualFileName);
+            }
+            catch {
+                // Ignorar errores de diagnósticos semánticos
+            }
+            // Combinar todos los diagnósticos
+            const allDiagnostics = [
+                ...syntacticDiagnostics,
+                ...semanticDiagnostics,
+            ];
+            // Filtrar diagnósticos relevantes
+            const filteredDiagnostics = allDiagnostics.filter((diag) => {
+                const messageText = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
+                // Solo errores de categoría Error
+                if (diag.category !== ts.DiagnosticCategory.Error) {
+                    return false;
+                }
+                // Ignorar SOLO errores específicos de infraestructura Vue y rutas de módulos
+                return (!messageText.includes('Cannot find module') &&
+                    !messageText.includes('Could not find source file') &&
+                    !messageText.includes("Parameter '$props' implicitly has an 'any' type") &&
+                    !messageText.includes("Parameter '$setup' implicitly has an 'any' type") &&
+                    !messageText.includes("Parameter '$data' implicitly has an 'any' type") &&
+                    !messageText.includes("Parameter '$options' implicitly has an 'any' type") &&
+                    !messageText.includes("Parameter '$event' implicitly has an 'any' type") &&
+                    !messageText.includes("Parameter '_ctx' implicitly has an 'any' type") &&
+                    !messageText.includes("Parameter '_cache' implicitly has an 'any' type") &&
+                    // Ignorar errores específicos de decorators cuando están mal configurados
+                    !messageText.includes('Unable to resolve signature of method decorator when called as an expression') &&
+                    !messageText.includes('The runtime will invoke the decorator with') &&
+                    // Ignorar errores TS7031 (binding element implicitly has any type)
+                    diag.code !== 7031 &&
+                    // Ignorar errores TS7006 (parameter implicitly has any type)
+                    diag.code !== 7006 &&
+                    // Ignorar errores TS1241 (decorator signature mismatch) durante desarrollo
+                    diag.code !== 1241 &&
+                    // Permitir errores de "Cannot find name" ya que son errores de código real
+                    // Solo filtrar parámetros implícitos de Vue generados automáticamente
+                    !(messageText.includes("implicitly has an 'any' type") &&
+                        (messageText.includes('_ctx') ||
+                            messageText.includes('_cache') ||
+                            messageText.includes('$props') ||
+                            messageText.includes('$setup'))));
+            });
+            return {
+                diagnostics: filteredDiagnostics,
+                hasErrors: filteredDiagnostics.length > 0,
+            };
+        }
+        catch {
+            return { diagnostics: [], hasErrors: false };
+        }
+    }
+    catch (error) {
+        // En caso de error, devolver diagnóstico de error
+        const errorDiagnostic = {
+            file: undefined,
+            start: undefined,
+            length: undefined,
+            messageText: `Error en validación de tipos: ${error instanceof Error ? error.message : 'Error desconocido'}`,
+            category: ts.DiagnosticCategory.Error,
+            code: 0,
+        };
+        return {
+            diagnostics: [errorDiagnostic],
+            hasErrors: true,
+        };
+    }
+};
+/**
+ * Valida tipos en archivos Vue antes de la compilación (versión síncrona)
+ * @param vueContent - Contenido del archivo Vue
+ * @param fileName - Nombre del archivo Vue
+ * @param compilerOptions - Opciones del compilador
+ * @returns Resultado de la validación de tipos
+ */
+export const validateVueTypes = (vueContent, fileName, compilerOptions) => {
+    return validateTypesWithLanguageService(fileName, vueContent, compilerOptions);
+};
+//# sourceMappingURL=typescript-sync-validator.js.map