versacompiler 2.4.1 → 2.6.0

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

@@ -0,0 +1,108 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { Worker } from 'node:worker_threads';
+export class CompileWorkerPool {
+    static instance;
+    workers = [];
+    pending = new Map();
+    queue = [];
+    poolSize;
+    workerPath;
+    TASK_TIMEOUT = 60000;
+    constructor() {
+        const cpuCount = os.cpus().length;
+        const configuredMax = parseInt(process.env.COMPILE_MAX_WORKERS || '2', 10);
+        this.poolSize = Math.min(configuredMax, Math.max(1, cpuCount - 1));
+        this.workerPath = path.join(process.env.PATH_PROY || path.join(process.cwd(), 'src'), 'compiler', 'compile-worker-thread.cjs');
+        this.initWorkers();
+    }
+    static getInstance() {
+        if (!CompileWorkerPool.instance) {
+            CompileWorkerPool.instance = new CompileWorkerPool();
+        }
+        return CompileWorkerPool.instance;
+    }
+    initWorkers() {
+        for (let i = 0; i < this.poolSize; i++) {
+            const worker = new Worker(this.workerPath, {
+                env: process.env,
+            });
+            const poolWorker = { worker, busy: false };
+            worker.on('message', (response) => {
+                const pending = this.pending.get(response.id);
+                if (!pending)
+                    return;
+                clearTimeout(pending.timeout);
+                this.pending.delete(response.id);
+                poolWorker.busy = false;
+                if (!response.success) {
+                    pending.reject(new Error(response.error || 'Worker task failed'));
+                }
+                else {
+                    pending.resolve(response.data);
+                }
+                this.drainQueue();
+            });
+            worker.on('error', error => {
+                poolWorker.busy = false;
+                for (const [id, pending] of this.pending) {
+                    clearTimeout(pending.timeout);
+                    const normalized = error instanceof Error
+                        ? error
+                        : new Error(String(error));
+                    pending.reject(normalized);
+                    this.pending.delete(id);
+                }
+                this.drainQueue();
+            });
+            this.workers.push(poolWorker);
+        }
+    }
+    async runTask(type, payload) {
+        const id = `${type}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        const message = { id, type, payload };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Worker timeout: ${type}`));
+            }, this.TASK_TIMEOUT);
+            this.pending.set(id, { resolve, reject, timeout });
+            const worker = this.getAvailableWorker();
+            if (worker) {
+                worker.busy = true;
+                worker.worker.postMessage(message);
+                return;
+            }
+            this.queue.push(message);
+        });
+    }
+    getAvailableWorker() {
+        return this.workers.find(worker => !worker.busy) || null;
+    }
+    drainQueue() {
+        if (this.queue.length === 0)
+            return;
+        const worker = this.getAvailableWorker();
+        if (!worker)
+            return;
+        const message = this.queue.shift();
+        if (!message)
+            return;
+        worker.busy = true;
+        worker.worker.postMessage(message);
+    }
+}
+//# sourceMappingURL=compile-worker-pool.js.map

package/dist/compiler/compile-worker-thread.cjs

