@aws-amplify/analytics 6.5.6-api-v6-models.b3abc9b.0 → 7.0.0

package/lib/providers/pinpoint/utils/resolveCredentials.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @internal
+ */
+export declare const resolveCredentials: () => Promise<{
+    credentials: import("@aws-amplify/core/lib-esm/libraryUtils").AWSCredentials;
+    identityId: string | undefined;
+}>;

package/lib/providers/pinpoint/utils/resolveCredentials.js

@@ -0,0 +1,16 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCredentials = void 0;
+const core_1 = require("@aws-amplify/core");
+const errors_1 = require("../../../errors");
+/**
+ * @internal
+ */
+const resolveCredentials = async () => {
+    const { credentials, identityId } = await (0, core_1.fetchAuthSession)();
+    (0, errors_1.assertValidationError)(!!credentials, errors_1.AnalyticsValidationErrorCode.NoCredentials);
+    return { credentials, identityId };
+};
+exports.resolveCredentials = resolveCredentials;

package/lib/setupTests.js

@@ -1,7 +1,7 @@
+"use strict";
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var anyGlobal = global;
+const anyGlobal = global;
 anyGlobal.navigator = anyGlobal.navigator || {};
 // @ts-ignore
 anyGlobal.navigator.sendBeacon = anyGlobal.navigator.sendBeacon || jest.fn();
-//# sourceMappingURL=setupTests.js.map

package/lib/trackers/EventTracker.d.ts

