wu-framework 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wu-framework",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "🚀 Universal Microfrontends Framework - Framework agnostic, zero config, Shadow DOM isolation",
   "main": "src/index.js",
   "type": "module",

package/src/core/wu-cache.js

@@ -102,7 +102,11 @@ export class WuCache {
       };
 
       // Verificar si necesitamos hacer espacio
-      this.ensureSpace(entry.size);
+      const hasSpace = this.ensureSpace(entry.size);
+      if (hasSpace === false) {
+        console.warn(`[WuCache] ⚠️ Cannot cache item: ${key} (too large)`);
+        return false;
+      }
 
       // Guardar en memoria
       this.memoryCache.set(key, entry);
@@ -194,9 +198,28 @@ export class WuCache {
   ensureSpace(neededSize) {
     const maxSizeBytes = this.config.maxSize * 1024 * 1024;
 
+    // 🛡️ FIX: Validar que el item no sea más grande que el máximo permitido
+    if (neededSize > maxSizeBytes) {
+      console.warn(`[WuCache] ⚠️ Item size (${neededSize}) exceeds max cache size (${maxSizeBytes}). Skipping.`);
+      return false;
+    }
+
+    // 🛡️ FIX: Límite de iteraciones para evitar loop infinito
+    const maxIterations = this.config.maxItems + 10;
+    let iterations = 0;
+
     // Verificar si necesitamos limpiar
-    while (this.stats.size + neededSize > maxSizeBytes ||
-           this.memoryCache.size >= this.config.maxItems) {
+    while ((this.stats.size + neededSize > maxSizeBytes ||
+           this.memoryCache.size >= this.config.maxItems) &&
+           iterations < maxIterations) {
+
+      iterations++;
+
+      // 🛡️ FIX: Si el cache está vacío pero aún no hay espacio, salir
+      if (this.memoryCache.size === 0) {
+        console.warn('[WuCache] ⚠️ Cache empty but still no space. Breaking loop.');
+        break;
+      }
 
       // Encontrar entrada menos recientemente usada (LRU)
       let oldestKey = null;
@@ -217,6 +240,13 @@ export class WuCache {
         break;
       }
     }
+
+    // 🛡️ FIX: Log si alcanzamos el límite de iteraciones
+    if (iterations >= maxIterations) {
+      console.error(`[WuCache] 🚨 Max eviction iterations reached (${maxIterations}). Possible infinite loop prevented.`);
+    }
+
+    return true;
   }
 
   /**

package/src/core/wu-core.js

@@ -104,56 +104,79 @@ export class WuCore {
   }
 
   /**
-   * 🔍 SMART MUTATION OBSERVER: Real-time DOM monitoring for efficiency
+   * 🔍 SMART MUTATION OBSERVER: Observa SOLO los contenedores de apps montadas
+   * FIX: Ya no observa todo document.body (memory leak)
    */
   initializeMutationObserver() {
-    if (!window.MutationObserver) return; // Fallback for older browsers
+    if (!window.MutationObserver) return;
 
-    this.healthState.mutationObserver = new MutationObserver((mutations) => {
-      let shouldCheckHealth = false;
+    // Map para trackear observers por contenedor (evita memory leak)
+    this.healthState.containerObservers = new Map();
+
+    // Callback compartido para todos los observers
+    this.healthState.mutationCallback = (mutations, observer) => {
+      let affectedAppName = null;
 
       for (const mutation of mutations) {
-        // Only check health if it affects our mounted apps
-        if (mutation.type === 'childList') {
-          const removedNodes = Array.from(mutation.removedNodes);
-          const affectedApps = removedNodes.some(node => {
-            if (node.nodeType === Node.ELEMENT_NODE) {
-              // Check if removed node contains any of our mounted apps
-              for (const [appName, mounted] of this.mounted) {
-                if (node.contains && node.contains(mounted.container)) {
-                  return true;
-                }
-                if (node === mounted.container) {
-                  return true;
-                }
-              }
+        if (mutation.type === 'childList' && mutation.removedNodes.length > 0) {
+          // Encontrar qué app fue afectada
+          for (const [appName, mounted] of this.mounted) {
+            const container = mounted.hostContainer || mounted.container;
+            if (mutation.target === container ||
+                mutation.target.contains?.(container)) {
+              affectedAppName = appName;
+              break;
             }
-            return false;
-          });
-
-          if (affectedApps) {
-            shouldCheckHealth = true;
-            break;
           }
         }
+        if (affectedAppName) break;
       }
 
-      // Debounced health check only when necessary
-      if (shouldCheckHealth) {
+      if (affectedAppName) {
         clearTimeout(this.healthState.mutationCheckTimeout);
         this.healthState.mutationCheckTimeout = setTimeout(() => {
           this.performHealthCheck();
-        }, 1000); // Wait 1 second to batch multiple mutations
+        }, 1000);
       }
-    });
+    };
+
+    logger.wuDebug('🔍 MutationObserver system initialized (lazy per-container)');
+  }
+
+  /**
+   * 🔗 Observar contenedor específico cuando se monta una app
+   */
+  observeContainer(appName, container) {
+    if (!this.healthState.containerObservers || !container) return;
+
+    // No observar si ya existe
+    if (this.healthState.containerObservers.has(appName)) return;
 
-    // Observe the entire document but only care about child changes
-    this.healthState.mutationObserver.observe(document.body, {
+    const observer = new MutationObserver(this.healthState.mutationCallback);
+
+    // Observar solo el contenedor padre directo (no subtree profundo)
+    const parentToObserve = container.parentElement || container;
+    observer.observe(parentToObserve, {
       childList: true,
-      subtree: true
+      subtree: false  // ✅ Solo hijos directos, no todo el árbol
     });
 
-    logger.wuDebug('🔍 MutationObserver initialized for smart DOM monitoring');
+    this.healthState.containerObservers.set(appName, observer);
+    logger.wuDebug(`🔍 Observing container for ${appName}`);
+  }
+
+  /**
+   * 🔓 Dejar de observar contenedor cuando se desmonta
+   */
+  unobserveContainer(appName) {
+    if (!this.healthState.containerObservers) return;
+
+    const observer = this.healthState.containerObservers.get(appName);
+    if (observer) {
+      observer.disconnect();
+      this.healthState.containerObservers.delete(appName);
+      logger.wuDebug(`🔓 Stopped observing container for ${appName}`);
+    }
   }
 
   /**
@@ -606,10 +629,14 @@ export class WuCore {
         poolSandbox,
         lifecycle,
         container: sandbox.container,
+        hostContainer: container,
         timestamp: Date.now(),
         state: 'stable'
       });
 
+      // 🔍 Observar contenedor para health monitoring (sin memory leak)
+      this.observeContainer(appName, container);
+
       // ⚡ End performance measurement
       const mountTime = this.performance.endMeasure('mount', appName);
 
@@ -1017,6 +1044,7 @@ export class WuCore {
   /**
    * 📦 MODULE LOADER: Advanced registration patterns
    * Handles asynchronous registration with timing synchronization
+   * FIX: Verifica que definitions tenga el lifecycle después de cargar
    */
   async moduleLoader(moduleUrl, appName) {
     // ✅ Check if already registered
@@ -1027,16 +1055,37 @@ export class WuCore {
 
     console.log(`[Wu] 📡 Using event-based registration for ${appName}`);
 
-    // 🔔 Use event-based waiting (no polling!)
-    const registrationPromise = this.registry.waitForApp(appName, 10000);
+    // 🚀 Load module first
+    try {
+      await import(/* @vite-ignore */ moduleUrl);
+    } catch (loadError) {
+      console.error(`[Wu] ❌ Failed to import module ${moduleUrl}:`, loadError);
+      throw loadError;
+    }
 
-    // 🚀 Load module asynchronously
-    const moduleLoadPromise = import(/* @vite-ignore */ moduleUrl);
+    // 🛡️ FIX: Esperar a que wu.define() se ejecute con verificación real
+    const maxWaitTime = 10000; // 10 segundos
+    const checkInterval = 50; // Verificar cada 50ms
+    const startTime = Date.now();
+
+    while (!this.definitions.has(appName)) {
+      const elapsed = Date.now() - startTime;
+
+      if (elapsed >= maxWaitTime) {
+        throw new Error(
+          `App '${appName}' module loaded but wu.define() was not called within ${maxWaitTime}ms.\n\n` +
+          `Make sure your module calls:\n` +
+          `  wu.define('${appName}', { mount, unmount })\n\n` +
+          `Or using window.wu:\n` +
+          `  window.wu.define('${appName}', { mount, unmount })`
+        );
+      }
 
-    // 🌌 Wait for both operations to complete
-    await Promise.all([moduleLoadPromise, registrationPromise]);
+      // Esperar un poco antes de verificar de nuevo
+      await new Promise(resolve => setTimeout(resolve, checkInterval));
+    }
 
-    console.log(`[Wu] ✅ App ${appName} loaded and registered via events`);
+    console.log(`[Wu] ✅ App ${appName} loaded and registered (verified in definitions)`);
   }
 
   /**
@@ -1080,6 +1129,9 @@ export class WuCore {
         this.sandboxPool.release(appName);
       }
 
+      // 🔓 Dejar de observar contenedor (evita memory leak)
+      this.unobserveContainer(appName);
+
       // Remover del registro de montadas
       this.mounted.delete(appName);
 
@@ -1243,10 +1295,12 @@ export class WuCore {
         this.healthState.monitor = null;
       }
 
-      // Limpiar MutationObserver
-      if (this.healthState.mutationObserver) {
-        this.healthState.mutationObserver.disconnect();
-        this.healthState.mutationObserver = null;
+      // Limpiar todos los MutationObservers por contenedor
+      if (this.healthState.containerObservers) {
+        for (const [appName, observer] of this.healthState.containerObservers) {
+          observer.disconnect();
+        }
+        this.healthState.containerObservers.clear();
       }
 
       // Limpiar timeouts pendientes

package/src/index.js

@@ -103,7 +103,7 @@ if (typeof window !== 'undefined') {
 
   // Configurar propiedades si no existen
   if (!wu.version) {
-    wu.version = '1.0.3';
+    wu.version = '1.0.4';
     console.log('🚀 Wu Framework loaded - Universal Microfrontends ready');
     wu.info = {
       name: 'Wu Framework',