versacompiler 2.0.1 → 2.0.3

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

@@ -2,6 +2,7 @@ import { readdir, rm, stat, unlink } from 'node:fs/promises';
 import path from 'node:path';
 import process, { env } from 'node:process';
 import * as chokidar from 'chokidar';
+import { minimatch } from 'minimatch';
 import { getOutputPath, initCompile, normalizeRuta } from '../compiler/compile.js';
 import { promptUser } from '../utils/promptUser.js';
 import { emitirCambios } from './browserSync.js';
@@ -30,7 +31,7 @@ class WatchDebouncer {
     /**
      * Añade un cambio al sistema de debouncing
      */
-    addChange(filePath, action, extensionAction) {
+    addChange(filePath, action, extensionAction, isAdditionalFile = false) {
         // Normalizar ruta para evitar duplicados
         const normalizedPath = normalizeRuta(filePath);
         // Agregar o actualizar el cambio pendiente
@@ -39,6 +40,7 @@ class WatchDebouncer {
             action,
             timestamp: Date.now(),
             extensionAction,
+            isAdditionalFile,
         });
         // Reiniciar el timer de debounce
         this.resetDebounceTimer();
@@ -88,39 +90,71 @@ class WatchDebouncer {
                 this.resetDebounceTimer();
             }
         }
-    }
-    /**
+    } /**
      * Procesa cambios de eliminación
      */
     async processDeleteChanges(deleteChanges) {
         for (const change of deleteChanges) {
-            logger.info(`\n🗑️ eliminando archivo: ${change.filePath}`);
-            const result = await deleteFile(getOutputPath(change.filePath));
-            if (result) {
-                logger.info(`Archivo eliminado: ${change.filePath}`);
+            if (change.isAdditionalFile) {
+                // ✨ Archivos adicionales: solo reload, sin eliminar del output
+                logger.info(`\n🗑️ Archivo adicional eliminado: ${change.filePath}`);
                 emitirCambios(this.browserSyncInstance, 'reloadFull', change.filePath);
             }
+            else {
+                // Archivos compilables: eliminar del output
+                logger.info(`\n🗑️ Eliminando archivo compilado: ${change.filePath}`);
+                const result = await deleteFile(getOutputPath(change.filePath));
+                if (result) {
+                    logger.info(`Archivo eliminado: ${change.filePath}`);
+                    emitirCambios(this.browserSyncInstance, 'reloadFull', change.filePath);
+                }
+            }
         }
     }
     /**
      * Procesa cambios de compilación en paralelo con límite de concurrencia
      */
     async processCompileChanges(compileChanges) {
+        // ✨ NUEVO: Separar archivos adicionales de archivos compilables
+        const additionalFiles = compileChanges.filter(c => c.isAdditionalFile);
+        const compilableFiles = compileChanges.filter(c => !c.isAdditionalFile);
+        // ✨ Procesar archivos adicionales (solo reload, sin compilación)
+        if (additionalFiles.length > 0) {
+            await this.processAdditionalFiles(additionalFiles);
+        }
+        // Procesar archivos compilables normalmente
+        if (compilableFiles.length > 0) {
+            await this.processCompilableFiles(compilableFiles);
+        }
+    }
+    /**
+     * ✨ RENOMBRADO: Procesa archivos compilables
+     */
+    async processCompilableFiles(compilableFiles) {
         const chalkInstance = await loadChalk();
         // Procesar en batches para evitar sobrecarga
-        for (let i = 0; i < compileChanges.length; i += this.BATCH_SIZE) {
-            const batch = compileChanges.slice(i, i + this.BATCH_SIZE);
-            // Mostrar información del batch
+        for (let i = 0; i < compilableFiles.length; i += this.BATCH_SIZE) {
+            const batch = compilableFiles.slice(i, i + this.BATCH_SIZE);
             if (batch.length > 1) {
-                logger.info(chalkInstance.cyan(`📦 Procesando batch de ${batch.length} archivos (${i + 1}-${Math.min(i + this.BATCH_SIZE, compileChanges.length)} de ${compileChanges.length})`));
+                logger.info(chalkInstance.cyan(`📦 Procesando batch de ${batch.length} archivos compilables (${i + 1}-${Math.min(i + this.BATCH_SIZE, compilableFiles.length)} de ${compilableFiles.length})`));
             }
-            // Procesar batch en paralelo con límite de concurrencia
             const promises = batch.map(change => this.compileFile(change));
             await Promise.allSettled(promises);
         }
-        // Emitir cambio global al final del batch
-        if (compileChanges.length > 1) {
-            logger.info(chalkInstance.green(`✅ Batch completado: ${compileChanges.length} archivos procesados`));
+        if (compilableFiles.length > 1) {
+            logger.info(chalkInstance.green(`✅ Batch completado: ${compilableFiles.length} archivos compilados`));
+        }
+    }
+    /**
+     * ✨ NUEVO: Procesa archivos adicionales (solo reloadFull)
+     */
+    async processAdditionalFiles(additionalFiles) {
+        const chalkInstance = await loadChalk();
+        logger.info(chalkInstance.blue(`🔄 Recargando ${additionalFiles.length} archivo(s) adicional(es) (sin compilación)`));
+        for (const change of additionalFiles) {
+            logger.info(`📄 Archivo adicional modificado: ${change.filePath}`);
+            // Solo hacer reloadFull, sin compilación
+            emitirCambios(this.browserSyncInstance, 'reloadFull', change.filePath);
         }
     }
     /**
@@ -175,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();
@@ -219,11 +259,28 @@ function getAction(ruta, extendsionWatch) {
         .find(item => item.ext === ruta.split('.').pop())?.action;
     return action || 'reloadFull';
 }
+/**
+ * Verifica si un archivo pertenece a las rutas adicionales (no compilables)
+ */
+function isAdditionalWatchFile(filePath, additionalPatterns) {
+    if (!additionalPatterns || additionalPatterns.length === 0) {
+        return false;
+    }
+    const normalizedPath = normalizeRuta(filePath);
+    return additionalPatterns.some(pattern => {
+        // Normalizar el patrón también
+        const normalizedPattern = pattern.replace(/\\/g, '/');
+        return minimatch(normalizedPath, normalizedPattern);
+    });
+}
 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`;
@@ -290,27 +347,33 @@ export async function initChokidar(bs) {
         watchDebouncer.setBrowserSyncInstance(bs);
         // ✨ OPTIMIZADO: Evento cuando se añade un archivo - Con debouncing
         watcher.on('add', async (ruta) => {
+            const isAdditional = isAdditionalWatchFile(ruta, watchAditional);
             const action = getAction(ruta, extendsionWatch.filter((item) => item !== undefined));
             // Usar sistema de debouncing en lugar de compilación inmediata
-            watchDebouncer.addChange(ruta, 'add', action);
+            watchDebouncer.addChange(ruta, 'add', action, isAdditional);
         });
         // ✨ OPTIMIZADO: Evento cuando se modifica un archivo - Con debouncing
         watcher.on('change', async (ruta) => {
+            const isAdditional = isAdditionalWatchFile(ruta, watchAditional);
             const action = getAction(ruta, extendsionWatch.filter((item) => item !== undefined));
             // Usar sistema de debouncing en lugar de compilación inmediata
-            watchDebouncer.addChange(ruta, 'change', action);
+            watchDebouncer.addChange(ruta, 'change', action, isAdditional);
         });
         // ✨ OPTIMIZADO: Evento cuando se elimina un archivo - Con debouncing
         watcher.on('unlink', async (ruta) => {
             const action = getAction(ruta, extendsionWatch.filter((item) => item !== undefined));
+            const isAdditional = isAdditionalWatchFile(ruta, watchAditional);
             // Usar sistema de debouncing para eliminaciones también
-            watchDebouncer.addChange(ruta, 'unlink', action);
+            watchDebouncer.addChange(ruta, 'unlink', action, isAdditional);
         });
         return watcher;
     }
     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/excluded-modules.js

@@ -0,0 +1,36 @@
+/**
+ * Lista centralizada de módulos excluidos de la resolución automática
+ * Estos módulos se mantienen con su importación original sin transformar
+ */
+export const EXCLUDED_MODULES = new Set([
+    // Módulos de Vue.js que requieren resolución específica
+    'vue/compiler-sfc',
+    'vue/dist/vue.runtime.esm-bundler',
+    '@vue/compiler-sfc',
+    '@vue/compiler-dom',
+    '@vue/runtime-core',
+    '@vue/runtime-dom',
+    // Módulos de oxc-parser que tienen dependencias específicas de WASM
+    'oxc-parser',
+    'oxc-parser/wasm',
+    'oxc-minify',
+    'oxc-minify/browser',
+    '@oxc-parser/binding-wasm32-wasi',
+    '@oxc-minify/binding-wasm32-wasi',
+    // Módulos de TypeScript que pueden tener resoluciones complejas
+    'typescript',
+    'typescript/lib/typescript',
+    // Módulos de herramientas de build y utilidades que deben mantenerse originales
+    'yargs',
+    'yargs/helpers',
+    'yargs-parser',
+    'chalk',
+    'browser-sync',
+    'chokidar',
+    'get-port',
+    'execa',
+    'find-root',
+    'fs-extra',
+    'minimatch', // ✅ Incluir minimatch aquí
+]);
+//# sourceMappingURL=excluded-modules.js.map

package/dist/utils/module-resolver.js

@@ -5,35 +5,7 @@ import { cwd, env } from 'node:process';
 // import pkg from '/node_modules/enhanced-resolve/lib/index.js';
 // import resolve from '/node_modules/resolve/index.js';
 import { logger } from '../servicios/logger.js';
-// Lista de módulos que deben ser excluidos de la resolución automática de rutas
-// Estos módulos se mantienen con su importación original sin transformar
-const EXCLUDED_MODULES = new Set([
-    'vue/compiler-sfc',
-    'vue/dist/vue.runtime.esm-bundler',
-    '@vue/compiler-sfc',
-    '@vue/compiler-dom',
-    '@vue/runtime-core',
-    '@vue/runtime-dom', // Módulos de oxc-parser que tienen dependencias específicas de WASM
-    'oxc-parser',
-    'oxc-parser/wasm',
-    'oxc-minify',
-    'oxc-minify/browser',
-    '@oxc-parser/binding-wasm32-wasi',
-    '@oxc-minify/binding-wasm32-wasi',
-    // Módulos de TypeScript que pueden tener resoluciones complejas
-    'typescript',
-    // Agregar más módulos problemáticos aquí según sea necesario
-    'yargs',
-    'yargs/helpers',
-    'yargs-parser',
-    'chalk',
-    'browser-sync',
-    'chokidar',
-    'get-port',
-    'execa',
-    'find-root',
-    'fs-extra',
-]);
+import { EXCLUDED_MODULES } from './excluded-modules.js';
 // function resolveESMWithLibrary(moduleName: string): string | null {
 //     try {
 //         // Resolver el módulo
@@ -256,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)) {
@@ -266,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;
@@ -409,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;
@@ -456,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.1",
+    "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": {
@@ -52,6 +52,7 @@
         "find-root": "^1.1.0",
         "fs-extra": "^11.3.0",
         "get-port": "^7.1.0",
+        "minimatch": "^10.0.1",
         "oxc-minify": "^0.72.3",
         "oxc-parser": "^0.72.3",
         "oxc-transform": "^0.72.3",