valtech-components 2.0.826 → 2.0.828

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.826';
+const VERSION = '2.0.828';
 
 /**
  * Servicio para gestionar presets de componentes.
@@ -21509,6 +21509,7 @@ class FirebaseService {
                 // true al haber User, false en signout. Permite que los gates
                 // re-evalúen tras un logout/login dentro de la misma sesión de página.
                 this._firebaseAuthReady.set(!!user);
+                console.log(`[FBAuth] authState emit user=${user?.uid ?? 'null'} firebaseAuthReady=${!!user}`);
                 this.sessionState.next({
                     user: user ? this.mapUser(user) : null,
                     isAuthenticated: !!user,
@@ -21518,6 +21519,7 @@ class FirebaseService {
             },
             error: error => {
                 this._firebaseAuthReady.set(false);
+                console.error(`[FBAuth] authState ERROR: ${error instanceof Error ? error.message : String(error)}`);
                 this.sessionState.next({
                     user: null,
                     isAuthenticated: false,
@@ -21536,9 +21538,14 @@ class FirebaseService {
      */
     whenFirebaseAuthReady() {
         if (this._firebaseAuthReady()) {
+            console.log('[FBAuth] whenFirebaseAuthReady resolved immediately (already ready)');
             return Promise.resolve(true);
         }
-        return firstValueFrom(this.firebaseAuthReady$);
+        console.log('[FBAuth] whenFirebaseAuthReady waiting for Firebase Auth session...');
+        return firstValueFrom(this.firebaseAuthReady$).then(v => {
+            console.log('[FBAuth] whenFirebaseAuthReady resolved after wait');
+            return v;
+        });
     }
     // ===========================================================================
     // AUTENTICACIÓN
