versacompiler 2.0.8 → 2.2.0

package/dist/compiler/parser.js

@@ -1 +1,336 @@
-import{createHash as e}from"node:crypto";import i,{readFile as a}from"node:fs/promises";import o from"oxc-parser";class s{static instance;cache=new Map;MAX_CACHE_SIZE=150;MAX_CACHE_MEMORY=30*1024*1024;CACHE_TTL=600*1e3;currentMemoryUsage=0;cacheHits=0;cacheMisses=0;totalParses=0;static getInstance(){return s.instance||=new s,s.instance}generateContentHash(i,a){return e(`sha256`).update(`${i}:${a}`).digest(`hex`)}estimateASTSize(e){try{return JSON.stringify(e).length*2}catch{return 1e4}}async getOrParseAST(e,i,a=`js`){this.totalParses++;let s=this.generateContentHash(i,a),c=`${e}:${s}`,l=this.cache.get(c);if(l&&Date.now()-l.timestamp<this.CACHE_TTL)return l.timestamp=Date.now(),this.cacheHits++,{ast:l.ast,cached:!0};this.cacheMisses++;let u=o.parseSync(e,i,{sourceType:`module`,showSemanticErrors:!0,astType:a});return u&&!u.errors?.length&&this.addToCache(c,u,a),{ast:u,cached:!1}}addToCache(e,i,a){try{let o=this.estimateASTSize(i);this.evictIfNeeded(o);let s={contentHash:e.split(`:`)[1]||``,ast:i,astType:a,timestamp:Date.now(),size:o};this.cache.set(e,s),this.currentMemoryUsage+=o}catch(e){console.warn(`[ParserASTCache] Error cacheando AST:`,e)}}evictIfNeeded(e){for(;this.cache.size>=this.MAX_CACHE_SIZE;)this.evictLRU();for(;this.currentMemoryUsage+e>this.MAX_CACHE_MEMORY&&this.cache.size>0;)this.evictLRU()}evictLRU(){let e=``,i=1/0;for(let[a,o]of this.cache)o.timestamp<i&&(i=o.timestamp,e=a);if(e){let i=this.cache.get(e);i&&(this.currentMemoryUsage-=i.size,this.cache.delete(e))}}cleanExpired(){let e=Date.now();for(let[i,a]of this.cache.entries())e-a.timestamp>this.CACHE_TTL&&(this.currentMemoryUsage-=a.size,this.cache.delete(i))}getStats(){let e=this.totalParses>0?Math.round(this.cacheHits/this.totalParses*100):0;return{cacheHits:this.cacheHits,cacheMisses:this.cacheMisses,hitRate:e,totalParses:this.totalParses,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.totalParses=0}}const c=s.getInstance();export const parser=async(e,i,a=`js`)=>{let{ast:o}=await c.getOrParseAST(e,i,a);return o};export const getCodeFile=async e=>{try{await i.access(e);let o=await a(e,`utf-8`);return{code:o,error:null}}catch(e){return{code:null,error:e}}};export const getParserCacheStats=()=>c.getStats();export const clearParserCache=()=>{c.clear()};export const cleanExpiredParserCache=()=>{c.cleanExpired()};
+import { createHash } from 'node:crypto';
+import { statSync } from 'node:fs';
+import { open, readFile } from 'node:fs/promises';
+import { parseSync } from 'oxc-parser';
+class FileContentCache {
+    static instance;
+    cache = new Map();
+    MAX_CACHE_SIZE = 500; // Máximo archivos en cache
+    MAX_FILE_SIZE_TO_CACHE = 1024 * 1024; // 1MB - solo cachear archivos < 1MB
+    CACHE_TTL = 5 * 60 * 1000; // 5 minutos
+    // Métricas
+    cacheHits = 0;
+    cacheMisses = 0;
+    totalReads = 0;
+    static getInstance() {
+        if (!FileContentCache.instance) {
+            FileContentCache.instance = new FileContentCache();
+        }
+        return FileContentCache.instance;
+    }
+    /**
+     * Lee archivo con cache inteligente
+     */
+    async readFileWithCache(filename) {
+        this.totalReads++;
+        // Obtener stats del archivo (más rápido que leerlo)
+        const stats = statSync(filename);
+        // No cachear archivos muy grandes
+        if (stats.size > this.MAX_FILE_SIZE_TO_CACHE) {
+            this.cacheMisses++;
+            return await this.fastReadFile(filename, stats.size);
+        }
+        const cached = this.cache.get(filename);
+        // Verificar si cache es válido (mismo mtime y no expirado)
+        if (cached &&
+            cached.mtimeMs === stats.mtimeMs &&
+            Date.now() - cached.timestamp < this.CACHE_TTL) {
+            this.cacheHits++;
+            cached.timestamp = Date.now(); // LRU update
+            return cached.content;
+        }
+        // Cache miss - leer archivo
+        this.cacheMisses++;
+        const content = await this.fastReadFile(filename, stats.size);
+        // Cachear si está dentro de límites
+        if (this.cache.size >= this.MAX_CACHE_SIZE) {
+            this.evictLRU();
+        }
+        this.cache.set(filename, {
+            content,
+            mtimeMs: stats.mtimeMs,
+            size: stats.size,
+            timestamp: Date.now(),
+        });
+        return content;
+    }
+    /**
+     * Lectura ultra-rápida con buffer pre-allocated
+     */
+    async fastReadFile(filename, size) {
+        // Para archivos pequeños, usar el método tradicional (más rápido en ese caso)
+        if (size < 16384) {
+            // 16KB
+            return await readFile(filename, 'utf-8');
+        }
+        // Para archivos grandes, usar open + read con buffer pre-allocated
+        let fileHandle;
+        try {
+            fileHandle = await open(filename, 'r');
+            const buffer = Buffer.allocUnsafe(size);
+            await fileHandle.read(buffer, 0, size, 0);
+            return buffer.toString('utf-8');
+        }
+        finally {
+            await fileHandle?.close();
+        }
+    }
+    /**
+     * Elimina entrada LRU
+     */
+    evictLRU() {
+        let oldestKey = '';
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.cache) {
+            if (entry.timestamp < oldestTime) {
+                oldestTime = entry.timestamp;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            this.cache.delete(oldestKey);
+        }
+    }
+    /**
+     * Invalida cache de un archivo específico
+     */
+    invalidate(filename) {
+        this.cache.delete(filename);
+    }
+    /**
+     * Limpia cache completo
+     */
+    clear() {
+        this.cache.clear();
+        this.cacheHits = 0;
+        this.cacheMisses = 0;
+        this.totalReads = 0;
+    }
+    /**
+     * Obtiene estadísticas
+     */
+    getStats() {
+        const hitRate = this.totalReads > 0
+            ? Math.round((this.cacheHits / this.totalReads) * 100)
+            : 0;
+        return {
+            cacheHits: this.cacheHits,
+            cacheMisses: this.cacheMisses,
+            hitRate,
+            totalReads: this.totalReads,
+            cacheSize: this.cache.size,
+            maxCacheSize: this.MAX_CACHE_SIZE,
+        };
+    }
+}
+// Instancia global del cache de archivos
+const fileCache = FileContentCache.getInstance();
+class ParserASTCache {
+    static instance;
+    cache = new Map();
+    MAX_CACHE_SIZE = 150; // Máximo ASTs en cache
+    MAX_CACHE_MEMORY = 30 * 1024 * 1024; // 30MB límite
+    CACHE_TTL = 10 * 60 * 1000; // 10 minutos
+    currentMemoryUsage = 0;
+    // Métricas
+    cacheHits = 0;
+    cacheMisses = 0;
+    totalParses = 0;
+    static getInstance() {
+        if (!ParserASTCache.instance) {
+            ParserASTCache.instance = new ParserASTCache();
+        }
+        return ParserASTCache.instance;
+    }
+    /**
+     * Genera un hash del contenido del código
+     */
+    generateContentHash(code, astType) {
+        return createHash('sha256').update(`${code}:${astType}`).digest('hex');
+    }
+    /**
+     * Estima el tamaño en memoria de un AST
+     */
+    estimateASTSize(ast) {
+        try {
+            return JSON.stringify(ast).length * 2; // UTF-16 characters
+        }
+        catch {
+            return 10000; // Estimación por defecto
+        }
+    }
+    /**
+     * Obtiene AST desde cache o lo parsea
+     */
+    async getOrParseAST(filename, code, astType = 'js') {
+        this.totalParses++;
+        const contentHash = this.generateContentHash(code, astType);
+        const cacheKey = `${filename}:${contentHash}`;
+        // Verificar cache
+        const cached = this.cache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
+            // Actualizar timestamp de uso (LRU)
+            cached.timestamp = Date.now();
+            this.cacheHits++;
+            return {
+                ast: cached.ast,
+                cached: true,
+            };
+        }
+        // Cache miss - parsear nuevo AST
+        this.cacheMisses++;
+        const ast = parseSync(filename, code, {
+            sourceType: 'module',
+            showSemanticErrors: true,
+            astType,
+        });
+        // Cachear resultado si es válido
+        if (ast && !ast.errors?.length) {
+            this.addToCache(cacheKey, ast, astType);
+        }
+        return {
+            ast,
+            cached: false,
+        };
+    }
+    /**
+     * Añade AST al cache con gestión de memoria
+     */
+    addToCache(cacheKey, ast, astType) {
+        try {
+            const size = this.estimateASTSize(ast);
+            // Aplicar políticas de eviction si es necesario
+            this.evictIfNeeded(size);
+            const entry = {
+                contentHash: cacheKey.split(':')[1] || '',
+                ast,
+                astType,
+                timestamp: Date.now(),
+                size,
+            };
+            this.cache.set(cacheKey, entry);
+            this.currentMemoryUsage += size;
+        }
+        catch (error) {
+            console.warn('[ParserASTCache] Error cacheando AST:', error);
+        }
+    }
+    /**
+     * Aplica políticas de eviction LRU si es necesario
+     */
+    evictIfNeeded(newEntrySize) {
+        // Verificar límite de entradas
+        while (this.cache.size >= this.MAX_CACHE_SIZE) {
+            this.evictLRU();
+        }
+        // Verificar límite de memoria
+        while (this.currentMemoryUsage + newEntrySize > this.MAX_CACHE_MEMORY &&
+            this.cache.size > 0) {
+            this.evictLRU();
+        }
+    }
+    /**
+     * Elimina la entrada menos recientemente usada
+     */
+    evictLRU() {
+        let oldestKey = '';
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.cache) {
+            if (entry.timestamp < oldestTime) {
+                oldestTime = entry.timestamp;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            const entry = this.cache.get(oldestKey);
+            if (entry) {
+                this.currentMemoryUsage -= entry.size;
+                this.cache.delete(oldestKey);
+            }
+        }
+    }
+    /**
+     * Limpia entradas expiradas
+     */
+    cleanExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.CACHE_TTL) {
+                this.currentMemoryUsage -= entry.size;
+                this.cache.delete(key);
+            }
+        }
+    }
+    /**
+     * Obtiene estadísticas del cache
+     */
+    getStats() {
+        const hitRate = this.totalParses > 0
+            ? Math.round((this.cacheHits / this.totalParses) * 100)
+            : 0;
+        return {
+            cacheHits: this.cacheHits,
+            cacheMisses: this.cacheMisses,
+            hitRate,
+            totalParses: this.totalParses,
+            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.totalParses = 0;
+    }
+}
+// Instancia global del cache AST
+const astCache = ParserASTCache.getInstance();
+/**
+ * Parses the given JavaScript code using Acorn and returns the Abstract Syntax Tree (AST).
+ *
+ * @param {string} data - The JavaScript code to be parsed.
+ * @returns {Promise<Object|null>} The parsed AST object if successful, or null if an error occurs.
+ * @throws {Error} If there is an error during parsing, it logs the error details and stack trace.
+ */
+export const parser = async (filename, code, astType = 'js') => {
+    const { ast } = await astCache.getOrParseAST(filename, code, astType);
+    return ast;
+};
+export const getCodeFile = async (filename) => {
+    try {
+        // ✨ Usar cache de archivos para lectura ultra-rápida
+        const code = await fileCache.readFileWithCache(filename);
+        return { code, error: null };
+    }
+    catch (error) {
+        return { code: null, error };
+    }
+};
+// ✨ NUEVAS FUNCIONES: Exportar funcionalidades del cache AST para uso externo
+export const getParserCacheStats = () => {
+    return astCache.getStats();
+};
+export const clearParserCache = () => {
+    astCache.clear();
+};
+export const cleanExpiredParserCache = () => {
+    astCache.cleanExpired();
+};
+// ✨ FUNCIONES: Cache de archivos
+export const getFileContentCacheStats = () => {
+    return fileCache.getStats();
+};
+export const clearFileContentCache = () => {
+    fileCache.clear();
+};
+export const invalidateFileCache = (filename) => {
+    fileCache.invalidate(filename);
+};
+//# sourceMappingURL=parser.js.map

