valtech-components 2.0.687 → 2.0.689

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

@@ -1,312 +0,0 @@
-import { Firestore, FieldValue } from '@angular/fire/firestore';
-import { Observable } from 'rxjs';
-import { FirestoreDocument, PaginatedResult, QueryOptions } from './types';
-import * as i0 from "@angular/core";
-/**
- * Servicio para operaciones CRUD en Firestore.
- *
- * @example
- * ```typescript
- * interface User extends FirestoreDocument {
- *   name: string;
- *   email: string;
- *   role: 'admin' | 'user';
- * }
- *
- * @Component({...})
- * export class UsersComponent {
- *   private firestore = inject(FirestoreService);
- *
- *   // Lectura one-time
- *   async loadUser(id: string) {
- *     const user = await this.firestore.getDoc<User>('users', id);
- *   }
- *
- *   // Subscripción real-time
- *   users$ = this.firestore.collectionChanges<User>('users', {
- *     where: [{ field: 'role', operator: '==', value: 'admin' }],
- *     orderBy: [{ field: 'name', direction: 'asc' }]
- *   });
- *
- *   // Crear documento
- *   async createUser(data: Omit<User, 'id'>) {
- *     const user = await this.firestore.addDoc<User>('users', data);
- *   }
- * }
- * ```
- */
-export declare class FirestoreService {
-    private firestore;
-    private config;
-    constructor(firestore: Firestore);
-    /**
-     * Prefija el path de colección con el appId si está configurado.
-     * Si no hay appId, retorna el path sin modificar (backward compatible).
-     *
-     * @internal
-     */
-    private prefixCollectionPath;
-    /**
-     * Obtiene un documento por ID (lectura única).
-     *
-     * @param collectionPath - Ruta de la colección
-     * @param docId - ID del documento
-     * @returns Documento o null si no existe
-     *
-     * @example
-     * ```typescript
-     * const user = await firestoreService.getDoc<User>('users', 'abc123');
-     * if (user) {
-     *   console.log(user.name);
-     * }
-     * ```
-     */
-    getDoc<T extends FirestoreDocument>(collectionPath: string, docId: string): Promise<T | null>;
-    /**
-     * Obtiene múltiples documentos con opciones de query.
-     *
-     * @param collectionPath - Ruta de la colección
-     * @param options - Opciones de query (where, orderBy, limit)
-     * @returns Array de documentos
-     *
-     * @example
-     * ```typescript
-     * // Todos los usuarios activos ordenados por nombre
-     * const users = await firestoreService.getDocs<User>('users', {
-     *   where: [{ field: 'active', operator: '==', value: true }],
-     *   orderBy: [{ field: 'name', direction: 'asc' }],
-     *   limit: 50
-     * });
-     * ```
-     */
-    getDocs<T extends FirestoreDocument>(collectionPath: string, options?: QueryOptions): Promise<T[]>;
-    /**
-     * Obtiene documentos con paginación basada en cursores.
-     *
-     * @param collectionPath - Ruta de la colección
-     * @param options - Opciones de query (debe incluir limit)
-     * @returns Resultado paginado con cursor para la siguiente página
-     *
-     * @example
-     * ```typescript
-     * // Primera página
-     * const page1 = await firestoreService.getPaginated<User>('users', {
-     *   orderBy: [{ field: 'createdAt', direction: 'desc' }],
-     *   limit: 10
-     * });
-     *
-     * // Siguiente página
-     * if (page1.hasMore) {
-     *   const page2 = await firestoreService.getPaginated<User>('users', {
-     *     orderBy: [{ field: 'createdAt', direction: 'desc' }],
-     *     limit: 10,
-     *     startAfter: page1.lastDoc
-     *   });
-     * }
-     * ```
-     */
-    getPaginated<T extends FirestoreDocument>(collectionPath: string, options: QueryOptions & {
-        limit: number;
-    }): Promise<PaginatedResult<T>>;
-    /**
-     * Verifica si un documento existe.
-     *
-     * @param collectionPath - Ruta de la colección
-     * @param docId - ID del documento
-     * @returns true si el documento existe
-     */
-    exists(collectionPath: string, docId: string): Promise<boolean>;
-    /**
-     * Suscribe a cambios de un documento (real-time).
-     *
-     * @param collectionPath - Ruta de la colección
-     * @param docId - ID del documento
-     * @returns Observable que emite cuando el documento cambia
-     *
-     * @example
-     * ```typescript
-     * // En el componente
-     * user$ = this.firestoreService.docChanges<User>('users', this.userId);
-     *
-     * // En el template
-     * @if (user$ | async; as user) {
-     *   <p>{{ user.name }}</p>
-     * }
-     * ```
-     */
-    docChanges<T extends FirestoreDocument>(collectionPath: string, docId: string): Observable<T | null>;
-    /**
-     * Suscribe a cambios de una colección (real-time).
-     *
-     * @param collectionPath - Ruta de la colección
-     * @param options - Opciones de query
-     * @returns Observable que emite cuando la colección cambia
-     *
-     * @example
-     * ```typescript
-     * // Usuarios activos en tiempo real
-     * activeUsers$ = this.firestoreService.collectionChanges<User>('users', {
-     *   where: [{ field: 'status', operator: '==', value: 'online' }]
-     * });
-     * ```
-     */
-    collectionChanges<T extends FirestoreDocument>(collectionPath: string, options?: QueryOptions): Observable<T[]>;
-    /**
-     * Agrega un documento con ID auto-generado.
-     *
-     * @param collectionPath - Ruta de la colección
-     * @param data - Datos del documento (sin id, createdAt, updatedAt)
-     * @returns Documento creado con su ID
-     *
-     * @example
-     * ```typescript
-     * const newUser = await firestoreService.addDoc<User>('users', {
-     *   name: 'John Doe',
-     *   email: 'john@example.com',
-     *   role: 'user'
-     * });
-     * console.log('Created user with ID:', newUser.id);
-     * ```
-     */
-    addDoc<T extends FirestoreDocument>(collectionPath: string, data: Omit<T, 'id' | 'createdAt' | 'updatedAt'>): Promise<T>;
-    /**
-     * Crea o sobrescribe un documento con ID específico.
-     *
-     * @param collectionPath - Ruta de la colección
-     * @param docId - ID del documento
-     * @param data - Datos del documento
-     * @param options - Opciones (merge: true para merge en lugar de sobrescribir)
-     *
-     * @example
-     * ```typescript
-     * // Sobrescribir completamente
-     * await firestoreService.setDoc<User>('users', 'user123', userData);
-     *
-     * // Merge con datos existentes
-     * await firestoreService.setDoc<User>('users', 'user123', { name: 'New Name' }, { merge: true });
-     * ```
-     */
-    setDoc<T extends FirestoreDocument>(collectionPath: string, docId: string, data: Omit<T, 'id'>, options?: {
-        merge?: boolean;
-    }): Promise<void>;
-    /**
-     * Actualiza campos específicos de un documento.
-     *
-     * @param collectionPath - Ruta de la colección
-     * @param docId - ID del documento
-     * @param data - Campos a actualizar
-     *
-     * @example
-     * ```typescript
-     * await firestoreService.updateDoc<User>('users', 'user123', {
-     *   name: 'Updated Name',
-     *   lastLogin: new Date()
-     * });
-     * ```
-     */
-    updateDoc<T extends FirestoreDocument>(collectionPath: string, docId: string, data: Partial<Omit<T, 'id' | 'createdAt'>>): Promise<void>;
-    /**
-     * Elimina un documento.
-     *
-     * @param collectionPath - Ruta de la colección
-     * @param docId - ID del documento
-     *
-     * @example
-     * ```typescript
-     * await firestoreService.deleteDoc('users', 'user123');
-     * ```
-     */
-    deleteDoc(collectionPath: string, docId: string): Promise<void>;
-    /**
-     * Ejecuta múltiples operaciones de escritura de forma atómica.
-     *
-     * @param operations - Función que recibe el batch y agrega operaciones
-     *
-     * @example
-     * ```typescript
-     * await firestoreService.batch((batch) => {
-     *   batch.set('users/user1', { name: 'User 1' });
-     *   batch.update('users/user2', { status: 'inactive' });
-     *   batch.delete('users/user3');
-     * });
-     * ```
-     */
-    batch(operations: (batch: {
-        set: <T>(path: string, data: T) => void;
-        update: <T>(path: string, data: Partial<T>) => void;
-        delete: (path: string) => void;
-    }) => void): Promise<void>;
-    /**
-     * Construye una ruta a partir de un template.
-     *
-     * @param template - Template con placeholders {param}
-     * @param params - Valores para los placeholders
-     * @returns Ruta construida
-     *
-     * @example
-     * ```typescript
-     * const path = firestoreService.buildPath('users/{userId}/documents/{docId}', {
-     *   userId: 'user123',
-     *   docId: 'doc456'
-     * });
-     * // => 'users/user123/documents/doc456'
-     * ```
-     */
-    buildPath(template: string, params: Record<string, string>): string;
-    /**
-     * Genera un ID único para un documento (sin crearlo).
-     *
-     * @param collectionPath - Ruta de la colección
-     * @returns ID único generado por Firestore
-     */
-    generateId(collectionPath: string): string;
-    /**
-     * Retorna un valor de timestamp del servidor.
-     * Usar en campos de fecha para que Firestore asigne el timestamp.
-     */
-    serverTimestamp(): FieldValue;
-    /**
-     * Retorna un valor para agregar elementos a un array.
-     *
-     * @example
-     * ```typescript
-     * await firestoreService.updateDoc('users', 'user123', {
-     *   tags: firestoreService.arrayUnion('new-tag')
-     * });
-     * ```
-     */
-    arrayUnion(...elements: unknown[]): FieldValue;
-    /**
-     * Retorna un valor para remover elementos de un array.
-     */
-    arrayRemove(...elements: unknown[]): FieldValue;
-    /**
-     * Retorna un valor para incrementar un campo numérico.
-     *
-     * @example
-     * ```typescript
-     * await firestoreService.updateDoc('users', 'user123', {
-     *   loginCount: firestoreService.increment(1)
-     * });
-     * ```
-     */
-    increment(n: number): FieldValue;
-    /**
-     * Construye los QueryConstraints a partir de QueryOptions
-     */
-    private buildQueryConstraints;
-    /**
-     * Mapea un DocumentSnapshot a nuestro tipo
-     */
-    private mapDocument;
-    /**
-     * Convierte Timestamps de Firestore a Date de JavaScript
-     */
-    private convertTimestamps;
-    /**
-     * Divide una ruta de documento en colección e ID
-     */
-    private splitPath;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FirestoreService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FirestoreService>;
-}

