versacompiler 2.4.0 → 2.5.0

package/dist/compiler/typescript-sync-validator.js

@@ -10,36 +10,36 @@ import * as typescript from 'typescript';
  * Genera declaraciones básicas de tipos para Vue como fallback
  */
 const generateBasicVueTypes = () => {
-    return `// Declaraciones básicas de tipos Vue para validación
-declare global {
-    function ref<T>(value: T): { value: T };
-    function reactive<T extends object>(target: T): T;
-    function computed<T>(getter: () => T): { value: T };
-    function defineComponent<T>(options: T): T;
-    function defineProps<T = {}>(): T;
-    function defineEmits<T = {}>(): T;
-    function defineExpose<T = {}>(exposed: T): void;
-    function onMounted(fn: () => void): void;
-    function onUnmounted(fn: () => void): void;
-    function onBeforeMount(fn: () => void): void;
-    function onBeforeUnmount(fn: () => void): void;
-    function onUpdated(fn: () => void): void;
-    function onBeforeUpdate(fn: () => void): void;
-    function provide<T>(key: string | symbol, value: T): void;
-    function inject<T>(key: string | symbol, defaultValue?: T): T | undefined;
-    function useSlots(): { [key: string]: (...args: any[]) => any };
-    function useAttrs(): { [key: string]: any };
-    function useModel<T>(modelName?: string): { value: T };
-    function watch<T>(source: () => T, callback: (newValue: T, oldValue: T) => void): void;
-    function watchEffect(effect: () => void): void;
-    function nextTick(callback?: () => void): Promise<void>;
-    function getCurrentInstance(): any;
-    function mergeModels<T>(models: T): T;
-}
-declare module '*.vue' {
-    const component: any;
-    export default component;
-}
+    return `// Declaraciones básicas de tipos Vue para validación
+declare global {
+    function ref<T>(value: T): { value: T };
+    function reactive<T extends object>(target: T): T;
+    function computed<T>(getter: () => T): { value: T };
+    function defineComponent<T>(options: T): T;
+    function defineProps<T = {}>(): T;
+    function defineEmits<T = {}>(): T;
+    function defineExpose<T = {}>(exposed: T): void;
+    function onMounted(fn: () => void): void;
+    function onUnmounted(fn: () => void): void;
+    function onBeforeMount(fn: () => void): void;
+    function onBeforeUnmount(fn: () => void): void;
+    function onUpdated(fn: () => void): void;
+    function onBeforeUpdate(fn: () => void): void;
+    function provide<T>(key: string | symbol, value: T): void;
+    function inject<T>(key: string | symbol, defaultValue?: T): T | undefined;
+    function useSlots(): { [key: string]: (...args: any[]) => any };
+    function useAttrs(): { [key: string]: any };
+    function useModel<T>(modelName?: string): { value: T };
+    function watch<T>(source: () => T, callback: (newValue: T, oldValue: T) => void): void;
+    function watchEffect(effect: () => void): void;
+    function nextTick(callback?: () => void): Promise<void>;
+    function getCurrentInstance(): any;
+    function mergeModels<T>(models: T): T;
+}
+declare module '*.vue' {
+    const component: any;
+    export default component;
+}
 export {};`;
 };
 /**
@@ -269,7 +269,9 @@ export const validateTypesWithLanguageService = (fileName, content, compilerOpti
             try {
                 languageService.dispose();
             }
-            catch { /* ignore dispose errors */ }
+            catch {
+                /* ignore dispose errors */
+            }
         }
     }
     catch (error) {

package/dist/compiler/typescript-worker-pool.js

@@ -19,8 +19,8 @@ export class TypeScriptWorkerPool {
     workerPath;
     initPromise = null;
     isInitialized = false; // Configuración optimizada con reciclaje de workers
-    TASK_TIMEOUT = 8000; // 8 segundos por tarea (reducido para mayor velocidad)
-    WORKER_INIT_TIMEOUT = 3000; // 3 segundos para inicializar (reducido)
+    TASK_TIMEOUT = 60000; // 60 segundos por tarea - workers son secuenciales, necesitan tiempo
+    WORKER_INIT_TIMEOUT = 10000; // 10 segundos para inicializar
     MAX_TASKS_PER_WORKER = 200; // ✨ OPTIMIZADO: Aumentado de 50 a 200 para reducir overhead de reciclaje
     WORKER_MEMORY_CHECK_INTERVAL = 500; // ✨ OPTIMIZADO: Verificar cada 500 tareas (reducir overhead)
     // ✨ FIX #1: Referencias a timers para limpieza adecuada
@@ -28,7 +28,7 @@ export class TypeScriptWorkerPool {
     cleanupInterval = null;
     // Cola de tareas para cuando todos los workers están ocupados
     taskQueue = [];
-    MAX_QUEUE_SIZE = 50;
+    MAX_QUEUE_SIZE = 1000; // Suficiente para proyectos de 300+ archivos
     // Flag para evitar concurrencia en ensureWorkerCapacity
     isScalingUp = false;
     // Métricas de rendimiento
@@ -85,8 +85,11 @@ export class TypeScriptWorkerPool {
                 // ✨ ISSUE #4: Obtener memoria real del worker
                 const memoryInfo = await this.getWorkerMemoryUsage(poolWorker);
                 poolWorker.memoryUsage = memoryInfo.heapUsed;
-                // Verificar límites de memoria y reciclaje automático
-                if (this.shouldRecycleWorker(poolWorker)) {
+                // Verificar límites de memoria y reciclaje automático.
+                // Solo reciclar workers INACTIVOS para evitar rechazar tareas en vuelo.
+                // Los workers con tareas pendientes se reciclan vía drainQueue cuando quedan libres.
+                const isIdle = !poolWorker.busy && poolWorker.pendingTasks.size === 0;
+                if (isIdle && this.shouldRecycleWorker(poolWorker)) {
                     const reason = this.getRecycleReason(poolWorker);
                     console.warn(`[WorkerPool] Worker ${poolWorker.id} requiere reciclaje: ${reason}`);
                     await this.recycleWorker(poolWorker);
@@ -198,8 +201,8 @@ export class TypeScriptWorkerPool {
         const cpuCount = os.cpus().length;
         switch (mode) {
             case 'batch':
-                // Para modo batch, hasta 3 workers conservando al menos 1 CPU libre
-                this.poolSize = Math.min(3, Math.max(1, cpuCount - 1));
+                // Para modo batch, hasta 4 workers para mejor rendimiento en proyectos grandes
+                this.poolSize = Math.min(4, Math.max(1, cpuCount - 1));
                 break;
             case 'watch':
                 // Para modo watch, hasta 2 workers para menor impacto en sistema
@@ -376,9 +379,10 @@ export class TypeScriptWorkerPool {
                     });
                 }
                 else {
-                    this.failedTasks++;
                     const errorMessage = response.error || 'Error desconocido del worker';
                     // ✨ FIX MEMORIA: Error simple sin referencias pesadas
+                    // failedTasks se incrementa en el wrapper de queued.reject para tareas de cola,
+                    // o en handleWorkerError/Exit para tareas directas que se re-encolan.
                     const error = new Error(errorMessage);
                     reject(error);
                 }
@@ -404,7 +408,8 @@ export class TypeScriptWorkerPool {
         const pendingTasksArray = Array.from(poolWorker.pendingTasks.entries());
         for (const [taskId, task] of pendingTasksArray) {
             clearTimeout(task.timeout);
-            this.failedTasks++;
+            // failedTasks se contabiliza en el wrapper de queued.reject (para cola)
+            // o via re-encolado en typeCheck() catch (para tareas directas).
             task.reject(new Error(`Worker ${poolWorker.id} failed`));
             poolWorker.pendingTasks.delete(taskId);
         }
@@ -436,6 +441,8 @@ export class TypeScriptWorkerPool {
                     if (index !== -1) {
                         this.workers[index] = newWorker;
                     }
+                    // Drenar la cola con el nuevo worker para evitar tareas atascadas
+                    setImmediate(() => this.drainAllWorkers());
                 }
                 catch {
                     // Silencioso
@@ -451,7 +458,8 @@ export class TypeScriptWorkerPool {
         // 1. Rechazar tareas pendientes con cleanup
         poolWorker.pendingTasks.forEach(task => {
             clearTimeout(task.timeout);
-            this.failedTasks++;
+            // failedTasks se contabiliza en el wrapper de queued.reject (para cola)
+            // o via re-encolado en typeCheck() catch (para tareas directas).
             task.reject(new Error(`Worker ${poolWorker.id} exited with code ${code}`));
         });
         poolWorker.pendingTasks.clear();
@@ -543,6 +551,8 @@ export class TypeScriptWorkerPool {
             if (index !== -1) {
                 this.workers[index] = newWorker;
             }
+            // Drenar la cola con el nuevo worker listo
+            setImmediate(() => this.drainQueue(newWorker));
         }
         catch (error) {
             console.error(`[WorkerPool] Error reciclando worker ${poolWorker.id}:`, error);
@@ -573,6 +583,18 @@ export class TypeScriptWorkerPool {
         }
         return null; // Todos los workers están muy ocupados
     }
+    /**
+     * Drena la cola en todos los workers disponibles
+     */
+    drainAllWorkers() {
+        for (const worker of this.workers) {
+            if (!worker.busy && worker.pendingTasks.size === 0) {
+                this.drainQueue(worker);
+                if (this.taskQueue.length === 0)
+                    break;
+            }
+        }
+    }
     /**
      * Procesa la siguiente tarea de la cola en el worker liberado
      */
@@ -581,19 +603,27 @@ export class TypeScriptWorkerPool {
             return;
         if (poolWorker.busy || poolWorker.pendingTasks.size > 0)
             return;
-        if (poolWorker.taskCounter >= this.MAX_TASKS_PER_WORKER)
+        // Si el worker alcanzó el límite de tareas, reciclarlo y luego drenar
+        if (poolWorker.taskCounter >= this.MAX_TASKS_PER_WORKER) {
+            this.recycleWorker(poolWorker)
+                .then(() => setImmediate(() => this.drainAllWorkers()))
+                .catch(() => { });
             return;
+        }
         const queued = this.taskQueue.shift();
         if (!queued)
             return;
         const waitMs = Date.now() - queued.queuedAt;
         if (waitMs > 30000) {
+            // queued.reject incluye failedTasks++ en el wrapper (ver typeCheck())
             queued.reject(new Error(`Queue task expired after ${waitMs}ms`));
+            // Continuar drenando la cola con la siguiente tarea
+            setImmediate(() => this.drainQueue(poolWorker));
             return;
         }
         this.typeCheckWithWorker(poolWorker, queued.fileName, queued.content, queued.compilerOptions)
             .then(queued.resolve)
-            .catch(queued.reject);
+            .catch(queued.reject); // queued.reject incluye failedTasks++ en el wrapper
     }
     /**
      * Realiza type checking usando el pool de workers
@@ -613,23 +643,38 @@ export class TypeScriptWorkerPool {
                 return await this.typeCheckWithWorker(availableWorker, fileName, content, compilerOptions);
             }
             catch {
-                // Worker falló; intentar encolar
+                // Worker falló o llegó al límite de tareas
+                // Si alcanzó el límite, disparar reciclaje inmediato
+                if (availableWorker.taskCounter >= this.MAX_TASKS_PER_WORKER) {
+                    this.recycleWorker(availableWorker)
+                        .then(() => setImmediate(() => this.drainAllWorkers()))
+                        .catch(() => { });
+                }
             }
         }
         // Ningún worker disponible: encolar la tarea
         if (this.taskQueue.length >= this.MAX_QUEUE_SIZE) {
-            // Cola llena → fallback síncrono para no perder el type check
-            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+            // Cola llena → omitir type check para no bloquear el event loop
+            // (con MAX_QUEUE_SIZE=1000 esto solo ocurre en proyectos extremadamente grandes)
+            console.warn(`[TypeCheckQueue] Cola llena (${this.MAX_QUEUE_SIZE} tareas). Type check omitido para: ${path.basename(fileName)}`);
+            this.completedTasks++; // Contabilizar como completado para mantener métricas consistentes
+            return { diagnostics: [], hasErrors: false };
         }
         // Escalar el pool si es posible
         this.ensureWorkerCapacity().catch(() => { });
         return new Promise((resolve, reject) => {
+            // Wrapper para reject que garantiza que failedTasks se incrementa exactamente una vez
+            // para todas las tareas que pasan por la cola (drainQueue path).
+            const wrappedReject = (err) => {
+                this.failedTasks++;
+                reject(err);
+            };
             this.taskQueue.push({
                 fileName,
                 content,
                 compilerOptions,
                 resolve,
-                reject,
+                reject: wrappedReject,
                 queuedAt: Date.now(),
             });
         });
@@ -639,9 +684,9 @@ export class TypeScriptWorkerPool {
      * ✨ FIX MEMORIA: Optimizado para prevenir fugas de memoria
      */
     async typeCheckWithWorker(poolWorker, fileName, content, compilerOptions) {
-        // Si el worker alcanzó su límite de tareas, usar fallback síncrono
+        // Si el worker alcanzó su límite de tareas, encolar para reciclaje
         if (poolWorker.taskCounter >= this.MAX_TASKS_PER_WORKER) {
-            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+            throw new Error(`Worker ${poolWorker.id} ha alcanzado el límite de tareas`);
         }
         return new Promise((resolve, reject) => {
             const taskId = `task-${poolWorker.id}-${++poolWorker.taskCounter}-${Date.now()}`;
@@ -660,6 +705,8 @@ export class TypeScriptWorkerPool {
                         poolWorker.busy = false;
                     }
                     reject(new Error(`Timeout (${dynamicTimeout}ms) en type checking para ${fileName}`));
+                    // Drenar la cola cuando se libera la tarea por timeout
+                    setImmediate(() => this.drainQueue(poolWorker));
                 }
             }, dynamicTimeout);
             // ✨ FIX MEMORIA: Wrapper para resolver/rechazar que limpia el timeout
@@ -764,7 +811,7 @@ export class TypeScriptWorkerPool {
         complexityMultiplier = Math.min(complexityMultiplier, 5); // Máximo 5x el timeout base
         complexityMultiplier = Math.max(complexityMultiplier, 0.5); // Mínimo 0.5x el timeout base
         const finalTimeout = Math.round(baseTimeout * complexityMultiplier);
-        return Math.min(finalTimeout, 60000); // Máximo absoluto de 60 segundos
+        return Math.min(finalTimeout, 120000); // Máximo absoluto de 120 segundos
     }
     /**
      * Fallback síncrono para type checking