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

package/lib/providers/kinesis-firehose/apis/record.js

@@ -0,0 +1,43 @@
+"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.record = void 0;
+const utils_1 = require("../utils");
+const utils_2 = require("../../../utils");
+const util_utf8_1 = require("@smithy/util-utf8");
+const utils_3 = require("@aws-amplify/core/internals/utils");
+const core_1 = require("@aws-amplify/core");
+const logger = new core_1.ConsoleLogger('KinesisFirehose');
+const record = ({ streamName, data }) => {
+    if (!(0, utils_2.isAnalyticsEnabled)()) {
+        logger.debug('Analytics is disabled, event will not be recorded.');
+        return;
+    }
+    const timestamp = Date.now();
+    const { region, bufferSize, flushSize, flushInterval, resendLimit } = (0, utils_1.resolveConfig)();
+    (0, utils_2.resolveCredentials)()
+        .then(({ credentials, identityId }) => {
+        const buffer = (0, utils_1.getEventBuffer)({
+            region,
+            credentials,
+            identityId,
+            bufferSize,
+            flushSize,
+            flushInterval,
+            resendLimit,
+            userAgentValue: (0, utils_2.getAnalyticsUserAgentString)(utils_3.AnalyticsAction.Record),
+        });
+        buffer.append({
+            region,
+            streamName,
+            event: ArrayBuffer.isView(data) ? data : (0, util_utf8_1.fromUtf8)(JSON.stringify(data)),
+            timestamp,
+            retryCount: 0,
+        });
+    })
+        .catch(e => {
+        logger.warn('Failed to record event.', e);
+    });
+};
+exports.record = record;

package/lib/providers/kinesis-firehose/index.d.ts

@@ -0,0 +1 @@
+export { record, flushEvents } from './apis';

package/lib/providers/kinesis-firehose/index.js

@@ -0,0 +1,8 @@
+"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.flushEvents = exports.record = void 0;
+var apis_1 = require("./apis");
+Object.defineProperty(exports, "record", { enumerable: true, get: function () { return apis_1.record; } });
+Object.defineProperty(exports, "flushEvents", { enumerable: true, get: function () { return apis_1.flushEvents; } });

package/lib/providers/kinesis-firehose/types/buffer.d.ts

@@ -0,0 +1,15 @@
+import { EventBufferConfig } from '../../../utils';
+import { KinesisStream } from '../../../types';
+import { AWSCredentials } from '@aws-amplify/core/internals/utils';
+export type KinesisFirehoseBufferEvent = KinesisStream & {
+    event: Uint8Array;
+    retryCount: number;
+    timestamp: number;
+};
+export type KinesisFirehoseEventBufferConfig = EventBufferConfig & {
+    region: string;
+    credentials: AWSCredentials;
+    identityId?: string;
+    resendLimit?: number;
+    userAgentValue?: string;
+};

package/lib/{types/Provider.js → providers/kinesis-firehose/types/buffer.js}

@@ -2,4 +2,3 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=Provider.js.map

package/lib/providers/kinesis-firehose/types/index.d.ts

@@ -0,0 +1,2 @@
+export { RecordInput } from './inputs';
+export { KinesisFirehoseBufferEvent, KinesisFirehoseEventBufferConfig, } from './buffer';

package/lib/providers/kinesis-firehose/types/index.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/providers/kinesis-firehose/types/inputs.d.ts

@@ -0,0 +1,5 @@
+import { KinesisEventData } from '../../../types';
+export type RecordInput = {
+    streamName: string;
+    data: KinesisEventData;
+};

package/lib/providers/kinesis-firehose/types/inputs.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/providers/kinesis-firehose/utils/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_KINESIS_FIREHOSE_CONFIG: {
+    bufferSize: number;
+    flushSize: number;
+    flushInterval: number;
+    resendLimit: number;
+};

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

