valtech-components 2.0.820 → 2.0.821

package/lib/services/firebase/messaging.service.d.ts

@@ -1,341 +0,0 @@
-/**
- * Messaging Service (FCM)
- *
- * Servicio para Firebase Cloud Messaging (Push Notifications).
- * Permite solicitar permisos, obtener tokens, escuchar mensajes y manejar
- * navegación (deep linking) cuando el usuario toca una notificación.
- */
-import { Injector, NgZone } from '@angular/core';
-import { Observable } from 'rxjs';
-import { NotificationAction, NotificationClickEvent, NotificationPayload, NotificationPermission, ValtechFirebaseConfig } from './types';
-import * as i0 from "@angular/core";
-/**
- * Estado interno del servicio de messaging
- */
-interface MessagingState {
-    token: string | null;
-    permission: NotificationPermission;
-    isSupported: boolean;
-}
-/**
- * Servicio para Firebase Cloud Messaging (FCM).
- *
- * Permite recibir notificaciones push en la aplicación web.
- * Requiere VAPID key configurada en ValtechFirebaseConfig.
- *
- * @example
- * ```typescript
- * @Component({...})
- * export class NotificationComponent {
- *   private messaging = inject(MessagingService);
- *
- *   token = signal<string | null>(null);
- *
- *   async enableNotifications() {
- *     // Solicitar permiso y obtener token
- *     const token = await this.messaging.requestPermission();
- *
- *     if (token) {
- *       this.token.set(token);
- *       // Enviar token a tu backend para almacenarlo
- *       await this.backend.registerDeviceToken(token);
- *     }
- *   }
- *
- *   // Escuchar mensajes en foreground
- *   messages$ = this.messaging.onMessage();
- * }
- * ```
- */
-export declare class MessagingService {
-    private injector;
-    private config;
-    private platformId;
-    private ngZone;
-    private messageSubject;
-    private notificationClickSubject;
-    private stateSubject;
-    private unsubscribeOnMessage?;
-    /** Flag para persistir mensajes FCM en localStorage (debugging) */
-    private readonly debugPersistence;
-    /** Key para localStorage de mensajes FCM (debugging) */
-    private readonly DEBUG_STORAGE_KEY;
-    /**
-     * 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()`.
-     */
-    private readonly TOKEN_STORAGE_KEY;
-    constructor(injector: Injector, config: ValtechFirebaseConfig, platformId: Object, ngZone: NgZone);
-    /**
-     * Obtiene la instancia de Messaging via Firebase SDK directo (NO AngularFire DI).
-     *
-     * **Por qué no usamos `injector.get(Messaging)`:**
-     * AngularFire `provideMessaging` registra un APP_INITIALIZER que internamente
-     * resuelve `await isSupported()`. Si `injector.get(Messaging)` se llama antes
-     * que ese APP_INITIALIZER termine (ej. otros APP_INITIALIZER del cliente
-     * construyen AuthService → MessagingService → toca Messaging temprano),
-     * AngularFire lanza el error "APP_INITIALIZER ... has not resolved". Angular
-     * DI **cachea errores de factory** — una vez que falló, todos los
-     * `injector.get` siguientes retornan el mismo error cacheado. Retry loops
-     * no funcionan.
-     *
-     * **Workaround:** bypass AngularFire entirely y usar Firebase SDK directo
-     * (`firebase/messaging.getMessaging(getApp())`). AngularFire es un wrapper
-     * sobre el mismo SDK — la instancia que obtenemos es funcionalmente idéntica.
-     * `getApp()` retorna la default Firebase app inicializada por
-     * `provideFirebaseApp(() => initializeApp(config.firebase))`. Si por alguna
-     * razón no está inicializada aún, hacemos initializeApp idempotente.
-     */
-    private fcmSupportPromise?;
-    private getMessagingInstance;
-    /**
-     * Inicializa el servicio de messaging
-     */
-    private initializeMessaging;
-    /**
-     * Configura listener para mensajes del Service Worker.
-     * Recibe eventos cuando el usuario hace click en una notificación background.
-     */
-    private setupServiceWorkerListener;
-    /**
-     * Verifica si FCM está soportado en el navegador actual
-     */
-    private checkSupport;
-    /**
-     * Solicita permiso de notificaciones y obtiene el token FCM.
-     *
-     * @returns Token FCM si se otorgó permiso, null si se denegó
-     *
-     * @example
-     * ```typescript
-     * const token = await messaging.requestPermission();
-     * if (token) {
-     *   console.log('Token FCM:', token);
-     *   // Enviar a backend
-     * } else {
-     *   console.log('Permiso denegado o no soportado');
-     * }
-     * ```
-     */
-    requestPermission(): Promise<string | null>;
-    /**
-     * Obtiene el token FCM actual (sin solicitar permiso).
-     *
-     * @returns Token FCM si está disponible, null si no
-     *
-     * @example
-     * ```typescript
-     * const token = await messaging.getToken();
-     * ```
-     */
-    getToken(): Promise<string | 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.
-     */
-    private resolveServiceWorkerRegistration;
-    /**
-     * Persiste el token FCM en localStorage (o lo limpia si es null/empty).
-     */
-    private persistToken;
-    /**
-     * Hidrata el estado del token desde localStorage en el arranque del servicio.
-     */
-    private hydrateTokenFromStorage;
-    /**
-     * Elimina el token FCM actual (unsubscribe de notificaciones).
-     *
-     * @example
-     * ```typescript
-     * await messaging.deleteToken();
-     * console.log('Token eliminado, no recibirá más notificaciones');
-     * ```
-     */
-    deleteToken(): Promise<void>;
-    /**
-     * Observable de mensajes recibidos en foreground.
-     *
-     * IMPORTANTE: Los mensajes en background son manejados por el Service Worker.
-     *
-     * @returns Observable que emite cuando llega un mensaje en foreground
-     *
-     * @example
-     * ```typescript
-     * messaging.onMessage().subscribe(payload => {
-     *   console.log('Mensaje recibido:', payload);
-     *   // Mostrar notificación custom o actualizar UI
-     * });
-     * ```
-     */
-    onMessage(): Observable<NotificationPayload>;
-    /**
-     * Configura el listener de mensajes en foreground
-     */
-    private setupMessageListener;
-    /**
-     * Persiste un mensaje FCM en localStorage para debugging.
-     * Solo se usa cuando debugMessagePersistence está habilitado.
-     * Mantiene los últimos 50 mensajes.
-     */
-    private persistMessageForDebug;
-    /**
-     * Obtiene el estado actual del permiso de notificaciones.
-     *
-     * @returns 'granted' | 'denied' | 'default'
-     *
-     * @example
-     * ```typescript
-     * const permission = messaging.getPermissionState();
-     * if (permission === 'granted') {
-     *   // Ya tiene permiso
-     * } else if (permission === 'default') {
-     *   // Puede solicitar permiso
-     * } else {
-     *   // Denegado, debe habilitar manualmente
-     * }
-     * ```
-     */
-    getPermissionState(): NotificationPermission;
-    /**
-     * Verifica si FCM está soportado en el navegador actual.
-     * Usa lógica inteligente para evitar falsos negativos por timing del Injector.
-     *
-     * @returns true si FCM está soportado
-     *
-     * @example
-     * ```typescript
-     * if (await messaging.isSupported()) {
-     *   // Puede usar notificaciones push
-     * } else {
-     *   // Navegador no soporta o no tiene Service Worker
-     * }
-     * ```
-     */
-    isSupported(): Promise<boolean>;
-    /**
-     * iOS sin estar instalado como PWA standalone — push web no disponible.
-     * Aplica a Safari y a Edge/Chrome/Firefox en iOS (todos WebKit por mandato Apple).
-     */
-    private isIOSWithoutStandalone;
-    /**
-     * Obtiene el token actual sin hacer request.
-     *
-     * @returns Token almacenado o null
-     */
-    get currentToken(): string | null;
-    /**
-     * Observable del estado completo del servicio de messaging.
-     */
-    get state$(): Observable<MessagingState>;
-    /**
-     * Verifica si el usuario ya otorgó permiso de notificaciones.
-     */
-    get hasPermission(): boolean;
-    /**
-     * Hidrata el estado del token desde un valor externo (ej: localStorage).
-     * Útil cuando el token ya existe pero el MessagingService no lo tiene en memoria.
-     *
-     * @param token Token FCM a setear
-     *
-     * @example
-     * ```typescript
-     * const storedToken = localStorage.getItem('fcm_token');
-     * if (storedToken) {
-     *   messaging.setTokenFromStorage(storedToken);
-     * }
-     * ```
-     */
-    setTokenFromStorage(token: string): void;
-    /**
-     * Observable de clicks en notificaciones.
-     *
-     * Emite cuando el usuario hace click en una notificación (foreground o background).
-     * Usa este observable para navegar a la página correspondiente.
-     *
-     * @returns Observable que emite NotificationClickEvent
-     *
-     * @example
-     * ```typescript
-     * @Component({...})
-     * export class AppComponent {
-     *   private messaging = inject(MessagingService);
-     *   private router = inject(Router);
-     *
-     *   constructor() {
-     *     this.messaging.onNotificationClick().subscribe(event => {
-     *       if (event.action.route) {
-     *         this.router.navigate([event.action.route], {
-     *           queryParams: event.action.queryParams
-     *         });
-     *       }
-     *     });
-     *   }
-     * }
-     * ```
-     */
-    onNotificationClick(): Observable<NotificationClickEvent>;
-    /**
-     * Extrae la acción de navegación de los datos de una notificación.
-     *
-     * Busca campos específicos en el payload de datos:
-     * - `route`: Ruta interna de la app (ej: '/orders/123')
-     * - `url`: URL externa (ej: 'https://example.com')
-     * - `action_type`: Tipo de acción personalizada
-     * - Campos con prefijo `action_`: Datos adicionales
-     *
-     * @param data - Datos del payload de la notificación
-     * @returns Acción de navegación extraída
-     *
-     * @example
-     * ```typescript
-     * // Payload desde el backend:
-     * // { route: '/orders/123', action_type: 'view_order', action_orderId: '123' }
-     *
-     * const action = messaging.extractActionFromData(notification.data);
-     * // { route: '/orders/123', actionType: 'view_order', actionData: { orderId: '123' } }
-     * ```
-     */
-    extractActionFromData(data?: Record<string, string>): NotificationAction;
-    /**
-     * Emite manualmente un evento de click en notificación.
-     *
-     * Útil para manejar clicks en notificaciones foreground donde
-     * la app decide mostrar un banner custom.
-     *
-     * @param notification - Payload de la notificación
-     *
-     * @example
-     * ```typescript
-     * messaging.onMessage().subscribe(notification => {
-     *   // Mostrar banner custom
-     *   this.showBanner(notification, () => {
-     *     // Usuario hizo click en el banner
-     *     messaging.handleNotificationClick(notification);
-     *   });
-     * });
-     * ```
-     */
-    handleNotificationClick(notification: NotificationPayload): void;
-    /**
-     * Verifica si una notificación tiene acción de navegación.
-     *
-     * @param data - Datos del payload
-     * @returns true si tiene route o url
-     */
-    hasNavigationAction(data?: Record<string, string>): boolean;
-    /**
-     * Parsea un query string en un objeto.
-     */
-    private parseQueryString;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MessagingService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<MessagingService>;
-}
-export {};

