angulartics2 9.1.0 → 12.0.0

package/esm2020/providers/gtm/gtm.mjs

@@ -0,0 +1,114 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class GoogleTagManagerDefaults {
+    constructor() {
+        this.userId = null;
+    }
+}
+export class Angulartics2GoogleTagManager {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+        // The dataLayer needs to be initialized
+        if (typeof dataLayer !== 'undefined' && dataLayer) {
+            dataLayer = window.dataLayer = window.dataLayer || [];
+        }
+        const defaults = new GoogleTagManagerDefaults();
+        // Set the default settings for this module
+        this.angulartics2.settings.gtm = { ...defaults, ...this.angulartics2.settings.gtm };
+        this.angulartics2.setUsername.subscribe((x) => this.setUsername(x));
+    }
+    startTracking() {
+        this.angulartics2.pageTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.pageTrack(x.path));
+        this.angulartics2.eventTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.eventTrack(x.action, x.properties));
+        this.angulartics2.exceptionTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe((x) => this.exceptionTrack(x));
+    }
+    pageTrack(path) {
+        this.pushLayer({
+            event: 'Page View',
+            'content-name': path,
+            userId: this.angulartics2.settings.gtm.userId,
+        });
+    }
+    /**
+     * Send Data Layer
+     *
+     * @layer data layer object
+     */
+    pushLayer(layer) {
+        if (typeof dataLayer !== 'undefined' && dataLayer) {
+            dataLayer.push(layer);
+        }
+    }
+    /**
+     * Send interactions to the dataLayer, i.e. for event tracking in Google Analytics
+     *
+     * @param action associated with the event
+     */
+    eventTrack(action, properties) {
+        // TODO: make interface
+        //  @param {string} properties.category
+        //  @param {string} [properties.label]
+        //  @param {number} [properties.value]
+        //  @param {boolean} [properties.noninteraction]
+        // Set a default GTM category
+        properties = properties || {};
+        this.pushLayer({
+            event: properties.event || 'interaction',
+            target: properties.category || 'Event',
+            action,
+            label: properties.label,
+            value: properties.value,
+            interactionType: properties.noninteraction,
+            userId: this.angulartics2.settings.gtm.userId,
+            ...properties.gtmCustom,
+        });
+    }
+    /**
+     * Exception Track Event in GTM
+     *
+     */
+    exceptionTrack(properties) {
+        // TODO: make interface
+        //  @param {Object} properties
+        //  @param {string} properties.appId
+        //  @param {string} properties.appName
+        //  @param {string} properties.appVersion
+        //  @param {string} [properties.description]
+        //  @param {boolean} [properties.fatal]
+        if (!properties || !properties.appId || !properties.appName || !properties.appVersion) {
+            console.error('Must be setted appId, appName and appVersion.');
+            return;
+        }
+        if (properties.fatal === undefined) {
+            console.log('No "fatal" provided, sending with fatal=true');
+            properties.exFatal = true;
+        }
+        properties.exDescription = properties.event ? properties.event.stack : properties.description;
+        this.eventTrack(`Exception thrown for ${properties.appName} <${properties.appId}@${properties.appVersion}>`, {
+            category: 'Exception',
+            label: properties.exDescription,
+        });
+    }
+    /**
+     * Set userId for use with Universal Analytics User ID feature
+     *
+     * @param userId used to identify user cross-device in Google Analytics
+     */
+    setUsername(userId) {
+        this.angulartics2.settings.gtm.userId = userId;
+    }
+}
+Angulartics2GoogleTagManager.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleTagManager, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2GoogleTagManager.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleTagManager, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleTagManager, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gtm.js","sourceRoot":"","sources":["../../../../src/lib/providers/gtm/gtm.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { Angulartics2 } from '../../angulartics2-core';\nimport { GoogleTagManagerSettings } from '../../angulartics2-config';\n\ndeclare var dataLayer: any;\n\nexport class GoogleTagManagerDefaults implements GoogleTagManagerSettings {\n  userId = null;\n}\n\n@Injectable({ providedIn: 'root' })\nexport class Angulartics2GoogleTagManager {\n  constructor(protected angulartics2: Angulartics2) {\n    // The dataLayer needs to be initialized\n    if (typeof dataLayer !== 'undefined' && dataLayer) {\n      dataLayer = (window as any).dataLayer = (window as any).dataLayer || [];\n    }\n    const defaults = new GoogleTagManagerDefaults();\n    // Set the default settings for this module\n    this.angulartics2.settings.gtm = { ...defaults, ...this.angulartics2.settings.gtm };\n    this.angulartics2.setUsername.subscribe((x: string) => this.setUsername(x));\n  }\n\n  startTracking() {\n    this.angulartics2.pageTrack\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe(x => this.pageTrack(x.path));\n    this.angulartics2.eventTrack\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe(x => this.eventTrack(x.action, x.properties));\n    this.angulartics2.exceptionTrack\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe((x: any) => this.exceptionTrack(x));\n  }\n\n  pageTrack(path: string) {\n    this.pushLayer({\n      event: 'Page View',\n      'content-name': path,\n      userId: this.angulartics2.settings.gtm.userId,\n    });\n  }\n\n  /**\n   * Send Data Layer\n   *\n   * @layer data layer object\n   */\n  pushLayer(layer: any) {\n    if (typeof dataLayer !== 'undefined' && dataLayer) {\n      dataLayer.push(layer);\n    }\n  }\n\n  /**\n   * Send interactions to the dataLayer, i.e. for event tracking in Google Analytics\n   *\n   * @param action associated with the event\n   */\n  eventTrack(action: string, properties: any) {\n    // TODO: make interface\n    //  @param {string} properties.category\n    //  @param {string} [properties.label]\n    //  @param {number} [properties.value]\n    //  @param {boolean} [properties.noninteraction]\n    // Set a default GTM category\n    properties = properties || {};\n\n    this.pushLayer({\n      event: properties.event || 'interaction',\n      target: properties.category || 'Event',\n      action,\n      label: properties.label,\n      value: properties.value,\n      interactionType: properties.noninteraction,\n      userId: this.angulartics2.settings.gtm.userId,\n      ...properties.gtmCustom,\n    });\n  }\n\n  /**\n   * Exception Track Event in GTM\n   *\n   */\n  exceptionTrack(properties: any) {\n    // TODO: make interface\n    //  @param {Object} properties\n    //  @param {string} properties.appId\n    //  @param {string} properties.appName\n    //  @param {string} properties.appVersion\n    //  @param {string} [properties.description]\n    //  @param {boolean} [properties.fatal]\n    if (!properties || !properties.appId || !properties.appName || !properties.appVersion) {\n      console.error('Must be setted appId, appName and appVersion.');\n      return;\n    }\n\n    if (properties.fatal === undefined) {\n      console.log('No \"fatal\" provided, sending with fatal=true');\n      properties.exFatal = true;\n    }\n\n    properties.exDescription = properties.event ? properties.event.stack : properties.description;\n\n    this.eventTrack(\n      `Exception thrown for ${properties.appName} <${properties.appId}@${properties.appVersion}>`,\n      {\n        category: 'Exception',\n        label: properties.exDescription,\n      },\n    );\n  }\n\n  /**\n   * Set userId for use with Universal Analytics User ID feature\n   *\n   * @param userId used to identify user cross-device in Google Analytics\n   */\n  setUsername(userId: string) {\n    this.angulartics2.settings.gtm.userId = userId;\n  }\n}\n"]}

package/esm2020/providers/hubspot/hubspot.mjs

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class Angulartics2Hubspot {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+        this.angulartics2.setUserProperties.subscribe(x => this.setUserProperties(x));
+    }
+    startTracking() {
+        this.angulartics2.pageTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.pageTrack(x.path));
+        this.angulartics2.eventTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.eventTrack(x.action, x.properties));
+    }
+    pageTrack(path) {
+        if (typeof _hsq !== 'undefined') {
+            _hsq.push(['setPath', path]);
+            _hsq.push(['trackPageView']);
+        }
+    }
+    eventTrack(action, properties) {
+        if (typeof _hsq !== 'undefined') {
+            _hsq.push(['trackEvent', properties]);
+        }
+    }
+    setUserProperties(properties) {
+        if (typeof _hsq !== 'undefined') {
+            _hsq.push(['identify', properties]);
+        }
+    }
+}
+Angulartics2Hubspot.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Hubspot, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2Hubspot.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Hubspot, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Hubspot, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/providers/ibm-digital-analytics/ibm-digital-analytics.mjs

