versacompiler 1.0.5 → 2.0.1

package/dist/compiler/parser.js

@@ -0,0 +1,203 @@
+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

package/dist/compiler/performance-monitor.js

@@ -0,0 +1,192 @@
+/**
+ * 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

package/dist/compiler/tailwindcss.js

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