angulartics2 10.1.0 → 12.1.0

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ29zcXVhcmVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9wcm92aWRlcnMvZ29zcXVhcmVkL2dvc3F1YXJlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFPM0MsTUFBTSxPQUFPLHFCQUFxQjtJQUNoQyxZQUFvQixZQUEwQjtRQUExQixpQkFBWSxHQUFaLFlBQVksQ0FBYztRQUM1QyxJQUFJLENBQUMsWUFBWSxDQUFDLGlCQUFpQixDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzlFLElBQUksQ0FBQyxZQUFZLENBQUMscUJBQXFCLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDcEYsQ0FBQztJQUVELGFBQWE7UUFDWCxJQUFJLENBQUMsWUFBWSxDQUFDLFNBQVM7YUFDeEIsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsbUJBQW1CLEVBQUUsQ0FBQzthQUM3QyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1FBQzFDLElBQUksQ0FBQyxZQUFZLENBQUMsVUFBVTthQUN6QixJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxtQkFBbUIsRUFBRSxDQUFDO2FBQzdDLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQztJQUM3RCxDQUFDO0lBRUQsU0FBUyxDQUFDLElBQVk7UUFDcEIsSUFBSTtZQUNGLEdBQUcsQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUM7U0FDcEI7UUFBQyxPQUFPLENBQUMsRUFBRTtZQUNWLElBQUksQ0FBQyxDQUFDLENBQUMsWUFBWSxjQUFjLENBQUMsRUFBRTtnQkFDbEMsTUFBTSxDQUFDLENBQUM7YUFDVDtTQUNGO0lBQ0gsQ0FBQztJQUVELFVBQVUsQ0FBQyxNQUFjLEVBQUUsVUFBZTtRQUN4QyxJQUFJO1lBQ0YsR0FBRyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxDQUFDLENBQUM7U0FDbEM7UUFBQyxPQUFPLENBQUMsRUFBRTtZQUNWLElBQUksQ0FBQyxDQUFDLENBQUMsWUFBWSxjQUFjLENBQUMsRUFBRTtnQkFDbEMsTUFBTSxDQUFDLENBQUM7YUFDVDtTQUNGO0lBQ0gsQ0FBQztJQUVELGlCQUFpQixDQUFDLFVBQWU7UUFDL0IsSUFBSTtZQUNGLEdBQUcsQ0FBQyxVQUFVLEVBQUUsVUFBVSxDQUFDLENBQUM7U0FDN0I7UUFBQyxPQUFPLENBQUMsRUFBRTtZQUNWLElBQUksQ0FBQyxDQUFDLENBQUMsWUFBWSxjQUFjLENBQUMsRUFBRTtnQkFDbEMsTUFBTSxDQUFDLENBQUM7YUFDVDtTQUNGO0lBQ0gsQ0FBQzs7a0hBM0NVLHFCQUFxQjtzSEFBckIscUJBQXFCLGNBRFIsTUFBTTsyRkFDbkIscUJBQXFCO2tCQURqQyxVQUFVO21CQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgQW5ndWxhcnRpY3MyIH0gZnJvbSAnLi4vLi4vYW5ndWxhcnRpY3MyLWNvcmUnO1xuXG5kZWNsYXJlIHZhciBfZ3M6IGFueTtcblxuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcbmV4cG9ydCBjbGFzcyBBbmd1bGFydGljczJHb1NxdWFyZWQge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGFuZ3VsYXJ0aWNzMjogQW5ndWxhcnRpY3MyKSB7XG4gICAgdGhpcy5hbmd1bGFydGljczIuc2V0VXNlclByb3BlcnRpZXMuc3Vic2NyaWJlKHggPT4gdGhpcy5zZXRVc2VyUHJvcGVydGllcyh4KSk7XG4gICAgdGhpcy5hbmd1bGFydGljczIuc2V0VXNlclByb3BlcnRpZXNPbmNlLnN1YnNjcmliZSh4ID0+IHRoaXMuc2V0VXNlclByb3BlcnRpZXMoeCkpO1xuICB9XG5cbiAgc3RhcnRUcmFja2luZygpOiB2b2lkIHtcbiAgICB0aGlzLmFuZ3VsYXJ0aWNzMi5wYWdlVHJhY2tcbiAgICAgIC5waXBlKHRoaXMuYW5ndWxhcnRpY3MyLmZpbHRlckRldmVsb3Blck1vZGUoKSlcbiAgICAgIC5zdWJzY3JpYmUoeCA9PiB0aGlzLnBhZ2VUcmFjayh4LnBhdGgpKTtcbiAgICB0aGlzLmFuZ3VsYXJ0aWNzMi5ldmVudFRyYWNrXG4gICAgICAucGlwZSh0aGlzLmFuZ3VsYXJ0aWNzMi5maWx0ZXJEZXZlbG9wZXJNb2RlKCkpXG4gICAgICAuc3Vic2NyaWJlKHggPT4gdGhpcy5ldmVudFRyYWNrKHguYWN0aW9uLCB4LnByb3BlcnRpZXMpKTtcbiAgfVxuXG4gIHBhZ2VUcmFjayhwYXRoOiBzdHJpbmcpIHtcbiAgICB0cnkge1xuICAgICAgX2dzKCd0cmFjaycsIHBhdGgpO1xuICAgIH0gY2F0Y2ggKGUpIHtcbiAgICAgIGlmICghKGUgaW5zdGFuY2VvZiBSZWZlcmVuY2VFcnJvcikpIHtcbiAgICAgICAgdGhyb3cgZTtcbiAgICAgIH1cbiAgICB9XG4gIH1cblxuICBldmVudFRyYWNrKGFjdGlvbjogc3RyaW5nLCBwcm9wZXJ0aWVzOiBhbnkpIHtcbiAgICB0cnkge1xuICAgICAgX2dzKCdldmVudCcsIGFjdGlvbiwgcHJvcGVydGllcyk7XG4gICAgfSBjYXRjaCAoZSkge1xuICAgICAgaWYgKCEoZSBpbnN0YW5jZW9mIFJlZmVyZW5jZUVycm9yKSkge1xuICAgICAgICB0aHJvdyBlO1xuICAgICAgfVxuICAgIH1cbiAgfVxuXG4gIHNldFVzZXJQcm9wZXJ0aWVzKHByb3BlcnRpZXM6IGFueSkge1xuICAgIHRyeSB7XG4gICAgICBfZ3MoJ2lkZW50aWZ5JywgcHJvcGVydGllcyk7XG4gICAgfSBjYXRjaCAoZSkge1xuICAgICAgaWYgKCEoZSBpbnN0YW5jZW9mIFJlZmVyZW5jZUVycm9yKSkge1xuICAgICAgICB0aHJvdyBlO1xuICAgICAgfVxuICAgIH1cbiAgfVxufVxuIl19

