@aws-amplify/analytics 7.0.1-preview-testing.034e780.0 → 7.0.1-server-generate-client.1e317a1.0

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

@@ -0,0 +1,83 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { __awaiter, __generator } from "tslib";
+import { autoTrackMedia, getEventBuffer, resolveCachedSession, resolveConfig, updateCachedSession, } from '../utils';
+import { getAnalyticsUserAgentString, isAnalyticsEnabled, resolveCredentials, } from '../../../utils';
+import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
+import { ConsoleLogger } from '@aws-amplify/core';
+import { IDENTIFY_EVENT_TYPE, MEDIA_AUTO_TRACK_EVENT_TYPE, } from '../utils/constants';
+var logger = new ConsoleLogger('Personalize');
+export var record = function (_a) {
+    var userId = _a.userId, eventId = _a.eventId, eventType = _a.eventType, properties = _a.properties;
+    if (!isAnalyticsEnabled()) {
+        logger.debug('Analytics is disabled, event will not be recorded.');
+        return;
+    }
+    var _b = resolveConfig(), region = _b.region, trackingId = _b.trackingId, bufferSize = _b.bufferSize, flushSize = _b.flushSize, flushInterval = _b.flushInterval;
+    resolveCredentials()
+        .then(function (_a) {
+        var credentials = _a.credentials, identityId = _a.identityId;
+        return __awaiter(void 0, void 0, void 0, function () {
+            var timestamp, _b, cachedSessionId, cachedUserId, _c, updatedSessionId, updatedUserId, eventBuffer;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        timestamp = Date.now();
+                        return [4 /*yield*/, resolveCachedSession()];
+                    case 1:
+                        _b = _d.sent(), cachedSessionId = _b.sessionId, cachedUserId = _b.userId;
+                        if (eventType === IDENTIFY_EVENT_TYPE) {
+                            updateCachedSession(typeof properties.userId === 'string' ? properties.userId : '', cachedSessionId, cachedUserId);
+                        }
+                        else if (!!userId) {
+                            updateCachedSession(userId, cachedSessionId, cachedUserId);
+                        }
+                        return [4 /*yield*/, resolveCachedSession()];
+                    case 2:
+                        _c = _d.sent(), updatedSessionId = _c.sessionId, updatedUserId = _c.userId;
+                        eventBuffer = getEventBuffer({
+                            region: region,
+                            flushSize: flushSize,
+                            flushInterval: flushInterval,
+                            bufferSize: bufferSize,
+                            credentials: credentials,
+                            identityId: identityId,
+                            userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
+                        });
+                        if (eventType === MEDIA_AUTO_TRACK_EVENT_TYPE) {
+                            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*/];
+                }
+            });
+        });
+    })
+        .catch(function (e) {
+        logger.warn('Failed to record event.', e);
+    });
+};

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

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

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

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

package/lib-esm/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-esm/providers/personalize/types/buffer.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/personalize/types/index.d.ts

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

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