@@ -0,0 +1,11 @@
+"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.DEFAULT_KINESIS_FIREHOSE_CONFIG = void 0;
+exports.DEFAULT_KINESIS_FIREHOSE_CONFIG = {
+    bufferSize: 1000,
+    flushSize: 100,
+    flushInterval: 5000,
+    resendLimit: 5,
+};

package/lib/providers/kinesis-firehose/utils/getEventBuffer.d.ts

@@ -0,0 +1,3 @@
+import { EventBuffer } from '../../../utils';
+import { KinesisFirehoseBufferEvent, KinesisFirehoseEventBufferConfig } from '../types';
+export declare const getEventBuffer: ({ region, credentials, identityId, bufferSize, flushSize, flushInterval, resendLimit, userAgentValue, }: KinesisFirehoseEventBufferConfig) => EventBuffer<KinesisFirehoseBufferEvent>;

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

@@ -0,0 +1,71 @@
+"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.getEventBuffer = void 0;
+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,
+ * consisting of a combined value comprising [region, sessionToken, identityId].
+ *
+ * Only one active session should exist at any given moment.
+ * When a new session is initiated, the previous ones should be released.
+ * */
+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)
+        : [];
+};
+const getEventBuffer = ({ region, credentials, identityId, bufferSize, flushSize, flushInterval, resendLimit, userAgentValue, }) => {
+    const sessionIdentityKey = [region, identityId].filter(id => !!id).join('-');
+    if (!eventBufferMap[sessionIdentityKey]) {
+        const getClient = () => {
+            if (!cachedClients[sessionIdentityKey]) {
+                cachedClients[sessionIdentityKey] = new client_firehose_1.FirehoseClient({
+                    region,
+                    credentials,
+                    customUserAgent: userAgentValue,
+                });
+            }
+            const firehoseClient = cachedClients[sessionIdentityKey];
+            return events => submitEvents(events, firehoseClient, resendLimit);
+        };
+        eventBufferMap[sessionIdentityKey] =
+            new utils_1.EventBuffer({
+                bufferSize,
+                flushSize,
+                flushInterval,
+            }, getClient);
+        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];
+            });
+        }
+    }
+    return eventBufferMap[sessionIdentityKey];
+};
+exports.getEventBuffer = getEventBuffer;

package/lib/providers/kinesis-firehose/utils/index.d.ts

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

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

@@ -0,0 +1,9 @@
+"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.resolveConfig = exports.getEventBuffer = void 0;
+var getEventBuffer_1 = require("./getEventBuffer");
+Object.defineProperty(exports, "getEventBuffer", { enumerable: true, get: function () { return getEventBuffer_1.getEventBuffer; } });
+var resolveConfig_1 = require("./resolveConfig");
+Object.defineProperty(exports, "resolveConfig", { enumerable: true, get: function () { return resolveConfig_1.resolveConfig; } });

package/lib/providers/kinesis-firehose/utils/resolveConfig.d.ts

@@ -0,0 +1,7 @@
+export declare const resolveConfig: () => {
+    region: string;
+    bufferSize: number;
+    flushSize: number;
+    flushInterval: number;
+    resendLimit: number;
+};

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

@@ -0,0 +1,25 @@
+"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.resolveConfig = void 0;
+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,
+        bufferSize,
+        flushSize,
+        flushInterval,
+        resendLimit,
+    };
+};
+exports.resolveConfig = resolveConfig;

package/lib/providers/personalize/apis/flushEvents.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Flushes all buffered Personalize events to the service.
+ *
+ * @note
+ * 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 declare const flushEvents: () => void;

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

