ng-easycommerce-v18 0.0.1 → 0.0.3

package/esm2022/lib/ec-services/analytics/facebook-pixel.service.mjs

@@ -0,0 +1,212 @@
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import { inject, Injectable, PLATFORM_ID, RendererFactory2 } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Servicio que se encarga de manejar el Analytics de Facebook.
+ * @class FacebookPixelService
+ */
+export class FacebookPixelService {
+    rendererFactory = inject(RendererFactory2);
+    document = null;
+    /**
+     * Se encarga de crear el elemento HTML con las configuraciones para
+     * que se pueda ejecutar el servicio.
+     */
+    renderer;
+    /**
+     * Indica cuando el servicio esta habilitado.
+     */
+    enabled = false;
+    platformId = inject(PLATFORM_ID);
+    constructor() {
+        if (isPlatformBrowser(this.platformId)) {
+            this.document = inject(DOCUMENT); // Solo se inyecta en el navegador
+        }
+        this.renderer = this.rendererFactory.createRenderer(null, null);
+    }
+    /**
+     * Inicializa el Servicio de analytics con sus configuraciones.
+     * @param pixel_id id provisto por Facebook Pixel.
+     */
+    initialize(pixel_id) {
+        if (!this.document?.getElementById('facebook_pixel')) {
+            let new_analityc_script = this.renderer.createElement('script');
+            new_analityc_script.id = "facebook_pixel";
+            new_analityc_script.type = 'text/javascript';
+            new_analityc_script.text = `!function(f,b,e,v,n,t,s) {if(f.fbq)return;n=f.fbq=function(){n.callMethod? n.callMethod.apply(n,arguments):n.queue.push(arguments)}; if(!f._fbq)f._fbq=n;n.push=n;n.loaded=!0;n.version='2.0'; n.queue=[];t=b.createElement(e);t.async=!0; t.src=v;s=b.getElementsByTagName(e)[0]; s.parentNode.insertBefore(t,s)}(window, document,'script', 'https://connect.facebook.net/en_US/fbevents.js'); fbq('init', ${pixel_id});`;
+            this.renderer.appendChild(this.document?.body, new_analityc_script);
+            this.enabled = true;
+        }
+        setTimeout(() => this.callEvent('initialize'), 1000);
+    }
+    /**
+     * Ejecuta el evento pasado por parametro.
+     * @param event_name Nombre del evento.
+     * @param data Data extra para agregar al evento.
+     * @returns
+     */
+    callEvent(event_name, data = {}) {
+        if (!this.enabled)
+            return;
+        let event = this.translateEventName(event_name);
+        event && fbq('track', this.translateEventName(event_name), this.evalEvent(event_name, data));
+    }
+    /**
+     * Traduce el evento recibido y devuelve el nombre de la función que lo va a tratar.
+     * @param event_name
+     * @returns
+     */
+    translateEventName(event_name) {
+        switch (event_name) {
+            case 'initialize': return 'PageView';
+            case 'view_item': return 'ViewContent';
+            case 'checkout_init': return 'InitiateCheckout';
+            case 'payment_info': return 'AddPaymentInfo';
+            case 'purchase': return 'Purchase';
+            case 'add_to_cart': return 'AddToCart';
+            default: return null;
+        }
+    }
+    /**
+     * Evalua el evento y devuelve los datos de las funciones relacionadas.
+     * @param event_name Nombre del evento
+     * @param data Data extra para agregar al evento
+     * @returns
+     */
+    evalEvent(event_name, data) {
+        switch (event_name) {
+            case 'initialize': return data;
+            case 'view_item': return this.toViewContent(data);
+            case 'checkout_init': return this.toCheckoutInit(data);
+            case 'payment_info': return this.toPaymentInfo(data);
+            case 'purchase': return this.toPurchase(data);
+            case 'add_to_cart': return this.toAddToCart(data);
+            default: return data;
+        }
+    }
+    /**
+     * Para ejecutar un evento propio.
+     * @param event_name Nombre de evento
+     * @param data Data extra para agregar al evento.
+     * @returns
+     */
+    callCustomEvent(event_name, data = {}) {
+        if (!this.enabled)
+            return;
+        fbq('trackCustom', event_name, data);
+    }
+    /**
+     * Cambia la variable **enabled** a `false`
+     * @returns
+     */
+    disable() { this.enabled = false; }
+    ;
+    /**
+     * Cuando un evento interactua con el contenido de la vista del producto.
+     * @param data
+     * @returns
+     */
+    toViewContent(data) {
+        let lastProduct = data?.name || 'not-product';
+        return {
+            content_type: 'product',
+            content_name: lastProduct,
+            content_ids: [data.variants[0]?.code],
+            currency: data.currency || "USD",
+            value: data.variants[0]?.saleprice || data.variants[0]?.price,
+            //product_catalog_id: 'TEST'
+        };
+    }
+    /**
+     * Evento que se dispara cuando se quiere comprar un producto.
+     * @param data
+     * @returns
+     */
+    toPurchase(data) {
+        return {
+            currency: data.currency || "USD",
+            value: data.totals?.total || 0,
+            content_type: 'product_group',
+            contents: this.getContents(data),
+            //product_catalog_id: 'TEST'
+        };
+    }
+    /**
+     * Evento que se dispara cuando se inicializa en checkout.
+     * @param data
+     * @returns
+     */
+    toCheckoutInit(data) {
+        return {
+            //content_category : "inicio checkout",
+            content_type: 'product_group',
+            contents: this.getContents(data),
+            content_ids: this.getContentIds(data),
+            currency: data.currency || "USD",
+            num_items: data.items?.length || 0,
+            value: data.totals?.total || 0,
+        };
+    }
+    /**
+     * Evento que se dispara cuando se consulta la información de pago.
+     * @param data
+     * @returns
+     */
+    toPaymentInfo(data) {
+        return {
+            //content_category : "inicio checkout",
+            content_type: 'product_group',
+            contents: this.getContents(data),
+            content_ids: this.getContentIds(data),
+            currency: data.currency || "USD",
+            value: data.totals?.total || 0,
+        };
+    }
+    /**
+     * Evento que se dispara cuando se agrega un producto al carrito.
+     * @param data
+     * @returns
+     */
+    toAddToCart(data) {
+        let lastProduct = data.items?.length && data.items[data.items.length - 1]?.product?.name || 'not-product';
+        return {
+            content_name: lastProduct,
+            content_type: 'product',
+            contents: this.getContents(data),
+            content_ids: this.getContentIds(data),
+            currency: data.currency || "USD",
+            value: data.totals?.total || 0,
+            //product_catalog_id: 'TEST'
+        };
+    }
+    /**
+     * Mapeo de datos para obtener solo el ID del producto y la cantidad.
+     * @param data
+     * @returns
+     */
+    getContents(data) {
+        return data.items.map((item) => {
+            return {
+                id: item.product.variants[0]?.code,
+                quantity: item.quantity
+            };
+        });
+    }
+    /**
+     * Mapeo de datos para obtener solo el ID del producto.
+     * @param data
+     * @returns
+     */
+    getContentIds(data) {
+        return data.items.map((item) => item.product.variants[0]?.code);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: FacebookPixelService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: FacebookPixelService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: FacebookPixelService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"facebook-pixel.service.js","sourceRoot":"","sources":["../../../../../../projects/ng-easycommerce-v18/src/lib/ec-services/analytics/facebook-pixel.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT, isPlatformBrowser } from '@angular/common';\r\nimport { inject, Injectable, PLATFORM_ID, Renderer2, RendererFactory2 } from '@angular/core';\r\nimport { AnalyticEventKey, FacebookPixelData } from '../../interfaces';\r\n/**\r\n * Funcion que sera dada por el script que se inserta en el inicializador de Facebook Analytics.\r\n * \r\n * https://es-la.facebook.com/business/help/402791146561655?id=1205376682832142 \r\n * \r\n * Relacionado con: {@link FacebookPixelService}\r\n */\r\ndeclare let fbq: Function;\r\n/**\r\n * Servicio que se encarga de manejar el Analytics de Facebook.\r\n * @class FacebookPixelService\r\n */\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class FacebookPixelService {\r\n\r\n    private rendererFactory: RendererFactory2 = inject(RendererFactory2)\r\n    private document: Document | null = null;\r\n    /**\r\n     * Se encarga de crear el elemento HTML con las configuraciones para \r\n     * que se pueda ejecutar el servicio.\r\n     */\r\n    private renderer: Renderer2;\r\n    /**\r\n     * Indica cuando el servicio esta habilitado.\r\n     */\r\n    private enabled: boolean = false;\r\n    private platformId = inject(PLATFORM_ID);\r\n\r\n    constructor() {\r\n        if (isPlatformBrowser(this.platformId)) {\r\n            this.document = inject(DOCUMENT); // Solo se inyecta en el navegador\r\n        }\r\n        this.renderer = this.rendererFactory.createRenderer(null, null);\r\n    }\r\n    /**\r\n     * Inicializa el Servicio de analytics con sus configuraciones.\r\n     * @param pixel_id id provisto por Facebook Pixel.\r\n     */\r\n    initialize(pixel_id: any) {\r\n        if (!this.document?.getElementById('facebook_pixel')) {\r\n            let new_analityc_script = this.renderer.createElement('script');\r\n            new_analityc_script.id = \"facebook_pixel\"\r\n            new_analityc_script.type = 'text/javascript';\r\n            new_analityc_script.text = `!function(f,b,e,v,n,t,s) {if(f.fbq)return;n=f.fbq=function(){n.callMethod? n.callMethod.apply(n,arguments):n.queue.push(arguments)}; if(!f._fbq)f._fbq=n;n.push=n;n.loaded=!0;n.version='2.0'; n.queue=[];t=b.createElement(e);t.async=!0; t.src=v;s=b.getElementsByTagName(e)[0]; s.parentNode.insertBefore(t,s)}(window, document,'script', 'https://connect.facebook.net/en_US/fbevents.js'); fbq('init', ${pixel_id});`;\r\n            this.renderer.appendChild(this.document?.body, new_analityc_script);\r\n            this.enabled = true;\r\n        }\r\n        setTimeout(() => this.callEvent('initialize'), 1000);\r\n    }\r\n    /**\r\n     * Ejecuta el evento pasado por parametro. \r\n     * @param event_name Nombre del evento.\r\n     * @param data Data extra para agregar al evento.\r\n     * @returns \r\n     */\r\n    callEvent(event_name: AnalyticEventKey, data = {}) {\r\n        if (!this.enabled) return;\r\n        let event = this.translateEventName(event_name);\r\n        event && fbq('track', this.translateEventName(event_name), this.evalEvent(event_name, data));\r\n    }\r\n    /**\r\n     * Traduce el evento recibido y devuelve el nombre de la función que lo va a tratar.\r\n     * @param event_name \r\n     * @returns \r\n     */\r\n    translateEventName(event_name: AnalyticEventKey) {\r\n        switch (event_name) {\r\n            case 'initialize': return 'PageView';\r\n            case 'view_item': return 'ViewContent';\r\n            case 'checkout_init': return 'InitiateCheckout';\r\n            case 'payment_info': return 'AddPaymentInfo';\r\n            case 'purchase': return 'Purchase';\r\n            case 'add_to_cart': return 'AddToCart';\r\n            default: return null;\r\n        }\r\n    }\r\n    /**\r\n     * Evalua el evento y devuelve los datos de las funciones relacionadas.\r\n     * @param event_name Nombre del evento\r\n     * @param data Data extra para agregar al evento\r\n     * @returns \r\n     */\r\n    evalEvent(event_name: AnalyticEventKey, data: any) {\r\n        switch (event_name) {\r\n            case 'initialize': return data;\r\n            case 'view_item': return this.toViewContent(data);\r\n            case 'checkout_init': return this.toCheckoutInit(data);\r\n            case 'payment_info': return this.toPaymentInfo(data);\r\n            case 'purchase': return this.toPurchase(data);\r\n            case 'add_to_cart': return this.toAddToCart(data);\r\n            default: return data;\r\n        }\r\n    }\r\n    /**\r\n     * Para ejecutar un evento propio.\r\n     * @param event_name Nombre de evento\r\n     * @param data Data extra para agregar al evento.\r\n     * @returns \r\n     */\r\n    callCustomEvent(event_name: AnalyticEventKey, data: FacebookPixelData = {}) {\r\n        if (!this.enabled) return;\r\n        fbq('trackCustom', event_name, data);\r\n    }\r\n    /**\r\n     * Cambia la variable **enabled** a `false`\r\n     * @returns \r\n     */\r\n    disable() { this.enabled = false };\r\n    /**\r\n     * Cuando un evento interactua con el contenido de la vista del producto.\r\n     * @param data \r\n     * @returns \r\n     */\r\n    private toViewContent(data: any) {\r\n        let lastProduct = data?.name || 'not-product'\r\n        return {\r\n            content_type: 'product',\r\n            content_name: lastProduct,\r\n            content_ids: [data.variants[0]?.code],\r\n            currency: data.currency || \"USD\",\r\n            value: data.variants[0]?.saleprice || data.variants[0]?.price,\r\n            //product_catalog_id: 'TEST'\r\n        }\r\n    }\r\n    /**\r\n     * Evento que se dispara cuando se quiere comprar un producto.\r\n     * @param data \r\n     * @returns \r\n     */\r\n    private toPurchase(data: any) {\r\n        return {\r\n            currency: data.currency || \"USD\",\r\n            value: data.totals?.total || 0,\r\n            content_type: 'product_group',\r\n            contents: this.getContents(data),\r\n            //product_catalog_id: 'TEST'\r\n        }\r\n    }\r\n    /**\r\n     * Evento que se dispara cuando se inicializa en checkout.\r\n     * @param data \r\n     * @returns \r\n     */\r\n    private toCheckoutInit(data: any) {\r\n        return {\r\n            //content_category : \"inicio checkout\",\r\n            content_type: 'product_group',\r\n            contents: this.getContents(data),\r\n            content_ids: this.getContentIds(data),\r\n            currency: data.currency || \"USD\",\r\n            num_items: data.items?.length || 0,\r\n            value: data.totals?.total || 0,\r\n        }\r\n    }\r\n    /**\r\n     * Evento que se dispara cuando se consulta la información de pago.\r\n     * @param data \r\n     * @returns \r\n     */\r\n    private toPaymentInfo(data: any) {\r\n        return {\r\n            //content_category : \"inicio checkout\",\r\n            content_type: 'product_group',\r\n            contents: this.getContents(data),\r\n            content_ids: this.getContentIds(data),\r\n            currency: data.currency || \"USD\",\r\n            value: data.totals?.total || 0,\r\n        }\r\n    }\r\n    /**\r\n     * Evento que se dispara cuando se agrega un producto al carrito. \r\n     * @param data \r\n     * @returns \r\n     */\r\n    private toAddToCart(data: any) {\r\n        let lastProduct = data.items?.length && data.items[data.items.length - 1]?.product?.name || 'not-product'\r\n        return {\r\n            content_name: lastProduct,\r\n            content_type: 'product',\r\n            contents: this.getContents(data),\r\n            content_ids: this.getContentIds(data),\r\n            currency: data.currency || \"USD\",\r\n            value: data.totals?.total || 0,\r\n            //product_catalog_id: 'TEST'\r\n\r\n        }\r\n    }\r\n    /**\r\n     * Mapeo de datos para obtener solo el ID del producto y la cantidad.\r\n     * @param data \r\n     * @returns \r\n     */\r\n    private getContents(data: any) {\r\n        return data.items.map(\r\n            (item: any) => {\r\n                return {\r\n                    id: item.product.variants[0]?.code,\r\n                    quantity: item.quantity\r\n                }\r\n            }\r\n        )\r\n    }\r\n    /**\r\n     * Mapeo de datos para obtener solo el ID del producto.\r\n     * @param data \r\n     * @returns \r\n     */\r\n    private getContentIds(data: any) {\r\n        return data.items.map(\r\n            (item: any) => item.product.variants[0]?.code\r\n        )\r\n    }\r\n}\r\n"]}

package/esm2022/lib/ec-services/analytics/google-analytics.service.mjs

@@ -0,0 +1,283 @@
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import { inject, Injectable, PLATFORM_ID, RendererFactory2 } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+import { filter } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Servicio encargado de manejar el analytics de google.
+ * @class GoogleAnalyticsService
+ */
+export class GoogleAnalyticsService {
+    /**
+     * Se encarga de crear el elemento HTML con las configuraciones para
+     * que se pueda ejecutar el servicio.
+     */
+    renderer;
+    /**
+     * Indica cuando el servicio esta habilitado.
+     */
+    enabled = false;
+    rendererFactory = inject(RendererFactory2);
+    document = null;
+    platformId = inject(PLATFORM_ID);
+    /**
+     * Servicio de ruteo de angular.
+     */
+    router = inject(Router);
+    constructor() {
+        if (isPlatformBrowser(this.platformId)) {
+            this.document = inject(DOCUMENT); // Solo se inyecta en el navegador
+        }
+        this.renderer = this.rendererFactory.createRenderer(null, null);
+    }
+    /**
+     * Inicializa el Servicio de analytics con sus configuraciones.
+     * @param gtm_id id provisto por Google Tag Manager.
+     */
+    initialize(gtm_id) {
+        if (!document.getElementById('google_tag_manager')) {
+            console.log('hay elemento');
+            const declaration = this.renderer.createElement('script');
+            declaration.async = true;
+            declaration.id = 'google_tag_manager';
+            declaration.src = `https://www.googletagmanager.com/gtag/js?id=${gtm_id}`;
+            const initialization = this.renderer.createElement('script');
+            initialization.text = `window.dataLayer = window.dataLayer || []; function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', '${gtm_id}')`;
+            this.renderer.appendChild(this.document?.head, initialization);
+            this.renderer.appendChild(this.document?.head, declaration);
+            this.enabled = true;
+        }
+        setTimeout(() => this.startListeningPageViews(gtm_id), 1000);
+    }
+    /**
+     *
+     * @param gtm_id
+     */
+    startListeningPageViews(gtm_id) {
+        this.router.events.pipe(filter(event => event instanceof NavigationEnd)).subscribe((event) => {
+            gtag('config', gtm_id, {
+                'page_path': event.urlAfterRedirects
+            });
+        });
+    }
+    /**
+     * Ejecuta el evento pasado por parametro.
+     * @param event_name Nombre del evento.
+     * @param data Data extra para agregar al evento.
+     * @returns
+     */
+    callEvent(event_name, data = {}) {
+        if (!this.enabled)
+            return;
+        let event = this.translateEventName(event_name);
+        event && gtag('event', this.translateEventName(event_name), this.evalEvent(event_name, data));
+    }
+    /**
+     * Traduce el evento recibido y devuelve el nombre de la función que lo va a tratar.
+     * @param event_name
+     * @returns
+     */
+    translateEventName(event_name) {
+        switch (event_name) {
+            case 'view_item': return 'view_item';
+            case 'view_item_list': return 'view_item_list';
+            case 'checkout_init': return 'begin_checkout';
+            case 'shipping_info': return 'add_shipping_info';
+            case 'add_payment_info': return 'add_payment_info';
+            case 'purchase': return 'purchase';
+            case 'add_to_cart': return 'add_to_cart';
+            case 'remove_from_cart': return 'remove_from_cart';
+            case 'sign_up': return 'sign_up';
+            default: return null;
+            //default: return event_name;
+        }
+    }
+    /**
+     * Evalua el evento y devuelve los datos de las funciones relacionadas.
+     * @param event_name Nombre del evento
+     * @param data Data extra para agregar al evento
+     * @returns
+     */
+    evalEvent(event_name, data) {
+        switch (event_name) {
+            case 'view_item': return this.toViewItem(data);
+            case 'view_item_list': return this.toViewItemList(data);
+            case 'checkout_init': return this.toCheckoutInit(data);
+            case 'shipping_info': return this.toShippingInfo(data);
+            case 'add_payment_info': return this.toPaymentInfo(data);
+            case 'purchase': return this.toPurchase(data);
+            case 'add_to_cart': return this.toAddToCart(data);
+            case 'remove_from_cart': return this.toRemoveToCart(data);
+            case 'sign_up': return this.toSignUp(data);
+            default: return data;
+        }
+    }
+    /**
+     * Evento que se dispara cuando se quiere comprar un producto.
+     * @param data
+     * @returns
+     */
+    toPurchase(data) {
+        return {
+            coupon: this.toCartDiscount(data),
+            currency: data.currency,
+            shipping: data.totals.shipping,
+            tax: data.totals.taxes,
+            value: data.totals.total,
+            transaction_id: data.number,
+            items: data.items.map((item) => ({
+                id: item.product.id,
+                name: item.product.name,
+                category: item.product.category,
+                price: item.total,
+                quantity: item.quantity
+            }))
+        };
+    }
+    /**
+     * Evento que se dispara cuando se inicializa en checkout.
+     * @param data
+     * @returns
+     */
+    toCheckoutInit(data) {
+        return {
+            coupon: this.toCartDiscount(data),
+            currency: data.currency || "USD",
+            items: data.items.map((item) => ({
+                id: item.product.id,
+                name: item.product.name,
+                category: item.product.category,
+                price: item.total,
+                quantity: item.quantity
+            })),
+            value: data.totals?.total || 0,
+        };
+    }
+    /**
+     * Evento que se dispara con los descuentos en el carrito.
+     * @param data
+     * @returns
+     */
+    toCartDiscount(data) {
+        let strDiscount = '';
+        strDiscount = data.cartDiscounts.map((itemDiscount) => itemDiscount?.type).join();
+        return strDiscount == '' ? 'not-discount' : strDiscount;
+    }
+    /**
+     * Evento que se dispara cuando se agrega un producto al carrito.
+     * @param data
+     * @returns
+     */
+    toAddToCart(data) {
+        let lastProduct = data.items?.length && data.items[data.items.length - 1];
+        return {
+            currency: data.currency || "USD",
+            items: [this.toItem({ quantity: lastProduct.quantity, ...lastProduct.product })],
+            value: lastProduct.total || 0,
+        };
+    }
+    /**
+     * Cambia la variable **enabled** a `false`
+     * @returns
+     */
+    disable() { this.enabled = false; }
+    /**
+     * Evento que se dispara cuando se interactua a las vista del producto.
+     * @param product
+     * @returns
+     */
+    toViewItem(product) {
+        return {
+            currency: product.currency,
+            items: [this.toItem(product)],
+            value: product.variants[0]?.saleprice || product.variants[0]?.price,
+        };
+    }
+    /**
+     * Evento que se dispara cuando se interactua con el listado de productos.
+     * @param data
+     * @returns
+     */
+    toViewItemList(data) {
+        return {
+            items: data.products.map((product) => this.toItem(product)),
+            item_list_name: data.item_list_name || 'Collection',
+            item_list_id: data.item_list_id || 'collection'
+        };
+    }
+    /**
+     * Evento que se dispara cuando se quita un item del carrito.
+     * @param product
+     * @returns
+     */
+    toRemoveToCart(product) {
+        let productParam = product.product;
+        return {
+            currency: product.currency || "USD",
+            items: [this.toItem({ quantity: product.quantity, ...productParam })],
+            value: (productParam.variants[0]?.saleprice || productParam.variants[0]?.price) * product.quantity || 1,
+        };
+    }
+    toItem = (product) => ({
+        item_name: product.name,
+        item_id: product.id,
+        item_brand: product.attributes?.length ? product.attributes[0].name : '',
+        item_category: product.category,
+        price: product.variants[0]?.saleprice || product.variants[0]?.price,
+        quantity: product.quantity || 1,
+    });
+    /**
+     * Evento que se dispara cuando se consulta la información de pago.
+     * @param data
+     * @returns
+     */
+    toPaymentInfo(data) {
+        return {
+            coupon: this.toCartDiscount(data),
+            currency: data.currency || "USD",
+            items: data.items.map((item) => ({
+                id: item.product.id,
+                name: item.product.name,
+                category: item.product.category,
+                price: item.total,
+                quantity: item.quantity
+            })),
+            payment_type: data.payments[0]?.method?.code || 'not-payments',
+            value: data.totals?.total || 0,
+        };
+    }
+    /**
+     * Evento que se dispara cuando se interactua con los métodos de envío.
+     * @param data
+     * @returns
+     */
+    toShippingInfo(data) {
+        return {
+            coupon: this.toCartDiscount(data),
+            currency: data.currency || "USD",
+            items: data.items.map((item) => ({
+                id: item.product.id,
+                name: item.product.name,
+                category: item.product.category,
+                price: item.total,
+                quantity: item.quantity
+            })),
+            shipping_tier: data.shipments[0]?.method?.code || 'not-shipping',
+            value: data.totals?.total || 0,
+        };
+    }
+    toSignUp(data) {
+        return {
+            ...data
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: GoogleAnalyticsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: GoogleAnalyticsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: GoogleAnalyticsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"google-analytics.service.js","sourceRoot":"","sources":["../../../../../../projects/ng-easycommerce-v18/src/lib/ec-services/analytics/google-analytics.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT, isPlatformBrowser } from '@angular/common';\r\nimport { inject, Injectable, PLATFORM_ID, Renderer2, RendererFactory2 } from '@angular/core';\r\nimport { AnalyticEventKey } from '../../interfaces';\r\nimport { NavigationEnd, Router } from '@angular/router';\r\nimport { filter } from 'rxjs';\r\n/**\r\n * Funcion que sera dada por el script que se inserta en el inicializador de Google Analytics.\r\n */\r\ndeclare var gtag: Function;\r\ndeclare var dataLayer: any[];\r\n\r\n/**\r\n * Servicio encargado de manejar el analytics de google.\r\n * @class GoogleAnalyticsService\r\n */\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class GoogleAnalyticsService {\r\n\t/**\r\n\t * Se encarga de crear el elemento HTML con las configuraciones para \r\n\t * que se pueda ejecutar el servicio.\r\n\t */\r\n\tprivate renderer: Renderer2;\r\n\t/**\r\n\t * Indica cuando el servicio esta habilitado.\r\n\t */\r\n\tprivate enabled: boolean = false;\r\n\r\n\tprivate rendererFactory: RendererFactory2 = inject(RendererFactory2);\r\n\tprivate document: Document | null = null;\r\n\tprivate platformId = inject(PLATFORM_ID);\r\n\r\n\t/**\r\n\t * Servicio de ruteo de angular.\r\n\t */\r\n\tprivate router: Router = inject(Router);\r\n\r\n\tconstructor() {\r\n\t\tif (isPlatformBrowser(this.platformId)) {\r\n\t\t\tthis.document = inject(DOCUMENT); // Solo se inyecta en el navegador\r\n\t\t}\r\n\t\tthis.renderer = this.rendererFactory.createRenderer(null, null);\r\n\t}\r\n\t/**\r\n\t * Inicializa el Servicio de analytics con sus configuraciones.\r\n\t * @param gtm_id id provisto por Google Tag Manager.\r\n\t */\r\n\tinitialize(gtm_id: string) {\r\n\t\tif (!document.getElementById('google_tag_manager')) {\r\n\t\t\tconsole.log('hay elemento')\r\n\t\t\tconst declaration = this.renderer.createElement('script');\r\n\t\t\tdeclaration.async = true;\r\n\t\t\tdeclaration.id = 'google_tag_manager';\r\n\t\t\tdeclaration.src = `https://www.googletagmanager.com/gtag/js?id=${gtm_id}`;\r\n\t\t\tconst initialization = this.renderer.createElement('script');\r\n\t\t\tinitialization.text = `window.dataLayer = window.dataLayer || []; function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', '${gtm_id}')`;\r\n\t\t\tthis.renderer.appendChild(this.document?.head, initialization);\r\n\t\t\tthis.renderer.appendChild(this.document?.head, declaration);\r\n\t\t\tthis.enabled = true;\r\n\t\t}\r\n\t\tsetTimeout(() => this.startListeningPageViews(gtm_id), 1000);\r\n\t}\r\n\t/**\r\n\t * \r\n\t * @param gtm_id \r\n\t */\r\n\tprivate startListeningPageViews(gtm_id: any) {\r\n\t\tthis.router.events.pipe(\r\n\t\t\tfilter(event => event instanceof NavigationEnd)\r\n\t\t).subscribe((event: NavigationEnd) => {\r\n\t\t\tgtag('config', gtm_id, {\r\n\t\t\t\t'page_path': event.urlAfterRedirects\r\n\t\t\t})\r\n\t\t})\r\n\t}\r\n\t/**\r\n\t * Ejecuta el evento pasado por parametro. \r\n\t * @param event_name Nombre del evento.\r\n\t * @param data Data extra para agregar al evento.\r\n\t * @returns \r\n\t */\r\n\tcallEvent(event_name: AnalyticEventKey, data = {}) {\r\n\t\tif (!this.enabled) return;\r\n\t\tlet event = this.translateEventName(event_name);\r\n\t\tevent && gtag('event', this.translateEventName(event_name), this.evalEvent(event_name, data));\r\n\t}\r\n\t/**\r\n\t * Traduce el evento recibido y devuelve el nombre de la función que lo va a tratar.\r\n\t * @param event_name \r\n\t * @returns \r\n\t */\r\n\ttranslateEventName(event_name: AnalyticEventKey) {\r\n\t\tswitch (event_name) {\r\n\t\t\tcase 'view_item': return 'view_item';\r\n\t\t\tcase 'view_item_list': return 'view_item_list';\r\n\t\t\tcase 'checkout_init': return 'begin_checkout';\r\n\t\t\tcase 'shipping_info': return 'add_shipping_info';\r\n\t\t\tcase 'add_payment_info': return 'add_payment_info';\r\n\t\t\tcase 'purchase': return 'purchase';\r\n\t\t\tcase 'add_to_cart': return 'add_to_cart';\r\n\t\t\tcase 'remove_from_cart': return 'remove_from_cart';\r\n\t\t\tcase 'sign_up': return 'sign_up';\r\n\t\t\tdefault: return null;\r\n\t\t\t//default: return event_name;\r\n\t\t}\r\n\t}\r\n\t/**\r\n\t * Evalua el evento y devuelve los datos de las funciones relacionadas.\r\n\t * @param event_name Nombre del evento\r\n\t * @param data Data extra para agregar al evento\r\n\t * @returns \r\n\t */\r\n\tevalEvent(event_name: AnalyticEventKey, data: any) {\r\n\t\tswitch (event_name) {\r\n\t\t\tcase 'view_item': return this.toViewItem(data);\r\n\t\t\tcase 'view_item_list': return this.toViewItemList(data);\r\n\t\t\tcase 'checkout_init': return this.toCheckoutInit(data);\r\n\t\t\tcase 'shipping_info': return this.toShippingInfo(data);\r\n\t\t\tcase 'add_payment_info': return this.toPaymentInfo(data);\r\n\t\t\tcase 'purchase': return this.toPurchase(data);\r\n\t\t\tcase 'add_to_cart': return this.toAddToCart(data);\r\n\t\t\tcase 'remove_from_cart': return this.toRemoveToCart(data);\r\n\t\t\tcase 'sign_up': return this.toSignUp(data);\r\n\t\t\tdefault: return data;\r\n\t\t}\r\n\t}\r\n\t/**\r\n\t * Evento que se dispara cuando se quiere comprar un producto.\r\n\t * @param data \r\n\t * @returns \r\n\t */\r\n\tprivate toPurchase(data: any) {\r\n\t\treturn {\r\n\t\t\tcoupon: this.toCartDiscount(data),\r\n\t\t\tcurrency: data.currency,\r\n\t\t\tshipping: data.totals.shipping,\r\n\t\t\ttax: data.totals.taxes,\r\n\t\t\tvalue: data.totals.total,\r\n\t\t\ttransaction_id: data.number,\r\n\t\t\titems: data.items.map((item: any) => ({\r\n\t\t\t\tid: item.product.id,\r\n\t\t\t\tname: item.product.name,\r\n\t\t\t\tcategory: item.product.category,\r\n\t\t\t\tprice: item.total,\r\n\t\t\t\tquantity: item.quantity\r\n\t\t\t}))\r\n\t\t}\r\n\t}\r\n\t/**\r\n\t * Evento que se dispara cuando se inicializa en checkout.\r\n\t * @param data \r\n\t * @returns \r\n\t */\r\n\tprivate toCheckoutInit(data: any) {\r\n\t\treturn {\r\n\t\t\tcoupon: this.toCartDiscount(data),\r\n\t\t\tcurrency: data.currency || \"USD\",\r\n\t\t\titems: data.items.map((item: any) => ({\r\n\t\t\t\tid: item.product.id,\r\n\t\t\t\tname: item.product.name,\r\n\t\t\t\tcategory: item.product.category,\r\n\t\t\t\tprice: item.total,\r\n\t\t\t\tquantity: item.quantity\r\n\t\t\t})),\r\n\t\t\tvalue: data.totals?.total || 0,\r\n\t\t}\r\n\t}\r\n\t/**\r\n\t * Evento que se dispara con los descuentos en el carrito.\r\n\t * @param data \r\n\t * @returns \r\n\t */\r\n\tprivate toCartDiscount(data: any) {\r\n\t\tlet strDiscount = ''\r\n\t\tstrDiscount = data.cartDiscounts.map((itemDiscount: any) => itemDiscount?.type).join()\r\n\t\treturn strDiscount == '' ? 'not-discount' : strDiscount\r\n\t}\r\n\t/**\r\n\t * Evento que se dispara cuando se agrega un producto al carrito. \r\n\t * @param data \r\n\t * @returns \r\n\t */\r\n\tprivate toAddToCart(data: any) {\r\n\t\tlet lastProduct = data.items?.length && data.items[data.items.length - 1]\r\n\t\treturn {\r\n\t\t\tcurrency: data.currency || \"USD\",\r\n\t\t\titems: [this.toItem({ quantity: lastProduct.quantity, ...lastProduct.product })],\r\n\t\t\tvalue: lastProduct.total || 0,\r\n\t\t}\r\n\t}\r\n\t/**\r\n\t * Cambia la variable **enabled** a `false`\r\n\t * @returns \r\n\t */\r\n\tdisable() { this.enabled = false; }\r\n\t/**\r\n\t * Evento que se dispara cuando se interactua a las vista del producto.\r\n\t * @param product \r\n\t * @returns \r\n\t */\r\n\tprivate toViewItem(product: any) {\r\n\t\treturn {\r\n\t\t\tcurrency: product.currency,\r\n\t\t\titems: [this.toItem(product)],\r\n\t\t\tvalue: product.variants[0]?.saleprice || product.variants[0]?.price,\r\n\t\t}\r\n\t}\r\n\t/**\r\n\t * Evento que se dispara cuando se interactua con el listado de productos.\r\n\t * @param data \r\n\t * @returns \r\n\t */\r\n\tprivate toViewItemList(data: any) {\r\n\t\treturn {\r\n\t\t\titems: data.products.map((product: any) => this.toItem(product)),\r\n\t\t\titem_list_name: data.item_list_name || 'Collection',\r\n\t\t\titem_list_id: data.item_list_id || 'collection'\r\n\t\t}\r\n\t}\r\n\t/**\r\n\t * Evento que se dispara cuando se quita un item del carrito.\r\n\t * @param product \r\n\t * @returns \r\n\t */\r\n\tprivate toRemoveToCart(product: any) {\r\n\t\tlet productParam = product.product\r\n\t\treturn {\r\n\t\t\tcurrency: product.currency || \"USD\",\r\n\t\t\titems: [this.toItem({ quantity: product.quantity, ...productParam })],\r\n\t\t\tvalue: (productParam.variants[0]?.saleprice || productParam.variants[0]?.price) * product.quantity || 1,\r\n\t\t}\r\n\t}\r\n\r\n\tprivate toItem = (product: any) => ({\r\n\t\titem_name: product.name,\r\n\t\titem_id: product.id,\r\n\t\titem_brand: product.attributes?.length ? product.attributes[0].name : '',\r\n\t\titem_category: product.category,\r\n\t\tprice: product.variants[0]?.saleprice || product.variants[0]?.price,\r\n\t\tquantity: product.quantity || 1,\r\n\t})\r\n\t/**\r\n\t * Evento que se dispara cuando se consulta la información de pago.\r\n\t * @param data \r\n\t * @returns \r\n\t */\r\n\tprivate toPaymentInfo(data: any) {\r\n\t\treturn {\r\n\t\t\tcoupon: this.toCartDiscount(data),\r\n\t\t\tcurrency: data.currency || \"USD\",\r\n\t\t\titems: data.items.map((item: any) => ({\r\n\t\t\t\tid: item.product.id,\r\n\t\t\t\tname: item.product.name,\r\n\t\t\t\tcategory: item.product.category,\r\n\t\t\t\tprice: item.total,\r\n\t\t\t\tquantity: item.quantity\r\n\t\t\t})),\r\n\t\t\tpayment_type: data.payments[0]?.method?.code || 'not-payments',\r\n\t\t\tvalue: data.totals?.total || 0,\r\n\t\t}\r\n\t}\r\n\t/**\r\n\t * Evento que se dispara cuando se interactua con los métodos de envío.\r\n\t * @param data \r\n\t * @returns \r\n\t */\r\n\tprivate toShippingInfo(data: any) {\r\n\t\treturn {\r\n\t\t\tcoupon: this.toCartDiscount(data),\r\n\t\t\tcurrency: data.currency || \"USD\",\r\n\t\t\titems: data.items.map((item: any) => ({\r\n\t\t\t\tid: item.product.id,\r\n\t\t\t\tname: item.product.name,\r\n\t\t\t\tcategory: item.product.category,\r\n\t\t\t\tprice: item.total,\r\n\t\t\t\tquantity: item.quantity\r\n\t\t\t})),\r\n\t\t\tshipping_tier: data.shipments[0]?.method?.code || 'not-shipping',\r\n\t\t\tvalue: data.totals?.total || 0,\r\n\t\t}\r\n\t}\r\n\r\n\tprivate toSignUp(data: any) {\r\n\t\treturn {\r\n\t\t\t...data\r\n\t\t}\r\n\t}\r\n}\r\n"]}