wu-framework 1.1.12 → 1.1.14

package/dist/wu-framework.dev.js

@@ -7363,6 +7363,8 @@ class WuCore {
     this.manifests = new Map();      // Manifiestos cargados
     this.mounted = new Map();        // Apps montadas
     this.hidden = new Map();         // Keep-alive hidden apps
+    this._pendingUnmounts = new Map(); // Deferred unmount timers (StrictMode compat)
+    this._mountingPromises = new Map(); // In-flight mount dedup
 
     // Componentes core
     this.loader = new WuLoader();
@@ -7511,6 +7513,31 @@ class WuCore {
    * @param {string} containerSelector - Selector del contenedor
    */
   async mount(appName, containerSelector) {
+    // ── StrictMode guard: cancel pending deferred unmount ──
+    // React StrictMode cycle: effect(mount) → cleanup(unmount) → effect(mount)
+    // The cleanup fires between two mounts. By deferring the actual unmount,
+    // the second mount cancels it and the app stays alive — zero flicker.
+    if (this._pendingUnmounts.has(appName)) {
+      clearTimeout(this._pendingUnmounts.get(appName));
+      this._pendingUnmounts.delete(appName);
+      logger.wuDebug(`${appName} deferred unmount cancelled by remount`);
+    }
+
+    // Already mounted in same container → no-op
+    if (this.mounted.has(appName)) {
+      const existing = this.mounted.get(appName);
+      if (existing.containerSelector === containerSelector) {
+        logger.wuDebug(`${appName} already mounted in ${containerSelector}`);
+        return;
+      }
+    }
+
+    // Deduplicate concurrent mounts (StrictMode fires effect twice)
+    if (this._mountingPromises.has(appName)) {
+      logger.wuDebug(`${appName} mount already in progress, deduplicating`);
+      return await this._mountingPromises.get(appName);
+    }
+
     // Check if app is in keep-alive (hidden) state
     const hiddenEntry = this.hidden.get(appName);
     if (hiddenEntry) {
@@ -7522,7 +7549,15 @@ class WuCore {
       await this._destroyHidden(appName);
     }
 
-    return await this.mountWithRecovery(appName, containerSelector, 0);
+    // Track mount promise for deduplication
+    const mountPromise = this.mountWithRecovery(appName, containerSelector, 0);
+    this._mountingPromises.set(appName, mountPromise);
+
+    try {
+      return await mountPromise;
+    } finally {
+      this._mountingPromises.delete(appName);
+    }
   }
 
   /**
@@ -8173,28 +8208,60 @@ class WuCore {
    * @param {boolean} [options.force] - Force destroy even if keepAlive
    */
   async unmount(appName, options = {}) {
-    try {
-      logger.wuDebug(`Unmounting ${appName}`);
+    logger.wuDebug(`Unmounting ${appName}`);
 
-      const mounted = this.mounted.get(appName);
-      if (!mounted) {
-        // Check if it's hidden (keep-alive) — force destroy if requested
-        if (options.force && this.hidden.has(appName)) {
-          return await this._destroyHidden(appName);
-        }
-        logger.wuWarn(`App ${appName} not mounted`);
-        return;
+    const mounted = this.mounted.get(appName);
+    if (!mounted) {
+      // Check if it's hidden (keep-alive) — force destroy if requested
+      if (options.force && this.hidden.has(appName)) {
+        return await this._destroyHidden(appName);
       }
+      logger.wuWarn(`App ${appName} not mounted`);
+      return;
+    }
 
-      // Resolve keepAlive: per-call > per-app config > default false
-      const keepAlive = options.force
-        ? false
-        : (options.keepAlive ?? mounted.app?.keepAlive ?? false);
+    // Resolve keepAlive: per-call > per-app config > default false
+    const keepAlive = options.force
+      ? false
+      : (options.keepAlive ?? mounted.app?.keepAlive ?? false);
 
-      if (keepAlive) {
-        return await this.hide(appName);
+    if (keepAlive) {
+      return await this.hide(appName);
+    }
+
+    // Force → immediate unmount (no deferral)
+    if (options.force) {
+      return await this._executeUnmount(appName, mounted);
+    }
+
+    // ── Deferred unmount: 60ms window for React StrictMode ──
+    // StrictMode cycle: effect(mount) → cleanup(unmount) → effect(mount)
+    // The cleanup fires between two mounts. By deferring the actual unmount,
+    // the second mount() call cancels the timer and the app stays alive.
+    if (this._pendingUnmounts.has(appName)) {
+      clearTimeout(this._pendingUnmounts.get(appName));
+    }
+
+    this._pendingUnmounts.set(appName, setTimeout(async () => {
+      this._pendingUnmounts.delete(appName);
+      // Re-verify: only unmount if the same mount entry is still current
+      if (this.mounted.has(appName) && this.mounted.get(appName) === mounted) {
+        try {
+          await this._executeUnmount(appName, mounted);
+        } catch (error) {
+          logger.wuError(`Deferred unmount failed for ${appName}:`, error);
+        }
       }
+    }, 60));
+  }
 
+  /**
+   * Execute the actual unmount immediately (no deferral).
+   * Called by the deferred timer, force unmount, or destroy.
+   * @private
+   */
+  async _executeUnmount(appName, mounted) {
+    try {
       // Execute beforeUnmount hooks
       const beforeUnmountResult = await this.hooks.execute('beforeUnmount', { appName, mounted });
       if (beforeUnmountResult.cancelled) {
@@ -8610,6 +8677,13 @@ class WuCore {
       // Call plugin onDestroy hooks
       await this.pluginSystem.callHook('onDestroy', {});
 
+      // Cancel all pending deferred unmounts
+      for (const timer of this._pendingUnmounts.values()) {
+        clearTimeout(timer);
+      }
+      this._pendingUnmounts.clear();
+      this._mountingPromises.clear();
+
       // Force-destroy all hidden (keep-alive) apps first
       for (const appName of [...this.hidden.keys()]) {
         await this._destroyHidden(appName);