versacompiler 2.4.0 → 2.5.0

package/dist/main.js

@@ -66,7 +66,8 @@ async function main() {
     const chalkInstance = await loadChalk();
     let yargInstance = yargsInstance(hideBinFn(globalProcess.argv))
         .scriptName('versa')
-        .usage(chalkInstance.blue('VersaCompiler') + ' - Compilador de archivos Vue/TS/JS')
+        .usage(chalkInstance.blue('VersaCompiler') +
+        ' - Compilador de archivos Vue/TS/JS')
         .option('init', {
         type: 'boolean',
         description: 'Inicializar la configuración',

package/dist/servicios/browserSync.js

@@ -565,11 +565,17 @@ export async function browserSyncServer() {
         process.exit(1);
     }
 }
-export async function emitirCambios(bs, action, filePath) {
+export async function emitirCambios(bs, action, filePath, payload = {}) {
     // ✨ OPTIMIZACIÓN: Emitir PRIMERO (crítico), logging DESPUÉS (no crítico)
     const normalizedPath = path.normalize(filePath).replace(/\\/g, '/');
     const nameFile = path.basename(normalizedPath, path.extname(normalizedPath));
-    bs.sockets.emit(action, { action, filePath, normalizedPath, nameFile });
+    bs.sockets.emit(action, {
+        action,
+        filePath,
+        normalizedPath,
+        nameFile,
+        ...payload,
+    });
     // Logging asíncrono para no bloquear la emisión
     setImmediate(async () => {
         const chalkInstance = await loadChalk();

package/dist/servicios/file-watcher.js

@@ -4,7 +4,7 @@ import * as process from 'node:process';
 const { env } = process;
 import * as chokidar from 'chokidar';
 import { minimatch } from 'minimatch';
-import { clearCompilationState, getOutputPath, initCompile, normalizeRuta } from '../compiler/compile.js';
+import { clearCompilationState, getOutputPath, getPipelineModuleGraph, initCompile, normalizeRuta, runPipelineHotUpdate, } from '../compiler/compile.js';
 import { promptUser } from '../utils/promptUser.js';
 import { emitirCambios } from './browserSync.js';
 import { logger } from './logger.js';
@@ -147,13 +147,32 @@ class WatchDebouncer {
      */
     async processCompilableFiles(compilableFiles) {
         const chalkInstance = await loadChalk();
+        const graph = getPipelineModuleGraph();
         // 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));
+            const expandedChanges = new Map();
+            for (const change of batch) {
+                expandedChanges.set(change.filePath, change);
+                if (graph) {
+                    const invalidated = graph.invalidate(change.filePath);
+                    for (const invalidatedPath of invalidated) {
+                        if (expandedChanges.has(invalidatedPath))
+                            continue;
+                        expandedChanges.set(invalidatedPath, {
+                            filePath: invalidatedPath,
+                            action: 'change',
+                            timestamp: Date.now(),
+                            extensionAction: 'reloadFull',
+                            isAdditionalFile: false,
+                        });
+                    }
+                }
+            }
+            const promises = Array.from(expandedChanges.values()).map(change => this.compileFile(change));
             await Promise.allSettled(promises);
         }
         if (compilableFiles.length > 1) {
@@ -177,12 +196,37 @@ class WatchDebouncer {
      */
     async compileFile(change) {
         try {
+            let pluginHmrReload = 'none';
+            if (change.action !== 'unlink') {
+                const hotUpdate = await runPipelineHotUpdate(change.filePath, change.action);
+                pluginHmrReload = hotUpdate.reload || 'none';
+            }
             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);
+                let payload = {};
+                if (accion === 'HRMHelper') {
+                    if (pluginHmrReload === 'full') {
+                        accion = 'reloadFull';
+                    }
+                    const graph = getPipelineModuleGraph();
+                    const node = graph?.getNode(change.filePath);
+                    const importers = node ? Array.from(node.importers) : [];
+                    const strategy = importers.length > 0 ? 'propagate' : 'full-reload';
+                    if (pluginHmrReload === 'module') {
+                        payload.strategy = 'propagate';
+                    }
+                    else {
+                        payload.strategy = strategy;
+                    }
+                    payload = {
+                        importers,
+                        ...payload,
+                    };
+                }
+                emitirCambios(this.browserSyncInstance, accion || 'reloadFull', result.output, payload);
             }
         }
         catch (error) {
@@ -355,9 +399,7 @@ export async function initChokidar(bs) {
         // ✨ OPTIMIZACIÓN: Pre-cargar módulos críticos al iniciar el watcher
         watcher.on('ready', async () => {
             const chalkInstance = await loadChalk();
-            logger.info(chalkInstance.green(`👀 : Listo para observar \n${fileWatch
-                .map((item) => `${item}`)
-                .join('\n')}\n`));
+            logger.info(chalkInstance.green(`👀 : Listo para observar \n${fileWatch.map((item) => `${item}`).join('\n')}\n`));
             // Pre-cargar módulos críticos para primera compilación más rápida
             setImmediate(async () => {
                 try {

package/dist/servicios/readConfig.js

@@ -25,7 +25,7 @@ export function validatePath(pathStr) {
         return false;
     }
     // Rechazar rutas absolutas de Windows (válido en cualquier plataforma)
-    if (/^[A-Za-z]:[\\\/]/.test(pathStr)) {
+    if (/^[A-Za-z]:[/\\]/.test(pathStr)) {
         logger.error(`Ruta absoluta de Windows no permitida: ${pathStr}`);
         return false;
     }
@@ -238,6 +238,80 @@ function safeJsonStringify(obj, fallback = 'false') {
         return fallback;
     }
 }
+function normalizeAliasKey(key) {
+    if (key.includes('*'))
+        return key;
+    if (key.endsWith('/'))
+        return `${key}*`;
+    return `${key}/*`;
+}
+function normalizeAliasValue(value) {
+    if (value.includes('*'))
+        return value;
+    if (value.endsWith('/'))
+        return `${value}*`;
+    return `${value}/*`;
+}
+function normalizeAlias(alias) {
+    if (!alias)
+        return {};
+    const result = {};
+    if (Array.isArray(alias)) {
+        for (const entry of alias) {
+            if (!entry || typeof entry.find !== 'string')
+                continue;
+            if (typeof entry.replacement !== 'string')
+                continue;
+            const key = normalizeAliasKey(entry.find);
+            const value = normalizeAliasValue(entry.replacement);
+            result[key] = [value];
+        }
+        return result;
+    }
+    for (const [key, value] of Object.entries(alias)) {
+        const normalizedKey = normalizeAliasKey(key);
+        if (Array.isArray(value)) {
+            result[normalizedKey] = value
+                .filter(v => typeof v === 'string')
+                .map(v => normalizeAliasValue(v));
+        }
+        else if (typeof value === 'string') {
+            result[normalizedKey] = [normalizeAliasValue(value)];
+        }
+    }
+    return result;
+}
+function normalizeConfig(input) {
+    if (input?.compilerOptions) {
+        return input;
+    }
+    const viteConfig = input;
+    const aliases = normalizeAlias(viteConfig?.resolve?.alias);
+    return {
+        tsconfig: viteConfig?.tsconfig,
+        compilerOptions: {
+            sourceRoot: viteConfig?.root || './src',
+            outDir: viteConfig?.build?.outDir || './dist',
+            pathsAlias: aliases,
+        },
+        plugins: viteConfig?.plugins,
+        proxyConfig: {
+            proxyUrl: viteConfig?.server?.proxyUrl || '',
+            assetsOmit: viteConfig?.server?.assetsOmit ?? false,
+        },
+        aditionalWatch: viteConfig?.watch?.additional ||
+            viteConfig?.server?.watch?.additional ||
+            [],
+        tailwindConfig: viteConfig?.tailwindConfig,
+        linter: viteConfig?.linter,
+        bundlers: viteConfig?.build?.bundlers,
+        typeCheckOptions: viteConfig?.typeCheckOptions,
+    };
+}
+let loadedConfig = null;
+export function getLoadedConfig() {
+    return loadedConfig;
+}
 /**
  * Wrapper para el import dinámico que permite mejor testing
  */
@@ -272,7 +346,8 @@ export async function readConfig() {
         if (!data) {
             throw new Error('No se pudo leer el archivo de configuración.');
         }
-        const tsConfig = data.default || data;
+        const rawConfig = data.default || data;
+        const tsConfig = normalizeConfig(rawConfig);
         // Validar tamaño de configuración
         if (!validateConfigSize(tsConfig)) {
             throw new Error('Configuración demasiado grande o contiene referencias circulares.');
@@ -323,6 +398,7 @@ export async function readConfig() {
         if (!tsConfig.compilerOptions.sourceRoot) {
             env.tsConfig = safeJsonStringify(tsConfig, '{}');
         }
+        loadedConfig = tsConfig;
         logger.info('✅ Configuration loaded and validated successfully');
         return true;
     }
@@ -347,58 +423,57 @@ export async function initConfig() {
             logger.warn(`🚩 El archivo de configuración '${env.PATH_CONFIG_FILE}' ya existe.`);
             return true;
         }
-        const configContent = `// Archivo de configuración de VersaCompiler
-export default {
-    tsconfig: './tsconfig.json',
-    compilerOptions: {
-        sourceRoot: './src',
-        outDir: './dist',
-        pathsAlias: {
-            '/dist/examples/*': ['src/*'],
-            '/dist/public/*': ['public/*'],
-        },
-    },
-    proxyConfig: {
-        proxyUrl: '',
-        assetsOmit: true,
-    },
-    aditionalWatch: ['./app/templates/**/*.twig', './app/templates/**/*.html'],
-    // puede dejar en false o no agregarlo si no quiere que se ejecute el compilador de tailwind
-    tailwindConfig: {
-        bin: './node_modules/.bin/tailwindcss',
-        input: './src/css/input.css',
-        output: './public/css/output.css',
-    },
-    linter: [
-        {
-            name: 'eslint',
-            bin: './node_modules/.bin/eslint',
-            configFile: './.eslintrc.json',
-            fix: false,
-            paths: ['src/']
-        },
-        {
-            name: 'oxlint',
-            bin: './node_modules/.bin/oxlint',
-            configFile: './.oxlintrc.json',
-            fix: false,
-            paths: ['src/']
-        },
-    ],
-    // Configuración de bundlers
-    bundlers: [
-        {
-            name: 'appLoader',
-            fileInput: './public/module/appLoader.js',
-            fileOutput: './public/module/appLoader.prod.js',
-        },
-        {
-            name: 'mainApp',
-            fileInput: './src/main.ts',
-            fileOutput: './dist/main.bundle.js',
-        }
-    ],
-};
+        const configContent = `import { defineConfig } from 'versacompiler/config';
+
+export default defineConfig({
+    root: './src',
+    build: {
+        outDir: './dist',
+        bundlers: [
+            {
+                name: 'appLoader',
+                fileInput: './public/module/appLoader.js',
+                fileOutput: './public/module/appLoader.prod.js',
+            },
+        ],
+    },
+    resolve: {
+        alias: {
+            '/dist': 'src',
+            '/dist/public': 'public',
+        },
+    },
+    server: {
+        proxyUrl: '',
+        assetsOmit: true,
+        watch: {
+            additional: ['./app/templates/**/*.twig', './app/templates/**/*.html'],
+        },
+    },
+    tsconfig: './tsconfig.json',
+    tailwindConfig: {
+        bin: './node_modules/.bin/tailwindcss',
+        input: './src/css/input.css',
+        output: './public/css/output.css',
+    },
+    linter: [
+        {
+            name: 'eslint',
+            bin: './node_modules/.bin/eslint',
+            configFile: './.eslintrc.json',
+            fix: false,
+            paths: ['src/'],
+        },
+        {
+            name: 'oxlint',
+            bin: './node_modules/.bin/oxlint',
+            configFile: './.oxlintrc.json',
+            fix: false,
+            paths: ['src/'],
+        },
+    ],
+    plugins: [],
+});
 `;
         fs.writeFileSync(configPath, configContent, 'utf8');
         logger.info(`🚩 Archivo de configuración '${env.PATH_CONFIG_FILE}' creado correctamente.`);

package/dist/servicios/versacompile.config.types.js

@@ -0,0 +1,2 @@
+export const defineConfig = (config) => config;
+//# sourceMappingURL=versacompile.config.types.js.map

package/dist/utils/module-resolver.js

@@ -1,9 +1,9 @@
-// Opción con librería '/node_modules/resolve/index.js' (npm install resolve)
+// Opción con librería 'resolve' (npm install resolve)
 import fs, { readFileSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
 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 pkg from 'enhanced-resolve';
+// import resolve from 'resolve';
 import { logger } from '../servicios/logger.js';
 import { EXCLUDED_MODULES } from './excluded-modules.js';
 class PackageJsonCache {
@@ -72,7 +72,7 @@ const packageJsonCache = PackageJsonCache.getInstance();
 //         return null;
 //     }
 // }
-// Opción con '/node_modules/enhanced-resolve/lib/index.js' (webpack's resolver)
+// Opción con 'enhanced-resolve' (webpack's resolver)
 // npm install enhanced-resolve
 // const { ResolverFactory } = pkg;
 // const resolver = ResolverFactory.createResolver({
@@ -350,26 +350,7 @@ function simpleESMResolver(moduleName) {
                     entryPoint = dotExport;
                 }
                 else if (typeof dotExport === 'object') {
-                    // Priorizar import > browser > default para compatibilidad ESM
-                    // Buscar específicamente patrones esm-browser primero
-                    const exportKeys = Object.keys(dotExport);
-                    const esmBrowserKey = exportKeys.find(key => key.includes('browser') &&
-                        (key.includes('esm') || key.includes('module')));
-                    if (esmBrowserKey &&
-                        typeof dotExport[esmBrowserKey] === 'string') {
-                        entryPoint = dotExport[esmBrowserKey];
-                    }
-                    else {
-                        // Priorizar import > browser > default
-                        entryPoint =
-                            (typeof dotExport.import === 'string'
-                                ? dotExport.import
-                                : null) ||
-                                dotExport.browser ||
-                                (typeof dotExport.default === 'string'
-                                    ? dotExport.default
-                                    : null);
-                    }
+                    entryPoint = resolveExportValue(dotExport);
                 }
             }
         }
@@ -489,6 +470,64 @@ function getNodeModulesRelativePath(fullPath, _fromFile) {
     }
     return rel;
 }
+/**
+ * Parses a module specifier into packageName and subPath.
+ * Handles scoped packages correctly.
+ * Examples:
+ *   '@vueuse/core'      → { packageName: '@vueuse/core', subPath: '' }
+ *   '@vueuse/core/sub'  → { packageName: '@vueuse/core', subPath: 'sub' }
+ *   'vue/dist/x'        → { packageName: 'vue', subPath: 'dist/x' }
+ *   'vue'               → { packageName: 'vue', subPath: '' }
+ */
+export function parseModuleSpecifier(moduleName) {
+    if (moduleName.startsWith('@')) {
+        const parts = moduleName.split('/');
+        if (parts.length < 2 || !parts[1]) {
+            return { packageName: moduleName, subPath: '' };
+        }
+        const packageName = `${parts[0]}/${parts[1]}`;
+        const subPath = parts.slice(2).join('/');
+        return { packageName, subPath };
+    }
+    else {
+        const slashIdx = moduleName.indexOf('/');
+        if (slashIdx === -1) {
+            return { packageName: moduleName, subPath: '' };
+        }
+        return {
+            packageName: moduleName.slice(0, slashIdx),
+            subPath: moduleName.slice(slashIdx + 1),
+        };
+    }
+}
+/**
+ * Recursively resolves a conditional export value.
+ * Priority: import > browser > module > default
+ * Handles nested objects up to a depth limit.
+ */
+export function resolveExportValue(exportVal, depth = 0) {
+    if (depth > 5)
+        return null;
+    if (typeof exportVal === 'string')
+        return exportVal;
+    if (typeof exportVal === 'object' && exportVal !== null) {
+        const obj = exportVal;
+        for (const key of [
+            'import',
+            'browser',
+            'module',
+            'default',
+            'require',
+        ]) {
+            if (obj[key] !== undefined) {
+                const resolved = resolveExportValue(obj[key], depth + 1);
+                if (resolved)
+                    return resolved;
+            }
+        }
+    }
+    return null;
+}
 export function getModulePath(moduleName, fromFile) {
     // Verificar si el módulo está en la lista de excluidos
     if (EXCLUDED_MODULES.has(moduleName)) {
@@ -501,14 +540,15 @@ export function getModuleSubPath(moduleName, fromFile) {
     // Verificar si el módulo está en la lista de excluidos
     if (EXCLUDED_MODULES.has(moduleName)) {
         return null; // Retornar null para mantener la importación original
-    } // Si contiene '/', es un subpath
+    }
+    // Usar parseModuleSpecifier para manejar correctamente paquetes con scope
+    const { packageName, subPath } = parseModuleSpecifier(moduleName);
+    // Si no hay subPath, delegar al resolver normal
+    if (!subPath) {
+        return getModulePath(moduleName, fromFile);
+    }
+    // Es un subpath: resolver con el packageName correcto
     if (moduleName.includes('/')) {
-        const [packageName, ...subPathParts] = moduleName.split('/');
-        const subPath = subPathParts.join('/');
-        // Verificar que packageName no esté vacío
-        if (!packageName) {
-            return null;
-        }
         try {
             const nodeModulesPath = join(cwd(), 'node_modules', packageName);
             const packagePath = join(nodeModulesPath, 'package.json');
@@ -525,15 +565,9 @@ export function getModuleSubPath(moduleName, fromFile) {
                 const exportKey = `./${subPath}`;
                 const exportPath = packageJson.exports[exportKey];
                 if (exportPath) {
-                    if (typeof exportPath === 'string') {
-                        return getNodeModulesRelativePath(join(moduleDir, exportPath), fromFile);
-                    }
-                    else if (typeof exportPath === 'object') {
-                        // Priorizar import > default para ESM
-                        const importPath = exportPath.import || exportPath.default;
-                        if (typeof importPath === 'string') {
-                            return getNodeModulesRelativePath(join(moduleDir, importPath), fromFile);
-                        }
+                    const resolved = resolveExportValue(exportPath);
+                    if (resolved) {
+                        return getNodeModulesRelativePath(join(moduleDir, resolved), fromFile);
                     }
                 }
             }