@@ -21558,6 +21565,7 @@ class FirebaseService {
      * ```
      */
     async signInWithCustomToken(token) {
+        console.log(`[FBAuth] signInWithCustomToken called tokenLen=${token?.length ?? 0}`);
         try {
             const credential = await signInWithCustomToken(this.auth, token);
             // Forzar refresh del token para asegurar que los claims estén actualizados
@@ -21565,10 +21573,12 @@ class FirebaseService {
             if (credential.user) {
                 await credential.user.getIdToken(true);
             }
+            console.log(`[FBAuth] signInWithCustomToken OK uid=${credential.user?.uid ?? 'null'}`);
             return credential;
         }
         catch (error) {
             const message = this.getErrorMessage(error);
+            console.error(`[FBAuth] signInWithCustomToken FAILED: ${message}`);
             throw new Error(message);
         }
     }
@@ -23766,8 +23776,11 @@ class NotificationsService {
             return this.collectionReady$.asObservable();
         }
         return this.collectionReady$.pipe(switchMap(collection => {
-            if (!collection)
+            if (!collection) {
+                console.log('[Notifs] collectionWhenAuthReady$ — collection is null (not initialized)');
                 return of(null);
+            }
+            console.log('[Notifs] collectionWhenAuthReady$ — collection ready, awaiting Firebase Auth');
             return from(fb.whenFirebaseAuthReady()).pipe(map$1(() => collection));
         }));
     }
@@ -23810,6 +23823,7 @@ class NotificationsService {
      * un userId diferente al del usuario autenticado.
      */
     initialize(userId) {
+        console.log(`[Notifs] initialize uid=${userId}`);
         if (!this.collectionFactory) {
             console.warn('[Notifications] FirestoreCollectionFactory not available. Ensure provideValtechFirebase() is configured.');
             return;
@@ -23853,8 +23867,11 @@ class NotificationsService {
      */
     getAll(limit = DEFAULT_LIMIT) {
         return this.collectionWhenAuthReady$().pipe(switchMap(collection => {
-            if (!collection)
+            if (!collection) {
+                console.warn('[Notifs] getAll — collection null → returning EMPTY (no emission)');
                 return EMPTY;
+            }
+            console.log('[Notifs] getAll — attaching Firestore watchAll listener');
             return collection.watchAll({
                 orderBy: [{ field: 'createdAt', direction: 'desc' }],
                 limit,
@@ -24609,6 +24626,14 @@ class AuthService {
                 }
                 // 3. Iniciar timer de refresco proactivo
                 this.startRefreshTimer();
+                // 4. Re-establecer la sesión de Firebase en bootstrap.
+                // El access token sigue válido, así que NO pasamos por la rama de
+                // refresh — pero la persistencia IndexedDB propia de Firebase Auth no
+                // sobrevive el contenedor de storage de una PWA standalone en iOS.
+                // Sin esto, `firebaseAuthReady` se queda en `false` para siempre y
+                // cualquier listener Firestore (ej. el inbox de notificaciones) cuelga.
+                // Fire-and-forget: NO debe demorar el resolve de initialize().
+                void this.ensureFirebaseSessionOnBootstrap();
             }
             else if (storedState.refreshToken) {
                 // 4. Token expirado pero hay refresh token - intentar refrescar
@@ -25355,6 +25380,8 @@ class AuthService {
     // FIREBASE INTEGRATION
     // =============================================
     async signInWithFirebase(firebaseToken) {
+        console.log(`[FBAuth] auth flow → signInWithFirebase attempt tokenLen=${firebaseToken?.length ?? 0} ` +
+            `firebaseServicePresent=${!!this.firebaseService}`);
         try {
             if (this.firebaseService) {
                 await this.firebaseService.signInWithCustomToken(firebaseToken);
@@ -25383,6 +25410,43 @@ class AuthService {
             console.warn('[ValtechAuth] Firebase signout failed:', error);
         }
     }
+    /**
+     * Re-establece la sesión de Firebase Auth en el bootstrap de la app cuando
+     * el access token de la app sigue válido (la rama de initialize() que NO
+     * pasa por refresh).
+     *
+     * Firebase Auth mantiene su PROPIA sesión con persistencia IndexedDB
+     * independiente del storage de tokens de la app. En un navegador normal esa
+     * persistencia se auto-restaura sola; en una PWA standalone en iOS el
+     * contenedor de storage no sobrevive, y `firebaseAuthReady` se queda en
+     * `false` indefinidamente → los listeners Firestore cuelgan (~40s timeout).
+     *
+     * Estrategia: dar una ventana corta a la auto-restauración de Firebase y, si
+     * no ocurre, forzar un `refreshAccessToken()` — que ya hace `signInWithFirebase`
+     * con el `firebaseToken` que devuelve `/refresh`.
+     *
+     * Fire-and-forget: se invoca con `void` para no demorar `initialize()`.
+     */
+    async ensureFirebaseSessionOnBootstrap() {
+        if (!this.config.enableFirebaseIntegration || !this.firebaseService)
+            return;
+        // Dar a la persistencia IndexedDB propia de Firebase Auth una oportunidad
+        // de auto-restaurarse (navegador normal). En una PWA standalone de iOS
+        // normalmente NO lo hará.
+        await new Promise(r => setTimeout(r, 2500));
+        if (this.firebaseService.firebaseAuthReady()) {
+            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');
+        try {
+            // refreshAccessToken() ya llama signInWithFirebase() en éxito.
+            await firstValueFrom(this.refreshAccessToken());
+        }
+        catch (e) {
+            console.warn('[FBAuth] bootstrap — refresh to re-establish Firebase failed:', e);
+        }
+    }
     // =============================================
     // DEVICE REGISTRATION (Push Notifications)
     // =============================================
@@ -38521,8 +38585,18 @@ function createRefreshableStream(factory, options) {
     // sesión NUNCA se establece (token inválido, signInWithFirebase falló), el
     // gate igual se libera tras `authGateTimeoutMs` y la factory procede: si no
     // hay permiso terminará en estado `error`, jamás en skeleton infinito.
+    // Tag los dos inputs del `race` para distinguir en logs cuál ganó: la sesión
+    // de Firebase Auth (`auth-ready`) o el timeout de seguridad (`timeout`).
     const authGate$ = firebase
-        ? race(firebase.firebaseAuthReady$, timer(authGateTimeoutMs)).pipe(take(1))
+        ? race(firebase.firebaseAuthReady$.pipe(map$1(() => 'auth-ready')), timer(authGateTimeoutMs).pipe(map$1(() => 'timeout'))).pipe(take(1), tap(winner => {
+            if (winner === 'timeout') {
+                console.warn(`[RefreshStream] auth gate resolved by TIMEOUT after ${authGateTimeoutMs}ms ` +
+                    '(Firebase Auth session never confirmed)');
+            }
+            else {
+                console.log('[RefreshStream] auth gate resolved by firebaseAuthReady$ (session ready)');
+            }
+        }))
         : of(true);
     const data = toSignal(toObservable(_reload, { injector }).pipe(tap(() => {
         _loading.set(true);
@@ -38534,6 +38608,7 @@ function createRefreshableStream(factory, options) {
     switchMap(() => authGate$.pipe(switchMap(() => factory().pipe(tap(() => {
         _loading.set(false);
         _error.set(false);
+        console.log('[RefreshStream] factory emitted first value — loading=false');
     }), 
     // Backoff corto exponencial acotado — solo red de seguridad para
     // reconexiones transitorias, NO para cubrir cold start.
@@ -38546,9 +38621,10 @@ function createRefreshableStream(factory, options) {
     // silencio), `timeout` dispara un error → `catchError` → estado
     // `error`. Nunca skeleton perpetuo. Va DESPUÉS de `retry` para
     // que cuente el tiempo total, no por intento.
-    timeout({ first: firstEmitTimeoutMs }), catchError(() => {
+    timeout({ first: firstEmitTimeoutMs }), catchError(err => {
         _loading.set(false);
         _error.set(true);
+        console.error(`[RefreshStream] factory failed/timed out → error state: ${err instanceof Error ? err.message : String(err)}`);
         return of(fallback);
     })))))), { initialValue: null, injector });
     return {