@@ -0,0 +1,33 @@
+"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.flushEvents = void 0;
+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.
+ *
+ * @note
+ * 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.
+ */
+const flushEvents = () => {
+    const { region, flushSize, bufferSize, flushInterval } = (0, utils_1.resolveConfig)();
+    (0, utils_2.resolveCredentials)()
+        .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/index.d.ts

@@ -0,0 +1,2 @@
+export { record } from './record';
+export { flushEvents } from './flushEvents';

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

@@ -0,0 +1,9 @@
+"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.flushEvents = exports.record = void 0;
+var record_1 = require("./record");
+Object.defineProperty(exports, "record", { enumerable: true, get: function () { return record_1.record; } });
+var flushEvents_1 = require("./flushEvents");
+Object.defineProperty(exports, "flushEvents", { enumerable: true, get: function () { return flushEvents_1.flushEvents; } });

package/lib/providers/personalize/apis/record.d.ts

@@ -0,0 +1,2 @@
+import { RecordInput } from '../types';
+export declare const record: ({ userId, eventId, eventType, properties, }: RecordInput) => void;

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

@@ -0,0 +1,71 @@
+"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.record = void 0;
+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;
+    }
+    const { region, trackingId, bufferSize, flushSize, flushInterval } = (0, utils_1.resolveConfig)();
+    (0, utils_2.resolveCredentials)()
+        .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(e => {
+        logger.warn('Failed to record event.', e);
+    });
+};
+exports.record = record;

package/lib/providers/personalize/index.d.ts

@@ -0,0 +1 @@
+export { record, flushEvents } from './apis';

package/lib/providers/personalize/index.js

@@ -0,0 +1,8 @@
+"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.flushEvents = exports.record = void 0;
+var apis_1 = require("./apis");
+Object.defineProperty(exports, "record", { enumerable: true, get: function () { return apis_1.record; } });
+Object.defineProperty(exports, "flushEvents", { enumerable: true, get: function () { return apis_1.flushEvents; } });

package/lib/providers/personalize/types/buffer.d.ts

@@ -0,0 +1,16 @@
+import { PersonalizeEvent } from './';
+import { EventBufferConfig } from '../../../utils';
+import { AWSCredentials } from '@aws-amplify/core/internals/utils';
+export type PersonalizeBufferEvent = {
+    trackingId: string;
+    sessionId?: string;
+    userId?: string;
+    event: PersonalizeEvent;
+    timestamp: number;
+};
+export type PersonalizeBufferConfig = EventBufferConfig & {
+    region: string;
+    credentials: AWSCredentials;
+    identityId?: string;
+    userAgentValue?: string;
+};

package/lib/providers/personalize/types/buffer.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/providers/personalize/types/index.d.ts

@@ -0,0 +1,2 @@
+export { RecordInput, PersonalizeEvent } from './inputs';
+export { PersonalizeBufferEvent, PersonalizeBufferConfig } from './buffer';

package/lib/providers/personalize/types/index.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/providers/personalize/types/inputs.d.ts

@@ -0,0 +1,7 @@
+export type PersonalizeEvent = {
+    userId?: string;
+    eventId?: string;
+    eventType: string;
+    properties: Record<string, unknown>;
+};
+export type RecordInput = PersonalizeEvent;

package/lib/providers/personalize/types/inputs.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/providers/personalize/utils/autoTrackMedia.d.ts

@@ -0,0 +1,10 @@
+import { EventBuffer } from '../../../utils';
+import { PersonalizeBufferEvent, PersonalizeEvent } from '../types';
+type MediaAutoTrackConfig = {
+    trackingId: string;
+    sessionId: string;
+    userId?: string;
+    event: PersonalizeEvent;
+};
+export declare const autoTrackMedia: (config: MediaAutoTrackConfig, eventBuffer: EventBuffer<PersonalizeBufferEvent>) => Promise<void>;
+export {};

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

