angulartics2 11.0.0 → 12.0.0

package/angular-router.d.ts

@@ -2,6 +2,7 @@ import { Location } from '@angular/common';
 import { Router } from '@angular/router';
 import { Observable } from 'rxjs';
 import { RouterlessTracking, TrackNavigationEnd } from './routerless';
+import * as i0 from "@angular/core";
 /**
  * Track Route changes for applications using Angular's
  * default router
@@ -14,4 +15,6 @@ export declare class AngularRouterTracking implements RouterlessTracking {
     constructor(router: Router, location: Location);
     trackLocation(settings: any): Observable<TrackNavigationEnd>;
     prepareExternalUrl(url: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularRouterTracking, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AngularRouterTracking>;
 }

package/angulartics2-core.d.ts

@@ -3,6 +3,7 @@ import { Angulartics2Settings } from './angulartics2-config';
 import { EventTrack, PageTrack, UserTimings } from './angulartics2-interfaces';
 import { Angulartics2Token } from './angulartics2-token';
 import { RouterlessTracking } from './routerless';
+import * as i0 from "@angular/core";
 export declare class Angulartics2 {
     private tracker;
     settings: Angulartics2Settings;
@@ -36,4 +37,6 @@ export declare class Angulartics2 {
      * @param url current page path
      */
     protected clearUrl(url: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Angulartics2, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Angulartics2>;
 }

package/angulartics2.d.ts

@@ -1,4 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="angulartics2" />
 export * from './public_api';

package/angulartics2.module.d.ts

@@ -1,5 +1,10 @@
 import { ModuleWithProviders } from '@angular/core';
 import { Angulartics2Settings } from './angulartics2-config';
+import * as i0 from "@angular/core";
+import * as i1 from "./angulartics2On";
 export declare class Angulartics2Module {
     static forRoot(settings?: Partial<Angulartics2Settings>): ModuleWithProviders<Angulartics2Module>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Angulartics2Module, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<Angulartics2Module, never, [typeof i1.Angulartics2OnModule], [typeof i1.Angulartics2On]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<Angulartics2Module>;
 }

package/angulartics2On.d.ts

@@ -1,5 +1,6 @@
 import { AfterContentInit, ElementRef, Renderer2 } from '@angular/core';
 import { Angulartics2 } from './angulartics2-core';
+import * as i0 from "@angular/core";
 export declare class Angulartics2On implements AfterContentInit {
     private elRef;
     private angulartics2;
@@ -13,6 +14,11 @@ export declare class Angulartics2On implements AfterContentInit {
     constructor(elRef: ElementRef, angulartics2: Angulartics2, renderer: Renderer2);
     ngAfterContentInit(): void;
     eventTrack(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Angulartics2On, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Angulartics2On, "[angulartics2On]", never, { "angulartics2On": "angulartics2On"; "angularticsAction": "angularticsAction"; "angularticsCategory": "angularticsCategory"; "angularticsLabel": "angularticsLabel"; "angularticsValue": "angularticsValue"; "angularticsProperties": "angularticsProperties"; }, {}, never>;
 }
 export declare class Angulartics2OnModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Angulartics2OnModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<Angulartics2OnModule, [typeof Angulartics2On], never, [typeof Angulartics2On]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<Angulartics2OnModule>;
 }

package/esm2020/angular-router.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import { delay, filter, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common";
+/**
+ * Track Route changes for applications using Angular's
+ * default router
+ *
+ * @link https://angular.io/api/router/Router
+ */
+export class AngularRouterTracking {
+    constructor(router, location) {
+        this.router = router;
+        this.location = location;
+    }
+    trackLocation(settings) {
+        return this.router.events.pipe(filter(e => e instanceof NavigationEnd), filter(() => !settings.developerMode), map((e) => {
+            return { url: e.urlAfterRedirects };
+        }), delay(0));
+    }
+    prepareExternalUrl(url) {
+        return this.location.prepareExternalUrl(url);
+    }
+}
+AngularRouterTracking.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AngularRouterTracking, deps: [{ token: i1.Router }, { token: i2.Location }], target: i0.ɵɵFactoryTarget.Injectable });
+AngularRouterTracking.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AngularRouterTracking, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AngularRouterTracking, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.Location }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/angulartics2-core.mjs