package/dist/compiler/performance-monitor.js

@@ -1,56 +1,204 @@
-import{clearBrowserSyncCache as e,getBrowserSyncCacheStats as r}from"../servicios/browserSync.js";import{cleanExpiredMinificationCache as i,clearMinificationCache as a,getMinificationCacheStats as o}from"./minify.js";import{getModuleResolutionMetrics as s}from"./module-resolution-optimizer.js";import{cleanExpiredParserCache as c,clearParserCache as l,getParserCacheStats as u}from"./parser.js";import{TransformOptimizer as d}from"./transform-optimizer.js";import{cleanExpiredVueHMRCache as f,clearVueHMRCache as p,getVueHMRCacheStats as m}from"./vuejs.js";export class PerformanceMonitor{static instance;static getInstance(){return PerformanceMonitor.instance||=new PerformanceMonitor,PerformanceMonitor.instance}getAllStats(){let e=m(),i=u(),a=r(),c=o(),l=d.getInstance().getStats(),f=s(),p=(i.cacheHits||0)+(a.cacheHits||0)+(c.cacheHits||0)+(l.cacheHits||0)+(f.cacheHits||0),h=(i.cacheMisses||0)+(a.cacheMisses||0)+(c.cacheMisses||0)+(l.cacheMisses||0)+(f.cacheMisses||0),g=p+h,_=g>0?Math.round(p/g*100):0,v=(i.memoryUsage||0)+(a.memoryUsage||0)+(c.memoryUsage||0)+(l.memoryUsage||0),y=(e.size||0)+(i.cacheSize||0)+(a.cacheSize||0)+(c.cacheSize||0)+(l.cacheSize||0)+(f.cacheSize||0);return{vueHMRCache:e,parserCache:i,browserSyncCache:a,minificationCache:c,transformOptimizer:l,moduleResolution:f,summary:{totalCacheHits:p,totalCacheMisses:h,overallHitRate:_,totalMemoryUsage:v,totalCacheEntries:y}}}generateReport(){let e=this.getAllStats(),r=e=>{if(e===0)return`0 B`;let r=1024,i=[`B`,`KB`,`MB`,`GB`],a=Math.floor(Math.log(e)/Math.log(r));return parseFloat((e/r**+a).toFixed(2))+` `+i[a]},i=`
-🚀 VERSACOMPILER PERFORMANCE REPORT
-=====================================
-
-📊 RESUMEN GENERAL
-Hit Rate Total: ${e.summary.overallHitRate}%
-Cache Hits: ${e.summary.totalCacheHits}
-Cache Misses: ${e.summary.totalCacheMisses}
-Memoria Total: ${r(e.summary.totalMemoryUsage)}
-Entradas Cache: ${e.summary.totalCacheEntries}
-
-🎯 VUE HMR CACHE
-Size: ${e.vueHMRCache.size}/${e.vueHMRCache.maxSize}
-TTL: ${Math.round(e.vueHMRCache.ttl/1e3/60)}min
-
-📝 PARSER AST CACHE
-Hit Rate: ${e.parserCache.hitRate}%
-Cache Hits: ${e.parserCache.cacheHits}
-Cache Misses: ${e.parserCache.cacheMisses}
-Size: ${e.parserCache.cacheSize}/${e.parserCache.maxCacheSize}
-Memoria: ${r(e.parserCache.memoryUsage)}/${r(e.parserCache.maxMemoryUsage)}
-
-🌐 BROWSERSYNC FILE CACHE
-Hit Rate: ${e.browserSyncCache.hitRate}%
-Cache Hits: ${e.browserSyncCache.cacheHits}
-Cache Misses: ${e.browserSyncCache.cacheMisses}
-Size: ${e.browserSyncCache.cacheSize}/${e.browserSyncCache.maxCacheSize}
-Memoria: ${r(e.browserSyncCache.memoryUsage)}/${r(e.browserSyncCache.maxMemoryUsage)}
-
-🗜️ MINIFICATION CACHE
-Hit Rate: ${e.minificationCache.hitRate}%
-Cache Hits: ${e.minificationCache.cacheHits}
-Cache Misses: ${e.minificationCache.cacheMisses}
-Size: ${e.minificationCache.cacheSize}/${e.minificationCache.maxCacheSize}
-Memoria: ${r(e.minificationCache.memoryUsage)}/${r(e.minificationCache.maxMemoryUsage)}
-Compresión Promedio: ${e.minificationCache.avgCompressionRatio}%
-
-🔄 TRANSFORM OPTIMIZER
-Hit Rate: ${e.transformOptimizer.hitRate}%
-Cache Hits: ${e.transformOptimizer.cacheHits}
-Cache Misses: ${e.transformOptimizer.cacheMisses}
-Transformaciones: ${e.transformOptimizer.totalTransforms}
-Size: ${e.transformOptimizer.cacheSize}
-Memoria: ${r(e.transformOptimizer.memoryUsage)}
-
-📦 MODULE RESOLUTION
-Hit Rate: ${e.moduleResolution.cacheHitRate?.toFixed(1)}%
-Cache Hits: ${e.moduleResolution.cacheHits}
-Cache Misses: ${e.moduleResolution.cacheMisses}
-Resoluciones: ${e.moduleResolution.totalResolutions}
-Índice Módulos: ${e.moduleResolution.moduleIndexSize}
-Índice Alias: ${e.moduleResolution.aliasIndexSize}
-Tiempo Promedio: ${e.moduleResolution.averageResolveTime?.toFixed(2)}ms
-
-=====================================
-        `;return i}clearAllCaches(){p(),l(),e(),a(),d.getInstance().clear(),console.log(`🧹 Todos los caches han sido limpiados`)}cleanExpiredCaches(){f(),c(),i(),console.log(`🧹 Entradas expiradas limpiadas de todos los caches`)}setupAutomaticCleanup(e=30){setInterval(()=>{this.cleanExpiredCaches(),console.log(`🔄 Limpieza automática ejecutada cada ${e} minutos`)},e*60*1e3)}getSimpleMetrics(){let e=this.getAllStats();return{hitRate:e.summary.overallHitRate,totalHits:e.summary.totalCacheHits,totalMisses:e.summary.totalCacheMisses,memoryUsage:e.summary.totalMemoryUsage,cacheEntries:e.summary.totalCacheEntries}}}export const performanceMonitor=PerformanceMonitor.getInstance();export const getAllPerformanceStats=()=>performanceMonitor.getAllStats();export const generatePerformanceReport=()=>performanceMonitor.generateReport();export const clearAllCaches=()=>performanceMonitor.clearAllCaches();export const cleanExpiredCaches=()=>performanceMonitor.cleanExpiredCaches();export const getSimpleMetrics=()=>performanceMonitor.getSimpleMetrics();
+/**
+ * Performance Monitor - Sistema centralizado de monitoreo de optimizaciones
+ * Reúne todas las métricas de cache y performance del VersaCompiler
+ */
+import { clearBrowserSyncCache, getBrowserSyncCacheStats, } from '../servicios/browserSync.js';
+import { cleanExpiredMinificationCache, clearMinificationCache, getMinificationCacheStats, } from './minify.js';
+import { getModuleResolutionMetrics } from './module-resolution-optimizer.js';
+import { cleanExpiredParserCache, clearFileContentCache, clearParserCache, getFileContentCacheStats, getParserCacheStats, } from './parser.js';
+import { TransformOptimizer } from './transform-optimizer.js';
+import { cleanExpiredVueHMRCache, clearVueHMRCache, getVueHMRCacheStats, } from './vuejs.js';
+export class PerformanceMonitor {
+    static instance;
+    static getInstance() {
+        if (!PerformanceMonitor.instance) {
+            PerformanceMonitor.instance = new PerformanceMonitor();
+        }
+        return PerformanceMonitor.instance;
+    }
+    /**
+     * Obtiene todas las estadísticas de performance de manera unificada
+     */
+    getAllStats() {
+        const vueHMRCache = getVueHMRCacheStats();
+        const parserCache = getParserCacheStats();
+        const fileContentCache = getFileContentCacheStats();
+        const browserSyncCache = getBrowserSyncCacheStats();
+        const minificationCache = getMinificationCacheStats();
+        const transformOptimizer = TransformOptimizer.getInstance().getStats();
+        const moduleResolution = getModuleResolutionMetrics();
+        // Calcular resumen general
+        const totalCacheHits = (parserCache.cacheHits || 0) +
+            (fileContentCache.cacheHits || 0) +
+            (browserSyncCache.cacheHits || 0) +
+            (minificationCache.cacheHits || 0) +
+            (transformOptimizer.cacheHits || 0) +
+            (moduleResolution.cacheHits || 0);
+        const totalCacheMisses = (parserCache.cacheMisses || 0) +
+            (fileContentCache.cacheMisses || 0) +
+            (browserSyncCache.cacheMisses || 0) +
+            (minificationCache.cacheMisses || 0) +
+            (transformOptimizer.cacheMisses || 0) +
+            (moduleResolution.cacheMisses || 0);
+        const totalRequests = totalCacheHits + totalCacheMisses;
+        const overallHitRate = totalRequests > 0
+            ? Math.round((totalCacheHits / totalRequests) * 100)
+            : 0;
+        const totalMemoryUsage = (parserCache.memoryUsage || 0) +
+            (browserSyncCache.memoryUsage || 0) +
+            (minificationCache.memoryUsage || 0) +
+            (transformOptimizer.memoryUsage || 0);
+        const totalCacheEntries = (vueHMRCache.size || 0) +
+            (parserCache.cacheSize || 0) +
+            (fileContentCache.cacheSize || 0) +
+            (browserSyncCache.cacheSize || 0) +
+            (minificationCache.cacheSize || 0) +
+            (transformOptimizer.cacheSize || 0) +
+            (moduleResolution.cacheSize || 0);
+        return {
+            vueHMRCache,
+            parserCache,
+            fileContentCache,
+            browserSyncCache,
+            minificationCache,
+            transformOptimizer,
+            moduleResolution,
+            summary: {
+                totalCacheHits,
+                totalCacheMisses,
+                overallHitRate,
+                totalMemoryUsage,
+                totalCacheEntries,
+            },
+        };
+    }
+    /**
+     * Genera un reporte detallado de performance
+     */
+    generateReport() {
+        const stats = this.getAllStats();
+        const formatBytes = (bytes) => {
+            if (bytes === 0)
+                return '0 B';
+            const k = 1024;
+            const sizes = ['B', 'KB', 'MB', 'GB'];
+            const i = Math.floor(Math.log(bytes) / Math.log(k));
+            return (parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]);
+        };
+        const report = `
+🚀 VERSACOMPILER PERFORMANCE REPORT
+=====================================
+
+📊 RESUMEN GENERAL
+Hit Rate Total: ${stats.summary.overallHitRate}%
+Cache Hits: ${stats.summary.totalCacheHits}
+Cache Misses: ${stats.summary.totalCacheMisses}
+Memoria Total: ${formatBytes(stats.summary.totalMemoryUsage)}
+Entradas Cache: ${stats.summary.totalCacheEntries}
+
+🎯 VUE HMR CACHE
+Size: ${stats.vueHMRCache.size}/${stats.vueHMRCache.maxSize}
+TTL: ${Math.round(stats.vueHMRCache.ttl / 1000 / 60)}min
+
+📝 PARSER AST CACHE
+Hit Rate: ${stats.parserCache.hitRate}%
+Cache Hits: ${stats.parserCache.cacheHits}
+Cache Misses: ${stats.parserCache.cacheMisses}
+Size: ${stats.parserCache.cacheSize}/${stats.parserCache.maxCacheSize}
+Memoria: ${formatBytes(stats.parserCache.memoryUsage)}/${formatBytes(stats.parserCache.maxMemoryUsage)}
+
+📖 FILE CONTENT CACHE
+Hit Rate: ${stats.fileContentCache.hitRate}%
+Cache Hits: ${stats.fileContentCache.cacheHits}
+Cache Misses: ${stats.fileContentCache.cacheMisses}
+Size: ${stats.fileContentCache.cacheSize}/${stats.fileContentCache.maxCacheSize}
+
+🌐 BROWSERSYNC FILE CACHE
+Hit Rate: ${stats.browserSyncCache.hitRate}%
+Cache Hits: ${stats.browserSyncCache.cacheHits}
+Cache Misses: ${stats.browserSyncCache.cacheMisses}
+Size: ${stats.browserSyncCache.cacheSize}/${stats.browserSyncCache.maxCacheSize}
+Memoria: ${formatBytes(stats.browserSyncCache.memoryUsage)}/${formatBytes(stats.browserSyncCache.maxMemoryUsage)}
+
+🗜️ MINIFICATION CACHE
+Hit Rate: ${stats.minificationCache.hitRate}%
+Cache Hits: ${stats.minificationCache.cacheHits}
+Cache Misses: ${stats.minificationCache.cacheMisses}
+Size: ${stats.minificationCache.cacheSize}/${stats.minificationCache.maxCacheSize}
+Memoria: ${formatBytes(stats.minificationCache.memoryUsage)}/${formatBytes(stats.minificationCache.maxMemoryUsage)}
+Compresión Promedio: ${stats.minificationCache.avgCompressionRatio}%
+
+🔄 TRANSFORM OPTIMIZER
+Hit Rate: ${stats.transformOptimizer.hitRate}%
+Cache Hits: ${stats.transformOptimizer.cacheHits}
+Cache Misses: ${stats.transformOptimizer.cacheMisses}
+Transformaciones: ${stats.transformOptimizer.totalTransforms}
+Size: ${stats.transformOptimizer.cacheSize}
+Memoria: ${formatBytes(stats.transformOptimizer.memoryUsage)}
+
+📦 MODULE RESOLUTION
+Hit Rate: ${stats.moduleResolution.cacheHitRate?.toFixed(1)}%
+Cache Hits: ${stats.moduleResolution.cacheHits}
+Cache Misses: ${stats.moduleResolution.cacheMisses}
+Resoluciones: ${stats.moduleResolution.totalResolutions}
+Índice Módulos: ${stats.moduleResolution.moduleIndexSize}
+Índice Alias: ${stats.moduleResolution.aliasIndexSize}
+Tiempo Promedio: ${stats.moduleResolution.averageResolveTime?.toFixed(2)}ms
+
+=====================================
+        `;
+        return report;
+    }
+    /**
+     * Limpia todos los caches
+     */
+    clearAllCaches() {
+        clearVueHMRCache();
+        clearParserCache();
+        clearFileContentCache();
+        clearBrowserSyncCache();
+        clearMinificationCache();
+        TransformOptimizer.getInstance().clear();
+        console.log('🧹 Todos los caches han sido limpiados');
+    }
+    /**
+     * Limpia entradas expiradas de todos los caches
+     */
+    cleanExpiredCaches() {
+        cleanExpiredVueHMRCache();
+        cleanExpiredParserCache();
+        cleanExpiredMinificationCache();
+        console.log('🧹 Entradas expiradas limpiadas de todos los caches');
+    }
+    /**
+     * Configura limpieza automática periódica
+     */
+    setupAutomaticCleanup(intervalMinutes = 30) {
+        setInterval(() => {
+            this.cleanExpiredCaches();
+            console.log(`🔄 Limpieza automática ejecutada cada ${intervalMinutes} minutos`);
+        }, intervalMinutes * 60 * 1000);
+    }
+    /**
+     * Obtiene métricas simplificadas para logging
+     */
+    getSimpleMetrics() {
+        const stats = this.getAllStats();
+        return {
+            hitRate: stats.summary.overallHitRate,
+            totalHits: stats.summary.totalCacheHits,
+            totalMisses: stats.summary.totalCacheMisses,
+            memoryUsage: stats.summary.totalMemoryUsage,
+            cacheEntries: stats.summary.totalCacheEntries,
+        };
+    }
+}
+// Exportar instancia singleton
+export const performanceMonitor = PerformanceMonitor.getInstance();
+// Funciones de conveniencia
+export const getAllPerformanceStats = () => performanceMonitor.getAllStats();
+export const generatePerformanceReport = () => performanceMonitor.generateReport();
+export const clearAllCaches = () => performanceMonitor.clearAllCaches();
+export const cleanExpiredCaches = () => performanceMonitor.cleanExpiredCaches();
+export const getSimpleMetrics = () => performanceMonitor.getSimpleMetrics();
+//# sourceMappingURL=performance-monitor.js.map

