versacompiler 2.0.0 → 2.0.1

package/dist/compiler/vuejs.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import path from 'node:path';
 import * as vCompiler from 'vue/compiler-sfc';
 import { logger } from '../servicios/logger.js';
@@ -10,6 +11,123 @@ async function loadChalk() {
     }
     return chalk;
 }
+class VueHMRInjectionCache {
+    static instance;
+    cache = new Map();
+    MAX_CACHE_SIZE = 100;
+    CACHE_TTL = 5 * 60 * 1000; // 5 minutos
+    static getInstance() {
+        if (!VueHMRInjectionCache.instance) {
+            VueHMRInjectionCache.instance = new VueHMRInjectionCache();
+        }
+        return VueHMRInjectionCache.instance;
+    }
+    /**
+     * Genera un hash del contenido original para detectar cambios
+     */
+    generateContentHash(data) {
+        return createHash('md5').update(data).digest('hex');
+    }
+    /**
+     * Obtiene código HMR inyectado desde cache o lo genera
+     */
+    getOrGenerateHMRInjection(originalData, fileName) {
+        const contentHash = this.generateContentHash(originalData);
+        const cacheKey = `${fileName}:${contentHash}`;
+        // Verificar cache
+        const cached = this.cache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
+            return {
+                injectedData: cached.injectedCode,
+                cached: true,
+            };
+        }
+        // Generar nueva inyección HMR
+        const vueImportPattern = /import\s*\{[^}]*\bref\b[^}]*\}\s*from\s*['"]vue['"]/;
+        const hasRefImport = vueImportPattern.test(originalData);
+        const varContent = `
+            ${hasRefImport ? '' : 'import { ref } from "/node_modules/vue/dist/vue.esm-browser.js";'}
+            const versaComponentKey = ref(0);
+            `;
+        let injectedData;
+        const ifExistScript = originalData.includes('<script');
+        if (!ifExistScript) {
+            injectedData =
+                `<script setup lang="ts">${varContent}</script>/n` +
+                    originalData;
+        }
+        else {
+            injectedData = originalData.replace(/(<script.*?>)/, `$1${varContent}`);
+        }
+        // Inyectar :key en el template
+        injectedData = injectedData.replace(/(<template[^>]*>[\s\S]*?)(<(\w+)([^>]*?))(\/?>)/, (match, p1, p2, p3, p4, p5) => {
+            if (p4.includes(':key=') || p4.includes('key=')) {
+                return match;
+            }
+            const isSelfClosing = p5 === '/>';
+            if (isSelfClosing) {
+                return `${p1}<${p3}${p4} :key="versaComponentKey" />`;
+            }
+            else {
+                return `${p1}<${p3}${p4} :key="versaComponentKey">`;
+            }
+        });
+        // Cachear resultado
+        this.cache.set(cacheKey, {
+            contentHash,
+            injectedCode: injectedData,
+            hasRefImport,
+            timestamp: Date.now(),
+        });
+        // Limpiar cache si es necesario
+        this.evictIfNeeded();
+        return {
+            injectedData,
+            cached: false,
+        };
+    }
+    /**
+     * Limpia entradas de cache cuando se excede el límite
+     */
+    evictIfNeeded() {
+        if (this.cache.size <= this.MAX_CACHE_SIZE)
+            return;
+        const entries = Array.from(this.cache.entries());
+        entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+        // Eliminar las entradas más antiguas
+        const toDelete = entries.slice(0, entries.length - this.MAX_CACHE_SIZE);
+        toDelete.forEach(([key]) => this.cache.delete(key));
+    }
+    /**
+     * Limpia entradas expiradas
+     */
+    cleanExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.CACHE_TTL) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    /**
+     * Obtiene estadísticas del cache
+     */
+    getStats() {
+        return {
+            size: this.cache.size,
+            maxSize: this.MAX_CACHE_SIZE,
+            ttl: this.CACHE_TTL,
+        };
+    }
+    /**
+     * Limpia todo el cache
+     */
+    clear() {
+        this.cache.clear();
+    }
+}
+// Instancia global del cache HMR
+const hmrInjectionCache = VueHMRInjectionCache.getInstance();
 const getComponentsVueMap = async (ast) => {
     let components = [];
     const importsStatic = ast?.module?.staticImports;
@@ -22,12 +140,6 @@ const getComponentsVueMap = async (ast) => {
     }
     return components;
 };
