versacompiler 2.0.2 → 2.0.3

package/dist/compiler/module-resolution-optimizer.js

@@ -161,9 +161,8 @@ export class ModuleResolutionOptimizer {
             const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
             this.metrics.filesystemAccess++;
             const isESM = packageJson.type === 'module';
-            const hasExports = !!packageJson.exports;
-            // Determinar entry point optimizado
-            let entryPoint = this.determineOptimalEntryPoint(packageJson);
+            const hasExports = !!packageJson.exports; // Determinar entry point optimizado
+            const entryPoint = this.determineOptimalEntryPoint(packageJson);
             let optimizedEntry;
             // Buscar versión ESM/browser optimizada
             if (entryPoint) {
@@ -251,7 +250,7 @@ export class ModuleResolutionOptimizer {
      */
     findDevelopmentAlternatives(entryPoint, packageJson) {
         // Crear versión de desarrollo basada en el entry point actual
-        let devVersion = entryPoint
+        const devVersion = entryPoint
             .replace('.min.', '.')
             .replace('.prod.', '.');
         // Si hay exports, buscar en diferentes condiciones

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

@@ -67,7 +67,7 @@ function enhanceErrorMessage(diagnostic, fileName, sourceCode) {
     const message = typeof diagnostic.messageText === 'string'
         ? diagnostic.messageText
         : typescript.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-    let enhancedMessage = cleanErrorMessage(message); // Información de ubicació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) {

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

@@ -86,7 +86,7 @@ class TypeScriptLanguageServiceHost {
 export const validateTypesWithLanguageService = (fileName, content, compilerOptions) => {
     let actualFileName = fileName; // Declarar aquí para acceso en catch
     try {
-        let scriptContent = content;
+        const scriptContent = content;
         // Si el script está vacío o es solo espacios en blanco, no validar
         if (!scriptContent.trim()) {
             return { diagnostics: [], hasErrors: false };

package/dist/compiler/typescript-worker-pool.js

@@ -18,10 +18,10 @@ export class TypeScriptWorkerPool {
     workerPath;
     initPromise = null;
     isInitialized = false; // Configuración optimizada con reciclaje de workers
-    TASK_TIMEOUT = 10000; // 10 segundos por tarea
+    TASK_TIMEOUT = 15000; // 15 segundos por tarea (aumentado)
     WORKER_INIT_TIMEOUT = 5000; // 5 segundos para inicializar
-    MAX_TASKS_PER_WORKER = 50; // Máximo de tareas por worker antes de reciclaje
-    WORKER_MEMORY_CHECK_INTERVAL = 100; // Verificar cada 100 tareas
+    MAX_TASKS_PER_WORKER = 25; // Reducido para liberar memoria más frecuentemente
+    WORKER_MEMORY_CHECK_INTERVAL = 50; // Verificar cada 50 tareas (más frecuente)
     // Métricas de rendimiento
     totalTasks = 0;
     completedTasks = 0;
@@ -31,22 +31,21 @@ export class TypeScriptWorkerPool {
         const cpuCount = os.cpus().length;
         this.poolSize = Math.min(Math.max(cpuCount - 1, 2), 8); // Entre 2 y 8 workers
         this.workerPath = path.join(process.env.PATH_PROY || path.join(process.cwd(), 'src'), 'compiler', 'typescript-worker-thread.cjs');
-        // ✨ ISSUE #4: Configurar monitoreo de memoria automático
-        this.startMemoryMonitoring();
+        // ✨ ISSUE #4: Configurar monitoreo de memoria automático        this.startMemoryMonitoring();
     }
     // ✨ ISSUE #4: Métodos de control de memoria y timeouts
     /**
      * Inicia el monitoreo automático de memoria de workers
      */
     startMemoryMonitoring() {
-        // Monitoreo cada 30 segundos
+        // Monitoreo cada 15 segundos (más frecuente)
         setInterval(() => {
             this.checkWorkersMemory();
-        }, 30000);
-        // Limpieza de workers inactivos cada 5 minutos
+        }, 15000);
+        // Limpieza de workers inactivos cada 2 minutos (más frecuente)
         setInterval(() => {
             this.cleanupInactiveWorkers();
-        }, 300000);
+        }, 120000);
     }
     /**
      * Verifica el uso de memoria de todos los workers con medición real
@@ -128,13 +127,12 @@ export class TypeScriptWorkerPool {
             reasons.push(`tareas procesadas exceden ${TASK_LIMIT} (actual: ${poolWorker.tasksProcessed})`);
         }
         return reasons.join(', ');
-    }
-    /**
+    } /**
      * Limpia workers que han estado inactivos por mucho tiempo
      */
     async cleanupInactiveWorkers() {
         const now = Date.now();
-        const INACTIVE_TIMEOUT = 10 * 60 * 1000; // 10 minutos
+        const INACTIVE_TIMEOUT = 5 * 60 * 1000; // 5 minutos (reducido)
         for (const poolWorker of this.workers) {
             const timeSinceLastActivity = now - poolWorker.lastActivityTime;
             if (timeSinceLastActivity > INACTIVE_TIMEOUT &&
@@ -144,14 +142,13 @@ export class TypeScriptWorkerPool {
                 await this.recycleWorker(poolWorker);
             }
         }
-    }
-    /**
+    } /**
      * Verifica si un worker debe ser reciclado por límites de memoria/tiempo
      */
     shouldRecycleWorker(poolWorker) {
         const now = Date.now();
-        const MEMORY_LIMIT = 50 * 1024 * 1024; // 50MB
-        const TIME_LIMIT = 30 * 60 * 1000; // 30 minutos
+        const MEMORY_LIMIT = 30 * 1024 * 1024; // 30MB (reducido)
+        const TIME_LIMIT = 15 * 60 * 1000; // 15 minutos (reducido)
         const TASK_LIMIT = this.MAX_TASKS_PER_WORKER;
         return (poolWorker.memoryUsage > MEMORY_LIMIT ||
             now - poolWorker.creationTime > TIME_LIMIT ||

package/dist/compiler/typescript-worker-thread.cjs

@@ -158,9 +158,8 @@ class WorkerTypeScriptLanguageServiceHost {
  */
 function validateTypesInWorker(fileName, content, compilerOptions) {
     let actualFileName = fileName;
-
     try {
-        let scriptContent = content;
+        const scriptContent = content;
 
         // Si el script está vacío o es solo espacios en blanco, no validar
         if (!scriptContent.trim()) {

package/dist/hrm/getInstanciaVue.js

@@ -56,7 +56,7 @@ function getVueInstanceFromElement(selector = '#app') {
 function findVueInstanceInDOM() {
     const allElements = document.querySelectorAll('*');
 
-    for (let element of allElements) {
+    for (const element of allElements) {
         // Vue 3
         if (element.__vue_app__) {
             return element.__vue_app__;

package/dist/hrm/initHRM.js

@@ -10,7 +10,7 @@
  */
 
 import { hideErrorOverlay, showErrorOverlay } from './errorScreen.js';
-import obtenerInstanciaVue from './getInstanciaVue.js';
+import { obtenerInstanciaVue } from './getInstanciaVue.js';
 import { reloadComponent } from './VueHRM.js';
 
 /**

package/dist/main.js

@@ -132,9 +132,18 @@ async function main() {
     })
         .parse());
     try {
-        logger.log(`\n\n` +
-            chalk.blue('VersaCompiler') +
-            ' - Servidor de Desarrollo HRM y compilador de archivos Vue/ts/js\n\n');
+        // 🎨 Header moderno y elegante
+        const headerLine = '━'.repeat(60);
+        logger.log(`\n` +
+            chalk.cyan(headerLine) +
+            `\n` +
+            chalk.bold.cyan('  ⚡ VersaCompiler ') +
+            chalk.gray('v2.0.3') +
+            `\n` +
+            chalk.gray('  Vue · TypeScript · JavaScript Compiler') +
+            `\n` +
+            chalk.cyan(headerLine) +
+            `\n`);
         if (argv.init) {
             logger.info('Iniciando la configuración...');
             const { initConfig } = await loadConfigModule();
@@ -149,20 +158,58 @@ async function main() {
         env.TAILWIND =
             argv.tailwind === undefined ? 'true' : String(argv.tailwind);
         env.ENABLE_LINTER = String(argv.linter);
-        env.VERBOSE = argv.verbose ? 'true' : 'false';
-        logger.info(chalk.green('Configuración de VersaCompiler:'));
-        logger.info(chalk.green(`Watch: ${argv.watch}`));
-        logger.info(chalk.green(`All: ${env.isALL}`));
-        logger.info(chalk.green(`File: ${argv.file || 'N/A'}`));
-        logger.info(chalk.green(`Prod: ${env.isPROD}`));
-        logger.info(chalk.green(`Tailwind: ${env.TAILWIND}`));
-        logger.info(chalk.green(`Minification: ${env.isPROD}`));
-        logger.info(chalk.green(`Linter: ${env.ENABLE_LINTER}`));
-        logger.info(chalk.green(`Verbose: ${env.VERBOSE}`));
-        logger.info(chalk.green(`Clean Output: ${argv.cleanOutput}`));
-        logger.info(chalk.green(`Clean Cache: ${argv.cleanCache}`));
-        logger.info(chalk.green(`Type Check: ${argv.typeCheck}`));
-        logger.log(`\n`);
+        env.VERBOSE = argv.verbose ? 'true' : 'false'; // 🎯 Configuración moderna y organizada
+        logger.info(chalk.bold.blue('⚙️  Configuración'));
+        logger.info(chalk.gray('   ┌─ Modo de ejecución'));
+        const modes = [
+            { label: 'Observar', value: argv.watch, icon: '👀' },
+            {
+                label: 'Todos los archivos',
+                value: env.isALL === 'true',
+                icon: '📁',
+            },
+            { label: 'Archivo único', value: !!argv.file, icon: '📄' },
+            { label: 'Producción', value: env.isPROD === 'true', icon: '🏭' },
+        ];
+        const features = [
+            { label: 'Tailwind', value: env.TAILWIND === 'true', icon: '🎨' },
+            { label: 'Minificación', value: env.isPROD === 'true', icon: '🗜️' },
+            {
+                label: 'Linter',
+                value: env.ENABLE_LINTER === 'true',
+                icon: '🔍',
+            },
+            { label: 'Verificar tipos', value: argv.typeCheck, icon: '📘' },
+            { label: 'Detallado', value: env.VERBOSE === 'true', icon: '📝' },
+        ];
+        modes.forEach(mode => {
+            const status = mode.value ? chalk.green('●') : chalk.gray('○');
+            const label = mode.value
+                ? chalk.green(mode.label)
+                : chalk.gray(mode.label);
+            logger.info(chalk.gray('   │  ') + status + ` ${mode.icon} ${label}`);
+        });
+        logger.info(chalk.gray('   ├─ Características'));
+        features.forEach(feature => {
+            const status = feature.value ? chalk.green('●') : chalk.gray('○');
+            const label = feature.value
+                ? chalk.green(feature.label)
+                : chalk.gray(feature.label);
+            logger.info(chalk.gray('   │  ') + status + ` ${feature.icon} ${label}`);
+        });
+        if (argv.file) {
+            logger.info(chalk.gray('   ├─ Objetivo'));
+            logger.info(chalk.gray('   │  ') + chalk.blue('📄 ') + argv.file);
+        }
+        if (argv.cleanOutput) {
+            logger.info(chalk.gray('   ├─ Limpieza'));
+            logger.info(chalk.gray('   │  ') + chalk.yellow('🧹 Limpiar salida'));
+        }
+        if (argv.cleanCache) {
+            logger.info(chalk.gray('   │  ') + chalk.yellow('🗑️  Limpiar caché'));
+        }
+        logger.info(chalk.gray('   └─ ¡Listo para compilar!'));
+        logger.log('');
         env.typeCheck = argv.typeCheck ? 'true' : 'false';
         env.cleanCache = argv.cleanCache ? 'true' : 'false';
         env.yes = argv.y ? 'true' : 'false';

package/dist/servicios/browserSync.js

@@ -279,7 +279,7 @@ const loadChalk = async () => {
 export async function browserSyncServer() {
     try {
         let bs = null;
-        const AssetsOmit = env.AssetsOmit === 'true' ? true : false;
+        const AssetsOmit = env.AssetsOmit === 'true';
         let proxy = {
             server: './',
         };

package/dist/servicios/file-watcher.js

@@ -209,13 +209,19 @@ export async function cleanOutputDir(outputDir, primerInteraccion = true) {
                         '? (s / N) : ');
                     if (answer.toLowerCase() !== 's') {
                         logger.info('🛑 Compilación cancelada por el usuario.');
-                        process.exit(0);
+                        if (process.env.NODE_ENV !== 'test') {
+                            process.exit(0);
+                        }
+                        return;
                     }
                 }
             }
             catch (error) {
                 logger.error(`Error en la entrada del usuario: ${error}`);
-                process.exit(1);
+                if (process.env.NODE_ENV !== 'test') {
+                    process.exit(1);
+                }
+                throw error;
             }
         }
         const chalkInstance = await loadChalk();
@@ -271,7 +277,10 @@ export async function initChokidar(bs) {
     try {
         if (!env.PATH_SOURCE) {
             logger.error('Error: La variable de entorno PATH_SOURCE no está definida.');
-            process.exit(1);
+            if (process.env.NODE_ENV !== 'test') {
+                process.exit(1);
+            }
+            throw new Error('PATH_SOURCE no está definida');
         }
         const watchJS = `${env.PATH_SOURCE}/**/*.js`;
         const watchVue = `${env.PATH_SOURCE}/**/*.vue`;
@@ -361,7 +370,10 @@ export async function initChokidar(bs) {
     }
     catch (error) {
         logger.error(`🚩 :Error al iniciar watch: ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
+        if (process.env.NODE_ENV !== 'test') {
+            process.exit(1);
+        }
+        throw error;
     }
 }
 //# sourceMappingURL=file-watcher.js.map

package/dist/servicios/logger.js

@@ -1,33 +1,62 @@
 import * as process from 'node:process';
+// Función para obtener ProgressManager (lazy import para evitar dependencias circulares)
+let getProgressManager = null;
+export function setProgressManagerGetter(getter) {
+    getProgressManager = getter;
+}
 class Logger {
     constructor() {
         // Bind console methods
         process.stdout.write = process.stdout.write.bind(process.stdout);
         process.stderr.write = process.stderr.write.bind(process.stderr);
     }
+    writeMessage(message, useStderr = false, immediate = false) {
+        if (getProgressManager) {
+            const progressManager = getProgressManager();
+            if (progressManager && progressManager.isActive()) {
+                // Si el progreso está activo, usar el sistema de logs apropiado
+                if (immediate) {
+                    progressManager.addImmediateLog(message);
+                }
+                else {
+                    progressManager.addLog(message);
+                }
+                return;
+            }
+        }
+        // Comportamiento normal si no hay progreso activo
+        if (useStderr) {
+            process.stderr.write(message + '\n');
+        }
+        else {
+            process.stdout.write(message + '\n');
+        }
+    }
     log(...args) {
-        process.stdout.write(args.map(arg => String(arg)).join(' ') + '\n');
+        this.writeMessage(args.map(arg => String(arg)).join(' '));
     }
     info(...args) {
-        process.stdout.write(args.map(arg => String(arg)).join(' ') + '\n');
+        // En modo verbose, mostrar logs inmediatamente
+        const isVerbose = process.env.VERBOSE === 'true';
+        this.writeMessage(args.map(arg => String(arg)).join(' '), false, isVerbose);
     }
     error(...args) {
-        process.stderr.write(args.map(arg => String(arg)).join(' ') + '\n');
+        this.writeMessage(args.map(arg => String(arg)).join(' '), true);
     }
     warn(...args) {
-        process.stderr.write(args.map(arg => String(arg)).join(' ') + '\n');
+        this.writeMessage(args.map(arg => String(arg)).join(' '), true);
     }
     debug(...args) {
-        process.stdout.write(args.map(arg => String(arg)).join(' ') + '\n');
+        this.writeMessage(args.map(arg => String(arg)).join(' '));
     }
     fatal(...args) {
-        process.stderr.write(args.map(arg => String(arg)).join(' ') + '\n');
+        this.writeMessage(args.map(arg => String(arg)).join(' '), true);
     }
     table(data, title) {
         const tableString = title
             ? console.table(data, title)
             : console.table(data);
-        process.stdout.write(String(tableString) + '\n');
+        this.writeMessage(String(tableString));
     }
 }
 export const logger = new Logger();

package/dist/servicios/readConfig.js

@@ -341,7 +341,7 @@ export async function readConfig() {
         if (!tsConfig.compilerOptions.sourceRoot) {
             env.tsConfig = safeJsonStringify(tsConfig, '{}');
         }
-        logger.info('Configuración cargada y validada exitosamente');
+        logger.info('✅ Configuration loaded and validated successfully');
         return true;
     }
     catch (error) {

package/dist/utils/module-resolver.js

@@ -228,7 +228,6 @@ function simpleESMResolver(moduleName) {
     try {
         const nodeModulesPath = join(cwd(), 'node_modules', moduleName);
         let packagePath;
-        let packageJson;
         try {
             packagePath = join(nodeModulesPath, 'package.json');
             if (!fs.existsSync(packagePath)) {
@@ -238,7 +237,7 @@ function simpleESMResolver(moduleName) {
         catch {
             return null;
         }
-        packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+        const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
         const moduleDir = dirname(packagePath);
         const isESM = packageJson.type === 'module'; // Determinar el entry point ESM/Browser optimizado
         let entryPoint = null;
@@ -381,7 +380,7 @@ function getNodeModulesRelativePath(fullPath, _fromFile) {
     const idx = fullPath.indexOf('node_modules');
     if (idx !== -1) {
         // Extraer solo la parte desde node_modules en adelante
-        let relativePath = fullPath.substring(idx).replace(/\\/g, '/');
+        const relativePath = fullPath.substring(idx).replace(/\\/g, '/');
         // Devolver ruta absoluta desde la raíz del proyecto (sin ../)
         // Esto permite que los archivos compilados accedan directamente a node_modules
         return '/' + relativePath;
@@ -428,7 +427,7 @@ export function getModuleSubPath(moduleName, fromFile) {
             if (packageJson.exports &&
                 typeof packageJson.exports === 'object') {
                 const exportKey = `./${subPath}`;
-                let exportPath = packageJson.exports[exportKey];
+                const exportPath = packageJson.exports[exportKey];
                 if (exportPath) {
                     if (typeof exportPath === 'string') {
                         return getNodeModulesRelativePath(join(moduleDir, exportPath), fromFile);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "versacompiler",
-    "version": "2.0.2",
+    "version": "2.0.3",
     "description": "Una herramienta para compilar y minificar archivos .vue, .js y .ts para proyectos de Vue 3 con soporte para TypeScript.",
     "main": "dist/main.js",
     "bin": {