versacompiler 2.3.3 → 2.3.5

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

@@ -1,12 +1,18 @@
+import { readFileSync } from 'node:fs';
 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
+ * 🚀 OPTIMIZADO: Sin split preventivo, sin enhance - solo lo esencial para máxima velocidad
+ * @param scriptInfo - Información de extracción de script para archivos Vue (opcional)
  */
-export function parseTypeScriptErrors(diagnostics, fileName, sourceCode) {
+export function parseTypeScriptErrors(diagnostics, fileName, sourceCode, scriptInfo) {
     return diagnostics.map(diagnostic => {
-        // Usar el mejorador de errores para obtener mensaje detallado
-        const enhancedMessage = enhanceErrorMessage(diagnostic, fileName, sourceCode); // Determinar la severidad
+        // Extraer mensaje básico sin enhance (más rápido)
+        const message = typeof diagnostic.messageText === 'string'
+            ? diagnostic.messageText
+            : typescript.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+        const cleanedMessage = cleanErrorMessage(message); // Determinar la severidad
         let severity;
         switch (diagnostic.category) {
             case typescript.DiagnosticCategory.Error:
@@ -20,32 +26,102 @@ export function parseTypeScriptErrors(diagnostics, fileName, sourceCode) {
                 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') {
+        if (diagnostic.start !== undefined) {
+            // Intentar usar el sourceFile si está disponible
+            if (diagnostic.file &&
+                typeof diagnostic.file.getLineAndCharacterOfPosition ===
+                    'function') {
                 try {
-                    const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
-                    help += ` | Línea ${lineAndChar.line + 1}, Columna ${lineAndChar.character + 1}`;
+                    const lineAndChar = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+                    // Ajustar línea si es un archivo Vue con script extraído
+                    const adjustedLine = scriptInfo
+                        ? lineAndChar.line + scriptInfo.startLine
+                        : lineAndChar.line + 1;
+                    help += ` | Línea ${adjustedLine}, Columna ${lineAndChar.character + 1}`;
                 }
                 catch {
-                    // Si falla, solo mostrar la posición de carácter
-                    help += ` | Posición ${diagnostic.start}`;
+                    // Fallback: calcular posición leyendo el archivo
+                    try {
+                        const content = readFileSync(fileName, 'utf-8');
+                        const lines = content.split('\n');
+                        const { line, column } = getLineAndColumnFromOffset(lines, diagnostic.start);
+                        help += ` | Línea ${line}, Columna ${column}`;
+                    }
+                    catch {
+                        // Último fallback: solo mostrar posición
+                        help += ` | Posición ${diagnostic.start}`;
+                    }
                 }
             }
             else {
-                // Fallback para cuando no está disponible el método (como en tests)
-                help += ` | Posición ${diagnostic.start}`;
+                // Fallback: calcular posición y mostrar snippet de código
+                try {
+                    // Para archivos Vue con sourceCode, extraer el snippet del código compilado
+                    if (scriptInfo && sourceCode) {
+                        const compiledLines = sourceCode.split('\n');
+                        const { line: compiledLine, column } = getLineAndColumnFromOffset(compiledLines, diagnostic.start);
+                        // Extraer la línea donde está el error
+                        const errorLine = compiledLines[compiledLine - 1]?.trim() || '';
+                        // Truncar si es muy largo, centrando en el punto del error
+                        const maxSnippetLength = 80;
+                        let snippet = errorLine;
+                        if (snippet.length > maxSnippetLength) {
+                            // Tomar alrededor del punto del error
+                            const start = Math.max(0, column - 40);
+                            const end = Math.min(snippet.length, column + 40);
+                            snippet =
+                                (start > 0 ? '...' : '') +
+                                    snippet.substring(start, end) +
+                                    (end < snippet.length ? '...' : '');
+                        }
+                        // Para archivos Vue, mostrar snippet para buscar
+                        help += ` | Buscar en archivo: "${snippet}"`;
+                    }
+                    else {
+                        // No es Vue o no tenemos sourceCode, usar el archivo directamente
+                        const content = readFileSync(fileName, 'utf-8');
+                        const lines = content.split('\n');
+                        const { line, column } = getLineAndColumnFromOffset(lines, diagnostic.start);
+                        help += ` | Línea ${line}, Columna ${column}`;
+                    }
+                }
+                catch {
+                    // Último fallback: solo mostrar posición
+                    help += ` | Posición ${diagnostic.start}`;
+                }
             }
         }
         return {
             file: fileName,
-            message: enhancedMessage,
+            message: cleanedMessage,
             severity,
             help,
         };
     });
 }
+/**
+ * Calcula línea y columna desde un offset de caracteres
+ * @param lines - Array de líneas ya procesadas (para evitar múltiples splits)
+ * @param offset - Posición del carácter
+ */
+function getLineAndColumnFromOffset(lines, offset) {
+    let currentOffset = 0;
+    let line = 1;
+    let column = 1;
+    for (let i = 0; i < lines.length; i++) {
+        const currentLine = lines[i];
+        if (currentLine === undefined)
+            continue;
+        const lineLength = currentLine.length + 1; // +1 para el \n
+        if (currentOffset + lineLength > offset) {
+            line = i + 1;
+            column = offset - currentOffset + 1;
+            break;
+        }
+        currentOffset += lineLength;
+    }
+    return { line, column };
+}
 /**
  * Limpia el mensaje de error eliminando información redundante
  */
@@ -61,8 +137,11 @@ function cleanErrorMessage(message) {
 }
 /**
  * Mejora significativamente el mensaje de error TypeScript con contexto visual
+ * ⚠️ DEPRECATED: Ya no se usa en el flujo normal para evitar overhead de performance
+ * Se mantiene para compatibilidad futura o modo verbose avanzado
+ * @param scriptInfo - Información de extracción de script para archivos Vue (opcional)
  */
-function enhanceErrorMessage(diagnostic, fileName, sourceCode) {
+function enhanceErrorMessage(diagnostic, fileName, sourceCode, scriptInfo) {
     // Extraer el mensaje del error
     const message = typeof diagnostic.messageText === 'string'
         ? diagnostic.messageText
@@ -76,35 +155,43 @@ function enhanceErrorMessage(diagnostic, fileName, sourceCode) {
         if (typeof sourceFile.getLineAndCharacterOfPosition === 'function') {
             try {
                 const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
-                const line = lineAndChar.line + 1;
+                // Ajustar línea si es un archivo Vue con script extraído
+                const line = scriptInfo
+                    ? lineAndChar.line + scriptInfo.startLine
+                    : 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}`;
+                // Si falla, solo mostrar el código de error
+                location = `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}`;
+            // Fallback: solo mostrar el código de error
+            location = `Código TS${diagnostic.code}`;
         } // Agregar contexto del código si está disponible
-        if ((sourceCode || sourceFile.text) &&
+        if ((sourceCode || scriptInfo?.originalData || sourceFile.text) &&
             typeof sourceFile.getLineAndCharacterOfPosition === 'function') {
             try {
                 const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
-                const text = sourceCode || sourceFile.text;
+                // Obtener código fuente apropiado
+                const text = scriptInfo?.originalData || sourceCode || sourceFile.text;
                 const lines = text.split('\n');
-                const errorLine = lines[lineAndChar.line];
+                // Calcular la línea real en el archivo original
+                const actualLineIndex = scriptInfo
+                    ? lineAndChar.line + scriptInfo.startLine - 1
+                    : lineAndChar.line;
+                const errorLine = lines[actualLineIndex];
                 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);
+                    const startLine = Math.max(0, actualLineIndex - 2);
+                    const endLine = Math.min(lines.length - 1, actualLineIndex + 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;
+                        const isErrorLine = i === actualLineIndex;
                         if (isErrorLine) {
                             codeContext += `  ${currentLine.toString().padStart(3, ' ')} ❌ ${lineContent}\n`;
                             // Agregar flecha apuntando al error

package/dist/compiler/typescript-manager.js

@@ -213,9 +213,10 @@ const cleanupUnnecessaryExports = (compiledOutput, originalSource) => {
  * 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.
+ * @param {ScriptExtractionInfo} scriptInfo - Información de extracción de script para archivos Vue (opcional).
  * @returns {Promise<CompileResult>} - Un objeto con el código precompilado o un error.
  */
-export const preCompileTS = async (data, fileName) => {
+export const preCompileTS = async (data, fileName, scriptInfo) => {
     try {
         // Validación temprana: contenido vacío
         if (!data.trim()) {
@@ -261,7 +262,7 @@ export const preCompileTS = async (data, fileName) => {
                     diag.code !== 6059);
             });
             if (criticalErrors.length > 0) {
-                const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(criticalErrors, fileName, data));
+                const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(criticalErrors, fileName, data, scriptInfo));
                 return {
                     error: new Error(errorMessage),
                     data: null,
@@ -275,9 +276,14 @@ export const preCompileTS = async (data, fileName) => {
                 const serializableOptions = createSerializableCompilerOptions(compilerOptions);
                 const typeCheckResult = await workerPool.typeCheck(fileName, data, serializableOptions);
                 if (typeCheckResult.hasErrors) {
-                    const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(typeCheckResult.diagnostics, fileName, data));
+                    const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(typeCheckResult.diagnostics, fileName, data, scriptInfo));
+                    const error = new Error(errorMessage);
+                    // Marcar como error de tipo (no error del compilador)
+                    error.isTypeError = true;
+                    // Limpiar stack trace para no confundir con errores del compilador
+                    error.stack = undefined;
                     return {
-                        error: new Error(errorMessage),
+                        error,
                         data: null,
                         lang: 'ts',
                     };

package/dist/compiler/vuejs.js

@@ -158,8 +158,11 @@ export const preCompileVue = async (data, source, isProd = false) => {
                 error: null,
                 data: 'export default {};',
                 lang: 'js',
+                scriptInfo: undefined,
             };
         }
+        // Guardar el código original antes de inyectar HMR
+        const originalData = data;
         if (!isProd) {
             const { injectedData } = hmrInjectionCache.getOrGenerateHMRInjection(data, fileName);
             data = injectedData;
@@ -370,11 +373,22 @@ export const preCompileVue = async (data, source, isProd = false) => {
 
             export default ${componentName};        `;
         output = `${output}\n${finishComponent}`;
-        return {
+        // 🚀 OPTIMIZACIÓN CRÍTICA: Evitar crear scriptInfo si no hay script
+        const result = {
             lang: finalCompiledScript.lang,
             error: null,
             data: output,
         };
+        // Solo agregar scriptInfo cuando realmente hay script (evita overhead)
+        if (descriptor.script || descriptor.scriptSetup) {
+            result.scriptInfo = {
+                startLine: (descriptor.script || descriptor.scriptSetup).loc?.start
+                    .line || 1,
+                content: (descriptor.script || descriptor.scriptSetup).content,
+                originalData: originalData, // String directa, no closure
+            };
+        }
+        return result;
     }
     catch (error) {
         logger.error('Vue compilation error:', error);
@@ -382,6 +396,7 @@ export const preCompileVue = async (data, source, isProd = false) => {
             lang: null,
             error: error instanceof Error ? error : new Error(String(error)),
             data: null,
+            scriptInfo: undefined,
         };
     }
 };

package/dist/main.js

@@ -121,7 +121,13 @@ async function main() {
         description: 'Habilitar/Deshabilitar la verificación de tipos. Por defecto --typeCheck=false',
         default: false,
     })
-        .alias('t', 'typeCheck');
+        .alias('t', 'typeCheck')
+        .option('checkIntegrity', {
+        type: 'boolean',
+        description: 'Validar la integridad del código compilado (para builds de deploy). Por defecto --checkIntegrity=false',
+        default: false,
+    })
+        .alias('ci', 'checkIntegrity');
     // Definir la opción tailwind dinámicamente
     // Asumiendo que env.TAILWIND es una cadena que podría ser 'true', 'false', o undefined
     if (env.tailwindcss !== 'false') {
@@ -177,7 +183,8 @@ async function main() {
         env.TAILWIND =
             argv.tailwind === undefined ? 'true' : String(argv.tailwind);
         env.ENABLE_LINTER = String(argv.linter);
-        env.VERBOSE = argv.verbose ? 'true' : 'false'; // 🎯 Configuración moderna y organizada
+        env.VERBOSE = argv.verbose ? 'true' : 'false';
+        env.CHECK_INTEGRITY = argv.checkIntegrity ? 'true' : 'false'; // 🎯 Configuración moderna y organizada
         logger.info(chalk.bold.blue('⚙️  Configuración'));
         logger.info(chalk.gray('   ┌─ Modo de ejecución'));
         const modes = [
@@ -199,6 +206,11 @@ async function main() {
                 icon: '🔍',
             },
             { label: 'Verificar tipos', value: argv.typeCheck, icon: '📘' },
+            {
+                label: 'Validar integridad',
+                value: argv.checkIntegrity,
+                icon: '🛡️',
+            },
             { label: 'Detallado', value: env.VERBOSE === 'true', icon: '📝' },
         ];
         modes.forEach(mode => {

package/dist/servicios/readConfig.js

@@ -108,7 +108,8 @@ export function validateConfigStructure(config) {
         logger.error('compilerOptions es requerido y debe ser un objeto');
         return false;
     }
-    if (!config.compilerOptions.pathsAlias || typeof config.compilerOptions.pathsAlias !== 'object') {
+    if (!config.compilerOptions.pathsAlias ||
+        typeof config.compilerOptions.pathsAlias !== 'object') {
         logger.error('pathsAlias es requerido y debe ser un objeto');
         return false;
     }
@@ -130,11 +131,13 @@ export function validateConfigStructure(config) {
         }
     }
     // Validar sourceRoot si existe
-    if (config.compilerOptions.sourceRoot && !validatePath(config.compilerOptions.sourceRoot)) {
+    if (config.compilerOptions.sourceRoot &&
+        !validatePath(config.compilerOptions.sourceRoot)) {
         return false;
     }
     // Validar outDir si existe
-    if (config.compilerOptions.outDir && !validatePath(config.compilerOptions.outDir)) {
+    if (config.compilerOptions.outDir &&
+        !validatePath(config.compilerOptions.outDir)) {
         return false;
     }
     // Validar linter si existe