valtech-components 2.0.498 → 2.0.501

package/esm2022/lib/services/firebase/analytics-error-handler.mjs

@@ -0,0 +1,141 @@
+/**
+ * Analytics Error Handler
+ *
+ * ErrorHandler personalizado que envía errores no capturados a Firebase Analytics.
+ * Se activa si enableErrorTracking=true en analyticsConfig.
+ */
+import { ErrorHandler, Injectable, inject } from '@angular/core';
+import { AnalyticsService } from './analytics.service';
+import * as i0 from "@angular/core";
+/**
+ * ErrorHandler que trackea errores en Firebase Analytics.
+ *
+ * Captura errores no manejados de la aplicación y los envía a GA4
+ * como eventos 'error_occurred'. También delega al ErrorHandler
+ * default para mantener el comportamiento de console.error.
+ *
+ * @example
+ * ```typescript
+ * // Se activa automáticamente si enableErrorTracking=true
+ * provideValtechFirebase({
+ *   firebase: environment.firebase,
+ *   enableAnalytics: true,
+ *   analyticsConfig: {
+ *     enableErrorTracking: true,
+ *   },
+ * });
+ * ```
+ */
+export class AnalyticsErrorHandler {
+    constructor() {
+        this.analytics = inject(AnalyticsService);
+        this.defaultHandler = new ErrorHandler();
+    }
+    /**
+     * Maneja un error no capturado.
+     * Envía el error a Analytics y luego al handler default.
+     */
+    handleError(error) {
+        // Enviar a Analytics
+        try {
+            this.trackError(error);
+        }
+        catch (trackingError) {
+            // No fallar si el tracking falla
+            console.warn('[AnalyticsErrorHandler] Error tracking failed:', trackingError);
+        }
+        // Delegar al handler default (console.error)
+        this.defaultHandler.handleError(error);
+    }
+    /**
+     * Trackea el error en Analytics
+     */
+    trackError(error) {
+        // Extraer información del error
+        const errorInfo = this.extractErrorInfo(error);
+        this.analytics.logError(errorInfo.error, {
+            source: 'uncaught',
+            url: this.getCurrentUrl(),
+            ...errorInfo.context,
+        });
+    }
+    /**
+     * Extrae información útil del error
+     */
+    extractErrorInfo(error) {
+        const context = {};
+        // Error estándar
+        if (error instanceof Error) {
+            // Detectar errores de chunk loading (lazy loading)
+            if (error.message.includes('Loading chunk')) {
+                context['error_category'] = 'chunk_loading';
+            }
+            // Detectar errores de red
+            if (error.message.includes('NetworkError') || error.message.includes('Failed to fetch')) {
+                context['error_category'] = 'network';
+            }
+            return { error, context };
+        }
+        // ErrorEvent (ej: errores de script)
+        if (typeof ErrorEvent !== 'undefined' && error instanceof ErrorEvent) {
+            return {
+                error: new Error(error.message || 'Script error'),
+                context: {
+                    filename: error.filename || 'unknown',
+                    lineno: String(error.lineno || 0),
+                    colno: String(error.colno || 0),
+                },
+            };
+        }
+        // PromiseRejection
+        if (this.isPromiseRejection(error)) {
+            const reason = error.reason;
+            if (reason instanceof Error) {
+                return {
+                    error: reason,
+                    context: { error_category: 'unhandled_promise' },
+                };
+            }
+            return {
+                error: new Error(String(reason) || 'Unhandled promise rejection'),
+                context: { error_category: 'unhandled_promise' },
+            };
+        }
+        // Objeto con message
+        if (error && typeof error === 'object' && 'message' in error) {
+            return {
+                error: new Error(String(error.message)),
+                context,
+            };
+        }
+        // Fallback: convertir a string
+        return {
+            error: new Error(String(error) || 'Unknown error'),
+            context,
+        };
+    }
+    /**
+     * Verifica si es un PromiseRejectionEvent
+     */
+    isPromiseRejection(error) {
+        return (typeof PromiseRejectionEvent !== 'undefined' &&
+            error instanceof PromiseRejectionEvent);
+    }
+    /**
+     * Obtiene la URL actual de forma segura
+     */
+    getCurrentUrl() {
+        try {
+            return window?.location?.href || 'unknown';
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnalyticsErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnalyticsErrorHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnalyticsErrorHandler, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analytics-error-handler.js","sourceRoot":"","sources":["../../../../../../src/lib/services/firebase/analytics-error-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Analytics Error Handler\n *\n * ErrorHandler personalizado que envía errores no capturados a Firebase Analytics.\n * Se activa si enableErrorTracking=true en analyticsConfig.\n */\n\nimport { ErrorHandler, Injectable, inject } from '@angular/core';\nimport { AnalyticsService } from './analytics.service';\n\n/**\n * ErrorHandler que trackea errores en Firebase Analytics.\n *\n * Captura errores no manejados de la aplicación y los envía a GA4\n * como eventos 'error_occurred'. También delega al ErrorHandler\n * default para mantener el comportamiento de console.error.\n *\n * @example\n * ```typescript\n * // Se activa automáticamente si enableErrorTracking=true\n * provideValtechFirebase({\n *   firebase: environment.firebase,\n *   enableAnalytics: true,\n *   analyticsConfig: {\n *     enableErrorTracking: true,\n *   },\n * });\n * ```\n */\n@Injectable()\nexport class AnalyticsErrorHandler implements ErrorHandler {\n  private readonly analytics = inject(AnalyticsService);\n  private readonly defaultHandler = new ErrorHandler();\n\n  /**\n   * Maneja un error no capturado.\n   * Envía el error a Analytics y luego al handler default.\n   */\n  handleError(error: unknown): void {\n    // Enviar a Analytics\n    try {\n      this.trackError(error);\n    } catch (trackingError) {\n      // No fallar si el tracking falla\n      console.warn('[AnalyticsErrorHandler] Error tracking failed:', trackingError);\n    }\n\n    // Delegar al handler default (console.error)\n    this.defaultHandler.handleError(error);\n  }\n\n  /**\n   * Trackea el error en Analytics\n   */\n  private trackError(error: unknown): void {\n    // Extraer información del error\n    const errorInfo = this.extractErrorInfo(error);\n\n    this.analytics.logError(\n      errorInfo.error,\n      {\n        source: 'uncaught',\n        url: this.getCurrentUrl(),\n        ...errorInfo.context,\n      }\n    );\n  }\n\n  /**\n   * Extrae información útil del error\n   */\n  private extractErrorInfo(error: unknown): {\n    error: Error;\n    context: Record<string, string>;\n  } {\n    const context: Record<string, string> = {};\n\n    // Error estándar\n    if (error instanceof Error) {\n      // Detectar errores de chunk loading (lazy loading)\n      if (error.message.includes('Loading chunk')) {\n        context['error_category'] = 'chunk_loading';\n      }\n\n      // Detectar errores de red\n      if (error.message.includes('NetworkError') || error.message.includes('Failed to fetch')) {\n        context['error_category'] = 'network';\n      }\n\n      return { error, context };\n    }\n\n    // ErrorEvent (ej: errores de script)\n    if (typeof ErrorEvent !== 'undefined' && error instanceof ErrorEvent) {\n      return {\n        error: new Error(error.message || 'Script error'),\n        context: {\n          filename: error.filename || 'unknown',\n          lineno: String(error.lineno || 0),\n          colno: String(error.colno || 0),\n        },\n      };\n    }\n\n    // PromiseRejection\n    if (this.isPromiseRejection(error)) {\n      const reason = (error as PromiseRejectionEvent).reason;\n      if (reason instanceof Error) {\n        return {\n          error: reason,\n          context: { error_category: 'unhandled_promise' },\n        };\n      }\n      return {\n        error: new Error(String(reason) || 'Unhandled promise rejection'),\n        context: { error_category: 'unhandled_promise' },\n      };\n    }\n\n    // Objeto con message\n    if (error && typeof error === 'object' && 'message' in error) {\n      return {\n        error: new Error(String((error as { message: unknown }).message)),\n        context,\n      };\n    }\n\n    // Fallback: convertir a string\n    return {\n      error: new Error(String(error) || 'Unknown error'),\n      context,\n    };\n  }\n\n  /**\n   * Verifica si es un PromiseRejectionEvent\n   */\n  private isPromiseRejection(error: unknown): boolean {\n    return (\n      typeof PromiseRejectionEvent !== 'undefined' &&\n      error instanceof PromiseRejectionEvent\n    );\n  }\n\n  /**\n   * Obtiene la URL actual de forma segura\n   */\n  private getCurrentUrl(): string {\n    try {\n      return window?.location?.href || 'unknown';\n    } catch {\n      return 'unknown';\n    }\n  }\n}\n"]}

package/esm2022/lib/services/firebase/analytics-router-tracker.mjs

@@ -0,0 +1,99 @@
+/**
+ * Analytics Router Tracker
+ *
+ * Servicio que trackea automáticamente page views cuando el usuario navega.
+ * Se activa automáticamente si enablePageViewTracking=true en analyticsConfig.
+ */
+import { DestroyRef, Inject, Injectable, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { NavigationEnd, Router } from '@angular/router';
+import { filter } from 'rxjs/operators';
+import { VALTECH_FIREBASE_CONFIG } from './config';
+import { AnalyticsService } from './analytics.service';
+import * as i0 from "@angular/core";
+/**
+ * Tracker automático de page views via Router.
+ *
+ * Este servicio escucha eventos de navegación del Router y registra
+ * page views automáticamente en Firebase Analytics.
+ *
+ * Se excluyen rutas configuradas en `analyticsConfig.excludeRoutes`.
+ *
+ * @example
+ * ```typescript
+ * // Se activa automáticamente si enablePageViewTracking=true
+ * provideValtechFirebase({
+ *   firebase: environment.firebase,
+ *   enableAnalytics: true,
+ *   analyticsConfig: {
+ *     enablePageViewTracking: true,
+ *     excludeRoutes: ['/admin/*', '/debug/*'],
+ *   },
+ * });
+ * ```
+ */
+export class AnalyticsRouterTracker {
+    constructor(config) {
+        this.config = config;
+        this.analytics = inject(AnalyticsService);
+        this.router = inject(Router);
+        this.destroyRef = inject(DestroyRef);
+        const analyticsConfig = config.analyticsConfig ?? {};
+        this.enabled = analyticsConfig.enablePageViewTracking !== false;
+        this.excludePatterns = this.compileExcludePatterns(analyticsConfig.excludeRoutes ?? []);
+        if (this.enabled && config.enableAnalytics) {
+            this.startTracking();
+        }
+    }
+    /**
+     * Inicia el tracking de navegación
+     */
+    startTracking() {
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd), filter((event) => !this.isExcluded(event.urlAfterRedirects)), takeUntilDestroyed(this.destroyRef))
+            .subscribe((event) => {
+            this.analytics.logPageView(event.urlAfterRedirects);
+        });
+    }
+    /**
+     * Compila patrones de exclusión a RegExp
+     */
+    compileExcludePatterns(patterns) {
+        return patterns.map((pattern) => {
+            // Convertir glob pattern a regex
+            // Ej: '/admin/*' -> /^\/admin\/.*$/
+            const regexPattern = pattern
+                .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escapar caracteres especiales
+                .replace(/\*/g, '.*'); // Convertir * a .*
+            return new RegExp(`^${regexPattern}$`);
+        });
+    }
+    /**
+     * Verifica si una URL debe ser excluida del tracking
+     */
+    isExcluded(url) {
+        // Remover query params para la comparación
+        const path = url.split('?')[0];
+        return this.excludePatterns.some((pattern) => pattern.test(path));
+    }
+    /**
+     * Registra un page view manualmente.
+     * Útil para casos donde necesitas trackear manualmente.
+     */
+    trackPageView(path, title) {
+        if (this.isExcluded(path)) {
+            return;
+        }
+        this.analytics.logPageView(path, title);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnalyticsRouterTracker, deps: [{ token: VALTECH_FIREBASE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnalyticsRouterTracker, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnalyticsRouterTracker, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_FIREBASE_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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