valtech-components 2.0.828 → 2.0.830

package/fesm2022/valtech-components.mjs

@@ -53,7 +53,7 @@ import 'prismjs/components/prism-json';
  * Current version of valtech-components.
  * This is automatically updated during the publish process.
  */
-const VERSION = '2.0.828';
+const VERSION = '2.0.830';
 
 /**
  * Servicio para gestionar presets de componentes.
@@ -19839,6 +19839,15 @@ class AppVersionService {
         this.swUpdate.versionUpdates
             .pipe(filter$1(evt => evt.type === 'VERSION_READY'), takeUntilDestroyed(this.destroyRef))
             .subscribe(() => this.swUpdateReady.set(true));
+        // SW en estado irrecuperable — la caché del service worker se corrompió o
+        // fue parcialmente evictada (común en PWAs standalone de iOS tras deploys
+        // repetidos). La app no puede cargar sus assets → pantalla en blanco.
+        // Recuperación recomendada por Angular: recargar para traer todo fresco
+        // desde la red.
+        this.swUpdate.unrecoverable.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(event => {
+            console.error('[AppVersionService] SW unrecoverable — reloading:', event.reason);
+            this.document.defaultView?.location.reload();
+        });
         // Chequeo periódico.
         const intervalMs = this.serviceConfig?.checkIntervalMs ?? DEFAULT_APP_VERSION_SERVICE_CONFIG.checkIntervalMs;
         interval(intervalMs)
@@ -24636,14 +24645,34 @@ class AuthService {
                 void this.ensureFirebaseSessionOnBootstrap();
             }
             else if (storedState.refreshToken) {
-                // 4. Token expirado pero hay refresh token - intentar refrescar
-                try {
-                    await firstValueFrom(this.refreshAccessToken());
+                // 4. Token expirado pero hay refresh token.
+                //
+                // NO bloqueamos el bootstrap esperando la red: un /refresh en una
+                // Lambda fría son 2-5s de pantalla en blanco (Angular no renderiza
+                // nada hasta que el APP_INITIALIZER resuelve).
+                //
+                // Restauración optimista: el access token expiró pero sus claims
+                // (uid/email/roles) siguen decodificables — `parseToken` NO valida
+                // `exp`. Restauramos la sesión desde esos claims para que la app
+                // renderice el shell autenticado de inmediato, y disparamos el
+                // /refresh en segundo plano (fire-and-forget).
+                //
+                // Seguridad de la ventana sub-segundo antes de que el refresh llegue:
+                // cualquier API call sale con el token expirado → 401 → el
+                // authInterceptor refresca + reintenta automáticamente. Si el refresh
+                // de fondo falla → signOut + clearState.
+                console.log('[ValtechAuth] bootstrap — access token expired, refreshing in background');
+                this.stateService.restoreFromStorage(storedState);
+                const expiredClaims = this.tokenService.parseToken(storedState.accessToken);
+                if (expiredClaims) {
+                    this.stateService.updateUserInfo(expiredClaims.uid, expiredClaims.email);
                 }
-                catch {
+                // Refresh en segundo plano — NO se hace await: initialize() resuelve ya.
+                firstValueFrom(this.refreshAccessToken()).catch(() => {
+                    console.warn('[ValtechAuth] bootstrap — background refresh failed, signing out');
                     this.signOutFirebase();
                     this.clearState();
-                }
+                });
             }
             else {
                 this.signOutFirebase();
@@ -25286,8 +25315,15 @@ class AuthService {
             console.log('[ValtechAuth] Calling signInWithFirebase with token length:', response.firebaseToken.length);
             this.signInWithFirebase(response.firebaseToken);
         }
+        else if (this.config.enableFirebaseIntegration) {
+            // El login NO trajo firebaseToken (ej. flujo OAuth que lo perdió). En vez
+            // de quedar sin sesión de Firebase, recurrimos al fallback self-healing:
+            // /refresh sí devuelve un firebaseToken confiable.
+            console.log('[FBAuth] login response sin firebaseToken → recurriendo a fallback /refresh');
+            void this.reestablishFirebaseViaRefresh('login-missing-firebase-token');
+        }
         else {
-            console.log('[ValtechAuth] Firebase signin skipped - conditions not met');
+            console.log('[ValtechAuth] Firebase signin skipped - integración Firebase desactivada');
         }
         // Registro automático de dispositivo para push notifications
         if (this.config.enableDeviceRegistration) {
@@ -25438,13 +25474,31 @@ class AuthService {
             console.log('[FBAuth] bootstrap — Firebase session restored on its own');
             return;
         }
-        console.log('[FBAuth] bootstrap — session valid but Firebase NOT ready → refreshing to re-establish');
+        console.log('[FBAuth] bootstrap — session valid but Firebase NOT ready → recurriendo a fallback');
+        await this.reestablishFirebaseViaRefresh('bootstrap-session-restore');
+    }
+    /**
+     * Fallback self-healing de Firebase Auth. Pide un firebaseToken fresco vía
+     * `/refresh` (que sí lo devuelve de forma confiable) y, en éxito,
+     * `refreshAccessToken()` ya ejecuta `signInWithFirebase()`.
+     *
+     * Se invoca cuando un path de auth dejó la sesión de Firebase sin establecer:
+     *  - login OAuth/password que volvió sin `firebaseToken`,
+     *  - cold launch de PWA iOS sin persistencia de Firebase.
+     *
+     * `reason` aparece en los logs `[FBAuth] fallback` para poder atestiguar
+     * desde el debug-console qué disparó el fallback.
+     */
+    async reestablishFirebaseViaRefresh(reason) {
+        if (!this.config.enableFirebaseIntegration || !this.firebaseService)
+            return;
+        console.log(`[FBAuth] fallback — re-estableciendo Firebase vía /refresh (motivo: ${reason})`);
         try {
-            // refreshAccessToken() ya llama signInWithFirebase() en éxito.
             await firstValueFrom(this.refreshAccessToken());
+            console.log(`[FBAuth] fallback — /refresh OK, Firebase re-establecido (motivo: ${reason})`);
         }
         catch (e) {
-            console.warn('[FBAuth] bootstrap — refresh to re-establish Firebase failed:', e);
+            console.warn(`[FBAuth] fallback — /refresh falló (motivo: ${reason}):`, e);
         }
     }
     // =============================================