package/lib/services/firebase/notifications.service.d.ts

@@ -1,158 +0,0 @@
-/**
- * Notifications Service
- *
- * Servicio para leer notificaciones desde Firestore.
- * El backend escribe las notificaciones, el frontend solo las lee y actualiza estado.
- *
- * Se auto-inicializa cuando AuthService tiene un usuario autenticado.
- * También puede inicializarse manualmente con `initialize(userId)`.
- */
-import { Injector } from '@angular/core';
-import { Observable } from 'rxjs';
-import { FirestoreCollectionFactory } from './firestore-collection';
-import { FirestoreDocument } from './types';
-import * as i0 from "@angular/core";
-/**
- * Documento de notificación en Firestore.
- * Estructura escrita por el backend.
- */
-export interface NotificationDocument extends FirestoreDocument {
-    /** Título de la notificación */
-    title?: string;
-    /** Cuerpo del mensaje */
-    body?: string;
-    /** URL de imagen */
-    image?: string;
-    /** Datos personalizados (ej: route, actionType). Legacy — preferir actionRoute + payload */
-    data?: Record<string, string>;
-    /** Tipo de notificación */
-    type?: 'fcm' | 'system' | 'reminder' | string;
-    /** Si la notificación fue leída */
-    isRead: boolean;
-    /** AppID origen (ej: 'showcase', 'sigify'). Permite cross-app routing */
-    appId?: string;
-    /** OrgID asociado (si la notif es org-scoped). Habilita switch-org al abrir */
-    orgId?: string;
-    /** Route destino al click (ej: '/app/docs/123') */
-    actionRoute?: string;
-    /** Payload estructurado para acciones (reemplazo tipado de `data`) */
-    payload?: Record<string, unknown>;
-}
-/**
- * Servicio para leer notificaciones desde Firestore.
- *
- * Se auto-inicializa cuando AuthService tiene un usuario autenticado.
- * No requiere llamar a `initialize()` manualmente si AuthService está configurado.
- *
- * @example
- * ```typescript
- * // Con AuthService configurado: auto-inicialización
- * // Solo inyectar y usar directamente
- * private notifications = inject(NotificationsService);
- *
- * notifications$ = this.notifications.getAll();
- * unreadCount$ = this.notifications.getUnreadCount();
- *
- * // Sin AuthService: inicialización manual
- * this.notifications.initialize(userId);
- * ```
- */
-export declare class NotificationsService {
-    private injector;
-    private collectionFactory;
-    private collection;
-    private currentUserId;
-    private collectionReady$;
-    private authService;
-    private firebaseService;
-    constructor(injector: Injector, collectionFactory: FirestoreCollectionFactory);
-    /**
-     * Gate de Firebase Auth: emite la colección lista SOLO cuando la sesión de
-     * Firebase Auth está confirmada. Sin FirebaseService disponible, no gatea
-     * (degrada al comportamiento previo). Espera a que `firebaseAuthReady$`
-     * emita antes de propagar la colección — así el listener Firestore nunca se
-     * adjunta antes de que `request.auth` esté disponible.
-     */
-    private collectionWhenAuthReady$;
-    /**
-     * Configura auto-inicialización observando el estado de AuthService.
-     * Se ejecuta en el contexto del injector para poder usar effect().
-     */
-    private setupAutoInitialization;
-    /**
-     * Inicializa el servicio para un usuario específico.
-     *
-     * NOTA: Se llama automáticamente si AuthService está configurado.
-     * Solo usar manualmente si AuthService no está disponible o se necesita
-     * un userId diferente al del usuario autenticado.
-     */
-    initialize(userId: string): void;
-    /**
-     * Verifica si el servicio está inicializado.
-     */
-    get isReady(): boolean;
-    /**
-     * Obtiene el ID del usuario actual.
-     */
-    get userId(): string | null;
-    /**
-     * Obtiene notificaciones ordenadas por fecha descendente (real-time).
-     * Se actualiza automáticamente cuando cambian los datos.
-     *
-     * El listener Firestore NO se adjunta hasta que la sesión de Firebase Auth
-     * esté confirmada (`FirebaseService.firebaseAuthReady`). Esto cierra la
-     * ventana de `permission-denied` en cold start de PWA, donde el JWT del
-     * backend puede estar listo antes que la sesión de Firebase Auth.
-     *
-     * @param limit - Máximo de notificaciones a cargar (default: 50)
-     */
-    getAll(limit?: number): Observable<NotificationDocument[]>;
-    /**
-     * Obtiene notificaciones (one-time fetch sin listener).
-     * Útil para cargas iniciales sin necesidad de updates en tiempo real.
-     *
-     * @param limit - Máximo de notificaciones a cargar (default: 50)
-     */
-    getAllOnce(limit?: number): Promise<NotificationDocument[]>;
-    /**
-     * Obtiene solo notificaciones no leídas (real-time, filtrado server-side).
-     *
-     * @param limit - Máximo de notificaciones (default: 50)
-     */
-    getUnread(limit?: number): Observable<NotificationDocument[]>;
-    /**
-     * Cuenta notificaciones no leídas usando server-side aggregation query.
-     * No descarga documentos — eficiente para badges en UI.
-     *
-     * Gateado por `firebaseAuthReady` — la aggregation query no se ejecuta hasta
-     * que la sesión de Firebase Auth esté lista.
-     */
-    getUnreadCount(): Observable<number>;
-    /**
-     * Obtiene una notificación por ID.
-     */
-    getById(notificationId: string): Promise<NotificationDocument | null>;
-    /**
-     * Marca una notificación como leída.
-     */
-    markAsRead(notificationId: string): Promise<void>;
-    /**
-     * Marca todas las notificaciones no leídas como leídas (batch write).
-     */
-    markAllAsRead(): Promise<void>;
-    /**
-     * Elimina una notificación.
-     */
-    delete(notificationId: string): Promise<void>;
-    /**
-     * Elimina todas las notificaciones del usuario (batch delete).
-     */
-    deleteAll(): Promise<void>;
-    /**
-     * Limpia el estado del servicio.
-     * Útil para logout.
-     */
-    reset(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationsService, [null, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationsService>;
-}

package/lib/services/firebase/shared-config.d.ts

@@ -1,151 +0,0 @@
-/**
- * Firebase Shared Configuration
- *
- * Utilidades genéricas para configuración de Firebase.
- * Las constantes específicas del proyecto (APP_IDS, FIREBASE_PROJECTS, EMULATOR_CONFIG)
- * deben definirse en cada app consumidora.
- */
-import { AppId, EmulatorConfig, FirebaseConfig, ValtechFirebaseConfig } from './types';
-import type { AnalyticsConfig } from './analytics-types';
-export type { AppId } from './types';
-/**
- * Genera paths de Storage alineados con storage.rules.
- *
- * Convenciones (ver frontend/firebase/storage.rules):
- * - Avatar global del user (cross-app): /users/{uid}/avatar.jpg
- * - Files privados del user (cross-app): /users/{uid}/files/{path}
- * - Avatar per-app del user: /apps/{appId}/users/{uid}/avatar.jpg
- * - Files per-app del user: /apps/{appId}/users/{uid}/files/{path}
- * - Public per-app: /apps/{appId}/public/{path}
- * - Shared per-app (auth-only): /apps/{appId}/shared/{path}
- * - Public global: /public/{path}
- *
- * @example
- * storagePaths.forApp('showcase', 'public', 'banner.jpg')
- * // => 'apps/showcase/public/banner.jpg'
- *
- * storagePaths.userAvatar('user123')
- * // => 'users/user123/avatar.jpg'
- *
- * storagePaths.appUserFile('showcase', 'user123', 'doc.pdf')
- * // => 'apps/showcase/users/user123/files/doc.pdf'
- */
-export declare const storagePaths: {
-    /** Path per-app: apps/{appId}/{...paths} */
-    forApp: (appId: AppId, ...paths: string[]) => string;
-    /** Avatar global del user (cross-app) */
-    userAvatar: (userId: string) => string;
-    /** Thumbnail global del user (cross-app) */
-    userThumb: (userId: string) => string;
-    /** File privado global del user (cross-app) */
-    userFile: (userId: string, ...paths: string[]) => string;
-    /** Avatar per-app del user */
-    appUserAvatar: (appId: AppId, userId: string) => string;
-    /** File per-app del user */
-    appUserFile: (appId: AppId, userId: string, ...paths: string[]) => string;
-    /** Public global (acceso sin auth, write admin-only) */
-    public: (...paths: string[]) => string;
-};
-/**
- * Genera paths de colecciones alineados con firestore.rules.
- *
- * Convenciones (ver frontend/firebase/firestore.rules):
- * - Cross-app shared:
- *   /users/{uid} (privado), /profiles/{uid} (público global),
- *   /users/{uid}/notifications (INBOX GLOBAL cross-app cross-org)
- * - Per-app:
- *   /apps/{appId}/{collection}, /apps/{appId}/profiles/{uid}
- * - Per-app per-user (notifications NO viven aquí):
- *   /apps/{appId}/users/{uid}/{collection}
- * - Per-app per-org:
- *   /apps/{appId}/orgs/{orgId}/{collection}
- *
- * @example
- * collections.forApp('showcase', 'items')
- * // => 'apps/showcase/items'
- *
- * collections.appUser('showcase', 'user123', 'drafts')
- * // => 'apps/showcase/users/user123/drafts'
- *
- * collections.appOrg('showcase', 'org_abc', 'posts')
- * // => 'apps/showcase/orgs/org_abc/posts'
- *
- * collections.userNotifications('user123')
- * // => 'users/user123/notifications'
- */
-export declare const collections: {
-    /** Per-app cross-user: apps/{appId}/{collection} */
-    forApp: (appId: AppId, collectionName: string) => string;
-    /** Per-app per-user: apps/{appId}/users/{uid}/{collection} */
-    appUser: (appId: AppId, userId: string, collectionName: string) => string;
-    /** Per-app per-org: apps/{appId}/orgs/{orgId}/{collection} */
-    appOrg: (appId: AppId, orgId: string, collectionName: string) => string;
-    /** Per-app perfil público del user: apps/{appId}/profiles/{uid} */
-    appProfile: (appId: AppId, userId: string) => string;
-    /** Inbox global del user (cross-app cross-org) */
-    userNotifications: (userId: string) => string;
-    /** Cross-app shared (sin namespace, nivel raíz) */
-    shared: {
-        /** Doc privado del user — /users/{uid} */
-        users: string;
-        /** Perfiles públicos globales — /profiles/{uid} */
-        profiles: string;
-    };
-};
-/**
- * Opciones para crear la configuración de Firebase
- */
-export interface CreateFirebaseConfigOptions {
-    /**
-     * Configuración de emuladores (para desarrollo local).
-     * Pasa tu propia configuración con hosts y puertos.
-     */
-    emulator?: EmulatorConfig;
-    /** Habilitar persistencia offline de Firestore */
-    persistence?: boolean;
-    /**
-     * ID de la aplicación para namespacing automático.
-     * Cuando se configura, FirestoreService y StorageService prefijan automáticamente los paths.
-     */
-    appId?: string;
-    /**
-     * Habilitar Firebase Analytics / GA4.
-     * Requiere measurementId en firebase config.
-     */
-    enableAnalytics?: boolean;
-    /**
-     * Configuración detallada de Analytics.
-     * Solo aplica si enableAnalytics es true.
-     */
-    analyticsConfig?: AnalyticsConfig;
-}
-/**
- * Crea la configuración completa de Firebase desde variables de entorno.
- * Usa esto en el environment.ts de cada app.
- *
- * @example
- * // environment.ts
- * import { createFirebaseConfig } from 'valtech-components';
- * import { APP_IDS, EMULATOR_CONFIG, USE_EMULATORS } from '../config/app-config';
- * import firebaseConfig from '../config/firebase.config.json';
- *
- * export const environment = {
- *   valtechFirebase: createFirebaseConfig(
- *     {
- *       ...firebaseConfig,
- *       enableMessaging: true,
- *       messagingVapidKey: 'BHLx...',
- *     },
- *     {
- *       emulator: USE_EMULATORS ? EMULATOR_CONFIG : undefined,
- *       persistence: true,
- *       appId: APP_IDS.MY_APP,
- *     }
- *   ),
- * };
- */
-export declare function createFirebaseConfig(config: FirebaseConfig, options?: CreateFirebaseConfigOptions): ValtechFirebaseConfig;
-/**
- * Verifica si la configuración tiene emuladores habilitados
- */
-export declare function isEmulatorMode(config: ValtechFirebaseConfig): boolean;