@@ -0,0 +1,72 @@
+const { parentPort } = require('node:worker_threads');
+
+let preCompileVue;
+let preCompileTS;
+let minifyJS;
+
+async function loadVue() {
+    if (!preCompileVue) {
+        const mod = await import('./vuejs.js');
+        preCompileVue = mod.preCompileVue;
+    }
+    return preCompileVue;
+}
+
+async function loadTypeScript() {
+    if (!preCompileTS) {
+        const mod = await import('./typescript-manager.js');
+        preCompileTS = mod.preCompileTS;
+    }
+    return preCompileTS;
+}
+
+async function loadMinify() {
+    if (!minifyJS) {
+        const mod = await import('./minify.js');
+        minifyJS = mod.minifyJS;
+    }
+    return minifyJS;
+}
+
+parentPort.on('message', async message => {
+    const { id, type, payload } = message;
+    try {
+        if (type === 'vue') {
+            const compileVue = await loadVue();
+            const result = await compileVue(
+                payload.source,
+                payload.fileName,
+                payload.isProd === true,
+            );
+            parentPort.postMessage({ id, success: true, data: result });
+            return;
+        }
+        if (type === 'ts') {
+            const compileTS = await loadTypeScript();
+            const result = await compileTS(
+                payload.source,
+                payload.fileName,
+                payload.scriptInfo,
+            );
+            parentPort.postMessage({ id, success: true, data: result });
+            return;
+        }
+        if (type === 'minify') {
+            const minify = await loadMinify();
+            const result = await minify(payload.source, payload.fileName, true);
+            parentPort.postMessage({ id, success: true, data: result });
+            return;
+        }
+        parentPort.postMessage({
+            id,
+            success: false,
+            error: `Tipo de tarea desconocido: ${type}`,
+        });
+    } catch (error) {
+        parentPort.postMessage({
+            id,
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+});

package/dist/compiler/compile.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 import { createHash } from 'node:crypto';
 import { glob, mkdir, readFile, stat, unlink, writeFile, } from 'node:fs/promises';
 import * as os from 'node:os';
@@ -6,9 +18,12 @@ import * as process from 'node:process';
 const { argv, cwd, env } = process;
 // Lazy loading optimizations - Only import lightweight modules synchronously
 import { logger, setProgressManagerGetter } from '../servicios/logger.js';
+import { getLoadedConfig } from '../servicios/readConfig.js';
 import { promptUser } from '../utils/promptUser.js';
 import { showTimingForHumans } from '../utils/utils.js';
 import { integrityValidator } from './integrity-validator.js';
+import { BuildPipeline } from './pipeline/build-pipeline.js';
+import { createCorePlugins } from './pipeline/core-plugins.js';
 // Configurar el getter del ProgressManager para el logger
 setProgressManagerGetter(() => ProgressManager.getInstance());
 /**
@@ -29,6 +44,7 @@ let generateTailwindCSS;
 let estandarizaCode;
 let preCompileTS;
 let preCompileVue;
+let pipelineInstance = null;
 // 🚀 Importar optimizador de transformaciones
 let TransformOptimizer;
 // 🚀 Importar optimizador de resolución de módulos
@@ -70,18 +86,22 @@ class OptimizedModuleManager {
     }
     /**
      * ✨ NUEVO: Precarga módulos críticos en background
+     * Cada módulo se precarga de forma independiente con su propio try-catch
+     * para que un fallo individual no rechace toda la Promise raíz.
      */
     async preloadCriticalModules() {
-        try {
-            // Precargar módulos críticos de forma asíncrona
-            const preloadPromises = this.HOT_MODULES.map(moduleName => this.ensureModuleLoaded(moduleName).catch(() => {
-                // Silenciar errores de precarga, se intentará cargar después
-            }));
-            await Promise.allSettled(preloadPromises);
-        }
-        catch {
-            // Fallos en precarga no deben afectar la funcionalidad principal
-        }
+        const preloadPromises = this.HOT_MODULES.map(async (moduleName) => {
+            try {
+                await this.ensureModuleLoaded(moduleName);
+            }
+            catch {
+                // Fallo individual no debe afectar otros módulos ni la Promise raíz
+                if (env.VERBOSE === 'true') {
+                    console.warn(`[ModuleManager] Precarga fallida para '${moduleName}', se intentará al primer uso`);
+                }
+            }
+        });
+        await Promise.all(preloadPromises);
     }
     /**
      * ✨ MEJORADO: Precarga contextual basada en tipos de archivo con lock para prevenir cargas concurrentes
@@ -348,21 +368,25 @@ class OptimizedModuleManager {
         if (currentMemory > this.MAX_POOL_MEMORY ||
             currentSize > this.MAX_POOL_SIZE) {
             // LRU: Ordenar por menos usado
-            const sortedModules = Array.from(this.usageStats.entries())
-                .sort((a, b) => a[1] - b[1]) // Ascendente por uso
-                .filter(([name]) => !this.HOT_MODULES.includes(name)); // No eliminar HOT_MODULES
+            const sortedModules = Array.from(this.usageStats.entries()).sort((a, b) => a[1] - b[1]); // Ascendente por uso
             // Eliminar módulos hasta estar por debajo del 70% del límite
             const targetMemory = this.MAX_POOL_MEMORY * 0.7;
             const targetSize = this.MAX_POOL_SIZE * 0.7;
+            const criticalPressure = currentMemory > this.MAX_POOL_MEMORY * 0.9;
             for (const [moduleName] of sortedModules) {
-                this.modulePool.delete(moduleName);
-                this.loadedModules.delete(moduleName);
-                this.usageStats.delete(moduleName);
                 const newMemory = this.getPoolMemoryUsage();
                 const newSize = this.modulePool.size;
                 if (newMemory <= targetMemory && newSize <= targetSize) {
                     break;
                 }
+                // HOT_MODULES solo se desalojan si la presión de memoria es crítica (>90%)
+                if (this.HOT_MODULES.includes(moduleName) &&
+                    !criticalPressure) {
+                    continue;
+                }
+                this.modulePool.delete(moduleName);
+                this.loadedModules.delete(moduleName);
+                this.usageStats.delete(moduleName);
             }
             if (env.VERBOSE === 'true') {
                 console.log(`[ModuleManager] Limpieza: ${currentSize} → ${this.modulePool.size} módulos, ` +
@@ -544,6 +568,16 @@ class SmartCompilationCache {
             catch {
                 // Ignorar si no existe package-lock.json
             }
+            // 2b. Hash de pnpm-lock.yaml si existe (pnpm)
+            try {
+                const pnpmLockPath = path.join(cwd(), 'pnpm-lock.yaml');
+                const pnpmLockContent = await readFile(pnpmLockPath, 'utf8');
+                hash.update(`pnpm-lock:${pnpmLockContent.length}`);
+                hash.update(pnpmLockContent);
+            }
+            catch {
+                // Ignorar si no existe pnpm-lock.yaml
+            }
             // 3. ✨ NUEVO: Hash de timestamps críticos de node_modules
             try {
                 const nodeModulesPath = path.join(cwd(), 'node_modules');
@@ -609,7 +643,7 @@ class SmartCompilationCache {
             return false;
         try {
             // Ejecutar todas las verificaciones independientes en paralelo
-            const [currentContentHash, currentDependencyHash, fileStat, _outputStat] = await Promise.all([
+            const [currentContentHash, currentDependencyHash, fileStat, _outputStat,] = await Promise.all([
                 this.generateContentHash(filePath),
                 this.generateDependencyHash(),
                 stat(filePath),
@@ -1406,7 +1440,8 @@ async function _displaySingleLinterError(error, filePath) {
                 }
                 else {
                     // Líneas de contexto
-                    logger.info(chalkLib.blue(` ${prefix} │ `) + chalkLib.gray(currentLine));
+                    logger.info(chalkLib.blue(` ${prefix} │ `) +
+                        chalkLib.gray(currentLine));
                 }
             }
             logger.info(chalkLib.blue('    ╰────'));
@@ -1558,6 +1593,124 @@ class WatchModeOptimizer {
         this.fileSystemCache.clear();
     }
 }
+function getBuildPipeline() {
+    if (!pipelineInstance) {
+        const basePlugins = createCorePlugins();
+        const config = getLoadedConfig();
+        const userPlugins = normalizeUserPlugins(config?.plugins);
+        pipelineInstance = new BuildPipeline([...basePlugins, ...userPlugins]);
+    }
+    return pipelineInstance;
+}
+function normalizeUserPlugins(plugins) {
+    if (!plugins || !Array.isArray(plugins))
+        return [];
+    return plugins.filter((plugin) => {
+        if (!plugin || typeof plugin !== 'object')
+            return false;
+        const candidate = plugin;
+        if (!candidate.name || typeof candidate.name !== 'string')
+            return false;
+        return Boolean(candidate.onResolve ||
+            candidate.onLoad ||
+            candidate.onTransform ||
+            candidate.onHotUpdate ||
+            candidate.onEnd);
+    });
+}
+export function getPipelineModuleGraph() {
+    if (env.PIPELINE_V2 === 'false')
+        return null;
+    return getBuildPipeline().getModuleGraph();
+}
+export async function runPipelineHotUpdate(filePath, type) {
+    if (env.PIPELINE_V2 === 'false') {
+        return { reload: 'none' };
+    }
+    return getBuildPipeline().hotUpdate({ path: filePath, type });
+}
+/**
+ * Extrae los imports locales (rutas absolutas con /) del código compilado.
+ * Solo imports estáticos de rutas absolutas del proyecto (excluye /node_modules/).
+ */
+function extractLocalImports(code) {
+    const imports = [];
+    const importRegex = /(?:from|import)\s+['"](\/((?!node_modules)[^'"?#]+\.js))['"]/g;
+    let match;
+    while ((match = importRegex.exec(code)) !== null) {
+        const importPath = match[1];
+        if (importPath && !imports.includes(importPath)) {
+            imports.push(importPath);
+        }
+    }
+    return imports;
+}
+/**
+ * Inyecta el shim de import.meta.hot al inicio de archivos JS compilados en modo dev.
+ * Adicionalmente registra accept() para cada dependencia local: cuando una dependencia
+ * se actualiza en versaHMR, el módulo actual se re-importa con timestamp nuevo,
+ * forzando al browser a crear un nuevo module record con la dependencia actualizada.
+ * Solo se llama cuando env.isPROD !== 'true' y la salida es un archivo .js.
+ */
+function injectHmrShim(code) {
+    const localImports = extractLocalImports(code);
+    // Detecta si es un Vue SFC (el compilador Vue inyecta 'data-versa-hmr-component')
+    const isVueComponent = code.includes('data-versa-hmr-component');
+    const depsAccept = localImports.length > 0
+        ? localImports
+            .map(dep => {
+            if (isVueComponent) {
+                // Vue SFC: tras actualizar dependencia, re-cargar instancia Vue en DOM
+                return `    window.__versaHMR.accept(${JSON.stringify(dep)}, async () => { await window.__versaHMR._reloadVueByPath?.(_id); });`;
+            }
+            // Módulo JS/TS plano: re-importar con nuevo timestamp para actualizar module record
+            return `    window.__versaHMR.accept(${JSON.stringify(dep)}, () => { import(_id + '?t=' + Date.now()); });`;
+        })
+            .join('\n') + '\n'
+        : '';
+    const shim = `/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+${depsAccept}  })();
+}\n`;
+    return shim + code;
+}
+async function compileWithPipeline(inPath, outPath, mode = 'individual') {
+    const pipeline = getBuildPipeline();
+    const result = await pipeline.compileFile(inPath);
+    if (result.errors.length > 0) {
+        for (const message of result.errors) {
+            await handleCompilationError(new Error(message), inPath, 'pipeline', mode, env.VERBOSE === 'true');
+        }
+        throw new Error(result.errors[0]);
+    }
+    if (!result.code || result.code.trim().length === 0) {
+        await handleCompilationError(new Error('El código compilado está vacío.'), inPath, 'pipeline', mode, env.VERBOSE === 'true');
+        throw new Error('El código compilado está vacío.');
+    }
+    const destinationDir = path.dirname(outPath);
+    await mkdir(destinationDir, { recursive: true });
+    let pipelineCode = result.code;
+    if (env.isPROD !== 'true' && outPath.endsWith('.js')) {
+        pipelineCode = injectHmrShim(pipelineCode);
+    }
+    await writeFile(outPath, pipelineCode, 'utf-8');
+    if (result.dependencies.length > 0) {
+        smartCache.registerDependencies(inPath, result.dependencies);
+    }
+    registerCompilationSuccess(inPath, 'pipeline');
+    return {
+        error: null,
+        action: 'extension',
+    };
+}
 async function compileJS(inPath, outPath, mode = 'individual') {
     const timings = {};
     // Si la ruta ya es absoluta, no la resolvamos de nuevo
@@ -1565,6 +1718,9 @@ async function compileJS(inPath, outPath, mode = 'individual') {
         ? normalizeRuta(inPath)
         : normalizeRuta(path.resolve(inPath)); // 🚀 Usar OptimizedModuleManager para carga optimizada
     const moduleManager = OptimizedModuleManager.getInstance();
+    if (env.PIPELINE_V2 !== 'false') {
+        return compileWithPipeline(inPath, outPath, mode);
+    }
     // Timing de lectura
     let start = Date.now();
     const extension = path.extname(inPath); // Asegurar que el parser esté cargado
@@ -1724,6 +1880,9 @@ async function compileJS(inPath, outPath, mode = 'individual') {
     } // Escribir archivo final
     const destinationDir = path.dirname(outPath);
     await mkdir(destinationDir, { recursive: true });
+    if (env.isPROD !== 'true' && outPath.endsWith('.js')) {
+        code = injectHmrShim(code);
+    }
     await writeFile(outPath, code, 'utf-8');
     // Logs de timing detallados en modo verbose
     if (shouldShowDetailedLogs) {

package/dist/compiler/error-reporter.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 // Lazy loading optimizations - Only import lightweight modules synchronously
 // Heavy dependencies will be loaded dynamically when needed
 let chalk;

package/dist/compiler/integrity-validator.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 import { parseSync } from 'oxc-parser';
 import { logger } from '../servicios/logger.js';
 /**
@@ -48,7 +60,7 @@ export class IntegrityValidator {
         // Revisar cache
         const cacheKey = this.getCacheKey(context, processed);
         const cached = this.cache.get(cacheKey);
-        if (cached && (Date.now() - cached.timestamp) < this.CACHE_TTL) {
+        if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
             this.stats.cacheHits++;
             if (options.verbose) {
                 logger.info(`[IntegrityValidator] Cache hit for ${context}`);

package/dist/compiler/linter.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 import { env } from 'node:process';
 import { logger } from '../servicios/logger.js';
 import { ESLintNode, } from './../wrappers/eslint-node.js';

package/dist/compiler/minify.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 import { createHash } from 'node:crypto';
 import { minifySync } from 'oxc-minify';
 import { logger } from '../servicios/logger.js';

package/dist/compiler/minifyTemplate.js

@@ -1,3 +1,15 @@
+/* VersaCompiler HMR shim [dev] */
+if (typeof window !== 'undefined' && window.__versaHMR) {
+  (() => {
+    const _id = new URL(import.meta.url).pathname;
+    import.meta.hot = {
+      accept(cb) { window.__versaHMR.accept(_id, typeof cb === 'function' ? cb : () => {}); },
+      invalidate() { window.__versaHMR._invalidate?.(_id); },
+      dispose(cb) { window.__versaHMR._onDispose?.(_id, cb); },
+      get data() { return window.__versaHMR._getHotData?.(_id) ?? {}; },
+    };
+  })();
+}
 import { minifyHTMLLiterals } from 'minify-html-literals';
 import { logger } from '../servicios/logger.js';
 import { integrityValidator } from './integrity-validator.js';