versacompiler 2.1.0 → 2.2.0

package/dist/servicios/file-watcher.js

@@ -1,4 +1,425 @@
-import{readdir as e,rm as r,stat as i,unlink as a}from"node:fs/promises";import o from"node:path";import s,{env as c}from"node:process";import*as l from"chokidar";import{minimatch as u}from"minimatch";import{getOutputPath as d,initCompile as f,normalizeRuta as p}from"../compiler/compile.js";import{promptUser as m}from"../utils/promptUser.js";import{emitirCambios as h}from"./browserSync.js";import{logger as g}from"./logger.js";let _;async function v(){return _||(_=(await import(`chalk`)).default),_}class y{pendingChanges=new Map;debounceTimer=null;DEBOUNCE_DELAY=100;BATCH_SIZE=10;isProcessing=!1;browserSyncInstance=null;setBrowserSyncInstance(e){this.browserSyncInstance=e}cleanup(){this.debounceTimer&&(clearTimeout(this.debounceTimer),this.debounceTimer=null),this.pendingChanges.clear(),this.isProcessing=!1,this.browserSyncInstance=null}addChange(e,r,i,a=!1){let o=p(e);this.pendingChanges.set(o,{filePath:o,action:r,timestamp:Date.now(),extensionAction:i,isAdditionalFile:a}),this.resetDebounceTimer()}resetDebounceTimer(){this.debounceTimer&&clearTimeout(this.debounceTimer),this.debounceTimer=setTimeout(()=>{this.processPendingChanges()},this.DEBOUNCE_DELAY)}async processPendingChanges(){if(this.isProcessing||this.pendingChanges.size===0)return;this.isProcessing=!0;let e=Array.from(this.pendingChanges.values());this.pendingChanges.clear();try{let r=e.filter(e=>e.action===`unlink`),i=e.filter(e=>e.action===`add`||e.action===`change`);r.length>0&&await this.processDeleteChanges(r),i.length>0&&await this.processCompileChanges(i)}catch(e){let r=await v();g.error(r.red(`🚩 Error procesando cambios en batch: ${e instanceof Error?e.message:String(e)}`))}finally{this.isProcessing=!1,this.pendingChanges.size>0&&this.resetDebounceTimer()}}async processDeleteChanges(e){for(let r of e)r.isAdditionalFile?(g.info(`\n🗑️ Archivo adicional eliminado: ${r.filePath}`),h(this.browserSyncInstance,`reloadFull`,r.filePath)):(g.info(`\n🗑️ Eliminando archivo compilado: ${r.filePath}`),await S(d(r.filePath))&&(g.info(`Archivo eliminado: ${r.filePath}`),h(this.browserSyncInstance,`reloadFull`,r.filePath)))}async processCompileChanges(e){let r=e.filter(e=>e.isAdditionalFile),i=e.filter(e=>!e.isAdditionalFile);r.length>0&&await this.processAdditionalFiles(r),i.length>0&&await this.processCompilableFiles(i)}async processCompilableFiles(e){let r=await v();for(let i=0;i<e.length;i+=this.BATCH_SIZE){let a=e.slice(i,i+this.BATCH_SIZE);a.length>1&&g.info(r.cyan(`📦 Procesando batch de ${a.length} archivos compilables (${i+1}-${Math.min(i+this.BATCH_SIZE,e.length)} de ${e.length})`));let o=a.map(e=>this.compileFile(e));await Promise.allSettled(o)}e.length>1&&g.info(r.green(`✅ Batch completado: ${e.length} archivos compilados`))}async processAdditionalFiles(e){let r=await v();g.info(r.blue(`🔄 Recargando ${e.length} archivo(s) adicional(es) (sin compilación)`));for(let r of e)g.info(`📄 Archivo adicional modificado: ${r.filePath}`),h(this.browserSyncInstance,`reloadFull`,r.filePath)}async compileFile(e){try{let r=await f(e.filePath,!0,`watch`);if(r.success){let i=r.action||e.extensionAction;i=i===`extension`?e.extensionAction:i,h(this.browserSyncInstance,i||`reloadFull`,r.output)}}catch(r){let i=await v();g.error(i.red(`🚩 Error compilando ${e.filePath}: ${r instanceof Error?r.message:String(r)}`))}}getStats(){return{pendingChanges:this.pendingChanges.size,isProcessing:this.isProcessing,hasTimer:this.debounceTimer!==null}}}const b=new y;export async function cleanOutputDir(l,u=!0){try{if(!l)throw Error(`El directorio de salida no está definido`);if(u){let e=await i(l).catch(()=>null);if(!e||!e.isDirectory()){g.error(`🚩 El directorio de salida no existe o no es un directorio: ${l}`);return}try{if(c.yes===`false`&&(await m(`
-
-¿Estás seguro deseas limpiar la carpeta `+(await v()).yellow(l)+`? (s / N) : `)).toLowerCase()!==`s`){g.info(`🛑 Compilación cancelada por el usuario.`),s.env.NODE_ENV!==`test`&&s.exit(0);return}}catch(e){throw g.error(`Error en la entrada del usuario: ${e}`),s.env.NODE_ENV!==`test`&&s.exit(1),e}}let d=await v();g.info(`🗑️ Limpiando directorio de salida: ${d.yellow(l)}\n`);let f=await e(l);await Promise.all(f.map(async e=>{let s=o.join(l,e);(await i(s)).isDirectory()?await r(s,{recursive:!0}):await a(s)})),g.info(`✅ Directorio limpiado: ${l}`)}catch(e){g.error(`🚩 Error al limpiar directorio de salida: ${e instanceof Error?e.message:String(e)}`)}}async function S(e){try{return await a(e),!0}catch(r){return g.error(`🚩 Error eliminando archivo ${e}: ${r instanceof Error?r.message:String(r)}`),!1}}function C(e,r){return r.filter(e=>e!==void 0).find(r=>r.ext===e.split(`.`).pop())?.action||`reloadFull`}function w(e,r){if(!r||r.length===0)return!1;let i=p(e);return r.some(e=>u(i,e.replace(/\\/g,`/`)))}export async function initChokidar(e){try{if(!c.PATH_SOURCE)throw g.error(`Error: La variable de entorno PATH_SOURCE no está definida.`),s.env.NODE_ENV!==`test`&&s.exit(1),Error(`PATH_SOURCE no está definida`);let r=`${c.PATH_SOURCE}/**/*.js`,i=`${c.PATH_SOURCE}/**/*.vue`,a=`${c.PATH_SOURCE}/**/*.ts`,o=`${c.PATH_SOURCE}/**/*.cjs`,u=`${c.PATH_SOURCE}/**/*.mjs`,d=JSON.parse(c.aditionalWatch||`[]`),f=[r,i,a,o,u,...d],p={vue:`HRMVue`,js:`HRMHelper`,ts:`HRMHelper`,cjs:`HRMHelper`,mjs:`HRMHelper`},m=f.map(e=>{let r=e.split(`.`).pop();if(r)return{ext:r,action:p[r]||`reloadFull`}});if(m.length===0||m[0]===void 0)throw Error(`No se encontraron extensiones para observar`);let h=RegExp(`\\.(?!${m.filter(e=>e!==void 0).map(e=>e.ext).join(`$|`)}$).+$`);f=f.map(e=>e.replace(/\/\*\*\//g,`/`));let _=new Map;f.forEach(e=>{let r=e.substring(0,e.lastIndexOf(`/`));_.has(r)||_.set(r,[]),_.get(r).push(e)});let y=Array.from(_.keys()),x=l.watch(y,{persistent:!0,ignoreInitial:!0,ignored:h});return x.on(`ready`,async()=>{let e=await v();g.info(e.green(`👀 : Listo para observar \n${f.map(e=>`${e}`).join(`
-`)}\n`))}),b.setBrowserSyncInstance(e),x.on(`add`,async e=>{let r=w(e,d),i=C(e,m.filter(e=>e!==void 0));b.addChange(e,`add`,i,r)}),x.on(`change`,async e=>{let r=w(e,d),i=C(e,m.filter(e=>e!==void 0));b.addChange(e,`change`,i,r)}),x.on(`unlink`,async e=>{let r=C(e,m.filter(e=>e!==void 0)),i=w(e,d);b.addChange(e,`unlink`,r,i)}),x}catch(e){throw g.error(`🚩 :Error al iniciar watch: ${e instanceof Error?e.message:String(e)}`),s.env.NODE_ENV!==`test`&&s.exit(1),e}}export async function cleanupWatcher(e){try{console.log(`[FileWatcher] Limpiando recursos...`),b.cleanup(),e&&await e.close(),console.log(`[FileWatcher] Recursos limpiados correctamente`)}catch(e){console.error(`[FileWatcher] Error al limpiar recursos:`,e instanceof Error?e.message:String(e))}}
+import { readdir, rm, stat, unlink } from 'node:fs/promises';
+import * as path from 'node:path';
+import * as process from 'node:process';
+const { env } = 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';
+import { logger } from './logger.js';
+// Lazy loading para chalk
+let chalk;
+async function loadChalk() {
+    if (!chalk) {
+        chalk = (await import('chalk')).default;
+    }
+    return chalk;
+}
+class WatchDebouncer {
+    pendingChanges = new Map();
+    debounceTimer = null;
+    DEBOUNCE_DELAY = 50; // ✨ OPTIMIZACIÓN: 50ms para hot reload más responsive
+    BATCH_SIZE = 10; // Máximo archivos por batch
+    isProcessing = false;
+    browserSyncInstance = null; // ✨ Almacenar referencia a browserSync
+    /**
+     * Establece la instancia de browserSync
+     */
+    setBrowserSyncInstance(bs) {
+        this.browserSyncInstance = bs;
+    }
+    /**
+     * ✨ FIX #3: Limpia todos los recursos del debouncer
+     */
+    cleanup() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        this.pendingChanges.clear();
+        this.isProcessing = false;
+        this.browserSyncInstance = null;
+    }
+    /**
+     * Añade un cambio al sistema de debouncing
+     */
+    addChange(filePath, action, extensionAction, isAdditionalFile = false) {
+        // Normalizar ruta para evitar duplicados
+        const normalizedPath = normalizeRuta(filePath);
+        // Agregar o actualizar el cambio pendiente
+        this.pendingChanges.set(normalizedPath, {
+            filePath: normalizedPath,
+            action,
+            timestamp: Date.now(),
+            extensionAction,
+            isAdditionalFile,
+        });
+        // Reiniciar el timer de debounce
+        this.resetDebounceTimer();
+    }
+    /**
+     * Reinicia el timer de debounce
+     */
+    resetDebounceTimer() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            this.processPendingChanges();
+        }, this.DEBOUNCE_DELAY);
+    }
+    /**
+     * Procesa todos los cambios pendientes en batch
+     */
+    async processPendingChanges() {
+        if (this.isProcessing || this.pendingChanges.size === 0) {
+            return;
+        }
+        this.isProcessing = true;
+        const changes = Array.from(this.pendingChanges.values());
+        this.pendingChanges.clear();
+        try {
+            // Agrupar por tipo de acción para optimización
+            const deleteChanges = changes.filter(c => c.action === 'unlink');
+            const compileChanges = changes.filter(c => c.action === 'add' || c.action === 'change');
+            // Procesar eliminaciones primero
+            if (deleteChanges.length > 0) {
+                await this.processDeleteChanges(deleteChanges);
+            }
+            // Procesar compilaciones en batches
+            if (compileChanges.length > 0) {
+                await this.processCompileChanges(compileChanges);
+            }
+        }
+        catch (error) {
+            const chalkInstance = await loadChalk();
+            logger.error(chalkInstance.red(`🚩 Error procesando cambios en batch: ${error instanceof Error ? error.message : String(error)}`));
+        }
+        finally {
+            this.isProcessing = false;
+            // Si hay más cambios pendientes, procesarlos
+            if (this.pendingChanges.size > 0) {
+                this.resetDebounceTimer();
+            }
+        }
+    } /**
+     * Procesa cambios de eliminación
+     */
+    async processDeleteChanges(deleteChanges) {
+        for (const change of deleteChanges) {
+            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 < 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 compilables (${i + 1}-${Math.min(i + this.BATCH_SIZE, compilableFiles.length)} de ${compilableFiles.length})`));
+            }
+            const promises = batch.map(change => this.compileFile(change));
+            await Promise.allSettled(promises);
+        }
+        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);
+        }
+    }
+    /**
+     * Compila un archivo individual
+     */
+    async compileFile(change) {
+        try {
+            const result = await initCompile(change.filePath, true, 'watch');
+            if (result.success) {
+                let accion = result.action || change.extensionAction;
+                accion =
+                    accion === 'extension' ? change.extensionAction : accion;
+                emitirCambios(this.browserSyncInstance, accion || 'reloadFull', result.output);
+            }
+        }
+        catch (error) {
+            const chalkInstance = await loadChalk();
+            logger.error(chalkInstance.red(`🚩 Error compilando ${change.filePath}: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+    /**
+     * Obtiene estadísticas del debouncer
+     */
+    getStats() {
+        return {
+            pendingChanges: this.pendingChanges.size,
+            isProcessing: this.isProcessing,
+            hasTimer: this.debounceTimer !== null,
+        };
+    }
+}
+// Instancia global del debouncer
+const watchDebouncer = new WatchDebouncer();
+// const cacheImportMap = new Map<string, string[]>();
+// const cacheComponentMap = new Map<string, string[]>();
+export async function cleanOutputDir(outputDir, primerInteraccion = true) {
+    try {
+        if (!outputDir) {
+            throw new Error('El directorio de salida no está definido');
+        }
+        if (primerInteraccion) {
+            const stats = await stat(outputDir).catch(() => null);
+            if (!stats || !stats.isDirectory()) {
+                logger.error(`🚩 El directorio de salida no existe o no es un directorio: ${outputDir}`);
+                return;
+            }
+            try {
+                if (env.yes === 'false') {
+                    const chalkInstance = await loadChalk();
+                    const answer = await promptUser('\n\n¿Estás seguro deseas limpiar la carpeta ' +
+                        chalkInstance.yellow(outputDir) +
+                        '? (s / N) : ');
+                    if (answer.toLowerCase() !== 's') {
+                        logger.info('🛑 Compilación cancelada por el usuario.');
+                        if (process.env.NODE_ENV !== 'test') {
+                            process.exit(0);
+                        }
+                        return;
+                    }
+                }
+            }
+            catch (error) {
+                logger.error(`Error en la entrada del usuario: ${error}`);
+                if (process.env.NODE_ENV !== 'test') {
+                    process.exit(1);
+                }
+                throw error;
+            }
+        }
+        const chalkInstance = await loadChalk();
+        logger.info(`🗑️ Limpiando directorio de salida: ${chalkInstance.yellow(outputDir)}\n`);
+        const items = await readdir(outputDir);
+        await Promise.all(items.map(async (item) => {
+            const itemPath = path.join(outputDir, item);
+            const itemStat = await stat(itemPath);
+            if (itemStat.isDirectory()) {
+                await rm(itemPath, { recursive: true });
+            }
+            else {
+                await unlink(itemPath);
+            }
+        }));
+        logger.info(`✅ Directorio limpiado: ${outputDir}`);
+    }
+    catch (error) {
+        logger.error(`🚩 Error al limpiar directorio de salida: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function deleteFile(filePath) {
+    try {
+        await unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        logger.error(`🚩 Error eliminando archivo ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+function getAction(ruta, extendsionWatch) {
+    const action = extendsionWatch
+        .filter((item) => item !== undefined)
+        .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.');
+            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`;
+        const watchTS = `${env.PATH_SOURCE}/**/*.ts`;
+        const watchCJS = `${env.PATH_SOURCE}/**/*.cjs`;
+        const watchMJS = `${env.PATH_SOURCE}/**/*.mjs`;
+        //TODO: agregar watch para CSS
+        const watchAditional = JSON.parse(env.aditionalWatch || '[]');
+        let fileWatch = [
+            watchJS,
+            watchVue,
+            watchTS,
+            watchCJS,
+            watchMJS,
+            ...watchAditional,
+        ];
+        //extraer sólo las extesniones  de fileWatch
+        const accionExtension = {
+            vue: 'HRMVue',
+            js: 'HRMHelper',
+            ts: 'HRMHelper',
+            cjs: 'HRMHelper',
+            mjs: 'HRMHelper',
+        };
+        const extendsionWatch = fileWatch.map(item => {
+            const ext = item.split('.').pop();
+            if (ext) {
+                return {
+                    ext,
+                    action: accionExtension[ext] ||
+                        'reloadFull',
+                };
+            }
+        });
+        if (extendsionWatch.length === 0 || extendsionWatch[0] === undefined) {
+            throw new Error('No se encontraron extensiones para observar');
+        }
+        const regExtExtension = new RegExp(`\\.(?!${extendsionWatch
+            .filter(item => item !== undefined)
+            .map(item => item.ext)
+            .join('$|')}$).+$`);
+        fileWatch = fileWatch.map(item => item.replace(/\/\*\*\//g, '/'));
+        const directories = new Map();
+        fileWatch.forEach(item => {
+            const dir = item.substring(0, item.lastIndexOf('/'));
+            if (!directories.has(dir)) {
+                directories.set(dir, []);
+            }
+            directories.get(dir).push(item);
+        });
+        const DirWatch = Array.from(directories.keys());
+        const watcher = chokidar.watch(DirWatch, {
+            persistent: true,
+            ignoreInitial: true,
+            ignored: regExtExtension,
+        });
+        // ✨ OPTIMIZACIÓN: Pre-cargar módulos críticos al iniciar el watcher
+        watcher.on('ready', async () => {
+            const chalkInstance = await loadChalk();
+            logger.info(chalkInstance.green(`👀 : Listo para observar \n${fileWatch
+                .map((item) => `${item}`)
+                .join('\n')}\n`));
+            // Pre-cargar módulos críticos para primera compilación más rápida
+            setImmediate(async () => {
+                try {
+                    // Pre-cargar módulos básicos que se usarán en compilación
+                    await Promise.all([
+                        import('../compiler/compile.js'),
+                        import('../compiler/parser.js'),
+                    ]);
+                }
+                catch {
+                    // Ignorar errores de pre-carga, no son críticos
+                }
+            });
+        });
+        // ✨ CONFIGURAR: Establecer la instancia de browserSync en el debouncer
+        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, 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, 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, isAdditional);
+        });
+        return watcher;
+    }
+    catch (error) {
+        logger.error(`🚩 :Error al iniciar watch: ${error instanceof Error ? error.message : String(error)}`);
+        if (process.env.NODE_ENV !== 'test') {
+            process.exit(1);
+        }
+        throw error;
+    }
+}
+/**
+ * ✨ FIX #3: Limpia todos los recursos de watch mode
+ * Cierra watchers y limpia timers para evitar fugas de memoria
+ */
+export async function cleanupWatcher(watcher) {
+    try {
+        console.log('[FileWatcher] Limpiando recursos...');
+        // 1. Limpiar debouncer
+        watchDebouncer.cleanup();
+        // 2. Cerrar watcher de chokidar
+        if (watcher) {
+            await watcher.close();
+        }
+        console.log('[FileWatcher] Recursos limpiados correctamente');
+    }
+    catch (error) {
+        console.error('[FileWatcher] Error al limpiar recursos:', error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=file-watcher.js.map

package/dist/servicios/logger.js

@@ -1,3 +1,63 @@
-import*as e from"node:process";let t=null;export function setProgressManagerGetter(e){t=e}class r{constructor(){e.stdout.write=e.stdout.write.bind(e.stdout),e.stderr.write=e.stderr.write.bind(e.stderr)}writeMessage(n,r=!1,i=!1){if(t){let e=t();if(e&&e.isActive()){i?e.addImmediateLog(n):e.addLog(n);return}}r?e.stderr.write(n+`
-`):e.stdout.write(n+`
-`)}log(...e){this.writeMessage(e.map(e=>String(e)).join(` `))}info(...t){let n=e.env.VERBOSE===`true`;this.writeMessage(t.map(e=>String(e)).join(` `),!1,n)}error(...e){this.writeMessage(e.map(e=>String(e)).join(` `),!0)}warn(...e){this.writeMessage(e.map(e=>String(e)).join(` `),!0)}debug(...e){this.writeMessage(e.map(e=>String(e)).join(` `))}fatal(...e){this.writeMessage(e.map(e=>String(e)).join(` `),!0)}table(e,t){let n=t?console.table(e,t):console.table(e);this.writeMessage(String(n))}}export const logger=new r;
+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) {
+        this.writeMessage(args.map(arg => String(arg)).join(' '));
+    }
+    info(...args) {
+        // En modo verbose, mostrar logs inmediatamente
+        const isVerbose = process.env.VERBOSE === 'true';
+        this.writeMessage(args.map(arg => String(arg)).join(' '), false, isVerbose);
+    }
+    error(...args) {
+        this.writeMessage(args.map(arg => String(arg)).join(' '), true);
+    }
+    warn(...args) {
+        this.writeMessage(args.map(arg => String(arg)).join(' '), true);
+    }
+    debug(...args) {
+        this.writeMessage(args.map(arg => String(arg)).join(' '));
+    }
+    fatal(...args) {
+        this.writeMessage(args.map(arg => String(arg)).join(' '), true);
+    }
+    table(data, title) {
+        const tableString = title
+            ? console.table(data, title)
+            : console.table(data);
+        this.writeMessage(String(tableString));
+    }
+}
+export const logger = new Logger();
+//# sourceMappingURL=logger.js.map