@@ -0,0 +1,125 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class Angulartics2IBMDigitalAnalytics {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+        if (typeof window['cmCreatePageviewTag'] !== 'function') {
+            console.warn('Angulartics 2 IBM Digital Analytics Plugin: eluminate.js is not loaded');
+        }
+    }
+    startTracking() {
+        this.angulartics2.pageTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.pageTrack(x.path));
+        this.angulartics2.eventTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.eventTrack(x.action, x.properties));
+    }
+    /**
+     * Track Page in IBM Digital Analytics
+     *
+     * @param path location
+     *
+     * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_pageviewtag.html
+     */
+    pageTrack(path) {
+        const cmCreatePageviewTag = window['cmCreatePageviewTag'];
+        cmCreatePageviewTag(path, null, null, null);
+    }
+    /**
+     * Track an event in IBM Digital Analytics
+     *
+     * @param action A string corresponding to the type of event that needs to be tracked.
+     * @param properties The properties that need to be logged with the event.
+     */
+    eventTrack(action, properties = {}) {
+        const cmDisplayShops = window['cmDisplayShops'];
+        switch (action) {
+            /**
+             * @description The Product View tag captures information about vdigitalDataiews of product detail pages.
+             *  The Product View tag should be called on the lowest level detail page for products, which is typically
+             *  the Product Details page. You can view example Product View tags below.
+             *
+             * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_prodviewtag.html
+             */
+            case 'cmCreateProductviewTag':
+                const cmCreateProductviewTag = window['cmCreateProductviewTag'];
+                cmCreateProductviewTag(properties.productId, properties.productName, properties.categoryId, properties.attrbute, properties.virtualCategory);
+                break;
+            /**
+             * @description The Shop Action 5 tag captures data about selected products and which products are present in a shopping cart,
+             *  if any, when the cart is viewed.
+             *
+             * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_shopact5tag.html
+             */
+            case 'cmCreateShopAction5Tag':
+                const cmCreateShopAction5Tag = window['cmCreateShopAction5Tag'];
+                cmCreateShopAction5Tag(properties.productId, properties.productName, properties.quantity, properties.unitPrice, properties.categoryId, properties.attrbute, properties.extraFields, properties.virtualCategory);
+                cmDisplayShops();
+                break;
+            /**
+             * @description The Shop Action 9 tag captures data about what products were purchased by a customer.
+             *  Like the Shop Action 5 tag, one tag should be sent for each product line item purchased. These tags should be sent
+             *  on the receipt or other completion page confirming a successful order.
+             *
+             * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_shopact9tag.html
+             */
+            case 'cmCreateShopAction9Tag':
+                const cmCreateShopAction9Tag = window['cmCreateShopAction9Tag'];
+                cmCreateShopAction9Tag(properties.productId, properties.productName, properties.quantity, properties.unitPrice, properties.registrationId, properties.orderId, properties.orderSubtotal, properties.categoryId, properties.attrbute, properties.extraFields);
+                cmDisplayShops();
+                break;
+            /**
+             * @description The Order tag captures order header information such as Registration ID, order ID, order subtotal,
+             *  and shipping and handling. The Order tag should be sent on the receipt page confirming order completion.
+             *
+             * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_ordertag.html
+             */
+            case 'cmCreateOrderTag':
+                const cmCreateOrderTag = window['cmCreateOrderTag'];
+                cmCreateOrderTag(properties.orderId, properties.orderSubtotal, properties.orderShipping, properties.registrationId, properties.registrantCity, properties.registrantState, properties.registrantPostalCode, properties.attrbute, properties.extraFields);
+                break;
+            /**
+             * @description The Registration tag creates a Lifetime Visitor Experience Profile (LIVE Profile) by associating a single
+             *  common Registration ID with the IBM® Digital Analytics permanent cookie set in every browser visiting the tagged site.
+             *
+             * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_registrationtag.html
+             */
+            case 'cmCreateRegistrationTag':
+                const cmCreateRegistrationTag = window['cmCreateRegistrationTag'];
+                cmCreateRegistrationTag(properties.registrationId, properties.registrantEmail, properties.registrantCity, properties.registrantState, properties.registrantPostalCode, properties.registrantCountry, properties.attrbute);
+                break;
+            /**
+             * @description The Element tag is used to track intra-page content in IBM® Digital Analytics. Data collected by
+             *  the Element tag is used to populate values in the Element Categories and Top Viewed Elements reports.
+             *
+             * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_elementtag.html
+             */
+            case 'cmCreateElementTag':
+                const cmCreateElementTag = window['cmCreateElementTag'];
+                cmCreateElementTag(properties.elementId, properties.elementCategory, properties.attrbute);
+                break;
+            /**
+             * @description The Conversion Event tag is employed for tracking of general non-commerce conversion events.
+             * The Conversion Event tag is used to populate values in the Conversion Events Reports and to create Key Segments.
+             * This tag and the reports it populates enable analysis of a wide variety of site activities.
+             *
+             * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_conversioneventtag.html
+             */
+            case 'cmCreateConversionEventTag':
+                const cmCreateConversionEventTag = window['cmCreateConversionEventTag'];
+                cmCreateConversionEventTag(properties.eventId, properties.actionType, properties.eventCategoryId, properties.points, properties.attrbute, properties.extraFields);
+                break;
+            default:
+                console.warn('Unsupported Event Action');
+        }
+    }
+}
+Angulartics2IBMDigitalAnalytics.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2IBMDigitalAnalytics, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2IBMDigitalAnalytics.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2IBMDigitalAnalytics, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2IBMDigitalAnalytics, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ibm-digital-analytics.js","sourceRoot":"","sources":["../../../../src/lib/providers/ibm-digital-analytics/ibm-digital-analytics.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Angulartics2 } from '../../angulartics2-core';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class Angulartics2IBMDigitalAnalytics {\r\n  constructor(private angulartics2: Angulartics2) {\r\n    if (typeof window['cmCreatePageviewTag'] !== 'function') {\r\n      console.warn('Angulartics 2 IBM Digital Analytics Plugin: eluminate.js is not loaded');\r\n    }\r\n  }\r\n\r\n  startTracking(): void {\r\n    this.angulartics2.pageTrack\r\n      .pipe(this.angulartics2.filterDeveloperMode())\r\n      .subscribe(x => this.pageTrack(x.path));\r\n    this.angulartics2.eventTrack\r\n      .pipe(this.angulartics2.filterDeveloperMode())\r\n      .subscribe(x => this.eventTrack(x.action, x.properties));\r\n  }\r\n\r\n  /**\r\n   * Track Page in IBM Digital Analytics\r\n   *\r\n   * @param path location\r\n   *\r\n   * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_pageviewtag.html\r\n   */\r\n  pageTrack(path: string) {\r\n    const cmCreatePageviewTag = window['cmCreatePageviewTag'];\r\n    cmCreatePageviewTag(path, null, null, null);\r\n  }\r\n\r\n  /**\r\n   * Track an event in IBM Digital Analytics\r\n   *\r\n   * @param action A string corresponding to the type of event that needs to be tracked.\r\n   * @param properties The properties that need to be logged with the event.\r\n   */\r\n  eventTrack(action: string, properties: any = {}) {\r\n    const cmDisplayShops = window['cmDisplayShops'];\r\n    switch (action) {\r\n      /**\r\n       * @description The Product View tag captures information about vdigitalDataiews of product detail pages.\r\n       *  The Product View tag should be called on the lowest level detail page for products, which is typically\r\n       *  the Product Details page. You can view example Product View tags below.\r\n       *\r\n       * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_prodviewtag.html\r\n       */\r\n      case 'cmCreateProductviewTag':\r\n        const cmCreateProductviewTag = window['cmCreateProductviewTag'];\r\n        cmCreateProductviewTag(\r\n          properties.productId,\r\n          properties.productName,\r\n          properties.categoryId,\r\n          properties.attrbute,\r\n          properties.virtualCategory,\r\n        );\r\n\r\n        break;\r\n\r\n      /**\r\n       * @description The Shop Action 5 tag captures data about selected products and which products are present in a shopping cart,\r\n       *  if any, when the cart is viewed.\r\n       *\r\n       * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_shopact5tag.html\r\n       */\r\n      case 'cmCreateShopAction5Tag':\r\n        const cmCreateShopAction5Tag = window['cmCreateShopAction5Tag'];\r\n        cmCreateShopAction5Tag(\r\n          properties.productId,\r\n          properties.productName,\r\n          properties.quantity,\r\n          properties.unitPrice,\r\n          properties.categoryId,\r\n          properties.attrbute,\r\n          properties.extraFields,\r\n          properties.virtualCategory,\r\n        );\r\n\r\n        cmDisplayShops();\r\n\r\n        break;\r\n\r\n      /**\r\n       * @description The Shop Action 9 tag captures data about what products were purchased by a customer.\r\n       *  Like the Shop Action 5 tag, one tag should be sent for each product line item purchased. These tags should be sent\r\n       *  on the receipt or other completion page confirming a successful order.\r\n       *\r\n       * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_shopact9tag.html\r\n       */\r\n      case 'cmCreateShopAction9Tag':\r\n        const cmCreateShopAction9Tag = window['cmCreateShopAction9Tag'];\r\n        cmCreateShopAction9Tag(\r\n          properties.productId,\r\n          properties.productName,\r\n          properties.quantity,\r\n          properties.unitPrice,\r\n          properties.registrationId,\r\n          properties.orderId,\r\n          properties.orderSubtotal,\r\n          properties.categoryId,\r\n          properties.attrbute,\r\n          properties.extraFields,\r\n        );\r\n\r\n        cmDisplayShops();\r\n\r\n        break;\r\n\r\n      /**\r\n       * @description The Order tag captures order header information such as Registration ID, order ID, order subtotal,\r\n       *  and shipping and handling. The Order tag should be sent on the receipt page confirming order completion.\r\n       *\r\n       * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_ordertag.html\r\n       */\r\n      case 'cmCreateOrderTag':\r\n        const cmCreateOrderTag = window['cmCreateOrderTag'];\r\n        cmCreateOrderTag(\r\n          properties.orderId,\r\n          properties.orderSubtotal,\r\n          properties.orderShipping,\r\n          properties.registrationId,\r\n          properties.registrantCity,\r\n          properties.registrantState,\r\n          properties.registrantPostalCode,\r\n          properties.attrbute,\r\n          properties.extraFields,\r\n        );\r\n\r\n        break;\r\n\r\n      /**\r\n       * @description The Registration tag creates a Lifetime Visitor Experience Profile (LIVE Profile) by associating a single\r\n       *  common Registration ID with the IBM® Digital Analytics permanent cookie set in every browser visiting the tagged site.\r\n       *\r\n       * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_registrationtag.html\r\n       */\r\n      case 'cmCreateRegistrationTag':\r\n        const cmCreateRegistrationTag = window['cmCreateRegistrationTag'];\r\n        cmCreateRegistrationTag(\r\n          properties.registrationId,\r\n          properties.registrantEmail,\r\n          properties.registrantCity,\r\n          properties.registrantState,\r\n          properties.registrantPostalCode,\r\n          properties.registrantCountry,\r\n          properties.attrbute,\r\n        );\r\n\r\n        break;\r\n\r\n      /**\r\n       * @description The Element tag is used to track intra-page content in IBM® Digital Analytics. Data collected by\r\n       *  the Element tag is used to populate values in the Element Categories and Top Viewed Elements reports.\r\n       *\r\n       * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_elementtag.html\r\n       */\r\n      case 'cmCreateElementTag':\r\n        const cmCreateElementTag = window['cmCreateElementTag'];\r\n        cmCreateElementTag(properties.elementId, properties.elementCategory, properties.attrbute);\r\n\r\n        break;\r\n\r\n      /**\r\n       * @description The Conversion Event tag is employed for tracking of general non-commerce conversion events.\r\n       * The Conversion Event tag is used to populate values in the Conversion Events Reports and to create Key Segments.\r\n       * This tag and the reports it populates enable analysis of a wide variety of site activities.\r\n       *\r\n       * @link https://www.ibm.com/support/knowledgecenter/SSPG9M/Implementation/impl_conversioneventtag.html\r\n       */\r\n      case 'cmCreateConversionEventTag':\r\n        const cmCreateConversionEventTag = window['cmCreateConversionEventTag'];\r\n        cmCreateConversionEventTag(\r\n          properties.eventId,\r\n          properties.actionType,\r\n          properties.eventCategoryId,\r\n          properties.points,\r\n          properties.attrbute,\r\n          properties.extraFields,\r\n        );\r\n\r\n        break;\r\n\r\n      default:\r\n        console.warn('Unsupported Event Action');\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/providers/intercom/intercom.mjs

@@ -0,0 +1,60 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class Angulartics2Intercom {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+        this.angulartics2.setUserProperties.subscribe(x => this.setUserProperties(x));
+        this.angulartics2.setUserPropertiesOnce.subscribe(x => this.setUserProperties(x));
+    }
+    startTracking() {
+        this.angulartics2.pageTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.pageTrack(x.path));
+        this.angulartics2.eventTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.eventTrack(x.action, x.properties));
+    }
+    pageTrack(path) {
+        try {
+            this.eventTrack('Pageview', {
+                url: path,
+            });
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    eventTrack(action, properties) {
+        try {
+            Intercom('trackEvent', action, properties);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    setUserProperties(properties) {
+        try {
+            if (properties.userId && !properties.user_id) {
+                properties.user_id = properties.userId;
+            }
+            Intercom('boot', properties);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+}
+Angulartics2Intercom.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Intercom, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2Intercom.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Intercom, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Intercom, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/providers/kissmetrics/kissmetrics.mjs

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class Angulartics2Kissmetrics {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+        if (typeof _kmq === 'undefined') {
+            _kmq = [];
+        }
+        this.angulartics2.setUsername.subscribe((x) => this.setUsername(x));
+        this.angulartics2.setUserProperties.subscribe(x => this.setUserProperties(x));
+    }
+    startTracking() {
+        this.angulartics2.pageTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.pageTrack(x.path));
+        this.angulartics2.eventTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.eventTrack(x.action, x.properties));
+    }
+    pageTrack(path) {
+        _kmq.push(['record', 'Pageview', { Page: path }]);
+    }
+    eventTrack(action, properties) {
+        _kmq.push(['record', action, properties]);
+    }
+    setUsername(userId) {
+        _kmq.push(['identify', userId]);
+    }
+    setUserProperties(properties) {
+        _kmq.push(['set', properties]);
+    }
+}
+Angulartics2Kissmetrics.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Kissmetrics, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2Kissmetrics.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Kissmetrics, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Kissmetrics, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/providers/launch/launch.mjs

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class Angulartics2LaunchByAdobe {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+        this.payload = {};
+        if ('undefined' === typeof _satellite) {
+            console.warn('Launch not found!');
+        }
+        this.angulartics2.setUsername.subscribe((x) => this.setUsername(x));
+        this.angulartics2.setUserProperties.subscribe(x => this.setUserProperties(x));
+    }
+    setUsername(userId) {
+        if ('undefined' !== typeof userId && userId) {
+            this.payload.userId = userId;
+        }
+    }
+    setUserProperties(properties) {
+        if ('undefined' !== typeof properties && properties) {
+            this.payload.properties = properties;
+        }
+    }
+    startTracking() {
+        this.angulartics2.pageTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.pageTrack(x.path));
+        this.angulartics2.eventTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.eventTrack(x.action, x.properties));
+    }
+    pageTrack(path) {
+        this.payload = this.payload || {};
+        this.payload.path = path;
+        if ('undefined' !== typeof _satellite && _satellite) {
+            _satellite.track('pageTrack', this.payload);
+        }
+    }
+    /**
+     * @param action associated with the event
+     * @param properties associated with the event
+     */
+    eventTrack(action, properties) {
+        properties = properties || {};
+        // add properties to payload
+        this.payload.action = action;
+        this.payload.eventProperties = properties;
+        if ('undefined' !== typeof _satellite && _satellite) {
+            _satellite.track('eventTrack', this.payload);
+        }
+    }
+}
+Angulartics2LaunchByAdobe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2LaunchByAdobe, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2LaunchByAdobe.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2LaunchByAdobe, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2LaunchByAdobe, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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