@kurkov87/ngx-analytics
Version:
Vendor-agnostic web analytics for Angular2 applications, based on angulartics2
246 lines (237 loc) • 9.79 kB
JavaScript
import { Directive, ElementRef, Inject, Injectable, InjectionToken, Input, NgModule, Renderer2 } from '@angular/core';
import { BehaviorSubject, ReplaySubject } from 'rxjs';
import { Location } from '@angular/common';
import { NavigationEnd, Router } from '@angular/router';
import { filter, map } from 'rxjs/operators';
var DefaultConfig = (function () {
function DefaultConfig() {
this.pageTracking = {
autoTrackVirtualPages: true,
basePath: '',
excludedRoutes: [],
clearIds: false,
clearQueryParams: false,
idsRegExp: /^\d+$|^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
};
this.developerMode = false;
this.ga = {};
this.appInsights = {};
this.gtm = {};
}
return DefaultConfig;
}());
var ANGULARTICS2_TOKEN = new InjectionToken('ANGULARTICS2');
var RouterlessTracking = (function () {
function RouterlessTracking() {
}
RouterlessTracking.prototype.trackLocation = function (settings) {
return new BehaviorSubject({ url: '/' });
};
RouterlessTracking.prototype.prepareExternalUrl = function (url) {
return url;
};
return RouterlessTracking;
}());
var __assign = (undefined && undefined.__assign) || Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
var NgxAnalytics = (function () {
function NgxAnalytics(tracker, setup) {
var _this = this;
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);
var defaultConfig = new DefaultConfig();
this.settings = __assign({}, defaultConfig, setup.settings);
this.settings.pageTracking = __assign({}, defaultConfig.pageTracking, setup.settings.pageTracking);
this.tracker
.trackLocation(this.settings)
.subscribe(function (event) {
return _this.trackUrlChange(event.url);
});
}
NgxAnalytics.prototype.virtualPageviews = function (value) {
this.settings.pageTracking.autoTrackVirtualPages = value;
};
NgxAnalytics.prototype.excludeRoutes = function (routes) {
this.settings.pageTracking.excludedRoutes = routes;
};
NgxAnalytics.prototype.withBase = function (value) {
this.settings.pageTracking.basePath = value;
};
NgxAnalytics.prototype.clearIds = function (value) {
this.settings.pageTracking.clearIds = value;
};
NgxAnalytics.prototype.developerMode = function (value) {
this.settings.developerMode = value;
};
NgxAnalytics.prototype.trackUrlChange = function (url) {
if (this.settings.pageTracking.autoTrackVirtualPages && !this.matchesExcludedRoute(url)) {
var clearedUrl = this.clearUrl(url);
var path = void 0;
if (this.settings.pageTracking.basePath.length) {
path = this.settings.pageTracking.basePath + clearedUrl;
}
else {
path = this.tracker.prepareExternalUrl(clearedUrl);
}
this.pageTrack.next({ path: path });
}
};
NgxAnalytics.prototype.matchesExcludedRoute = function (url) {
for (var _i = 0, _a = this.settings.pageTracking.excludedRoutes; _i < _a.length; _i++) {
var excludedRoute = _a[_i];
var matchesRegex = excludedRoute instanceof RegExp && excludedRoute.test(url);
if (matchesRegex || url.indexOf(excludedRoute) !== -1) {
return true;
}
}
return false;
};
NgxAnalytics.prototype.clearUrl = function (url) {
var _this = this;
if (this.settings.pageTracking.clearIds || this.settings.pageTracking.clearQueryParams) {
return url
.split('/')
.map(function (part) { return _this.settings.pageTracking.clearQueryParams ? part.split('?')[0] : part; })
.filter(function (part) { return !_this.settings.pageTracking.clearIds || !part.match(_this.settings.pageTracking.idsRegExp); })
.join('/');
}
return url;
};
NgxAnalytics.decorators = [
{ type: Injectable },
];
NgxAnalytics.ctorParameters = function () { return [
{ type: RouterlessTracking, },
{ type: undefined, decorators: [{ type: Inject, args: [ANGULARTICS2_TOKEN,] },] },
]; };
return NgxAnalytics;
}());
var AngularRouterTracking = (function () {
function AngularRouterTracking(router$$1, location) {
this.router = router$$1;
this.location = location;
}
AngularRouterTracking.prototype.trackLocation = function (settings) {
return this.router.events.pipe(filter(function (e) { return e instanceof NavigationEnd; }), filter(function () { return !settings.developerMode; }), map(function (e) {
return { url: e.urlAfterRedirects };
}));
};
AngularRouterTracking.prototype.prepareExternalUrl = function (url) {
return this.location.prepareExternalUrl(url);
};
AngularRouterTracking.decorators = [
{ type: Injectable },
];
AngularRouterTracking.ctorParameters = function () { return [
{ type: Router, },
{ type: Location, },
]; };
return AngularRouterTracking;
}());
var __assign$1 = (undefined && undefined.__assign) || Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
var NgxAnalyticsOn = (function () {
function NgxAnalyticsOn(elRef, ngxAnalytics, renderer) {
this.elRef = elRef;
this.ngxAnalytics = ngxAnalytics;
this.renderer = renderer;
this.angularticsProperties = {};
}
NgxAnalyticsOn.prototype.ngAfterContentInit = function () {
var _this = this;
this.renderer.listen(this.elRef.nativeElement, this.ngxAnalyticsOn || 'click', function (event) { return _this.eventTrack(event); });
};
NgxAnalyticsOn.prototype.eventTrack = function (event) {
var action = this.angularticsAction;
var properties = __assign$1({}, 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.ngxAnalytics.eventTrack.next({
action: action,
properties: properties,
});
};
NgxAnalyticsOn.decorators = [
{ type: Injectable },
{ type: Directive, args: [{ selector: '[ngx-analyticsOn]' },] },
];
NgxAnalyticsOn.ctorParameters = function () { return [
{ type: ElementRef, },
{ type: NgxAnalytics, },
{ type: Renderer2, },
]; };
NgxAnalyticsOn.propDecorators = {
'ngxAnalyticsOn': [{ type: Input, args: ['ngx-analyticsOn',] },],
'angularticsAction': [{ type: Input },],
'angularticsCategory': [{ type: Input },],
'angularticsLabel': [{ type: Input },],
'angularticsValue': [{ type: Input },],
'angularticsProperties': [{ type: Input },],
};
return NgxAnalyticsOn;
}());
var NgxAnalyticsOnModule = (function () {
function NgxAnalyticsOnModule() {
}
NgxAnalyticsOnModule.decorators = [
{ type: NgModule, args: [{
declarations: [NgxAnalyticsOn],
exports: [NgxAnalyticsOn],
},] },
];
NgxAnalyticsOnModule.ctorParameters = function () { return []; };
return NgxAnalyticsOnModule;
}());
var NgxAnalyticsModule = (function () {
function NgxAnalyticsModule() {
}
NgxAnalyticsModule.forRoot = function (providers, settings) {
if (settings === void 0) { settings = {}; }
return {
ngModule: NgxAnalyticsModule,
providers: [
{ provide: ANGULARTICS2_TOKEN, useValue: { providers: providers, settings: settings } },
NgxAnalytics,
{ provide: RouterlessTracking, useClass: AngularRouterTracking }
].concat(providers),
};
};
NgxAnalyticsModule.decorators = [
{ type: NgModule, args: [{
imports: [NgxAnalyticsOnModule],
exports: [NgxAnalyticsOn],
},] },
];
NgxAnalyticsModule.ctorParameters = function () { return []; };
return NgxAnalyticsModule;
}());
export { NgxAnalytics, NgxAnalyticsModule, ANGULARTICS2_TOKEN, NgxAnalyticsOn, NgxAnalyticsOnModule, RouterlessTracking, AngularRouterTracking, DefaultConfig };
//# sourceMappingURL=core.es5.js.map