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

package/lib-esm/providers/pinpoint/apis/record.js

@@ -0,0 +1,62 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Hub, ConsoleLogger } from '@aws-amplify/core';
+import { AMPLIFY_SYMBOL, AnalyticsAction, } from '@aws-amplify/core/internals/utils';
+import { record as recordCore } from '@aws-amplify/core/internals/providers/pinpoint';
+import { AnalyticsValidationErrorCode, assertValidationError, } from '../../../errors';
+import { getAnalyticsUserAgentString, isAnalyticsEnabled, } from '../../../utils';
+import { resolveConfig, resolveCredentials } from '../utils';
+const logger = new ConsoleLogger('Analytics');
+/**
+ * Records an Analytic event to Pinpoint. Events will be buffered and periodically sent to Pinpoint.
+ *
+ * @param {RecordInput} params The input object used to construct the request.
+ *
+ * @throws validation: {@link AnalyticsValidationErrorCode} - Thrown when the provided parameters or library
+ *  configuration is incorrect.
+ *
+ * @example
+ * ```ts
+ * // Send an event to Pinpoint
+ * record({ name: eventName })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Send an event to Pinpoint with metrics & custom attributes
+ * record({
+ *     name: eventName,
+ *     attributes: {
+ *         'my-attribute': attributeValue
+ *     },
+ *     metrics: {
+ *         'my-metric': metricValue
+ *     }
+ * })
+ * ```
+ */
+export const record = (input) => {
+    const { appId, region } = resolveConfig();
+    if (!isAnalyticsEnabled()) {
+        logger.debug('Analytics is disabled, event will not be recorded.');
+        return;
+    }
+    assertValidationError(!!input.name, AnalyticsValidationErrorCode.NoEventName);
+    resolveCredentials()
+        .then(({ credentials, identityId }) => {
+        Hub.dispatch('analytics', { event: 'record', data: input, message: 'Recording Analytics event' }, 'Analytics', AMPLIFY_SYMBOL);
+        recordCore({
+            appId,
+            category: 'Analytics',
+            credentials,
+            event: input,
+            identityId,
+            region,
+            userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
+        });
+    })
+        .catch(e => {
+        // An error occured while fetching credentials or persisting the event to the buffer
+        logger.warn('Failed to record event.', e);
+    });
+};

package/lib-esm/providers/pinpoint/index.d.ts

@@ -0,0 +1,2 @@
+export { record, identifyUser, flushEvents, configureAutoTrack } from './apis';
+export { RecordInput, IdentifyUserInput, ConfigureAutoTrackInput, } from './types/inputs';

package/lib-esm/providers/pinpoint/index.js

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { record, identifyUser, flushEvents, configureAutoTrack } from './apis';

package/lib-esm/providers/pinpoint/types/index.d.ts

@@ -0,0 +1,2 @@
+export { RecordInput, IdentifyUserInput, ConfigureAutoTrackInput, } from './inputs';
+export { IdentifyUserOptions } from './options';

package/lib-esm/providers/pinpoint/types/index.js

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export {};

package/lib-esm/providers/pinpoint/types/inputs.d.ts

@@ -0,0 +1,15 @@
+import { PinpointAnalyticsEvent } from '@aws-amplify/core/internals/providers/pinpoint';
+import { IdentifyUserOptions } from '.';
+import { AnalyticsConfigureAutoTrackInput, AnalyticsIdentifyUserInput } from '../../../types';
+/**
+ * Input type for Pinpoint record API.
+ */
+export type RecordInput = PinpointAnalyticsEvent;
+/**
+ * Input type for Pinpoint identifyUser API.
+ */
+export type IdentifyUserInput = AnalyticsIdentifyUserInput<IdentifyUserOptions>;
+/**
+ * Input type for Pinpoint configureAutoTrack API.
+ */
+export type ConfigureAutoTrackInput = AnalyticsConfigureAutoTrackInput;

package/lib-esm/providers/pinpoint/types/inputs.js

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export {};

package/lib-esm/providers/pinpoint/types/options.d.ts

@@ -0,0 +1,5 @@
+import { PinpointServiceOptions } from '@aws-amplify/core/internals/providers/pinpoint';
+/**
+ * Options specific to Pinpoint identityUser.
+ */
+export type IdentifyUserOptions = Pick<PinpointServiceOptions, 'userAttributes'>;

package/lib-esm/providers/pinpoint/types/options.js

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export {};

package/lib-esm/providers/pinpoint/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { resolveConfig } from './resolveConfig';
+export { resolveCredentials } from './resolveCredentials';

package/lib-esm/providers/pinpoint/utils/index.js

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { resolveConfig } from './resolveConfig';
+export { resolveCredentials } from './resolveCredentials';

package/lib-esm/providers/pinpoint/utils/resolveConfig.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @internal
+ */
+export declare const resolveConfig: () => {
+    appId: string;
+    region: string;
+};

package/lib-esm/providers/pinpoint/utils/resolveConfig.js

@@ -0,0 +1,13 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Amplify } from '@aws-amplify/core';
+import { AnalyticsValidationErrorCode, assertValidationError, } from '../../../errors';
+/**
+ * @internal
+ */
+export const resolveConfig = () => {
+    const { appId, region } = Amplify.getConfig().Analytics?.Pinpoint ?? {};
+    assertValidationError(!!appId, AnalyticsValidationErrorCode.NoAppId);
+    assertValidationError(!!region, AnalyticsValidationErrorCode.NoRegion);
+    return { appId, region };
+};

package/lib-esm/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-esm/providers/pinpoint/utils/resolveCredentials.js

@@ -0,0 +1,12 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { fetchAuthSession } from '@aws-amplify/core';
+import { AnalyticsValidationErrorCode, assertValidationError, } from '../../../errors';
+/**
+ * @internal
+ */
+export const resolveCredentials = async () => {
+    const { credentials, identityId } = await fetchAuthSession();
+    assertValidationError(!!credentials, AnalyticsValidationErrorCode.NoCredentials);
+    return { credentials, identityId };
+};

package/lib-esm/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-esm/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-esm/trackers/EventTracker.js

@@ -1,97 +1,94 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __awaiter, __generator } from "tslib";
-import { delegate } from '../vendor/dom-utils';
-import { ConsoleLogger as Logger, browserOrNode } from '@aws-amplify/core';
-var logger = new Logger('EventTracker');
-var defaultOpts = {
-    enable: false,
-    events: ['click'],
-    selectorPrefix: 'data-amplify-analytics-',
-    provider: 'AWSPinpoint',
-};
-var EventTracker = /** @class */ (function () {
-    function EventTracker(tracker, opts) {
-        if (!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);
+import { ConsoleLogger } from '@aws-amplify/core';
+import { isBrowser } from '@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 ConsoleLogger('EventTracker');
+export 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 (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] = 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 __awaiter(this, void 0, void 0, function () {
-            var customAttrs, events, eventName, attrs, defaultAttrs, _a, attributes;
-            return __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;
-}());
-export { EventTracker };
-//# sourceMappingURL=EventTracker.js.map
+    }
+    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);
+            }
+        }
+    }
+}

package/lib-esm/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;
 }