valtech-components 2.0.408 → 2.0.410

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

@@ -0,0 +1,254 @@
+import { Observable } from 'rxjs';
+import { NotificationAction, NotificationClickEvent, NotificationPayload, NotificationPermission } 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 messaging;
+    private config;
+    private platformId;
+    private ngZone;
+    private messageSubject;
+    private notificationClickSubject;
+    private stateSubject;
+    private unsubscribeOnMessage?;
+    constructor();
+    /**
+     * 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>;
+    /**
+     * 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;
+    /**
+     * 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.
+     *
+     * @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>;
+    /**
+     * 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;
+    /**
+     * 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/storage.service.d.ts

@@ -0,0 +1,204 @@
+import { Observable } from 'rxjs';
+import { StorageListResult, StorageMetadata, UploadProgress, UploadResult } from './types';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para Firebase Storage.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class FileUploadComponent {
+ *   private storage = inject(StorageService);
+ *
+ *   uploadProgress = signal<number>(0);
+ *   downloadUrl = signal<string | null>(null);
+ *
+ *   async onFileSelected(event: Event) {
+ *     const file = (event.target as HTMLInputElement).files?.[0];
+ *     if (!file) return;
+ *
+ *     // Upload con progreso
+ *     this.storage.upload(`uploads/${file.name}`, file).subscribe({
+ *       next: (progress) => this.uploadProgress.set(progress.percentage),
+ *       complete: async () => {
+ *         const url = await this.storage.getDownloadUrl(`uploads/${file.name}`);
+ *         this.downloadUrl.set(url);
+ *       }
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export declare class StorageService {
+    private storage;
+    /**
+     * Sube un archivo con tracking de progreso.
+     *
+     * @param path - Ruta en Storage donde guardar el archivo
+     * @param file - Archivo a subir (File o Blob)
+     * @param metadata - Metadata opcional (contentType, customMetadata)
+     * @returns Observable que emite el progreso y completa cuando termina
+     *
+     * @example
+     * ```typescript
+     * // Upload básico
+     * storage.upload('images/photo.jpg', file).subscribe({
+     *   next: (progress) => console.log(`${progress.percentage}%`),
+     *   complete: () => console.log('Upload completado')
+     * });
+     *
+     * // Con metadata
+     * storage.upload('docs/report.pdf', file, {
+     *   contentType: 'application/pdf',
+     *   customMetadata: { uploadedBy: 'user123' }
+     * }).subscribe(...);
+     * ```
+     */
+    upload(path: string, file: File | Blob, metadata?: StorageMetadata): Observable<UploadProgress>;
+    /**
+     * Sube un archivo y retorna la URL de descarga al completar.
+     *
+     * @param path - Ruta en Storage
+     * @param file - Archivo a subir
+     * @param metadata - Metadata opcional
+     * @returns Resultado del upload con URL de descarga
+     *
+     * @example
+     * ```typescript
+     * const result = await storage.uploadAndGetUrl('avatars/user123.jpg', file);
+     * console.log('URL:', result.downloadUrl);
+     * ```
+     */
+    uploadAndGetUrl(path: string, file: File | Blob, metadata?: StorageMetadata): Promise<UploadResult>;
+    /**
+     * Sube un archivo desde una Data URL (base64).
+     *
+     * @param path - Ruta en Storage
+     * @param dataUrl - Data URL (ej: 'data:image/png;base64,...')
+     * @param metadata - Metadata opcional
+     * @returns Resultado del upload
+     *
+     * @example
+     * ```typescript
+     * // Desde canvas
+     * const dataUrl = canvas.toDataURL('image/png');
+     * const result = await storage.uploadFromDataUrl('images/drawing.png', dataUrl);
+     * ```
+     */
+    uploadFromDataUrl(path: string, dataUrl: string, metadata?: StorageMetadata): Promise<UploadResult>;
+    /**
+     * Obtiene la URL de descarga de un archivo.
+     *
+     * @param path - Ruta del archivo en Storage
+     * @returns URL de descarga
+     *
+     * @example
+     * ```typescript
+     * const url = await storage.getDownloadUrl('images/photo.jpg');
+     * // Usar en <img [src]="url">
+     * ```
+     */
+    getDownloadUrl(path: string): Promise<string>;
+    /**
+     * Obtiene la metadata de un archivo.
+     *
+     * @param path - Ruta del archivo
+     * @returns Metadata del archivo
+     */
+    getMetadata(path: string): Promise<StorageMetadata & {
+        size: number;
+        name: string;
+    }>;
+    /**
+     * Elimina un archivo.
+     *
+     * @param path - Ruta del archivo a eliminar
+     *
+     * @example
+     * ```typescript
+     * await storage.delete('images/old-photo.jpg');
+     * ```
+     */
+    delete(path: string): Promise<void>;
+    /**
+     * Elimina múltiples archivos.
+     *
+     * @param paths - Array de rutas a eliminar
+     *
+     * @example
+     * ```typescript
+     * await storage.deleteMultiple([
+     *   'images/photo1.jpg',
+     *   'images/photo2.jpg'
+     * ]);
+     * ```
+     */
+    deleteMultiple(paths: string[]): Promise<void>;
+    /**
+     * Lista archivos en un directorio.
+     *
+     * @param path - Ruta del directorio
+     * @returns Lista de rutas de archivos
+     *
+     * @example
+     * ```typescript
+     * const result = await storage.list('images/');
+     * console.log(result.items); // ['images/photo1.jpg', 'images/photo2.jpg']
+     * ```
+     */
+    list(path: string): Promise<StorageListResult>;
+    /**
+     * Genera un nombre de archivo único con timestamp.
+     *
+     * @param originalName - Nombre original del archivo
+     * @param prefix - Prefijo opcional
+     * @returns Nombre único
+     *
+     * @example
+     * ```typescript
+     * const uniqueName = storage.generateFileName('photo.jpg', 'user123');
+     * // => 'user123_1703091234567_photo.jpg'
+     * ```
+     */
+    generateFileName(originalName: string, prefix?: string): string;
+    /**
+     * Genera una ruta única para un archivo.
+     *
+     * @param directory - Directorio base
+     * @param originalName - Nombre original
+     * @param prefix - Prefijo opcional
+     * @returns Ruta completa única
+     *
+     * @example
+     * ```typescript
+     * const path = storage.generatePath('uploads', 'photo.jpg', 'user123');
+     * // => 'uploads/user123_1703091234567_photo.jpg'
+     * ```
+     */
+    generatePath(directory: string, originalName: string, prefix?: string): string;
+    /**
+     * Obtiene la extensión de un archivo.
+     *
+     * @param filename - Nombre del archivo
+     * @returns Extensión (sin el punto)
+     */
+    getExtension(filename: string): string;
+    /**
+     * Verifica si un archivo es una imagen basándose en su extensión.
+     */
+    isImage(filename: string): boolean;
+    /**
+     * Verifica si un archivo es un documento.
+     */
+    isDocument(filename: string): boolean;
+    /**
+     * Mapea el estado de la tarea de upload
+     */
+    private mapTaskState;
+    /**
+     * Convierte errores de Storage a mensajes en español
+     */
+    private getErrorMessage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
+}