versacompiler 2.4.1 → 2.6.0

package/dist/hrm/versaHMR.js

@@ -0,0 +1,317 @@
+/* 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) ?? {}; },
+    };
+  })();
+}
+/**
+ * @fileoverview VersaHMR — Registry de módulos para Hot Module Replacement
+ *
+ * Permite que librerías y utilidades JS/TS reciban actualizaciones sin full-reload.
+ *
+ * Uso básico (en cualquier módulo que consuma una librería):
+ *
+ *   window.__versaHMR.accept('/public/utils/math.js', (newModule) => {
+ *     // Recibir la nueva versión y actualizar referencias locales
+ *     mathLib = newModule;
+ *   });
+ *
+ * Uso automático (para módulos que solo exportan funciones/constantes):
+ *   El sistema detecta automáticamente si es seguro hacer HMR y llama a los callbacks.
+ */
+
+/**
+ * @typedef {Object} ModuleEntry
+ * @property {any} module - La instancia actual del módulo
+ * @property {Set<Function>} callbacks - Callbacks registrados para actualizaciones
+ * @property {number} version - Versión (incrementa en cada update)
+ */
+
+class VersaModuleRegistry {
+    constructor() {
+        /** @type {Map<string, ModuleEntry>} */
+        this._registry = new Map();
+
+        /** @type {Map<string, Set<string>>} Árbol inverso: módulo → quién lo importa */
+        this._importers = new Map();
+
+        /** @type {Set<string>} Módulos que han fallado al actualizarse */
+        this._failedUpdates = new Set();
+
+        /** @type {Map<string, Set<Function>>} Callbacks de cleanup por módulo */
+        this._disposeCallbacks = new Map();
+
+        /** @type {Map<string, Object>} Datos persistentes entre ciclos HMR */
+        this._hotData = new Map();
+    }
+
+    /**
+     * Normaliza un moduleId para uso como clave en el registry.
+     * Elimina query params y asegura formato consistente.
+     * @param {string} moduleId
+     * @returns {string}
+     */
+    _normalizeId(moduleId) {
+        try {
+            // Si es una URL relativa, la convertimos a pathname limpio
+            const url = new URL(moduleId, window.location.origin);
+            return url.pathname;
+        } catch {
+            return moduleId.split('?')[0];
+        }
+    }
+
+    /**
+     * Registra un callback para recibir actualizaciones de un módulo.
+     * El callback se llama con (newModule, { moduleId, version }) cuando el módulo cambia.
+     *
+     * @param {string} moduleId - Path/URL del módulo a observar (ej: '/public/utils/math.js')
+     * @param {Function} updateCallback - Función llamada cuando el módulo cambia
+     * @returns {Function} Función para cancelar el registro (unsubscribe)
+     */
+    accept(moduleId, updateCallback) {
+        const id = this._normalizeId(moduleId);
+
+        if (!this._registry.has(id)) {
+            this._registry.set(id, {
+                module: null,
+                callbacks: new Set(),
+                version: 0,
+            });
+        }
+
+        const entry = this._registry.get(id);
+        entry.callbacks.add(updateCallback);
+
+        console.log(`[VersaHMR] Registrado observer para: ${id}`);
+
+        // Retornar función de cleanup
+        return () => {
+            const e = this._registry.get(id);
+            if (e) {
+                e.callbacks.delete(updateCallback);
+                if (e.callbacks.size === 0) {
+                    this._registry.delete(id);
+                    console.log(`[VersaHMR] Registry limpiado para: ${id}`);
+                }
+            }
+        };
+    }
+
+    /**
+     * Notifica a todos los observers registrados que un módulo fue actualizado.
+     * Llamado internamente por el handler de HRMHelper cuando recibe un nuevo módulo.
+     *
+     * @param {string} moduleId - Path del módulo actualizado
+     * @param {any} newModule - La nueva instancia del módulo exportado
+     * @returns {boolean} true si había al menos un observer y todos ejecutaron sin error
+     */
+    notifyUpdate(moduleId, newModule) {
+        const id = this._normalizeId(moduleId);
+        const entry = this._registry.get(id);
+
+        if (!entry || entry.callbacks.size === 0) {
+            return false;
+        }
+
+        // Ejecutar dispose callbacks antes de actualizar
+        this._runDispose(id);
+
+        entry.version++;
+        entry.module = newModule;
+        const meta = { moduleId: id, version: entry.version };
+
+        let allSucceeded = true;
+
+        for (const callback of entry.callbacks) {
+            try {
+                callback(newModule, meta);
+            } catch (err) {
+                console.error(
+                    `[VersaHMR] Error en callback de update para ${id}:`,
+                    err,
+                );
+                allSucceeded = false;
+                this._failedUpdates.add(id);
+            }
+        }
+
+        if (allSucceeded) {
+            this._failedUpdates.delete(id);
+            console.log(
+                `[VersaHMR] ✅ Módulo actualizado (v${entry.version}): ${id} — ${entry.callbacks.size} observer(s) notificado(s)`,
+            );
+        }
+
+        return allSucceeded;
+    }
+
+    /**
+     * Registra la relación de importación entre módulos.
+     * Esto permite propagación en cadena cuando cambia un módulo.
+     *
+     * @param {string} importer - Path del módulo que importa
+     * @param {string} imported - Path del módulo importado
+     */
+    registerImporter(importer, imported) {
+        const importedId = this._normalizeId(imported);
+        const importerId = this._normalizeId(importer);
+
+        if (!this._importers.has(importedId)) {
+            this._importers.set(importedId, new Set());
+        }
+        this._importers.get(importedId).add(importerId);
+    }
+
+    /**
+     * Obtiene el módulo actual registrado (si fue cargado via notifyUpdate).
+     * @param {string} moduleId
+     * @returns {any | null}
+     */
+    getModule(moduleId) {
+        const id = this._normalizeId(moduleId);
+        return this._registry.get(id)?.module ?? null;
+    }
+
+    /**
+     * Registra un callback de dispose que se ejecuta antes de que el módulo
+     * sea reemplazado. Permite cleanup de timers, event listeners, etc.
+     * Expuesto como import.meta.hot.dispose(cb) en el shim de HMR.
+     *
+     * @param {string} moduleId
+     * @param {Function} cb - Llamado con (data) donde data = _getHotData(moduleId)
+     */
+    _onDispose(moduleId, cb) {
+        const id = this._normalizeId(moduleId);
+        if (!this._disposeCallbacks.has(id)) {
+            this._disposeCallbacks.set(id, new Set());
+        }
+        this._disposeCallbacks.get(id).add(cb);
+    }
+
+    /**
+     * Retorna el objeto de datos persistentes de un módulo.
+     * El objeto sobrevive entre ciclos HMR para preservar estado local.
+     * Expuesto como import.meta.hot.data en el shim de HMR.
+     *
+     * @param {string} moduleId
+     * @returns {Object}
+     */
+    _getHotData(moduleId) {
+        const id = this._normalizeId(moduleId);
+        if (!this._hotData.has(id)) {
+            this._hotData.set(id, {});
+        }
+        return this._hotData.get(id);
+    }
+
+    /**
+     * Ejecuta los callbacks de dispose antes de un update HMR.
+     * Llamado internamente desde notifyUpdate antes de notificar observers.
+     *
+     * @param {string} moduleId
+     */
+    _runDispose(moduleId) {
+        const id = this._normalizeId(moduleId);
+        const disposers = this._disposeCallbacks.get(id);
+        if (!disposers || disposers.size === 0) return;
+
+        const data = this._getHotData(id);
+        for (const cb of disposers) {
+            try {
+                cb(data);
+            } catch (err) {
+                console.error(
+                    `[VersaHMR] Error en dispose callback para ${id}:`,
+                    err,
+                );
+            }
+        }
+        this._disposeCallbacks.delete(id);
+    }
+
+    /**
+     * Invalida un módulo: ejecuta dispose callbacks y fuerza recarga de página.
+     * Expuesto como import.meta.hot.invalidate() en el shim de HMR.
+     *
+     * @param {string} moduleId
+     */
+    _invalidate(moduleId) {
+        const id = this._normalizeId(moduleId);
+
+        // Ejecutar dispose callbacks antes de invalidar
+        this._runDispose(id);
+
+        // Limpiar estado del módulo
+        this._hotData.delete(id);
+        this._registry.delete(id);
+
+        console.log(
+            `[VersaHMR] Módulo invalidado: ${id} — forzando recarga completa`,
+        );
+        window.location.reload();
+    }
+
+    /**
+     * Indica si un módulo tiene observers registrados (puede hacer HMR).
+     * @param {string} moduleId
+     * @returns {boolean}
+     */
+    hasObservers(moduleId) {
+        const id = this._normalizeId(moduleId);
+        const entry = this._registry.get(id);
+        return !!(entry && entry.callbacks.size > 0);
+    }
+
+    /**
+     * Indica si un módulo tuvo fallos en el último update.
+     * @param {string} moduleId
+     * @returns {boolean}
+     */
+    hasFailed(moduleId) {
+        return this._failedUpdates.has(this._normalizeId(moduleId));
+    }
+
+    /**
+     * Limpia todos los registros (útil para tests o hot-reload del propio sistema).
+     */
+    clear() {
+        this._registry.clear();
+        this._importers.clear();
+        this._failedUpdates.clear();
+        this._disposeCallbacks.clear();
+        this._hotData.clear();
+    }
+
+    /**
+     * Estadísticas del registry (para debugging).
+     * @returns {{ modules: number, totalObservers: number, failedModules: number }}
+     */
+    getStats() {
+        let totalObservers = 0;
+        for (const entry of this._registry.values()) {
+            totalObservers += entry.callbacks.size;
+        }
+        return {
+            modules: this._registry.size,
+            totalObservers,
+            failedModules: this._failedUpdates.size,
+        };
+    }
+}
+
+// Singleton global expuesto en window.__versaHMR
+// Se preserva entre recargas parciales para no perder observers
+if (!window.__versaHMR) {
+    window.__versaHMR = new VersaModuleRegistry();
+    console.log('[VersaHMR] Registry inicializado');
+}
+
+export const versaHMR = window.__versaHMR;
+export default versaHMR;

