valtech-components 2.0.500 → 2.0.501

package/esm2022/lib/services/ads/ads-consent.service.mjs

@@ -0,0 +1,152 @@
+/**
+ * Ads Consent Service
+ *
+ * Integra el servicio de Ads con el Consent Mode v2 existente en AnalyticsService.
+ * Proporciona estado de consent especifico para ads (advertising).
+ */
+import { Injectable, Injector, PLATFORM_ID, inject, signal, computed } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import * as i0 from "@angular/core";
+/**
+ * Servicio que maneja el consent para ads.
+ *
+ * Se integra con AnalyticsService para reutilizar el estado de consent GDPR.
+ * Si AnalyticsService no esta disponible, usa valores por defecto conservadores.
+ */
+export class AdsConsentService {
+    constructor() {
+        this.platformId = inject(PLATFORM_ID);
+        this.injector = inject(Injector);
+        // Cache del estado de consent
+        this._consentState = signal({
+            adStorage: false,
+            adPersonalization: false,
+            adUserData: false,
+        });
+        /** Estado de consent para ads (readonly) */
+        this.adsConsentState = this._consentState.asReadonly();
+        /** Indica si se pueden mostrar ads (al menos consent basico) */
+        this.canShowAds = computed(() => {
+            // Siempre permitimos mostrar ads (pueden ser no personalizados)
+            // El control real esta en canPersonalize
+            return true;
+        });
+        /** Indica si se pueden mostrar ads personalizados */
+        this.canPersonalize = computed(() => {
+            const state = this._consentState();
+            return state.adStorage && state.adPersonalization && state.adUserData;
+        });
+        this.analyticsService = null;
+        this.consentSyncInterval = null;
+        if (isPlatformBrowser(this.platformId)) {
+            this.initializeConsentSync();
+        }
+    }
+    /**
+     * Inicializa la sincronizacion con AnalyticsService.
+     */
+    initializeConsentSync() {
+        // Intentar obtener AnalyticsService de forma lazy
+        // Usamos setTimeout para dar tiempo a que se inicialice
+        setTimeout(() => {
+            this.syncWithAnalyticsConsent();
+        }, 100);
+        // Re-sincronizar periodicamente por si el usuario cambia consent
+        this.consentSyncInterval = setInterval(() => {
+            this.syncWithAnalyticsConsent();
+        }, 5000);
+    }
+    /**
+     * Sincroniza el estado de consent desde AnalyticsService.
+     */
+    async syncWithAnalyticsConsent() {
+        try {
+            // Importar AnalyticsService dinamicamente
+            const { AnalyticsService } = await import('../firebase/analytics.service');
+            if (!this.analyticsService) {
+                this.analyticsService = this.injector.get(AnalyticsService, null);
+            }
+            if (this.analyticsService) {
+                // AnalyticsService expone consentState como signal
+                const consentState = this.analyticsService.consentState();
+                this.updateFromAnalyticsConsent(consentState.settings);
+            }
+        }
+        catch {
+            // AnalyticsService no disponible - usar defaults
+            this.setDefaultConsent();
+        }
+    }
+    /**
+     * Actualiza el estado de consent desde AnalyticsService.
+     */
+    updateFromAnalyticsConsent(settings) {
+        const hasAdvertisingConsent = settings['advertising'] === true;
+        this._consentState.set({
+            adStorage: hasAdvertisingConsent,
+            adPersonalization: hasAdvertisingConsent,
+            adUserData: hasAdvertisingConsent,
+        });
+    }
+    /**
+     * Establece consent por defecto (sin datos personales).
+     */
+    setDefaultConsent() {
+        this._consentState.set({
+            adStorage: false,
+            adPersonalization: false,
+            adUserData: false,
+        });
+    }
+    /**
+     * Actualiza manualmente el consent para ads.
+     * Usar cuando el usuario actualiza sus preferencias directamente.
+     *
+     * @param consent - Nuevo estado de consent parcial
+     */
+    updateConsent(consent) {
+        this._consentState.update((current) => ({
+            ...current,
+            ...consent,
+        }));
+        // Notificar a GPT si ya esta cargado
+        this.applyConsentToGPT();
+    }
+    /**
+     * Aplica el estado de consent actual a GPT.
+     */
+    applyConsentToGPT() {
+        if (!isPlatformBrowser(this.platformId))
+            return;
+        const googletag = window.googletag;
+        if (!googletag)
+            return;
+        googletag.cmd.push(() => {
+            const canPersonalize = this.canPersonalize();
+            // 0 = personalized, 1 = non-personalized
+            googletag.pubads().setRequestNonPersonalizedAds(canPersonalize ? 0 : 1);
+        });
+    }
+    /**
+     * Obtiene el estado actual de consent.
+     */
+    getConsentState() {
+        return this._consentState();
+    }
+    /**
+     * Destruye el servicio y limpia recursos.
+     */
+    destroy() {
+        if (this.consentSyncInterval) {
+            clearInterval(this.consentSyncInterval);
+            this.consentSyncInterval = null;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdsConsentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdsConsentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdsConsentService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ads-consent.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/ads/ads-consent.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Ads Consent Service\n *\n * Integra el servicio de Ads con el Consent Mode v2 existente en AnalyticsService.\n * Proporciona estado de consent especifico para ads (advertising).\n */\n\nimport { Injectable, Injector, PLATFORM_ID, inject, signal, computed, effect } from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\nimport { AdsConsentState } from './types';\n\n/**\n * Servicio que maneja el consent para ads.\n *\n * Se integra con AnalyticsService para reutilizar el estado de consent GDPR.\n * Si AnalyticsService no esta disponible, usa valores por defecto conservadores.\n */\n@Injectable({ providedIn: 'root' })\nexport class AdsConsentService {\n  private readonly platformId = inject(PLATFORM_ID);\n  private readonly injector = inject(Injector);\n\n  // Cache del estado de consent\n  private readonly _consentState = signal<AdsConsentState>({\n    adStorage: false,\n    adPersonalization: false,\n    adUserData: false,\n  });\n\n  /** Estado de consent para ads (readonly) */\n  readonly adsConsentState = this._consentState.asReadonly();\n\n  /** Indica si se pueden mostrar ads (al menos consent basico) */\n  readonly canShowAds = computed(() => {\n    // Siempre permitimos mostrar ads (pueden ser no personalizados)\n    // El control real esta en canPersonalize\n    return true;\n  });\n\n  /** Indica si se pueden mostrar ads personalizados */\n  readonly canPersonalize = computed(() => {\n    const state = this._consentState();\n    return state.adStorage && state.adPersonalization && state.adUserData;\n  });\n\n  private analyticsService: unknown = null;\n  private consentSyncInterval: ReturnType<typeof setInterval> | null = null;\n\n  constructor() {\n    if (isPlatformBrowser(this.platformId)) {\n      this.initializeConsentSync();\n    }\n  }\n\n  /**\n   * Inicializa la sincronizacion con AnalyticsService.\n   */\n  private initializeConsentSync(): void {\n    // Intentar obtener AnalyticsService de forma lazy\n    // Usamos setTimeout para dar tiempo a que se inicialice\n    setTimeout(() => {\n      this.syncWithAnalyticsConsent();\n    }, 100);\n\n    // Re-sincronizar periodicamente por si el usuario cambia consent\n    this.consentSyncInterval = setInterval(() => {\n      this.syncWithAnalyticsConsent();\n    }, 5000);\n  }\n\n  /**\n   * Sincroniza el estado de consent desde AnalyticsService.\n   */\n  private async syncWithAnalyticsConsent(): Promise<void> {\n    try {\n      // Importar AnalyticsService dinamicamente\n      const { AnalyticsService } = await import('../firebase/analytics.service');\n\n      if (!this.analyticsService) {\n        this.analyticsService = this.injector.get(AnalyticsService, null);\n      }\n\n      if (this.analyticsService) {\n        // AnalyticsService expone consentState como signal\n        const consentState = (this.analyticsService as { consentState: () => { settings: Record<string, boolean | undefined> } }).consentState();\n        this.updateFromAnalyticsConsent(consentState.settings);\n      }\n    } catch {\n      // AnalyticsService no disponible - usar defaults\n      this.setDefaultConsent();\n    }\n  }\n\n  /**\n   * Actualiza el estado de consent desde AnalyticsService.\n   */\n  private updateFromAnalyticsConsent(settings: Record<string, boolean | undefined>): void {\n    const hasAdvertisingConsent = settings['advertising'] === true;\n\n    this._consentState.set({\n      adStorage: hasAdvertisingConsent,\n      adPersonalization: hasAdvertisingConsent,\n      adUserData: hasAdvertisingConsent,\n    });\n  }\n\n  /**\n   * Establece consent por defecto (sin datos personales).\n   */\n  private setDefaultConsent(): void {\n    this._consentState.set({\n      adStorage: false,\n      adPersonalization: false,\n      adUserData: false,\n    });\n  }\n\n  /**\n   * Actualiza manualmente el consent para ads.\n   * Usar cuando el usuario actualiza sus preferencias directamente.\n   *\n   * @param consent - Nuevo estado de consent parcial\n   */\n  updateConsent(consent: Partial<AdsConsentState>): void {\n    this._consentState.update((current) => ({\n      ...current,\n      ...consent,\n    }));\n\n    // Notificar a GPT si ya esta cargado\n    this.applyConsentToGPT();\n  }\n\n  /**\n   * Aplica el estado de consent actual a GPT.\n   */\n  applyConsentToGPT(): void {\n    if (!isPlatformBrowser(this.platformId)) return;\n\n    const googletag = window.googletag;\n    if (!googletag) return;\n\n    googletag.cmd.push(() => {\n      const canPersonalize = this.canPersonalize();\n      // 0 = personalized, 1 = non-personalized\n      googletag.pubads().setRequestNonPersonalizedAds(canPersonalize ? 0 : 1);\n    });\n  }\n\n  /**\n   * Obtiene el estado actual de consent.\n   */\n  getConsentState(): AdsConsentState {\n    return this._consentState();\n  }\n\n  /**\n   * Destruye el servicio y limpia recursos.\n   */\n  destroy(): void {\n    if (this.consentSyncInterval) {\n      clearInterval(this.consentSyncInterval);\n      this.consentSyncInterval = null;\n    }\n  }\n}\n"]}

package/esm2022/lib/services/ads/ads-loader.service.mjs

@@ -0,0 +1,160 @@
+/**
+ * Ads Loader Service
+ *
+ * Maneja la carga lazy del script GPT (Google Publisher Tag).
+ * Solo carga el script cuando se necesita el primer ad.
+ */
+import { Injectable, Inject, PLATFORM_ID, signal } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { VALTECH_ADS_CONFIG } from './config';
+import * as i0 from "@angular/core";
+import * as i1 from "./ads-consent.service";
+/** URL del script GPT */
+const GPT_SCRIPT_URL = 'https://securepubads.g.doubleclick.net/tag/js/gpt.js';
+/**
+ * Servicio para cargar el script de Google Publisher Tags.
+ *
+ * Implementa lazy loading: el script solo se carga cuando
+ * se solicita renderizar el primer ad slot.
+ */
+export class AdsLoaderService {
+    constructor(config, platformId, consentService) {
+        this.config = config;
+        this.platformId = platformId;
+        this.consentService = consentService;
+        this._isLoading = signal(false);
+        this._isLoaded = signal(false);
+        this._error = signal(null);
+        /** Indica si el script esta cargando */
+        this.isLoading = this._isLoading.asReadonly();
+        /** Indica si el script esta cargado */
+        this.isLoaded = this._isLoaded.asReadonly();
+        /** Error de carga (si existe) */
+        this.error = this._error.asReadonly();
+        this.loadPromise = null;
+    }
+    /**
+     * Carga el script GPT de forma lazy.
+     * Retorna la instancia de googletag o null si falla.
+     *
+     * @returns Promise con googletag o null
+     */
+    loadGPT() {
+        // SSR check
+        if (!isPlatformBrowser(this.platformId)) {
+            return Promise.resolve(null);
+        }
+        // Ya cargado
+        if (this._isLoaded() && window.googletag) {
+            return Promise.resolve(window.googletag);
+        }
+        // Ya hay una carga en progreso
+        if (this.loadPromise) {
+            return this.loadPromise;
+        }
+        this._isLoading.set(true);
+        this._error.set(null);
+        this.loadPromise = new Promise((resolve) => {
+            // Inicializar cmd queue
+            window.googletag = window.googletag || { cmd: [] };
+            const googletag = window.googletag;
+            // Crear script
+            const script = document.createElement('script');
+            script.async = true;
+            script.src = GPT_SCRIPT_URL;
+            script.onload = () => {
+                googletag.cmd.push(() => {
+                    this.configureGPT(googletag);
+                    this._isLoaded.set(true);
+                    this._isLoading.set(false);
+                    if (this.config.debugMode) {
+                        console.log('[ValtechAds] Script GPT cargado y configurado');
+                    }
+                    resolve(googletag);
+                });
+            };
+            script.onerror = (error) => {
+                console.error('[ValtechAds] Error cargando GPT:', error);
+                this._error.set(new Error('Error cargando Google Publisher Tag'));
+                this._isLoading.set(false);
+                this.loadPromise = null;
+                resolve(null);
+            };
+            // Insertar script
+            const firstScript = document.getElementsByTagName('script')[0];
+            firstScript.parentNode?.insertBefore(script, firstScript);
+        });
+        return this.loadPromise;
+    }
+    /**
+     * Configura GPT con las opciones de la aplicacion.
+     */
+    configureGPT(googletag) {
+        const pubads = googletag.pubads();
+        // Single Request Architecture para mejor performance
+        pubads.enableSingleRequest();
+        // Colapsar divs vacios antes de fetch
+        pubads.collapseEmptyDivs(true);
+        // Lazy loading nativo de GPT
+        if (this.config.lazyLoad && this.config.lazyLoadConfig) {
+            pubads.enableLazyLoad({
+                fetchMarginPercent: this.config.lazyLoadConfig.fetchMarginPercent,
+                renderMarginPercent: this.config.lazyLoadConfig.renderMarginPercent,
+                mobileScaling: 2.0,
+            });
+        }
+        // Targeting global
+        if (this.config.globalTargeting) {
+            for (const [key, value] of Object.entries(this.config.globalTargeting)) {
+                pubads.setTargeting(key, value);
+            }
+        }
+        // Non-personalized ads segun consent
+        if (!this.consentService.canPersonalize()) {
+            pubads.setRequestNonPersonalizedAds(1);
+        }
+        // Event listeners
+        pubads.addEventListener('slotRenderEnded', (event) => {
+            const slotId = event.slot.getSlotElementId();
+            if (this.config.debugMode) {
+                console.log(`[ValtechAds] Slot ${slotId} rendered, empty: ${event.isEmpty}`);
+            }
+        });
+        // Debug mode
+        if (this.config.debugMode) {
+            console.log('[ValtechAds] GPT configurado:', {
+                lazyLoad: this.config.lazyLoad,
+                personalized: this.consentService.canPersonalize(),
+                targeting: this.config.globalTargeting,
+            });
+        }
+    }
+    /**
+     * Verifica si el script GPT esta disponible.
+     */
+    isGPTAvailable() {
+        return isPlatformBrowser(this.platformId) && !!window.googletag && this._isLoaded();
+    }
+    /**
+     * Obtiene la instancia de googletag si esta cargada.
+     */
+    getGPT() {
+        if (this.isGPTAvailable()) {
+            return window.googletag;
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdsLoaderService, deps: [{ token: VALTECH_ADS_CONFIG }, { token: PLATFORM_ID }, { token: i1.AdsConsentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdsLoaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdsLoaderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_ADS_CONFIG]
+                }] }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i1.AdsConsentService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ads-loader.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/ads/ads-loader.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Ads Loader Service\n *\n * Maneja la carga lazy del script GPT (Google Publisher Tag).\n * Solo carga el script cuando se necesita el primer ad.\n */\n\nimport { Injectable, Inject, PLATFORM_ID, signal } from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\n\nimport { VALTECH_ADS_CONFIG } from './config';\nimport { ValtechAdsConfig, GPTNamespace } from './types';\nimport { AdsConsentService } from './ads-consent.service';\n\n/** URL del script GPT */\nconst GPT_SCRIPT_URL = 'https://securepubads.g.doubleclick.net/tag/js/gpt.js';\n\n/**\n * Servicio para cargar el script de Google Publisher Tags.\n *\n * Implementa lazy loading: el script solo se carga cuando\n * se solicita renderizar el primer ad slot.\n */\n@Injectable({ providedIn: 'root' })\nexport class AdsLoaderService {\n  private readonly _isLoading = signal<boolean>(false);\n  private readonly _isLoaded = signal<boolean>(false);\n  private readonly _error = signal<Error | null>(null);\n\n  /** Indica si el script esta cargando */\n  readonly isLoading = this._isLoading.asReadonly();\n\n  /** Indica si el script esta cargado */\n  readonly isLoaded = this._isLoaded.asReadonly();\n\n  /** Error de carga (si existe) */\n  readonly error = this._error.asReadonly();\n\n  private loadPromise: Promise<GPTNamespace | null> | null = null;\n\n  constructor(\n    @Inject(VALTECH_ADS_CONFIG) private config: ValtechAdsConfig,\n    @Inject(PLATFORM_ID) private platformId: Object,\n    private consentService: AdsConsentService\n  ) {}\n\n  /**\n   * Carga el script GPT de forma lazy.\n   * Retorna la instancia de googletag o null si falla.\n   *\n   * @returns Promise con googletag o null\n   */\n  loadGPT(): Promise<GPTNamespace | null> {\n    // SSR check\n    if (!isPlatformBrowser(this.platformId)) {\n      return Promise.resolve(null);\n    }\n\n    // Ya cargado\n    if (this._isLoaded() && window.googletag) {\n      return Promise.resolve(window.googletag);\n    }\n\n    // Ya hay una carga en progreso\n    if (this.loadPromise) {\n      return this.loadPromise;\n    }\n\n    this._isLoading.set(true);\n    this._error.set(null);\n\n    this.loadPromise = new Promise<GPTNamespace | null>((resolve) => {\n      // Inicializar cmd queue\n      window.googletag = window.googletag || ({ cmd: [] } as GPTNamespace);\n      const googletag = window.googletag;\n\n      // Crear script\n      const script = document.createElement('script');\n      script.async = true;\n      script.src = GPT_SCRIPT_URL;\n\n      script.onload = () => {\n        googletag.cmd.push(() => {\n          this.configureGPT(googletag);\n          this._isLoaded.set(true);\n          this._isLoading.set(false);\n\n          if (this.config.debugMode) {\n            console.log('[ValtechAds] Script GPT cargado y configurado');\n          }\n\n          resolve(googletag);\n        });\n      };\n\n      script.onerror = (error) => {\n        console.error('[ValtechAds] Error cargando GPT:', error);\n        this._error.set(new Error('Error cargando Google Publisher Tag'));\n        this._isLoading.set(false);\n        this.loadPromise = null;\n        resolve(null);\n      };\n\n      // Insertar script\n      const firstScript = document.getElementsByTagName('script')[0];\n      firstScript.parentNode?.insertBefore(script, firstScript);\n    });\n\n    return this.loadPromise;\n  }\n\n  /**\n   * Configura GPT con las opciones de la aplicacion.\n   */\n  private configureGPT(googletag: GPTNamespace): void {\n    const pubads = googletag.pubads();\n\n    // Single Request Architecture para mejor performance\n    pubads.enableSingleRequest();\n\n    // Colapsar divs vacios antes de fetch\n    pubads.collapseEmptyDivs(true);\n\n    // Lazy loading nativo de GPT\n    if (this.config.lazyLoad && this.config.lazyLoadConfig) {\n      pubads.enableLazyLoad({\n        fetchMarginPercent: this.config.lazyLoadConfig.fetchMarginPercent,\n        renderMarginPercent: this.config.lazyLoadConfig.renderMarginPercent,\n        mobileScaling: 2.0,\n      });\n    }\n\n    // Targeting global\n    if (this.config.globalTargeting) {\n      for (const [key, value] of Object.entries(this.config.globalTargeting)) {\n        pubads.setTargeting(key, value);\n      }\n    }\n\n    // Non-personalized ads segun consent\n    if (!this.consentService.canPersonalize()) {\n      pubads.setRequestNonPersonalizedAds(1);\n    }\n\n    // Event listeners\n    pubads.addEventListener('slotRenderEnded', (event) => {\n      const slotId = event.slot.getSlotElementId();\n      if (this.config.debugMode) {\n        console.log(`[ValtechAds] Slot ${slotId} rendered, empty: ${event.isEmpty}`);\n      }\n    });\n\n    // Debug mode\n    if (this.config.debugMode) {\n      console.log('[ValtechAds] GPT configurado:', {\n        lazyLoad: this.config.lazyLoad,\n        personalized: this.consentService.canPersonalize(),\n        targeting: this.config.globalTargeting,\n      });\n    }\n  }\n\n  /**\n   * Verifica si el script GPT esta disponible.\n   */\n  isGPTAvailable(): boolean {\n    return isPlatformBrowser(this.platformId) && !!window.googletag && this._isLoaded();\n  }\n\n  /**\n   * Obtiene la instancia de googletag si esta cargada.\n   */\n  getGPT(): GPTNamespace | null {\n    if (this.isGPTAvailable()) {\n      return window.googletag!;\n    }\n    return null;\n  }\n}\n"]}