@@ -0,0 +1,179 @@
+// 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;
+(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 = {}));
+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));
+        return {
+            duration: duration,
+            eventValue: Number((currentTime / duration).toFixed(4)),
+        };
+    };
+    var scriptElement = document.createElement('script');
+    scriptElement.type = 'text/javascript';
+    scriptElement.src = 'https://www.youtube.com/iframe_api';
+    document.body.append(scriptElement);
+    var timer = setInterval(function () {
+        if (isPlaying && player) {
+            recordEvent(EVENT_TYPE.TIME_WATCHED, mediaProperties());
+        }
+    }, 3000);
+    element.addEventListener('unload', function () { return clearInterval(timer); });
+    // @ts-ignore
+    window.onYouTubeIframeAPIReady = function () {
+        // @ts-ignore
+        delete window.onYouTubeIframeAPIReady;
+        // @ts-ignore
+        player = new window.YT.Player(element.id, {
+            events: {
+                onStateChange: function (event) {
+                    var iframeEventMapping = {
+                        0: EVENT_TYPE.ENDED,
+                        1: EVENT_TYPE.PLAY,
+                        2: EVENT_TYPE.PAUSE,
+                    };
+                    // @ts-ignore
+                    var 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());
+                    }
+                },
+            },
+        });
+    };
+};
+var startHTMLMediaAutoTracking = function (element, recordEvent) {
+    var isPlaying = false;
+    var mediaProperties = function () { return ({
+        duration: element.duration,
+        eventValue: Number((element.currentTime / element.duration).toFixed(4)),
+    }); };
+    var timer = setInterval(function () {
+        if (isPlaying) {
+            recordEvent(EVENT_TYPE.TIME_WATCHED, mediaProperties());
+        }
+    }, 3000);
+    element.addEventListener('unload', function () { return clearInterval(timer); });
+    element.addEventListener(HTML5_MEDIA_EVENT.PLAY, function () {
+        isPlaying = true;
+        recordEvent(EVENT_TYPE.PLAY, mediaProperties());
+    });
+    element.addEventListener(HTML5_MEDIA_EVENT.PAUSE, function () {
+        isPlaying = false;
+        recordEvent(EVENT_TYPE.PAUSE, mediaProperties());
+    });
+    element.addEventListener(HTML5_MEDIA_EVENT.ENDED, function () {
+        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()];
+            }
+        });
+    }); };
+    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() }));
+    };
+};
+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.');
+                }
+                return [2 /*return*/];
+        }
+    });
+}); };

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

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

@@ -0,0 +1,56 @@
+// 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);
+    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;
+    if (isRequireNewSession) {
+        var newSessionId = amplifyUuid();
+        setCache(PERSONALIZE_CACHE_SESSIONID, newSessionId);
+        setCache(PERSONALIZE_CACHE_USERID, newUserId);
+    }
+    else if (isRequireUpdateSession) {
+        setCache(PERSONALIZE_CACHE_USERID, newUserId);
+    }
+};

package/lib-esm/providers/personalize/utils/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_PERSONALIZE_CONFIG: {
+    flushSize: number;
+    flushInterval: number;
+};
+export declare const PERSONALIZE_FLUSH_SIZE_MAX = 10;
+export declare const IDENTIFY_EVENT_TYPE = "Identify";
+export declare const MEDIA_AUTO_TRACK_EVENT_TYPE = "MediaAutoTrack";

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

@@ -0,0 +1,9 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export var 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';

package/lib-esm/providers/personalize/utils/getEventBuffer.d.ts

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

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

