versacompiler 2.3.3 → 2.3.5

package/dist/utils/module-resolver.js

@@ -6,6 +6,48 @@ import { cwd, env } from 'node:process';
 // import resolve from '/node_modules/resolve/index.js';
 import { logger } from '../servicios/logger.js';
 import { EXCLUDED_MODULES } from './excluded-modules.js';
+class PackageJsonCache {
+    static instance;
+    cache = new Map();
+    MAX_CACHE_SIZE = 200;
+    static getInstance() {
+        if (!PackageJsonCache.instance) {
+            PackageJsonCache.instance = new PackageJsonCache();
+        }
+        return PackageJsonCache.instance;
+    }
+    get(packagePath) {
+        try {
+            if (!fs.existsSync(packagePath)) {
+                return null;
+            }
+            const stats = fs.statSync(packagePath);
+            const cached = this.cache.get(packagePath);
+            if (cached && cached.mtime === stats.mtimeMs) {
+                return cached.content;
+            }
+            const content = JSON.parse(readFileSync(packagePath, 'utf-8'));
+            if (this.cache.size >= this.MAX_CACHE_SIZE) {
+                const firstKey = this.cache.keys().next().value;
+                if (firstKey) {
+                    this.cache.delete(firstKey);
+                }
+            }
+            this.cache.set(packagePath, {
+                content,
+                mtime: stats.mtimeMs,
+            });
+            return content;
+        }
+        catch {
+            return null;
+        }
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+const packageJsonCache = PackageJsonCache.getInstance();
 // function resolveESMWithLibrary(moduleName: string): string | null {
 //     try {
 //         // Resolver el módulo
@@ -141,166 +183,130 @@ function findOptimalESMVersion(moduleDir, entryPoint) {
                 }
                 return optimizedPath;
             }
-        } // Buscar archivos que contengan patrones ESM/browser dinámicamente
-        const esmBrowserFiles = files.filter((file) => {
+        }
+        // ✨ OPTIMIZACIÓN CRÍTICA: Clasificar archivos en un solo loop
+        const fileGroups = {
+            esmBrowserProd: [],
+            esmBrowserMin: [],
+            esmBrowserDev: [],
+            esmProd: [],
+            esmMin: [],
+            esmDev: [],
+            browserMin: [],
+            runtimeDev: [],
+            runtime: [],
+            other: [],
+        };
+        for (const file of files) {
+            if (!file.endsWith('.js') && !file.endsWith('.mjs'))
+                continue;
             const lowerFile = file.toLowerCase();
-            return ((lowerFile.includes('.esm-browser.') || // Prioridad alta: combinación esm-browser
-                lowerFile.includes('.esm.') ||
-                lowerFile.includes('.module.') ||
-                lowerFile.includes('.browser.') ||
-                lowerFile.includes('.web.') ||
-                lowerFile.includes('.runtime.esm-browser.')) && // Runtime como última opción
-                (file.endsWith('.js') || file.endsWith('.mjs')));
-        });
-        if (esmBrowserFiles.length > 0) {
-            // Primera prioridad: archivos que combinan ESM y Browser (sin runtime)
-            const esmBrowserCombined = esmBrowserFiles.filter((file) => file.toLowerCase().includes('.esm-browser.') &&
-                !file.toLowerCase().includes('.runtime.'));
-            if (esmBrowserCombined.length > 0) {
-                // ✨ MODO PRODUCCIÓN: Priorizar .prod.js o .min.js
-                if (env.isPROD === 'true') {
-                    // Primera opción: archivos .prod.js
-                    const prodFiles = esmBrowserCombined.filter((file) => file.toLowerCase().includes('.prod.'));
-                    if (prodFiles.length > 0 && prodFiles[0]) {
-                        const optimizedPath = join(dir, prodFiles[0]).replace(/\\/g, '/');
-                        if (env.VERBOSE === 'true') {
-                            logger.info(`🏭 Versión ESM-Browser producción encontrada: ${optimizedPath}`);
-                        }
-                        return optimizedPath;
-                    }
-                    // Segunda opción: archivos .min.js
-                    const minFiles = esmBrowserCombined.filter((file) => file.toLowerCase().includes('.min.'));
-                    if (minFiles.length > 0 && minFiles[0]) {
-                        const optimizedPath = join(dir, minFiles[0]).replace(/\\/g, '/');
-                        if (env.VERBOSE === 'true') {
-                            logger.info(`🗜️ Versión ESM-Browser minificada encontrada: ${optimizedPath}`);
-                        }
-                        return optimizedPath;
-                    }
-                    // Fallback: si no hay .prod ni .min, usar desarrollo
-                    if (env.VERBOSE === 'true') {
-                        logger.warn('⚠️ No se encontró versión de producción, usando desarrollo');
-                    }
-                }
-                // ✨ MODO DESARROLLO: Priorizar desarrollo > .prod > .min
-                const devFiles = esmBrowserCombined.filter((file) => !file.toLowerCase().includes('.prod.') &&
-                    !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 desarrollo encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
-                // Fallback en desarrollo: si no hay versión dev, usar prod
-                const prodFiles = esmBrowserCombined.filter((file) => file.toLowerCase().includes('.prod.'));
-                if (prodFiles.length > 0 && prodFiles[0]) {
-                    const optimizedPath = join(dir, prodFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión ESM-Browser producción encontrada (fallback): ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
-                const minFiles = esmBrowserCombined.filter((file) => file.toLowerCase().includes('.min.'));
-                if (minFiles.length > 0 && minFiles[0]) {
-                    const optimizedPath = join(dir, minFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión ESM-Browser minificada encontrada (fallback): ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
-                if (esmBrowserCombined[0]) {
-                    const optimizedPath = join(dir, esmBrowserCombined[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión ESM-Browser encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
+            const hasEsmBrowser = lowerFile.includes('.esm-browser.');
+            const hasEsm = lowerFile.includes('.esm.') || lowerFile.includes('.module.');
+            const hasBrowser = lowerFile.includes('.browser.') || lowerFile.includes('.web.');
+            const hasRuntime = lowerFile.includes('.runtime.');
+            const isProd = lowerFile.includes('.prod.');
+            const isMin = lowerFile.includes('.min.');
+            if (hasEsmBrowser && !hasRuntime) {
+                if (isProd)
+                    fileGroups.esmBrowserProd.push(file);
+                else if (isMin)
+                    fileGroups.esmBrowserMin.push(file);
+                else
+                    fileGroups.esmBrowserDev.push(file);
             }
-            // Segunda prioridad: cualquier versión ESM disponible
-            if (env.isPROD === 'true') {
-                // En producción, buscar versiones minificadas/prod primero
-                const esmProdFiles = esmBrowserFiles.filter((file) => (file.toLowerCase().includes('.esm.') ||
-                    file.toLowerCase().includes('.module.')) &&
-                    (file.toLowerCase().includes('.prod.') ||
-                        file.toLowerCase().includes('.min.')) &&
-                    !file.toLowerCase().includes('.runtime.'));
-                if (esmProdFiles.length > 0 && esmProdFiles[0]) {
-                    const optimizedPath = join(dir, esmProdFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`🏭 Versión ESM producción encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
+            else if (hasEsm && !hasRuntime) {
+                if (isProd)
+                    fileGroups.esmProd.push(file);
+                else if (isMin)
+                    fileGroups.esmMin.push(file);
+                else
+                    fileGroups.esmDev.push(file);
             }
-            else {
-                // En desarrollo, buscar versiones sin minificar
-                const esmFiles = esmBrowserFiles.filter((file) => (file.toLowerCase().includes('.esm.') ||
-                    file.toLowerCase().includes('.module.')) &&
-                    !file.toLowerCase().includes('.min.') &&
-                    !file.toLowerCase().includes('.prod.') &&
-                    !file.toLowerCase().includes('.runtime.'));
-                if (esmFiles.length > 0 && esmFiles[0]) {
-                    const optimizedPath = join(dir, esmFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`🔧 Versión ESM desarrollo encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
+            else if (hasBrowser && isMin) {
+                fileGroups.browserMin.push(file);
             }
-            // Tercera prioridad: archivos minificados de cualquier tipo ESM/browser (sin runtime)
-            const minifiedFiles = esmBrowserFiles.filter((file) => (file.toLowerCase().includes('.min.') ||
-                file.toLowerCase().includes('.prod.')) &&
-                !file.toLowerCase().includes('.runtime.'));
-            if (minifiedFiles.length > 0) {
-                // Priorizar ESM sobre browser sobre UMD
-                const esmFiles = minifiedFiles.filter((file) => file.toLowerCase().includes('.esm.') ||
-                    file.toLowerCase().includes('.module.'));
-                if (esmFiles.length > 0 && esmFiles[0]) {
-                    const optimizedPath = join(dir, esmFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión ESM minificada encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
-                if (minifiedFiles[0]) {
-                    const optimizedPath = join(dir, minifiedFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión minificada encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
+            else if (hasRuntime && hasEsmBrowser) {
+                if (!isProd && !isMin)
+                    fileGroups.runtimeDev.push(file);
+                else
+                    fileGroups.runtime.push(file);
             }
-            // Cuarta prioridad: versiones runtime como último recurso
-            const runtimeFiles = esmBrowserFiles.filter((file) => file.toLowerCase().includes('.runtime.esm-browser.'));
-            if (runtimeFiles.length > 0) {
-                // Priorizar desarrollo sobre producción en runtime también
-                const devRuntimeFiles = runtimeFiles.filter((file) => !file.toLowerCase().includes('.prod.') &&
-                    !file.toLowerCase().includes('.min.'));
-                if (devRuntimeFiles.length > 0 && devRuntimeFiles[0]) {
-                    const optimizedPath = join(dir, devRuntimeFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión Runtime ESM-Browser dev encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
-                if (runtimeFiles[0]) {
-                    const optimizedPath = join(dir, runtimeFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión Runtime ESM-Browser encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
+            else if (hasEsm || hasBrowser) {
+                fileGroups.other.push(file);
             }
-            // Fallback: cualquier versión browser
-            if (esmBrowserFiles[0]) {
-                const optimizedPath = join(dir, esmBrowserFiles[0]).replace(/\\/g, '/');
-                if (env.VERBOSE === 'true') {
-                    logger.info(`Versión browser encontrada: ${optimizedPath}`);
-                }
+        }
+        // Seleccionar archivo según prioridad y modo
+        const isProd = env.isPROD === 'true';
+        // Prioridad 1: ESM-Browser
+        if (isProd) {
+            if (fileGroups.esmBrowserProd[0]) {
+                const optimizedPath = join(dir, fileGroups.esmBrowserProd[0]).replace(/\\/g, '/');
+                if (env.VERBOSE === 'true')
+                    logger.info(`🏭 Versión ESM-Browser producción encontrada: ${optimizedPath}`);
+                return optimizedPath;
+            }
+            if (fileGroups.esmBrowserMin[0]) {
+                const optimizedPath = join(dir, fileGroups.esmBrowserMin[0]).replace(/\\/g, '/');
+                if (env.VERBOSE === 'true')
+                    logger.info(`🗜️ Versión ESM-Browser minificada encontrada: ${optimizedPath}`);
                 return optimizedPath;
             }
         }
+        if (fileGroups.esmBrowserDev[0]) {
+            const optimizedPath = join(dir, fileGroups.esmBrowserDev[0]).replace(/\\/g, '/');
+            if (env.VERBOSE === 'true')
+                logger.info(`🔧 Versión ESM-Browser desarrollo encontrada: ${optimizedPath}`);
+            return optimizedPath;
+        }
+        // Prioridad 2: ESM puro
+        if (isProd) {
+            if (fileGroups.esmProd[0]) {
+                const optimizedPath = join(dir, fileGroups.esmProd[0]).replace(/\\/g, '/');
+                if (env.VERBOSE === 'true')
+                    logger.info(`Versión ESM producción encontrada: ${optimizedPath}`);
+                return optimizedPath;
+            }
+            if (fileGroups.esmMin[0]) {
+                const optimizedPath = join(dir, fileGroups.esmMin[0]).replace(/\\/g, '/');
+                if (env.VERBOSE === 'true')
+                    logger.info(`Versión ESM minificada encontrada: ${optimizedPath}`);
+                return optimizedPath;
+            }
+        }
+        if (fileGroups.esmDev[0]) {
+            const optimizedPath = join(dir, fileGroups.esmDev[0]).replace(/\\/g, '/');
+            if (env.VERBOSE === 'true')
+                logger.info(`Versión ESM encontrada: ${optimizedPath}`);
+            return optimizedPath;
+        }
+        // Prioridad 3: Browser minificado
+        if (fileGroups.browserMin[0]) {
+            const optimizedPath = join(dir, fileGroups.browserMin[0]).replace(/\\/g, '/');
+            if (env.VERBOSE === 'true')
+                logger.info(`Versión browser minificada encontrada: ${optimizedPath}`);
+            return optimizedPath;
+        }
+        // Prioridad 4: Runtime
+        if (fileGroups.runtimeDev[0]) {
+            const optimizedPath = join(dir, fileGroups.runtimeDev[0]).replace(/\\/g, '/');
+            if (env.VERBOSE === 'true')
+                logger.info(`Versión Runtime ESM-Browser dev encontrada: ${optimizedPath}`);
+            return optimizedPath;
+        }
+        if (fileGroups.runtime[0]) {
+            const optimizedPath = join(dir, fileGroups.runtime[0]).replace(/\\/g, '/');
+            if (env.VERBOSE === 'true')
+                logger.info(`Versión Runtime ESM-Browser encontrada: ${optimizedPath}`);
+            return optimizedPath;
+        }
+        // Fallback: otros archivos browser/esm
+        if (fileGroups.other[0]) {
+            const optimizedPath = join(dir, fileGroups.other[0]).replace(/\\/g, '/');
+            if (env.VERBOSE === 'true')
+                logger.info(`Versión browser encontrada: ${optimizedPath}`);
+            return optimizedPath;
+        }
     }
     catch (error) {
         if (env.VERBOSE === 'true') {
@@ -323,7 +329,9 @@ function simpleESMResolver(moduleName) {
         catch {
             return null;
         }
-        const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+        const packageJson = packageJsonCache.get(packagePath);
+        if (!packageJson)
+            return null;
         const moduleDir = dirname(packagePath);
         const isESM = packageJson.type === 'module'; // Determinar el entry point ESM/Browser optimizado
         let entryPoint = null;
@@ -392,7 +400,7 @@ function simpleESMResolver(moduleName) {
             entryPoint = isESM ? 'index.js' : 'index.cjs';
         } // Resolver la ruta final
         let finalPath = join(moduleDir, entryPoint);
-        // Buscar una versión ESM/browser optimizada
+        // Buscar una versión ESM/browser optimizada (garantizar que entryPoint es string)
         const optimizedEntry = findOptimalESMVersion(moduleDir, entryPoint);
         if (optimizedEntry && optimizedEntry !== entryPoint) {
             finalPath = join(moduleDir, optimizedEntry);
@@ -507,7 +515,9 @@ export function getModuleSubPath(moduleName, fromFile) {
             if (!fs.existsSync(packagePath)) {
                 return null;
             }
-            const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+            const packageJson = packageJsonCache.get(packagePath);
+            if (!packageJson)
+                return null;
             const moduleDir = dirname(packagePath);
             // Revisar exports field para subpaths
             if (packageJson.exports &&

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "versacompiler",
-    "version": "2.3.3",
+    "version": "2.3.5",
     "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": {
@@ -18,13 +18,14 @@
     "scripts": {
         "dev": "tsx --watch src/main.ts --watch --verbose --tailwind",
         "file": "tsx src/main.ts ",
-        "compile": "tsx src/main.ts --all --cc --co -y --verbose --prod",
-        "compileDev": "tsx src/main.ts --all --cc -y --verbose",
+        "build": "tsx src/main.ts --all -t --cc --co -y --verbose",
+        "compileDev": "tsx src/main.ts --all --ci --cc -y -t --linter --verbose",
+        "vlint": "tsx src/main.ts --all --cc --co -y --linter",
+        "vtlint": "tsx src/main.ts --all --cc --co -y -t",
         "test": "vitest run",
         "test:watch": "vitest",
         "test:ui": "vitest --ui",
         "test:coverage": "vitest run --coverage",
-        "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"
     },