angulartics2 11.0.0 → 12.0.0

package/esm2020/providers/matomo/matomo.mjs

@@ -0,0 +1,303 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class Angulartics2Matomo {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+        if (typeof _paq === 'undefined') {
+            console.warn('Matomo not found');
+        }
+        this.angulartics2.setUsername.subscribe((x) => this.setUsername(x));
+        this.angulartics2.setUserProperties.subscribe((x) => this.setUserProperties(x));
+    }
+    startTracking() {
+        this.angulartics2.pageTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.pageTrack(x.path));
+        this.angulartics2.eventTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.eventTrack(x.action, x.properties));
+    }
+    pageTrack(path, title) {
+        try {
+            if (!window.location.origin) {
+                window.location.origin =
+                    window.location.protocol +
+                        '//' +
+                        window.location.hostname +
+                        (window.location.port ? ':' + window.location.port : '');
+            }
+            _paq.push(['setDocumentTitle', title || window.document.title]);
+            _paq.push(['setCustomUrl', window.location.origin + path]);
+            _paq.push(['trackPageView']);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    resetUser() {
+        try {
+            _paq.push(['appendToTrackingUrl', 'new_visit=1']); // (1) forces a new visit
+            _paq.push(['deleteCookies']); // (2) deletes existing tracking cookies to start the new visit
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    /**
+     * Track a basic event in Matomo, or send an ecommerce event.
+     *
+     * @param action A string corresponding to the type of event that needs to be tracked.
+     * @param properties The properties that need to be logged with the event.
+     */
+    eventTrack(action, properties) {
+        let params = [];
+        switch (action) {
+            /**
+             * @description Sets the current page view as a product or category page view. When you call
+             * setEcommerceView it must be followed by a call to trackPageView to record the product or
+             * category page view.
+             *
+             * @link https://matomo.org/docs/ecommerce-analytics/#tracking-product-page-views-category-page-views-optional
+             * @link https://developer.matomo.org/api-reference/tracking-javascript#ecommerce
+             *
+             * @property productSKU (required) SKU: Product unique identifier
+             * @property productName (optional) Product name
+             * @property categoryName (optional) Product category, or array of up to 5 categories
+             * @property price (optional) Product Price as displayed on the page
+             */
+            case 'setEcommerceView':
+                params = [
+                    'setEcommerceView',
+                    properties.productSKU,
+                    properties.productName,
+                    properties.categoryName,
+                    properties.price,
+                ];
+                break;
+            /**
+             * @description Adds a product into the ecommerce order. Must be called for each product in
+             * the order.
+             *
+             * @link https://matomo.org/docs/ecommerce-analytics/#tracking-ecommerce-orders-items-purchased-required
+             * @link https://developer.matomo.org/api-reference/tracking-javascript#ecommerce
+             *
+             * @property productSKU (required) SKU: Product unique identifier
+             * @property productName (optional) Product name
+             * @property categoryName (optional) Product category, or array of up to 5 categories
+             * @property price (recommended) Product price
+             * @property quantity (optional, default to 1) Product quantity
+             */
+            case 'addEcommerceItem':
+                params = [
+                    'addEcommerceItem',
+                    properties.productSKU,
+                    properties.productName,
+                    properties.productCategory,
+                    properties.price,
+                    properties.quantity,
+                ];
+                break;
+            /**
+             * @description Tracks a shopping cart. Call this javascript function every time a user is
+             * adding, updating or deleting a product from the cart.
+             *
+             * @link https://matomo.org/docs/ecommerce-analytics/#tracking-add-to-cart-items-added-to-the-cart-optional
+             * @link https://developer.matomo.org/api-reference/tracking-javascript#ecommerce
+             *
+             * @property grandTotal (required) Cart amount
+             */
+            case 'trackEcommerceCartUpdate':
+                params = [
+                    'trackEcommerceCartUpdate',
+                    properties.grandTotal,
+                ];
+                break;
+            /**
+             * @description Tracks an Ecommerce order, including any ecommerce item previously added to
+             * the order. orderId and grandTotal (ie. revenue) are required parameters.
+             *
+             * @link https://matomo.org/docs/ecommerce-analytics/#tracking-ecommerce-orders-items-purchased-required
+             * @link https://developer.matomo.org/api-reference/tracking-javascript#ecommerce
+             *
+             * @property orderId (required) Unique Order ID
+             * @property grandTotal (required) Order Revenue grand total (includes tax, shipping, and subtracted discount)
+             * @property subTotal (optional) Order sub total (excludes shipping)
+             * @property tax (optional) Tax amount
+             * @property shipping (optional) Shipping amount
+             * @property discount (optional) Discount offered (set to false for unspecified parameter)
+             */
+            case 'trackEcommerceOrder':
+                params = [
+                    'trackEcommerceOrder',
+                    properties.orderId,
+                    properties.grandTotal,
+                    properties.subTotal,
+                    properties.tax,
+                    properties.shipping,
+                    properties.discount,
+                ];
+                break;
+            /**
+             * @description To manually trigger an outlink
+             *
+             * @link https://matomo.org/docs/tracking-goals-web-analytics/
+             * @link https://developer.matomo.org/guides/tracking-javascript-guide#tracking-a-click-as-an-outlink-via-css-or-javascript
+             *
+             * @property url (required) link url
+             * @property linkType (optional) type of link
+             */
+            case 'trackLink':
+                params = [
+                    'trackLink',
+                    properties.url,
+                    properties.linkType,
+                ];
+                break;
+            /**
+             * @description Tracks an Ecommerce goal
+             *
+             * @link https://matomo.org/docs/tracking-goals-web-analytics/
+             * @link https://developer.matomo.org/guides/tracking-javascript-guide#manually-trigger-goal-conversions
+             *
+             * @property goalId (required) Unique Goal ID
+             * @property value (optional) passed to goal tracking
+             */
+            case 'trackGoal':
+                params = [
+                    'trackGoal',
+                    properties.goalId,
+                    properties.value,
+                ];
+                break;
+            /**
+             * @description Tracks a site search
+             *
+             * @link https://matomo.org/docs/site-search/
+             * @link https://developer.matomo.org/guides/tracking-javascript-guide#internal-search-tracking
+             *
+             * @property keyword (required) Keyword searched for
+             * @property category (optional) Search category
+             * @property searchCount (optional) Number of results
+             */
+            case 'trackSiteSearch':
+                params = [
+                    'trackSiteSearch',
+                    properties.keyword,
+                    properties.category,
+                    properties.searchCount,
+                ];
+                break;
+            /**
+             * @description Logs an event with an event category (Videos, Music, Games...), an event
+             * action (Play, Pause, Duration, Add Playlist, Downloaded, Clicked...), and an optional
+             * event name and optional numeric value.
+             *
+             * @link https://matomo.org/docs/event-tracking/
+             * @link https://developer.matomo.org/api-reference/tracking-javascript#using-the-tracker-object
+             *
+             * @property category
+             * @property action
+             * @property name (optional, recommended)
+             * @property value (optional)
+             */
+            default:
+                // PAQ requires that eventValue be an integer, see: http://matomo.org/docs/event-tracking
+                if (properties.value) {
+                    const parsed = parseInt(properties.value, 10);
+                    properties.value = isNaN(parsed) ? 0 : parsed;
+                }
+                params = [
+                    'trackEvent',
+                    properties.category,
+                    action,
+                    properties.name ||
+                        properties.label,
+                    properties.value,
+                ];
+        }
+        try {
+            _paq.push(params);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    setUsername(userId) {
+        try {
+            _paq.push(['setUserId', userId]);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    /**
+     * Sets custom dimensions if at least one property has the key "dimension<n>",
+     * e.g. dimension10. If there are custom dimensions, any other property is ignored.
+     *
+     * If there are no custom dimensions in the given properties object, the properties
+     * object is saved as a custom variable.
+     *
+     * If in doubt, prefer custom dimensions.
+     * @link https://matomo.org/docs/custom-variables/
+     */
+    setUserProperties(properties) {
+        const dimensions = this.setCustomDimensions(properties);
+        try {
+            if (dimensions.length === 0) {
+                _paq.push([
+                    'setCustomVariable',
+                    properties.index,
+                    properties.name,
+                    properties.value,
+                    properties.scope,
+                ]);
+            }
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    /**
+     * If you created a custom variable and then decide to remove this variable from
+     * a visit or page view, you can use deleteCustomVariable.
+     *
+     * @link https://developer.matomo.org/guides/tracking-javascript-guide#deleting-a-custom-variable
+     */
+    deletedUserProperties(properties) {
+        try {
+            _paq.push(['deleteCustomVariable', properties.index, properties.scope]);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    setCustomDimensions(properties) {
+        const dimensionRegex = /dimension[1-9]\d*/;
+        const dimensions = Object.keys(properties).filter(key => dimensionRegex.exec(key));
+        dimensions.forEach(dimension => {
+            const number = Number(dimension.substr(9));
+            _paq.push(['setCustomDimension', number, properties[dimension]]);
+        });
+        return dimensions;
+    }
+}
+Angulartics2Matomo.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Matomo, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2Matomo.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Matomo, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Matomo, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matomo.js","sourceRoot":"","sources":["../../../../src/lib/providers/matomo/matomo.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { Angulartics2 } from '../../angulartics2-core';\n\ndeclare var _paq: any;\n\nexport type EventTrackAction =\n  | 'setEcommerceView'\n  | 'addEcommerceItem'\n  | 'trackEcommerceCartUpdate'\n  | 'trackEcommerceOrder'\n  | 'trackLink'\n  | 'trackGoal'\n  | 'trackSiteSearch'\n  | string;\n\nexport type ScopeMatomo = 'visit' | 'page';\n\nexport interface DimensionsMatomoProperties {\n  dimension0?: string;\n  dimension1?: string;\n  dimension2?: string;\n  dimension3?: string;\n  dimension4?: string;\n  dimension5?: string;\n  dimension6?: string;\n  dimension7?: string;\n  dimension8?: string;\n  dimension9?: string;\n}\nexport interface SetEcommerceViewMatomoProperties {\n  /** @class SetEcommerceViewMatomoProperties */\n  productSKU: string;\n  /** @class SetEcommerceViewMatomoProperties */\n  productName: string;\n  /** @class SetEcommerceViewMatomoProperties */\n  categoryName: string;\n  /** @class SetEcommerceViewMatomoProperties */\n  price: string;\n}\n\nexport interface AddEcommerceItemProperties {\n  /** @class AddEcommerceItemProperties */\n  productSKU: string;\n  /** @class AddEcommerceItemProperties */\n  productName: string;\n  /** @class AddEcommerceItemProperties */\n  productCategory: string;\n  /** @class AddEcommerceItemProperties */\n  price: string;\n  /** @class AddEcommerceItemProperties */\n  quantity: string;\n}\n\nexport interface TrackEcommerceCartUpdateMatomoProperties {\n  /** @class TrackEcommerceCartUpdateMatomoProperties */\n  grandTotal: string;\n}\n\nexport interface TrackEcommerceOrderMatomoProperties {\n  /** @class TrackEcommerceOrderMatomoProperties */\n  orderId: string;\n  /** @class TrackEcommerceOrderMatomoProperties */\n  grandTotal: string;\n  /** @class TrackEcommerceOrderMatomoProperties */\n  subTotal: string;\n  /** @class TrackEcommerceOrderMatomoProperties */\n  tax: string;\n  /** @class TrackEcommerceOrderMatomoProperties */\n  shipping: string;\n  /** @class TrackEcommerceOrderMatomoProperties */\n  discount: string;\n}\n\nexport interface TrackLinkMatomoProperties {\n  /** @class TrackLinkMatomoProperties */\n  url: string;\n  /** @class TrackLinkMatomoProperties */\n  linkType: string;\n}\n\nexport interface TrackGoalMatomoProperties {\n  /** @class TrackGoalMatomoProperties */\n  goalId: string;\n  /** @class TrackGoalMatomoProperties */\n  value: string;\n}\n\nexport interface TrackSiteSearchMatomoProperties {\n  /** @class TrackSiteSearchMatomoProperties */\n  keyword: string;\n  /** @class TrackSiteSearchMatomoProperties */\n  category: string;\n  /** @class TrackSiteSearchMatomoProperties */\n  searchCount: string;\n}\n\nexport interface TrackEventMatomoProperties {\n  /** @class TrackEventMatomoProperties */\n  category: string;\n  /** @class TrackEventMatomoProperties */\n  name?: string;\n  /** @class TrackEventMatomoProperties */\n  label?: string;\n  /** @class TrackEventMatomoProperties */\n  value: number | string;\n}\n\nexport interface SetCustomVariableMatomoProperties extends DimensionsMatomoProperties {\n  /** @class SetCustomVariableMatomoProperties */\n  index: number;\n  /** @class SetCustomVariableMatomoProperties */\n  name: string;\n  /** @class SetCustomVariableMatomoProperties */\n  value: string;\n  /** @class SetCustomVariableMatomoProperties */\n  scope: ScopeMatomo;\n}\n\nexport interface DeleteCustomVariableMatomoProperties {\n  /** @class DeleteCustomVariableMatomoProperties */\n  index: number;\n  /** @class DeleteCustomVariableMatomoProperties */\n  scope: ScopeMatomo;\n}\n\nexport type EventTrackactionProperties =\n  | SetEcommerceViewMatomoProperties\n  | AddEcommerceItemProperties\n  | TrackEcommerceCartUpdateMatomoProperties\n  | TrackEcommerceOrderMatomoProperties\n  | TrackLinkMatomoProperties\n  | TrackGoalMatomoProperties\n  | TrackSiteSearchMatomoProperties\n  | TrackEventMatomoProperties;\n\n@Injectable({ providedIn: 'root' })\nexport class Angulartics2Matomo {\n  constructor(private angulartics2: Angulartics2) {\n    if (typeof _paq === 'undefined') {\n      console.warn('Matomo not found');\n    }\n    this.angulartics2.setUsername.subscribe((x: string) => this.setUsername(x));\n    this.angulartics2.setUserProperties.subscribe((x: SetCustomVariableMatomoProperties) =>\n      this.setUserProperties(x),\n    );\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, title?: string) {\n    try {\n      if (!window.location.origin) {\n        (window.location as any).origin =\n          window.location.protocol +\n          '//' +\n          window.location.hostname +\n          (window.location.port ? ':' + window.location.port : '');\n      }\n      _paq.push(['setDocumentTitle', title || window.document.title]);\n      _paq.push(['setCustomUrl', window.location.origin + path]);\n      _paq.push(['trackPageView']);\n    } catch (e) {\n      if (!(e instanceof ReferenceError)) {\n        throw e;\n      }\n    }\n  }\n\n  resetUser() {\n    try {\n      _paq.push(['appendToTrackingUrl', 'new_visit=1']); // (1) forces a new visit\n      _paq.push(['deleteCookies']); // (2) deletes existing tracking cookies to start the new visit\n    } catch (e) {\n      if (!(e instanceof ReferenceError)) {\n        throw e;\n      }\n    }\n  }\n\n  eventTrack(action: 'setEcommerceView', properties: SetEcommerceViewMatomoProperties): void;\n  eventTrack(action: 'addEcommerceItem', properties: AddEcommerceItemProperties): void;\n  eventTrack(\n    action: 'trackEcommerceCartUpdate',\n    properties: TrackEcommerceCartUpdateMatomoProperties,\n  ): void;\n  eventTrack(action: 'trackEcommerceOrder', properties: TrackEcommerceOrderMatomoProperties): void;\n  eventTrack(action: 'trackLink', properties: TrackLinkMatomoProperties): void;\n  eventTrack(action: 'trackGoal', properties: TrackGoalMatomoProperties): void;\n  eventTrack(action: 'trackSiteSearch', properties: TrackSiteSearchMatomoProperties): void;\n  eventTrack(action: string, properties: TrackEventMatomoProperties): void;\n\n  /**\n   * Track a basic event in Matomo, or send an ecommerce event.\n   *\n   * @param action A string corresponding to the type of event that needs to be tracked.\n   * @param properties The properties that need to be logged with the event.\n   */\n  eventTrack(action: EventTrackAction, properties?: EventTrackactionProperties) {\n    let params = [];\n    switch (action) {\n      /**\n       * @description Sets the current page view as a product or category page view. When you call\n       * setEcommerceView it must be followed by a call to trackPageView to record the product or\n       * category page view.\n       *\n       * @link https://matomo.org/docs/ecommerce-analytics/#tracking-product-page-views-category-page-views-optional\n       * @link https://developer.matomo.org/api-reference/tracking-javascript#ecommerce\n       *\n       * @property productSKU (required) SKU: Product unique identifier\n       * @property productName (optional) Product name\n       * @property categoryName (optional) Product category, or array of up to 5 categories\n       * @property price (optional) Product Price as displayed on the page\n       */\n      case 'setEcommerceView':\n        params = [\n          'setEcommerceView',\n          (properties as SetEcommerceViewMatomoProperties).productSKU,\n          (properties as SetEcommerceViewMatomoProperties).productName,\n          (properties as SetEcommerceViewMatomoProperties).categoryName,\n          (properties as SetEcommerceViewMatomoProperties).price,\n        ];\n        break;\n\n      /**\n       * @description Adds a product into the ecommerce order. Must be called for each product in\n       * the order.\n       *\n       * @link https://matomo.org/docs/ecommerce-analytics/#tracking-ecommerce-orders-items-purchased-required\n       * @link https://developer.matomo.org/api-reference/tracking-javascript#ecommerce\n       *\n       * @property productSKU (required) SKU: Product unique identifier\n       * @property productName (optional) Product name\n       * @property categoryName (optional) Product category, or array of up to 5 categories\n       * @property price (recommended) Product price\n       * @property quantity (optional, default to 1) Product quantity\n       */\n      case 'addEcommerceItem':\n        params = [\n          'addEcommerceItem',\n          (properties as AddEcommerceItemProperties).productSKU,\n          (properties as AddEcommerceItemProperties).productName,\n          (properties as AddEcommerceItemProperties).productCategory,\n          (properties as AddEcommerceItemProperties).price,\n          (properties as AddEcommerceItemProperties).quantity,\n        ];\n        break;\n\n      /**\n       * @description Tracks a shopping cart. Call this javascript function every time a user is\n       * adding, updating or deleting a product from the cart.\n       *\n       * @link https://matomo.org/docs/ecommerce-analytics/#tracking-add-to-cart-items-added-to-the-cart-optional\n       * @link https://developer.matomo.org/api-reference/tracking-javascript#ecommerce\n       *\n       * @property grandTotal (required) Cart amount\n       */\n      case 'trackEcommerceCartUpdate':\n        params = [\n          'trackEcommerceCartUpdate',\n          (properties as TrackEcommerceCartUpdateMatomoProperties).grandTotal,\n        ];\n        break;\n\n      /**\n       * @description Tracks an Ecommerce order, including any ecommerce item previously added to\n       * the order. orderId and grandTotal (ie. revenue) are required parameters.\n       *\n       * @link https://matomo.org/docs/ecommerce-analytics/#tracking-ecommerce-orders-items-purchased-required\n       * @link https://developer.matomo.org/api-reference/tracking-javascript#ecommerce\n       *\n       * @property orderId (required) Unique Order ID\n       * @property grandTotal (required) Order Revenue grand total (includes tax, shipping, and subtracted discount)\n       * @property subTotal (optional) Order sub total (excludes shipping)\n       * @property tax (optional) Tax amount\n       * @property shipping (optional) Shipping amount\n       * @property discount (optional) Discount offered (set to false for unspecified parameter)\n       */\n      case 'trackEcommerceOrder':\n        params = [\n          'trackEcommerceOrder',\n          (properties as TrackEcommerceOrderMatomoProperties).orderId,\n          (properties as TrackEcommerceOrderMatomoProperties).grandTotal,\n          (properties as TrackEcommerceOrderMatomoProperties).subTotal,\n          (properties as TrackEcommerceOrderMatomoProperties).tax,\n          (properties as TrackEcommerceOrderMatomoProperties).shipping,\n          (properties as TrackEcommerceOrderMatomoProperties).discount,\n        ];\n        break;\n\n      /**\n       * @description To manually trigger an outlink\n       *\n       * @link https://matomo.org/docs/tracking-goals-web-analytics/\n       * @link https://developer.matomo.org/guides/tracking-javascript-guide#tracking-a-click-as-an-outlink-via-css-or-javascript\n       *\n       * @property url (required) link url\n       * @property linkType (optional) type of link\n       */\n      case 'trackLink':\n        params = [\n          'trackLink',\n          (properties as TrackLinkMatomoProperties).url,\n          (properties as TrackLinkMatomoProperties).linkType,\n        ];\n        break;\n\n      /**\n       * @description Tracks an Ecommerce goal\n       *\n       * @link https://matomo.org/docs/tracking-goals-web-analytics/\n       * @link https://developer.matomo.org/guides/tracking-javascript-guide#manually-trigger-goal-conversions\n       *\n       * @property goalId (required) Unique Goal ID\n       * @property value (optional) passed to goal tracking\n       */\n      case 'trackGoal':\n        params = [\n          'trackGoal',\n          (properties as TrackGoalMatomoProperties).goalId,\n          (properties as TrackGoalMatomoProperties).value,\n        ];\n        break;\n\n      /**\n       * @description Tracks a site search\n       *\n       * @link https://matomo.org/docs/site-search/\n       * @link https://developer.matomo.org/guides/tracking-javascript-guide#internal-search-tracking\n       *\n       * @property keyword (required) Keyword searched for\n       * @property category (optional) Search category\n       * @property searchCount (optional) Number of results\n       */\n      case 'trackSiteSearch':\n        params = [\n          'trackSiteSearch',\n          (properties as TrackSiteSearchMatomoProperties).keyword,\n          (properties as TrackSiteSearchMatomoProperties).category,\n          (properties as TrackSiteSearchMatomoProperties).searchCount,\n        ];\n        break;\n\n      /**\n       * @description Logs an event with an event category (Videos, Music, Games...), an event\n       * action (Play, Pause, Duration, Add Playlist, Downloaded, Clicked...), and an optional\n       * event name and optional numeric value.\n       *\n       * @link https://matomo.org/docs/event-tracking/\n       * @link https://developer.matomo.org/api-reference/tracking-javascript#using-the-tracker-object\n       *\n       * @property category\n       * @property action\n       * @property name (optional, recommended)\n       * @property value (optional)\n       */\n      default:\n        // PAQ requires that eventValue be an integer, see: http://matomo.org/docs/event-tracking\n        if ((properties as TrackEventMatomoProperties).value) {\n          const parsed = parseInt((properties as TrackEventMatomoProperties).value as any, 10);\n          (properties as TrackEventMatomoProperties).value = isNaN(parsed) ? 0 : parsed;\n        }\n\n        params = [\n          'trackEvent',\n          (properties as TrackEventMatomoProperties).category,\n          action,\n          (properties as TrackEventMatomoProperties).name ||\n            (properties as TrackEventMatomoProperties).label, // Changed in favour of Matomo documentation. Added fallback so it's backwards compatible.\n          (properties as TrackEventMatomoProperties).value,\n        ];\n    }\n    try {\n      _paq.push(params);\n    } catch (e) {\n      if (!(e instanceof ReferenceError)) {\n        throw e;\n      }\n    }\n  }\n\n  setUsername(userId: string | boolean) {\n    try {\n      _paq.push(['setUserId', userId]);\n    } catch (e) {\n      if (!(e instanceof ReferenceError)) {\n        throw e;\n      }\n    }\n  }\n\n  /**\n   * Sets custom dimensions if at least one property has the key \"dimension<n>\",\n   * e.g. dimension10. If there are custom dimensions, any other property is ignored.\n   *\n   * If there are no custom dimensions in the given properties object, the properties\n   * object is saved as a custom variable.\n   *\n   * If in doubt, prefer custom dimensions.\n   * @link https://matomo.org/docs/custom-variables/\n   */\n  setUserProperties(properties: SetCustomVariableMatomoProperties) {\n    const dimensions = this.setCustomDimensions(properties);\n    try {\n      if (dimensions.length === 0) {\n        _paq.push([\n          'setCustomVariable',\n          properties.index,\n          properties.name,\n          properties.value,\n          properties.scope,\n        ]);\n      }\n    } catch (e) {\n      if (!(e instanceof ReferenceError)) {\n        throw e;\n      }\n    }\n  }\n\n  /**\n   * If you created a custom variable and then decide to remove this variable from\n   * a visit or page view, you can use deleteCustomVariable.\n   *\n   * @link https://developer.matomo.org/guides/tracking-javascript-guide#deleting-a-custom-variable\n   */\n  deletedUserProperties(properties: DeleteCustomVariableMatomoProperties) {\n    try {\n      _paq.push(['deleteCustomVariable', properties.index, properties.scope]);\n    } catch (e) {\n      if (!(e instanceof ReferenceError)) {\n        throw e;\n      }\n    }\n  }\n\n  private setCustomDimensions(properties: SetCustomVariableMatomoProperties): string[] {\n    const dimensionRegex: RegExp = /dimension[1-9]\\d*/;\n    const dimensions = Object.keys(properties).filter(key => dimensionRegex.exec(key));\n    dimensions.forEach(dimension => {\n      const number = Number(dimension.substr(9));\n      _paq.push(['setCustomDimension', number, properties[dimension]]);\n    });\n    return dimensions;\n  }\n}\n"]}

package/esm2020/providers/mixpanel/mixpanel.mjs

@@ -0,0 +1,109 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class Angulartics2Mixpanel {
+    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.setUserPropertiesOnce(x));
+        this.angulartics2.setSuperProperties.subscribe(x => this.setSuperProperties(x));
+        this.angulartics2.setSuperPropertiesOnce.subscribe(x => this.setSuperPropertiesOnce(x));
+        this.angulartics2.setAlias.subscribe(x => this.setAlias(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 {
+            mixpanel.track('Page Viewed', { page: path });
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    eventTrack(action, properties) {
+        try {
+            mixpanel.track(action, properties);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    setUsername(userId) {
+        try {
+            mixpanel.identify(userId);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    setUserProperties(properties) {
+        try {
+            mixpanel.people.set(properties);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    setUserPropertiesOnce(properties) {
+        try {
+            mixpanel.people.set_once(properties);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    setSuperProperties(properties) {
+        try {
+            mixpanel.register(properties);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    setSuperPropertiesOnce(properties) {
+        try {
+            mixpanel.register_once(properties);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+    setAlias(alias) {
+        try {
+            mixpanel.alias(alias);
+        }
+        catch (e) {
+            if (!(e instanceof ReferenceError)) {
+                throw e;
+            }
+        }
+    }
+}
+Angulartics2Mixpanel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Mixpanel, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2Mixpanel.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Mixpanel, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Mixpanel, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/providers/pyze/pyze.mjs

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