@@ -0,0 +1,96 @@
+// 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';
+/**
+ * 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.
+ * */
+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];
+    return new PutEventsCommand({
+        trackingId: trackingId,
+        sessionId: sessionId,
+        userId: userId,
+        eventList: events.map(function (event) { return ({
+            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('-');
+    if (!eventBufferMap[sessionIdentityKey]) {
+        var getClient = function () {
+            if (!cachedClients[sessionIdentityKey]) {
+                cachedClients[sessionIdentityKey] = new PersonalizeEventsClient({
+                    region: region,
+                    credentials: credentials,
+                    customUserAgent: userAgentValue,
+                });
+            }
+            return function (events) { return submitEvents(events, cachedClients[sessionIdentityKey]); };
+        };
+        eventBufferMap[sessionIdentityKey] =
+            new EventBuffer({
+                bufferSize: bufferSize,
+                flushSize: flushSize,
+                flushInterval: 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;
+                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/index.d.ts

@@ -0,0 +1,5 @@
+export { getEventBuffer } from './getEventBuffer';
+export { resolveConfig } from './resolveConfig';
+export { autoTrackMedia } from './autoTrackMedia';
+export { resolveCachedSession, updateCachedSession } from './cachedSession';
+export { DEFAULT_PERSONALIZE_CONFIG, PERSONALIZE_FLUSH_SIZE_MAX, } from './constants';

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

@@ -0,0 +1,7 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { getEventBuffer } from './getEventBuffer';
+export { resolveConfig } from './resolveConfig';
+export { autoTrackMedia } from './autoTrackMedia';
+export { resolveCachedSession, updateCachedSession } from './cachedSession';
+export { DEFAULT_PERSONALIZE_CONFIG, PERSONALIZE_FLUSH_SIZE_MAX, } from './constants';

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

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

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

@@ -0,0 +1,21 @@
+// 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;
+    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));
+    return {
+        region: region,
+        trackingId: trackingId,
+        bufferSize: flushSize + 1,
+        flushSize: flushSize,
+        flushInterval: flushInterval,
+    };
+};

package/lib-esm/providers/pinpoint/apis/configureAutoTrack.d.ts

@@ -0,0 +1,15 @@
+import { ConfigureAutoTrackInput } from '../types';
+/**
+ * Configures automatic event tracking for Pinpoint. This API will automatically transmit an analytic event when
+ * configured events are detected within your application. This can include: DOM element events (via the `event`
+ * tracker), session events (via the `session` tracker), and page view events (via the `pageView` tracker).
+ *
+ * @remark Only session tracking is currently supported on React Native.
+ *
+ * @param {ConfigureAutoTrackInput} params The input object to configure auto track behavior.
+ *
+ * @throws service: {@link UpdateEndpointException} - Thrown when the underlying Pinpoint service returns an error.
+ * @throws validation: {@link AnalyticsValidationErrorCode} - Thrown when the provided parameters or library
+ *  configuration is incorrect.
+ */
+export declare const configureAutoTrack: (input: ConfigureAutoTrackInput) => void;

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

@@ -0,0 +1,31 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { updateProviderTrackers, validateTrackerConfiguration, } from '../../../utils';
+import { record } from './record';
+// Configured Tracker instances for Pinpoint
+var configuredTrackers = {};
+// Callback that will emit an appropriate event to Pinpoint when required by the Tracker
+var emitTrackingEvent = function (eventName, attributes) {
+    record({
+        name: eventName,
+        attributes: attributes,
+    });
+};
+/**
+ * Configures automatic event tracking for Pinpoint. This API will automatically transmit an analytic event when
+ * configured events are detected within your application. This can include: DOM element events (via the `event`
+ * tracker), session events (via the `session` tracker), and page view events (via the `pageView` tracker).
+ *
+ * @remark Only session tracking is currently supported on React Native.
+ *
+ * @param {ConfigureAutoTrackInput} params The input object to configure auto track behavior.
+ *
+ * @throws service: {@link UpdateEndpointException} - Thrown when the underlying Pinpoint service returns an error.
+ * @throws validation: {@link AnalyticsValidationErrorCode} - Thrown when the provided parameters or library
+ *  configuration is incorrect.
+ */
+export var configureAutoTrack = function (input) {
+    validateTrackerConfiguration(input);
+    // Initialize or update this provider's trackers
+    updateProviderTrackers(input, emitTrackingEvent, configuredTrackers);
+};

package/lib-esm/providers/pinpoint/apis/flushEvents.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Flushes all buffered Pinpoint 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-esm/providers/pinpoint/apis/flushEvents.js

@@ -0,0 +1,24 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { resolveConfig, resolveCredentials } from '../utils';
+import { flushEvents as flushEventsCore } from '@aws-amplify/core/internals/providers/pinpoint';
+import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
+import { ConsoleLogger } from '@aws-amplify/core';
+import { getAnalyticsUserAgentString } from '../../../utils';
+var logger = new ConsoleLogger('Analytics');
+/**
+ * Flushes all buffered Pinpoint 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 var flushEvents = function () {
+    var _a = resolveConfig(), appId = _a.appId, region = _a.region;
+    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); });
+};