versacompiler 2.0.8 → 2.2.0

package/dist/servicios/browserSync.js

@@ -1,7 +1,589 @@
-import{createHash as e}from"node:crypto";import{promises as t}from"node:fs";import n from"node:path";import r,{env as i}from"node:process";import a from"browser-sync";import o from"get-port";import{promptUser as s}from"../utils/promptUser.js";import{getProxyInfo as c,validateProxyAvailability as l}from"../utils/proxyValidator.js";import{logger as u}from"./logger.js";class d{static instance;cache=new Map;MAX_CACHE_SIZE=200;MAX_CACHE_MEMORY=50*1024*1024;CACHE_TTL=900*1e3;currentMemoryUsage=0;cacheHits=0;cacheMisses=0;totalRequests=0;static getInstance(){return d.instance||=new d,d.instance}generateETag(t,n){let r=e(`md5`).update(`${t}:${n.mtime.getTime()}:${n.size}`).digest(`hex`);return`"${r}"`}getContentType(e){let t=n.extname(e).toLowerCase(),r={".js":`application/javascript`,".mjs":`application/javascript`,".ts":`application/javascript`,".css":`text/css`,".html":`text/html`,".json":`application/json`,".png":`image/png`,".jpg":`image/jpeg`,".jpeg":`image/jpeg`,".gif":`image/gif`,".svg":`image/svg+xml`,".ico":`image/x-icon`,".webp":`image/webp`,".avif":`image/avif`,".woff":`font/woff`,".woff2":`font/woff2`,".ttf":`font/ttf`,".eot":`application/vnd.ms-fontobject`,".map":`application/json`,".xml":`application/xml`,".txt":`text/plain`,".pdf":`application/pdf`,".zip":`application/zip`,".mp4":`video/mp4`,".mp3":`audio/mpeg`,".wav":`audio/wav`,".ogg":`audio/ogg`};return r[t]||`application/octet-stream`}shouldCache(e){let t=n.extname(e).toLowerCase(),r=[`.js`,`.mjs`,`.css`,`.json`,`.png`,`.jpg`,`.jpeg`,`.gif`,`.svg`,`.ico`,`.webp`,`.avif`,`.woff`,`.woff2`,`.ttf`,`.eot`,`.map`];return r.includes(t)}async getOrReadFile(e){this.totalRequests++;try{let n=await t.stat(e),r=n.mtime.getTime(),i=this.generateETag(e,n);if(!this.shouldCache(e)){let n=await t.readFile(e,`utf-8`);return{content:n,contentType:this.getContentType(e),etag:i,cached:!1}}let a=this.cache.get(e);if(a&&a.lastModified===r)return this.cacheHits++,{content:a.content,contentType:a.contentType,etag:a.etag,cached:!0};this.cacheMisses++;let o=this.isBinaryFile(e),s=await t.readFile(e,o?void 0:`utf-8`),c=this.getContentType(e);return this.addToCache(e,{content:s,contentType:c,lastModified:r,etag:i,size:n.size}),{content:s,contentType:c,etag:i,cached:!1}}catch{return null}}isBinaryFile(e){let t=n.extname(e).toLowerCase(),r=[`.png`,`.jpg`,`.jpeg`,`.gif`,`.ico`,`.webp`,`.avif`,`.woff`,`.woff2`,`.ttf`,`.eot`,`.pdf`,`.zip`,`.mp4`,`.mp3`,`.wav`,`.ogg`];return r.includes(t)}addToCache(e,t){try{this.evictIfNeeded(t.size);let n={content:t.content,contentType:t.contentType,lastModified:t.lastModified,etag:t.etag,size:t.size};this.cache.set(e,n),this.currentMemoryUsage+=t.size}catch(e){console.warn(`[BrowserSyncFileCache] Error cacheando archivo:`,e)}}evictIfNeeded(e){for(;this.cache.size>=this.MAX_CACHE_SIZE;)this.evictOldest();for(;this.currentMemoryUsage+e>this.MAX_CACHE_MEMORY&&this.cache.size>0;)this.evictOldest()}evictOldest(){let e=``,t=1/0;for(let[n,r]of this.cache)r.lastModified<t&&(t=r.lastModified,e=n);if(e){let t=this.cache.get(e);t&&(this.currentMemoryUsage-=t.size,this.cache.delete(e))}}invalidateFile(e){let t=this.cache.get(e);t&&(this.currentMemoryUsage-=t.size,this.cache.delete(e))}getStats(){let e=this.totalRequests>0?Math.round(this.cacheHits/this.totalRequests*100):0;return{cacheHits:this.cacheHits,cacheMisses:this.cacheMisses,hitRate:e,totalRequests:this.totalRequests,cacheSize:this.cache.size,maxCacheSize:this.MAX_CACHE_SIZE,memoryUsage:this.currentMemoryUsage,maxMemoryUsage:this.MAX_CACHE_MEMORY}}clear(){this.cache.clear(),this.currentMemoryUsage=0,this.cacheHits=0,this.cacheMisses=0,this.totalRequests=0}}const f=d.getInstance(),p=async()=>{let{default:e}=await import(`chalk`);return e};export async function browserSyncServer(){try{let e=null,t=i.AssetsOmit===`true`,d={server:`./`};if(i.proxyUrl){u.info(`🔍 Validando disponibilidad del servidor proxy: ${i.proxyUrl}`);let e=await l(i.proxyUrl,5e3);if(e)u.info(`✅ Servidor proxy disponible`);else{let e=c(i.proxyUrl);u.warn(`⚠️  El servidor proxy no está disponible:`),u.warn(`   Host: ${e.host}`),u.warn(`   Puerto: ${e.port}`),u.warn(`   Protocolo: ${e.protocol}`);let t=await s(`
-¿Desea continuar de todos modos? El modo proxy podría no funcionar correctamente. (s/n): `,3e4);t.toLowerCase().trim()!==`s`&&t.toLowerCase().trim()!==`si`&&(u.info(`🛑 Operación cancelada por el usuario.`),r.exit(0)),u.warn(`⚠️  Continuando con el servidor proxy no disponible...`)}d={proxy:i.proxyUrl}}let m=n.join(i.PATH_PROY||r.cwd(),`hrm`),h=r.cwd(),g=n.relative(h,m);e=a.create();let _=await o({port:3e3}),v=await o({port:4e3});return e.init({...d,files:[`${i.PATH_DIST}/**/*.css`],injectChanges:!0,open:!1,port:_,ui:{port:v},socket:{path:`/browser-sync/socket.io`},snippetOptions:{rule:{match:/<\/body>/i,fn:(e,t)=>`
-                            ${e}${t}
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import * as process from 'node:process';
+const { env } = process;
+import * as browserSync from 'browser-sync';
+
+import getPort from 'get-port';
+import { promptUser } from '../utils/promptUser.js';
+import { getProxyInfo, validateProxyAvailability, } from '../utils/proxyValidator.js';
+import { logger } from './logger.js';
+class BrowserSyncFileCache {
+    static instance;
+    cache = new Map();
+    MAX_CACHE_SIZE = 200; // Máximo archivos en cache
+    MAX_CACHE_MEMORY = 50 * 1024 * 1024; // 50MB límite
+    CACHE_TTL = 15 * 60 * 1000; // 15 minutos para archivos estáticos
+    currentMemoryUsage = 0;
+    // ✨ FIX #8: Intervalo de limpieza automática
+    cleanupInterval = null;
+    // Métricas
+    cacheHits = 0;
+    cacheMisses = 0;
+    totalRequests = 0;
+    constructor() {
+        // ✨ FIX #8: Iniciar limpieza automática cada 5 minutos
+        this.startAutoCleanup();
+    }
+    static getInstance() {
+        if (!BrowserSyncFileCache.instance) {
+            BrowserSyncFileCache.instance = new BrowserSyncFileCache();
+        }
+        return BrowserSyncFileCache.instance;
+    }
+    /**
+     * ✨ FIX #8: Inicia la limpieza automática de entradas expiradas
+     */
+    startAutoCleanup() {
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupExpiredEntries();
+        }, 5 * 60 * 1000); // Cada 5 minutos
+    }
+    /**
+     * ✨ FIX #8: Limpia entradas de cache expiradas
+     */
+    cleanupExpiredEntries() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [filePath, entry] of this.cache.entries()) {
+            if (now - entry.lastModified > this.CACHE_TTL) {
+                this.currentMemoryUsage -= entry.size;
+                this.cache.delete(filePath);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            console.log(`[BrowserSync] Limpiadas ${cleaned} entradas expiradas del cache`);
+        }
+    }
+    /**
+     * Genera ETag para el archivo basado en contenido y timestamp
+     */
+    generateETag(filePath, stats) {
+        const hash = createHash('md5')
+            .update(`${filePath}:${stats.mtime.getTime()}:${stats.size}`)
+            .digest('hex');
+        return `"${hash}"`;
+    }
+    /**
+     * Determina el Content-Type basado en la extensión del archivo
+     */
+    getContentType(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const mimeTypes = {
+            '.js': 'application/javascript',
+            '.mjs': 'application/javascript',
+            '.ts': 'application/javascript', // Se transpila a JS
+            '.css': 'text/css',
+            '.html': 'text/html',
+            '.json': 'application/json',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.svg': 'image/svg+xml',
+            '.ico': 'image/x-icon',
+            '.webp': 'image/webp',
+            '.avif': 'image/avif',
+            '.woff': 'font/woff',
+            '.woff2': 'font/woff2',
+            '.ttf': 'font/ttf',
+            '.eot': 'application/vnd.ms-fontobject',
+            '.map': 'application/json',
+            '.xml': 'application/xml',
+            '.txt': 'text/plain',
+            '.pdf': 'application/pdf',
+            '.zip': 'application/zip',
+            '.mp4': 'video/mp4',
+            '.mp3': 'audio/mpeg',
+            '.wav': 'audio/wav',
+            '.ogg': 'audio/ogg',
+        };
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+    /**
+     * Verifica si el archivo debe ser cacheado
+     */
+    shouldCache(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const cacheableExtensions = [
+            '.js',
+            '.mjs',
+            '.css',
+            '.json',
+            '.png',
+            '.jpg',
+            '.jpeg',
+            '.gif',
+            '.svg',
+            '.ico',
+            '.webp',
+            '.avif',
+            '.woff',
+            '.woff2',
+            '.ttf',
+            '.eot',
+            '.map',
+        ];
+        return cacheableExtensions.includes(ext);
+    }
+    /**
+     * Obtiene archivo desde cache o lo lee del disco
+     */
+    async getOrReadFile(filePath) {
+        this.totalRequests++;
+        try {
+            // Verificar si el archivo existe y obtener stats
+            const stats = await fs.stat(filePath);
+            const lastModified = stats.mtime.getTime();
+            const etag = this.generateETag(filePath, stats);
+            // Si no debe ser cacheado, leer directamente
+            if (!this.shouldCache(filePath)) {
+                const content = await fs.readFile(filePath, 'utf-8');
+                return {
+                    content,
+                    contentType: this.getContentType(filePath),
+                    etag,
+                    cached: false,
+                };
+            }
+            // Verificar cache
+            const cached = this.cache.get(filePath);
+            if (cached && cached.lastModified === lastModified) {
+                this.cacheHits++;
+                return {
+                    content: cached.content,
+                    contentType: cached.contentType,
+                    etag: cached.etag,
+                    cached: true,
+                };
+            }
+            // Cache miss - leer archivo
+            this.cacheMisses++;
+            const isBinary = this.isBinaryFile(filePath);
+            const content = await fs.readFile(filePath, isBinary ? undefined : 'utf-8');
+            const contentType = this.getContentType(filePath);
+            // Cachear resultado
+            this.addToCache(filePath, {
+                content,
+                contentType,
+                lastModified,
+                etag,
+                size: stats.size,
+            });
+            return {
+                content,
+                contentType,
+                etag,
+                cached: false,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Determina si un archivo es binario
+     */
+    isBinaryFile(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const binaryExtensions = [
+            '.png',
+            '.jpg',
+            '.jpeg',
+            '.gif',
+            '.ico',
+            '.webp',
+            '.avif',
+            '.woff',
+            '.woff2',
+            '.ttf',
+            '.eot',
+            '.pdf',
+            '.zip',
+            '.mp4',
+            '.mp3',
+            '.wav',
+            '.ogg',
+        ];
+        return binaryExtensions.includes(ext);
+    }
+    /**
+     * Añade archivo al cache con gestión de memoria
+     */
+    addToCache(filePath, fileData) {
+        try {
+            // Aplicar políticas de eviction si es necesario
+            this.evictIfNeeded(fileData.size);
+            const cacheEntry = {
+                content: fileData.content,
+                contentType: fileData.contentType,
+                lastModified: fileData.lastModified,
+                etag: fileData.etag,
+                size: fileData.size,
+            };
+            this.cache.set(filePath, cacheEntry);
+            this.currentMemoryUsage += fileData.size;
+        }
+        catch (error) {
+            console.warn('[BrowserSyncFileCache] Error cacheando archivo:', error);
+        }
+    }
+    /**
+     * Aplica políticas de eviction LRU si es necesario
+     */
+    evictIfNeeded(newFileSize) {
+        // Verificar límite de archivos
+        while (this.cache.size >= this.MAX_CACHE_SIZE) {
+            this.evictOldest();
+        }
+        // Verificar límite de memoria
+        while (this.currentMemoryUsage + newFileSize > this.MAX_CACHE_MEMORY &&
+            this.cache.size > 0) {
+            this.evictOldest();
+        }
+    }
+    /**
+     * Elimina el archivo más antiguo del cache
+     */
+    evictOldest() {
+        let oldestPath = '';
+        let oldestTime = Infinity;
+        for (const [filePath, entry] of this.cache) {
+            if (entry.lastModified < oldestTime) {
+                oldestTime = entry.lastModified;
+                oldestPath = filePath;
+            }
+        }
+        if (oldestPath) {
+            const entry = this.cache.get(oldestPath);
+            if (entry) {
+                this.currentMemoryUsage -= entry.size;
+                this.cache.delete(oldestPath);
+            }
+        }
+    }
+    /**
+     * Invalidar cache para un archivo específico
+     */
+    invalidateFile(filePath) {
+        const entry = this.cache.get(filePath);
+        if (entry) {
+            this.currentMemoryUsage -= entry.size;
+            this.cache.delete(filePath);
+        }
+    }
+    /**
+     * Obtiene estadísticas del cache
+     */
+    getStats() {
+        const hitRate = this.totalRequests > 0
+            ? Math.round((this.cacheHits / this.totalRequests) * 100)
+            : 0;
+        return {
+            cacheHits: this.cacheHits,
+            cacheMisses: this.cacheMisses,
+            hitRate,
+            totalRequests: this.totalRequests,
+            cacheSize: this.cache.size,
+            maxCacheSize: this.MAX_CACHE_SIZE,
+            memoryUsage: this.currentMemoryUsage,
+            maxMemoryUsage: this.MAX_CACHE_MEMORY,
+        };
+    }
+    /**
+     * Limpia todo el cache
+     */
+    clear() {
+        this.cache.clear();
+        this.currentMemoryUsage = 0;
+        this.cacheHits = 0;
+        this.cacheMisses = 0;
+        this.totalRequests = 0;
+    }
+    /**
+     * ✨ FIX #8: Destruye la instancia y limpia recursos
+     */
+    terminate() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.clear();
+    }
+}
+// Instancia global del cache de archivos
+const fileCache = BrowserSyncFileCache.getInstance();
+// Lazy loading para chalk - pre-cargado para mejor rendimiento
+let chalk;
+let chalkPromise = null;
+async function loadChalk() {
+    if (!chalk) {
+        if (!chalkPromise) {
+            chalkPromise = import('chalk').then(m => {
+                chalk = m.default;
+                return chalk;
+            });
+        }
+        await chalkPromise;
+    }
+    return chalk;
+}
+// Pre-cargar chalk al cargar el módulo para hot reload más rápido
+loadChalk().catch(() => { });
+export async function browserSyncServer() {
+    try {
+        let bs = null;
+        const AssetsOmit = env.AssetsOmit === 'true';
+        let proxy = {
+            server: './',
+        };
+        // ✨ VALIDACIÓN DE PROXY: Verificar disponibilidad antes de inicializar BrowserSync
+        if (env.proxyUrl) {
+            logger.info(`🔍 Validando disponibilidad del servidor proxy: ${env.proxyUrl}`);
+            const isProxyAvailable = await validateProxyAvailability(env.proxyUrl, 5000);
+            if (!isProxyAvailable) {
+                const proxyInfo = getProxyInfo(env.proxyUrl);
+                logger.warn(`⚠️  El servidor proxy no está disponible:`);
+                logger.warn(`   Host: ${proxyInfo.host}`);
+                logger.warn(`   Puerto: ${proxyInfo.port}`);
+                logger.warn(`   Protocolo: ${proxyInfo.protocol}`);
+                const response = await promptUser('\n¿Desea continuar de todos modos? El modo proxy podría no funcionar correctamente. (s/n): ', 30000);
+                if (response.toLowerCase().trim() !== 's' &&
+                    response.toLowerCase().trim() !== 'si') {
+                    logger.info('🛑 Operación cancelada por el usuario.');
+                    process.exit(0);
+                }
+                logger.warn('⚠️  Continuando con el servidor proxy no disponible...');
+            }
+            else {
+                logger.info('✅ Servidor proxy disponible');
+            }
+            proxy = {
+                proxy: env.proxyUrl,
+            };
+        }
+        const hrmDir = path.join(env.PATH_PROY || process.cwd(), 'hrm');
+        const projectRoot = process.cwd();
+        const relativeHrmPath = path.relative(projectRoot, hrmDir);
+        bs = browserSync.create();
+        const port = await getPort({ port: 3000 });
+        const uiPort = await getPort({ port: 4000 });
+        bs.init({
+            ...proxy,
+            files: [`${env.PATH_DIST}/**/*.css`], // Observa cambios en archivos CSS
+            injectChanges: true, // Inyecta CSS sin recargar la página
+            open: false, // No abre automáticamente el navegador
+            port, // Puerto aleatorio para BrowserSync
+            ui: {
+                port: uiPort, // Puerto aleatorio para la interfaz de usuario
+            },
+            socket: {
+                path: '/browser-sync/socket.io', // Ruta correcta para socket.io
+            },
+            snippetOptions: {
+                rule: {
+                    match: /<\/body>/i,
+                    fn: (snippet, match) => {
+                        return `
+                            ${snippet}${match}
                             <script
                                 type="module"
-                                src="/__versa/initHRM.js"><\/script>
-                        `}},logLevel:`info`,logPrefix:`BS`,logConnections:!0,logFileChanges:!0,watchEvents:[`change`,`add`,`unlink`,`addDir`,`unlinkDir`],reloadDelay:500,reloadDebounce:500,reloadOnRestart:!0,notify:!0,watchOptions:{ignoreInitial:!0,ignored:[`node_modules`,`.git`]},middleware:[async function(e,i,a){if(i.setHeader(`Access-Control-Allow-Origin`,`*`),i.setHeader(`Access-Control-Allow-Methods`,`*`),i.setHeader(`Access-Control-Allow-Headers`,`*`),i.setHeader(`Access-Control-Allow-Credentials`,`true`),i.setHeader(`Access-Control-Max-Age`,`3600`),i.setHeader(`Cache-Control`,`no-cache, no-store, must-revalidate`),i.setHeader(`Pragma`,`no-cache`),i.setHeader(`Expires`,`0`),e.url===`/__versa/initHRM.js`){let e=n.join(g,`/initHRM.js`),t=await f.getOrReadFile(e);if(t)i.setHeader(`Content-Type`,t.contentType),i.setHeader(`ETag`,t.etag),i.end(t.content);else{let t=await p();u.error(t.red(`🚩 :Error al leer el archivo ${e}`)),i.statusCode=404,i.end(`// vueLoader.js not found`)}return}if(e.url.startsWith(`/__versa/`)){let t=n.join(g,e.url.replace(`/__versa/`,``)),r=await f.getOrReadFile(t);if(r)i.setHeader(`Content-Type`,r.contentType),i.setHeader(`ETag`,r.etag),i.end(r.content);else{let e=await p();u.error(e.red(`🚩 :Error al leer el archivo ${t}`)),i.statusCode=404,i.end(`// Not found`)}return}if(e.url.startsWith(`/node_modules/`)){let t=n.join(r.cwd(),e.url),a=await f.getOrReadFile(t);if(a)i.setHeader(`Content-Type`,a.contentType),i.setHeader(`ETag`,a.etag),i.end(a.content);else{let e=await p();u.error(e.red(`🚩 Error al leer el módulo ${t}`)),i.statusCode=404,i.end(`// Module not found`)}return}let o=e.url.match(/\.(js|css|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|eot|map|webp|avif|json|html|xml|txt|pdf|zip|mp4|mp3|wav|ogg)(\?.*)?$/i);if(e.method===`GET`){let n=await p();o&&!t?u.info(n.white(`GET: ${e.url}`)):o||u.info(n.cyan(`GET: ${e.url}`))}else if(e.method===`POST`){let t=await p();u.info(t.blue(`POST: ${e.url}`))}else if(e.method===`PUT`){let t=await p();u.info(t.yellow(`PUT: ${e.url}`))}else if(e.method===`DELETE`){let t=await p();u.info(t.red(`DELETE: ${e.url}`))}else{let t=await p();u.info(t.gray(`${e.method}: ${e.url}`))}a()}]}),e}catch(e){u.error(`🚩 :Error al iniciar BrowserSync: ${e instanceof Error?e.message:String(e)}`),r.exit(1)}}export async function emitirCambios(e,t,r){let i=await p();u.info(i.green(`[HMR] Emitiendo cambios: ${t} ${r}\n`));let a=n.normalize(r).replace(/\\/g,`/`),o=n.basename(a,n.extname(a));e.sockets.emit(t,{action:t,filePath:r,normalizedPath:a,nameFile:o})}export const getBrowserSyncCacheStats=()=>f.getStats();export const clearBrowserSyncCache=()=>{f.clear()};export const invalidateBrowserSyncFile=e=>{f.invalidateFile(e)};
+                                src="/__versa/initHRM.js"></script>
+                        `;
+                    },
+                },
+            },
+            logLevel: 'info',
+            logPrefix: 'BS',
+            logConnections: true,
+            logFileChanges: true,
+            watchEvents: ['change', 'add', 'unlink', 'addDir', 'unlinkDir'],
+            reloadDelay: 500,
+            reloadDebounce: 500,
+            reloadOnRestart: true,
+            notify: true,
+            watchOptions: {
+                ignoreInitial: true,
+                ignored: ['node_modules', '.git'],
+            },
+            middleware: [
+                async function (req, res, next) {
+                    //para evitar el error de CORS
+                    res.setHeader('Access-Control-Allow-Origin', '*');
+                    res.setHeader('Access-Control-Allow-Methods', '*');
+                    res.setHeader('Access-Control-Allow-Headers', '*');
+                    res.setHeader('Access-Control-Allow-Credentials', 'true');
+                    res.setHeader('Access-Control-Max-Age', '3600');
+                    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+                    res.setHeader('Pragma', 'no-cache');
+                    res.setHeader('Expires', '0');
+                    //para redigir a la ubicación correcta
+                    if (req.url === '/__versa/initHRM.js') {
+                        // ✨ OPTIMIZADO: Usar cache para archivos HRM
+                        const vueLoaderPath = path.join(relativeHrmPath, '/initHRM.js');
+                        const cachedFile = await fileCache.getOrReadFile(vueLoaderPath);
+                        if (cachedFile) {
+                            res.setHeader('Content-Type', cachedFile.contentType);
+                            res.setHeader('ETag', cachedFile.etag);
+                            // if (
+                            //     process.env.VERBOSE === 'true' &&
+                            //     cachedFile.cached
+                            // ) {
+                            //     logger.info(
+                            //         `🚀 File cache hit para ${vueLoaderPath}`,
+                            //     );
+                            // }
+                            res.end(cachedFile.content);
+                        }
+                        else {
+                            const chalkInstance = await loadChalk();
+                            logger.error(chalkInstance.red(`🚩 :Error al leer el archivo ${vueLoaderPath}`));
+                            res.statusCode = 404;
+                            res.end('// vueLoader.js not found');
+                        }
+                        return;
+                    }
+                    // Si la URL comienza con /__versa/hrm/, sirve los archivos de dist/hrm
+                    if (req.url.startsWith('/__versa/')) {
+                        // ✨ OPTIMIZADO: Usar cache para archivos Versa
+                        const filePath = path.join(relativeHrmPath, req.url.replace('/__versa/', ''));
+                        const cachedFile = await fileCache.getOrReadFile(filePath);
+                        if (cachedFile) {
+                            res.setHeader('Content-Type', cachedFile.contentType);
+                            res.setHeader('ETag', cachedFile.etag);
+                            // if (
+                            //     process.env.VERBOSE === 'true' &&
+                            //     cachedFile.cached
+                            // ) {
+                            //     logger.info(
+                            //         `🚀 File cache hit para ${filePath}`,
+                            //     );
+                            // }
+                            res.end(cachedFile.content);
+                        }
+                        else {
+                            const chalkInstance = await loadChalk();
+                            logger.error(chalkInstance.red(`🚩 :Error al leer el archivo ${filePath}`));
+                            res.statusCode = 404;
+                            res.end('// Not found');
+                        }
+                        return;
+                    }
+                    // Si la URL comienza con /node_modules/, sirve los archivos de node_modules
+                    if (req.url.startsWith('/node_modules/')) {
+                        // ✨ OPTIMIZADO: Usar cache para módulos de node_modules
+                        const modulePath = path.join(process.cwd(), req.url);
+                        const cachedFile = await fileCache.getOrReadFile(modulePath);
+                        if (cachedFile) {
+                            res.setHeader('Content-Type', cachedFile.contentType);
+                            res.setHeader('ETag', cachedFile.etag);
+                            // if (
+                            //     process.env.VERBOSE === 'true' &&
+                            //     cachedFile.cached
+                            // ) {
+                            //     logger.info(
+                            //         `🚀 Module cache hit para ${modulePath}`,
+                            //     );
+                            // }
+                            res.end(cachedFile.content);
+                        }
+                        else {
+                            const chalkInstance = await loadChalk();
+                            logger.error(chalkInstance.red(`🚩 Error al leer el módulo ${modulePath}`));
+                            res.statusCode = 404;
+                            res.end('// Module not found');
+                        }
+                        return;
+                    }
+                    // detectar si es un archivo estático, puede que contenga un . y alguna extensión o dashUsers.js?v=1746559083866
+                    const isAssets = req.url.match(/\.(js|css|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|eot|map|webp|avif|json|html|xml|txt|pdf|zip|mp4|mp3|wav|ogg)(\?.*)?$/i);
+                    if (req.method === 'GET') {
+                        const chalkInstance = await loadChalk();
+                        // omitir archivos estáticos sólo si AssetsOmit es true
+                        if (isAssets && !AssetsOmit) {
+                            logger.info(chalkInstance.white(`GET: ${req.url}`));
+                        }
+                        else if (!isAssets) {
+                            logger.info(chalkInstance.cyan(`GET: ${req.url}`));
+                        }
+                    }
+                    else if (req.method === 'POST') {
+                        const chalkInstance = await loadChalk();
+                        logger.info(chalkInstance.blue(`POST: ${req.url}`));
+                    }
+                    else if (req.method === 'PUT') {
+                        const chalkInstance = await loadChalk();
+                        logger.info(chalkInstance.yellow(`PUT: ${req.url}`));
+                    }
+                    else if (req.method === 'DELETE') {
+                        const chalkInstance = await loadChalk();
+                        logger.info(chalkInstance.red(`DELETE: ${req.url}`));
+                    }
+                    else {
+                        const chalkInstance = await loadChalk();
+                        logger.info(chalkInstance.gray(`${req.method}: ${req.url}`));
+                    }
+                    // Aquí podrías, por ejemplo, escribir estos logs en un archivo o base de datos
+                    next();
+                },
+            ],
+        });
+        // 🔍 Listener para errores del cliente
+        bs.sockets.on('connection', (socket) => {
+            socket.on('client:error', async (errorData) => {
+                const chalkInstance = await loadChalk();
+                logger.error(chalkInstance.red('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+                logger.error(chalkInstance.red.bold('🔥 ERROR DEL CLIENTE (NAVEGADOR)'));
+                logger.error(chalkInstance.red('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+                logger.error(chalkInstance.yellow(`📍 Tipo: ${errorData.type}`));
+                logger.error(chalkInstance.yellow(`⏰ Timestamp: ${errorData.timestamp}`));
+                logger.error(chalkInstance.yellow(`🌐 URL: ${errorData.url}`));
+                logger.error(chalkInstance.yellow(`🖥️  User Agent: ${errorData.userAgent}`));
+                if (errorData.context &&
+                    Object.keys(errorData.context).length > 0) {
+                    logger.error(chalkInstance.cyan('\n📋 Contexto:'));
+                    logger.error(chalkInstance.cyan(JSON.stringify(errorData.context, null, 2)));
+                }
+                if (errorData.error) {
+                    logger.error(chalkInstance.red('\n💥 Error:'));
+                    logger.error(chalkInstance.red(`   Nombre: ${errorData.error.name}`));
+                    logger.error(chalkInstance.red(`   Mensaje: ${errorData.error.message}`));
+                    if (errorData.error.stack) {
+                        logger.error(chalkInstance.gray('\n📚 Stack Trace:'));
+                        logger.error(chalkInstance.gray(errorData.error.stack));
+                    }
+                }
+                logger.error(chalkInstance.red('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+            });
+        });
+        return bs;
+    }
+    catch (error) {
+        logger.error(`🚩 :Error al iniciar BrowserSync: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+export async function emitirCambios(bs, action, filePath) {
+    // ✨ OPTIMIZACIÓN: Emitir PRIMERO (crítico), logging DESPUÉS (no crítico)
+    const normalizedPath = path.normalize(filePath).replace(/\\/g, '/');
+    const nameFile = path.basename(normalizedPath, path.extname(normalizedPath));
+    bs.sockets.emit(action, { action, filePath, normalizedPath, nameFile });
+    // Logging asíncrono para no bloquear la emisión
+    setImmediate(async () => {
+        const chalkInstance = await loadChalk();
+        logger.info(chalkInstance.green(`[HMR] Emitiendo cambios: ${action} ${filePath}\n`));
+    });
+}
+// ✨ NUEVAS FUNCIONES: Exportar funcionalidades del cache de archivos para uso externo
+export const getBrowserSyncCacheStats = () => {
+    return fileCache.getStats();
+};
+export const clearBrowserSyncCache = () => {
+    fileCache.clear();
+};
+export const invalidateBrowserSyncFile = (filePath) => {
+    fileCache.invalidateFile(filePath);
+};
+//# sourceMappingURL=browserSync.js.map