valtech-components 2.0.691 → 2.0.692

package/esm2022/lib/services/firebase/config.mjs

@@ -0,0 +1,131 @@
+/**
+ * Firebase Configuration
+ *
+ * Configuración e inicialización de Firebase para aplicaciones Angular.
+ * Usa provideValtechFirebase() en el bootstrap de tu aplicación.
+ */
+import { ErrorHandler, InjectionToken, makeEnvironmentProviders } from '@angular/core';
+import { getAnalytics, provideAnalytics } from '@angular/fire/analytics';
+import { initializeApp, provideFirebaseApp } from '@angular/fire/app';
+import { connectAuthEmulator, getAuth, provideAuth } from '@angular/fire/auth';
+import { connectFirestoreEmulator, enableIndexedDbPersistence, getFirestore, provideFirestore, } from '@angular/fire/firestore';
+import { getMessaging, provideMessaging } from '@angular/fire/messaging';
+import { connectStorageEmulator, getStorage, provideStorage } from '@angular/fire/storage';
+import { AnalyticsErrorHandler } from './analytics-error-handler';
+import { AnalyticsRouterTracker } from './analytics-router-tracker';
+/**
+ * Token de inyección para la configuración de Firebase.
+ * Usado internamente por los servicios de Firebase.
+ */
+export const VALTECH_FIREBASE_CONFIG = new InjectionToken('ValtechFirebaseConfig');
+/**
+ * Provee Firebase a la aplicación Angular.
+ *
+ * @param config - Configuración de Firebase
+ * @returns EnvironmentProviders para usar en bootstrapApplication
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { provideValtechFirebase } from 'valtech-components';
+ * import { environment } from './environments/environment';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechFirebase({
+ *       firebase: environment.firebase,
+ *       persistence: true,
+ *       emulator: environment.useEmulators ? {
+ *         firestore: { host: 'localhost', port: 8080 },
+ *         auth: { host: 'localhost', port: 9099 },
+ *         storage: { host: 'localhost', port: 9199 },
+ *       } : undefined,
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export function provideValtechFirebase(config) {
+    // Construir array de providers base
+    const providers = [
+        // Guardar configuración para uso en servicios
+        { provide: VALTECH_FIREBASE_CONFIG, useValue: config },
+        // Inicializar Firebase App
+        provideFirebaseApp(() => initializeApp(config.firebase)),
+        // Firestore con soporte para emuladores y persistencia
+        provideFirestore(() => {
+            const firestore = getFirestore();
+            // Conectar a emulador si está configurado
+            if (config.emulator?.firestore) {
+                connectFirestoreEmulator(firestore, config.emulator.firestore.host, config.emulator.firestore.port);
+            }
+            // Habilitar persistencia offline si está configurada
+            if (config.persistence) {
+                enableIndexedDbPersistence(firestore).catch((err) => {
+                    if (err.code === 'failed-precondition') {
+                        console.warn('[ValtechFirebase] Persistencia no disponible: múltiples pestañas abiertas');
+                    }
+                    else if (err.code === 'unimplemented') {
+                        console.warn('[ValtechFirebase] Persistencia no soportada en este navegador');
+                    }
+                });
+            }
+            return firestore;
+        }),
+        // Auth con soporte para emulador
+        provideAuth(() => {
+            const auth = getAuth();
+            // Conectar a emulador si está configurado
+            if (config.emulator?.auth) {
+                connectAuthEmulator(auth, `http://${config.emulator.auth.host}:${config.emulator.auth.port}`, { disableWarnings: true });
+            }
+            return auth;
+        }),
+        // Storage con soporte para emulador
+        provideStorage(() => {
+            const storage = getStorage();
+            // Conectar a emulador si está configurado
+            if (config.emulator?.storage) {
+                connectStorageEmulator(storage, config.emulator.storage.host, config.emulator.storage.port);
+            }
+            return storage;
+        }),
+    ];
+    // Messaging (FCM) - solo si está explícitamente habilitado
+    // Requiere Service Worker configurado, puede congelar la app si no está disponible
+    if (config.enableMessaging) {
+        // Pre-registrar SW custom antes de que Firebase lo intente
+        if (typeof navigator !== 'undefined' && 'serviceWorker' in navigator) {
+            navigator.serviceWorker.register('/firebase-messaging-sw.js').catch(console.error);
+        }
+        providers.push(provideMessaging(() => getMessaging()));
+    }
+    // Analytics (GA4) - solo si está explícitamente habilitado
+    // Requiere measurementId en firebase config
+    if (config.enableAnalytics && config.firebase.measurementId) {
+        providers.push(provideAnalytics(() => getAnalytics()));
+        // Router tracker para page views automáticos (por defecto habilitado)
+        if (config.analyticsConfig?.enablePageViewTracking !== false) {
+            providers.push(AnalyticsRouterTracker);
+        }
+        // Error handler para tracking automático de errores
+        if (config.analyticsConfig?.enableErrorTracking) {
+            providers.push({
+                provide: ErrorHandler,
+                useClass: AnalyticsErrorHandler,
+            });
+        }
+    }
+    return makeEnvironmentProviders(providers);
+}
+/**
+ * Verifica si los emuladores están configurados.
+ *
+ * @param config - Configuración de Firebase
+ * @returns true si hay al menos un emulador configurado
+ */
+export function hasEmulators(config) {
+    return !!(config.emulator?.firestore || config.emulator?.auth || config.emulator?.storage);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../../../../src/lib/services/firebase/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Firebase Configuration\n *\n * Configuración e inicialización de Firebase para aplicaciones Angular.\n * Usa provideValtechFirebase() en el bootstrap de tu aplicación.\n */\n\nimport { EnvironmentProviders, ErrorHandler, InjectionToken, makeEnvironmentProviders } from '@angular/core';\nimport { getAnalytics, provideAnalytics, ScreenTrackingService } from '@angular/fire/analytics';\nimport { initializeApp, provideFirebaseApp } from '@angular/fire/app';\nimport { connectAuthEmulator, getAuth, provideAuth } from '@angular/fire/auth';\nimport {\n  connectFirestoreEmulator,\n  enableIndexedDbPersistence,\n  getFirestore,\n  provideFirestore,\n} from '@angular/fire/firestore';\nimport { getMessaging, provideMessaging } from '@angular/fire/messaging';\nimport { connectStorageEmulator, getStorage, provideStorage } from '@angular/fire/storage';\n\nimport { ValtechFirebaseConfig } from './types';\nimport { AnalyticsErrorHandler } from './analytics-error-handler';\nimport { AnalyticsRouterTracker } from './analytics-router-tracker';\n\n/**\n * Token de inyección para la configuración de Firebase.\n * Usado internamente por los servicios de Firebase.\n */\nexport const VALTECH_FIREBASE_CONFIG = new InjectionToken<ValtechFirebaseConfig>(\n  'ValtechFirebaseConfig'\n);\n\n/**\n * Provee Firebase a la aplicación Angular.\n *\n * @param config - Configuración de Firebase\n * @returns EnvironmentProviders para usar en bootstrapApplication\n *\n * @example\n * ```typescript\n * // main.ts\n * import { bootstrapApplication } from '@angular/platform-browser';\n * import { provideValtechFirebase } from 'valtech-components';\n * import { environment } from './environments/environment';\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [\n *     provideValtechFirebase({\n *       firebase: environment.firebase,\n *       persistence: true,\n *       emulator: environment.useEmulators ? {\n *         firestore: { host: 'localhost', port: 8080 },\n *         auth: { host: 'localhost', port: 9099 },\n *         storage: { host: 'localhost', port: 9199 },\n *       } : undefined,\n *     }),\n *   ],\n * });\n * ```\n */\nexport function provideValtechFirebase(config: ValtechFirebaseConfig): EnvironmentProviders {\n  // Construir array de providers base\n  const providers: any[] = [\n    // Guardar configuración para uso en servicios\n    { provide: VALTECH_FIREBASE_CONFIG, useValue: config },\n\n    // Inicializar Firebase App\n    provideFirebaseApp(() => initializeApp(config.firebase)),\n\n    // Firestore con soporte para emuladores y persistencia\n    provideFirestore(() => {\n      const firestore = getFirestore();\n\n      // Conectar a emulador si está configurado\n      if (config.emulator?.firestore) {\n        connectFirestoreEmulator(\n          firestore,\n          config.emulator.firestore.host,\n          config.emulator.firestore.port\n        );\n      }\n\n      // Habilitar persistencia offline si está configurada\n      if (config.persistence) {\n        enableIndexedDbPersistence(firestore).catch((err) => {\n          if (err.code === 'failed-precondition') {\n            console.warn(\n              '[ValtechFirebase] Persistencia no disponible: múltiples pestañas abiertas'\n            );\n          } else if (err.code === 'unimplemented') {\n            console.warn('[ValtechFirebase] Persistencia no soportada en este navegador');\n          }\n        });\n      }\n\n      return firestore;\n    }),\n\n    // Auth con soporte para emulador\n    provideAuth(() => {\n      const auth = getAuth();\n\n      // Conectar a emulador si está configurado\n      if (config.emulator?.auth) {\n        connectAuthEmulator(\n          auth,\n          `http://${config.emulator.auth.host}:${config.emulator.auth.port}`,\n          { disableWarnings: true }\n        );\n      }\n\n      return auth;\n    }),\n\n    // Storage con soporte para emulador\n    provideStorage(() => {\n      const storage = getStorage();\n\n      // Conectar a emulador si está configurado\n      if (config.emulator?.storage) {\n        connectStorageEmulator(\n          storage,\n          config.emulator.storage.host,\n          config.emulator.storage.port\n        );\n      }\n\n      return storage;\n    }),\n  ];\n\n  // Messaging (FCM) - solo si está explícitamente habilitado\n  // Requiere Service Worker configurado, puede congelar la app si no está disponible\n  if (config.enableMessaging) {\n    // Pre-registrar SW custom antes de que Firebase lo intente\n    if (typeof navigator !== 'undefined' && 'serviceWorker' in navigator) {\n      navigator.serviceWorker.register('/firebase-messaging-sw.js').catch(console.error);\n    }\n    providers.push(provideMessaging(() => getMessaging()));\n  }\n\n  // Analytics (GA4) - solo si está explícitamente habilitado\n  // Requiere measurementId en firebase config\n  if (config.enableAnalytics && config.firebase.measurementId) {\n    providers.push(provideAnalytics(() => getAnalytics()));\n\n    // Router tracker para page views automáticos (por defecto habilitado)\n    if (config.analyticsConfig?.enablePageViewTracking !== false) {\n      providers.push(AnalyticsRouterTracker);\n    }\n\n    // Error handler para tracking automático de errores\n    if (config.analyticsConfig?.enableErrorTracking) {\n      providers.push({\n        provide: ErrorHandler,\n        useClass: AnalyticsErrorHandler,\n      });\n    }\n  }\n\n  return makeEnvironmentProviders(providers);\n}\n\n/**\n * Verifica si los emuladores están configurados.\n *\n * @param config - Configuración de Firebase\n * @returns true si hay al menos un emulador configurado\n */\nexport function hasEmulators(config: ValtechFirebaseConfig): boolean {\n  return !!(config.emulator?.firestore || config.emulator?.auth || config.emulator?.storage);\n}\n"]}