valtech-components 2.0.803 → 2.0.805

package/esm2022/lib/services/firebase/notifications.service.mjs

@@ -9,8 +9,9 @@
  */
 import { effect, Injectable, Optional, runInInjectionContext } from '@angular/core';
 import { BehaviorSubject, EMPTY, from, of } from 'rxjs';
-import { switchMap } from 'rxjs/operators';
+import { map, switchMap } from 'rxjs/operators';
 import { AuthService } from '../auth/auth.service';
+import { FirebaseService } from './firebase.service';
 import * as i0 from "@angular/core";
 import * as i1 from "./firestore-collection";
 /** Límite por defecto de notificaciones a cargar */
@@ -43,9 +44,32 @@ export class NotificationsService {
         this.collectionReady$ = new BehaviorSubject(null);
         // Inyección opcional - AuthService puede no estar configurado
         this.authService = null;
+        // Inyección opcional - FirebaseService gatea los listeners hasta que la
+        // sesión de Firebase Auth esté lista (cierra la ventana de permission-denied
+        // en cold start de PWA).
+        this.firebaseService = null;
+        this.firebaseService = this.injector.get(FirebaseService, null);
         // Intentar obtener AuthService de forma lazy (puede no estar configurado)
         this.setupAutoInitialization();
     }
+    /**
+     * 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.
+     */
+    collectionWhenAuthReady$() {
+        const fb = this.firebaseService;
+        if (!fb) {
+            return this.collectionReady$.asObservable();
+        }
+        return this.collectionReady$.pipe(switchMap(collection => {
+            if (!collection)
+                return of(null);
+            return from(fb.whenFirebaseAuthReady()).pipe(map(() => collection));
+        }));
+    }
     /**
      * Configura auto-inicialización observando el estado de AuthService.
      * Se ejecuta en el contexto del injector para poder usar effect().
@@ -119,10 +143,15 @@ export class NotificationsService {
      * 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 = DEFAULT_LIMIT) {
-        return this.collectionReady$.pipe(switchMap(collection => {
+        return this.collectionWhenAuthReady$().pipe(switchMap(collection => {
             if (!collection)
                 return EMPTY;
             return collection.watchAll({
@@ -162,9 +191,12 @@ export class NotificationsService {
     /**
      * 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() {
-        return this.collectionReady$.pipe(switchMap(collection => {
+        return this.collectionWhenAuthReady$().pipe(switchMap(collection => {
             if (!collection)
                 return of(0);
             return from(collection.count({
@@ -239,4 +271,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
         }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.FirestoreCollectionFactory, decorators: [{
                     type: Optional
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notifications.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/firebase/notifications.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Notifications Service\n *\n * Servicio para leer notificaciones desde Firestore.\n * El backend escribe las notificaciones, el frontend solo las lee y actualiza estado.\n *\n * Se auto-inicializa cuando AuthService tiene un usuario autenticado.\n * También puede inicializarse manualmente con `initialize(userId)`.\n */\n\nimport { effect, Injectable, Injector, Optional, runInInjectionContext } from '@angular/core';\nimport { BehaviorSubject, EMPTY, from, Observable, of } from 'rxjs';\nimport { switchMap } from 'rxjs/operators';\n\nimport { AuthService } from '../auth/auth.service';\nimport { FirestoreCollectionFactory, TypedCollection } from './firestore-collection';\nimport { FirestoreDocument } from './types';\n\n/** Límite por defecto de notificaciones a cargar */\nconst DEFAULT_LIMIT = 50;\n\n/**\n * Documento de notificación en Firestore.\n * Estructura escrita por el backend.\n */\nexport interface NotificationDocument extends FirestoreDocument {\n  /** Título de la notificación */\n  title?: string;\n  /** Cuerpo del mensaje */\n  body?: string;\n  /** URL de imagen */\n  image?: string;\n  /** Datos personalizados (ej: route, actionType). Legacy — preferir actionRoute + payload */\n  data?: Record<string, string>;\n  /** Tipo de notificación */\n  type?: 'fcm' | 'system' | 'reminder' | string;\n  /** Si la notificación fue leída */\n  isRead: boolean;\n  /** AppID origen (ej: 'showcase', 'sigify'). Permite cross-app routing */\n  appId?: string;\n  /** OrgID asociado (si la notif es org-scoped). Habilita switch-org al abrir */\n  orgId?: string;\n  /** Route destino al click (ej: '/app/docs/123') */\n  actionRoute?: string;\n  /** Payload estructurado para acciones (reemplazo tipado de `data`) */\n  payload?: Record<string, unknown>;\n}\n\n/**\n * Servicio para leer notificaciones desde Firestore.\n *\n * Se auto-inicializa cuando AuthService tiene un usuario autenticado.\n * No requiere llamar a `initialize()` manualmente si AuthService está configurado.\n *\n * @example\n * ```typescript\n * // Con AuthService configurado: auto-inicialización\n * // Solo inyectar y usar directamente\n * private notifications = inject(NotificationsService);\n *\n * notifications$ = this.notifications.getAll();\n * unreadCount$ = this.notifications.getUnreadCount();\n *\n * // Sin AuthService: inicialización manual\n * this.notifications.initialize(userId);\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class NotificationsService {\n  private collection: TypedCollection<NotificationDocument> | null = null;\n  private currentUserId: string | null = null;\n  private collectionReady$ = new BehaviorSubject<TypedCollection<NotificationDocument> | null>(\n    null\n  );\n\n  // Inyección opcional - AuthService puede no estar configurado\n  private authService: AuthService | null = null;\n\n  constructor(\n    private injector: Injector,\n    @Optional() private collectionFactory: FirestoreCollectionFactory\n  ) {\n    // Intentar obtener AuthService de forma lazy (puede no estar configurado)\n    this.setupAutoInitialization();\n  }\n\n  /**\n   * Configura auto-inicialización observando el estado de AuthService.\n   * Se ejecuta en el contexto del injector para poder usar effect().\n   */\n  private setupAutoInitialization(): void {\n    // Obtener AuthService de forma lazy\n    try {\n      this.authService = this.injector.get(AuthService, null);\n    } catch {\n      // AuthService no está configurado, no hay auto-inicialización\n      return;\n    }\n\n    if (!this.authService) {\n      return;\n    }\n\n    // Usar runInInjectionContext para poder crear el effect\n    runInInjectionContext(this.injector, () => {\n      effect(() => {\n        const user = this.authService!.user();\n\n        if (user?.userId && this.currentUserId !== user.userId) {\n          // Usuario autenticado: inicializar con su ID\n          this.initialize(user.userId);\n        } else if (!user && this.currentUserId) {\n          // Logout: limpiar estado\n          this.reset();\n        }\n      });\n    });\n  }\n\n  /**\n   * Inicializa el servicio para un usuario específico.\n   *\n   * NOTA: Se llama automáticamente si AuthService está configurado.\n   * Solo usar manualmente si AuthService no está disponible o se necesita\n   * un userId diferente al del usuario autenticado.\n   */\n  initialize(userId: string): void {\n    if (!this.collectionFactory) {\n      console.warn(\n        '[Notifications] FirestoreCollectionFactory not available. Ensure provideValtechFirebase() is configured.'\n      );\n      return;\n    }\n\n    this.currentUserId = userId;\n\n    // Path global cross-app: /users/{uid}/notifications (sin prefijo apps/{appId}/).\n    // skipAppPrefix bypassa FirestoreService.prefixCollectionPath para fan-out compartido.\n    const basePath = `users/${userId}/notifications`;\n\n    this.collection = this.collectionFactory.create<NotificationDocument>(basePath, {\n      timestamps: true,\n      skipAppPrefix: true,\n    });\n    this.collectionReady$.next(this.collection);\n\n    console.log('[Notifications] Initialized with path:', basePath);\n  }\n\n  /**\n   * Verifica si el servicio está inicializado.\n   */\n  get isReady(): boolean {\n    return this.collection !== null;\n  }\n\n  /**\n   * Obtiene el ID del usuario actual.\n   */\n  get userId(): string | null {\n    return this.currentUserId;\n  }\n\n  // ===========================================================================\n  // LECTURA\n  // ===========================================================================\n\n  /**\n   * Obtiene notificaciones ordenadas por fecha descendente (real-time).\n   * Se actualiza automáticamente cuando cambian los datos.\n   *\n   * @param limit - Máximo de notificaciones a cargar (default: 50)\n   */\n  getAll(limit = DEFAULT_LIMIT): Observable<NotificationDocument[]> {\n    return this.collectionReady$.pipe(\n      switchMap(collection => {\n        if (!collection) return EMPTY;\n        return collection.watchAll({\n          orderBy: [{ field: 'createdAt', direction: 'desc' }],\n          limit,\n        });\n      })\n    );\n  }\n\n  /**\n   * Obtiene notificaciones (one-time fetch sin listener).\n   * Útil para cargas iniciales sin necesidad de updates en tiempo real.\n   *\n   * @param limit - Máximo de notificaciones a cargar (default: 50)\n   */\n  async getAllOnce(limit = DEFAULT_LIMIT): Promise<NotificationDocument[]> {\n    if (!this.collection) return [];\n\n    return this.collection.getAllOnce({\n      orderBy: [{ field: 'createdAt', direction: 'desc' }],\n      limit,\n    });\n  }\n\n  /**\n   * Obtiene solo notificaciones no leídas (real-time, filtrado server-side).\n   *\n   * @param limit - Máximo de notificaciones (default: 50)\n   */\n  getUnread(limit = DEFAULT_LIMIT): Observable<NotificationDocument[]> {\n    if (!this.collection) return of([]);\n\n    return this.collection.watchAll({\n      where: [{ field: 'isRead', operator: '==', value: false }],\n      orderBy: [{ field: 'createdAt', direction: 'desc' }],\n      limit,\n    });\n  }\n\n  /**\n   * Cuenta notificaciones no leídas usando server-side aggregation query.\n   * No descarga documentos — eficiente para badges en UI.\n   */\n  getUnreadCount(): Observable<number> {\n    return this.collectionReady$.pipe(\n      switchMap(collection => {\n        if (!collection) return of(0);\n        return from(\n          collection.count({\n            where: [{ field: 'isRead', operator: '==', value: false }],\n          })\n        );\n      })\n    );\n  }\n\n  /**\n   * Obtiene una notificación por ID.\n   */\n  async getById(notificationId: string): Promise<NotificationDocument | null> {\n    if (!this.collection) return null;\n    return this.collection.getById(notificationId);\n  }\n\n  // ===========================================================================\n  // ACCIONES\n  // ===========================================================================\n\n  /**\n   * Marca una notificación como leída.\n   */\n  async markAsRead(notificationId: string): Promise<void> {\n    if (!this.collection) return;\n    await this.collection.update(notificationId, { isRead: true });\n  }\n\n  /**\n   * Marca todas las notificaciones no leídas como leídas (batch write).\n   */\n  async markAllAsRead(): Promise<void> {\n    if (!this.collection) return;\n\n    const unread = await this.collection.query({\n      where: [{ field: 'isRead', operator: '==', value: false }],\n    });\n\n    const ids = unread.map(n => n.id!).filter(Boolean);\n    await this.collection.batchUpdate(ids, { isRead: true });\n  }\n\n  /**\n   * Elimina una notificación.\n   */\n  async delete(notificationId: string): Promise<void> {\n    if (!this.collection) return;\n    await this.collection.delete(notificationId);\n  }\n\n  /**\n   * Elimina todas las notificaciones del usuario (batch delete).\n   */\n  async deleteAll(): Promise<void> {\n    if (!this.collection) return;\n\n    const all = await this.collection.getAll();\n    const ids = all.map(n => n.id!).filter(Boolean);\n    await this.collection.batchDelete(ids);\n  }\n\n  /**\n   * Limpia el estado del servicio.\n   * Útil para logout.\n   */\n  reset(): void {\n    this.collection = null;\n    this.currentUserId = null;\n    this.collectionReady$.next(null);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notifications.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/firebase/notifications.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Notifications Service\n *\n * Servicio para leer notificaciones desde Firestore.\n * El backend escribe las notificaciones, el frontend solo las lee y actualiza estado.\n *\n * Se auto-inicializa cuando AuthService tiene un usuario autenticado.\n * También puede inicializarse manualmente con `initialize(userId)`.\n */\n\nimport { effect, Injectable, Injector, Optional, runInInjectionContext } from '@angular/core';\nimport { BehaviorSubject, EMPTY, from, Observable, of } from 'rxjs';\nimport { map, switchMap } from 'rxjs/operators';\n\nimport { AuthService } from '../auth/auth.service';\nimport { FirebaseService } from './firebase.service';\nimport { FirestoreCollectionFactory, TypedCollection } from './firestore-collection';\nimport { FirestoreDocument } from './types';\n\n/** Límite por defecto de notificaciones a cargar */\nconst DEFAULT_LIMIT = 50;\n\n/**\n * Documento de notificación en Firestore.\n * Estructura escrita por el backend.\n */\nexport interface NotificationDocument extends FirestoreDocument {\n  /** Título de la notificación */\n  title?: string;\n  /** Cuerpo del mensaje */\n  body?: string;\n  /** URL de imagen */\n  image?: string;\n  /** Datos personalizados (ej: route, actionType). Legacy — preferir actionRoute + payload */\n  data?: Record<string, string>;\n  /** Tipo de notificación */\n  type?: 'fcm' | 'system' | 'reminder' | string;\n  /** Si la notificación fue leída */\n  isRead: boolean;\n  /** AppID origen (ej: 'showcase', 'sigify'). Permite cross-app routing */\n  appId?: string;\n  /** OrgID asociado (si la notif es org-scoped). Habilita switch-org al abrir */\n  orgId?: string;\n  /** Route destino al click (ej: '/app/docs/123') */\n  actionRoute?: string;\n  /** Payload estructurado para acciones (reemplazo tipado de `data`) */\n  payload?: Record<string, unknown>;\n}\n\n/**\n * Servicio para leer notificaciones desde Firestore.\n *\n * Se auto-inicializa cuando AuthService tiene un usuario autenticado.\n * No requiere llamar a `initialize()` manualmente si AuthService está configurado.\n *\n * @example\n * ```typescript\n * // Con AuthService configurado: auto-inicialización\n * // Solo inyectar y usar directamente\n * private notifications = inject(NotificationsService);\n *\n * notifications$ = this.notifications.getAll();\n * unreadCount$ = this.notifications.getUnreadCount();\n *\n * // Sin AuthService: inicialización manual\n * this.notifications.initialize(userId);\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class NotificationsService {\n  private collection: TypedCollection<NotificationDocument> | null = null;\n  private currentUserId: string | null = null;\n  private collectionReady$ = new BehaviorSubject<TypedCollection<NotificationDocument> | null>(\n    null\n  );\n\n  // Inyección opcional - AuthService puede no estar configurado\n  private authService: AuthService | null = null;\n\n  // Inyección opcional - FirebaseService gatea los listeners hasta que la\n  // sesión de Firebase Auth esté lista (cierra la ventana de permission-denied\n  // en cold start de PWA).\n  private firebaseService: FirebaseService | null = null;\n\n  constructor(\n    private injector: Injector,\n    @Optional() private collectionFactory: FirestoreCollectionFactory\n  ) {\n    this.firebaseService = this.injector.get(FirebaseService, null);\n    // Intentar obtener AuthService de forma lazy (puede no estar configurado)\n    this.setupAutoInitialization();\n  }\n\n  /**\n   * Gate de Firebase Auth: emite la colección lista SOLO cuando la sesión de\n   * Firebase Auth está confirmada. Sin FirebaseService disponible, no gatea\n   * (degrada al comportamiento previo). Espera a que `firebaseAuthReady$`\n   * emita antes de propagar la colección — así el listener Firestore nunca se\n   * adjunta antes de que `request.auth` esté disponible.\n   */\n  private collectionWhenAuthReady$(): Observable<TypedCollection<NotificationDocument> | null> {\n    const fb = this.firebaseService;\n    if (!fb) {\n      return this.collectionReady$.asObservable();\n    }\n    return this.collectionReady$.pipe(\n      switchMap(collection => {\n        if (!collection) return of(null);\n        return from(fb.whenFirebaseAuthReady()).pipe(map(() => collection));\n      })\n    );\n  }\n\n  /**\n   * Configura auto-inicialización observando el estado de AuthService.\n   * Se ejecuta en el contexto del injector para poder usar effect().\n   */\n  private setupAutoInitialization(): void {\n    // Obtener AuthService de forma lazy\n    try {\n      this.authService = this.injector.get(AuthService, null);\n    } catch {\n      // AuthService no está configurado, no hay auto-inicialización\n      return;\n    }\n\n    if (!this.authService) {\n      return;\n    }\n\n    // Usar runInInjectionContext para poder crear el effect\n    runInInjectionContext(this.injector, () => {\n      effect(() => {\n        const user = this.authService!.user();\n\n        if (user?.userId && this.currentUserId !== user.userId) {\n          // Usuario autenticado: inicializar con su ID\n          this.initialize(user.userId);\n        } else if (!user && this.currentUserId) {\n          // Logout: limpiar estado\n          this.reset();\n        }\n      });\n    });\n  }\n\n  /**\n   * Inicializa el servicio para un usuario específico.\n   *\n   * NOTA: Se llama automáticamente si AuthService está configurado.\n   * Solo usar manualmente si AuthService no está disponible o se necesita\n   * un userId diferente al del usuario autenticado.\n   */\n  initialize(userId: string): void {\n    if (!this.collectionFactory) {\n      console.warn(\n        '[Notifications] FirestoreCollectionFactory not available. Ensure provideValtechFirebase() is configured.'\n      );\n      return;\n    }\n\n    this.currentUserId = userId;\n\n    // Path global cross-app: /users/{uid}/notifications (sin prefijo apps/{appId}/).\n    // skipAppPrefix bypassa FirestoreService.prefixCollectionPath para fan-out compartido.\n    const basePath = `users/${userId}/notifications`;\n\n    this.collection = this.collectionFactory.create<NotificationDocument>(basePath, {\n      timestamps: true,\n      skipAppPrefix: true,\n    });\n    this.collectionReady$.next(this.collection);\n\n    console.log('[Notifications] Initialized with path:', basePath);\n  }\n\n  /**\n   * Verifica si el servicio está inicializado.\n   */\n  get isReady(): boolean {\n    return this.collection !== null;\n  }\n\n  /**\n   * Obtiene el ID del usuario actual.\n   */\n  get userId(): string | null {\n    return this.currentUserId;\n  }\n\n  // ===========================================================================\n  // LECTURA\n  // ===========================================================================\n\n  /**\n   * Obtiene notificaciones ordenadas por fecha descendente (real-time).\n   * Se actualiza automáticamente cuando cambian los datos.\n   *\n   * El listener Firestore NO se adjunta hasta que la sesión de Firebase Auth\n   * esté confirmada (`FirebaseService.firebaseAuthReady`). Esto cierra la\n   * ventana de `permission-denied` en cold start de PWA, donde el JWT del\n   * backend puede estar listo antes que la sesión de Firebase Auth.\n   *\n   * @param limit - Máximo de notificaciones a cargar (default: 50)\n   */\n  getAll(limit = DEFAULT_LIMIT): Observable<NotificationDocument[]> {\n    return this.collectionWhenAuthReady$().pipe(\n      switchMap(collection => {\n        if (!collection) return EMPTY;\n        return collection.watchAll({\n          orderBy: [{ field: 'createdAt', direction: 'desc' }],\n          limit,\n        });\n      })\n    );\n  }\n\n  /**\n   * Obtiene notificaciones (one-time fetch sin listener).\n   * Útil para cargas iniciales sin necesidad de updates en tiempo real.\n   *\n   * @param limit - Máximo de notificaciones a cargar (default: 50)\n   */\n  async getAllOnce(limit = DEFAULT_LIMIT): Promise<NotificationDocument[]> {\n    if (!this.collection) return [];\n\n    return this.collection.getAllOnce({\n      orderBy: [{ field: 'createdAt', direction: 'desc' }],\n      limit,\n    });\n  }\n\n  /**\n   * Obtiene solo notificaciones no leídas (real-time, filtrado server-side).\n   *\n   * @param limit - Máximo de notificaciones (default: 50)\n   */\n  getUnread(limit = DEFAULT_LIMIT): Observable<NotificationDocument[]> {\n    if (!this.collection) return of([]);\n\n    return this.collection.watchAll({\n      where: [{ field: 'isRead', operator: '==', value: false }],\n      orderBy: [{ field: 'createdAt', direction: 'desc' }],\n      limit,\n    });\n  }\n\n  /**\n   * Cuenta notificaciones no leídas usando server-side aggregation query.\n   * No descarga documentos — eficiente para badges en UI.\n   *\n   * Gateado por `firebaseAuthReady` — la aggregation query no se ejecuta hasta\n   * que la sesión de Firebase Auth esté lista.\n   */\n  getUnreadCount(): Observable<number> {\n    return this.collectionWhenAuthReady$().pipe(\n      switchMap(collection => {\n        if (!collection) return of(0);\n        return from(\n          collection.count({\n            where: [{ field: 'isRead', operator: '==', value: false }],\n          })\n        );\n      })\n    );\n  }\n\n  /**\n   * Obtiene una notificación por ID.\n   */\n  async getById(notificationId: string): Promise<NotificationDocument | null> {\n    if (!this.collection) return null;\n    return this.collection.getById(notificationId);\n  }\n\n  // ===========================================================================\n  // ACCIONES\n  // ===========================================================================\n\n  /**\n   * Marca una notificación como leída.\n   */\n  async markAsRead(notificationId: string): Promise<void> {\n    if (!this.collection) return;\n    await this.collection.update(notificationId, { isRead: true });\n  }\n\n  /**\n   * Marca todas las notificaciones no leídas como leídas (batch write).\n   */\n  async markAllAsRead(): Promise<void> {\n    if (!this.collection) return;\n\n    const unread = await this.collection.query({\n      where: [{ field: 'isRead', operator: '==', value: false }],\n    });\n\n    const ids = unread.map(n => n.id!).filter(Boolean);\n    await this.collection.batchUpdate(ids, { isRead: true });\n  }\n\n  /**\n   * Elimina una notificación.\n   */\n  async delete(notificationId: string): Promise<void> {\n    if (!this.collection) return;\n    await this.collection.delete(notificationId);\n  }\n\n  /**\n   * Elimina todas las notificaciones del usuario (batch delete).\n   */\n  async deleteAll(): Promise<void> {\n    if (!this.collection) return;\n\n    const all = await this.collection.getAll();\n    const ids = all.map(n => n.id!).filter(Boolean);\n    await this.collection.batchDelete(ids);\n  }\n\n  /**\n   * Limpia el estado del servicio.\n   * Útil para logout.\n   */\n  reset(): void {\n    this.collection = null;\n    this.currentUserId = null;\n    this.collectionReady$.next(null);\n  }\n}\n"]}

package/esm2022/lib/services/refreshable-stream/index.mjs

@@ -0,0 +1,8 @@
+/**
+ * Refreshable Stream
+ *
+ * Helper `createRefreshableStream` para vistas con datos Firestore.
+ * Soporta modo one-shot y real-time, con gate de `firebaseAuthReady`.
+ */
+export { createRefreshableStream, } from './refreshable-stream';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL3JlZnJlc2hhYmxlLXN0cmVhbS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUNILE9BQU8sRUFDTCx1QkFBdUIsR0FHeEIsTUFBTSxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUmVmcmVzaGFibGUgU3RyZWFtXG4gKlxuICogSGVscGVyIGBjcmVhdGVSZWZyZXNoYWJsZVN0cmVhbWAgcGFyYSB2aXN0YXMgY29uIGRhdG9zIEZpcmVzdG9yZS5cbiAqIFNvcG9ydGEgbW9kbyBvbmUtc2hvdCB5IHJlYWwtdGltZSwgY29uIGdhdGUgZGUgYGZpcmViYXNlQXV0aFJlYWR5YC5cbiAqL1xuZXhwb3J0IHtcbiAgY3JlYXRlUmVmcmVzaGFibGVTdHJlYW0sXG4gIHR5cGUgUmVmcmVzaGFibGVTdHJlYW0sXG4gIHR5cGUgUmVmcmVzaGFibGVTdHJlYW1PcHRpb25zLFxufSBmcm9tICcuL3JlZnJlc2hhYmxlLXN0cmVhbSc7XG4iXX0=

package/esm2022/lib/services/refreshable-stream/refreshable-stream.mjs

@@ -0,0 +1,99 @@
+/**
+ * Refreshable Stream
+ *
+ * Helper estándar para vistas que consumen datos de Firestore. Soporta DOS
+ * modos — el caller decide cuál vía la `factory`:
+ *
+ *  - **one-shot** (recomendado por defecto): `() => from(svc.getAllOnce())`.
+ *    Carga una vez y completa. Más barato — sin listener vivo.
+ *  - **real-time**: `() => svc.getAll()`. Listener Firestore que auto-actualiza.
+ *    Solo donde importa (inbox de notificaciones, badges).
+ *
+ * En ambos modos la primera suscripción se gatea por `firebaseAuthReady`
+ * (sesión de Firebase Auth lista) — así el listener/lectura nunca se adjunta
+ * antes de que `request.auth` esté disponible en las reglas de Firestore, lo
+ * que cierra la ventana de `permission-denied` en cold start de PWA.
+ *
+ * El `retry` con backoff corto es solo red de seguridad para reconexiones
+ * transitorias (no para cubrir cold start — eso lo cubre el gate de auth).
+ */
+import { inject, Injector } from '@angular/core';
+import { toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { signal } from '@angular/core';
+import { of, timer } from 'rxjs';
+import { catchError, retry, switchMap, tap } from 'rxjs/operators';
+import { FirebaseService } from '../firebase/firebase.service';
+/**
+ * Crea un stream refrescable a partir de una factory de Observable.
+ *
+ * DEBE llamarse en un injection context (field initializer o constructor) —
+ * usa `toSignal`/`toObservable`/`inject` internamente.
+ *
+ * @param factory - Función que produce el Observable a consumir. El caller
+ *   decide el modo: `() => from(svc.getAllOnce())` (one-shot) o
+ *   `() => svc.getAll()` (real-time).
+ * @param options - Configuración opcional (fallback, retry, gate).
+ *
+ * @example
+ * ```typescript
+ * // one-shot (recomendado por defecto)
+ * private readonly stream = createRefreshableStream(
+ *   () => from(this.svc.getAllOnce()),
+ * );
+ *
+ * // real-time (inbox)
+ * private readonly stream = createRefreshableStream(
+ *   () => this.notifs.getAll(50),
+ * );
+ *
+ * readonly items = this.stream.data;
+ * readonly loading = this.stream.loading;
+ *
+ * ionViewWillEnter() {
+ *   this.pageRefresh.register(() => this.stream.reload());
+ * }
+ * ```
+ */
+export function createRefreshableStream(factory, options) {
+    const injector = options?.injector ?? inject(Injector);
+    const fallback = (options?.fallback ?? null);
+    const retryCount = options?.retryCount ?? 4;
+    const retryBaseDelayMs = options?.retryBaseDelayMs ?? 500;
+    const gateOnFirebaseAuth = options?.gateOnFirebaseAuth ?? true;
+    // FirebaseService es opcional — sin él (apps sin Firebase) no se gatea.
+    const firebase = gateOnFirebaseAuth ? injector.get(FirebaseService, null) : null;
+    const _reload = signal(0);
+    const _loading = signal(true);
+    const _error = signal(false);
+    // Gate compartido de Firebase Auth: el stream no abre la primera
+    // suscripción hasta que la sesión de Firebase Auth esté confirmada.
+    const authGate$ = firebase ? firebase.firebaseAuthReady$ : of(true);
+    const data = toSignal(toObservable(_reload, { injector }).pipe(tap(() => {
+        _loading.set(true);
+        _error.set(false);
+    }), 
+    // Esperar a Firebase Auth listo antes de cada (re)suscripción. Como
+    // `firebaseAuthReady$` completa tras la primera emisión, las reloads
+    // posteriores resuelven el gate de inmediato (auth ya está listo).
+    switchMap(() => authGate$.pipe(switchMap(() => factory().pipe(tap(() => {
+        _loading.set(false);
+        _error.set(false);
+    }), 
+    // Backoff corto exponencial acotado — solo red de seguridad para
+    // reconexiones transitorias, NO para cubrir cold start.
+    retry({
+        count: retryCount,
+        delay: (_err, attempt) => timer(Math.min(retryBaseDelayMs * 2 ** (attempt - 1), 4000)),
+    }), catchError(() => {
+        _loading.set(false);
+        _error.set(true);
+        return of(fallback);
+    })))))), { initialValue: null, injector });
+    return {
+        data,
+        loading: _loading.asReadonly(),
+        error: _error.asReadonly(),
+        reload: () => _reload.update(n => n + 1),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"refreshable-stream.js","sourceRoot":"","sources":["../../../../../../src/lib/services/refreshable-stream/refreshable-stream.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Refreshable Stream\n *\n * Helper estándar para vistas que consumen datos de Firestore. Soporta DOS\n * modos — el caller decide cuál vía la `factory`:\n *\n *  - **one-shot** (recomendado por defecto): `() => from(svc.getAllOnce())`.\n *    Carga una vez y completa. Más barato — sin listener vivo.\n *  - **real-time**: `() => svc.getAll()`. Listener Firestore que auto-actualiza.\n *    Solo donde importa (inbox de notificaciones, badges).\n *\n * En ambos modos la primera suscripción se gatea por `firebaseAuthReady`\n * (sesión de Firebase Auth lista) — así el listener/lectura nunca se adjunta\n * antes de que `request.auth` esté disponible en las reglas de Firestore, lo\n * que cierra la ventana de `permission-denied` en cold start de PWA.\n *\n * El `retry` con backoff corto es solo red de seguridad para reconexiones\n * transitorias (no para cubrir cold start — eso lo cubre el gate de auth).\n */\n\nimport { inject, Injector, Signal } from '@angular/core';\nimport { toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { signal } from '@angular/core';\nimport { Observable, of, timer } from 'rxjs';\nimport { catchError, retry, switchMap, tap } from 'rxjs/operators';\n\nimport { FirebaseService } from '../firebase/firebase.service';\n\n/** Opciones de configuración para `createRefreshableStream`. */\nexport interface RefreshableStreamOptions<T> {\n  /**\n   * Valor emitido cuando la factory falla tras agotar los reintentos.\n   * Default: `null`.\n   */\n  fallback?: T;\n  /**\n   * Número máximo de reintentos ante un error de la factory.\n   * Backoff corto — NO cubre cold start (eso lo hace el gate de auth), solo\n   * reconexiones transitorias. Default: 4.\n   */\n  retryCount?: number;\n  /**\n   * Delay base del backoff (ms). El delay efectivo crece exponencialmente\n   * acotado: 500ms → 1s → 2s ... Default: 500.\n   */\n  retryBaseDelayMs?: number;\n  /**\n   * Si `false`, NO espera a `firebaseAuthReady` antes de la primera\n   * suscripción. Útil para streams que no leen Firestore. Default: `true`.\n   */\n  gateOnFirebaseAuth?: boolean;\n  /**\n   * Injector explícito. Solo necesario si `createRefreshableStream` se llama\n   * fuera de un injection context (raro). Por defecto usa `inject(Injector)`.\n   */\n  injector?: Injector;\n}\n\n/**\n * Resultado de `createRefreshableStream`.\n */\nexport interface RefreshableStream<T> {\n  /** Datos actuales. `null` mientras la primera emisión no ha llegado. */\n  readonly data: Signal<T | null>;\n  /** `true` mientras se espera la primera emisión de la suscripción actual. */\n  readonly loading: Signal<boolean>;\n  /** `true` si la factory falló tras agotar los reintentos. */\n  readonly error: Signal<boolean>;\n  /**\n   * Re-suscribe la factory desde cero (nuevo listener / nueva lectura).\n   * Es lo que registra el `PageRefreshService` como handler de pull-to-refresh,\n   * y también el \"reconectar manual\" si un listener murió.\n   */\n  reload: () => void;\n}\n\n/**\n * Crea un stream refrescable a partir de una factory de Observable.\n *\n * DEBE llamarse en un injection context (field initializer o constructor) —\n * usa `toSignal`/`toObservable`/`inject` internamente.\n *\n * @param factory - Función que produce el Observable a consumir. El caller\n *   decide el modo: `() => from(svc.getAllOnce())` (one-shot) o\n *   `() => svc.getAll()` (real-time).\n * @param options - Configuración opcional (fallback, retry, gate).\n *\n * @example\n * ```typescript\n * // one-shot (recomendado por defecto)\n * private readonly stream = createRefreshableStream(\n *   () => from(this.svc.getAllOnce()),\n * );\n *\n * // real-time (inbox)\n * private readonly stream = createRefreshableStream(\n *   () => this.notifs.getAll(50),\n * );\n *\n * readonly items = this.stream.data;\n * readonly loading = this.stream.loading;\n *\n * ionViewWillEnter() {\n *   this.pageRefresh.register(() => this.stream.reload());\n * }\n * ```\n */\nexport function createRefreshableStream<T>(\n  factory: () => Observable<T>,\n  options?: RefreshableStreamOptions<T>\n): RefreshableStream<T> {\n  const injector = options?.injector ?? inject(Injector);\n  const fallback = (options?.fallback ?? null) as T | null;\n  const retryCount = options?.retryCount ?? 4;\n  const retryBaseDelayMs = options?.retryBaseDelayMs ?? 500;\n  const gateOnFirebaseAuth = options?.gateOnFirebaseAuth ?? true;\n\n  // FirebaseService es opcional — sin él (apps sin Firebase) no se gatea.\n  const firebase = gateOnFirebaseAuth ? injector.get(FirebaseService, null) : null;\n\n  const _reload = signal(0);\n  const _loading = signal(true);\n  const _error = signal(false);\n\n  // Gate compartido de Firebase Auth: el stream no abre la primera\n  // suscripción hasta que la sesión de Firebase Auth esté confirmada.\n  const authGate$: Observable<unknown> = firebase ? firebase.firebaseAuthReady$ : of(true);\n\n  const data = toSignal(\n    toObservable(_reload, { injector }).pipe(\n      tap(() => {\n        _loading.set(true);\n        _error.set(false);\n      }),\n      // Esperar a Firebase Auth listo antes de cada (re)suscripción. Como\n      // `firebaseAuthReady$` completa tras la primera emisión, las reloads\n      // posteriores resuelven el gate de inmediato (auth ya está listo).\n      switchMap(() =>\n        authGate$.pipe(\n          switchMap(() =>\n            factory().pipe(\n              tap(() => {\n                _loading.set(false);\n                _error.set(false);\n              }),\n              // Backoff corto exponencial acotado — solo red de seguridad para\n              // reconexiones transitorias, NO para cubrir cold start.\n              retry({\n                count: retryCount,\n                delay: (_err, attempt) =>\n                  timer(Math.min(retryBaseDelayMs * 2 ** (attempt - 1), 4000)),\n              }),\n              catchError(() => {\n                _loading.set(false);\n                _error.set(true);\n                return of(fallback as T);\n              })\n            )\n          )\n        )\n      )\n    ),\n    { initialValue: null as T | null, injector }\n  );\n\n  return {\n    data,\n    loading: _loading.asReadonly(),\n    error: _error.asReadonly(),\n    reload: () => _reload.update(n => n + 1),\n  };\n}\n"]}

package/esm2022/lib/version.mjs

@@ -2,5 +2,5 @@
  * Current version of valtech-components.
  * This is automatically updated during the publish process.
  */
-export const VERSION = '2.0.803';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC44MDMnO1xuIl19
+export const VERSION = '2.0.805';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC44MDUnO1xuIl19

package/esm2022/public-api.mjs

@@ -282,6 +282,10 @@ export * from './lib/services/preferences';
 // Page Refresh Service — bus del pull-to-refresh estándar.
 // La página activa registra su handler; val-page-wrapper dispara el gesto.
 export * from './lib/services/page-refresh/page-refresh.service';
+// Refreshable Stream — helper estándar para vistas con datos Firestore.
+// `createRefreshableStream` soporta modo one-shot y real-time, gateado por
+// `firebaseAuthReady` (cierra la ventana de permission-denied en cold start).
+export * from './lib/services/refreshable-stream';
 // App Config Services
 // Sistema de configuración remota, feature flags y detección de actualizaciones
 // Requiere provideValtechAppConfig() y provideValtechFirebase() en el bootstrap de la app
@@ -311,6 +315,8 @@ export * from './lib/services/content';
 // Feedback Services & Components
 // Sistema de feedback de usuarios que requiere provideValtechFeedback() en el bootstrap
 export * from './lib/services/feedback';
+// Donation / Support — aportes voluntarios. Requiere provideValtechDonations()
+export * from './lib/services/donation';
 export * from './lib/components/molecules/feedback-form/feedback-form.component';
 export * from './lib/components/molecules/feedback-form/types';
 export * from './lib/components/molecules/content-reaction/content-reaction.component';
@@ -351,4 +357,4 @@ export * from './lib/shared/utils/text';
 // Shared Configuration
 // Configuración compartida para todos los productos Valtech
 export * from './lib/config';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.js","sourceRoot":"","sources":["../../../src/public-api.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Public API Surface of valtech-components\n */\n\n// Version\nexport * from './lib/version';\n\nexport * from './lib/components/atoms/avatar/avatar.component';\nexport * from './lib/components/atoms/avatar/types';\nexport * from './lib/components/atoms/box/box.component';\nexport * from './lib/components/atoms/box/types';\nexport * from './lib/components/atoms/glow/glow.component';\nexport * from './lib/components/atoms/glow/types';\nexport * from './lib/components/atoms/container/container.component';\nexport * from './lib/components/atoms/container/types';\nexport * from './lib/components/atoms/button/button.component';\nexport * from './lib/components/atoms/button/factory';\nexport * from './lib/components/atoms/display/display.component';\nexport * from './lib/components/atoms/display/types';\nexport * from './lib/components/atoms/divider/divider.component';\nexport * from './lib/components/atoms/divider/types';\nexport * from './lib/components/atoms/href/href.component';\nexport * from './lib/components/atoms/href/types';\nexport * from './lib/components/atoms/icon/icon.component';\nexport * from './lib/components/atoms/icon/types';\nexport * from './lib/components/atoms/image/image.component';\nexport * from './lib/components/atoms/image/types';\nexport * from './lib/components/atoms/progress-bar/progress-bar.component';\nexport * from './lib/components/atoms/progress-bar/types';\nexport * from './lib/components/atoms/text/text.component';\nexport * from './lib/components/atoms/text/types';\nexport * from './lib/components/atoms/title/title.component';\nexport * from './lib/components/atoms/title/types';\nexport * from './lib/components/atoms/skeleton/skeleton.component';\nexport * from './lib/components/atoms/skeleton/types';\nexport * from './lib/components/atoms/progress-ring/progress-ring.component';\nexport * from './lib/components/atoms/progress-ring/types';\nexport * from './lib/components/atoms/fab/fab.component';\nexport * from './lib/components/atoms/fab/types';\nexport * from './lib/components/atoms/qr-code/qr-code.component';\nexport * from './lib/components/atoms/qr-code/types';\nexport * from './lib/components/atoms/countdown/countdown.component';\nexport * from './lib/components/atoms/countdown/types';\nexport * from './lib/components/atoms/price-tag/price-tag.component';\nexport * from './lib/components/atoms/price-tag/types';\nexport * from './lib/components/atoms/horizontal-scroll/horizontal-scroll.component';\nexport * from './lib/components/atoms/horizontal-scroll/types';\nexport * from './lib/components/atoms/rights-footer/rights-footer.component';\nexport * from './lib/components/atoms/rights-footer/types';\nexport * from './lib/components/atoms/pattern/pattern.component';\nexport * from './lib/components/atoms/pattern/types';\nexport * from './lib/components/atoms/pattern/motifs';\nexport * from './lib/components/atoms/glass/glass.component';\nexport { GlassMetadata } from './lib/components/atoms/glass/types';\nexport * from './lib/components/atoms/user-avatar/user-avatar.component';\nexport { UserAvatarMetadata } from './lib/components/atoms/user-avatar/types';\n\nexport * from './lib/components/molecules/alert-box/alert-box.component';\nexport * from './lib/components/molecules/alert-box/types';\nexport * from './lib/components/molecules/button-group/button-group.component';\nexport * from './lib/components/molecules/button-group/types';\nexport * from './lib/components/molecules/card/card.component';\nexport * from './lib/components/molecules/card/types';\nexport * from './lib/components/molecules/check-input/check-input.component';\nexport * from './lib/components/molecules/checkbox-radio-input/checkbox-radio-input.component';\nexport * from './lib/components/molecules/comment-input/comment-input.component';\nexport * from './lib/components/molecules/comment-input/types';\nexport * from './lib/components/molecules/content-loader/content-loader.component';\nexport * from './lib/components/molecules/content-loader/types';\nexport * from './lib/components/molecules/date-input/date-input.component';\nexport * from './lib/components/molecules/date-input/types';\nexport * from './lib/components/molecules/email-input/email-input.component';\nexport * from './lib/components/molecules/expandable-text/expandable-text.component';\nexport * from './lib/components/molecules/expandable-text/types';\nexport * from './lib/components/molecules/file-input/file-input.component';\nexport * from './lib/components/molecules/file-input/types';\nexport * from './lib/components/molecules/hint/hint.component';\nexport * from './lib/components/molecules/hour-input/hour-input.component';\nexport * from './lib/components/molecules/language-selector/language-selector.component';\nexport * from './lib/components/molecules/language-selector/types';\nexport * from './lib/components/molecules/layered-card/layered-card.component';\nexport * from './lib/components/molecules/layered-card/types';\nexport * from './lib/components/molecules/link/link.component';\nexport * from './lib/components/molecules/link/types';\nexport * from './lib/components/molecules/links-cake/links-cake.component';\nexport * from './lib/components/molecules/links-cake/types';\nexport * from './lib/components/molecules/notes-box/notes-box.component';\nexport * from './lib/components/molecules/notes-box/types';\nexport * from './lib/components/molecules/page-links/page-links.component';\nexport * from './lib/components/molecules/page-links/types';\nexport * from './lib/components/molecules/number-input/number-input.component';\nexport * from './lib/components/molecules/number-from-to/number-from-to.component';\nexport * from './lib/components/molecules/number-from-to/types';\nexport * from './lib/components/molecules/password-input/password-input.component';\nexport * from './lib/components/molecules/pin-input/pin-input.component';\nexport * from './lib/components/molecules/pin-input/types';\nexport * from './lib/components/molecules/popover-selector/popover-selector.component';\nexport * from './lib/components/molecules/popover-selector/types';\nexport * from './lib/components/molecules/progress-status/progress-status.component';\nexport * from './lib/components/molecules/progress-status/types';\nexport * from './lib/components/molecules/prompter/prompter.component';\nexport * from './lib/components/molecules/prompter/types';\nexport * from './lib/components/molecules/radio-input/radio-input.component';\nexport * from './lib/components/molecules/range-input/range-input.component';\nexport * from './lib/components/molecules/range-input/types';\nexport * from './lib/components/molecules/searchbar/searchbar.component';\nexport * from './lib/components/molecules/select-input/select-input.component';\nexport * from './lib/components/molecules/select-search/select-search.component';\nexport * from './lib/components/molecules/segment-control/segment-control.component';\nexport * from './lib/components/molecules/segment-control/types';\nexport * from './lib/components/molecules/text-input/text-input.component';\nexport * from './lib/components/molecules/toggle-input/toggle-input.component';\nexport * from './lib/components/molecules/toggle-input/types';\nexport * from './lib/components/molecules/title-block/title-block.component';\nexport * from './lib/components/molecules/title-block/types';\nexport * from './lib/components/molecules/code-display/code-display.component';\nexport * from './lib/components/molecules/code-display/types';\nexport * from './lib/components/molecules/action-header/action-header.component';\nexport * from './lib/components/molecules/action-header/types';\nexport * from './lib/components/molecules/pill/pill.component';\nexport * from './lib/components/molecules/pill/types';\nexport * from './lib/components/molecules/command-display/command-display.component';\nexport * from './lib/components/molecules/command-display/types';\nexport * from './lib/components/molecules/info/info.component';\nexport * from './lib/components/molecules/info/types';\nexport * from './lib/components/molecules/plain-code-box/plain-code-box.component';\nexport * from './lib/components/molecules/plain-code-box/types';\nexport * from './lib/components/molecules/accordion/accordion.component';\nexport * from './lib/components/molecules/accordion/types';\nexport * from './lib/components/molecules/tabs/tabs.component';\nexport * from './lib/components/molecules/tabs/types';\nexport * from './lib/components/molecules/breadcrumb/breadcrumb.component';\nexport * from './lib/components/molecules/breadcrumb/types';\nexport * from './lib/components/molecules/pagination/pagination.component';\nexport * from './lib/components/molecules/pagination/types';\nexport * from './lib/components/molecules/stepper/stepper.component';\nexport * from './lib/components/molecules/stepper/types';\nexport * from './lib/components/molecules/chip-group/chip-group.component';\nexport * from './lib/components/molecules/chip-group/types';\nexport * from './lib/components/molecules/rating/rating.component';\nexport * from './lib/components/molecules/rating/types';\nexport * from './lib/components/molecules/timeline/timeline.component';\nexport * from './lib/components/molecules/timeline/types';\nexport * from './lib/components/molecules/stats-card/stats-card.component';\nexport * from './lib/components/molecules/stats-card/types';\nexport * from './lib/components/molecules/comment/comment.component';\nexport * from './lib/components/molecules/comment/types';\nexport * from './lib/components/molecules/multi-select-search/multi-select-search.component';\nexport * from './lib/components/molecules/quote-box/quote-box.component';\nexport * from './lib/components/molecules/textarea-input/textarea-input.component';\nexport * from './lib/components/molecules/textarea-input/types';\nexport * from './lib/components/molecules/phone-input/phone-input.component';\nexport * from './lib/components/molecules/phone-input/types';\nexport * from './lib/components/molecules/currency-input/currency-input.component';\nexport * from './lib/components/molecules/currency-input/types';\nexport * from './lib/components/molecules/date-range-input/date-range-input.component';\nexport * from './lib/components/molecules/date-range-input/types';\nexport * from './lib/components/molecules/number-stepper/number-stepper.component';\nexport * from './lib/components/molecules/number-stepper/types';\nexport * from './lib/components/molecules/share-buttons/share-buttons.component';\nexport * from './lib/components/molecules/share-buttons/types';\nexport * from './lib/components/molecules/glow-card/glow-card.component';\nexport * from './lib/components/molecules/glow-card/types';\nexport * from './lib/components/molecules/swipe-carousel/swipe-carousel.component';\nexport * from './lib/components/molecules/swipe-carousel/types';\nexport * from './lib/components/molecules/testimonial-card/testimonial-card.component';\nexport * from './lib/components/molecules/testimonial-card/types';\nexport * from './lib/components/molecules/features-list/features-list.component';\nexport * from './lib/components/molecules/features-list/types';\nexport * from './lib/components/molecules/footer-links/footer-links.component';\nexport * from './lib/components/molecules/footer-links/types';\nexport * from './lib/components/molecules/links-accordion/links-accordion.component';\nexport * from './lib/components/molecules/links-accordion/types';\nexport * from './lib/components/molecules/refresher/refresher.component';\nexport * from './lib/components/molecules/refresher/types';\nexport * from './lib/components/molecules/update-banner/update-banner.component';\nexport * from './lib/components/molecules/action-card/action-card.component';\nexport * from './lib/components/molecules/action-card/types';\nexport * from './lib/components/molecules/username-input/username-input.component';\nexport * from './lib/components/molecules/username-input/types';\nexport * from './lib/components/molecules/linked-providers/linked-providers.component';\nexport * from './lib/components/molecules/linked-providers/types';\nexport * from './lib/components/molecules/image-crop/image-crop.component';\n\nexport * from './lib/components/organisms/article/article.component';\nexport * from './lib/components/organisms/article/types';\nexport * from './lib/components/organisms/banner/banner.component';\nexport * from './lib/components/organisms/banner/types';\nexport * from './lib/components/organisms/cookie-banner/cookie-banner.component';\nexport * from './lib/components/organisms/cookie-banner/types';\nexport * from './lib/components/organisms/footer/footer.component';\nexport * from './lib/components/organisms/form/factory';\nexport * from './lib/components/organisms/form/form-footer/form-footer.component';\nexport * from './lib/components/organisms/form/form.component';\nexport * from './lib/components/organisms/header/header.component';\nexport * from './lib/components/organisms/header/types';\nexport * from './lib/components/organisms/item-list/item-list.component';\nexport * from './lib/components/organisms/item-list/types';\nexport * from './lib/components/organisms/no-content/no-content.component';\nexport * from './lib/components/organisms/no-content/types';\nexport * from './lib/components/organisms/toolbar/toolbar.component';\nexport * from './lib/components/organisms/toolbar/types';\nexport * from './lib/components/organisms/wizard/types';\nexport * from './lib/components/organisms/wizard/wizard-footer/wizard-footer.component';\nexport * from './lib/components/organisms/wizard/wizard.component';\nexport * from './lib/components/organisms/comment-section/comment-section.component';\nexport * from './lib/components/organisms/comment-section/types';\nexport * from './lib/components/organisms/data-table/data-table.component';\nexport * from './lib/components/organisms/data-table/types';\nexport * from './lib/components/organisms/cards-carousel/cards-carousel.component';\nexport * from './lib/components/organisms/cards-carousel/types';\nexport * from './lib/components/organisms/testimonial-carousel/testimonial-carousel.component';\nexport * from './lib/components/organisms/testimonial-carousel/types';\nexport * from './lib/components/organisms/fun-header/fun-header.component';\nexport * from './lib/components/organisms/fun-header/types';\nexport * from './lib/components/organisms/company-footer/company-footer.component';\nexport * from './lib/components/organisms/company-footer/types';\nexport * from './lib/components/organisms/menu/menu.component';\nexport * from './lib/components/organisms/menu/types';\nexport * from './lib/components/organisms/tabbed-content/tabbed-content.component';\nexport * from './lib/components/organisms/tabbed-content/types';\nexport * from './lib/components/organisms/infinite-list/infinite-list.component';\nexport * from './lib/components/organisms/infinite-list/types';\nexport * from './lib/components/organisms/login/login.component';\nexport * from './lib/components/organisms/login/types';\nexport * from './lib/components/organisms/rotating-text/rotating-text.component';\nexport * from './lib/components/organisms/rotating-text/types';\nexport * from './lib/components/organisms/terminal-404/terminal-404.component';\nexport * from './lib/components/organisms/terminal-404/types';\nexport * from './lib/components/organisms/bottom-nav/bottom-nav.component';\nexport * from './lib/components/organisms/bottom-nav/types';\nexport * from './lib/components/organisms/avatar-upload/avatar-upload.component';\nexport * from './lib/components/organisms/avatar-upload/types';\nexport * from './lib/components/organisms/skeleton-layout/skeleton-layout.component';\nexport * from './lib/components/organisms/skeleton-layout/types';\n\nexport * from './lib/components/templates/simple/simple.component';\nexport * from './lib/components/templates/simple/types';\nexport * from './lib/components/templates/page-template/page-template.component';\nexport * from './lib/components/templates/page-template/types';\nexport * from './lib/components/templates/page-content/page-content.component';\nexport * from './lib/components/templates/page-content/types';\nexport * from './lib/components/templates/page-wrapper/page-wrapper.component';\nexport * from './lib/components/templates/page-wrapper/types';\nexport * from './lib/components/templates/maintenance-page/maintenance-page.component';\nexport * from './lib/components/templates/maintenance-page/types';\nexport * from './lib/components/templates/auth-background/auth-background.component';\nexport * from './lib/components/templates/auth-background/types';\n\nexport * from './lib/services/download.service';\nexport * from './lib/services/icons.service';\nexport * from './lib/services/in-app-browser.service';\nexport * from './lib/services/link-processor.service';\nexport * from './lib/services/local-storage.service';\nexport * from './lib/services/locale.service';\nexport * from './lib/services/navigation';\nexport * from './lib/services/theme.service';\nexport * from './lib/services/toast.service';\nexport * from './lib/services/types';\nexport * from './lib/services/confirmation-dialog/confirmation-dialog.service';\nexport * from './lib/services/confirmation-dialog/types';\nexport * from './lib/services/qr-generator/qr-generator.service';\nexport * from './lib/services/qr-generator/types';\nexport * from './lib/services/modal/modal.service';\nexport * from './lib/services/modal/types';\nexport * from './lib/services/meta';\n\n// Markdown Article Services\n// Parser Markdown → ArticleMetadata + loader para docs legales en /assets/legal/{locale}/{slug}.md\n// `parseMarkdownArticle` (pure fn, no Angular deps) usable desde Node scripts.\nexport * from './lib/services/markdown-article/markdown-article-parser';\nexport * from './lib/services/markdown-article/markdown-article-parser.service';\nexport * from './lib/services/markdown-article/legal-content.service';\n\n// Legal Link Service\n// Cross-app resolver: satellite apps redirigen links legal/site al main site\nexport * from './lib/services/legal-link/legal-link.service';\n\n// Firebase Services\n// Los servicios de Firebase requieren provideValtechFirebase() en el bootstrap de la app\nexport * from './lib/services/firebase';\n\n// Auth Services\n// Los servicios de Auth requieren provideValtechAuth() en el bootstrap de la app\nexport * from './lib/services/auth';\n\n// i18n Services\n// Sistema de internacionalización basado en Signals\n// Requiere provideValtechI18n() en el bootstrap de la app\nexport * from './lib/services/i18n';\n\n// Preferences Service\n// Read reactivo del doc /apps/{appId}/users/{uid}/preferences/main + write via PUT backend.\n// Side-effects: cuando cambia el snapshot, aplica theme + language a ThemeService + I18nService.\nexport * from './lib/services/preferences';\n\n// Page Refresh Service — bus del pull-to-refresh estándar.\n// La página activa registra su handler; val-page-wrapper dispara el gesto.\nexport * from './lib/services/page-refresh/page-refresh.service';\n\n// App Config Services\n// Sistema de configuración remota, feature flags y detección de actualizaciones\n// Requiere provideValtechAppConfig() y provideValtechFirebase() en el bootstrap de la app\nexport * from './lib/services/app-config';\n\n// Presets Services\n// Sistema de presets para configuración reutilizable de componentes\n// Requiere provideValtechPresets() en el bootstrap de la app\nexport * from './lib/services/presets';\n\n// Skeleton Services\n// Sistema de skeletons reutilizables con templates y directivas\n// Requiere provideValtechSkeleton() en el bootstrap de la app\nexport * from './lib/services/skeleton';\n\n// Pagination Services\n// Controladores de paginacion reutilizables\nexport * from './lib/services/pagination';\n\n// Image Services\n// Servicio para procesamiento de imágenes (compress, thumbnail, crop, validate)\nexport * from './lib/services/image';\n\n// Ads Services\n// Sistema de ads con Google Ad Manager (GPT)\n// Requiere provideValtechAds() en el bootstrap de la app\nexport * from './lib/services/ads';\nexport * from './lib/components/molecules/ad-slot/ad-slot.component';\n\n// Content Types\n// Abstracción de tipos de contenido que se transforman a ArticleMetadata\nexport * from './lib/services/content';\n\n// Feedback Services & Components\n// Sistema de feedback de usuarios que requiere provideValtechFeedback() en el bootstrap\nexport * from './lib/services/feedback';\nexport * from './lib/components/molecules/feedback-form/feedback-form.component';\nexport * from './lib/components/molecules/feedback-form/types';\nexport * from './lib/components/molecules/content-reaction/content-reaction.component';\nexport * from './lib/components/molecules/content-reaction/types';\n\n// Documentation Components\n// Componentes para construir documentación técnica estilo Ionic Docs\nexport * from './lib/components/templates/docs-layout/docs-layout.component';\nexport * from './lib/components/templates/docs-layout/types';\nexport * from './lib/components/organisms/docs-sidebar/docs-sidebar.component';\nexport * from './lib/components/organisms/docs-sidebar/types';\nexport * from './lib/components/organisms/docs-toc/docs-toc.component';\nexport * from './lib/components/organisms/docs-toc/types';\nexport * from './lib/components/molecules/docs-nav-links/docs-nav-links.component';\nexport * from './lib/components/molecules/docs-nav-links/types';\nexport * from './lib/components/molecules/docs-api-table/docs-api-table.component';\nexport * from './lib/components/molecules/docs-api-table/types';\nexport * from './lib/components/molecules/docs-code-example/docs-code-example.component';\nexport * from './lib/components/molecules/docs-code-example/types';\nexport * from './lib/components/molecules/docs-search/docs-search.component';\nexport * from './lib/components/molecules/docs-search/types';\nexport * from './lib/components/molecules/docs-breadcrumb/docs-breadcrumb.component';\nexport * from './lib/components/molecules/docs-breadcrumb/types';\nexport * from './lib/components/molecules/docs-callout/docs-callout.component';\nexport * from './lib/components/molecules/docs-section/docs-section.component';\nexport * from './lib/components/molecules/docs-section/types';\nexport * from './lib/components/templates/docs-page/docs-page.component';\nexport * from './lib/components/templates/docs-page/types';\nexport * from './lib/components/templates/docs-shell/docs-shell.component';\nexport * from './lib/components/templates/docs-shell/types';\nexport * from './lib/services/docs/docs-navigation.service';\n\nexport * from './lib/components/types';\nexport * from './lib/shared/pipes/process-links.pipe';\nexport * from './lib/shared/utils/datetime';\nexport * from './lib/shared/utils/dom';\nexport * from './lib/shared/utils/form-defaults';\nexport * from './lib/shared/utils/styles';\nexport * from './lib/shared/utils/text';\n\n// Shared Configuration\n// Configuración compartida para todos los productos Valtech\nexport * from './lib/config';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.js","sourceRoot":"","sources":["../../../src/public-api.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Public API Surface of valtech-components\n */\n\n// Version\nexport * from './lib/version';\n\nexport * from './lib/components/atoms/avatar/avatar.component';\nexport * from './lib/components/atoms/avatar/types';\nexport * from './lib/components/atoms/box/box.component';\nexport * from './lib/components/atoms/box/types';\nexport * from './lib/components/atoms/glow/glow.component';\nexport * from './lib/components/atoms/glow/types';\nexport * from './lib/components/atoms/container/container.component';\nexport * from './lib/components/atoms/container/types';\nexport * from './lib/components/atoms/button/button.component';\nexport * from './lib/components/atoms/button/factory';\nexport * from './lib/components/atoms/display/display.component';\nexport * from './lib/components/atoms/display/types';\nexport * from './lib/components/atoms/divider/divider.component';\nexport * from './lib/components/atoms/divider/types';\nexport * from './lib/components/atoms/href/href.component';\nexport * from './lib/components/atoms/href/types';\nexport * from './lib/components/atoms/icon/icon.component';\nexport * from './lib/components/atoms/icon/types';\nexport * from './lib/components/atoms/image/image.component';\nexport * from './lib/components/atoms/image/types';\nexport * from './lib/components/atoms/progress-bar/progress-bar.component';\nexport * from './lib/components/atoms/progress-bar/types';\nexport * from './lib/components/atoms/text/text.component';\nexport * from './lib/components/atoms/text/types';\nexport * from './lib/components/atoms/title/title.component';\nexport * from './lib/components/atoms/title/types';\nexport * from './lib/components/atoms/skeleton/skeleton.component';\nexport * from './lib/components/atoms/skeleton/types';\nexport * from './lib/components/atoms/progress-ring/progress-ring.component';\nexport * from './lib/components/atoms/progress-ring/types';\nexport * from './lib/components/atoms/fab/fab.component';\nexport * from './lib/components/atoms/fab/types';\nexport * from './lib/components/atoms/qr-code/qr-code.component';\nexport * from './lib/components/atoms/qr-code/types';\nexport * from './lib/components/atoms/countdown/countdown.component';\nexport * from './lib/components/atoms/countdown/types';\nexport * from './lib/components/atoms/price-tag/price-tag.component';\nexport * from './lib/components/atoms/price-tag/types';\nexport * from './lib/components/atoms/horizontal-scroll/horizontal-scroll.component';\nexport * from './lib/components/atoms/horizontal-scroll/types';\nexport * from './lib/components/atoms/rights-footer/rights-footer.component';\nexport * from './lib/components/atoms/rights-footer/types';\nexport * from './lib/components/atoms/pattern/pattern.component';\nexport * from './lib/components/atoms/pattern/types';\nexport * from './lib/components/atoms/pattern/motifs';\nexport * from './lib/components/atoms/glass/glass.component';\nexport { GlassMetadata } from './lib/components/atoms/glass/types';\nexport * from './lib/components/atoms/user-avatar/user-avatar.component';\nexport { UserAvatarMetadata } from './lib/components/atoms/user-avatar/types';\n\nexport * from './lib/components/molecules/alert-box/alert-box.component';\nexport * from './lib/components/molecules/alert-box/types';\nexport * from './lib/components/molecules/button-group/button-group.component';\nexport * from './lib/components/molecules/button-group/types';\nexport * from './lib/components/molecules/card/card.component';\nexport * from './lib/components/molecules/card/types';\nexport * from './lib/components/molecules/check-input/check-input.component';\nexport * from './lib/components/molecules/checkbox-radio-input/checkbox-radio-input.component';\nexport * from './lib/components/molecules/comment-input/comment-input.component';\nexport * from './lib/components/molecules/comment-input/types';\nexport * from './lib/components/molecules/content-loader/content-loader.component';\nexport * from './lib/components/molecules/content-loader/types';\nexport * from './lib/components/molecules/date-input/date-input.component';\nexport * from './lib/components/molecules/date-input/types';\nexport * from './lib/components/molecules/email-input/email-input.component';\nexport * from './lib/components/molecules/expandable-text/expandable-text.component';\nexport * from './lib/components/molecules/expandable-text/types';\nexport * from './lib/components/molecules/file-input/file-input.component';\nexport * from './lib/components/molecules/file-input/types';\nexport * from './lib/components/molecules/hint/hint.component';\nexport * from './lib/components/molecules/hour-input/hour-input.component';\nexport * from './lib/components/molecules/language-selector/language-selector.component';\nexport * from './lib/components/molecules/language-selector/types';\nexport * from './lib/components/molecules/layered-card/layered-card.component';\nexport * from './lib/components/molecules/layered-card/types';\nexport * from './lib/components/molecules/link/link.component';\nexport * from './lib/components/molecules/link/types';\nexport * from './lib/components/molecules/links-cake/links-cake.component';\nexport * from './lib/components/molecules/links-cake/types';\nexport * from './lib/components/molecules/notes-box/notes-box.component';\nexport * from './lib/components/molecules/notes-box/types';\nexport * from './lib/components/molecules/page-links/page-links.component';\nexport * from './lib/components/molecules/page-links/types';\nexport * from './lib/components/molecules/number-input/number-input.component';\nexport * from './lib/components/molecules/number-from-to/number-from-to.component';\nexport * from './lib/components/molecules/number-from-to/types';\nexport * from './lib/components/molecules/password-input/password-input.component';\nexport * from './lib/components/molecules/pin-input/pin-input.component';\nexport * from './lib/components/molecules/pin-input/types';\nexport * from './lib/components/molecules/popover-selector/popover-selector.component';\nexport * from './lib/components/molecules/popover-selector/types';\nexport * from './lib/components/molecules/progress-status/progress-status.component';\nexport * from './lib/components/molecules/progress-status/types';\nexport * from './lib/components/molecules/prompter/prompter.component';\nexport * from './lib/components/molecules/prompter/types';\nexport * from './lib/components/molecules/radio-input/radio-input.component';\nexport * from './lib/components/molecules/range-input/range-input.component';\nexport * from './lib/components/molecules/range-input/types';\nexport * from './lib/components/molecules/searchbar/searchbar.component';\nexport * from './lib/components/molecules/select-input/select-input.component';\nexport * from './lib/components/molecules/select-search/select-search.component';\nexport * from './lib/components/molecules/segment-control/segment-control.component';\nexport * from './lib/components/molecules/segment-control/types';\nexport * from './lib/components/molecules/text-input/text-input.component';\nexport * from './lib/components/molecules/toggle-input/toggle-input.component';\nexport * from './lib/components/molecules/toggle-input/types';\nexport * from './lib/components/molecules/title-block/title-block.component';\nexport * from './lib/components/molecules/title-block/types';\nexport * from './lib/components/molecules/code-display/code-display.component';\nexport * from './lib/components/molecules/code-display/types';\nexport * from './lib/components/molecules/action-header/action-header.component';\nexport * from './lib/components/molecules/action-header/types';\nexport * from './lib/components/molecules/pill/pill.component';\nexport * from './lib/components/molecules/pill/types';\nexport * from './lib/components/molecules/command-display/command-display.component';\nexport * from './lib/components/molecules/command-display/types';\nexport * from './lib/components/molecules/info/info.component';\nexport * from './lib/components/molecules/info/types';\nexport * from './lib/components/molecules/plain-code-box/plain-code-box.component';\nexport * from './lib/components/molecules/plain-code-box/types';\nexport * from './lib/components/molecules/accordion/accordion.component';\nexport * from './lib/components/molecules/accordion/types';\nexport * from './lib/components/molecules/tabs/tabs.component';\nexport * from './lib/components/molecules/tabs/types';\nexport * from './lib/components/molecules/breadcrumb/breadcrumb.component';\nexport * from './lib/components/molecules/breadcrumb/types';\nexport * from './lib/components/molecules/pagination/pagination.component';\nexport * from './lib/components/molecules/pagination/types';\nexport * from './lib/components/molecules/stepper/stepper.component';\nexport * from './lib/components/molecules/stepper/types';\nexport * from './lib/components/molecules/chip-group/chip-group.component';\nexport * from './lib/components/molecules/chip-group/types';\nexport * from './lib/components/molecules/rating/rating.component';\nexport * from './lib/components/molecules/rating/types';\nexport * from './lib/components/molecules/timeline/timeline.component';\nexport * from './lib/components/molecules/timeline/types';\nexport * from './lib/components/molecules/stats-card/stats-card.component';\nexport * from './lib/components/molecules/stats-card/types';\nexport * from './lib/components/molecules/comment/comment.component';\nexport * from './lib/components/molecules/comment/types';\nexport * from './lib/components/molecules/multi-select-search/multi-select-search.component';\nexport * from './lib/components/molecules/quote-box/quote-box.component';\nexport * from './lib/components/molecules/textarea-input/textarea-input.component';\nexport * from './lib/components/molecules/textarea-input/types';\nexport * from './lib/components/molecules/phone-input/phone-input.component';\nexport * from './lib/components/molecules/phone-input/types';\nexport * from './lib/components/molecules/currency-input/currency-input.component';\nexport * from './lib/components/molecules/currency-input/types';\nexport * from './lib/components/molecules/date-range-input/date-range-input.component';\nexport * from './lib/components/molecules/date-range-input/types';\nexport * from './lib/components/molecules/number-stepper/number-stepper.component';\nexport * from './lib/components/molecules/number-stepper/types';\nexport * from './lib/components/molecules/share-buttons/share-buttons.component';\nexport * from './lib/components/molecules/share-buttons/types';\nexport * from './lib/components/molecules/glow-card/glow-card.component';\nexport * from './lib/components/molecules/glow-card/types';\nexport * from './lib/components/molecules/swipe-carousel/swipe-carousel.component';\nexport * from './lib/components/molecules/swipe-carousel/types';\nexport * from './lib/components/molecules/testimonial-card/testimonial-card.component';\nexport * from './lib/components/molecules/testimonial-card/types';\nexport * from './lib/components/molecules/features-list/features-list.component';\nexport * from './lib/components/molecules/features-list/types';\nexport * from './lib/components/molecules/footer-links/footer-links.component';\nexport * from './lib/components/molecules/footer-links/types';\nexport * from './lib/components/molecules/links-accordion/links-accordion.component';\nexport * from './lib/components/molecules/links-accordion/types';\nexport * from './lib/components/molecules/refresher/refresher.component';\nexport * from './lib/components/molecules/refresher/types';\nexport * from './lib/components/molecules/update-banner/update-banner.component';\nexport * from './lib/components/molecules/action-card/action-card.component';\nexport * from './lib/components/molecules/action-card/types';\nexport * from './lib/components/molecules/username-input/username-input.component';\nexport * from './lib/components/molecules/username-input/types';\nexport * from './lib/components/molecules/linked-providers/linked-providers.component';\nexport * from './lib/components/molecules/linked-providers/types';\nexport * from './lib/components/molecules/image-crop/image-crop.component';\n\nexport * from './lib/components/organisms/article/article.component';\nexport * from './lib/components/organisms/article/types';\nexport * from './lib/components/organisms/banner/banner.component';\nexport * from './lib/components/organisms/banner/types';\nexport * from './lib/components/organisms/cookie-banner/cookie-banner.component';\nexport * from './lib/components/organisms/cookie-banner/types';\nexport * from './lib/components/organisms/footer/footer.component';\nexport * from './lib/components/organisms/form/factory';\nexport * from './lib/components/organisms/form/form-footer/form-footer.component';\nexport * from './lib/components/organisms/form/form.component';\nexport * from './lib/components/organisms/header/header.component';\nexport * from './lib/components/organisms/header/types';\nexport * from './lib/components/organisms/item-list/item-list.component';\nexport * from './lib/components/organisms/item-list/types';\nexport * from './lib/components/organisms/no-content/no-content.component';\nexport * from './lib/components/organisms/no-content/types';\nexport * from './lib/components/organisms/toolbar/toolbar.component';\nexport * from './lib/components/organisms/toolbar/types';\nexport * from './lib/components/organisms/wizard/types';\nexport * from './lib/components/organisms/wizard/wizard-footer/wizard-footer.component';\nexport * from './lib/components/organisms/wizard/wizard.component';\nexport * from './lib/components/organisms/comment-section/comment-section.component';\nexport * from './lib/components/organisms/comment-section/types';\nexport * from './lib/components/organisms/data-table/data-table.component';\nexport * from './lib/components/organisms/data-table/types';\nexport * from './lib/components/organisms/cards-carousel/cards-carousel.component';\nexport * from './lib/components/organisms/cards-carousel/types';\nexport * from './lib/components/organisms/testimonial-carousel/testimonial-carousel.component';\nexport * from './lib/components/organisms/testimonial-carousel/types';\nexport * from './lib/components/organisms/fun-header/fun-header.component';\nexport * from './lib/components/organisms/fun-header/types';\nexport * from './lib/components/organisms/company-footer/company-footer.component';\nexport * from './lib/components/organisms/company-footer/types';\nexport * from './lib/components/organisms/menu/menu.component';\nexport * from './lib/components/organisms/menu/types';\nexport * from './lib/components/organisms/tabbed-content/tabbed-content.component';\nexport * from './lib/components/organisms/tabbed-content/types';\nexport * from './lib/components/organisms/infinite-list/infinite-list.component';\nexport * from './lib/components/organisms/infinite-list/types';\nexport * from './lib/components/organisms/login/login.component';\nexport * from './lib/components/organisms/login/types';\nexport * from './lib/components/organisms/rotating-text/rotating-text.component';\nexport * from './lib/components/organisms/rotating-text/types';\nexport * from './lib/components/organisms/terminal-404/terminal-404.component';\nexport * from './lib/components/organisms/terminal-404/types';\nexport * from './lib/components/organisms/bottom-nav/bottom-nav.component';\nexport * from './lib/components/organisms/bottom-nav/types';\nexport * from './lib/components/organisms/avatar-upload/avatar-upload.component';\nexport * from './lib/components/organisms/avatar-upload/types';\nexport * from './lib/components/organisms/skeleton-layout/skeleton-layout.component';\nexport * from './lib/components/organisms/skeleton-layout/types';\n\nexport * from './lib/components/templates/simple/simple.component';\nexport * from './lib/components/templates/simple/types';\nexport * from './lib/components/templates/page-template/page-template.component';\nexport * from './lib/components/templates/page-template/types';\nexport * from './lib/components/templates/page-content/page-content.component';\nexport * from './lib/components/templates/page-content/types';\nexport * from './lib/components/templates/page-wrapper/page-wrapper.component';\nexport * from './lib/components/templates/page-wrapper/types';\nexport * from './lib/components/templates/maintenance-page/maintenance-page.component';\nexport * from './lib/components/templates/maintenance-page/types';\nexport * from './lib/components/templates/auth-background/auth-background.component';\nexport * from './lib/components/templates/auth-background/types';\n\nexport * from './lib/services/download.service';\nexport * from './lib/services/icons.service';\nexport * from './lib/services/in-app-browser.service';\nexport * from './lib/services/link-processor.service';\nexport * from './lib/services/local-storage.service';\nexport * from './lib/services/locale.service';\nexport * from './lib/services/navigation';\nexport * from './lib/services/theme.service';\nexport * from './lib/services/toast.service';\nexport * from './lib/services/types';\nexport * from './lib/services/confirmation-dialog/confirmation-dialog.service';\nexport * from './lib/services/confirmation-dialog/types';\nexport * from './lib/services/qr-generator/qr-generator.service';\nexport * from './lib/services/qr-generator/types';\nexport * from './lib/services/modal/modal.service';\nexport * from './lib/services/modal/types';\nexport * from './lib/services/meta';\n\n// Markdown Article Services\n// Parser Markdown → ArticleMetadata + loader para docs legales en /assets/legal/{locale}/{slug}.md\n// `parseMarkdownArticle` (pure fn, no Angular deps) usable desde Node scripts.\nexport * from './lib/services/markdown-article/markdown-article-parser';\nexport * from './lib/services/markdown-article/markdown-article-parser.service';\nexport * from './lib/services/markdown-article/legal-content.service';\n\n// Legal Link Service\n// Cross-app resolver: satellite apps redirigen links legal/site al main site\nexport * from './lib/services/legal-link/legal-link.service';\n\n// Firebase Services\n// Los servicios de Firebase requieren provideValtechFirebase() en el bootstrap de la app\nexport * from './lib/services/firebase';\n\n// Auth Services\n// Los servicios de Auth requieren provideValtechAuth() en el bootstrap de la app\nexport * from './lib/services/auth';\n\n// i18n Services\n// Sistema de internacionalización basado en Signals\n// Requiere provideValtechI18n() en el bootstrap de la app\nexport * from './lib/services/i18n';\n\n// Preferences Service\n// Read reactivo del doc /apps/{appId}/users/{uid}/preferences/main + write via PUT backend.\n// Side-effects: cuando cambia el snapshot, aplica theme + language a ThemeService + I18nService.\nexport * from './lib/services/preferences';\n\n// Page Refresh Service — bus del pull-to-refresh estándar.\n// La página activa registra su handler; val-page-wrapper dispara el gesto.\nexport * from './lib/services/page-refresh/page-refresh.service';\n\n// Refreshable Stream — helper estándar para vistas con datos Firestore.\n// `createRefreshableStream` soporta modo one-shot y real-time, gateado por\n// `firebaseAuthReady` (cierra la ventana de permission-denied en cold start).\nexport * from './lib/services/refreshable-stream';\n\n// App Config Services\n// Sistema de configuración remota, feature flags y detección de actualizaciones\n// Requiere provideValtechAppConfig() y provideValtechFirebase() en el bootstrap de la app\nexport * from './lib/services/app-config';\n\n// Presets Services\n// Sistema de presets para configuración reutilizable de componentes\n// Requiere provideValtechPresets() en el bootstrap de la app\nexport * from './lib/services/presets';\n\n// Skeleton Services\n// Sistema de skeletons reutilizables con templates y directivas\n// Requiere provideValtechSkeleton() en el bootstrap de la app\nexport * from './lib/services/skeleton';\n\n// Pagination Services\n// Controladores de paginacion reutilizables\nexport * from './lib/services/pagination';\n\n// Image Services\n// Servicio para procesamiento de imágenes (compress, thumbnail, crop, validate)\nexport * from './lib/services/image';\n\n// Ads Services\n// Sistema de ads con Google Ad Manager (GPT)\n// Requiere provideValtechAds() en el bootstrap de la app\nexport * from './lib/services/ads';\nexport * from './lib/components/molecules/ad-slot/ad-slot.component';\n\n// Content Types\n// Abstracción de tipos de contenido que se transforman a ArticleMetadata\nexport * from './lib/services/content';\n\n// Feedback Services & Components\n// Sistema de feedback de usuarios que requiere provideValtechFeedback() en el bootstrap\nexport * from './lib/services/feedback';\n\n// Donation / Support — aportes voluntarios. Requiere provideValtechDonations()\nexport * from './lib/services/donation';\nexport * from './lib/components/molecules/feedback-form/feedback-form.component';\nexport * from './lib/components/molecules/feedback-form/types';\nexport * from './lib/components/molecules/content-reaction/content-reaction.component';\nexport * from './lib/components/molecules/content-reaction/types';\n\n// Documentation Components\n// Componentes para construir documentación técnica estilo Ionic Docs\nexport * from './lib/components/templates/docs-layout/docs-layout.component';\nexport * from './lib/components/templates/docs-layout/types';\nexport * from './lib/components/organisms/docs-sidebar/docs-sidebar.component';\nexport * from './lib/components/organisms/docs-sidebar/types';\nexport * from './lib/components/organisms/docs-toc/docs-toc.component';\nexport * from './lib/components/organisms/docs-toc/types';\nexport * from './lib/components/molecules/docs-nav-links/docs-nav-links.component';\nexport * from './lib/components/molecules/docs-nav-links/types';\nexport * from './lib/components/molecules/docs-api-table/docs-api-table.component';\nexport * from './lib/components/molecules/docs-api-table/types';\nexport * from './lib/components/molecules/docs-code-example/docs-code-example.component';\nexport * from './lib/components/molecules/docs-code-example/types';\nexport * from './lib/components/molecules/docs-search/docs-search.component';\nexport * from './lib/components/molecules/docs-search/types';\nexport * from './lib/components/molecules/docs-breadcrumb/docs-breadcrumb.component';\nexport * from './lib/components/molecules/docs-breadcrumb/types';\nexport * from './lib/components/molecules/docs-callout/docs-callout.component';\nexport * from './lib/components/molecules/docs-section/docs-section.component';\nexport * from './lib/components/molecules/docs-section/types';\nexport * from './lib/components/templates/docs-page/docs-page.component';\nexport * from './lib/components/templates/docs-page/types';\nexport * from './lib/components/templates/docs-shell/docs-shell.component';\nexport * from './lib/components/templates/docs-shell/types';\nexport * from './lib/services/docs/docs-navigation.service';\n\nexport * from './lib/components/types';\nexport * from './lib/shared/pipes/process-links.pipe';\nexport * from './lib/shared/utils/datetime';\nexport * from './lib/shared/utils/dom';\nexport * from './lib/shared/utils/form-defaults';\nexport * from './lib/shared/utils/styles';\nexport * from './lib/shared/utils/text';\n\n// Shared Configuration\n// Configuración compartida para todos los productos Valtech\nexport * from './lib/config';\n"]}