versacompiler 2.5.0 → 2.6.1

package/dist/hrm/initHRM.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) ?? {}; },
+    };
+  })();
+}
 /**
  * @fileoverview Inicialización del sistema Hot Module Replacement (HMR) para VersaCompiler
  * Este archivo maneja la conexión con BrowserSync y configura los listeners para HMR de Vue
@@ -11,6 +23,9 @@
 
 import { hideErrorOverlay, showErrorOverlay } from './errorScreen.js';
 import { obtenerInstanciaVue } from './getInstanciaVue.js';
+
+// oxlint-disable-next-line import/no-unassigned-import -- side-effect: inicializa window.__versaHMR
+import './versaHMR.js';
 import { reloadComponent } from './VueHRM.js';
 
 /**
@@ -343,6 +358,27 @@ async function initSocket(retries = 0) {
         socket.on('reloadFull', () => window.location.reload()); // Obtener la instancia de Vue con toda la lógica integrada
         let vueInstance = await obtenerInstanciaVue();
 
+        // Exponer función de recarga Vue por path para que los shims de módulos
+        // puedan disparar una actualización de instancia Vue cuando una dependencia
+        // (sampleFile.js, etc.) se actualiza vía HMR propagation.
+        if (window.__versaHMR) {
+            window.__versaHMR._reloadVueByPath = async path => {
+                try {
+                    vueInstance = window.__VUE_APP__ || vueInstance;
+                    // normalizedPath sin slash inicial (reloadComponent usa origin + '/' + path)
+                    const normalizedPath = path.replace(/^\//, '');
+                    const nameFile =
+                        path.split('/').pop()?.replace('.js', '') ?? '';
+                    await reloadComponent(vueInstance, {
+                        normalizedPath,
+                        nameFile,
+                    });
+                } catch (err) {
+                    console.error('❌ _reloadVueByPath failed:', err);
+                }
+            };
+        }
+
         // Configurar listener para HMR de componentes Vue
         socket.on('HRMVue', async (/** @type {ComponentInfo} */ data) => {
             try {
@@ -372,12 +408,31 @@ async function initSocket(retries = 0) {
             console.log('🔄 HRMHelper recibido:', data);
             console.log('📋 Archivo modificado:', data.filePath);
 
+            // moduleId: identificador canónico del módulo en el registry
+            // El servidor lo envía como el path del output (ej: /public/utils/math.js)
+            const moduleId = data.moduleId || data.filePath;
+
             if (data?.strategy) {
                 switch (data.strategy) {
                     case 'self-accept': {
+                        // El módulo acepta su propio reemplazo (import.meta.hot.accept)
                         try {
                             const timestamp = Date.now();
-                            await import(`${data.filePath}?t=${timestamp}`);
+                            // Usar moduleId (path absoluto con /) en lugar de data.filePath (relativo)
+                            // data.filePath relativo resuelve mal desde /__versa/initHRM.js
+                            const newModule = await import(
+                                `${moduleId}?t=${timestamp}`
+                            );
+                            // También notificar al registry por si hay consumers adicionales
+                            const registry = window.__versaHMR;
+                            if (registry && registry.hasObservers(moduleId)) {
+                                const exportedValue =
+                                    newModule.default !== undefined
+                                        ? newModule.default
+                                        : newModule;
+                                registry.notifyUpdate(moduleId, exportedValue);
+                            }
+                            console.log(`✅ Self-accept HMR: ${moduleId}`);
                             return;
                         } catch (error) {
                             reportErrorToServer(
@@ -391,9 +446,48 @@ async function initSocket(retries = 0) {
                         break;
                     }
                     case 'propagate': {
+                        // Re-importar el módulo con cache-bust y notificar al registry
                         try {
                             const timestamp = Date.now();
-                            await import(`${data.filePath}?t=${timestamp}`);
+                            // Usar moduleId (path absoluto con /) en lugar de data.filePath (relativo)
+                            // data.filePath relativo resuelve mal desde /__versa/initHRM.js
+                            const newModule = await import(
+                                `${moduleId}?t=${timestamp}`
+                            );
+
+                            // Extraer el valor exportado (default o namespace)
+                            const exportedValue =
+                                newModule.default !== undefined
+                                    ? newModule.default
+                                    : newModule;
+
+                            // Notificar al registry de VersaHMR si hay observers registrados
+                            const registry = window.__versaHMR;
+                            if (registry && registry.hasObservers(moduleId)) {
+                                const notified = registry.notifyUpdate(
+                                    moduleId,
+                                    exportedValue,
+                                );
+                                if (notified) {
+                                    console.log(
+                                        `✅ HMR sin recarga: ${moduleId} actualizado via registry`,
+                                    );
+                                    return;
+                                }
+                                // Si los callbacks fallaron, hacer full-reload como safety net
+                                console.warn(
+                                    `⚠️ Callbacks del registry fallaron para ${moduleId}, haciendo full-reload`,
+                                );
+                                window.location.reload();
+                                return;
+                            }
+
+                            // Sin observers en registry → la re-importación ya actualizó
+                            // el módulo en el scope de ES modules del browser.
+                            // Los consumers que hicieron import dinámico obtendrán la nueva versión.
+                            console.log(
+                                `✅ HMR propagado: ${moduleId} (sin observers en registry, re-import completado)`,
+                            );
                             return;
                         } catch (error) {
                             reportErrorToServer(
@@ -403,8 +497,10 @@ async function initSocket(retries = 0) {
                                     : new Error(String(error)),
                                 data,
                             );
+                            // Fallback a full-reload en caso de error
+                            window.location.reload();
+                            return;
                         }
-                        break;
                     }
                     case 'full-reload':
                     default: {
@@ -453,18 +549,30 @@ async function initSocket(retries = 0) {
                         break;
 
                     case 'propagate':
-                        // Propagar la actualización a los importadores
+                        // Propagar la actualización: re-importar y notificar al registry
                         console.log(
                             '🔄 Propagando actualización a importadores',
                         );
                         try {
-                            // Invalidar el módulo en el cache del navegador
-                            // y dejar que los importadores se actualicen
                             const timestamp = Date.now();
-                            await import(`${data.filePath}?t=${timestamp}`);
-                            console.log(
-                                '✅ Actualización propagada exitosamente',
+                            const newModule = await import(
+                                `${data.filePath}?t=${timestamp}`
                             );
+                            const exportedValue =
+                                newModule.default !== undefined
+                                    ? newModule.default
+                                    : newModule;
+                            const registry = window.__versaHMR;
+                            if (registry && registry.hasObservers(moduleId)) {
+                                registry.notifyUpdate(moduleId, exportedValue);
+                                console.log(
+                                    '✅ Actualización propagada via registry',
+                                );
+                            } else {
+                                console.log(
+                                    '✅ Re-import completado (sin observers en registry)',
+                                );
+                            }
                             return;
                         } catch (error) {
                             console.error(

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

@@ -259,6 +259,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) {
@@ -269,8 +276,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;
                 }
             }