ng-easycommerce-v18 0.0.1 → 0.0.2

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

@@ -0,0 +1,414 @@
+import { inject, Injectable, PLATFORM_ID, RendererFactory2 } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import * as i0 from "@angular/core";
+/**
+ * Servicio que se encarga de manejar el analytics de GTM.
+ */
+export class GTMService {
+    /**
+     * Indica si se esta cargando el servicio.
+     */
+    isLoaded = false;
+    /**
+     * Indica cuando el servicio esta habilitado.
+     */
+    enabled = false;
+    /**
+     * Se encarga de crear el elemento HTML con las configuraciones para
+     * que se pueda ejecutar el servicio.
+     */
+    renderer;
+    /**
+     * Almacena el objecto window del navegador.
+     */
+    window;
+    rendererFactory = inject(RendererFactory2);
+    document = null;
+    /**
+     * Servicio de ruteo de angular.
+     */
+    router = inject(Router);
+    /**
+     * Configuración de Google Tag Manager.
+     */
+    config = { id: null };
+    platformId = inject(PLATFORM_ID);
+    constructor() {
+        this.renderer = this.rendererFactory.createRenderer(null, null);
+        if (isPlatformBrowser(this.platformId)) {
+            this.window = window;
+            this.document = inject(DOCUMENT);
+        }
+    }
+    /**
+     * Obtiene el dataLayer del objecto window
+     * @returns
+     */
+    getDataLayer() {
+        const window = this.window;
+        /* if(window)
+        window.dataLayer = window.dataLayer || [];
+        return window.dataLayer; */
+        return [];
+    }
+    /**
+     * Agrega datos al dataLayer.
+     * @param obj
+     */
+    pushOnDataLayer(obj) {
+        const dataLayer = this.getDataLayer();
+        dataLayer.push(obj);
+    }
+    /**
+     * Agrega el script de GTM para que empiece a capturar eventos.
+     * @returns
+     */
+    addGtmToDom() {
+        return new Promise((resolve, reject) => {
+            if (this.isLoaded) {
+                return resolve(this.isLoaded);
+            }
+            //const doc = this.browserGlobals.documentRef();
+            this.pushOnDataLayer({ 'gtm.start': new Date().getTime(), event: 'gtm.js' });
+            const gtmScript = this.document?.createElement('script'); //doc.createElement('script');
+            if (gtmScript) {
+                gtmScript.id = 'GTMscript';
+                gtmScript.async = true;
+                gtmScript.src = this.applyGtmQueryParams(this.config["gtm_resource_path"] ? this.config["gtm_resource_path"] : 'https://www.googletagmanager.com/gtm.js');
+                gtmScript.addEventListener('load', () => {
+                    return resolve(this.isLoaded = true);
+                });
+                gtmScript.addEventListener('error', () => {
+                    return reject(false);
+                });
+                this.document?.head.insertBefore(gtmScript, this.document.head.firstChild);
+            }
+        });
+    }
+    applyGtmQueryParams(url) {
+        if (url.indexOf('?') === -1) {
+            url += '?';
+        }
+        return (url + Object.keys(this.config).filter((k) => this.config[k]).map((k) => `${k}=${this.config[k]}`).join('&'));
+    }
+    /**
+     * Inicializa el Servicio de analytics con sus configuraciones.
+     * @param config Configuraciones de Google Tag Manager
+     */
+    initialize(config) {
+        this.config = config || this.config;
+        this.addGtmToDom().then(() => {
+            this.router.events.forEach(item => {
+                if (item instanceof NavigationEnd) {
+                    const gtmTag = {
+                        event: 'page',
+                        pageName: item.url
+                    };
+                    this.pushTag(gtmTag);
+                }
+            });
+        });
+    }
+    pushTag(item) {
+        return new Promise((resolve, reject) => {
+            if (!this.isLoaded) {
+                this.addGtmToDom().then(() => {
+                    this.pushOnDataLayer(item);
+                    return resolve();
+                }).catch(() => reject());
+            }
+            else {
+                this.pushOnDataLayer(item);
+                return resolve();
+            }
+        });
+    }
+    /**
+     * 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.isLoaded)
+            return;
+        let event = this.translateEventName(event_name);
+        event && this.pushTag({ ecommerce: null });
+        event && this.pushTag({ 'event': this.translateEventName(event_name), ecommerce: 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';
+            case 'select_promotion': return 'select_promotion';
+            case 'select_item': return 'select_item';
+            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 '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);
+            case 'select_promotion': return this.toSelectPromotion(data);
+            case 'select_item': return this.toSelectItem(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,
+            countItems: data.items?.length || 0,
+            items: data.items.map((item) => ({
+                item_id: item.product.id,
+                item_name: item.product.name,
+                //coupon:'',
+                discount: item.product.discount || 0,
+                //index:'',
+                item_brand: item.product.attributes?.length ? item.product.attributes[0].name : '',
+                item_category: item.product.category,
+                item_variant: item.product.variants[0]?.code || '',
+                //location_id: '',
+                price: item.product.variants[0]?.saleprice || item.product.variants[0]?.price,
+                quantity: item.quantity || 1,
+            }))
+        };
+    }
+    /**
+     * 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) => ({
+                item_id: item.product.id,
+                item_name: item.product.name,
+                //coupon:'',
+                discount: item.product.discount || 0,
+                //index:'',
+                item_brand: item.product.attributes?.length ? item.product.attributes[0].name : '',
+                item_category: item.product.category,
+                //item_list_id: '',
+                //item_list_name: '',
+                item_variant: item.product.variants[0]?.code || '',
+                //location_id: '',
+                price: item.product.variants[0]?.saleprice || item.product.variants[0]?.price,
+                quantity: item.quantity || 1,
+            })),
+            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,
+            value: product.price,
+            items: [this.toItem(product)]
+        };
+    }
+    /**
+     * 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 || 0
+        };
+    }
+    /**
+     * 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_id: product.id,
+        item_name: product.name,
+        //coupon:'',
+        discount: product.discount || 0,
+        //index:'',
+        item_brand: product.attributes?.length ? product.attributes[0].name : '',
+        item_category: product.category,
+        //item_list_id: '',
+        //item_list_name: '',
+        item_variant: product.variants[0]?.code || '',
+        //location_id: '',
+        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",
+            payment_type: data.payments[0]?.method?.code || 'not-payments',
+            value: data.totals?.total || 0,
+            items: data.items.map((item) => ({
+                item_id: item.product.id,
+                item_name: item.product.name,
+                //coupon:'',
+                discount: item.product.discount || 0,
+                //index:'',
+                item_brand: item.product.attributes?.length ? item.product.attributes[0].name : '',
+                item_category: item.product.category,
+                //item_list_id: '',
+                //item_list_name: '',
+                item_variant: item.product.variants[0]?.code || '',
+                //location_id: '',
+                price: item.product.variants[0]?.saleprice || item.product.variants[0]?.price,
+                quantity: item.quantity || 1,
+            })),
+        };
+    }
+    /**
+     * 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",
+            shipping_tier: data.shipments[0]?.method?.code || 'not-shipping',
+            value: data.totals?.total || 0,
+            items: data.items.map((item) => ({
+                item_id: item.product.id,
+                item_name: item.product.name,
+                //coupon:'',
+                discount: item.product.discount || 0,
+                //index:'',
+                item_brand: item.product.attributes?.length ? item.product.attributes[0].name : '',
+                item_category: item.product.category,
+                //item_list_id: '',
+                //item_list_name: '',
+                item_variant: item.product.variants[0]?.code || '',
+                //location_id: '',
+                price: item.product.variants[0]?.saleprice || item.product.variants[0]?.price,
+                quantity: item.quantity || 1,
+            })),
+        };
+    }
+    toSignUp(data) {
+        return {
+            ...data
+        };
+    }
+    /**
+     * Evento que se dispara cuando se interactua con una promoción.
+     * @param data
+     * @returns
+     */
+    toSelectPromotion(data) {
+        console.log(data);
+        return {
+            promotion_id: data.id || '',
+            promotion_name: data.code || data.name,
+            promotion_title: data.subtitle,
+            location_id: data.priority || 0
+        };
+    }
+    /**
+     * Evento que se disapra cuando se interactua al seleccionar un item.
+     * @param data
+     * @returns
+     */
+    toSelectItem(data) {
+        console.log(data);
+        return {
+            items: this.toItem(data)
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: GTMService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: GTMService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: GTMService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gtm.service.js","sourceRoot":"","sources":["../../../../../../projects/ng-easycommerce-v18/src/lib/ec-services/analytics/gtm.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { afterRender, inject, Injectable, PLATFORM_ID, Renderer2, RendererFactory2 } from '@angular/core';\nimport { AnalyticEventKey, GoogleTagManagerConfig } from '../../interfaces';\nimport { NavigationEnd, Router } from '@angular/router';\nimport { DOCUMENT, isPlatformBrowser } from '@angular/common';\n/**\n * Servicio que se encarga de manejar el analytics de GTM.\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class GTMService {\n    /**\n     * Indica si se esta cargando el servicio.\n     */\n    private isLoaded: boolean = false;\n    /**\n     * Indica cuando el servicio esta habilitado.\n     */\n    private enabled: boolean = false;\n    /**\n     * Se encarga de crear el elemento HTML con las configuraciones para \n     * que se pueda ejecutar el servicio.\n     */\n    private renderer: Renderer2;\n    /**\n     * Almacena el objecto window del navegador.\n     */\n    private window?: Window;\n\n    private rendererFactory: RendererFactory2 = inject(RendererFactory2);\n    private document: Document | null = null;\n    /**\n     * Servicio de ruteo de angular.\n     */\n    private router: Router = inject(Router);\n    /**\n     * Configuración de Google Tag Manager.\n     */\n    private config: GoogleTagManagerConfig = { id: null }\n    private platformId: any = inject(PLATFORM_ID)\n    constructor() {\n        this.renderer = this.rendererFactory.createRenderer(null, null);\n        if (isPlatformBrowser(this.platformId)) {\n            this.window = window\n            this.document = inject(DOCUMENT);\n        }\n    }\n    /**\n     * Obtiene el dataLayer del objecto window\n     * @returns \n     */\n    public getDataLayer(): any[] {\n        const window = this.window;\n        /* if(window)\n        window.dataLayer = window.dataLayer || [];\n        return window.dataLayer; */\n        return []\n    }\n    /**\n     * Agrega datos al dataLayer.\n     * @param obj \n     */\n    private pushOnDataLayer(obj: object): void {\n        const dataLayer = this.getDataLayer();\n        dataLayer.push(obj);\n    }\n    /**\n     * Agrega el script de GTM para que empiece a capturar eventos.\n     * @returns \n     */\n    public addGtmToDom(): Promise<boolean> {\n        return new Promise(\n            (resolve, reject) => {\n                if (this.isLoaded) {\n                    return resolve(this.isLoaded);\n                }\n                //const doc = this.browserGlobals.documentRef();\n                this.pushOnDataLayer({ 'gtm.start': new Date().getTime(), event: 'gtm.js' });\n\n                const gtmScript = this.document?.createElement('script') //doc.createElement('script');\n                if(gtmScript){\n                    gtmScript.id = 'GTMscript';\n                    gtmScript.async = true;\n                    gtmScript.src = this.applyGtmQueryParams(this.config[\"gtm_resource_path\"] ? this.config[\"gtm_resource_path\"] : 'https://www.googletagmanager.com/gtm.js');\n                    gtmScript.addEventListener('load', () => {\n                        return resolve(this.isLoaded = true);\n                    });\n                    gtmScript.addEventListener('error', () => {\n                        return reject(false);\n                    });\n                    this.document?.head.insertBefore(gtmScript, this.document.head.firstChild);\n                }\n            }\n        );\n    }\n\n    private applyGtmQueryParams(url: string): string {\n        if (url.indexOf('?') === -1) {\n            url += '?';\n        }\n        return (url + Object.keys(this.config).filter((k) => this.config[k]).map((k) => `${k}=${this.config[k]\n            }`).join('&'));\n    }\n    /**\n     * Inicializa el Servicio de analytics con sus configuraciones.\n     * @param config Configuraciones de Google Tag Manager\n     */\n    public initialize(config: GoogleTagManagerConfig) {\n        this.config = config || this.config;\n        this.addGtmToDom().then(() => {\n            this.router.events.forEach(item => {\n                if (item instanceof NavigationEnd) {\n                    const gtmTag = {\n                        event: 'page',\n                        pageName: item.url\n                    };\n                    this.pushTag(gtmTag);\n                }\n            });\n        })\n    }\n\n    public pushTag(item: object): Promise<void> {\n        return new Promise<void>((resolve, reject) => {\n            if (!this.isLoaded) {\n                this.addGtmToDom().then(() => {\n                    this.pushOnDataLayer(item);\n                    return resolve();\n                }).catch(() => reject());\n            } else {\n                this.pushOnDataLayer(item);\n                return resolve();\n            }\n        });\n    }\n    /**\n     * Ejecuta el evento pasado por parametro. \n     * @param event_name Nombre del evento.\n     * @param data Data extra para agregar al evento.\n     * @returns \n     */\n    callEvent(event_name: AnalyticEventKey, data = {}) {\n        if (!this.isLoaded) return;\n        let event = this.translateEventName(event_name);\n        event && this.pushTag({ ecommerce: null })\n        event && this.pushTag({ 'event': this.translateEventName(event_name), ecommerce: this.evalEvent(event_name, data) })\n    }\n    /**\n     * Traduce el evento recibido y devuelve el nombre de la función que lo va a tratar.\n     * @param event_name \n     * @returns \n     */\n    translateEventName(event_name: AnalyticEventKey) {\n        switch (event_name) {\n            case 'view_item': return 'view_item';\n            case 'view_item_list': return 'view_item_list';\n            case 'checkout_init': return 'begin_checkout';\n            case 'shipping_info': return 'add_shipping_info';\n            case 'add_payment_info': return 'add_payment_info';\n            case 'purchase': return 'purchase';\n            case 'add_to_cart': return 'add_to_cart';\n            case 'remove_from_cart': return 'remove_from_cart';\n            case 'sign_up': return 'sign_up';\n            case 'select_promotion': return 'select_promotion';\n            case 'select_item': return 'select_item';\n            default: return null;\n        }\n    }\n    /**\n     * Evalua el evento y devuelve los datos de las funciones relacionadas.\n     * @param event_name Nombre del evento\n     * @param data Data extra para agregar al evento\n     * @returns \n     */\n    evalEvent(event_name: AnalyticEventKey, data: any) {\n        switch (event_name) {\n            case 'view_item': return this.toViewItem(data);\n            case 'view_item_list': return this.toViewItemList(data);\n            case 'checkout_init': return this.toCheckoutInit(data);\n            case 'shipping_info': return this.toShippingInfo(data);\n            case 'add_payment_info': return this.toPaymentInfo(data);\n            case 'purchase': return this.toPurchase(data);\n            case 'add_to_cart': return this.toAddToCart(data);\n            case 'remove_from_cart': return this.toRemoveToCart(data);\n            case 'sign_up': return this.toSignUp(data);\n            case 'select_promotion': return this.toSelectPromotion(data);\n            case 'select_item': return this.toSelectItem(data);\n            default: return data;\n        }\n    }\n    /**\n     * Evento que se dispara cuando se quiere comprar un producto.\n     * @param data \n     * @returns \n     */\n    private toPurchase(data: any) {\n        return {\n            coupon: this.toCartDiscount(data),\n            currency: data.currency,\n            shipping: data.totals.shipping,\n            tax: data.totals.taxes,\n            value: data.totals.total,\n            transaction_id: data.number,\n            countItems: data.items?.length || 0,\n            items: data.items.map((item: any) => ({\n                item_id: item.product.id,\n                item_name: item.product.name,\n                //coupon:'',\n                discount: item.product.discount || 0,\n                //index:'',\n                item_brand: item.product.attributes?.length ? item.product.attributes[0].name : '',\n                item_category: item.product.category,\n                item_variant: item.product.variants[0]?.code || '',\n                //location_id: '',\n                price: item.product.variants[0]?.saleprice || item.product.variants[0]?.price,\n                quantity: item.quantity || 1,\n            }))\n        }\n    }\n    /**\n     * Evento que se dispara cuando se inicializa en checkout.\n     * @param data \n     * @returns \n     */\n    private toCheckoutInit(data: any) {\n        return {\n            coupon: this.toCartDiscount(data),\n            currency: data.currency || \"USD\",\n            items: data.items.map((item: any) => ({\n                item_id: item.product.id,\n                item_name: item.product.name,\n                //coupon:'',\n                discount: item.product.discount || 0,\n                //index:'',\n                item_brand: item.product.attributes?.length ? item.product.attributes[0].name : '',\n                item_category: item.product.category,\n                //item_list_id: '',\n                //item_list_name: '',\n                item_variant: item.product.variants[0]?.code || '',\n                //location_id: '',\n                price: item.product.variants[0]?.saleprice || item.product.variants[0]?.price,\n                quantity: item.quantity || 1,\n            })),\n            value: data.totals?.total || 0,\n        }\n    }\n    /**\n     * Evento que se dispara con los descuentos en el carrito.\n     * @param data \n     * @returns \n     */\n    private toCartDiscount(data: any) {\n        let strDiscount = ''\n        strDiscount = data.cartDiscounts.map((itemDiscount: any) => itemDiscount?.type).join()\n        return strDiscount == '' ? 'not-discount' : strDiscount\n    }\n    /**\n     * Evento que se dispara cuando se agrega un producto al carrito. \n     * @param data \n     * @returns \n     */\n    private toAddToCart(data: any) {\n        let lastProduct = data.items?.length && data.items[data.items.length - 1]\n        return {\n            currency: data.currency || \"USD\",\n            items: [this.toItem({ quantity: lastProduct.quantity, ...lastProduct.product })],\n            value: lastProduct.total || 0,\n        }\n    }\n    /**\n     * Cambia la variable **enabled** a `false`\n     * @returns \n     */\n    disable() { this.enabled = false }\n    /**\n     * Evento que se dispara cuando se interactua a las vista del producto.\n     * @param product \n     * @returns \n     */\n    private toViewItem(product: any) {\n        return {\n            currency: product.currency,\n            value: product.price,\n            items: [this.toItem(product)]\n\n        }\n    }\n    /**\n     * Evento que se dispara cuando se interactua con el listado de productos.\n     * @param data \n     * @returns \n     */\n    private toViewItemList(data: any) {\n        return {\n            items: data.products.map((product: any) => this.toItem(product)),\n            item_list_name: data.item_list_name || 'Collection',\n            item_list_id: data.item_list_id || 0\n        }\n\n\n    }\n    /**\n     * Evento que se dispara cuando se quita un item del carrito.\n     * @param product \n     * @returns \n     */\n    private toRemoveToCart(product: any) {\n        let productParam = product.product\n        return {\n            currency: product.currency || \"USD\",\n            items: [this.toItem({ quantity: product.quantity, ...productParam })],\n            value: (productParam.variants[0]?.saleprice || productParam.variants[0]?.price) * product.quantity || 1,\n        }\n    }\n\n    private toItem = (product: any) => ({\n        item_id: product.id,\n        item_name: product.name,\n        //coupon:'',\n        discount: product.discount || 0,\n        //index:'',\n        item_brand: product.attributes?.length ? product.attributes[0].name : '',\n        item_category: product.category,\n        //item_list_id: '',\n        //item_list_name: '',\n        item_variant: product.variants[0]?.code || '',\n        //location_id: '',\n        price: product.variants[0]?.saleprice || product.variants[0]?.price,\n        quantity: product.quantity || 1,\n    })\n    /**\n     * Evento que se dispara cuando se consulta la información de pago.\n     * @param data \n     * @returns \n     */\n    private toPaymentInfo(data: any) {\n        return {\n            coupon: this.toCartDiscount(data),\n            currency: data.currency || \"USD\",\n            payment_type: data.payments[0]?.method?.code || 'not-payments',\n            value: data.totals?.total || 0,\n            items: data.items.map((item: any) => ({\n                item_id: item.product.id,\n                item_name: item.product.name,\n                //coupon:'',\n                discount: item.product.discount || 0,\n                //index:'',\n                item_brand: item.product.attributes?.length ? item.product.attributes[0].name : '',\n                item_category: item.product.category,\n                //item_list_id: '',\n                //item_list_name: '',\n                item_variant: item.product.variants[0]?.code || '',\n                //location_id: '',\n                price: item.product.variants[0]?.saleprice || item.product.variants[0]?.price,\n                quantity: item.quantity || 1,\n            })),\n        }\n    }\n    /**\n     * Evento que se dispara cuando se interactua con los métodos de envío.\n     * @param data \n     * @returns \n     */\n    private toShippingInfo(data: any) {\n        return {\n            coupon: this.toCartDiscount(data),\n            currency: data.currency || \"USD\",\n            shipping_tier: data.shipments[0]?.method?.code || 'not-shipping',\n            value: data.totals?.total || 0,\n            items: data.items.map((item: any) => ({\n                item_id: item.product.id,\n                item_name: item.product.name,\n                //coupon:'',\n                discount: item.product.discount || 0,\n                //index:'',\n                item_brand: item.product.attributes?.length ? item.product.attributes[0].name : '',\n                item_category: item.product.category,\n                //item_list_id: '',\n                //item_list_name: '',\n                item_variant: item.product.variants[0]?.code || '',\n                //location_id: '',\n                price: item.product.variants[0]?.saleprice || item.product.variants[0]?.price,\n                quantity: item.quantity || 1,\n            })),\n        }\n    }\n\n    private toSignUp(data: any) {\n        return {\n            ...data\n        }\n    }\n    /**\n     * Evento que se dispara cuando se interactua con una promoción.\n     * @param data \n     * @returns \n     */\n    private toSelectPromotion(data: any) {\n        console.log(data);\n        return {\n            promotion_id: data.id || '',\n            promotion_name: data.code || data.name,\n            promotion_title: data.subtitle,\n            location_id: data.priority || 0\n        }\n    }\n    /**\n     * Evento que se disapra cuando se interactua al seleccionar un item.\n     * @param data \n     * @returns \n     */\n    private toSelectItem(data: any) {\n        console.log(data);\n        return {\n            items: this.toItem(data)\n        }\n    }\n}\n"]}

package/esm2022/lib/ec-services/analytics/index.mjs

@@ -0,0 +1,7 @@
+export * from './facebook-pixel.service';
+export * from './analytics.service';
+export * from './doppler.service';
+export * from './metricool-pixel.service';
+export * from './google-analytics.service';
+export * from './gtm.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1lYXN5Y29tbWVyY2UtdjE4L3NyYy9saWIvZWMtc2VydmljZXMvYW5hbHl0aWNzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZmFjZWJvb2stcGl4ZWwuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2FuYWx5dGljcy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZG9wcGxlci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbWV0cmljb29sLXBpeGVsLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9nb29nbGUtYW5hbHl0aWNzLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9ndG0uc2VydmljZSc7Il19

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

@@ -0,0 +1,55 @@
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import { inject, Injectable, PLATFORM_ID, RendererFactory2 } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Servicio encargado de manejar el analytics de Metricool Pixel
+ */
+export class MetricoolPixelService {
+    /**
+     * Indica si se esta cargando el Servicio.
+     */
+    isLoaded = false;
+    rendererFactory = inject(RendererFactory2);
+    document = inject(DOCUMENT);
+    platformId = inject(PLATFORM_ID);
+    /**
+     * Se encarga de crear el elemento HTML con las configuraciones para
+     * que se pueda ejecutar el servicio.
+     */
+    renderer;
+    constructor() {
+        if (isPlatformBrowser(this.platformId)) {
+            this.document = document;
+        }
+        this.renderer = this.rendererFactory.createRenderer(null, null);
+    }
+    /**
+     * Inicializa el Servicio de analytics con sus configuraciones.
+     * @param pixel_hash hash provisto por Metricool Pixel.
+     */
+    initialize = (pixel_hash) => {
+        let new_analityc_script = this.renderer.createElement('script');
+        new_analityc_script.type = 'text/javascript';
+        new_analityc_script.text = `
+        function loadScript(a) {
+            var b = document.getElementsByTagName("head")[0], c = document.createElement("script");
+            c.type = "text/javascript",
+                c.src = "https://tracker.metricool.com/resources/be.js",
+                c.onreadystatechange = a,
+                c.onload = a, b.appendChild(c)
+        } loadScript(function () {
+            beTracker.t({ hash: "${pixel_hash}" })
+        });
+        `;
+        this.renderer.appendChild(this.document?.body, new_analityc_script);
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: MetricoolPixelService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: MetricoolPixelService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: MetricoolPixelService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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