package/lib/services/firebase/index.d.ts

@@ -1,44 +0,0 @@
-/**
- * Firebase Services
- *
- * Servicios reutilizables para integración con Firebase.
- *
- * @example
- * ```typescript
- * // En main.ts
- * import { provideValtechFirebase } from 'valtech-components';
- *
- * bootstrapApplication(AppComponent, {
- *   providers: [
- *     provideValtechFirebase({
- *       firebase: environment.firebase,
- *       persistence: true,
- *     }),
- *   ],
- * });
- *
- * // En componentes
- * import { FirebaseService, FirestoreService } from 'valtech-components';
- *
- * @Component({...})
- * export class MyComponent {
- *   private firebase = inject(FirebaseService);
- *   private firestore = inject(FirestoreService);
- * }
- * ```
- */
-export * from './types';
-export { VALTECH_FIREBASE_CONFIG, hasEmulators, provideValtechFirebase } from './config';
-export { collections, createFirebaseConfig, isEmulatorMode, storagePaths, type AppId, type CreateFirebaseConfigOptions, } from './shared-config';
-export { FirebaseService } from './firebase.service';
-export { FirestoreService } from './firestore.service';
-export { CollectionOptions, FirestoreCollection, FirestoreCollectionFactory, SubCollectionRef, TypedCollection, } from './firestore-collection';
-export { QueryBuilder, query } from './utils/query-builder';
-export { buildPath, extractPathParams, getCollectionPath, getDocumentId, isCollectionPath, isDocumentPath, isValidPath, joinPath, } from './utils/path-builder';
-export { StorageService } from './storage.service';
-export { MessagingService } from './messaging.service';
-export { NotificationDocument, NotificationsService } from './notifications.service';
-export { AnalyticsService } from './analytics.service';
-export { AnalyticsRouterTracker } from './analytics-router-tracker';
-export { AnalyticsErrorHandler } from './analytics-error-handler';
-export * from './analytics-types';

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

@@ -1,293 +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;
-    constructor(injector: Injector, config: ValtechFirebaseConfig, platformId: Object, ngZone: NgZone);
-    /**
-     * Obtiene la instancia de Messaging de forma perezosa.
-     * Esto evita el error de APP_INITIALIZER de AngularFire.
-     */
-    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>;
-    /**
-     * 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>;
-    /**
-     * 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 {};