versacompiler 2.0.8 → 2.2.0

package/dist/main.js

@@ -1,8 +1,354 @@
 #!/usr/bin/env node
-import e from"node:path";import t,{env as n}from"node:process";import{fileURLToPath as r}from"node:url";import{logger as i}from"./servicios/logger.js";import{readConfig as a}from"./servicios/readConfig.js";let o,s,c;n.PATH_PROY=e.dirname(r(import.meta.url)),n.PATH_CONFIG_FILE=e.resolve(t.cwd(),`versacompile.config.ts`);async function l(){return o||=(await import(`chalk`)).default,o}async function u(){try{let t=await import(`node:fs/promises`),i=e.resolve(n.PATH_PROY||e.dirname(r(import.meta.url)),`..`,`package.json`),a=await t.readFile(i,`utf-8`),o=JSON.parse(a);return o.version||`unknown`}catch{return`unknown`}}async function d(){if(!s){let e=await import(`yargs`),t=await import(`yargs/helpers`);s=e.default,c=t.hideBin}return{yargs:s,hideBin:c}}async function f(){return await import(`./compiler/compile.js`)}async function p(){return await import(`./servicios/browserSync.js`)}async function m(){return await import(`./servicios/file-watcher.js`)}async function h(){return await import(`./servicios/readConfig.js`)}function g(){i.info(`VersaCompiler cerrado correctamente`)}async function _(){let{yargs:r,hideBin:o}=await d(),s=await l(),c=r(o(t.argv)).scriptName(`versa`).usage(s.blue(`VersaCompiler`)+` - Compilador de archivos Vue/TS/JS`).option(`init`,{type:`boolean`,description:`Inicializar la configuración`}).option(`watch`,{type:`boolean`,description:`Habilitar el modo de observación (watch)`,default:!1}).alias(`w`,`watch`).option(`all`,{type:`boolean`,description:`Compilar todos los archivos`}).option(`file`,{type:`string`,description:`Compilar un archivo específico`,alias:`f`}).option(`prod`,{type:`boolean`,description:`Modo producción`}).alias(`p`,`prod`).option(`verbose`,{type:`boolean`,description:`Habilitar salida detallada (verbose)`,default:!1}).alias(`v`,`verbose`).option(`cleanOutput`,{type:`boolean`,description:`Limpiar el directorio de salida antes de compilar`,default:!1}).alias(`co`,`cleanOutput`).option(`cleanCache`,{type:`boolean`,description:`Limpiar el cache de compilación antes de compilar`,default:!1}).alias(`cc`,`cleanCache`).option(`yes`,{type:`boolean`,description:`Confirmar automáticamente las acciones que requieren confirmación`,default:!1}).alias(`y`,`yes`).option(`typeCheck`,{type:`boolean`,description:`Habilitar/Deshabilitar la verificación de tipos. Por defecto --typeCheck=false`,default:!1}).alias(`t`,`typeCheck`);n.tailwindcss!==`false`&&(c=c.option(`tailwind`,{type:`boolean`,description:`Habilitar/Deshabilitar compilación de Tailwind CSS. Por defecto --tailwind=false`,default:!1})),n.linter!==`false`&&(c=c.option(`linter`,{type:`boolean`,description:`Habilitar/Deshabilitar el linter. Por defecto --linter=false`,default:!1}));let _=await c.help().alias(`h`,`help`).command(`* [files...]`,`Compilar archivos específicos`,e=>e.positional(`files`,{describe:`Archivos para compilar`,type:`string`,array:!0})).parse();try{let r=await u(),o=`━`.repeat(60);if(i.log(`
-`+s.cyan(o)+`
-`+s.bold.cyan(`  ⚡ VersaCompiler `)+s.gray(`v${r}`)+`
-`+s.gray(`  Vue · TypeScript · JavaScript Compiler`)+`
-`+s.cyan(o)+`
-`),_.init){i.info(`Iniciando la configuración...`);let{initConfig:e}=await h();await e(),t.exit(0)}await a()||t.exit(1),n.isPROD=_.prod?`true`:`false`,n.isALL=_.all?`true`:`false`,n.TAILWIND=_.tailwind===void 0?`true`:String(_.tailwind),n.ENABLE_LINTER=String(_.linter),n.VERBOSE=_.verbose?`true`:`false`,i.info(s.bold.blue(`⚙️  Configuración`)),i.info(s.gray(`   ┌─ Modo de ejecución`));let c=[{label:`Observar`,value:_.watch,icon:`👀`},{label:`Todos los archivos`,value:n.isALL===`true`,icon:`📁`},{label:`Archivo único`,value:!!_.file,icon:`📄`},{label:`Producción`,value:n.isPROD===`true`,icon:`🏭`}],l=[{label:`Tailwind`,value:n.TAILWIND===`true`,icon:`🎨`},{label:`Minificación`,value:n.isPROD===`true`,icon:`🗜️`},{label:`Linter`,value:n.ENABLE_LINTER===`true`,icon:`🔍`},{label:`Verificar tipos`,value:_.typeCheck,icon:`📘`},{label:`Detallado`,value:n.VERBOSE===`true`,icon:`📝`}];if(c.forEach(e=>{let t=e.value?s.green(`●`):s.gray(`○`),n=e.value?s.green(e.label):s.gray(e.label);i.info(s.gray(`   │  `)+t+` ${e.icon} ${n}`)}),i.info(s.gray(`   ├─ Características`)),l.forEach(e=>{let t=e.value?s.green(`●`):s.gray(`○`),n=e.value?s.green(e.label):s.gray(e.label);i.info(s.gray(`   │  `)+t+` ${e.icon} ${n}`)}),_.file&&(i.info(s.gray(`   ├─ Objetivo`)),i.info(s.gray(`   │  `)+s.blue(`📄 `)+_.file)),_.cleanOutput&&(i.info(s.gray(`   ├─ Limpieza`)),i.info(s.gray(`   │  `)+s.yellow(`🧹 Limpiar salida`))),_.cleanCache&&i.info(s.gray(`   │  `)+s.yellow(`🗑️  Limpiar caché`)),i.info(s.gray(`   └─ ¡Listo para compilar!`)),i.log(``),n.typeCheck=_.typeCheck?`true`:`false`,n.cleanCache=_.cleanCache?`true`:`false`,n.yes=_.y?`true`:`false`,_.cleanOutput){let{cleanOutputDir:e}=await m();await e(n.PATH_DIST||`./dist`)}if(_.files&&_.files.length>0){i.info(s.yellow(`📄 Compilando ${_.files.length} archivo(s)...`));let e=await import(`node:fs/promises`),{compileFile:n}=await f(),r=!1;for(let t of _.files)try{await e.access(t),i.info(s.blue(`🔄 Compilando: ${t}`));let a=await n(t);a.success?i.info(s.green(`✅ ${t} → ${a.output}`)):(i.error(s.red(`❌ Error al compilar: ${t}`)),r=!0)}catch{i.error(s.red(`❌ El archivo '${t}' no existe.`)),r=!0}t.exit(r?1:0)}if(_.file){i.info(s.yellow(`📄 Compilando archivo: ${_.file}`));let n=await import(`node:fs/promises`),{compileFile:r}=await f(),a;try{await n.access(_.file),a=e.resolve(_.file)}catch{i.error(s.red(`❌ Error: El archivo '${_.file}' no existe.`)),t.exit(1)}let o=await r(a);o.success?(i.info(s.green(`✅ Archivo compilado exitosamente: ${o.output}`)),t.exit(0)):(i.error(s.red(`❌ Error al compilar el archivo: ${_.file}`)),t.exit(1))}if(_.all){let{initCompileAll:e}=await f();await e(),t.exit(0)}if(!_.watch&&n.ENABLE_LINTER===`true`){let{runLinter:e}=await f();await e(!0),t.exit(1)}if(n.TAILWIND===`true`){let e=await import(`./compiler/tailwindcss.js`),t=await e.generateTailwindCSS();if(typeof t!=`boolean`)if(t?.success)i.info(`\nTailwind CSS compilado🎨 ${t.message}\n`);else{let e=`${t.message}${t.details?`
-`+t.details:``}`;i.error(`\n❌ Error al generar Tailwind CSS: ${e}\n`)}}let d,v;if(_.watch){let{browserSyncServer:e}=await p(),{initChokidar:n}=await m();d=await e(),d||t.exit(1),v=await n(d),v||t.exit(1)}t.on(`SIGINT`,async()=>{d&&d.exit(),v&&v.close(),g(),t.exit(0)}),t.on(`SIGTERM`,async()=>{g(),t.exit(0)})}catch(e){i.error(`Error en la aplicación:`,e),g(),t.exit(1)}}_();
+import * as path from 'node:path';
+import * as processModule from 'node:process';
+const { env } = processModule;
+// Usar el objeto process global para event listeners
+const globalProcess = globalThis.process || processModule;
+// Lazy loading optimizations - Only import lightweight modules synchronously
+import { fileURLToPath } from 'node:url';
+import { logger } from './servicios/logger.js';
+import { readConfig } from './servicios/readConfig.js';
+// Heavy dependencies will be loaded dynamically when needed
+let chalk;
+let yargs;
+let hideBin;
+// Obtener el directorio del archivo actual (src/)
+env.PATH_PROY = path.dirname(fileURLToPath(import.meta.url));
+env.PATH_CONFIG_FILE = path.resolve(globalProcess.cwd(), 'versacompile.config.ts');
+// Lazy loading helper functions
+async function loadChalk() {
+    if (!chalk) {
+        chalk = (await import('chalk')).default;
+    }
+    return chalk;
+}
+// Función para obtener la versión del package.json
+async function getPackageVersion() {
+    try {
+        const fs = await import('node:fs/promises');
+        const packageJsonPath = path.resolve(env.PATH_PROY || path.dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+        const packageContent = await fs.readFile(packageJsonPath, 'utf-8');
+        const packageData = JSON.parse(packageContent);
+        return packageData.version || 'unknown';
+    }
+    catch {
+        // Fallback si no se puede leer el package.json
+        return 'unknown';
+    }
+}
+async function loadYargs() {
+    if (!yargs) {
+        const yargsModule = await import('yargs');
+        const helpersModule = await import('yargs/helpers');
+        yargs = yargsModule.default;
+        hideBin = helpersModule.hideBin;
+    }
+    return { yargs, hideBin };
+}
+async function loadCompilerModule() {
+    return await import('./compiler/compile.js');
+}
+async function loadBrowserSyncModule() {
+    return await import('./servicios/browserSync.js');
+}
+async function loadChokidarModule() {
+    return await import('./servicios/file-watcher.js');
+}
+async function loadConfigModule() {
+    return await import('./servicios/readConfig.js');
+}
+function stopCompile() {
+    logger.info('VersaCompiler cerrado correctamente');
+}
+async function main() {
+    // Load yargs dynamically
+    const { yargs: yargsInstance, hideBin: hideBinFn } = await loadYargs();
+    const chalk = await loadChalk();
+    let yargInstance = yargsInstance(hideBinFn(globalProcess.argv))
+        .scriptName('versa')
+        .usage(chalk.blue('VersaCompiler') + ' - Compilador de archivos Vue/TS/JS')
+        .option('init', {
+        type: 'boolean',
+        description: 'Inicializar la configuración',
+    })
+        .option('watch', {
+        type: 'boolean',
+        description: 'Habilitar el modo de observación (watch)',
+        default: false, // Por defecto, el modo watch está habilitado
+    })
+        .alias('w', 'watch')
+        .option('all', {
+        type: 'boolean',
+        description: 'Compilar todos los archivos',
+    })
+        .option('file', {
+        type: 'string',
+        description: 'Compilar un archivo específico',
+        alias: 'f',
+    })
+        .option('prod', {
+        type: 'boolean',
+        description: 'Modo producción',
+    })
+        .alias('p', 'prod')
+        .option('verbose', {
+        type: 'boolean',
+        description: 'Habilitar salida detallada (verbose)',
+        default: false, // Por defecto, verbose está deshabilitado
+    })
+        .alias('v', 'verbose')
+        .option('cleanOutput', {
+        type: 'boolean',
+        description: 'Limpiar el directorio de salida antes de compilar',
+        default: false, // Por defecto, clean está deshabilitado
+    })
+        .alias('co', 'cleanOutput')
+        .option('cleanCache', {
+        type: 'boolean',
+        description: 'Limpiar el cache de compilación antes de compilar',
+        default: false, // Por defecto, clean está deshabilitado
+    })
+        .alias('cc', 'cleanCache')
+        .option('yes', {
+        type: 'boolean',
+        description: 'Confirmar automáticamente las acciones que requieren confirmación',
+        default: false, // Por defecto, no se confirma automáticamente
+    })
+        .alias('y', 'yes')
+        .option('typeCheck', {
+        type: 'boolean',
+        description: 'Habilitar/Deshabilitar la verificación de tipos. Por defecto --typeCheck=false',
+        default: false,
+    })
+        .alias('t', 'typeCheck');
+    // 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') {
+        yargInstance = yargInstance.option('tailwind', {
+            type: 'boolean',
+            description: 'Habilitar/Deshabilitar compilación de Tailwind CSS. Por defecto --tailwind=false',
+            default: false,
+        });
+    }
+    if (env.linter !== 'false') {
+        yargInstance = yargInstance.option('linter', {
+            type: 'boolean',
+            description: 'Habilitar/Deshabilitar el linter. Por defecto --linter=false',
+            default: false,
+        });
+    }
+    const argv = (await yargInstance
+        .help()
+        .alias('h', 'help')
+        .command('* [files...]', 'Compilar archivos específicos', (yargs) => {
+        return yargs.positional('files', {
+            describe: 'Archivos para compilar',
+            type: 'string',
+            array: true,
+        });
+    })
+        .parse());
+    try {
+        // 🎨 Header moderno y elegante
+        const version = await getPackageVersion();
+        const headerLine = '━'.repeat(60);
+        logger.log(`\n` +
+            chalk.cyan(headerLine) +
+            `\n` +
+            chalk.bold.cyan('  ⚡ VersaCompiler ') +
+            chalk.gray(`v${version}`) +
+            `\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();
+            await initConfig();
+            globalProcess.exit(0);
+        }
+        if (!(await readConfig())) {
+            globalProcess.exit(1);
+        }
+        env.isPROD = argv.prod ? 'true' : 'false';
+        env.isALL = argv.all ? 'true' : 'false';
+        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
+        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';
+        if (argv.cleanOutput) {
+            const { cleanOutputDir } = await loadChokidarModule();
+            await cleanOutputDir(env.PATH_DIST || './dist');
+        }
+        // Manejar archivos pasados como argumentos posicionales
+        if (argv.files && argv.files.length > 0) {
+            logger.info(chalk.yellow(`📄 Compilando ${argv.files.length} archivo(s)...`));
+            const fs = await import('node:fs/promises');
+            const { compileFile } = await loadCompilerModule();
+            let hasErrors = false;
+            for (const file of argv.files) {
+                try {
+                    // Verificar si el archivo existe
+                    await fs.access(file);
+                    logger.info(chalk.blue(`🔄 Compilando: ${file}`));
+                    const result = await compileFile(file);
+                    if (result.success) {
+                        logger.info(chalk.green(`✅ ${file} → ${result.output}`));
+                    }
+                    else {
+                        logger.error(chalk.red(`❌ Error al compilar: ${file}`));
+                        hasErrors = true;
+                    }
+                }
+                catch {
+                    logger.error(chalk.red(`❌ El archivo '${file}' no existe.`));
+                    hasErrors = true;
+                }
+            }
+            globalProcess.exit(hasErrors ? 1 : 0);
+        }
+        if (argv.file) {
+            // Compilar archivo individual
+            logger.info(chalk.yellow(`📄 Compilando archivo: ${argv.file}`)); // Verificar si el archivo existe
+            const fs = await import('node:fs/promises');
+            const { compileFile } = await loadCompilerModule();
+            let absolutePathFile;
+            try {
+                await fs.access(argv.file);
+                absolutePathFile = path.resolve(argv.file);
+            }
+            catch {
+                logger.error(chalk.red(`❌ Error: El archivo '${argv.file}' no existe.`));
+                globalProcess.exit(1);
+            }
+            // Compilar el archivo (absolutePathFile está garantizado aquí)
+            const result = await compileFile(absolutePathFile);
+            if (result.success) {
+                logger.info(chalk.green(`✅ Archivo compilado exitosamente: ${result.output}`));
+                globalProcess.exit(0);
+            }
+            else {
+                logger.error(chalk.red(`❌ Error al compilar el archivo: ${argv.file}`));
+                globalProcess.exit(1);
+            }
+        }
+        if (argv.all) {
+            const { initCompileAll } = await loadCompilerModule();
+            await initCompileAll();
+            globalProcess.exit(0);
+        }
+        if (!argv.watch) {
+            if (env.ENABLE_LINTER === 'true') {
+                const { runLinter } = await loadCompilerModule();
+                await runLinter(true);
+                globalProcess.exit(1);
+            }
+        }
+        if (env.TAILWIND === 'true') {
+            const tailwindModule = await import('./compiler/tailwindcss.js');
+            const resultTW = await tailwindModule.generateTailwindCSS();
+            if (typeof resultTW !== 'boolean') {
+                if (resultTW?.success) {
+                    logger.info(`\nTailwind CSS compilado🎨 ${resultTW.message}\n`);
+                }
+                else {
+                    const errorMsg = `${resultTW.message}${resultTW.details ? '\n' + resultTW.details : ''}`;
+                    logger.error(`\n❌ Error al generar Tailwind CSS: ${errorMsg}\n`);
+                }
+            }
+        }
+        let bs;
+        let watch;
+        if (argv.watch) {
+            const { browserSyncServer } = await loadBrowserSyncModule();
+            const { initChokidar } = await loadChokidarModule();
+            bs = await browserSyncServer();
+            if (!bs) {
+                globalProcess.exit(1);
+            }
+            watch = await initChokidar(bs);
+            if (!watch) {
+                globalProcess.exit(1);
+            }
+        }
+        // ✨ FIX: Cleanup handler para evitar acumulación de listeners
+        const cleanupHandler = async () => {
+            if (bs) {
+                bs.exit();
+            }
+            if (watch) {
+                // ✨ FIX #3: Usar nuevo método cleanupWatcher
+                const { cleanupWatcher } = await loadChokidarModule();
+                await cleanupWatcher(watch);
+            }
+            stopCompile();
+            globalProcess.exit(0);
+        };
+        const sigintHandler = () => cleanupHandler();
+        const sigtermHandler = () => cleanupHandler();
+        globalProcess.on('SIGINT', sigintHandler);
+        globalProcess.on('SIGTERM', sigtermHandler);
+    }
+    catch (error) {
+        logger.error('Error en la aplicación:', error);
+        stopCompile();
+        globalProcess.exit(1);
+    }
+}
+main();
+//# sourceMappingURL=main.js.map