versacompiler 2.0.0 → 2.0.2

package/dist/servicios/file-watcher.js

@@ -0,0 +1,367 @@
+import { readdir, rm, stat, unlink } from 'node:fs/promises';
+import path from 'node:path';
+import process, { env } from 'node:process';
+import * as chokidar from 'chokidar';
+import { minimatch } from 'minimatch';
+import { getOutputPath, initCompile, normalizeRuta } from '../compiler/compile.js';
+import { promptUser } from '../utils/promptUser.js';
+import { emitirCambios } from './browserSync.js';
+import { logger } from './logger.js';
+// Lazy loading para chalk
+let chalk;
+async function loadChalk() {
+    if (!chalk) {
+        chalk = (await import('chalk')).default;
+    }
+    return chalk;
+}
+class WatchDebouncer {
+    pendingChanges = new Map();
+    debounceTimer = null;
+    DEBOUNCE_DELAY = 300; // 300ms debounce
+    BATCH_SIZE = 10; // Máximo archivos por batch
+    isProcessing = false;
+    browserSyncInstance = null; // ✨ Almacenar referencia a browserSync
+    /**
+     * Establece la instancia de browserSync
+     */
+    setBrowserSyncInstance(bs) {
+        this.browserSyncInstance = bs;
+    }
+    /**
+     * Añade un cambio al sistema de debouncing
+     */
+    addChange(filePath, action, extensionAction, isAdditionalFile = false) {
+        // Normalizar ruta para evitar duplicados
+        const normalizedPath = normalizeRuta(filePath);
+        // Agregar o actualizar el cambio pendiente
+        this.pendingChanges.set(normalizedPath, {
+            filePath: normalizedPath,
+            action,
+            timestamp: Date.now(),
+            extensionAction,
+            isAdditionalFile,
+        });
+        // Reiniciar el timer de debounce
+        this.resetDebounceTimer();
+    }
+    /**
+     * Reinicia el timer de debounce
+     */
+    resetDebounceTimer() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            this.processPendingChanges();
+        }, this.DEBOUNCE_DELAY);
+    }
+    /**
+     * Procesa todos los cambios pendientes en batch
+     */
+    async processPendingChanges() {
+        if (this.isProcessing || this.pendingChanges.size === 0) {
+            return;
+        }
+        this.isProcessing = true;
+        const changes = Array.from(this.pendingChanges.values());
+        this.pendingChanges.clear();
+        try {
+            // Agrupar por tipo de acción para optimización
+            const deleteChanges = changes.filter(c => c.action === 'unlink');
+            const compileChanges = changes.filter(c => c.action === 'add' || c.action === 'change');
+            // Procesar eliminaciones primero
+            if (deleteChanges.length > 0) {
+                await this.processDeleteChanges(deleteChanges);
+            }
+            // Procesar compilaciones en batches
+            if (compileChanges.length > 0) {
+                await this.processCompileChanges(compileChanges);
+            }
+        }
+        catch (error) {
+            const chalkInstance = await loadChalk();
+            logger.error(chalkInstance.red(`🚩 Error procesando cambios en batch: ${error instanceof Error ? error.message : String(error)}`));
+        }
+        finally {
+            this.isProcessing = false;
+            // Si hay más cambios pendientes, procesarlos
+            if (this.pendingChanges.size > 0) {
+                this.resetDebounceTimer();
+            }
+        }
+    } /**
+     * Procesa cambios de eliminación
+     */
+    async processDeleteChanges(deleteChanges) {
+        for (const change of deleteChanges) {
+            if (change.isAdditionalFile) {
+                // ✨ Archivos adicionales: solo reload, sin eliminar del output
+                logger.info(`\n🗑️ Archivo adicional eliminado: ${change.filePath}`);
+                emitirCambios(this.browserSyncInstance, 'reloadFull', change.filePath);
+            }
+            else {
+                // Archivos compilables: eliminar del output
+                logger.info(`\n🗑️ Eliminando archivo compilado: ${change.filePath}`);
+                const result = await deleteFile(getOutputPath(change.filePath));
+                if (result) {
+                    logger.info(`Archivo eliminado: ${change.filePath}`);
+                    emitirCambios(this.browserSyncInstance, 'reloadFull', change.filePath);
+                }
+            }
+        }
+    }
+    /**
+     * Procesa cambios de compilación en paralelo con límite de concurrencia
+     */
+    async processCompileChanges(compileChanges) {
+        // ✨ NUEVO: Separar archivos adicionales de archivos compilables
+        const additionalFiles = compileChanges.filter(c => c.isAdditionalFile);
+        const compilableFiles = compileChanges.filter(c => !c.isAdditionalFile);
+        // ✨ Procesar archivos adicionales (solo reload, sin compilación)
+        if (additionalFiles.length > 0) {
+            await this.processAdditionalFiles(additionalFiles);
+        }
+        // Procesar archivos compilables normalmente
+        if (compilableFiles.length > 0) {
+            await this.processCompilableFiles(compilableFiles);
+        }
+    }
+    /**
+     * ✨ RENOMBRADO: Procesa archivos compilables
+     */
+    async processCompilableFiles(compilableFiles) {
+        const chalkInstance = await loadChalk();
+        // Procesar en batches para evitar sobrecarga
+        for (let i = 0; i < compilableFiles.length; i += this.BATCH_SIZE) {
+            const batch = compilableFiles.slice(i, i + this.BATCH_SIZE);
+            if (batch.length > 1) {
+                logger.info(chalkInstance.cyan(`📦 Procesando batch de ${batch.length} archivos compilables (${i + 1}-${Math.min(i + this.BATCH_SIZE, compilableFiles.length)} de ${compilableFiles.length})`));
+            }
+            const promises = batch.map(change => this.compileFile(change));
+            await Promise.allSettled(promises);
+        }
+        if (compilableFiles.length > 1) {
+            logger.info(chalkInstance.green(`✅ Batch completado: ${compilableFiles.length} archivos compilados`));
+        }
+    }
+    /**
+     * ✨ NUEVO: Procesa archivos adicionales (solo reloadFull)
+     */
+    async processAdditionalFiles(additionalFiles) {
+        const chalkInstance = await loadChalk();
+        logger.info(chalkInstance.blue(`🔄 Recargando ${additionalFiles.length} archivo(s) adicional(es) (sin compilación)`));
+        for (const change of additionalFiles) {
+            logger.info(`📄 Archivo adicional modificado: ${change.filePath}`);
+            // Solo hacer reloadFull, sin compilación
+            emitirCambios(this.browserSyncInstance, 'reloadFull', change.filePath);
+        }
+    }
+    /**
+     * Compila un archivo individual
+     */
+    async compileFile(change) {
+        try {
+            const result = await initCompile(change.filePath, true, 'watch');
+            if (result.success) {
+                let accion = result.action || change.extensionAction;
+                accion =
+                    accion === 'extension' ? change.extensionAction : accion;
+                emitirCambios(this.browserSyncInstance, accion || 'reloadFull', result.output);
+            }
+        }
+        catch (error) {
+            const chalkInstance = await loadChalk();
+            logger.error(chalkInstance.red(`🚩 Error compilando ${change.filePath}: ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
+    /**
+     * Obtiene estadísticas del debouncer
+     */
+    getStats() {
+        return {
+            pendingChanges: this.pendingChanges.size,
+            isProcessing: this.isProcessing,
+            hasTimer: this.debounceTimer !== null,
+        };
+    }
+}
+// Instancia global del debouncer
+const watchDebouncer = new WatchDebouncer();
+// const cacheImportMap = new Map<string, string[]>();
+// const cacheComponentMap = new Map<string, string[]>();
+export async function cleanOutputDir(outputDir, primerInteraccion = true) {
+    try {
+        if (!outputDir) {
+            throw new Error('El directorio de salida no está definido');
+        }
+        if (primerInteraccion) {
+            const stats = await stat(outputDir).catch(() => null);
+            if (!stats || !stats.isDirectory()) {
+                logger.error(`🚩 El directorio de salida no existe o no es un directorio: ${outputDir}`);
+                return;
+            }
+            try {
+                if (env.yes === 'false') {
+                    const chalkInstance = await loadChalk();
+                    const answer = await promptUser('\n\n¿Estás seguro deseas limpiar la carpeta ' +
+                        chalkInstance.yellow(outputDir) +
+                        '? (s / N) : ');
+                    if (answer.toLowerCase() !== 's') {
+                        logger.info('🛑 Compilación cancelada por el usuario.');
+                        process.exit(0);
+                    }
+                }
+            }
+            catch (error) {
+                logger.error(`Error en la entrada del usuario: ${error}`);
+                process.exit(1);
+            }
+        }
+        const chalkInstance = await loadChalk();
+        logger.info(`🗑️ Limpiando directorio de salida: ${chalkInstance.yellow(outputDir)}\n`);
+        const items = await readdir(outputDir);
+        await Promise.all(items.map(async (item) => {
+            const itemPath = path.join(outputDir, item);
+            const itemStat = await stat(itemPath);
+            if (itemStat.isDirectory()) {
+                await rm(itemPath, { recursive: true });
+            }
+            else {
+                await unlink(itemPath);
+            }
+        }));
+        logger.info(`✅ Directorio limpiado: ${outputDir}`);
+    }
+    catch (error) {
+        logger.error(`🚩 Error al limpiar directorio de salida: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function deleteFile(filePath) {
+    try {
+        await unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        logger.error(`🚩 Error eliminando archivo ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+function getAction(ruta, extendsionWatch) {
+    const action = extendsionWatch
+        .filter((item) => item !== undefined)
+        .find(item => item.ext === ruta.split('.').pop())?.action;
+    return action || 'reloadFull';
+}
+/**
+ * Verifica si un archivo pertenece a las rutas adicionales (no compilables)
+ */
+function isAdditionalWatchFile(filePath, additionalPatterns) {
+    if (!additionalPatterns || additionalPatterns.length === 0) {
+        return false;
+    }
+    const normalizedPath = normalizeRuta(filePath);
+    return additionalPatterns.some(pattern => {
+        // Normalizar el patrón también
+        const normalizedPattern = pattern.replace(/\\/g, '/');
+        return minimatch(normalizedPath, normalizedPattern);
+    });
+}
+export async function initChokidar(bs) {
+    try {
+        if (!env.PATH_SOURCE) {
+            logger.error('Error: La variable de entorno PATH_SOURCE no está definida.');
+            process.exit(1);
+        }
+        const watchJS = `${env.PATH_SOURCE}/**/*.js`;
+        const watchVue = `${env.PATH_SOURCE}/**/*.vue`;
+        const watchTS = `${env.PATH_SOURCE}/**/*.ts`;
+        const watchCJS = `${env.PATH_SOURCE}/**/*.cjs`;
+        const watchMJS = `${env.PATH_SOURCE}/**/*.mjs`;
+        //TODO: agregar watch para CSS
+        const watchAditional = JSON.parse(env.aditionalWatch || '[]');
+        let fileWatch = [
+            watchJS,
+            watchVue,
+            watchTS,
+            watchCJS,
+            watchMJS,
+            ...watchAditional,
+        ];
+        //extraer sólo las extesniones  de fileWatch
+        const accionExtension = {
+            vue: 'HRMVue',
+            js: 'HRMHelper',
+            ts: 'HRMHelper',
+            cjs: 'HRMHelper',
+            mjs: 'HRMHelper',
+        };
+        const extendsionWatch = fileWatch.map(item => {
+            const ext = item.split('.').pop();
+            if (ext) {
+                return {
+                    ext,
+                    action: accionExtension[ext] ||
+                        'reloadFull',
+                };
+            }
+        });
+        if (extendsionWatch.length === 0 || extendsionWatch[0] === undefined) {
+            throw new Error('No se encontraron extensiones para observar');
+        }
+        const regExtExtension = new RegExp(`\\.(?!${extendsionWatch
+            .filter(item => item !== undefined)
+            .map(item => item.ext)
+            .join('$|')}$).+$`);
+        fileWatch = fileWatch.map(item => item.replace(/\/\*\*\//g, '/'));
+        const directories = new Map();
+        fileWatch.forEach(item => {
+            const dir = item.substring(0, item.lastIndexOf('/'));
+            if (!directories.has(dir)) {
+                directories.set(dir, []);
+            }
+            directories.get(dir).push(item);
+        });
+        const DirWatch = Array.from(directories.keys());
+        const watcher = chokidar.watch(DirWatch, {
+            persistent: true,
+            ignoreInitial: true,
+            ignored: regExtExtension,
+        });
+        watcher.on('ready', async () => {
+            const chalkInstance = await loadChalk();
+            logger.info(chalkInstance.green(`👀 : Listo para observar \n${fileWatch
+                .map((item) => `${item}`)
+                .join('\n')}\n`));
+        });
+        // ✨ CONFIGURAR: Establecer la instancia de browserSync en el debouncer
+        watchDebouncer.setBrowserSyncInstance(bs);
+        // ✨ OPTIMIZADO: Evento cuando se añade un archivo - Con debouncing
+        watcher.on('add', async (ruta) => {
+            const isAdditional = isAdditionalWatchFile(ruta, watchAditional);
+            const action = getAction(ruta, extendsionWatch.filter((item) => item !== undefined));
+            // Usar sistema de debouncing en lugar de compilación inmediata
+            watchDebouncer.addChange(ruta, 'add', action, isAdditional);
+        });
+        // ✨ OPTIMIZADO: Evento cuando se modifica un archivo - Con debouncing
+        watcher.on('change', async (ruta) => {
+            const isAdditional = isAdditionalWatchFile(ruta, watchAditional);
+            const action = getAction(ruta, extendsionWatch.filter((item) => item !== undefined));
+            // Usar sistema de debouncing en lugar de compilación inmediata
+            watchDebouncer.addChange(ruta, 'change', action, isAdditional);
+        });
+        // ✨ OPTIMIZADO: Evento cuando se elimina un archivo - Con debouncing
+        watcher.on('unlink', async (ruta) => {
+            const action = getAction(ruta, extendsionWatch.filter((item) => item !== undefined));
+            const isAdditional = isAdditionalWatchFile(ruta, watchAditional);
+            // Usar sistema de debouncing para eliminaciones también
+            watchDebouncer.addChange(ruta, 'unlink', action, isAdditional);
+        });
+        return watcher;
+    }
+    catch (error) {
+        logger.error(`🚩 :Error al iniciar watch: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=file-watcher.js.map

package/dist/servicios/logger.js

@@ -1,3 +1,4 @@
+import * as process from 'node:process';
 class Logger {
     constructor() {
         // Bind console methods

package/dist/servicios/readConfig.js

@@ -1,4 +1,5 @@
 import { normalize, relative, resolve } from 'node:path';
+import * as process from 'node:process';
 import { env } from 'node:process';
 import { pathToFileURL } from 'node:url';
 import { logger } from './logger.js';

package/dist/utils/excluded-modules.js

@@ -0,0 +1,36 @@
+/**
+ * Lista centralizada de módulos excluidos de la resolución automática
+ * Estos módulos se mantienen con su importación original sin transformar
+ */
+export const EXCLUDED_MODULES = new Set([
+    // Módulos de Vue.js que requieren resolución específica
+    'vue/compiler-sfc',
+    'vue/dist/vue.runtime.esm-bundler',
+    '@vue/compiler-sfc',
+    '@vue/compiler-dom',
+    '@vue/runtime-core',
+    '@vue/runtime-dom',
+    // Módulos de oxc-parser que tienen dependencias específicas de WASM
+    'oxc-parser',
+    'oxc-parser/wasm',
+    'oxc-minify',
+    'oxc-minify/browser',
+    '@oxc-parser/binding-wasm32-wasi',
+    '@oxc-minify/binding-wasm32-wasi',
+    // Módulos de TypeScript que pueden tener resoluciones complejas
+    'typescript',
+    'typescript/lib/typescript',
+    // Módulos de herramientas de build y utilidades que deben mantenerse originales
+    'yargs',
+    'yargs/helpers',
+    'yargs-parser',
+    'chalk',
+    'browser-sync',
+    'chokidar',
+    'get-port',
+    'execa',
+    'find-root',
+    'fs-extra',
+    'minimatch', // ✅ Incluir minimatch aquí
+]);
+//# sourceMappingURL=excluded-modules.js.map

package/dist/utils/module-resolver.js

@@ -1,39 +1,11 @@
 // Opción con librería '/node_modules/resolve/index.js' (npm install resolve)
 import fs, { readFileSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
-import { env } from 'node:process';
-// import pkg from '/node_modules/enhanced-resolve/index.cjs';
+import { cwd, env } from 'node:process';
+// import pkg from '/node_modules/enhanced-resolve/lib/index.js';
 // import resolve from '/node_modules/resolve/index.js';
 import { logger } from '../servicios/logger.js';
-// Lista de módulos que deben ser excluidos de la resolución automática de rutas
-// Estos módulos se mantienen con su importación original sin transformar
-const EXCLUDED_MODULES = new Set([
-    'vue/compiler-sfc',
-    'vue/dist/vue.runtime.esm-bundler',
-    '@vue/compiler-sfc',
-    '@vue/compiler-dom',
-    '@vue/runtime-core',
-    '@vue/runtime-dom', // Módulos de oxc-parser que tienen dependencias específicas de WASM
-    'oxc-parser',
-    'oxc-parser/wasm',
-    'oxc-minify',
-    'oxc-minify/browser',
-    '@oxc-parser/binding-wasm32-wasi',
-    '@oxc-minify/binding-wasm32-wasi',
-    // Módulos de TypeScript que pueden tener resoluciones complejas
-    'typescript',
-    // Agregar más módulos problemáticos aquí según sea necesario
-    'yargs',
-    'yargs/helpers',
-    'yargs-parser',
-    'chalk',
-    'browser-sync',
-    'chokidar',
-    'get-port',
-    'execa',
-    'find-root',
-    'fs-extra',
-]);
+import { EXCLUDED_MODULES } from './excluded-modules.js';
 // function resolveESMWithLibrary(moduleName: string): string | null {
 //     try {
 //         // Resolver el módulo
@@ -58,7 +30,7 @@ const EXCLUDED_MODULES = new Set([
 //         return null;
 //     }
 // }
-// Opción con '/node_modules/enhanced-resolve/index.cjs' (webpack's resolver)
+// Opción con '/node_modules/enhanced-resolve/lib/index.js' (webpack's resolver)
 // npm install enhanced-resolve
 // const { ResolverFactory } = pkg;
 // const resolver = ResolverFactory.createResolver({
@@ -128,9 +100,6 @@ function findOptimalESMVersion(moduleDir, entryPoint) {
         for (const pattern of priorityPatterns) {
             if (files.includes(pattern)) {
                 const optimizedPath = join(dir, pattern).replace(/\\/g, '/');
-                if (env.VERBOSE === 'true') {
-                    logger.info(`Versión optimizada encontrada: ${optimizedPath}`);
-                }
                 return optimizedPath;
             }
         } // Buscar archivos que contengan patrones ESM/browser dinámicamente
@@ -154,9 +123,6 @@ function findOptimalESMVersion(moduleDir, entryPoint) {
                     !file.toLowerCase().includes('.min.'));
                 if (devFiles.length > 0 && devFiles[0]) {
                     const optimizedPath = join(dir, devFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión ESM-Browser dev encontrada: ${optimizedPath}`);
-                    }
                     return optimizedPath;
                 }
                 const prodFiles = esmBrowserCombined.filter(file => file.toLowerCase().includes('.prod.'));
@@ -260,7 +226,7 @@ function findOptimalESMVersion(moduleDir, entryPoint) {
 // Función mejorada para detectar automáticamente entry points browser-compatible
 function simpleESMResolver(moduleName) {
     try {
-        const nodeModulesPath = join(process.cwd(), 'node_modules', moduleName);
+        const nodeModulesPath = join(cwd(), 'node_modules', moduleName);
         let packagePath;
         let packageJson;
         try {
@@ -370,7 +336,8 @@ function simpleESMResolver(moduleName) {
                     if (env.VERBOSE === 'true')
                         logger.info(`Módulo ${moduleName} usa imports privados:`, privateImports.map(m => m[1]));
                     // Si usa imports privados, asegurarnos de que estén disponibles
-                    for (const [, importPath] of privateImports) {
+                    for (const match of privateImports) {
+                        const [, importPath] = match;
                         if (!importMap.has(importPath)) {
                             if (env.VERBOSE === 'true')
                                 logger.warn(`Import privado no resuelto: ${importPath} en ${moduleName}`);
@@ -381,8 +348,6 @@ function simpleESMResolver(moduleName) {
         }
         // Verificar que el archivo existe
         if (!fs.existsSync(finalPath)) {
-            if (env.VERBOSE === 'true')
-                logger.warn(`⚠️ Archivo no existe: ${finalPath}, buscando alternativas...`);
             // Intentar alternativas comunes
             const alternatives = [
                 entryPoint,
@@ -422,7 +387,7 @@ function getNodeModulesRelativePath(fullPath, _fromFile) {
         return '/' + relativePath;
     }
     // Para rutas que no están en node_modules, convertir a ruta absoluta desde la raíz
-    let rel = relative(process.cwd(), fullPath).replace(/\\/g, '/');
+    let rel = relative(cwd(), fullPath).replace(/\\/g, '/');
     if (!rel)
         rel = '.';
     // Convertir a ruta absoluta desde la raíz
@@ -434,8 +399,6 @@ function getNodeModulesRelativePath(fullPath, _fromFile) {
 export function getModulePath(moduleName, fromFile) {
     // Verificar si el módulo está en la lista de excluidos
     if (EXCLUDED_MODULES.has(moduleName)) {
-        if (env.VERBOSE === 'true')
-            logger.info(`Módulo ${moduleName} está en la lista de excluidos, manteniendo importación original`);
         return null; // Retornar null para mantener la importación original
     }
     return getNodeModulesRelativePath(simpleESMResolver(moduleName), fromFile);
@@ -444,8 +407,6 @@ export function getModulePath(moduleName, fromFile) {
 export function getModuleSubPath(moduleName, fromFile) {
     // Verificar si el módulo está en la lista de excluidos
     if (EXCLUDED_MODULES.has(moduleName)) {
-        if (env.VERBOSE === 'true')
-            logger.info(`Módulo ${moduleName} está en la lista de excluidos, manteniendo importación original`);
         return null; // Retornar null para mantener la importación original
     } // Si contiene '/', es un subpath
     if (moduleName.includes('/')) {
@@ -456,7 +417,7 @@ export function getModuleSubPath(moduleName, fromFile) {
             return null;
         }
         try {
-            const nodeModulesPath = join(process.cwd(), 'node_modules', packageName);
+            const nodeModulesPath = join(cwd(), 'node_modules', packageName);
             const packagePath = join(nodeModulesPath, 'package.json');
             if (!fs.existsSync(packagePath)) {
                 return null;

package/dist/utils/promptUser.js

@@ -1,4 +1,4 @@
-import { stdin as input, stdout as output } from 'node:process';
+import process, { stdin as input, stdout as output } from 'node:process';
 import * as readline from 'node:readline/promises';
 import { logger } from '../servicios/logger.js';
 export async function promptUser(question, timeout = 30000) {

package/dist/utils/resolve-bin.js

@@ -1,19 +1,38 @@
-import { createRequire } from 'node:module';
-import path from 'node:path';
+import * as path from 'node:path';
+import * as process from 'node:process';
 import findRoot from 'find-root';
 import fs from 'fs-extra';
+// Función helper para resolver módulos sin createRequire
+function resolveModule(moduleName, paths) {
+    for (const searchPath of paths) {
+        try {
+            const nodeModulesPath = path.join(searchPath, 'node_modules', moduleName);
+            if (fs.existsSync(nodeModulesPath)) {
+                return nodeModulesPath;
+            }
+        }
+        catch {
+            // Continuar con el siguiente path
+        }
+    }
+    throw new Error(`Cannot resolve module ${moduleName} from paths: ${paths.join(', ')}`);
+}
 export function resolveBin(moduleName, { executable = moduleName, paths = [process.cwd()], } = {}) {
     let rootDir;
     try {
-        const customRequire = createRequire(__filename);
-        const resolved = customRequire.resolve(moduleName, { paths });
+        const resolved = resolveModule(moduleName, paths);
         rootDir = findRoot(resolved);
     }
-    catch (e) {
-        const modJson = require.resolve(`${moduleName}/package.json`, {
-            paths,
-        });
-        rootDir = path.dirname(modJson);
+    catch {
+        // Intentar resolver package.json directamente
+        const basePath = paths[0] || process.cwd();
+        const packagePath = path.join(basePath, 'node_modules', moduleName, 'package.json');
+        if (fs.existsSync(packagePath)) {
+            rootDir = path.dirname(packagePath);
+        }
+        else {
+            throw new Error(`Cannot resolve module ${moduleName}`);
+        }
     }
     const packageJsonPath = path.join(rootDir, 'package.json');
     const packageJson = fs.readJsonSync(packageJsonPath);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "versacompiler",
-    "version": "2.0.0",
+    "version": "2.0.2",
     "description": "Una herramienta para compilar y minificar archivos .vue, .js y .ts para proyectos de Vue 3 con soporte para TypeScript.",
     "main": "dist/main.js",
     "bin": {
@@ -19,7 +19,7 @@
         "dev": "tsx --watch src/main.ts --watch --verbose --tailwind",
         "compile": "tsx src/main.ts --all",
         "test": "jest --config jest.config.js",
-        "build": "tsx src/main.ts --all -t --clean -y",
+        "build": "tsx src/main.ts --all -t --cc --co -y --verbose",
         "lint": "oxlint --fix --config .oxlintrc.json",
         "lint:eslint": "eslint --ext .js,.ts,.vue src/ --fix",
         "perf": "scripts\\run-performance.bat",
@@ -52,6 +52,7 @@
         "find-root": "^1.1.0",
         "fs-extra": "^11.3.0",
         "get-port": "^7.1.0",
+        "minimatch": "^10.0.1",
         "oxc-minify": "^0.72.3",
         "oxc-parser": "^0.72.3",
         "oxc-transform": "^0.72.3",
@@ -69,7 +70,7 @@
         "@types/fs-extra": "^11.0.4",
         "@types/jest": "^29.5.14",
         "@types/mocha": "^10.0.10",
-        "@types/node": "^22.15.30",
+        "@types/node": "^24.0.0",
         "@types/resolve": "^1.20.6",
         "@types/yargs": "^17.0.33",
         "@typescript-eslint/eslint-plugin": "^8.34.0",
@@ -80,15 +81,15 @@
         "eslint": "^9.28.0",
         "eslint-import-resolver-typescript": "^4.4.3",
         "eslint-plugin-import": "^2.31.0",
-        "eslint-plugin-oxlint": "^0.17.0",
+        "eslint-plugin-oxlint": "^1.0.0",
         "eslint-plugin-promise": "^7.2.1",
         "eslint-plugin-unicorn": "^59.0.1",
         "eslint-plugin-vue": "^10.2.0",
         "happy-dom": "^17.6.3",
         "jest": "^29.7.0",
-        "jest-environment-jsdom": "30.0.0-beta.3",
-        "jest-environment-node": "30.0.0-beta.3",
-        "oxlint": "^0.17.0",
+        "jest-environment-jsdom": "30.0.0",
+        "jest-environment-node": "30.0.0",
+        "oxlint": "^1.0.0",
         "prettier": "3.5.3",
         "rimraf": "^6.0.1",
         "sweetalert2": "^11.22.0",