versacompiler 2.0.0 → 2.0.2

package/dist/compiler/typescript-worker.js

@@ -16,10 +16,10 @@ export class TypeScriptWorkerManager {
     pendingTasks = new Map();
     taskCounter = 0;
     workerReady = false;
-    initPromise = null;
-    // Configuración del worker
-    WORKER_TIMEOUT = 30000; // 30 segundos timeout (incrementado)
+    initPromise = null; // Configuración del worker    private readonly WORKER_TIMEOUT = 45000; // 45 segundos timeout (incrementado para manejar concurrencia)
     MAX_RETRY_ATTEMPTS = 2;
+    MAX_CONCURRENT_TASKS = 20; // Aumentar límite de tareas concurrentes
+    TASK_TIMEOUT = 15000; // 15 segundos timeout por tarea individual
     // NUEVOS: Gestión de modo y estado para optimización
     currentMode = null;
     constructor() { }
@@ -50,29 +50,38 @@ export class TypeScriptWorkerManager {
         }
         this.initPromise = this._performWorkerInitialization();
         return this.initPromise;
-    } /**
+    }
+    /**
      * Realiza la inicialización del worker thread
-     */
-    async _performWorkerInitialization() {
+     */ async _performWorkerInitialization() {
         try {
-            // Obtener ruta al worker thread (compatible con ES modules y Windows)
-            const workerPath = path.join(process.env.PATH_PROY || process.cwd(), 'compiler', 'typescript-worker-thread.cjs');
-            // console.log('[WorkerManager] Inicializando worker en:', workerPath);
+            console.log('[WorkerManager] 🚀 Iniciando proceso de inicialización del worker...'); // Obtener ruta al worker thread (compatible con ES modules y Windows)
+            const workerPath = path.join(process.env.PATH_PROY || path.join(process.cwd(), 'src'), 'compiler', 'typescript-worker-thread.cjs');
+            console.log('[WorkerManager] 📂 Ruta del worker:', workerPath);
+            console.log('[WorkerManager] 🌍 PATH_PROY:', process.env.PATH_PROY);
+            console.log('[WorkerManager] 📁 CWD:', process.cwd());
+            // Verificar que el archivo existe
+            const fs = await import('node:fs');
+            const exists = fs.existsSync(workerPath);
+            console.log('[WorkerManager] 📋 Worker file exists:', exists);
             // Crear el worker thread sin tsx para evitar dependencias externas
+            console.log('[WorkerManager] 🔧 Creando Worker...');
             this.worker = new Worker(workerPath, {
                 env: {
                     ...process.env,
                     NODE_OPTIONS: '', // Limpiar NODE_OPTIONS para evitar conflictos con tsx
                 },
             });
+            console.log('[WorkerManager] ✅ Worker creado, configurando listeners...');
             // Configurar listeners del worker
             this.setupWorkerListeners();
+            console.log('[WorkerManager] ⏳ Esperando que el worker esté listo...');
             // Esperar a que el worker esté listo
             await this.waitForWorkerReady();
-            // console.log('[WorkerManager] Worker inicializado exitosamente');
+            console.log('[WorkerManager] ✅ Worker inicializado exitosamente');
         }
         catch (error) {
-            console.error('[WorkerManager] Error inicializando worker:', error);
+            console.error('[WorkerManager] ❌ Error inicializando worker:', error);
             this.worker = null;
             this.workerReady = false;
             throw error;
@@ -178,33 +187,55 @@ export class TypeScriptWorkerManager {
      */
     generateTaskId() {
         return `task-${++this.taskCounter}-${Date.now()}`;
-    } /**
+    }
+    /**
      * Realiza type checking usando el worker thread (con fallback síncrono)
      * @param fileName - Nombre del archivo TypeScript
      * @param content - Contenido del archivo
      * @param compilerOptions - Opciones del compilador TypeScript
      * @returns Resultado de la validación de tipos
-     */
-    async typeCheck(fileName, content, compilerOptions) {
+     */ async typeCheck(fileName, content, compilerOptions) {
+        // Limitar tareas concurrentes para evitar saturación
+        if (this.pendingTasks.size >= this.MAX_CONCURRENT_TASKS) {
+            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+        }
         // En modo de testing o si hay problemas de inicialización, usar fallback directo
         if (process.env.NODE_ENV === 'test' || !this.worker) {
+            if (!this.worker) {
+                try {
+                    await this.initializeWorker();
+                    if (this.worker && this.workerReady) {
+                        console.log('[WorkerManager] ✅ Worker inicializado exitosamente, reintentando...');
+                        return this.typeCheckWithWorker(fileName, content, compilerOptions);
+                    }
+                }
+                catch (error) {
+                    console.error('[WorkerManager] ❌ Error inicializando worker:', error);
+                }
+            }
+            console.log('[WorkerManager] 🔄 Usando fallback síncrono (test mode o worker no disponible)');
             return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
         }
         try {
-            // Intentar usar el worker thread con timeout más corto
+            console.log('[WorkerManager] 🚀 Intentando usar worker thread...');
+            // Intentar usar el worker thread con timeout más realista
             const workerPromise = this.typeCheckWithWorker(fileName, content, compilerOptions);
             const timeoutPromise = new Promise((resolve, reject) => {
                 setTimeout(() => {
+                    console.log('[WorkerManager] ⏰ Worker timeout, usando fallback');
                     reject(new Error('Worker timeout - usando fallback'));
-                }, 5000); // 5 segundos max para worker
+                }, this.TASK_TIMEOUT); // Usar timeout por tarea más realista
             });
-            return await Promise.race([workerPromise, timeoutPromise]);
+            console.log('[WorkerManager] ⏳ Esperando respuesta del worker...');
+            const result = await Promise.race([workerPromise, timeoutPromise]);
+            console.log('[WorkerManager] ✅ Worker completado exitosamente');
+            return result;
         }
         catch (workerError) {
             const errorMessage = workerError instanceof Error
                 ? workerError.message
                 : String(workerError);
-            console.warn('[WorkerManager] Error en worker, usando fallback síncrono:', errorMessage);
+            console.warn('[WorkerManager] ❌ Error en worker, usando fallback síncrono:', errorMessage);
             // Fallback a validación síncrona
             return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
         }
@@ -219,12 +250,11 @@ export class TypeScriptWorkerManager {
             throw new Error('Worker no disponible');
         }
         return new Promise((resolve, reject) => {
-            const taskId = this.generateTaskId();
-            // Configurar timeout para la tarea
+            const taskId = this.generateTaskId(); // Configurar timeout para la tarea
             const timeout = setTimeout(() => {
                 this.pendingTasks.delete(taskId);
                 reject(new Error(`Timeout en type checking para ${fileName}`));
-            }, this.WORKER_TIMEOUT);
+            }, this.TASK_TIMEOUT);
             // Agregar tarea a la lista de pendientes
             this.pendingTasks.set(taskId, {
                 resolve,

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}`));