@@ -0,0 +1,93 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { DefaultConfig } from './angulartics2-config';
+import { ANGULARTICS2_TOKEN } from './angulartics2-token';
+import * as i0 from "@angular/core";
+import * as i1 from "./routerless";
+export class Angulartics2 {
+    constructor(tracker, setup) {
+        this.tracker = tracker;
+        this.pageTrack = new ReplaySubject(10);
+        this.eventTrack = new ReplaySubject(10);
+        this.exceptionTrack = new ReplaySubject(10);
+        this.setAlias = new ReplaySubject(10);
+        this.setUsername = new ReplaySubject(10);
+        this.setUserProperties = new ReplaySubject(10);
+        this.setUserPropertiesOnce = new ReplaySubject(10);
+        this.setSuperProperties = new ReplaySubject(10);
+        this.setSuperPropertiesOnce = new ReplaySubject(10);
+        this.userTimings = new ReplaySubject(10);
+        const defaultConfig = new DefaultConfig();
+        this.settings = { ...defaultConfig, ...setup.settings };
+        this.settings.pageTracking = {
+            ...defaultConfig.pageTracking,
+            ...setup.settings.pageTracking,
+        };
+        this.tracker
+            .trackLocation(this.settings)
+            .subscribe((event) => this.trackUrlChange(event.url));
+    }
+    /** filters all events when developer mode is true */
+    filterDeveloperMode() {
+        return filter((value, index) => !this.settings.developerMode);
+    }
+    trackUrlChange(url) {
+        if (this.settings.pageTracking.autoTrackVirtualPages && !this.matchesExcludedRoute(url)) {
+            const clearedUrl = this.clearUrl(url);
+            let path;
+            if (this.settings.pageTracking.basePath.length) {
+                path = this.settings.pageTracking.basePath + clearedUrl;
+            }
+            else {
+                path = this.tracker.prepareExternalUrl(clearedUrl);
+            }
+            this.pageTrack.next({ path });
+        }
+    }
+    /**
+     * Use string literals or regular expressions to exclude routes
+     * from automatic pageview tracking.
+     *
+     * @param url location
+     */
+    matchesExcludedRoute(url) {
+        for (const excludedRoute of this.settings.pageTracking.excludedRoutes) {
+            const matchesRegex = excludedRoute instanceof RegExp && excludedRoute.test(url);
+            if (matchesRegex || url.indexOf(excludedRoute) !== -1) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Removes id's from tracked route.
+     *  EX: `/project/12981/feature` becomes `/project/feature`
+     *
+     * @param url current page path
+     */
+    clearUrl(url) {
+        if (this.settings.pageTracking.clearIds ||
+            this.settings.pageTracking.clearQueryParams ||
+            this.settings.pageTracking.clearHash) {
+            return url
+                .split('/')
+                .map(part => (this.settings.pageTracking.clearQueryParams ? part.split('?')[0] : part))
+                .map(part => (this.settings.pageTracking.clearHash ? part.split('#')[0] : part))
+                .filter(part => !this.settings.pageTracking.clearIds ||
+                !part.match(this.settings.pageTracking.idsRegExp))
+                .join('/');
+        }
+        return url;
+    }
+}
+Angulartics2.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2, deps: [{ token: i1.RouterlessTracking }, { token: ANGULARTICS2_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.RouterlessTracking }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ANGULARTICS2_TOKEN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angulartics2-core.js","sourceRoot":"","sources":["../../src/lib/angulartics2-core.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\n\nimport { MonoTypeOperatorFunction, ReplaySubject } from 'rxjs';\nimport { filter } from 'rxjs/operators';\n\nimport { Angulartics2Settings, DefaultConfig } from './angulartics2-config';\nimport { EventTrack, PageTrack, UserTimings } from './angulartics2-interfaces';\nimport { Angulartics2Token, ANGULARTICS2_TOKEN } from './angulartics2-token';\nimport { RouterlessTracking, TrackNavigationEnd } from './routerless';\n\n@Injectable({ providedIn: 'root' })\nexport class Angulartics2 {\n  settings: Angulartics2Settings;\n\n  pageTrack = new ReplaySubject<Partial<PageTrack>>(10);\n  eventTrack = new ReplaySubject<Partial<EventTrack>>(10);\n  exceptionTrack = new ReplaySubject<any>(10);\n  setAlias = new ReplaySubject<string>(10);\n  setUsername = new ReplaySubject<{ userId: string | number } | string>(10);\n  setUserProperties = new ReplaySubject<any>(10);\n  setUserPropertiesOnce = new ReplaySubject<any>(10);\n  setSuperProperties = new ReplaySubject<any>(10);\n  setSuperPropertiesOnce = new ReplaySubject<any>(10);\n  userTimings = new ReplaySubject<UserTimings>(10);\n\n  constructor(\n    private tracker: RouterlessTracking,\n    @Inject(ANGULARTICS2_TOKEN) setup: Angulartics2Token,\n  ) {\n    const defaultConfig = new DefaultConfig();\n    this.settings = { ...defaultConfig, ...setup.settings };\n    this.settings.pageTracking = {\n      ...defaultConfig.pageTracking,\n      ...setup.settings.pageTracking,\n    };\n    this.tracker\n      .trackLocation(this.settings)\n      .subscribe((event: TrackNavigationEnd) => this.trackUrlChange(event.url));\n  }\n\n  /** filters all events when developer mode is true */\n  filterDeveloperMode<T>(): MonoTypeOperatorFunction<T> {\n    return filter((value, index) => !this.settings.developerMode);\n  }\n\n  protected trackUrlChange(url: string) {\n    if (this.settings.pageTracking.autoTrackVirtualPages && !this.matchesExcludedRoute(url)) {\n      const clearedUrl = this.clearUrl(url);\n      let path: string;\n      if (this.settings.pageTracking.basePath.length) {\n        path = this.settings.pageTracking.basePath + clearedUrl;\n      } else {\n        path = this.tracker.prepareExternalUrl(clearedUrl);\n      }\n      this.pageTrack.next({ path });\n    }\n  }\n\n  /**\n   * Use string literals or regular expressions to exclude routes\n   * from automatic pageview tracking.\n   *\n   * @param url location\n   */\n  protected matchesExcludedRoute(url: string): boolean {\n    for (const excludedRoute of this.settings.pageTracking.excludedRoutes) {\n      const matchesRegex = excludedRoute instanceof RegExp && excludedRoute.test(url);\n      if (matchesRegex || url.indexOf(excludedRoute as string) !== -1) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Removes id's from tracked route.\n   *  EX: `/project/12981/feature` becomes `/project/feature`\n   *\n   * @param url current page path\n   */\n  protected clearUrl(url: string): string {\n    if (\n      this.settings.pageTracking.clearIds ||\n      this.settings.pageTracking.clearQueryParams ||\n      this.settings.pageTracking.clearHash\n    ) {\n      return url\n        .split('/')\n        .map(part => (this.settings.pageTracking.clearQueryParams ? part.split('?')[0] : part))\n        .map(part => (this.settings.pageTracking.clearHash ? part.split('#')[0] : part))\n        .filter(\n          part =>\n            !this.settings.pageTracking.clearIds ||\n            !part.match(this.settings.pageTracking.idsRegExp),\n        )\n        .join('/');\n    }\n    return url;\n  }\n}\n"]}

package/esm2020/angulartics2.module.mjs

@@ -0,0 +1,30 @@
+import { NgModule } from '@angular/core';
+import { AngularRouterTracking } from './angular-router';
+import { Angulartics2 } from './angulartics2-core';
+import { ANGULARTICS2_TOKEN } from './angulartics2-token';
+import { Angulartics2On, Angulartics2OnModule } from './angulartics2On';
+import { RouterlessTracking } from './routerless';
+import * as i0 from "@angular/core";
+export class Angulartics2Module {
+    static forRoot(settings = {}) {
+        return {
+            ngModule: Angulartics2Module,
+            providers: [
+                { provide: ANGULARTICS2_TOKEN, useValue: { settings } },
+                { provide: RouterlessTracking, useClass: AngularRouterTracking },
+                Angulartics2,
+            ],
+        };
+    }
+}
+Angulartics2Module.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Module, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+Angulartics2Module.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Module, imports: [Angulartics2OnModule], exports: [Angulartics2On] });
+Angulartics2Module.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Module, imports: [[Angulartics2OnModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Module, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [Angulartics2OnModule],
+                    exports: [Angulartics2On],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/angulartics2On.mjs

@@ -0,0 +1,66 @@
+import { Directive, Input, NgModule } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./angulartics2-core";
+export class Angulartics2On {
+    constructor(elRef, angulartics2, renderer) {
+        this.elRef = elRef;
+        this.angulartics2 = angulartics2;
+        this.renderer = renderer;
+        this.angularticsProperties = {};
+    }
+    ngAfterContentInit() {
+        this.renderer.listen(this.elRef.nativeElement, this.angulartics2On || 'click', (event) => this.eventTrack(event));
+    }
+    eventTrack(event) {
+        const action = this.angularticsAction; // || this.inferEventName();
+        const properties = {
+            ...this.angularticsProperties,
+            eventType: event.type,
+        };
+        if (this.angularticsCategory) {
+            properties.category = this.angularticsCategory;
+        }
+        if (this.angularticsLabel) {
+            properties.label = this.angularticsLabel;
+        }
+        if (this.angularticsValue) {
+            properties.value = this.angularticsValue;
+        }
+        this.angulartics2.eventTrack.next({
+            action,
+            properties,
+        });
+    }
+}
+Angulartics2On.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2On, deps: [{ token: i0.ElementRef }, { token: i1.Angulartics2 }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+Angulartics2On.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: Angulartics2On, selector: "[angulartics2On]", inputs: { angulartics2On: "angulartics2On", angularticsAction: "angularticsAction", angularticsCategory: "angularticsCategory", angularticsLabel: "angularticsLabel", angularticsValue: "angularticsValue", angularticsProperties: "angularticsProperties" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2On, decorators: [{
+            type: Directive,
+            args: [{ selector: '[angulartics2On]' }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.Angulartics2 }, { type: i0.Renderer2 }]; }, propDecorators: { angulartics2On: [{
+                type: Input,
+                args: ['angulartics2On']
+            }], angularticsAction: [{
+                type: Input
+            }], angularticsCategory: [{
+                type: Input
+            }], angularticsLabel: [{
+                type: Input
+            }], angularticsValue: [{
+                type: Input
+            }], angularticsProperties: [{
+                type: Input
+            }] } });
+export class Angulartics2OnModule {
+}
+Angulartics2OnModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2OnModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+Angulartics2OnModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2OnModule, declarations: [Angulartics2On], exports: [Angulartics2On] });
+Angulartics2OnModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2OnModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2OnModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [Angulartics2On],
+                    exports: [Angulartics2On],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/providers/adobeanalytics/adobeanalytics.mjs

@@ -0,0 +1,98 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+import * as i2 from "@angular/common";
+export class Angulartics2AdobeAnalytics {
+    constructor(angulartics2, location) {
+        this.angulartics2 = angulartics2;
+        this.location = location;
+        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 s !== 'undefined' && s) {
+            s.clearVars();
+            s.t({ pageName: path });
+        }
+    }
+    /**
+     * Track Event in Adobe Analytics
+     *
+     * @param action associated with the event
+     * @param properties action detials
+     *
+     * @link https://marketing.adobe.com/resources/help/en_US/sc/implement/js_implementation.html
+     */
+    eventTrack(action, properties) {
+        // TODO: make interface
+        // @property {string} properties.category
+        // @property {string} properties.label
+        // @property {number} properties.value
+        // @property {boolean} properties.noninteraction
+        if (!properties) {
+            properties = properties || {};
+        }
+        if (typeof s !== 'undefined' && s) {
+            if (typeof properties === 'object') {
+                this.setUserProperties(properties);
+            }
+            if (action) {
+                // if linkName property is passed, use that; otherwise, the action is the linkName
+                const linkName = properties['linkName'] ? properties['linkName'] : action;
+                // note that 'this' should refer the link element, but we can't get that in this function. example:
+                // <a href="http://anothersite.com" onclick="s.tl(this,'e','AnotherSite',null)">
+                // if disableDelay property is passed, use that to turn off/on the 500ms delay; otherwise, it uses this
+                const disableDelay = !!properties['disableDelay'] ? true : this;
+                // if action property is passed, use that; otherwise, the action remains unchanged
+                if (properties['action']) {
+                    action = properties['action'];
+                }
+                this.setPageName();
+                if (action.toUpperCase() === 'DOWNLOAD') {
+                    s.tl(disableDelay, 'd', linkName);
+                }
+                else if (action.toUpperCase() === 'EXIT') {
+                    s.tl(disableDelay, 'e', linkName);
+                }
+                else {
+                    s.tl(disableDelay, 'o', linkName);
+                }
+            }
+        }
+    }
+    setPageName() {
+        const path = this.location.path(true);
+        const hashNdx = path.indexOf('#');
+        if (hashNdx > 0 && hashNdx < path.length) {
+            s.pageName = path.substring(hashNdx + 1);
+        }
+        else {
+            s.pageName = path;
+        }
+    }
+    setUserProperties(properties) {
+        if (typeof s !== 'undefined' && s) {
+            if (typeof properties === 'object') {
+                for (const key in properties) {
+                    if (properties.hasOwnProperty(key)) {
+                        s[key] = properties[key];
+                    }
+                }
+            }
+        }
+    }
+}
+Angulartics2AdobeAnalytics.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2AdobeAnalytics, deps: [{ token: i1.Angulartics2 }, { token: i2.Location }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2AdobeAnalytics.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2AdobeAnalytics, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2AdobeAnalytics, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }, { type: i2.Location }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adobeanalytics.js","sourceRoot":"","sources":["../../../../src/lib/providers/adobeanalytics/adobeanalytics.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\nimport { Injectable } from '@angular/core';\n\nimport { Angulartics2 } from '../../angulartics2-core';\n\ndeclare const s: any;\n\n@Injectable({ providedIn: 'root' })\nexport class Angulartics2AdobeAnalytics {\n  constructor(private angulartics2: Angulartics2, private location: Location) {\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  }\n\n  pageTrack(path: string) {\n    if (typeof s !== 'undefined' && s) {\n      s.clearVars();\n      s.t({ pageName: path });\n    }\n  }\n\n  /**\n   * Track Event in Adobe Analytics\n   *\n   * @param action associated with the event\n   * @param properties action detials\n   *\n   * @link https://marketing.adobe.com/resources/help/en_US/sc/implement/js_implementation.html\n   */\n  eventTrack(action: string, properties: any) {\n    // TODO: make interface\n    // @property {string} properties.category\n    // @property {string} properties.label\n    // @property {number} properties.value\n    // @property {boolean} properties.noninteraction\n    if (!properties) {\n      properties = properties || {};\n    }\n\n    if (typeof s !== 'undefined' && s) {\n      if (typeof properties === 'object') {\n        this.setUserProperties(properties);\n      }\n      if (action) {\n        // if linkName property is passed, use that; otherwise, the action is the linkName\n        const linkName = properties['linkName'] ? properties['linkName'] : action;\n        // note that 'this' should refer the link element, but we can't get that in this function. example:\n        // <a href=\"http://anothersite.com\" onclick=\"s.tl(this,'e','AnotherSite',null)\">\n        // if disableDelay property is passed, use that to turn off/on the 500ms delay; otherwise, it uses this\n        const disableDelay = !!properties['disableDelay'] ? true : this;\n        // if action property is passed, use that; otherwise, the action remains unchanged\n        if (properties['action']) {\n          action = properties['action'];\n        }\n        this.setPageName();\n\n        if (action.toUpperCase() === 'DOWNLOAD') {\n          s.tl(disableDelay, 'd', linkName);\n        } else if (action.toUpperCase() === 'EXIT') {\n          s.tl(disableDelay, 'e', linkName);\n        } else {\n          s.tl(disableDelay, 'o', linkName);\n        }\n      }\n    }\n  }\n\n  private setPageName() {\n    const path = this.location.path(true);\n    const hashNdx = path.indexOf('#');\n    if (hashNdx > 0 && hashNdx < path.length) {\n      s.pageName = path.substring(hashNdx + 1);\n    } else {\n      s.pageName = path;\n    }\n  }\n\n  setUserProperties(properties: any) {\n    if (typeof s !== 'undefined' && s) {\n      if (typeof properties === 'object') {\n        for (const key in properties) {\n          if (properties.hasOwnProperty(key)) {\n            s[key] = properties[key];\n          }\n        }\n      }\n    }\n  }\n}\n"]}

package/esm2020/providers/amplitude/amplitude.mjs

@@ -0,0 +1,68 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class Angulartics2Amplitude {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+        this.angulartics2.setUsername.subscribe((x) => this.setUsername(x));
+        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 {
+            amplitude.getInstance().logEvent(action, properties);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    setUsername(userId) {
+        try {
+            amplitude.getInstance().setUserId(userId);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    setUserProperties(properties) {
+        try {
+            amplitude.getInstance().setUserProperties(properties);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+}
+Angulartics2Amplitude.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Amplitude, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2Amplitude.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Amplitude, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Amplitude, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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