versacompiler 2.0.8 → 2.2.0

package/dist/compiler/typescript-worker.js

@@ -1 +1,339 @@
-import*as e from"node:path";import*as t from"node:process";import{Worker as n}from"node:worker_threads";import{validateTypesWithLanguageService as r}from"./typescript-sync-validator.js";export class TypeScriptWorkerManager{static instance;worker=null;pendingTasks=new Map;taskCounter=0;workerReady=!1;initPromise=null;MAX_RETRY_ATTEMPTS=2;MAX_CONCURRENT_TASKS=20;TASK_TIMEOUT=15e3;currentMode=null;constructor(){}setMode(e){this.currentMode=e,console.log(`[WorkerManager] Modo establecido: ${e}`)}static getInstance(){return TypeScriptWorkerManager.instance||=new TypeScriptWorkerManager,TypeScriptWorkerManager.instance}async initializeWorker(){return this.initPromise||=this._performWorkerInitialization(),this.initPromise}async _performWorkerInitialization(){try{console.log(`[WorkerManager] 🚀 Iniciando proceso de inicialización del worker...`);let r=e.join(t.env.PATH_PROY||e.join(t.cwd(),`src`),`compiler`,`typescript-worker-thread.cjs`);console.log(`[WorkerManager] 📂 Ruta del worker:`,r),console.log(`[WorkerManager] 🌍 PATH_PROY:`,t.env.PATH_PROY),console.log(`[WorkerManager] 📁 CWD:`,t.cwd());let i=await import(`node:fs`),a=i.existsSync(r);console.log(`[WorkerManager] 📋 Worker file exists:`,a),console.log(`[WorkerManager] 🔧 Creando Worker...`),this.worker=new n(r,{env:{...t.env,NODE_OPTIONS:``}}),console.log(`[WorkerManager] ✅ Worker creado, configurando listeners...`),this.setupWorkerListeners(),console.log(`[WorkerManager] ⏳ Esperando que el worker esté listo...`),await this.waitForWorkerReady(),console.log(`[WorkerManager] ✅ Worker inicializado exitosamente`)}catch(e){throw console.error(`[WorkerManager] ❌ Error inicializando worker:`,e),this.worker=null,this.workerReady=!1,e}}setupWorkerListeners(){this.worker&&(this.worker.on(`message`,e=>{try{if(e.id===`worker-ready`){this.workerReady=!0;return}let t=this.pendingTasks.get(e.id);if(!t){console.warn(`[WorkerManager] Respuesta para tarea desconocida:`,e.id);return}if(clearTimeout(t.timeout),this.pendingTasks.delete(e.id),e.success&&e.diagnostics!==void 0&&e.hasErrors!==void 0)t.resolve({diagnostics:e.diagnostics,hasErrors:e.hasErrors});else{let n=e.error||`Error desconocido del worker`;t.reject(Error(n))}}catch(e){console.error(`[WorkerManager] Error procesando respuesta del worker:`,e)}}),this.worker.on(`error`,e=>{console.error(`[WorkerManager] Error en worker thread:`,e),this.handleWorkerError(e)}),this.worker.on(`exit`,e=>{console.warn(`[WorkerManager] Worker thread cerrado con código:`,e),this.workerReady=!1,this.pendingTasks.forEach(t=>{clearTimeout(t.timeout),t.reject(Error(`Worker cerrado inesperadamente con código ${e}`))}),this.pendingTasks.clear()}))}async waitForWorkerReady(){return new Promise((e,t)=>{let n=setTimeout(()=>{t(Error(`Timeout esperando a que el worker esté listo`))},5e3),r=()=>{this.workerReady?(clearTimeout(n),e()):setTimeout(r,50)};r()})}handleWorkerError(e){console.error(`[WorkerManager] Manejando error del worker:`,e),this.pendingTasks.forEach(t=>{clearTimeout(t.timeout),t.reject(Error(`Error en worker: ${e.message}`))}),this.pendingTasks.clear(),this.workerReady=!1}generateTaskId(){return`task-${++this.taskCounter}-${Date.now()}`}async typeCheck(e,n,r){if(this.pendingTasks.size>=this.MAX_CONCURRENT_TASKS)return this.typeCheckWithSyncFallback(e,n,r);if(t.env.NODE_ENV===`test`||!this.worker){if(!this.worker)try{if(await this.initializeWorker(),this.worker&&this.workerReady)return console.log(`[WorkerManager] ✅ Worker inicializado exitosamente, reintentando...`),this.typeCheckWithWorker(e,n,r)}catch(e){console.error(`[WorkerManager] ❌ Error inicializando worker:`,e)}return console.log(`[WorkerManager] 🔄 Usando fallback síncrono (test mode o worker no disponible)`),this.typeCheckWithSyncFallback(e,n,r)}try{console.log(`[WorkerManager] 🚀 Intentando usar worker thread...`);let t=this.typeCheckWithWorker(e,n,r),i=new Promise((e,t)=>{setTimeout(()=>{console.log(`[WorkerManager] ⏰ Worker timeout, usando fallback`),t(Error(`Worker timeout - usando fallback`))},this.TASK_TIMEOUT)});console.log(`[WorkerManager] ⏳ Esperando respuesta del worker...`);let a=await Promise.race([t,i]);return console.log(`[WorkerManager] ✅ Worker completado exitosamente`),a}catch(t){let i=t instanceof Error?t.message:String(t);return console.warn(`[WorkerManager] ❌ Error en worker, usando fallback síncrono:`,i),this.typeCheckWithSyncFallback(e,n,r)}}async typeCheckWithWorker(e,t,n){if(await this.initializeWorker(),!this.worker||!this.workerReady)throw Error(`Worker no disponible`);return new Promise((r,i)=>{let a=this.generateTaskId(),o=setTimeout(()=>{this.pendingTasks.delete(a),i(Error(`Timeout en type checking para ${e}`))},this.TASK_TIMEOUT);this.pendingTasks.set(a,{resolve:r,reject:i,timeout:o});try{let r={id:a,fileName:e,content:t,compilerOptions:n};this.worker.postMessage(r)}catch(e){clearTimeout(o),this.pendingTasks.delete(a),i(e)}})}typeCheckWithSyncFallback(e,t,n){try{return r(e,t,n)}catch(e){return console.error(`[WorkerManager] Error en fallback síncrono:`,e),{diagnostics:[],hasErrors:!1}}}async terminate(){this.worker&&(this.pendingTasks.forEach(e=>{clearTimeout(e.timeout),e.reject(Error(`Worker manager cerrado`))}),this.pendingTasks.clear(),await this.worker.terminate(),this.worker=null,this.workerReady=!1,this.initPromise=null)}getStats(){return{workerReady:this.workerReady,pendingTasks:this.pendingTasks.size,taskCounter:this.taskCounter}}}
+/**
+ * TypeScript Worker Manager - Gestiona workers dedicados para type checking asíncrono
+ * Implementa el patrón Singleton para reutilizar workers entre compilaciones
+ */
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { Worker } from 'node:worker_threads';
+import { validateTypesWithLanguageService } from './typescript-sync-validator.js';
+/**
+ * Gestiona workers dedicados para type checking asíncrono de TypeScript
+ * Implementa patrón Singleton para eficiencia y reutilización de recursos
+ */
+export class TypeScriptWorkerManager {
+    static instance;
+    worker = null;
+    pendingTasks = new Map();
+    taskCounter = 0;
+    workerReady = false;
+    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() { }
+    /**
+     * NUEVO: Configura el modo de operación del worker
+     */
+    setMode(mode) {
+        this.currentMode = mode;
+        // En modo watch, el worker se mantiene activo más tiempo
+        // En otros modos, se puede optimizar la gestión de recursos
+        console.log(`[WorkerManager] Modo establecido: ${mode}`);
+    }
+    /**
+     * Obtiene la instancia singleton del Worker Manager
+     */
+    static getInstance() {
+        if (!TypeScriptWorkerManager.instance) {
+            TypeScriptWorkerManager.instance = new TypeScriptWorkerManager();
+        }
+        return TypeScriptWorkerManager.instance;
+    }
+    /**
+     * Inicializa el worker thread de TypeScript
+     */
+    async initializeWorker() {
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = this._performWorkerInitialization();
+        return this.initPromise;
+    }
+    /**
+     * Realiza la inicialización del worker thread
+     */ async _performWorkerInitialization() {
+        try {
+            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');
+        }
+        catch (error) {
+            console.error('[WorkerManager] ❌ Error inicializando worker:', error);
+            this.worker = null;
+            this.workerReady = false;
+            throw error;
+        }
+    }
+    /**
+     * Configura los listeners del worker thread
+     */
+    setupWorkerListeners() {
+        if (!this.worker)
+            return;
+        this.worker.on('message', (response) => {
+            try {
+                // console.log('[WorkerManager] Mensaje recibido del worker:', {
+                //     id: response.id,
+                //     success: response.success,
+                //     hasErrors: response.hasErrors,
+                //     diagnosticsCount: response.diagnostics?.length,
+                // });
+                // Manejar mensaje de worker ready
+                if (response.id === 'worker-ready') {
+                    this.workerReady = true;
+                    return;
+                }
+                // Buscar la tarea pendiente correspondiente
+                const pendingTask = this.pendingTasks.get(response.id);
+                if (!pendingTask) {
+                    console.warn('[WorkerManager] Respuesta para tarea desconocida:', response.id);
+                    return;
+                }
+                // Limpiar timeout y eliminar tarea pendiente
+                clearTimeout(pendingTask.timeout);
+                this.pendingTasks.delete(response.id);
+                // Procesar respuesta
+                if (response.success &&
+                    response.diagnostics !== undefined &&
+                    response.hasErrors !== undefined) {
+                    pendingTask.resolve({
+                        diagnostics: response.diagnostics,
+                        hasErrors: response.hasErrors,
+                    });
+                }
+                else {
+                    const errorMessage = response.error || 'Error desconocido del worker';
+                    pendingTask.reject(new Error(errorMessage));
+                }
+            }
+            catch (error) {
+                console.error('[WorkerManager] Error procesando respuesta del worker:', error);
+            }
+        });
+        this.worker.on('error', (error) => {
+            console.error('[WorkerManager] Error en worker thread:', error);
+            this.handleWorkerError(error);
+        });
+        this.worker.on('exit', (code) => {
+            console.warn('[WorkerManager] Worker thread cerrado con código:', code);
+            this.workerReady = false;
+            // Rechazar todas las tareas pendientes
+            this.pendingTasks.forEach(task => {
+                clearTimeout(task.timeout);
+                task.reject(new Error(`Worker cerrado inesperadamente con código ${code}`));
+            });
+            this.pendingTasks.clear();
+        });
+    } /**
+     * Espera a que el worker esté listo para recibir tareas
+     */
+    async waitForWorkerReady() {
+        return new Promise((resolve, reject) => {
+            // Reducir timeout para inicialización a 5 segundos
+            const timeout = setTimeout(() => {
+                reject(new Error('Timeout esperando a que el worker esté listo'));
+            }, 5000);
+            const checkReady = () => {
+                if (this.workerReady) {
+                    clearTimeout(timeout);
+                    resolve();
+                }
+                else {
+                    setTimeout(checkReady, 50); // Verificar cada 50ms (más frecuente)
+                }
+            };
+            checkReady();
+        });
+    }
+    /**
+     * Maneja errores del worker thread
+     */
+    handleWorkerError(error) {
+        console.error('[WorkerManager] Manejando error del worker:', error);
+        // Rechazar todas las tareas pendientes
+        this.pendingTasks.forEach(task => {
+            clearTimeout(task.timeout);
+            task.reject(new Error(`Error en worker: ${error.message}`));
+        });
+        this.pendingTasks.clear();
+        // Marcar worker como no disponible
+        this.workerReady = false;
+    }
+    /**
+     * Genera un ID único para cada tarea
+     */
+    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) {
+        // 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 {
+            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'));
+                }, this.TASK_TIMEOUT); // Usar timeout por tarea más realista
+            });
+            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);
+            // Fallback a validación síncrona
+            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+        }
+    }
+    /**
+     * Realiza type checking usando el worker thread
+     */
+    async typeCheckWithWorker(fileName, content, compilerOptions) {
+        // Asegurar que el worker esté inicializado
+        await this.initializeWorker();
+        if (!this.worker || !this.workerReady) {
+            throw new Error('Worker no disponible');
+        }
+        return new Promise((resolve, reject) => {
+            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.TASK_TIMEOUT);
+            // Agregar tarea a la lista de pendientes
+            this.pendingTasks.set(taskId, {
+                resolve,
+                reject,
+                timeout,
+            });
+            try {
+                // Crear mensaje para el worker
+                const message = {
+                    id: taskId,
+                    fileName,
+                    content,
+                    compilerOptions,
+                };
+                // console.log('[WorkerManager] Enviando tarea al worker:', {
+                //     id: taskId,
+                //     fileName,
+                //     contentLength: content.length,
+                //     compilerOptionsKeys: Object.keys(compilerOptions),
+                // });
+                // Enviar mensaje al worker
+                this.worker.postMessage(message);
+            }
+            catch (error) {
+                // Limpiar en caso de error
+                clearTimeout(timeout);
+                this.pendingTasks.delete(taskId);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Fallback síncrono para type checking cuando el worker no está disponible
+     */
+    typeCheckWithSyncFallback(fileName, content, compilerOptions) {
+        // console.log(
+        //     '[WorkerManager] Ejecutando type checking síncrono como fallback',
+        // );
+        try {
+            return validateTypesWithLanguageService(fileName, content, compilerOptions);
+        }
+        catch (error) {
+            console.error('[WorkerManager] Error en fallback síncrono:', error);
+            // Devolver resultado vacío en caso de error total
+            return {
+                diagnostics: [],
+                hasErrors: false,
+            };
+        }
+    }
+    /**
+     * Cierra el worker thread y limpia recursos
+     */
+    async terminate() {
+        if (this.worker) {
+            // console.log('[WorkerManager] Cerrando worker thread...');
+            // Rechazar todas las tareas pendientes
+            this.pendingTasks.forEach(task => {
+                clearTimeout(task.timeout);
+                task.reject(new Error('Worker manager cerrado'));
+            });
+            this.pendingTasks.clear();
+            // Cerrar worker
+            await this.worker.terminate();
+            this.worker = null;
+            this.workerReady = false;
+            this.initPromise = null;
+            // console.log('[WorkerManager] Worker cerrado exitosamente');
+        }
+    }
+    /**
+     * Obtiene estadísticas del worker manager
+     */
+    getStats() {
+        return {
+            workerReady: this.workerReady,
+            pendingTasks: this.pendingTasks.size,
+            taskCounter: this.taskCounter,
+        };
+    }
+}
+//# sourceMappingURL=typescript-worker.js.map