package/dist/main.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) ?? {}; },
+    };
+  })();
+}
 #!/usr/bin/env node
 import * as path from 'node:path';
 import * as processModule from 'node:process';
@@ -66,7 +78,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',
@@ -258,6 +271,13 @@ async function main() {
                 try {
                     // Verificar si el archivo existe
                     await fs.access(file);
+                }
+                catch {
+                    logger.error(chalk.red(`❌ El archivo '${file}' no existe.`));
+                    hasErrors = true;
+                    continue;
+                }
+                try {
                     logger.info(chalk.blue(`🔄 Compilando: ${file}`));
                     const result = await compileFile(file);
                     if (result.success) {
@@ -268,8 +288,8 @@ async function main() {
                         hasErrors = true;
                     }
                 }
-                catch {
-                    logger.error(chalk.red(`❌ El archivo '${file}' no existe.`));
+                catch (err) {
+                    logger.error(chalk.red(`❌ Error al compilar '${file}': ${err instanceof Error ? err.message : String(err)}`));
                     hasErrors = true;
                 }
             }

package/dist/servicios/browserSync.js

@@ -1,3 +1,17 @@
+/* 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) ?? {}; },
+    };
+    window.__versaHMR.accept("/path/to/file.js", () => { import(_id + '?t=' + Date.now()); });
+    window.__versaHMR.accept("/public/js/bar.js", () => { import(_id + '?t=' + Date.now()); });
+  })();
+}
 import { createHash } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
@@ -315,6 +329,54 @@ class BrowserSyncFileCache {
 }
 // Instancia global del cache de archivos
 const fileCache = BrowserSyncFileCache.getInstance();
+// ─── HMR Import Rewriting ─────────────────────────────────────────────────────
+// Cuando un módulo se re-compila en watch mode, registramos su path con timestamp.
+// Al servir requests con ?t= (re-imports HMR), reescribimos los static imports de
+// ese archivo para que también incluyan ?t=, forzando al browser a cargar la nueva
+// versión en lugar de usar el módulo cacheado en su module registry.
+/** Map de path normalizado → timestamp de la última compilación exitosa */
+const recentHMRTimestamps = new Map();
+/** TTL para limpiar entradas viejas del mapa (5 minutos) */
+const HMR_TIMESTAMP_TTL = 5 * 60 * 1000;
+/**
+ * Registra que un output file fue re-compilado en modo watch.
+ * Debe llamarse inmediatamente después de escribir el archivo a disco.
+ * @param outputPath - Path relativo del output compilado (ej: 'public/js/sampleFile.js')
+ */
+export function registerHMRUpdate(outputPath) {
+    // Normalizar a path absoluto con / inicial (como lo ve el browser)
+    const normalized = '/' + outputPath.replace(/\\/g, '/').replace(/^\.?\/+/, '');
+    recentHMRTimestamps.set(normalized, Date.now());
+    // Limpiar entradas viejas para evitar crecimiento ilimitado
+    const cutoff = Date.now() - HMR_TIMESTAMP_TTL;
+    for (const [key, ts] of recentHMRTimestamps) {
+        if (ts < cutoff)
+            recentHMRTimestamps.delete(key);
+    }
+}
+/**
+ * Reescribe los static imports de un archivo JS para agregar ?t=<timestamp>
+ * a cualquier módulo que haya sido recientemente re-compilado.
+ * Esto fuerza al browser a crear un nuevo module record (URL diferente)
+ * en lugar de reusar el módulo cacheado del registry.
+ */
+function rewriteImportsForHMR(content) {
+    if (recentHMRTimestamps.size === 0)
+        return content;
+    // Reescribir: from '/path/to/file.js' → from '/path/to/file.js?t=<ts>'
+    // Handles: import ... from '...', export ... from '...'
+    // Solo paths absolutos (con /) → son los compilados por VersaCompiler
+    return content.replace(/((?:from|import)\s+['"])(\/.+?\.js)(['""])/g, (_match, prefix, importPath, suffix) => {
+        // Quitar ?t= previo si ya existe
+        const cleanPath = importPath.split('?')[0];
+        const ts = recentHMRTimestamps.get(cleanPath);
+        if (ts) {
+            return `${prefix}${cleanPath}?t=${ts}${suffix}`;
+        }
+        return _match;
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
 // Lazy loading para chalk - pre-cargado para mejor rendimiento
 let chalk;
 let chalkPromise = null;
@@ -388,6 +450,9 @@ export async function browserSyncServer() {
                     fn: (snippet, match) => {
                         return `
                             ${snippet}${match}
+                            <script
+                                type="module"
+                                src="/__versa/versaHMR.js"></script>
                             <script
                                 type="module"
                                 src="/__versa/initHRM.js"></script>
@@ -447,8 +512,19 @@ export async function browserSyncServer() {
                     }
                     // Si la URL comienza con /__versa/hrm/, sirve los archivos de dist/hrm
                     if (req.url.startsWith('/__versa/')) {
-                        // ✨ OPTIMIZADO: Usar cache para archivos Versa
-                        const filePath = path.join(relativeHrmPath, req.url.replace('/__versa/', ''));
+                        // ✨ SEGURIDAD: Prevenir path traversal normalizando y verificando el directorio
+                        const requestedRelative = req.url
+                            .replace('/__versa/', '')
+                            .split('?')[0]; // strip query string
+                        const resolvedFilePath = path.resolve(relativeHrmPath, requestedRelative);
+                        const allowedBase = path.resolve(relativeHrmPath);
+                        if (!resolvedFilePath.startsWith(allowedBase + path.sep) &&
+                            resolvedFilePath !== allowedBase) {
+                            res.statusCode = 403;
+                            res.end('// Forbidden');
+                            return;
+                        }
+                        const filePath = resolvedFilePath;
                         const cachedFile = await fileCache.getOrReadFile(filePath);
                         if (cachedFile) {
                             res.setHeader('Content-Type', cachedFile.contentType);
@@ -473,8 +549,19 @@ export async function browserSyncServer() {
                     }
                     // Si la URL comienza con /node_modules/, sirve los archivos de node_modules
                     if (req.url.startsWith('/node_modules/')) {
-                        // ✨ OPTIMIZADO: Usar cache para módulos de node_modules
-                        const modulePath = path.join(process.cwd(), req.url);
+                        // ✨ SEGURIDAD: Prevenir path traversal verificando que el path resuelto
+                        // permanece dentro de node_modules del proyecto
+                        const requestedRelative = req.url
+                            .replace('/node_modules/', '')
+                            .split('?')[0]; // strip query string
+                        const nodeModulesBase = path.resolve(process.cwd(), 'node_modules');
+                        const modulePath = path.resolve(nodeModulesBase, requestedRelative);
+                        if (!modulePath.startsWith(nodeModulesBase + path.sep) &&
+                            modulePath !== nodeModulesBase) {
+                            res.statusCode = 403;
+                            res.end('// Forbidden');
+                            return;
+                        }
                         const cachedFile = await fileCache.getOrReadFile(modulePath);
                         if (cachedFile) {
                             res.setHeader('Content-Type', cachedFile.contentType);
@@ -497,6 +584,34 @@ export async function browserSyncServer() {
                         }
                         return;
                     }
+                    // ── HMR re-import: reescribir imports para que el browser no use caché ──
+                    // Cuando el cliente hace import('/public/js/foo.js?t=123'), el browser crea
+                    // un nuevo module record para esa URL. Al evaluar el módulo, sus static imports
+                    // (ej: import { x } from '/public/js/bar.js') SIN timestamp reusan el módulo
+                    // cacheado del registry → se ve el código viejo.
+                    // Solución: interceptar estas requests y reescribir los imports del archivo
+                    // para que también lleven ?t= en los módulos recientemente modificados.
+                    const isHMRReimport = req.method === 'GET' &&
+                        req.url.includes('?t=') &&
+                        /\.js\?/.test(req.url) &&
+                        !req.url.startsWith('/__versa/') &&
+                        !req.url.startsWith('/node_modules/');
+                    if (isHMRReimport) {
+                        const urlPath = req.url.split('?')[0];
+                        const filePath = path.join(process.cwd(), urlPath);
+                        try {
+                            const rawContent = await fs.readFile(filePath, 'utf-8');
+                            const rewritten = rewriteImportsForHMR(rawContent);
+                            res.setHeader('Content-Type', 'application/javascript; charset=utf-8');
+                            res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+                            res.end(rewritten);
+                            return;
+                        }
+                        catch {
+                            // Archivo no encontrado, seguir al handler estático
+                        }
+                    }
+                    // ──────────────────────────────────────────────────────────────────────────
                     // detectar si es un archivo estático, puede que contenga un . y alguna extensión o dashUsers.js?v=1746559083866
                     const isAssets = req.url.match(/\.(js|css|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|eot|map|webp|avif|json|html|xml|txt|pdf|zip|mp4|mp3|wav|ogg)(\?.*)?$/i);
                     if (req.method === 'GET') {
@@ -565,11 +680,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();