versacompiler 2.0.7 → 2.0.8

package/dist/compiler/parser.js

@@ -1,203 +1 @@
-import { createHash } from 'node:crypto';
-import fs, { readFile } from 'node:fs/promises';
-import oxc from 'oxc-parser';
-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 = oxc.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 {
-        // validar si existe el archivo
-        await fs.access(filename);
-        const code = await readFile(filename, 'utf-8');
-        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();
-};
-//# sourceMappingURL=parser.js.map
+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()};

package/dist/compiler/performance-monitor.js

@@ -1,192 +1,56 @@
-/**
- * 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, clearParserCache, 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 browserSyncCache = getBrowserSyncCacheStats();
-        const minificationCache = getMinificationCacheStats();
-        const transformOptimizer = TransformOptimizer.getInstance().getStats();
-        const moduleResolution = getModuleResolutionMetrics();
-        // Calcular resumen general
-        const totalCacheHits = (parserCache.cacheHits || 0) +
-            (browserSyncCache.cacheHits || 0) +
-            (minificationCache.cacheHits || 0) +
-            (transformOptimizer.cacheHits || 0) +
-            (moduleResolution.cacheHits || 0);
-        const totalCacheMisses = (parserCache.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) +
-            (browserSyncCache.cacheSize || 0) +
-            (minificationCache.cacheSize || 0) +
-            (transformOptimizer.cacheSize || 0) +
-            (moduleResolution.cacheSize || 0);
-        return {
-            vueHMRCache,
-            parserCache,
-            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)}
-
-🌐 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();
-        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
+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();

package/dist/compiler/tailwindcss.js

@@ -1,39 +1 @@
-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
+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}}