@aws-amplify/analytics 7.0.1-api-v6-models.9351bcf.0 → 7.0.1-api-v6-models.891fe0d.0

package/lib-esm/providers/personalize/utils/autoTrackMedia.js

@@ -1,6 +1,5 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __assign, __awaiter, __generator, __rest } from "tslib";
 import { isBrowser } from '@aws-amplify/core/internals/utils';
 import { ConsoleLogger } from '@aws-amplify/core';
 var HTML5_MEDIA_EVENT;
@@ -22,43 +21,43 @@ var EVENT_TYPE;
     EVENT_TYPE["PAUSE"] = "Pause";
     EVENT_TYPE["TIME_WATCHED"] = "TimeWatched";
 })(EVENT_TYPE || (EVENT_TYPE = {}));
-var logger = new ConsoleLogger('MediaAutoTrack');
-var startIframeAutoTracking = function (element, recordEvent) {
-    var isPlaying = false;
-    var player;
-    var mediaProperties = function () {
-        var duration = Number(parseFloat(player.getDuration()).toFixed(4));
-        var currentTime = Number(parseFloat(player.getCurrentTime()).toFixed(4));
+const logger = new ConsoleLogger('MediaAutoTrack');
+const startIframeAutoTracking = (element, recordEvent) => {
+    let isPlaying = false;
+    let player;
+    const mediaProperties = () => {
+        const duration = Number(parseFloat(player.getDuration()).toFixed(4));
+        const currentTime = Number(parseFloat(player.getCurrentTime()).toFixed(4));
         return {
-            duration: duration,
+            duration,
             eventValue: Number((currentTime / duration).toFixed(4)),
         };
     };
-    var scriptElement = document.createElement('script');
+    const scriptElement = document.createElement('script');
     scriptElement.type = 'text/javascript';
     scriptElement.src = 'https://www.youtube.com/iframe_api';
     document.body.append(scriptElement);
-    var timer = setInterval(function () {
+    const timer = setInterval(() => {
         if (isPlaying && player) {
             recordEvent(EVENT_TYPE.TIME_WATCHED, mediaProperties());
         }
     }, 3000);
-    element.addEventListener('unload', function () { return clearInterval(timer); });
+    element.addEventListener('unload', () => clearInterval(timer));
     // @ts-ignore
-    window.onYouTubeIframeAPIReady = function () {
+    window.onYouTubeIframeAPIReady = () => {
         // @ts-ignore
         delete window.onYouTubeIframeAPIReady;
         // @ts-ignore
         player = new window.YT.Player(element.id, {
             events: {
-                onStateChange: function (event) {
-                    var iframeEventMapping = {
+                onStateChange: (event) => {
+                    const iframeEventMapping = {
                         0: EVENT_TYPE.ENDED,
                         1: EVENT_TYPE.PLAY,
                         2: EVENT_TYPE.PAUSE,
                     };
                     // @ts-ignore
-                    var eventType = iframeEventMapping[event.data];
+                    const eventType = iframeEventMapping[event.data];
                     switch (eventType) {
                         case EVENT_TYPE.ENDED:
                         case EVENT_TYPE.PAUSE:
@@ -76,104 +75,103 @@ var startIframeAutoTracking = function (element, recordEvent) {
         });
     };
 };
-var startHTMLMediaAutoTracking = function (element, recordEvent) {
-    var isPlaying = false;
-    var mediaProperties = function () { return ({
+const startHTMLMediaAutoTracking = (element, recordEvent) => {
+    let isPlaying = false;
+    const mediaProperties = () => ({
         duration: element.duration,
         eventValue: Number((element.currentTime / element.duration).toFixed(4)),
-    }); };
-    var timer = setInterval(function () {
+    });
+    const timer = setInterval(() => {
         if (isPlaying) {
             recordEvent(EVENT_TYPE.TIME_WATCHED, mediaProperties());
         }
     }, 3000);
-    element.addEventListener('unload', function () { return clearInterval(timer); });
-    element.addEventListener(HTML5_MEDIA_EVENT.PLAY, function () {
+    element.addEventListener('unload', () => clearInterval(timer));
+    element.addEventListener(HTML5_MEDIA_EVENT.PLAY, () => {
         isPlaying = true;
         recordEvent(EVENT_TYPE.PLAY, mediaProperties());
     });
-    element.addEventListener(HTML5_MEDIA_EVENT.PAUSE, function () {
+    element.addEventListener(HTML5_MEDIA_EVENT.PAUSE, () => {
         isPlaying = false;
         recordEvent(EVENT_TYPE.PAUSE, mediaProperties());
     });
-    element.addEventListener(HTML5_MEDIA_EVENT.ENDED, function () {
+    element.addEventListener(HTML5_MEDIA_EVENT.ENDED, () => {
         isPlaying = false;
         recordEvent(EVENT_TYPE.ENDED, mediaProperties());
     });
 };
-var checkElementLoaded = function (interval, maxTries) {
-    var retryCount = 0;
-    var wait = function () { return new Promise(function (r) { return setTimeout(r, interval); }); };
-    var check = function (elementId) { return __awaiter(void 0, void 0, void 0, function () {
-        var domElement;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (retryCount >= maxTries) {
-                        return [2 /*return*/, false];
-                    }
-                    domElement = document.getElementById(elementId);
-                    if (!(domElement && domElement.clientHeight)) return [3 /*break*/, 1];
-                    return [2 /*return*/, true];
-                case 1:
-                    retryCount += 1;
-                    return [4 /*yield*/, wait()];
-                case 2:
-                    _a.sent();
-                    return [4 /*yield*/, check(elementId)];
-                case 3: return [2 /*return*/, _a.sent()];
-            }
-        });
-    }); };
+const checkElementLoaded = (interval, maxTries) => {
+    let retryCount = 0;
+    const wait = () => new Promise(r => setTimeout(r, interval));
+    const check = async (elementId) => {
+        if (retryCount >= maxTries) {
+            return false;
+        }
+        const domElement = document.getElementById(elementId);
+        if (domElement && domElement.clientHeight) {
+            return true;
+        }
+        else {
+            retryCount += 1;
+            await wait();
+            return await check(elementId);
+        }
+    };
     return check;
 };
-var recordEvent = function (config, eventBuffer) {
-    return function (eventType, properties) {
-        // override eventType and merge properties
-        eventBuffer.append(__assign(__assign({}, config), { event: __assign(__assign({}, config.event), { eventType: eventType, properties: __assign(__assign({}, config.event.properties), properties) }), timestamp: Date.now() }));
-    };
+const recordEvent = (config, eventBuffer) => (eventType, properties) => {
+    // override eventType and merge properties
+    eventBuffer.append({
+        ...config,
+        event: {
+            ...config.event,
+            eventType,
+            properties: {
+                ...config.event.properties,
+                ...properties,
+            },
+        },
+        timestamp: Date.now(),
+    });
 };
-export var autoTrackMedia = function (config, eventBuffer) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, eventType, properties, domElementId, otherProperties, elementId, isElementLoaded, autoTrackConfigWithoutDomElementId, element;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                _a = config.event, eventType = _a.eventType, properties = _a.properties;
-                domElementId = properties.domElementId, otherProperties = __rest(properties, ["domElementId"]);
-                if (!isBrowser()) {
-                    logger.debug("".concat(eventType, " only for browser"));
-                    return [2 /*return*/];
-                }
-                if (typeof domElementId === 'string' && !domElementId) {
-                    logger.debug("Missing domElementId field in 'properties' for MediaAutoTrack event type.");
-                    return [2 /*return*/];
-                }
-                elementId = domElementId;
-                return [4 /*yield*/, checkElementLoaded(500, 5)(elementId)];
-            case 1:
-                isElementLoaded = _b.sent();
-                if (isElementLoaded) {
-                    autoTrackConfigWithoutDomElementId = __assign(__assign({}, config), { event: __assign(__assign({}, config.event), { properties: otherProperties }) });
-                    element = document.getElementById(elementId);
-                    switch (element === null || element === void 0 ? void 0 : element.tagName) {
-                        case MEDIA_TYPE.IFRAME:
-                            startIframeAutoTracking(element, recordEvent(autoTrackConfigWithoutDomElementId, eventBuffer));
-                            break;
-                        case MEDIA_TYPE.VIDEO:
-                        case MEDIA_TYPE.AUDIO:
-                            if (element instanceof HTMLMediaElement) {
-                                startHTMLMediaAutoTracking(element, recordEvent(autoTrackConfigWithoutDomElementId, eventBuffer));
-                            }
-                            break;
-                        default:
-                            logger.debug("Unsupported DOM element tag: ".concat(element === null || element === void 0 ? void 0 : element.tagName));
-                            break;
-                    }
-                }
-                else {
-                    logger.debug('Cannot find the media element.');
+export const autoTrackMedia = async (config, eventBuffer) => {
+    const { eventType, properties } = config.event;
+    const { domElementId, ...otherProperties } = properties;
+    if (!isBrowser()) {
+        logger.debug(`${eventType} only for browser`);
+        return;
+    }
+    if (typeof domElementId === 'string' && !domElementId) {
+        logger.debug("Missing domElementId field in 'properties' for MediaAutoTrack event type.");
+        return;
+    }
+    const elementId = domElementId;
+    const isElementLoaded = await checkElementLoaded(500, 5)(elementId);
+    if (isElementLoaded) {
+        const autoTrackConfigWithoutDomElementId = {
+            ...config,
+            event: {
+                ...config.event,
+                properties: otherProperties,
+            },
+        };
+        const element = document.getElementById(elementId);
+        switch (element?.tagName) {
+            case MEDIA_TYPE.IFRAME:
+                startIframeAutoTracking(element, recordEvent(autoTrackConfigWithoutDomElementId, eventBuffer));
+                break;
+            case MEDIA_TYPE.VIDEO:
+            case MEDIA_TYPE.AUDIO:
+                if (element instanceof HTMLMediaElement) {
+                    startHTMLMediaAutoTracking(element, recordEvent(autoTrackConfigWithoutDomElementId, eventBuffer));
                 }
-                return [2 /*return*/];
+                break;
+            default:
+                logger.debug(`Unsupported DOM element tag: ${element?.tagName}`);
+                break;
         }
-    });
-}); };
+    }
+    else {
+        logger.debug('Cannot find the media element.');
+    }
+};

package/lib-esm/providers/personalize/utils/cachedSession.js

@@ -1,52 +1,40 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __awaiter, __generator } from "tslib";
 import { Cache } from '@aws-amplify/core';
 import { isBrowser, amplifyUuid } from '@aws-amplify/core/internals/utils';
-var PERSONALIZE_CACHE_USERID = '_awsct_uid';
-var PERSONALIZE_CACHE_SESSIONID = '_awsct_sid';
-var DEFAULT_CACHE_PREFIX = 'personalize';
-var DELIMITER = '.';
-var CACHE_EXPIRY_IN_DAYS = 7;
-var normalize = function (key) {
-    return [key, isBrowser() ? window.location.host : DEFAULT_CACHE_PREFIX].join(DELIMITER);
-};
-var getCache = function (key) { return Cache.getItem(normalize(key)); };
-var setCache = function (key, value) {
-    var expiredAt = new Date(Date.now() + 3600000 * 24 * CACHE_EXPIRY_IN_DAYS);
+const PERSONALIZE_CACHE_USERID = '_awsct_uid';
+const PERSONALIZE_CACHE_SESSIONID = '_awsct_sid';
+const DEFAULT_CACHE_PREFIX = 'personalize';
+const DELIMITER = '.';
+const CACHE_EXPIRY_IN_DAYS = 7;
+const normalize = (key) => [key, isBrowser() ? window.location.host : DEFAULT_CACHE_PREFIX].join(DELIMITER);
+const getCache = (key) => Cache.getItem(normalize(key));
+const setCache = (key, value) => {
+    const expiredAt = new Date(Date.now() + 3600000 * 24 * CACHE_EXPIRY_IN_DAYS);
     Cache.setItem(normalize(key), value, {
         expires: expiredAt.getTime(),
     });
 };
-export var resolveCachedSession = function () { return __awaiter(void 0, void 0, void 0, function () {
-    var sessionId, userId;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, getCache(PERSONALIZE_CACHE_SESSIONID)];
-            case 1:
-                sessionId = _a.sent();
-                if (!sessionId) {
-                    sessionId = amplifyUuid();
-                    setCache(PERSONALIZE_CACHE_SESSIONID, sessionId);
-                }
-                return [4 /*yield*/, getCache(PERSONALIZE_CACHE_USERID)];
-            case 2:
-                userId = _a.sent();
-                return [2 /*return*/, {
-                        sessionId: sessionId,
-                        userId: userId,
-                    }];
-        }
-    });
-}); };
-export var updateCachedSession = function (newUserId, currentSessionId, currentUserId) {
-    var isNoCachedSession = !currentSessionId;
-    var isSignOutCase = !newUserId && !currentUserId;
-    var isSwitchUserCase = !!newUserId && !!currentUserId && newUserId !== currentUserId;
-    var isRequireNewSession = isNoCachedSession || isSignOutCase || isSwitchUserCase;
-    var isRequireUpdateSession = !!currentSessionId && !currentUserId && !!newUserId;
+export const resolveCachedSession = async () => {
+    let sessionId = await getCache(PERSONALIZE_CACHE_SESSIONID);
+    if (!sessionId) {
+        sessionId = amplifyUuid();
+        setCache(PERSONALIZE_CACHE_SESSIONID, sessionId);
+    }
+    const userId = await getCache(PERSONALIZE_CACHE_USERID);
+    return {
+        sessionId,
+        userId,
+    };
+};
+export const updateCachedSession = (newUserId, currentSessionId, currentUserId) => {
+    const isNoCachedSession = !currentSessionId;
+    const isSignOutCase = !newUserId && !currentUserId;
+    const isSwitchUserCase = !!newUserId && !!currentUserId && newUserId !== currentUserId;
+    const isRequireNewSession = isNoCachedSession || isSignOutCase || isSwitchUserCase;
+    const isRequireUpdateSession = !!currentSessionId && !currentUserId && !!newUserId;
     if (isRequireNewSession) {
-        var newSessionId = amplifyUuid();
+        const newSessionId = amplifyUuid();
         setCache(PERSONALIZE_CACHE_SESSIONID, newSessionId);
         setCache(PERSONALIZE_CACHE_USERID, newUserId);
     }

package/lib-esm/providers/personalize/utils/constants.js

@@ -1,9 +1,9 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export var DEFAULT_PERSONALIZE_CONFIG = {
+export const DEFAULT_PERSONALIZE_CONFIG = {
     flushSize: 5,
     flushInterval: 5000,
 };
-export var PERSONALIZE_FLUSH_SIZE_MAX = 10;
-export var IDENTIFY_EVENT_TYPE = 'Identify';
-export var MEDIA_AUTO_TRACK_EVENT_TYPE = 'MediaAutoTrack';
+export const PERSONALIZE_FLUSH_SIZE_MAX = 10;
+export const IDENTIFY_EVENT_TYPE = 'Identify';
+export const MEDIA_AUTO_TRACK_EVENT_TYPE = 'MediaAutoTrack';

package/lib-esm/providers/personalize/utils/getEventBuffer.js

@@ -1,6 +1,5 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __awaiter, __generator, __read, __values } from "tslib";
 import { EventBuffer, groupBy } from '../../../utils';
 import { PersonalizeEventsClient, PutEventsCommand, } from '@aws-sdk/client-personalize-events';
 /**
@@ -11,85 +10,59 @@ import { PersonalizeEventsClient, PutEventsCommand, } from '@aws-sdk/client-pers
  * Only one active session should exist at any given moment.
  * When a new session is initiated, the previous ones should be released.
  * */
-var eventBufferMap = {};
-var cachedClients = {};
-var DELIMITER = '#';
-var createPutEventsCommand = function (ids, events) {
-    var _a = __read(ids.split(DELIMITER), 3), trackingId = _a[0], sessionId = _a[1], userId = _a[2];
+const eventBufferMap = {};
+const cachedClients = {};
+const DELIMITER = '#';
+const createPutEventsCommand = (ids, events) => {
+    const [trackingId, sessionId, userId] = ids.split(DELIMITER);
     return new PutEventsCommand({
-        trackingId: trackingId,
-        sessionId: sessionId,
-        userId: userId,
-        eventList: events.map(function (event) { return ({
+        trackingId,
+        sessionId,
+        userId,
+        eventList: events.map(event => ({
             eventId: event.event.eventId,
             eventType: event.event.eventType,
             properties: JSON.stringify(event.event.properties),
             sentAt: new Date(event.timestamp),
-        }); }),
+        })),
     });
 };
-var submitEvents = function (events, client) { return __awaiter(void 0, void 0, void 0, function () {
-    var groupedByIds, requests;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                groupedByIds = Object.entries(groupBy(function (event) {
-                    return [event.trackingId, event.sessionId, event.userId]
-                        .filter(function (id) { return !!id; })
-                        .join(DELIMITER);
-                }, events));
-                requests = groupedByIds
-                    .map(function (_a) {
-                    var _b = __read(_a, 2), ids = _b[0], events = _b[1];
-                    return createPutEventsCommand(ids, events);
-                })
-                    .map(function (command) { return client.send(command); });
-                return [4 /*yield*/, Promise.allSettled(requests)];
-            case 1:
-                _a.sent();
-                return [2 /*return*/, Promise.resolve([])];
-        }
-    });
-}); };
-export var getEventBuffer = function (_a) {
-    var e_1, _b;
-    var region = _a.region, flushSize = _a.flushSize, flushInterval = _a.flushInterval, bufferSize = _a.bufferSize, credentials = _a.credentials, identityId = _a.identityId, userAgentValue = _a.userAgentValue;
-    var sessionToken = credentials.sessionToken;
-    var sessionIdentityKey = [region, sessionToken, identityId]
-        .filter(function (x) { return !!x; })
-        .join('-');
+const submitEvents = async (events, client) => {
+    const groupedByIds = Object.entries(groupBy(event => [event.trackingId, event.sessionId, event.userId]
+        .filter(id => !!id)
+        .join(DELIMITER), events));
+    const requests = groupedByIds
+        .map(([ids, events]) => createPutEventsCommand(ids, events))
+        .map(command => client.send(command));
+    await Promise.allSettled(requests);
+    return Promise.resolve([]);
+};
+export const getEventBuffer = ({ region, flushSize, flushInterval, bufferSize, credentials, identityId, userAgentValue, }) => {
+    const sessionIdentityKey = [region, identityId].filter(x => !!x).join('-');
     if (!eventBufferMap[sessionIdentityKey]) {
-        var getClient = function () {
+        const getClient = () => {
             if (!cachedClients[sessionIdentityKey]) {
                 cachedClients[sessionIdentityKey] = new PersonalizeEventsClient({
-                    region: region,
-                    credentials: credentials,
+                    region,
+                    credentials,
                     customUserAgent: userAgentValue,
                 });
             }
-            return function (events) { return submitEvents(events, cachedClients[sessionIdentityKey]); };
+            return events => submitEvents(events, cachedClients[sessionIdentityKey]);
         };
         eventBufferMap[sessionIdentityKey] =
             new EventBuffer({
-                bufferSize: bufferSize,
-                flushSize: flushSize,
-                flushInterval: flushInterval,
+                bufferSize,
+                flushSize,
+                flushInterval,
             }, getClient);
-        var releaseSessionKeys = Object.keys(eventBufferMap).filter(function (key) { return key !== sessionIdentityKey; });
-        try {
-            for (var releaseSessionKeys_1 = __values(releaseSessionKeys), releaseSessionKeys_1_1 = releaseSessionKeys_1.next(); !releaseSessionKeys_1_1.done; releaseSessionKeys_1_1 = releaseSessionKeys_1.next()) {
-                var releaseSessionKey = releaseSessionKeys_1_1.value;
+        const releaseSessionKeys = Object.keys(eventBufferMap).filter(key => key !== sessionIdentityKey);
+        for (const releaseSessionKey of releaseSessionKeys) {
+            eventBufferMap[releaseSessionKey].flushAll().finally(() => {
                 eventBufferMap[releaseSessionKey].release();
                 delete eventBufferMap[releaseSessionKey];
                 delete cachedClients[releaseSessionKey];
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (releaseSessionKeys_1_1 && !releaseSessionKeys_1_1.done && (_b = releaseSessionKeys_1.return)) _b.call(releaseSessionKeys_1);
-            }
-            finally { if (e_1) throw e_1.error; }
+            });
         }
     }
     return eventBufferMap[sessionIdentityKey];

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

@@ -1,21 +1,22 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __assign } from "tslib";
 import { Amplify } from '@aws-amplify/core';
 import { AnalyticsValidationErrorCode, assertValidationError, } from '../../../errors';
 import { DEFAULT_PERSONALIZE_CONFIG, PERSONALIZE_FLUSH_SIZE_MAX } from './';
-export var resolveConfig = function () {
-    var _a;
-    var config = (_a = Amplify.getConfig().Analytics) === null || _a === void 0 ? void 0 : _a.Personalize;
-    var _b = __assign(__assign({}, DEFAULT_PERSONALIZE_CONFIG), config), region = _b.region, trackingId = _b.trackingId, _c = _b.flushSize, flushSize = _c === void 0 ? DEFAULT_PERSONALIZE_CONFIG.flushSize : _c, _d = _b.flushInterval, flushInterval = _d === void 0 ? DEFAULT_PERSONALIZE_CONFIG.flushInterval : _d;
+export const resolveConfig = () => {
+    const config = Amplify.getConfig().Analytics?.Personalize;
+    const { region, trackingId, flushSize = DEFAULT_PERSONALIZE_CONFIG.flushSize, flushInterval = DEFAULT_PERSONALIZE_CONFIG.flushInterval, } = {
+        ...DEFAULT_PERSONALIZE_CONFIG,
+        ...config,
+    };
     assertValidationError(!!region, AnalyticsValidationErrorCode.NoRegion);
     assertValidationError(!!trackingId, AnalyticsValidationErrorCode.NoTrackingId);
-    assertValidationError(flushSize <= PERSONALIZE_FLUSH_SIZE_MAX, AnalyticsValidationErrorCode.InvalidFlushSize, "FlushSize for Personalize should be less or equal than ".concat(PERSONALIZE_FLUSH_SIZE_MAX));
+    assertValidationError(flushSize <= PERSONALIZE_FLUSH_SIZE_MAX, AnalyticsValidationErrorCode.InvalidFlushSize, `FlushSize for Personalize should be less or equal than ${PERSONALIZE_FLUSH_SIZE_MAX}`);
     return {
-        region: region,
-        trackingId: trackingId,
+        region,
+        trackingId,
         bufferSize: flushSize + 1,
-        flushSize: flushSize,
-        flushInterval: flushInterval,
+        flushSize,
+        flushInterval,
     };
 };

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

@@ -3,12 +3,12 @@
 import { updateProviderTrackers, validateTrackerConfiguration, } from '../../../utils';
 import { record } from './record';
 // Configured Tracker instances for Pinpoint
-var configuredTrackers = {};
+const configuredTrackers = {};
 // Callback that will emit an appropriate event to Pinpoint when required by the Tracker
-var emitTrackingEvent = function (eventName, attributes) {
+const emitTrackingEvent = (eventName, attributes) => {
     record({
         name: eventName,
-        attributes: attributes,
+        attributes,
     });
 };
 /**
@@ -24,7 +24,7 @@ var emitTrackingEvent = function (eventName, attributes) {
  * @throws validation: {@link AnalyticsValidationErrorCode} - Thrown when the provided parameters or library
  *  configuration is incorrect.
  */
-export var configureAutoTrack = function (input) {
+export const configureAutoTrack = (input) => {
     validateTrackerConfiguration(input);
     // Initialize or update this provider's trackers
     updateProviderTrackers(input, emitTrackingEvent, configuredTrackers);

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

@@ -5,7 +5,7 @@ import { flushEvents as flushEventsCore } from '@aws-amplify/core/internals/prov
 import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
 import { ConsoleLogger } from '@aws-amplify/core';
 import { getAnalyticsUserAgentString } from '../../../utils';
-var logger = new ConsoleLogger('Analytics');
+const logger = new ConsoleLogger('Analytics');
 /**
  * Flushes all buffered Pinpoint events to the service.
  *
@@ -13,12 +13,9 @@ var logger = new ConsoleLogger('Analytics');
  * This API will make a best-effort attempt to flush events from the buffer. Events recorded immediately after invoking
  * this API may not be included in the flush.
  */
-export var flushEvents = function () {
-    var _a = resolveConfig(), appId = _a.appId, region = _a.region;
+export const flushEvents = () => {
+    const { appId, region } = resolveConfig();
     resolveCredentials()
-        .then(function (_a) {
-        var credentials = _a.credentials, identityId = _a.identityId;
-        return flushEventsCore(appId, region, credentials, identityId, getAnalyticsUserAgentString(AnalyticsAction.Record));
-    })
-        .catch(function (e) { return logger.warn('Failed to flush events', e); });
+        .then(({ credentials, identityId }) => flushEventsCore(appId, region, credentials, identityId, getAnalyticsUserAgentString(AnalyticsAction.Record)))
+        .catch(e => logger.warn('Failed to flush events', e));
 };

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

@@ -1,6 +1,5 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __awaiter, __generator } from "tslib";
 import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
 import { updateEndpoint, } from '@aws-amplify/core/internals/providers/pinpoint';
 import { getAnalyticsUserAgentString } from '../../../utils';
@@ -50,30 +49,19 @@ import { resolveConfig, resolveCredentials } from '../utils';
  *     }
  * });
  */
-export var identifyUser = function (_a) {
-    var userId = _a.userId, userProfile = _a.userProfile, options = _a.options;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var _b, credentials, identityId, _c, appId, region, userAttributes;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0: return [4 /*yield*/, resolveCredentials()];
-                case 1:
-                    _b = _d.sent(), credentials = _b.credentials, identityId = _b.identityId;
-                    _c = resolveConfig(), appId = _c.appId, region = _c.region;
-                    userAttributes = (options !== null && options !== void 0 ? options : {}).userAttributes;
-                    updateEndpoint({
-                        appId: appId,
-                        category: 'Analytics',
-                        credentials: credentials,
-                        identityId: identityId,
-                        region: region,
-                        userAttributes: userAttributes,
-                        userId: userId,
-                        userProfile: userProfile,
-                        userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.IdentifyUser),
-                    });
-                    return [2 /*return*/];
-            }
-        });
+export const identifyUser = async ({ userId, userProfile, options, }) => {
+    const { credentials, identityId } = await resolveCredentials();
+    const { appId, region } = resolveConfig();
+    const { userAttributes } = options ?? {};
+    updateEndpoint({
+        appId,
+        category: 'Analytics',
+        credentials,
+        identityId,
+        region,
+        userAttributes,
+        userId,
+        userProfile,
+        userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.IdentifyUser),
     });
 };