valtech-components 2.0.798 → 2.0.800

package/fesm2022/valtech-components.mjs

@@ -52,7 +52,7 @@ import 'prismjs/components/prism-json';
  * Current version of valtech-components.
  * This is automatically updated during the publish process.
  */
-const VERSION = '2.0.798';
+const VERSION = '2.0.800';
 
 /**
  * Servicio para gestionar presets de componentes.
@@ -22598,6 +22598,15 @@ class MessagingService {
         });
         /** Key para localStorage de mensajes FCM (debugging) */
         this.DEBUG_STORAGE_KEY = 'fcm_debug_messages';
+        /**
+         * Key de localStorage donde se persiste el token FCM.
+         *
+         * El token vive en un `BehaviorSubject` en memoria y se pierde en cada
+         * recarga / suspensión de la PWA (iOS reinicia PWAs con frecuencia). Persistir
+         * el token permite hidratar el estado en cold start y que la UI no parpadee.
+         * Es un *optimistic hint* — la verdad la confirma el siguiente `getToken()`.
+         */
+        this.TOKEN_STORAGE_KEY = 'valtech_fcm_token';
         this.debugPersistence = this.config?.debugMessagePersistence ?? false;
         this.initializeMessaging();
     }
@@ -22637,6 +22646,10 @@ class MessagingService {
         if (!isPlatformBrowser(this.platformId)) {
             return;
         }
+        // Hidratar el token desde localStorage ANTES del check de soporte: el token
+        // cacheado es un hint optimista para la UI tras recargas / suspensiones de
+        // la PWA. La validez real se confirma en el próximo getToken().
+        this.hydrateTokenFromStorage();
         const supported = await this.checkSupport();
         const permission = this.getPermissionState();
         this.stateSubject.next({
@@ -22770,10 +22783,11 @@ class MessagingService {
             return null;
         }
         try {
-            // Registrar SW personalizado antes de obtener token
-            // Esto es necesario cuando usamos un SW custom (firebase-messaging-sw.js)
-            const registration = await navigator.serviceWorker.register('/firebase-messaging-sw.js');
-            console.log('[Messaging] SW registered, waiting ready...');
+            // Reutilizar el SW ya registrado (en config.ts durante el bootstrap) en
+            // lugar de re-registrarlo en cada llamada — re-registrar dispara
+            // revalidaciones del SW en iOS PWA. Solo registramos si no existe aún.
+            const registration = await this.resolveServiceWorkerRegistration();
+            console.log('[Messaging] SW resolved, waiting ready...');
             // Esperar a que el SW esté activo
             await navigator.serviceWorker.ready;
             console.log('[Messaging] SW ready, calling Firebase getToken()...');
@@ -22786,13 +22800,68 @@ class MessagingService {
                 ...this.stateSubject.value,
                 token,
             });
+            // Persistir el token para hidratar el estado en futuros cold starts.
+            this.persistToken(token);
             return token;
         }
         catch (error) {
-            console.error('[Messaging] getToken error:', error);
+            // No tragamos la causa: logueamos el detalle para diagnóstico. La firma
+            // sigue siendo Promise<string | null> para no romper callers.
+            const reason = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+            console.error('[Messaging] getToken error:', reason, error);
             return null;
         }
     }
+    /**
+     * Resuelve el `ServiceWorkerRegistration` del SW de FCM.
+     *
+     * El SW `/firebase-messaging-sw.js` ya se registra una vez en el bootstrap de
+     * la app (`config.ts`). Reutilizamos ese registro en lugar de re-registrarlo
+     * en cada `getToken()` — re-registrar repetidamente dispara revalidaciones del
+     * SW en iOS PWA. Solo registramos como fallback si todavía no existe.
+     */
+    async resolveServiceWorkerRegistration() {
+        const existing = await navigator.serviceWorker.getRegistration('/firebase-messaging-sw.js');
+        if (existing) {
+            return existing;
+        }
+        console.warn('[Messaging] SW not registered yet, registering as fallback');
+        return navigator.serviceWorker.register('/firebase-messaging-sw.js');
+    }
+    /**
+     * Persiste el token FCM en localStorage (o lo limpia si es null/empty).
+     */
+    persistToken(token) {
+        if (!isPlatformBrowser(this.platformId))
+            return;
+        try {
+            if (token) {
+                localStorage.setItem(this.TOKEN_STORAGE_KEY, token);
+            }
+            else {
+                localStorage.removeItem(this.TOKEN_STORAGE_KEY);
+            }
+        }
+        catch (e) {
+            console.warn('[Messaging] token persistence failed:', e);
+        }
+    }
+    /**
+     * Hidrata el estado del token desde localStorage en el arranque del servicio.
+     */
+    hydrateTokenFromStorage() {
+        if (!isPlatformBrowser(this.platformId))
+            return;
+        try {
+            const cached = localStorage.getItem(this.TOKEN_STORAGE_KEY);
+            if (cached) {
+                this.setTokenFromStorage(cached);
+            }
+        }
+        catch (e) {
+            console.warn('[Messaging] token hydration failed:', e);
+        }
+    }
     /**
      * Elimina el token FCM actual (unsubscribe de notificaciones).
      *
@@ -22813,6 +22882,8 @@ class MessagingService {
                 ...this.stateSubject.value,
                 token: null,
             });
+            // Limpiar el token persistido — ya no estamos suscritos.
+            this.persistToken(null);
             // Limpiar listener de mensajes
             if (this.unsubscribeOnMessage) {
                 this.unsubscribeOnMessage();
@@ -37283,6 +37354,16 @@ class PreferencesService {
         this.language = this._language.asReadonly();
         this.notificationsMaster = this._notificationsMaster.asReadonly();
         this.synced = this._synced.asReadonly();
+        /**
+         * `true` mientras un `update()` está en vuelo (PUT al backend).
+         *
+         * El listener Firestore (`bindToUser`) es real-time y puede emitir un snapshot
+         * *stale* — anterior al sync del backend — que pisaría el valor optimista de
+         * `_notificationsMaster` y revertiría el toggle. Mientras este flag esté `true`
+         * el listener ignora las emisiones; el `update()` ya alinea las señales con la
+         * respuesta del backend al terminar.
+         */
+        this._updateInFlight = false;
         const destroyRef = inject(DestroyRef);
         destroyRef.onDestroy(() => this.unbind());
         // Auto-bind al user actual. effect() corre en injection context (constructor OK).
@@ -37335,8 +37416,15 @@ class PreferencesService {
         if (partial.notifications && typeof partial.notifications.master === 'boolean') {
             this._notificationsMaster.set(partial.notifications.master);
         }
+        // Bloquear el listener Firestore mientras el PUT está en vuelo: un snapshot
+        // stale no debe pisar el valor optimista recién aplicado.
+        this._updateInFlight = true;
         try {
-            const res = await firstValueFrom(this.http.put(url, partial));
+            // Enviar appId explícito — el backend lo usa para escribir el mirror
+            // Firestore en apps/{appId}/... correcto, sin depender del header Origin
+            // (que en PWA iOS puede no resolver al AppID esperado).
+            const body = { ...partial, appId: this.config.appId };
+            const res = await firstValueFrom(this.http.put(url, body));
             // El listener Firestore es la fuente final, pero alinear ya con la
             // respuesta del backend acelera UX (especialmente si el listener
             // tarda en propagar).
@@ -37356,6 +37444,9 @@ class PreferencesService {
             this._notificationsMaster.set(prev.master);
             throw err;
         }
+        finally {
+            this._updateInFlight = false;
+        }
     }
     setTheme(theme) {
         return this.update({ theme });
@@ -37382,6 +37473,12 @@ class PreferencesService {
                 // pisan el theme/lang locales con valores arbitrarios.
                 return;
             }
+            // Ignorar emisiones del listener mientras hay un update() en vuelo: un
+            // snapshot stale (anterior al sync del backend) revertiría el valor
+            // optimista. El update() ya alinea las señales con la respuesta real.
+            if (this._updateInFlight) {
+                return;
+            }
             if (doc.theme)
                 this._theme.set(doc.theme);
             if (doc.language)