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

package/lib/providers/kinesis-firehose/utils/getEventBuffer.js

@@ -3,9 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEventBuffer = void 0;
-var tslib_1 = require("tslib");
-var utils_1 = require("../../../utils");
-var client_firehose_1 = require("@aws-sdk/client-firehose");
+const utils_1 = require("../../../utils");
+const client_firehose_1 = require("@aws-sdk/client-firehose");
 /**
  * These Records hold cached event buffers and AWS clients.
  * The hash key is determined by the region and session,
@@ -14,85 +13,57 @@ var client_firehose_1 = require("@aws-sdk/client-firehose");
  * 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 createPutRecordsBatchCommand = function (streamName, events) {
-    return new client_firehose_1.PutRecordBatchCommand({
-        DeliveryStreamName: streamName,
-        Records: events.map(function (event) { return ({
-            Data: event.event,
-        }); }),
-    });
+const eventBufferMap = {};
+const cachedClients = {};
+const createPutRecordsBatchCommand = (streamName, events) => new client_firehose_1.PutRecordBatchCommand({
+    DeliveryStreamName: streamName,
+    Records: events.map(event => ({
+        Data: event.event,
+    })),
+});
+const submitEvents = async (events, client, resendLimit) => {
+    const groupedByStreamName = Object.entries((0, utils_1.groupBy)(event => event.streamName, events));
+    const requests = groupedByStreamName
+        .map(([streamName, events]) => createPutRecordsBatchCommand(streamName, events))
+        .map(command => client.send(command));
+    const responses = await Promise.allSettled(requests);
+    const failedEvents = responses
+        .map((response, i) => response.status === 'rejected' ? groupedByStreamName[i][1] : [])
+        .flat();
+    return resendLimit
+        ? failedEvents
+            .filter(event => event.retryCount < resendLimit)
+            .map(event => ({ ...event, retryCount: event.retryCount + 1 }))
+            .sort((a, b) => a.timestamp - b.timestamp)
+        : [];
 };
-var submitEvents = function (events, client, resendLimit) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-    var groupedByStreamName, requests, responses, failedEvents;
-    return tslib_1.__generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                groupedByStreamName = Object.entries((0, utils_1.groupBy)(function (event) { return event.streamName; }, events));
-                requests = groupedByStreamName
-                    .map(function (_a) {
-                    var _b = tslib_1.__read(_a, 2), streamName = _b[0], events = _b[1];
-                    return createPutRecordsBatchCommand(streamName, events);
-                })
-                    .map(function (command) { return client.send(command); });
-                return [4 /*yield*/, Promise.allSettled(requests)];
-            case 1:
-                responses = _a.sent();
-                failedEvents = responses
-                    .map(function (response, i) {
-                    return response.status === 'rejected' ? groupedByStreamName[i][1] : [];
-                })
-                    .flat();
-                return [2 /*return*/, resendLimit
-                        ? failedEvents
-                            .filter(function (event) { return event.retryCount < resendLimit; })
-                            .map(function (event) { return (tslib_1.__assign(tslib_1.__assign({}, event), { retryCount: event.retryCount + 1 })); })
-                            .sort(function (a, b) { return a.timestamp - b.timestamp; })
-                        : []];
-        }
-    });
-}); };
-var getEventBuffer = function (_a) {
-    var e_1, _b;
-    var region = _a.region, credentials = _a.credentials, identityId = _a.identityId, bufferSize = _a.bufferSize, flushSize = _a.flushSize, flushInterval = _a.flushInterval, resendLimit = _a.resendLimit, userAgentValue = _a.userAgentValue;
-    var sessionToken = credentials.sessionToken;
-    var sessionIdentityKey = [region, sessionToken, identityId]
-        .filter(function (id) { return !!id; })
-        .join('-');
+const getEventBuffer = ({ region, credentials, identityId, bufferSize, flushSize, flushInterval, resendLimit, userAgentValue, }) => {
+    const sessionIdentityKey = [region, identityId].filter(id => !!id).join('-');
     if (!eventBufferMap[sessionIdentityKey]) {
-        var getClient = function () {
+        const getClient = () => {
             if (!cachedClients[sessionIdentityKey]) {
                 cachedClients[sessionIdentityKey] = new client_firehose_1.FirehoseClient({
-                    region: region,
-                    credentials: credentials,
+                    region,
+                    credentials,
                     customUserAgent: userAgentValue,
                 });
             }
-            var firehoseClient = cachedClients[sessionIdentityKey];
-            return function (events) { return submitEvents(events, firehoseClient, resendLimit); };
+            const firehoseClient = cachedClients[sessionIdentityKey];
+            return events => submitEvents(events, firehoseClient, resendLimit);
         };
         eventBufferMap[sessionIdentityKey] =
             new utils_1.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 = tslib_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/providers/kinesis-firehose/utils/resolveConfig.js

@@ -3,22 +3,23 @@
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveConfig = void 0;
-var tslib_1 = require("tslib");
-var core_1 = require("@aws-amplify/core");
-var errors_1 = require("../../../errors");
-var constants_1 = require("./constants");
-var resolveConfig = function () {
-    var _a;
-    var config = (_a = core_1.Amplify.getConfig().Analytics) === null || _a === void 0 ? void 0 : _a.KinesisFirehose;
-    var _b = tslib_1.__assign(tslib_1.__assign({}, constants_1.DEFAULT_KINESIS_FIREHOSE_CONFIG), config), region = _b.region, _c = _b.bufferSize, bufferSize = _c === void 0 ? constants_1.DEFAULT_KINESIS_FIREHOSE_CONFIG.bufferSize : _c, _d = _b.flushSize, flushSize = _d === void 0 ? constants_1.DEFAULT_KINESIS_FIREHOSE_CONFIG.flushSize : _d, _e = _b.flushInterval, flushInterval = _e === void 0 ? constants_1.DEFAULT_KINESIS_FIREHOSE_CONFIG.flushInterval : _e, resendLimit = _b.resendLimit;
+const core_1 = require("@aws-amplify/core");
+const errors_1 = require("../../../errors");
+const constants_1 = require("./constants");
+const resolveConfig = () => {
+    const config = core_1.Amplify.getConfig().Analytics?.KinesisFirehose;
+    const { region, bufferSize = constants_1.DEFAULT_KINESIS_FIREHOSE_CONFIG.bufferSize, flushSize = constants_1.DEFAULT_KINESIS_FIREHOSE_CONFIG.flushSize, flushInterval = constants_1.DEFAULT_KINESIS_FIREHOSE_CONFIG.flushInterval, resendLimit, } = {
+        ...constants_1.DEFAULT_KINESIS_FIREHOSE_CONFIG,
+        ...config,
+    };
     (0, errors_1.assertValidationError)(!!region, errors_1.AnalyticsValidationErrorCode.NoRegion);
     (0, errors_1.assertValidationError)(flushSize < bufferSize, errors_1.AnalyticsValidationErrorCode.InvalidFlushSize);
     return {
-        region: region,
-        bufferSize: bufferSize,
-        flushSize: flushSize,
-        flushInterval: flushInterval,
-        resendLimit: resendLimit,
+        region,
+        bufferSize,
+        flushSize,
+        flushInterval,
+        resendLimit,
     };
 };
 exports.resolveConfig = resolveConfig;

package/lib/providers/personalize/apis/flushEvents.js

@@ -3,11 +3,11 @@
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flushEvents = void 0;
-var utils_1 = require("../utils");
-var utils_2 = require("../../../utils");
-var utils_3 = require("@aws-amplify/core/internals/utils");
-var core_1 = require("@aws-amplify/core");
-var logger = new core_1.ConsoleLogger('Personalize');
+const utils_1 = require("../utils");
+const utils_2 = require("../../../utils");
+const utils_3 = require("@aws-amplify/core/internals/utils");
+const core_1 = require("@aws-amplify/core");
+const logger = new core_1.ConsoleLogger('Personalize');
 /**
  * Flushes all buffered Personalize events to the service.
  *
@@ -15,22 +15,19 @@ var logger = new core_1.ConsoleLogger('Personalize');
  * 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.
  */
-var flushEvents = function () {
-    var _a = (0, utils_1.resolveConfig)(), region = _a.region, flushSize = _a.flushSize, bufferSize = _a.bufferSize, flushInterval = _a.flushInterval;
+const flushEvents = () => {
+    const { region, flushSize, bufferSize, flushInterval } = (0, utils_1.resolveConfig)();
     (0, utils_2.resolveCredentials)()
-        .then(function (_a) {
-        var credentials = _a.credentials, identityId = _a.identityId;
-        return (0, utils_1.getEventBuffer)({
-            region: region,
-            flushSize: flushSize,
-            flushInterval: flushInterval,
-            bufferSize: bufferSize,
-            credentials: credentials,
-            identityId: identityId,
-            userAgentValue: (0, utils_2.getAnalyticsUserAgentString)(utils_3.AnalyticsAction.Record),
-        });
-    })
-        .then(function (eventBuffer) { return eventBuffer.flushAll(); })
-        .catch(function (e) { return logger.warn('Failed to flush events', e); });
+        .then(({ credentials, identityId }) => (0, utils_1.getEventBuffer)({
+        region,
+        flushSize,
+        flushInterval,
+        bufferSize,
+        credentials,
+        identityId,
+        userAgentValue: (0, utils_2.getAnalyticsUserAgentString)(utils_3.AnalyticsAction.Record),
+    }))
+        .then(eventBuffer => eventBuffer.flushAll())
+        .catch(e => logger.warn('Failed to flush events', e));
 };
 exports.flushEvents = flushEvents;

package/lib/providers/personalize/apis/record.js

@@ -3,84 +3,68 @@
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.record = void 0;
-var tslib_1 = require("tslib");
-var utils_1 = require("../utils");
-var utils_2 = require("../../../utils");
-var utils_3 = require("@aws-amplify/core/internals/utils");
-var core_1 = require("@aws-amplify/core");
-var constants_1 = require("../utils/constants");
-var logger = new core_1.ConsoleLogger('Personalize');
-var record = function (_a) {
-    var userId = _a.userId, eventId = _a.eventId, eventType = _a.eventType, properties = _a.properties;
+const utils_1 = require("../utils");
+const utils_2 = require("../../../utils");
+const utils_3 = require("@aws-amplify/core/internals/utils");
+const core_1 = require("@aws-amplify/core");
+const constants_1 = require("../utils/constants");
+const logger = new core_1.ConsoleLogger('Personalize');
+const record = ({ userId, eventId, eventType, properties, }) => {
     if (!(0, utils_2.isAnalyticsEnabled)()) {
         logger.debug('Analytics is disabled, event will not be recorded.');
         return;
     }
-    var _b = (0, utils_1.resolveConfig)(), region = _b.region, trackingId = _b.trackingId, bufferSize = _b.bufferSize, flushSize = _b.flushSize, flushInterval = _b.flushInterval;
+    const { region, trackingId, bufferSize, flushSize, flushInterval } = (0, utils_1.resolveConfig)();
     (0, utils_2.resolveCredentials)()
-        .then(function (_a) {
-        var credentials = _a.credentials, identityId = _a.identityId;
-        return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-            var timestamp, _b, cachedSessionId, cachedUserId, _c, updatedSessionId, updatedUserId, eventBuffer;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        timestamp = Date.now();
-                        return [4 /*yield*/, (0, utils_1.resolveCachedSession)()];
-                    case 1:
-                        _b = _d.sent(), cachedSessionId = _b.sessionId, cachedUserId = _b.userId;
-                        if (eventType === constants_1.IDENTIFY_EVENT_TYPE) {
-                            (0, utils_1.updateCachedSession)(typeof properties.userId === 'string' ? properties.userId : '', cachedSessionId, cachedUserId);
-                        }
-                        else if (!!userId) {
-                            (0, utils_1.updateCachedSession)(userId, cachedSessionId, cachedUserId);
-                        }
-                        return [4 /*yield*/, (0, utils_1.resolveCachedSession)()];
-                    case 2:
-                        _c = _d.sent(), updatedSessionId = _c.sessionId, updatedUserId = _c.userId;
-                        eventBuffer = (0, utils_1.getEventBuffer)({
-                            region: region,
-                            flushSize: flushSize,
-                            flushInterval: flushInterval,
-                            bufferSize: bufferSize,
-                            credentials: credentials,
-                            identityId: identityId,
-                            userAgentValue: (0, utils_2.getAnalyticsUserAgentString)(utils_3.AnalyticsAction.Record),
-                        });
-                        if (eventType === constants_1.MEDIA_AUTO_TRACK_EVENT_TYPE) {
-                            (0, utils_1.autoTrackMedia)({
-                                trackingId: trackingId,
-                                sessionId: updatedSessionId,
-                                userId: updatedUserId,
-                                event: {
-                                    eventId: eventId,
-                                    eventType: eventType,
-                                    properties: properties,
-                                },
-                            }, eventBuffer);
-                        }
-                        else {
-                            eventBuffer.append({
-                                trackingId: trackingId,
-                                sessionId: updatedSessionId,
-                                userId: updatedUserId,
-                                event: {
-                                    eventId: eventId,
-                                    eventType: eventType,
-                                    properties: properties,
-                                },
-                                timestamp: timestamp,
-                            });
-                        }
-                        if (eventBuffer.length >= bufferSize) {
-                            eventBuffer.flushAll();
-                        }
-                        return [2 /*return*/];
-                }
-            });
+        .then(async ({ credentials, identityId }) => {
+        const timestamp = Date.now();
+        const { sessionId: cachedSessionId, userId: cachedUserId } = await (0, utils_1.resolveCachedSession)();
+        if (eventType === constants_1.IDENTIFY_EVENT_TYPE) {
+            (0, utils_1.updateCachedSession)(typeof properties.userId === 'string' ? properties.userId : '', cachedSessionId, cachedUserId);
+        }
+        else if (!!userId) {
+            (0, utils_1.updateCachedSession)(userId, cachedSessionId, cachedUserId);
+        }
+        const { sessionId: updatedSessionId, userId: updatedUserId } = await (0, utils_1.resolveCachedSession)();
+        const eventBuffer = (0, utils_1.getEventBuffer)({
+            region,
+            flushSize,
+            flushInterval,
+            bufferSize,
+            credentials,
+            identityId,
+            userAgentValue: (0, utils_2.getAnalyticsUserAgentString)(utils_3.AnalyticsAction.Record),
         });
+        if (eventType === constants_1.MEDIA_AUTO_TRACK_EVENT_TYPE) {
+            (0, utils_1.autoTrackMedia)({
+                trackingId,
+                sessionId: updatedSessionId,
+                userId: updatedUserId,
+                event: {
+                    eventId,
+                    eventType,
+                    properties,
+                },
+            }, eventBuffer);
+        }
+        else {
+            eventBuffer.append({
+                trackingId,
+                sessionId: updatedSessionId,
+                userId: updatedUserId,
+                event: {
+                    eventId,
+                    eventType,
+                    properties,
+                },
+                timestamp,
+            });
+        }
+        if (eventBuffer.length >= bufferSize) {
+            eventBuffer.flushAll();
+        }
     })
-        .catch(function (e) {
+        .catch(e => {
         logger.warn('Failed to record event.', e);
     });
 };

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

@@ -3,9 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.autoTrackMedia = void 0;
-var tslib_1 = require("tslib");
-var utils_1 = require("@aws-amplify/core/internals/utils");
-var core_1 = require("@aws-amplify/core");
+const utils_1 = require("@aws-amplify/core/internals/utils");
+const core_1 = require("@aws-amplify/core");
 var HTML5_MEDIA_EVENT;
 (function (HTML5_MEDIA_EVENT) {
     HTML5_MEDIA_EVENT["PLAY"] = "play";
@@ -25,43 +24,43 @@ var EVENT_TYPE;
     EVENT_TYPE["PAUSE"] = "Pause";
     EVENT_TYPE["TIME_WATCHED"] = "TimeWatched";
 })(EVENT_TYPE || (EVENT_TYPE = {}));
-var logger = new core_1.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 core_1.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:
@@ -79,105 +78,104 @@ 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 tslib_1.__awaiter(void 0, void 0, void 0, function () {
-        var domElement;
-        return tslib_1.__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(tslib_1.__assign(tslib_1.__assign({}, config), { event: tslib_1.__assign(tslib_1.__assign({}, config.event), { eventType: eventType, properties: tslib_1.__assign(tslib_1.__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(),
+    });
 };
-var autoTrackMedia = function (config, eventBuffer) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-    var _a, eventType, properties, domElementId, otherProperties, elementId, isElementLoaded, autoTrackConfigWithoutDomElementId, element;
-    return tslib_1.__generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                _a = config.event, eventType = _a.eventType, properties = _a.properties;
-                domElementId = properties.domElementId, otherProperties = tslib_1.__rest(properties, ["domElementId"]);
-                if (!(0, utils_1.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 = tslib_1.__assign(tslib_1.__assign({}, config), { event: tslib_1.__assign(tslib_1.__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.');
+const autoTrackMedia = async (config, eventBuffer) => {
+    const { eventType, properties } = config.event;
+    const { domElementId, ...otherProperties } = properties;
+    if (!(0, utils_1.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.');
+    }
+};
 exports.autoTrackMedia = autoTrackMedia;