-/**
- * Compila un bloque personalizado.
- * @param {Object} block - El bloque personalizado a compilar.
- * @param {string} source - La fuente del bloque.
- */
-const _compileCustomBlock = async (_block, _source) => { };
 /**
  * Precompila un componente Vue.
  * @param {string} data - El código del componente Vue.
@@ -45,36 +157,8 @@ export const preCompileVue = async (data, source, isProd = false) => {
             };
         }
         if (!isProd) {
-            // Verificar si ya existe una importación de ref desde vue de manera más precisa
-            const vueImportPattern = /import\s*\{[^}]*\bref\b[^}]*\}\s*from\s*['"]vue['"]/;
-            const hasRefImport = vueImportPattern.test(data);
-            // esto es para HMR re re forzado
-            const varContent = `
-            ${hasRefImport ? '' : 'import { ref } from "/node_modules/vue/dist/vue.esm-browser.js";'}
-            const versaComponentKey = ref(0);
-            `;
-            const ifExistScript = data.includes('<script');
-            if (!ifExistScript) {
-                data =
-                    `<script setup lang="ts">${varContent}</script>/n` + data;
-            }
-            else {
-                data = data.replace(/(<script.*?>)/, `$1${varContent}`);
-            }
-            data = data.replace(/(<template[^>]*>[\s\S]*?)(<(\w+)([^>]*?))(\/?>)/, (match, p1, p2, p3, p4, p5) => {
-                // Si ya tiene :key, no agregarlo de nuevo
-                if (p4.includes(':key=') || p4.includes('key=')) {
-                    return match;
-                }
-                // Si es self-closing (termina con '/>'), manejar diferente
-                const isSelfClosing = p5 === '/>';
-                if (isSelfClosing) {
-                    return `${p1}<${p3}${p4} :key="versaComponentKey" />`;
-                }
-                else {
-                    return `${p1}<${p3}${p4} :key="versaComponentKey">`;
-                }
-            });
+            const { injectedData } = hmrInjectionCache.getOrGenerateHMRInjection(data, fileName);
+            data = injectedData;
         }
         const { descriptor, errors } = vCompiler.parse(data, {
             filename: fileName,
@@ -132,7 +216,7 @@ export const preCompileVue = async (data, source, isProd = false) => {
         const ast = await parser(`temp.${scriptLang}`, scriptContent, scriptLang);
         if (ast?.errors.length > 0) {
             throw new Error(`Error al analizar el script del componente Vue ${source}:\n${ast.errors
-                .map(e => e.message)
+                .map((e) => e.message)
                 .join('\n')}`);
         }
         const components = await getComponentsVueMap(ast);
@@ -293,4 +377,14 @@ export const preCompileVue = async (data, source, isProd = false) => {
         };
     }
 };
+// ✨ NUEVA FUNCIÓN: Exportar funcionalidades del cache HMR para uso externo
+export const getVueHMRCacheStats = () => {
+    return hmrInjectionCache.getStats();
+};
+export const clearVueHMRCache = () => {
+    hmrInjectionCache.clear();
+};
+export const cleanExpiredVueHMRCache = () => {
+    hmrInjectionCache.cleanExpired();
+};
 //# sourceMappingURL=vuejs.js.map

package/dist/main.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import path from 'node:path'; // Importar el módulo path
-import { env } from 'node:process';
+import process, { env } from 'node:process';
 // Lazy loading optimizations - Only import lightweight modules synchronously
 import { fileURLToPath } from 'node:url';
 import { logger } from './servicios/logger.js';
@@ -35,7 +35,7 @@ async function loadBrowserSyncModule() {
     return await import('./servicios/browserSync.js');
 }
 async function loadChokidarModule() {
-    return await import('./servicios/chokidar.js');
+    return await import('./servicios/file-watcher.js');
 }
 async function loadConfigModule() {
     return await import('./servicios/readConfig.js');
@@ -100,7 +100,7 @@ async function main() {
         .alias('y', 'yes')
         .option('typeCheck', {
         type: 'boolean',
-        description: 'Habilitar/Deshabilitar la verificación de tipos. Por defecto --typeCheck=true',
+        description: 'Habilitar/Deshabilitar la verificación de tipos. Por defecto --typeCheck=false',
         default: false,
     })
         .alias('t', 'typeCheck');
@@ -199,8 +199,7 @@ async function main() {
         }
         if (argv.file) {
             // Compilar archivo individual
-            logger.info(chalk.yellow(`📄 Compilando archivo: ${argv.file}`));
-            // Verificar si el archivo existe
+            logger.info(chalk.yellow(`📄 Compilando archivo: ${argv.file}`)); // Verificar si el archivo existe
             const fs = await import('node:fs/promises');
             const { compileFile } = await loadCompilerModule();
             let absolutePathFile;
@@ -212,7 +211,7 @@ async function main() {
                 logger.error(chalk.red(`❌ Error: El archivo '${argv.file}' no existe.`));
                 process.exit(1);
             }
-            // Compilar el archivo
+            // Compilar el archivo (absolutePathFile está garantizado aquí)
             const result = await compileFile(absolutePathFile);
             if (result.success) {
                 logger.info(chalk.green(`✅ Archivo compilado exitosamente: ${result.output}`));

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