versacompiler 2.0.7 → 2.0.8

package/dist/compiler/typescript-worker.js

@@ -1,339 +1 @@
-/**
- * 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
+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}}}