package/{gst/esm2015/gst-interfaces.js → esm2020/providers/gst/gst-interfaces.mjs}

@@ -1 +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":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;AAU3C,MAAM,OAAO,2BAA2B;IAGtC;QAFA,gBAAW,GAAa,EAAE,CAAC;QAGzB,IAAI,OAAO,EAAE,KAAK,WAAW,IAAI,EAAE,EAAE;YACnC,4GAA4G;YAC5G,EAAE,CAAC,GAAG,EAAE;gBACN,EAAE,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,CAAC,OAAY,EAAE,EAAE;oBACnC,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;oBACrC,oEAAoE;oBACpE,IAAI,EAAE,KAAK,SAAS,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE;wBAC3D,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;qBAC3B;gBACH,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;CACF;AAGD,MAAM,OAAO,+BAA+B;IAG1C,YAAsB,YAA0B;QAA1B,iBAAY,GAAZ,YAAY,CAAc;QAFxC,yBAAoB,GAA2B,EAAE,CAAC;QAGxD,MAAM,QAAQ,GAAG,IAAI,2BAA2B,EAAE,CAAC;QACnD,2CAA2C;QAC3C,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,GAAG,EAAE,GAAG,QAAQ,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;IACtF,CAAC;IAED,aAAa;QACX,IAAI,CAAC,YAAY,CAAC,SAAS;aACxB,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,CAAC;aAC7C,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAC1C,IAAI,CAAC,YAAY,CAAC,UAAU;aACzB,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,CAAC;aAC7C,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;QAC3D,IAAI,CAAC,YAAY,CAAC,cAAc;aAC7B,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,CAAC;aAC7C,SAAS,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QACjD,IAAI,CAAC,YAAY,CAAC,WAAW;aAC1B,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,CAAC;aAC7C,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5D,IAAI,CAAC,YAAY,CAAC,WAAW;aAC1B,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,CAAC;aAC7C,SAAS,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QACjD,IAAI,CAAC,YAAY,CAAC,iBAAiB;aAChC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,CAAC;aAC7C,SAAS,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;IACtD,CAAC;IAED;;;;;;OAMG;IACH,SAAS,CAAC,IAAY;QACpB,IAAI,OAAO,IAAI,KAAK,WAAW,IAAI,IAAI,EAAE;YACvC,MAAM,MAAM,GAAQ;gBAClB,SAAS,EAAE,IAAI;gBACf,aAAa,EAAE,MAAM,CAAC,QAAQ,CAAC,QAAQ,GAAG,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,IAAI;gBAC5E,GAAG,IAAI,CAAC,oBAAoB;aAC7B,CAAC;YAEF,0DAA0D;YAE1D,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE;gBAC5C,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC;aAC9D;YACD,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE;gBACzC,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC;aACxD;YACD,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE;gBAC9C,MAAM,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC;aAClE;YAED,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE;gBAC3D,IAAI,CAAC,QAAQ,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;aAC5B;SACF;IACH,CAAC;IAED;;;;;;OAMG;IACH,UAAU,CAAC,MAAc,EAAE,aAAgC,EAAE;QAC3D,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE;YAC9B,cAAc,EAAE,UAAU,CAAC,QAAQ,IAAI,aAAa;YACpD,WAAW,EAAE,UAAU,CAAC,KAAK;YAC7B,KAAK,EAAE,UAAU,CAAC,KAAK;YACvB,eAAe,EAAE,UAAU,CAAC,cAAc;YAC1C,GAAG,UAAU,CAAC,SAAS;SACxB,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,UAAe;QAC5B,uBAAuB;QACvB,8BAA8B;QAC9B,4CAA4C;QAC5C,uCAAuC;QACvC,IAAI,UAAU,CAAC,KAAK,KAAK,SAAS,EAAE;YAClC,OAAO,CAAC,GAAG,CAAC,8CAA8C,CAAC,CAAC;YAC5D,UAAU,CAAC,KAAK,GAAG,IAAI,CAAC;SACzB;QAED,UAAU,CAAC,aAAa,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC;QAE9F,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE;YAC3B,SAAS,EAAE;gBACT,WAAW,EAAE,UAAU,CAAC,aAAa;gBACrC,KAAK,EAAE,UAAU,CAAC,KAAK;gBACvB,GAAG,UAAU,CAAC,SAAS;aACxB;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,UAA0B;QACpC,IAAI,CAAC,UAAU,EAAE;YACf,OAAO,CAAC,KAAK,CAAC,8DAA8D,CAAC,CAAC;YAC9E,OAAO;SACR;QAED,IAAI,CAAC,kBAAkB,CAAC,iBAAiB,EAAE;YACzC,IAAI,EAAE,UAAU,CAAC,IAAI;YACrB,KAAK,EAAE,UAAU,CAAC,KAAK;YACvB,cAAc,EAAE,UAAU,CAAC,QAAQ;YACnC,WAAW,EAAE,UAAU,CAAC,KAAK;SAC9B,CAAC,CAAC;IACL,CAAC;IAEO,cAAc,CAAC,UAAuB;QAC5C,OAAO;YACL,IAAI,EAAE,UAAU,CAAC,SAAS;YAC1B,KAAK,EAAE,UAAU,CAAC,WAAW;YAC7B,QAAQ,EAAE,UAAU,CAAC,cAAc;YACnC,KAAK,EAAE,UAAU,CAAC,WAAW;SAC9B,CAAC;IACJ,CAAC;IAED,WAAW,CAAC,MAA4C;QACtD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC;QAC/C,IAAI,OAAO,IAAI,KAAK,WAAW,IAAI,IAAI,EAAE;YACvC,IAAI,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,OAAO,MAAM,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;SAC1F;IACH,CAAC;IAED,iBAAiB,CAAC,UAAe;QAC/B,IAAI,CAAC,uBAAuB,CAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;IAEO,uBAAuB,CAAC,UAAkC;QAChE,oFAAoF;QACpF,IAAI,CAAC,oBAAoB,GAAG;YAC1B,GAAG,IAAI,CAAC,oBAAoB;YAC5B,GAAG,UAAU;SACd,CAAC;QAEF,+CAA+C;QAC/C,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACnD,MAAM,GAAG,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;YAC3C,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,EAAE;gBACrC,OAAO,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;aACvC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,OAAO,IAAI,KAAK,WAAW,IAAI,IAAI,EAAE;YACvC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;SACxC;IACH,CAAC;IAEO,kBAAkB,CAAC,MAAc,EAAE,aAAkB,EAAE;QAC7D,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QACjC,IAAI,OAAO,IAAI,KAAK,WAAW,IAAI,IAAI,EAAE;YACvC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;SACnC;IACH,CAAC;IAEO,eAAe,CAAC,UAAkC;QACxD,+DAA+D;QAC/D,6EAA6E;QAC7E,IAAI,UAAU,CAAC,KAAK,EAAE;YACpB,MAAM,MAAM,GAAG,QAAQ,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YAC9C,UAAU,CAAC,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;SAC/C;IACH,CAAC;;4HA3LU,+BAA+B;gIAA/B,+BAA+B,cADlB,MAAM;2FACnB,+BAA+B;kBAD3C,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","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"]}

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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