angulartics2 9.1.0 → 12.0.0

package/esm2020/providers/ga/ga.mjs

@@ -0,0 +1,219 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class GoogleAnalyticsDefaults {
+    constructor() {
+        this.additionalAccountNames = [];
+        this.userId = null;
+        this.transport = '';
+        this.anonymizeIp = false;
+    }
+}
+export class Angulartics2GoogleAnalytics {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+        this.dimensionsAndMetrics = [];
+        const defaults = new GoogleAnalyticsDefaults();
+        // Set the default settings for this module
+        this.angulartics2.settings.ga = {
+            ...defaults,
+            ...this.angulartics2.settings.ga,
+        };
+        this.settings = this.angulartics2.settings.ga;
+        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));
+        this.angulartics2.exceptionTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.exceptionTrack(x));
+        this.angulartics2.userTimings
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.userTimings(x));
+    }
+    pageTrack(path) {
+        if (typeof _gaq !== 'undefined' && _gaq) {
+            _gaq.push(['_trackPageview', path]);
+            for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+                _gaq.push([accountName + '._trackPageview', path]);
+            }
+        }
+        if (typeof ga !== 'undefined' && ga) {
+            if (this.angulartics2.settings.ga.userId) {
+                ga('set', '&uid', this.angulartics2.settings.ga.userId);
+                for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+                    ga(accountName + '.set', '&uid', this.angulartics2.settings.ga.userId);
+                }
+            }
+            if (this.angulartics2.settings.ga.anonymizeIp) {
+                ga('set', 'anonymizeIp', true);
+                for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+                    ga(accountName + '.set', 'anonymizeIp', true);
+                }
+            }
+            ga('send', 'pageview', path);
+            for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+                ga(accountName + '.send', 'pageview', path);
+            }
+        }
+    }
+    /**
+     * Track Event in GA
+     *
+     * @param action Associated with the event
+     * @param properties Comprised of:
+     *  - category (string) and optional
+     *  - label (string)
+     *  - value (integer)
+     *  - noninteraction (boolean)
+     *
+     * @link https://developers.google.com/analytics/devguides/collection/gajs/eventTrackerGuide#SettingUpEventTracking
+     * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/events
+     */
+    eventTrack(action, properties) {
+        // Google Analytics requires an Event Category
+        if (!properties || !properties.category) {
+            properties = properties || {};
+            properties.category = 'Event';
+        }
+        // GA requires that eventValue be an integer, see:
+        // https://developers.google.com/analytics/devguides/collection/analyticsjs/field-reference#eventValue
+        // https://github.com/luisfarzati/angulartics/issues/81
+        if (properties.value) {
+            const parsed = parseInt(properties.value, 10);
+            properties.value = isNaN(parsed) ? 0 : parsed;
+        }
+        if (typeof ga !== 'undefined') {
+            const eventOptions = {
+                eventCategory: properties.category,
+                eventAction: action,
+                eventLabel: properties.label,
+                eventValue: properties.value,
+                nonInteraction: properties.noninteraction,
+                page: properties.page || location.hash.substring(1) || location.pathname,
+                userId: this.angulartics2.settings.ga.userId,
+                hitCallback: properties.hitCallback,
+                ...(this.angulartics2.settings.ga.transport && {
+                    transport: this.angulartics2.settings.ga.transport,
+                }),
+            };
+            // add custom dimensions and metrics
+            this.setDimensionsAndMetrics(properties);
+            ga('send', 'event', eventOptions);
+            for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+                ga(accountName + '.send', 'event', eventOptions);
+            }
+        }
+        else if (typeof _gaq !== 'undefined') {
+            _gaq.push([
+                '_trackEvent',
+                properties.category,
+                action,
+                properties.label,
+                properties.value,
+                properties.noninteraction,
+            ]);
+        }
+    }
+    /**
+     * Exception Track Event in GA
+     *
+     * @param properties Comprised of the optional fields:
+     *  - fatal (string)
+     *  - description (string)
+     *
+     * @https://developers.google.com/analytics/devguides/collection/analyticsjs/exceptions
+     *
+     * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/events
+     */
+    exceptionTrack(properties) {
+        if (properties.fatal === undefined) {
+            console.log('No "fatal" provided, sending with fatal=true');
+            properties.fatal = true;
+        }
+        properties.exDescription = properties.description;
+        const eventOptions = {
+            exFatal: properties.fatal,
+            exDescription: properties.description,
+        };
+        ga('send', 'exception', eventOptions);
+        for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+            ga(accountName + '.send', 'exception', eventOptions);
+        }
+    }
+    /**
+     * User Timings Event in GA
+     *
+     * @param properties Comprised of the mandatory fields:
+     *  - timingCategory (string)
+     *  - timingVar (string)
+     *  - timingValue (number)
+     * Properties can also have the optional fields:
+     *  - timingLabel (string)
+     *
+     * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/user-timings
+     */
+    userTimings(properties) {
+        if (!properties ||
+            !properties.timingCategory ||
+            !properties.timingVar ||
+            !properties.timingValue) {
+            console.error('Properties timingCategory, timingVar, and timingValue are required to be set.');
+            return;
+        }
+        if (typeof ga !== 'undefined') {
+            ga('send', 'timing', properties);
+            for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+                ga(accountName + '.send', 'timing', properties);
+            }
+        }
+    }
+    setUsername(userId) {
+        this.angulartics2.settings.ga.userId = userId;
+        if (typeof ga === 'undefined') {
+            return;
+        }
+        ga('set', 'userId', userId);
+    }
+    setUserProperties(properties) {
+        this.setDimensionsAndMetrics(properties);
+    }
+    setDimensionsAndMetrics(properties) {
+        if (typeof ga === 'undefined') {
+            return;
+        }
+        // clean previously used dimensions and metrics that will not be overriden
+        this.dimensionsAndMetrics.forEach(elem => {
+            if (!properties.hasOwnProperty(elem)) {
+                ga('set', elem, undefined);
+                this.angulartics2.settings.ga.additionalAccountNames.forEach((accountName) => {
+                    ga(`${accountName}.set`, elem, undefined);
+                });
+            }
+        });
+        this.dimensionsAndMetrics = [];
+        // add custom dimensions and metrics
+        Object.keys(properties).forEach(key => {
+            if (key.lastIndexOf('dimension', 0) === 0 || key.lastIndexOf('metric', 0) === 0) {
+                ga('set', key, properties[key]);
+                this.angulartics2.settings.ga.additionalAccountNames.forEach((accountName) => {
+                    ga(`${accountName}.set`, key, properties[key]);
+                });
+                this.dimensionsAndMetrics.push(key);
+            }
+        });
+    }
+}
+Angulartics2GoogleAnalytics.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleAnalytics, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2GoogleAnalytics.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleAnalytics, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleAnalytics, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ga.js","sourceRoot":"","sources":["../../../../src/lib/providers/ga/ga.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { Angulartics2 } from '../../angulartics2-core';\nimport { GoogleAnalyticsSettings } from '../../angulartics2-config';\nimport { UserTimings } from '../../angulartics2-interfaces';\n\ndeclare var _gaq: GoogleAnalyticsCode;\ndeclare var ga: UniversalAnalytics.ga;\ndeclare var location: any;\n\nexport class GoogleAnalyticsDefaults implements GoogleAnalyticsSettings {\n  additionalAccountNames = [];\n  userId = null;\n  transport = '';\n  anonymizeIp = false;\n}\n\n@Injectable({ providedIn: 'root' })\nexport class Angulartics2GoogleAnalytics {\n  dimensionsAndMetrics = [];\n  settings: Partial<GoogleAnalyticsSettings>;\n\n  constructor(private angulartics2: Angulartics2) {\n    const defaults = new GoogleAnalyticsDefaults();\n    // Set the default settings for this module\n    this.angulartics2.settings.ga = {\n      ...defaults,\n      ...this.angulartics2.settings.ga,\n    };\n    this.settings = this.angulartics2.settings.ga;\n    this.angulartics2.setUsername.subscribe((x: string) => this.setUsername(x));\n    this.angulartics2.setUserProperties.subscribe(x => this.setUserProperties(x));\n  }\n\n  startTracking(): void {\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 => this.exceptionTrack(x));\n    this.angulartics2.userTimings\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe(x => this.userTimings(x));\n  }\n\n  pageTrack(path: string) {\n    if (typeof _gaq !== 'undefined' && _gaq) {\n      _gaq.push(['_trackPageview', path]);\n      for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n        _gaq.push([accountName + '._trackPageview', path]);\n      }\n    }\n    if (typeof ga !== 'undefined' && ga) {\n      if (this.angulartics2.settings.ga.userId) {\n        ga('set', '&uid', this.angulartics2.settings.ga.userId);\n        for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n          ga(accountName + '.set', '&uid', this.angulartics2.settings.ga.userId);\n        }\n      }\n      if (this.angulartics2.settings.ga.anonymizeIp) {\n        ga('set', 'anonymizeIp', true);\n        for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n          ga(accountName + '.set', 'anonymizeIp', true);\n        }\n      }\n      ga('send', 'pageview', path);\n      for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n        ga(accountName + '.send', 'pageview', path);\n      }\n    }\n  }\n\n  /**\n   * Track Event in GA\n   *\n   * @param action Associated with the event\n   * @param properties Comprised of:\n   *  - category (string) and optional\n   *  - label (string)\n   *  - value (integer)\n   *  - noninteraction (boolean)\n   *\n   * @link https://developers.google.com/analytics/devguides/collection/gajs/eventTrackerGuide#SettingUpEventTracking\n   * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/events\n   */\n  eventTrack(action: string, properties: any) {\n    // Google Analytics requires an Event Category\n    if (!properties || !properties.category) {\n      properties = properties || {};\n      properties.category = 'Event';\n    }\n    // GA requires that eventValue be an integer, see:\n    // https://developers.google.com/analytics/devguides/collection/analyticsjs/field-reference#eventValue\n    // https://github.com/luisfarzati/angulartics/issues/81\n    if (properties.value) {\n      const parsed = parseInt(properties.value, 10);\n      properties.value = isNaN(parsed) ? 0 : parsed;\n    }\n\n    if (typeof ga !== 'undefined') {\n      const eventOptions = {\n        eventCategory: properties.category,\n        eventAction: action,\n        eventLabel: properties.label,\n        eventValue: properties.value,\n        nonInteraction: properties.noninteraction,\n        page: properties.page || location.hash.substring(1) || location.pathname,\n        userId: this.angulartics2.settings.ga.userId,\n        hitCallback: properties.hitCallback,\n        ...(this.angulartics2.settings.ga.transport && {\n          transport: this.angulartics2.settings.ga.transport,\n        }),\n      };\n\n      // add custom dimensions and metrics\n      this.setDimensionsAndMetrics(properties);\n\n      ga('send', 'event', eventOptions);\n\n      for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n        ga(accountName + '.send', 'event', eventOptions);\n      }\n    } else if (typeof _gaq !== 'undefined') {\n      _gaq.push([\n        '_trackEvent',\n        properties.category,\n        action,\n        properties.label,\n        properties.value,\n        properties.noninteraction,\n      ]);\n    }\n  }\n\n  /**\n   * Exception Track Event in GA\n   *\n   * @param properties Comprised of the optional fields:\n   *  - fatal (string)\n   *  - description (string)\n   *\n   * @https://developers.google.com/analytics/devguides/collection/analyticsjs/exceptions\n   *\n   * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/events\n   */\n  exceptionTrack(properties: any) {\n    if (properties.fatal === undefined) {\n      console.log('No \"fatal\" provided, sending with fatal=true');\n      properties.fatal = true;\n    }\n\n    properties.exDescription = properties.description;\n\n    const eventOptions = {\n      exFatal: properties.fatal,\n      exDescription: properties.description,\n    };\n\n    ga('send', 'exception', eventOptions);\n    for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n      ga(accountName + '.send', 'exception', eventOptions);\n    }\n  }\n\n  /**\n   * User Timings Event in GA\n   *\n   * @param properties Comprised of the mandatory fields:\n   *  - timingCategory (string)\n   *  - timingVar (string)\n   *  - timingValue (number)\n   * Properties can also have the optional fields:\n   *  - timingLabel (string)\n   *\n   * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/user-timings\n   */\n  userTimings(properties: UserTimings) {\n    if (\n      !properties ||\n      !properties.timingCategory ||\n      !properties.timingVar ||\n      !properties.timingValue\n    ) {\n      console.error(\n        'Properties timingCategory, timingVar, and timingValue are required to be set.',\n      );\n      return;\n    }\n\n    if (typeof ga !== 'undefined') {\n      ga('send', 'timing', properties);\n      for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n        ga(accountName + '.send', 'timing', properties);\n      }\n    }\n  }\n\n  setUsername(userId: string) {\n    this.angulartics2.settings.ga.userId = userId;\n    if (typeof ga === 'undefined') {\n      return;\n    }\n    ga('set', 'userId', userId);\n  }\n\n  setUserProperties(properties: any) {\n    this.setDimensionsAndMetrics(properties);\n  }\n\n  private setDimensionsAndMetrics(properties: any) {\n    if (typeof ga === 'undefined') {\n      return;\n    }\n    // clean previously used dimensions and metrics that will not be overriden\n    this.dimensionsAndMetrics.forEach(elem => {\n      if (!properties.hasOwnProperty(elem)) {\n        ga('set', elem, undefined);\n\n        this.angulartics2.settings.ga.additionalAccountNames.forEach((accountName: string) => {\n          ga(`${accountName}.set`, elem, undefined);\n        });\n      }\n    });\n    this.dimensionsAndMetrics = [];\n\n    // add custom dimensions and metrics\n    Object.keys(properties).forEach(key => {\n      if (key.lastIndexOf('dimension', 0) === 0 || key.lastIndexOf('metric', 0) === 0) {\n        ga('set', key, properties[key]);\n\n        this.angulartics2.settings.ga.additionalAccountNames.forEach((accountName: string) => {\n          ga(`${accountName}.set`, key, properties[key]);\n        });\n        this.dimensionsAndMetrics.push(key);\n      }\n    });\n  }\n}\n"]}

package/esm2020/providers/ga-enhanced-ecom/ga-enhanced-ecom-options.mjs

@@ -0,0 +1,7 @@
+/**
+ * Product and Promotion Actions
+ *
+ * Actions specify how to interpret product and promotion data that you send to Google Analytics.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/providers/ga-enhanced-ecom/ga-enhanced-ecom.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class Angulartics2GoogleAnalyticsEnhancedEcommerce {
+    /**
+     * Add impression in GA enhanced ecommerce tracking
+     * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/enhanced-ecommerce#measuring-activities
+     */
+    ecAddImpression(properties) {
+        ga('ec:addImpression', properties);
+    }
+    /**
+     * Add product in GA enhanced ecommerce tracking
+     * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/ecommerce
+     */
+    ecAddProduct(product) {
+        ga('ec:addProduct', product);
+    }
+    /**
+     * Set action in GA enhanced ecommerce tracking
+     * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/ecommerce
+     */
+    ecSetAction(action, properties) {
+        ga('ec:setAction', action, properties);
+    }
+}
+Angulartics2GoogleAnalyticsEnhancedEcommerce.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleAnalyticsEnhancedEcommerce, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2GoogleAnalyticsEnhancedEcommerce.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleAnalyticsEnhancedEcommerce, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleAnalyticsEnhancedEcommerce, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/providers/gosquared/gosquared.mjs

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class Angulartics2GoSquared {
+    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 {
+            _gs('track', path);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    eventTrack(action, properties) {
+        try {
+            _gs('event', action, properties);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    setUserProperties(properties) {
+        try {
+            _gs('identify', properties);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+}
+Angulartics2GoSquared.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoSquared, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2GoSquared.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoSquared, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoSquared, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/providers/gst/gst-interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3N0LWludGVyZmFjZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3Byb3ZpZGVycy9nc3QvZ3N0LWludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBAbGluayBodHRwczovL2RldmVsb3BlcnMuZ29vZ2xlLmNvbS9hbmFseXRpY3MvZGV2Z3VpZGVzL2NvbGxlY3Rpb24vZ3RhZ2pzL3VzZXItdGltaW5ncyAqL1xuZXhwb3J0IGludGVyZmFjZSBVc2VyVGltaW5nc0dzdCB7XG4gIC8qKiBBIHN0cmluZyB0byBpZGVudGlmeSB0aGUgdmFyaWFibGUgYmVpbmcgcmVjb3JkZWQgKGUuZy4gJ2xvYWQnKS4gKi9cbiAgbmFtZTogc3RyaW5nO1xuICAvKiogVGhlIG51bWJlciBvZiBtaWxsaXNlY29uZHMgaW4gZWxhcHNlZCB0aW1lIHRvIHJlcG9ydCB0byBHb29nbGUgQW5hbHl0aWNzIChlLmcuIDIwKS4gKi9cbiAgdmFsdWU6IG51bWJlcjtcbiAgLyoqIEEgc3RyaW5nIGZvciBjYXRlZ29yaXppbmcgYWxsIHVzZXIgdGltaW5nIHZhcmlhYmxlcyBpbnRvIGxvZ2ljYWwgZ3JvdXBzIChlLmcuICdKUyBEZXBlbmRlbmNpZXMnKS4gKi9cbiAgY2F0ZWdvcnk/OiBzdHJpbmc7XG4gIC8qKiBBIHN0cmluZyB0aGF0IGNhbiBiZSB1c2VkIHRvIGFkZCBmbGV4aWJpbGl0eSBpbiB2aXN1YWxpemluZyB1c2VyIHRpbWluZ3MgaW4gdGhlIHJlcG9ydHMgKGUuZy4gJ0dvb2dsZSBDRE4nKS4gKi9cbiAgbGFiZWw/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRXZlbnRHc3Qge1xuICBjYXRlZ29yeTogc3RyaW5nO1xuICBsYWJlbD86IHN0cmluZztcbiAgdmFsdWU/OiBudW1iZXIgfCBzdHJpbmc7XG4gIG5vbmludGVyYWN0aW9uPzogYm9vbGVhbjtcbiAgZ3N0Q3VzdG9tPzogYW55O1xufVxuIl19

package/esm2020/providers/gst/gst.mjs

@@ -0,0 +1,197 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class GoogleGlobalSiteTagDefaults {
+    constructor() {
+        this.trackingIds = [];
+        if (typeof ga !== 'undefined' && ga) {
+            // See: https://developers.google.com/analytics/devguides/collection/analyticsjs/ga-object-methods-reference
+            ga(() => {
+                ga.getAll().forEach((tracker) => {
+                    const id = tracker.get('trackingId');
+                    // If set both in forRoot and HTML page, we want to avoid duplicates
+                    if (id !== undefined && this.trackingIds.indexOf(id) === -1) {
+                        this.trackingIds.push(id);
+                    }
+                });
+            });
+        }
+    }
+}
+export class Angulartics2GoogleGlobalSiteTag {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+        this.dimensionsAndMetrics = {};
+        const defaults = new GoogleGlobalSiteTagDefaults();
+        // Set the default settings for this module
+        this.angulartics2.settings.gst = { ...defaults, ...this.angulartics2.settings.gst };
+    }
+    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));
+        this.angulartics2.userTimings
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.userTimings(this.convertTimings(x)));
+        this.angulartics2.setUsername
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe((x) => this.setUsername(x));
+        this.angulartics2.setUserProperties
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe((x) => this.setUserProperties(x));
+    }
+    /**
+     * Manually track page view, see:
+     *
+     * https://developers.google.com/analytics/devguides/collection/gtagjs/single-page-applications#tracking_virtual_pageviews
+     *
+     * @param path relative url
+     */
+    pageTrack(path) {
+        if (typeof gtag !== 'undefined' && gtag) {
+            const params = {
+                page_path: path,
+                page_location: window.location.protocol + '//' + window.location.host + path,
+                ...this.dimensionsAndMetrics,
+            };
+            // Custom map must be reset with all config to stay valid.
+            if (this.angulartics2.settings.gst.customMap) {
+                params.custom_map = this.angulartics2.settings.gst.customMap;
+            }
+            if (this.angulartics2.settings.gst.userId) {
+                params.user_id = this.angulartics2.settings.gst.userId;
+            }
+            if (this.angulartics2.settings.gst.anonymizeIp) {
+                params.anonymize_ip = this.angulartics2.settings.gst.anonymizeIp;
+            }
+            for (const id of this.angulartics2.settings.gst.trackingIds) {
+                gtag('config', id, params);
+            }
+        }
+    }
+    /**
+     * Send interactions to gtag, i.e. for event tracking in Google Analytics. See:
+     *
+     * https://developers.google.com/analytics/devguides/collection/gtagjs/events
+     *
+     * @param action associated with the event
+     */
+    eventTrack(action, properties = {}) {
+        this.eventTrackInternal(action, {
+            event_category: properties.category || 'interaction',
+            event_label: properties.label,
+            value: properties.value,
+            non_interaction: properties.noninteraction,
+            ...properties.gstCustom,
+        });
+    }
+    /**
+     * Exception Track Event in GST. See:
+     *
+     * https://developers.google.com/analytics/devguides/collection/gtagjs/exceptions
+     *
+     */
+    exceptionTrack(properties) {
+        // TODO: make interface
+        //  @param {Object} properties
+        //  @param {string} [properties.description]
+        //  @param {boolean} [properties.fatal]
+        if (properties.fatal === undefined) {
+            console.log('No "fatal" provided, sending with fatal=true');
+            properties.fatal = true;
+        }
+        properties.exDescription = properties.event ? properties.event.stack : properties.description;
+        this.eventTrack('exception', {
+            gstCustom: {
+                description: properties.exDescription,
+                fatal: properties.fatal,
+                ...properties.gstCustom,
+            },
+        });
+    }
+    /**
+     * User Timings Event in GST.
+     *
+     * @param properties Comprised of the mandatory fields:
+     *  - name (string)
+     *  - value (number - integer)
+     * Properties can also have the optional fields:
+     *  - category (string)
+     *  - label (string)
+     *
+     * @link https://developers.google.com/analytics/devguides/collection/gtagjs/user-timings
+     */
+    userTimings(properties) {
+        if (!properties) {
+            console.error('User timings - "properties" parameter is required to be set.');
+            return;
+        }
+        this.eventTrackInternal('timing_complete', {
+            name: properties.name,
+            value: properties.value,
+            event_category: properties.category,
+            event_label: properties.label,
+        });
+    }
+    convertTimings(properties) {
+        return {
+            name: properties.timingVar,
+            value: properties.timingValue,
+            category: properties.timingCategory,
+            label: properties.timingLabel,
+        };
+    }
+    setUsername(userId) {
+        this.angulartics2.settings.gst.userId = userId;
+        if (typeof gtag !== 'undefined' && gtag) {
+            gtag('set', { user_id: typeof userId === 'string' || !userId ? userId : userId.userId });
+        }
+    }
+    setUserProperties(properties) {
+        this.setDimensionsAndMetrics(properties);
+    }
+    setDimensionsAndMetrics(properties) {
+        // We want the dimensions and metrics to accumulate, so we merge with previous value
+        this.dimensionsAndMetrics = {
+            ...this.dimensionsAndMetrics,
+            ...properties,
+        };
+        // Remove properties that are null or undefined
+        Object.keys(this.dimensionsAndMetrics).forEach(key => {
+            const val = this.dimensionsAndMetrics[key];
+            if (val === undefined || val === null) {
+                delete this.dimensionsAndMetrics[key];
+            }
+        });
+        if (typeof gtag !== 'undefined' && gtag) {
+            gtag('set', this.dimensionsAndMetrics);
+        }
+    }
+    eventTrackInternal(action, properties = {}) {
+        this.cleanProperties(properties);
+        if (typeof gtag !== 'undefined' && gtag) {
+            gtag('event', action, properties);
+        }
+    }
+    cleanProperties(properties) {
+        // GA requires that eventValue be an non-negative integer, see:
+        // https://developers.google.com/analytics/devguides/collection/gtagjs/events
+        if (properties.value) {
+            const parsed = parseInt(properties.value, 10);
+            properties.value = isNaN(parsed) ? 0 : parsed;
+        }
+    }
+}
+Angulartics2GoogleGlobalSiteTag.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleGlobalSiteTag, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2GoogleGlobalSiteTag.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleGlobalSiteTag, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleGlobalSiteTag, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gst.js","sourceRoot":"","sources":["../../../../src/lib/providers/gst/gst.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { UserTimings } from '../../angulartics2-interfaces';\nimport { GoogleGlobalSiteTagSettings } from '../../angulartics2-config';\nimport { Angulartics2 } from '../../angulartics2-core';\nimport { EventGst, UserTimingsGst } from './gst-interfaces';\n\ndeclare var gtag: any;\ndeclare var ga: any;\n\nexport class GoogleGlobalSiteTagDefaults implements GoogleGlobalSiteTagSettings {\n  trackingIds: string[] = [];\n\n  constructor() {\n    if (typeof ga !== 'undefined' && ga) {\n      // See: https://developers.google.com/analytics/devguides/collection/analyticsjs/ga-object-methods-reference\n      ga(() => {\n        ga.getAll().forEach((tracker: any) => {\n          const id = tracker.get('trackingId');\n          // If set both in forRoot and HTML page, we want to avoid duplicates\n          if (id !== undefined && this.trackingIds.indexOf(id) === -1) {\n            this.trackingIds.push(id);\n          }\n        });\n      });\n    }\n  }\n}\n\n@Injectable({ providedIn: 'root' })\nexport class Angulartics2GoogleGlobalSiteTag {\n  private dimensionsAndMetrics: { [key: string]: any } = {};\n\n  constructor(protected angulartics2: Angulartics2) {\n    const defaults = new GoogleGlobalSiteTagDefaults();\n    // Set the default settings for this module\n    this.angulartics2.settings.gst = { ...defaults, ...this.angulartics2.settings.gst };\n  }\n\n  startTracking(): void {\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    this.angulartics2.userTimings\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe(x => this.userTimings(this.convertTimings(x)));\n    this.angulartics2.setUsername\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe((x: string) => this.setUsername(x));\n    this.angulartics2.setUserProperties\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe((x: any) => this.setUserProperties(x));\n  }\n\n  /**\n   * Manually track page view, see:\n   *\n   * https://developers.google.com/analytics/devguides/collection/gtagjs/single-page-applications#tracking_virtual_pageviews\n   *\n   * @param path relative url\n   */\n  pageTrack(path: string) {\n    if (typeof gtag !== 'undefined' && gtag) {\n      const params: any = {\n        page_path: path,\n        page_location: window.location.protocol + '//' + window.location.host + path,\n        ...this.dimensionsAndMetrics,\n      };\n\n      // Custom map must be reset with all config to stay valid.\n\n      if (this.angulartics2.settings.gst.customMap) {\n        params.custom_map = this.angulartics2.settings.gst.customMap;\n      }\n      if (this.angulartics2.settings.gst.userId) {\n        params.user_id = this.angulartics2.settings.gst.userId;\n      }\n      if (this.angulartics2.settings.gst.anonymizeIp) {\n        params.anonymize_ip = this.angulartics2.settings.gst.anonymizeIp;\n      }\n\n      for (const id of this.angulartics2.settings.gst.trackingIds) {\n        gtag('config', id, params);\n      }\n    }\n  }\n\n  /**\n   * Send interactions to gtag, i.e. for event tracking in Google Analytics. See:\n   *\n   * https://developers.google.com/analytics/devguides/collection/gtagjs/events\n   *\n   * @param action associated with the event\n   */\n  eventTrack(action: string, properties: Partial<EventGst> = {}) {\n    this.eventTrackInternal(action, {\n      event_category: properties.category || 'interaction',\n      event_label: properties.label,\n      value: properties.value,\n      non_interaction: properties.noninteraction,\n      ...properties.gstCustom,\n    });\n  }\n\n  /**\n   * Exception Track Event in GST. See:\n   *\n   * https://developers.google.com/analytics/devguides/collection/gtagjs/exceptions\n   *\n   */\n  exceptionTrack(properties: any) {\n    // TODO: make interface\n    //  @param {Object} properties\n    //  @param {string} [properties.description]\n    //  @param {boolean} [properties.fatal]\n    if (properties.fatal === undefined) {\n      console.log('No \"fatal\" provided, sending with fatal=true');\n      properties.fatal = true;\n    }\n\n    properties.exDescription = properties.event ? properties.event.stack : properties.description;\n\n    this.eventTrack('exception', {\n      gstCustom: {\n        description: properties.exDescription,\n        fatal: properties.fatal,\n        ...properties.gstCustom,\n      },\n    });\n  }\n\n  /**\n   * User Timings Event in GST.\n   *\n   * @param properties Comprised of the mandatory fields:\n   *  - name (string)\n   *  - value (number - integer)\n   * Properties can also have the optional fields:\n   *  - category (string)\n   *  - label (string)\n   *\n   * @link https://developers.google.com/analytics/devguides/collection/gtagjs/user-timings\n   */\n  userTimings(properties: UserTimingsGst) {\n    if (!properties) {\n      console.error('User timings - \"properties\" parameter is required to be set.');\n      return;\n    }\n\n    this.eventTrackInternal('timing_complete', {\n      name: properties.name,\n      value: properties.value,\n      event_category: properties.category,\n      event_label: properties.label,\n    });\n  }\n\n  private convertTimings(properties: UserTimings): UserTimingsGst {\n    return {\n      name: properties.timingVar,\n      value: properties.timingValue,\n      category: properties.timingCategory,\n      label: properties.timingLabel,\n    };\n  }\n\n  setUsername(userId: string | { userId: string | number }) {\n    this.angulartics2.settings.gst.userId = userId;\n    if (typeof gtag !== 'undefined' && gtag) {\n      gtag('set', { user_id: typeof userId === 'string' || !userId ? userId : userId.userId });\n    }\n  }\n\n  setUserProperties(properties: any) {\n    this.setDimensionsAndMetrics(properties);\n  }\n\n  private setDimensionsAndMetrics(properties: { [key: string]: any }) {\n    // We want the dimensions and metrics to accumulate, so we merge with previous value\n    this.dimensionsAndMetrics = {\n      ...this.dimensionsAndMetrics,\n      ...properties,\n    };\n\n    // Remove properties that are null or undefined\n    Object.keys(this.dimensionsAndMetrics).forEach(key => {\n      const val = this.dimensionsAndMetrics[key];\n      if (val === undefined || val === null) {\n        delete this.dimensionsAndMetrics[key];\n      }\n    });\n\n    if (typeof gtag !== 'undefined' && gtag) {\n      gtag('set', this.dimensionsAndMetrics);\n    }\n  }\n\n  private eventTrackInternal(action: string, properties: any = {}) {\n    this.cleanProperties(properties);\n    if (typeof gtag !== 'undefined' && gtag) {\n      gtag('event', action, properties);\n    }\n  }\n\n  private cleanProperties(properties: { [key: string]: any }): void {\n    // GA requires that eventValue be an non-negative integer, see:\n    // https://developers.google.com/analytics/devguides/collection/gtagjs/events\n    if (properties.value) {\n      const parsed = parseInt(properties.value, 10);\n      properties.value = isNaN(parsed) ? 0 : parsed;\n    }\n  }\n}\n"]}