@@ -1,9 +1,10 @@
-import { EventTrackOpts } from '../types';
-export declare class EventTracker {
-    private _tracker;
-    private _config;
-    private _delegates;
-    constructor(tracker: any, opts: any);
-    configure(opts?: EventTrackOpts): EventTrackOpts;
-    private _trackFunc;
+import { EventTrackingOptions, TrackerEventRecorder, TrackerInterface } from '../types/trackers';
+export declare class EventTracker implements TrackerInterface {
+    private trackerActive;
+    private options;
+    private eventRecorder;
+    constructor(eventRecorder: TrackerEventRecorder, options?: EventTrackingOptions);
+    configure(eventRecorder: TrackerEventRecorder, options?: EventTrackingOptions): void;
+    cleanup(): void;
+    private handleDocEvent;
 }

package/lib/trackers/EventTracker.js

@@ -2,98 +2,97 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var dom_utils_1 = require("../vendor/dom-utils");
-var core_1 = require("@aws-amplify/core");
-var logger = new core_1.ConsoleLogger('EventTracker');
-var defaultOpts = {
-    enable: false,
-    events: ['click'],
-    selectorPrefix: 'data-amplify-analytics-',
-    provider: 'AWSPinpoint',
-};
-var EventTracker = /** @class */ (function () {
-    function EventTracker(tracker, opts) {
-        if (!core_1.browserOrNode().isBrowser || !window.addEventListener) {
-            logger.debug('not in the supported web environment');
-            return;
-        }
-        this._config = Object.assign({}, defaultOpts, opts);
-        this._tracker = tracker;
-        this._delegates = {};
-        this._trackFunc = this._trackFunc.bind(this);
-        logger.debug('initialize pageview tracker with opts', this._config);
-        this.configure(this._config);
+exports.EventTracker = void 0;
+const core_1 = require("@aws-amplify/core");
+const utils_1 = require("@aws-amplify/core/internals/utils");
+const DEFAULT_EVENTS = ['click'];
+const DEFAULT_SELECTOR_PREFIX = 'data-amplify-analytics-';
+const DEFAULT_EVENT_NAME = 'event'; // Default event name as sent to the analytics provider
+const logger = new core_1.ConsoleLogger('EventTracker');
+class EventTracker {
+    constructor(eventRecorder, options) {
+        this.options = {};
+        this.trackerActive = false;
+        this.eventRecorder = eventRecorder;
+        this.handleDocEvent = this.handleDocEvent.bind(this);
+        this.configure(eventRecorder, options);
     }
-    EventTracker.prototype.configure = function (opts) {
-        var _this = this;
-        Object.assign(this._config, opts);
-        if (!this._config.enable) {
-            Object.keys(this._delegates).forEach(function (key) {
-                if (typeof _this._delegates[key].destroy === 'function')
-                    _this._delegates[key].destroy();
+    configure(eventRecorder, options) {
+        this.eventRecorder = eventRecorder;
+        // Clean up any existing listeners
+        this.cleanup();
+        // Apply defaults
+        this.options = {
+            attributes: options?.attributes ?? undefined,
+            events: options?.events ?? DEFAULT_EVENTS,
+            selectorPrefix: options?.selectorPrefix ?? DEFAULT_SELECTOR_PREFIX,
+        };
+        // Register event listeners
+        if ((0, utils_1.isBrowser)()) {
+            this.options.events?.forEach(targetEvent => {
+                document.addEventListener(targetEvent, this.handleDocEvent, {
+                    capture: true,
+                });
             });
-            this._delegates = {};
+            this.trackerActive = true;
         }
-        else if (this._config.enable &&
-            Object.keys(this._delegates).length === 0) {
-            var selector_1 = '[' + this._config.selectorPrefix + 'on]';
-            this._config.events.forEach(function (evt) {
-                _this._delegates[evt] = dom_utils_1.delegate(document, evt, selector_1, _this._trackFunc, { composed: true, useCapture: true });
-            });
+    }
+    cleanup() {
+        // No-op if document listener is not active
+        if (!this.trackerActive) {
+            return;
         }
-        return this._config;
-    };
-    EventTracker.prototype._trackFunc = function (event, element) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var customAttrs, events, eventName, attrs, defaultAttrs, _a, attributes;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        customAttrs = {};
-                        events = element
-                            .getAttribute(this._config.selectorPrefix + 'on')
-                            .split(/\s*,\s*/);
-                        eventName = element.getAttribute(this._config.selectorPrefix + 'name');
-                        attrs = element.getAttribute(this._config.selectorPrefix + 'attrs');
-                        if (attrs) {
-                            attrs.split(/\s*,\s*/).forEach(function (attr) {
-                                var tmp = attr.trim().split(/\s*:\s*/);
-                                customAttrs[tmp[0]] = tmp[1];
-                            });
-                        }
-                        if (!(typeof this._config.attributes === 'function')) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this._config.attributes()];
-                    case 1:
-                        _a = _b.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        _a = this._config.attributes;
-                        _b.label = 3;
-                    case 3:
-                        defaultAttrs = _a;
-                        attributes = Object.assign({
-                            type: event.type,
-                            target: event.target.localName + " with id " + event.target.id,
-                        }, defaultAttrs, customAttrs);
-                        logger.debug('events needed to be recorded', events);
-                        logger.debug('attributes needed to be attached', customAttrs);
-                        if (events.indexOf(event.type) < 0) {
-                            logger.debug("event " + event.type + " is not selected to be recorded");
-                            return [2 /*return*/];
-                        }
-                        this._tracker({
-                            name: eventName || 'event',
-                            attributes: attributes,
-                        }, this._config.provider).catch(function (e) {
-                            logger.debug("Failed to record the " + event.type + " event', " + e);
-                        });
-                        return [2 /*return*/];
-                }
+        // Clean up event listeners
+        this.options.events?.forEach(targetEvent => {
+            document.removeEventListener(targetEvent, this.handleDocEvent, {
+                capture: true,
             });
         });
-    };
-    return EventTracker;
-}());
+    }
+    handleDocEvent(event) {
+        /**
+         * Example DOM element:
+         *
+         * ```
+         * <button
+         *   data-amplify-analytics-on="click"
+         *   data-amplify-analytics-name="click"
+         *   data-amplify-analytics-attrs="attr1:attr1_value,attr2:attr2_value"
+         * />
+         * ```
+         */
+        const triggerSelector = `[${this.options.selectorPrefix}on]`;
+        const attrSelector = `${this.options.selectorPrefix}attrs`;
+        const eventNameSelector = `${this.options.selectorPrefix}name`;
+        const eventSource = event.target;
+        // Validate that the triggering event type is being tracked
+        if (!this.options.events?.includes(event.type)) {
+            return;
+        }
+        if (eventSource instanceof HTMLElement) {
+            const target = eventSource.closest(triggerSelector);
+            if (target) {
+                // Parse event name from the element
+                const eventName = target.getAttribute(eventNameSelector) || DEFAULT_EVENT_NAME;
+                // Parse attributes from the element
+                const elementAttributes = {};
+                const rawElementAttributes = target.getAttribute(attrSelector);
+                rawElementAttributes?.split(/\s*,\s*/).forEach(attr => {
+                    const tmp = attr.trim().split(/\s*:\s*/);
+                    elementAttributes[tmp[0]] = tmp[1];
+                });
+                // Assemble final list of attributes
+                const attributes = Object.assign({
+                    type: event.type,
+                    target: `${target.localName} with id ${target.id}`,
+                }, this.options.attributes, elementAttributes);
+                logger.debug('Recording automatically tracked DOM event', {
+                    eventName,
+                    attributes,
+                });
+                this.eventRecorder(eventName, attributes);
+            }
+        }
+    }
+}
 exports.EventTracker = EventTracker;
-//# sourceMappingURL=EventTracker.js.map

package/lib/trackers/PageViewTracker.d.ts

@@ -1,12 +1,18 @@
-import { pageViewTrackOpts } from '../types';
-export declare class PageViewTracker {
-    private _config;
-    private _tracker;
-    private _hasEnabled;
-    constructor(tracker: any, opts: any);
-    configure(opts?: pageViewTrackOpts): pageViewTrackOpts;
-    private _isSameUrl;
-    private _pageViewTrackDefault;
-    private _trackFunc;
-    private _pageViewTrackSPA;
+import { PageViewTrackingOptions, TrackerEventRecorder, TrackerInterface } from '../types/trackers';
+export declare class PageViewTracker implements TrackerInterface {
+    private trackerActive;
+    private options;
+    private eventRecorder;
+    private spaTrackingActive;
+    private pushStateProxy?;
+    private replaceStateProxy?;
+    private originalPushState;
+    private originalReplaceState;
+    constructor(eventRecorder: TrackerEventRecorder, options?: PageViewTrackingOptions);
+    configure(eventRecorder: TrackerEventRecorder, options?: PageViewTrackingOptions): void;
+    cleanup(): void;
+    private setupSPATracking;
+    private setupMPATracking;
+    private handleLocationChange;
+    private urlHasChanged;
 }

package/lib/trackers/PageViewTracker.js

@@ -2,157 +2,111 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var MethodEmbed_1 = require("../utils/MethodEmbed");
-var core_1 = require("@aws-amplify/core");
-var logger = new core_1.ConsoleLogger('PageViewTracker');
-var PREV_URL_KEY = 'aws-amplify-analytics-prevUrl';
-var getUrl = function () {
-    if (!core_1.browserOrNode().isBrowser)
-        return '';
-    else
-        return window.location.origin + window.location.pathname;
+exports.PageViewTracker = void 0;
+const core_1 = require("@aws-amplify/core");
+const utils_1 = require("@aws-amplify/core/internals/utils");
+const logger = new core_1.ConsoleLogger('PageViewTracker');
+const DEFAULT_EVENT_NAME = 'pageView';
+const DEFAULT_APP_TYPE = 'singlePage';
+const DEFAULT_URL_PROVIDER = () => {
+    return window.location.origin + window.location.pathname;
 };
-var defaultOpts = {
-    enable: false,
-    provider: 'AWSPinpoint',
-    getUrl: getUrl,
-};
-var PageViewTracker = /** @class */ (function () {
-    function PageViewTracker(tracker, opts) {
-        logger.debug('initialize pageview tracker with opts', opts);
-        this._config = Object.assign({}, defaultOpts, opts);
-        this._tracker = tracker;
-        this._hasEnabled = false;
-        this._trackFunc = this._trackFunc.bind(this);
-        if (this._config.type === 'SPA') {
-            this._pageViewTrackSPA();
-        }
-        else {
-            this._pageViewTrackDefault();
+const PREV_URL_STORAGE_KEY = 'aws-amplify-analytics-prevUrl';
+class PageViewTracker {
+    constructor(eventRecorder, options) {
+        this.options = {};
+        this.trackerActive = true;
+        this.eventRecorder = eventRecorder;
+        this.spaTrackingActive = false;
+        this.handleLocationChange = this.handleLocationChange.bind(this);
+        this.configure(eventRecorder, options);
+    }
+    configure(eventRecorder, options) {
+        this.eventRecorder = eventRecorder;
+        // Clean up any existing listeners
+        this.cleanup();
+        // Apply defaults
+        this.options = {
+            appType: options?.appType ?? DEFAULT_APP_TYPE,
+            attributes: options?.attributes ?? undefined,
+            eventName: this.options?.eventName ?? DEFAULT_EVENT_NAME,
+            urlProvider: this.options?.urlProvider ?? DEFAULT_URL_PROVIDER,
+        };
+        // Configure SPA or MPA page view tracking
+        if ((0, utils_1.isBrowser)()) {
+            if (this.options.appType === 'singlePage') {
+                this.setupSPATracking();
+            }
+            else {
+                this.setupMPATracking();
+            }
+            this.trackerActive = true;
         }
     }
-    PageViewTracker.prototype.configure = function (opts) {
-        Object.assign(this._config, opts);
-        // if spa, need to remove those listeners if disabled
-        if (this._config.type === 'SPA') {
-            this._pageViewTrackSPA();
+    cleanup() {
+        // No-op if document listener is not active
+        if (!this.trackerActive) {
+            return;
         }
-        return this._config;
-    };
-    PageViewTracker.prototype._isSameUrl = function () {
-        var prevUrl = sessionStorage.getItem(PREV_URL_KEY);
-        var curUrl = this._config.getUrl();
-        if (prevUrl === curUrl) {
-            logger.debug('the url is same');
-            return true;
+        // Clean up SPA page view listeners
+        if (this.spaTrackingActive) {
+            window.history.pushState = this.originalPushState;
+            window.history.replaceState = this.originalReplaceState;
+            this.pushStateProxy?.revoke();
+            this.replaceStateProxy?.revoke();
+            window.removeEventListener('popstate', this.handleLocationChange);
+            this.spaTrackingActive = false;
         }
-        else
-            return false;
-    };
-    PageViewTracker.prototype._pageViewTrackDefault = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var url, customAttrs, _a, attributes;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!core_1.browserOrNode().isBrowser ||
-                            !window.addEventListener ||
-                            !window.sessionStorage) {
-                            logger.debug('not in the supported web enviroment');
-                            return [2 /*return*/];
-                        }
-                        url = this._config.getUrl();
-                        if (!(typeof this._config.attributes === 'function')) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this._config.attributes()];
-                    case 1:
-                        _a = _b.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        _a = this._config.attributes;
-                        _b.label = 3;
-                    case 3:
-                        customAttrs = _a;
-                        attributes = Object.assign({
-                            url: url,
-                        }, customAttrs);
-                        if (this._config.enable && !this._isSameUrl()) {
-                            this._tracker({
-                                name: this._config.eventName || 'pageView',
-                                attributes: attributes,
-                            }, this._config.provider).catch(function (e) {
-                                logger.debug('Failed to record the page view event', e);
-                            });
-                            sessionStorage.setItem(PREV_URL_KEY, url);
-                        }
-                        return [2 /*return*/];
-                }
+    }
+    setupSPATracking() {
+        if (!this.spaTrackingActive) {
+            // Configure proxies on History APIs
+            this.pushStateProxy = Proxy.revocable(window.history.pushState, {
+                apply: (target, thisArg, args) => {
+                    const proxiedResult = target.apply(thisArg, args);
+                    this.handleLocationChange();
+                    return proxiedResult;
+                },
             });
-        });
-    };
-    PageViewTracker.prototype._trackFunc = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var url, customAttrs, _a, attributes;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!core_1.browserOrNode().isBrowser ||
-                            !window.addEventListener ||
-                            !history.pushState ||
-                            !window.sessionStorage) {
-                            logger.debug('not in the supported web enviroment');
-                            return [2 /*return*/];
-                        }
-                        url = this._config.getUrl();
-                        if (!(typeof this._config.attributes === 'function')) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this._config.attributes()];
-                    case 1:
-                        _a = _b.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        _a = this._config.attributes;
-                        _b.label = 3;
-                    case 3:
-                        customAttrs = _a;
-                        attributes = Object.assign({
-                            url: url,
-                        }, customAttrs);
-                        if (!this._isSameUrl()) {
-                            this._tracker({
-                                name: this._config.eventName || 'pageView',
-                                attributes: attributes,
-                            }, this._config.provider).catch(function (e) {
-                                logger.debug('Failed to record the page view event', e);
-                            });
-                            sessionStorage.setItem(PREV_URL_KEY, url);
-                        }
-                        return [2 /*return*/];
-                }
+            this.replaceStateProxy = Proxy.revocable(window.history.replaceState, {
+                apply: (target, thisArg, args) => {
+                    const proxiedResult = target.apply(thisArg, args);
+                    this.handleLocationChange();
+                    return proxiedResult;
+                },
             });
-        });
-    };
-    PageViewTracker.prototype._pageViewTrackSPA = function () {
-        if (!core_1.browserOrNode().isBrowser ||
-            !window.addEventListener ||
-            !history.pushState) {
-            logger.debug('not in the supported web enviroment');
-            return;
+            this.originalPushState = window.history.pushState;
+            this.originalReplaceState = window.history.replaceState;
+            window.history.pushState = this.pushStateProxy.proxy;
+            window.history.replaceState = this.replaceStateProxy.proxy;
+            window.addEventListener('popstate', this.handleLocationChange);
+            sessionStorage.removeItem(PREV_URL_STORAGE_KEY);
+            this.spaTrackingActive = true;
         }
-        if (this._config.enable && !this._hasEnabled) {
-            MethodEmbed_1.MethodEmbed.add(history, 'pushState', this._trackFunc);
-            MethodEmbed_1.MethodEmbed.add(history, 'replaceState', this._trackFunc);
-            window.addEventListener('popstate', this._trackFunc);
-            this._trackFunc();
-            this._hasEnabled = true;
-        }
-        else {
-            MethodEmbed_1.MethodEmbed.remove(history, 'pushState');
-            MethodEmbed_1.MethodEmbed.remove(history, 'replaceState');
-            window.removeEventListener('popstate', this._trackFunc);
-            this._hasEnabled = false;
+    }
+    setupMPATracking() {
+        this.handleLocationChange();
+    }
+    handleLocationChange() {
+        const currentUrl = this.options.urlProvider();
+        const eventName = this.options.eventName || DEFAULT_EVENT_NAME;
+        if (this.urlHasChanged()) {
+            sessionStorage.setItem(PREV_URL_STORAGE_KEY, currentUrl);
+            // Assemble attribute list
+            const attributes = Object.assign({
+                url: currentUrl,
+            }, this.options.attributes);
+            logger.debug('Recording automatically tracked page view event', {
+                eventName,
+                attributes,
+            });
+            this.eventRecorder(eventName, attributes);
         }
-    };
-    return PageViewTracker;
-}());
+    }
+    urlHasChanged() {
+        const prevUrl = sessionStorage.getItem(PREV_URL_STORAGE_KEY);
+        const currUrl = this.options.urlProvider();
+        return currUrl !== prevUrl;
+    }
+}
 exports.PageViewTracker = PageViewTracker;
-//# sourceMappingURL=PageViewTracker.js.map

package/lib/trackers/SessionTracker.d.ts

@@ -1,14 +1,13 @@
-import { SessionTrackOpts } from '../types';
-export declare class SessionTracker {
-    private _tracker;
-    private _hasEnabled;
-    private _config;
-    private _hidden;
-    private _visibilityChange;
-    constructor(tracker: any, opts: any);
-    private _envCheck;
-    private _trackFunc;
-    private _trackBeforeUnload;
-    private _sendInitialEvent;
-    configure(opts?: SessionTrackOpts): SessionTrackOpts;
+import { SessionTrackingOptions, TrackerEventRecorder, TrackerInterface } from '../types/trackers';
+export declare class SessionTracker implements TrackerInterface {
+    private options;
+    private eventRecorder;
+    private sessionTrackingActive;
+    private initialEventSent;
+    constructor(eventRecorder: TrackerEventRecorder, options?: SessionTrackingOptions);
+    configure(eventRecorder: TrackerEventRecorder, options?: SessionTrackingOptions): void;
+    cleanup(): void;
+    private handleStateChange;
+    private sessionStarted;
+    private sessionStopped;
 }