package/dist/compiler/tailwindcss.js

@@ -1 +1,39 @@
-import{env as e}from"node:process";import{logger as t}from"../servicios/logger.js";import{TailwindNode as n}from"../wrappers/tailwind-node.js";export async function generateTailwindCSS(){if(e.tailwindcss===`false`||e.tailwindcss===void 0||e.TAILWIND===`false`)return!1;try{let t=JSON.parse(e.tailwindcss);if(!t||!t.input||!t.output||!t.bin)return!1;let r=await new n({binPath:t.bin,input:t.input,output:t.output,minify:e.isProd===`true`});return await r.run()}catch(e){let n=e instanceof Error?e.stderr||e.message:String(e);if(t.error(`❌ :Error al compilar Tailwind:`,n),e instanceof SyntaxError&&e.message.includes(`JSON`))return!1;throw e}}
+import { env } from 'node:process';
+import { logger } from '../servicios/logger.js';
+import { TailwindNode } from '../wrappers/tailwind-node.js';
+export async function generateTailwindCSS() {
+    if (env.tailwindcss === 'false' ||
+        env.tailwindcss === undefined ||
+        env.TAILWIND === 'false') {
+        return false;
+    }
+    try {
+        const tailwindcssConfig = JSON.parse(env.tailwindcss);
+        if (!tailwindcssConfig ||
+            !tailwindcssConfig.input ||
+            !tailwindcssConfig.output ||
+            !tailwindcssConfig.bin) {
+            return false;
+        }
+        const tnode = await new TailwindNode({
+            binPath: tailwindcssConfig.bin,
+            input: tailwindcssConfig.input,
+            output: tailwindcssConfig.output,
+            minify: env.isProd === 'true',
+        });
+        return await tnode.run();
+    }
+    catch (err) {
+        // Si es un error de JSON parse, devolver false en lugar de lanzar error
+        const errorMessage = err instanceof Error
+            ? err.stderr || err.message
+            : String(err);
+        logger.error('❌ :Error al compilar Tailwind:', errorMessage);
+        if (err instanceof SyntaxError && err.message.includes('JSON')) {
+            return false;
+        }
+        // Para otros errores (como errores de ejecución de TailwindCSS), loggear y relanzar
+        throw err;
+    }
+}
+//# sourceMappingURL=tailwindcss.js.map