@@ -0,0 +1,181 @@
+"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.autoTrackMedia = void 0;
+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";
+    HTML5_MEDIA_EVENT["PAUSE"] = "pause";
+    HTML5_MEDIA_EVENT["ENDED"] = "Ended";
+})(HTML5_MEDIA_EVENT || (HTML5_MEDIA_EVENT = {}));
+var MEDIA_TYPE;
+(function (MEDIA_TYPE) {
+    MEDIA_TYPE["IFRAME"] = "IFRAME";
+    MEDIA_TYPE["VIDEO"] = "VIDEO";
+    MEDIA_TYPE["AUDIO"] = "AUDIO";
+})(MEDIA_TYPE || (MEDIA_TYPE = {}));
+var EVENT_TYPE;
+(function (EVENT_TYPE) {
+    EVENT_TYPE["PLAY"] = "Play";
+    EVENT_TYPE["ENDED"] = "Ended";
+    EVENT_TYPE["PAUSE"] = "Pause";
+    EVENT_TYPE["TIME_WATCHED"] = "TimeWatched";
+})(EVENT_TYPE || (EVENT_TYPE = {}));
+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,
+            eventValue: Number((currentTime / duration).toFixed(4)),
+        };
+    };
+    const scriptElement = document.createElement('script');
+    scriptElement.type = 'text/javascript';
+    scriptElement.src = 'https://www.youtube.com/iframe_api';
+    document.body.append(scriptElement);
+    const timer = setInterval(() => {
+        if (isPlaying && player) {
+            recordEvent(EVENT_TYPE.TIME_WATCHED, mediaProperties());
+        }
+    }, 3000);
+    element.addEventListener('unload', () => clearInterval(timer));
+    // @ts-ignore
+    window.onYouTubeIframeAPIReady = () => {
+        // @ts-ignore
+        delete window.onYouTubeIframeAPIReady;
+        // @ts-ignore
+        player = new window.YT.Player(element.id, {
+            events: {
+                onStateChange: (event) => {
+                    const iframeEventMapping = {
+                        0: EVENT_TYPE.ENDED,
+                        1: EVENT_TYPE.PLAY,
+                        2: EVENT_TYPE.PAUSE,
+                    };
+                    // @ts-ignore
+                    const eventType = iframeEventMapping[event.data];
+                    switch (eventType) {
+                        case EVENT_TYPE.ENDED:
+                        case EVENT_TYPE.PAUSE:
+                            isPlaying = false;
+                            break;
+                        case EVENT_TYPE.PLAY:
+                            isPlaying = true;
+                            break;
+                    }
+                    if (eventType) {
+                        recordEvent(eventType, mediaProperties());
+                    }
+                },
+            },
+        });
+    };
+};
+const startHTMLMediaAutoTracking = (element, recordEvent) => {
+    let isPlaying = false;
+    const mediaProperties = () => ({
+        duration: element.duration,
+        eventValue: Number((element.currentTime / element.duration).toFixed(4)),
+    });
+    const timer = setInterval(() => {
+        if (isPlaying) {
+            recordEvent(EVENT_TYPE.TIME_WATCHED, mediaProperties());
+        }
+    }, 3000);
+    element.addEventListener('unload', () => clearInterval(timer));
+    element.addEventListener(HTML5_MEDIA_EVENT.PLAY, () => {
+        isPlaying = true;
+        recordEvent(EVENT_TYPE.PLAY, mediaProperties());
+    });
+    element.addEventListener(HTML5_MEDIA_EVENT.PAUSE, () => {
+        isPlaying = false;
+        recordEvent(EVENT_TYPE.PAUSE, mediaProperties());
+    });
+    element.addEventListener(HTML5_MEDIA_EVENT.ENDED, () => {
+        isPlaying = false;
+        recordEvent(EVENT_TYPE.ENDED, mediaProperties());
+    });
+};
+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;
+};
+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(),
+    });
+};
+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));
+                }
+                break;
+            default:
+                logger.debug(`Unsupported DOM element tag: ${element?.tagName}`);
+                break;
+        }
+    }
+    else {
+        logger.debug('Cannot find the media element.');
+    }
+};
+exports.autoTrackMedia = autoTrackMedia;

package/lib/providers/personalize/utils/cachedSession.d.ts

@@ -0,0 +1,5 @@
+export declare const resolveCachedSession: () => Promise<{
+    sessionId: string;
+    userId: string | undefined;
+}>;
+export declare const updateCachedSession: (newUserId?: string, currentSessionId?: string, currentUserId?: string) => void;