versacompiler 2.0.0 → 2.0.2

package/dist/servicios/browserSync.js

@@ -1,10 +1,276 @@
+import { createHash } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { env } from 'node:process';
+import process, { env } from 'node:process';
 import browserSync from 'browser-sync';
 
 import getPort from 'get-port';
 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;
+    // Métricas
+    cacheHits = 0;
+    cacheMisses = 0;
+    totalRequests = 0;
+    static getInstance() {
+        if (!BrowserSyncFileCache.instance) {
+            BrowserSyncFileCache.instance = new BrowserSyncFileCache();
+        }
+        return BrowserSyncFileCache.instance;
+    }
+    /**
+     * 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;
+    }
+}
+// Instancia global del cache de archivos
+const fileCache = BrowserSyncFileCache.getInstance();
 // Lazy loading para chalk
 const loadChalk = async () => {
     const { default: chalk } = await import('chalk');
@@ -79,16 +345,21 @@ export async function browserSyncServer() {
                     res.setHeader('Expires', '0');
                     //para redigir a la ubicación correcta
                     if (req.url === '/__versa/initHRM.js') {
-                        // Busca vueLoader.js en la carpeta de salida configurada
+                        // ✨ OPTIMIZADO: Usar cache para archivos HRM
                         const vueLoaderPath = path.join(relativeHrmPath, '/initHRM.js');
-                        res.setHeader('Content-Type', 'application/javascript');
-                        try {
-                            const fileContent = await fs.readFile(vueLoaderPath, 'utf-8');
-                            res.end(fileContent);
+                        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);
                         }
-                        catch (error) {
+                        else {
                             const chalkInstance = await loadChalk();
-                            logger.error(chalkInstance.red(`🚩 :Error al leer el archivo ${vueLoaderPath}: ${error instanceof Error ? error.message : String(error)}/n ${error instanceof Error ? error.stack : ''}`));
+                            logger.error(chalkInstance.red(`🚩 :Error al leer el archivo ${vueLoaderPath}`));
                             res.statusCode = 404;
                             res.end('// vueLoader.js not found');
                         }
@@ -96,16 +367,21 @@ export async function browserSyncServer() {
                     }
                     // Si la URL comienza con /__versa/hrm/, sirve los archivos de dist/hrm
                     if (req.url.startsWith('/__versa/')) {
-                        // Sirve archivos de dist/hrm como /__versa/hrm/*
+                        // ✨ OPTIMIZADO: Usar cache para archivos Versa
                         const filePath = path.join(relativeHrmPath, req.url.replace('/__versa/', ''));
-                        res.setHeader('Content-Type', 'application/javascript');
-                        try {
-                            const fileContent = await fs.readFile(filePath, 'utf-8');
-                            res.end(fileContent);
+                        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);
                         }
-                        catch (error) {
+                        else {
                             const chalkInstance = await loadChalk();
-                            logger.error(chalkInstance.red(`🚩 :Error al leer el archivo ${filePath}: ${error instanceof Error ? error.message : String(error)}`));
+                            logger.error(chalkInstance.red(`🚩 :Error al leer el archivo ${filePath}`));
                             res.statusCode = 404;
                             res.end('// Not found');
                         }
@@ -113,15 +389,21 @@ export async function browserSyncServer() {
                     }
                     // 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);
-                        res.setHeader('Content-Type', 'application/javascript');
-                        try {
-                            const fileContent = await fs.readFile(modulePath, 'utf-8');
-                            res.end(fileContent);
+                        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);
                         }
-                        catch (error) {
+                        else {
                             const chalkInstance = await loadChalk();
-                            logger.error(chalkInstance.red(`🚩 Error al leer el módulo ${modulePath}: ${error instanceof Error ? error.message : String(error)}`));
+                            logger.error(chalkInstance.red(`🚩 Error al leer el módulo ${modulePath}`));
                             res.statusCode = 404;
                             res.end('// Module not found');
                         }
@@ -174,4 +456,14 @@ export async function emitirCambios(bs, action, filePath) {
     const nameFile = path.basename(normalizedPath, path.extname(normalizedPath));
     bs.sockets.emit(action, { action, filePath, normalizedPath, nameFile });
 }
+// ✨ 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