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

package/lib/utils/eventBuffer/EventBuffer.js

@@ -3,89 +3,61 @@
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventBuffer = void 0;
-var tslib_1 = require("tslib");
-var core_1 = require("@aws-amplify/core");
-var logger = new core_1.ConsoleLogger('EventBuffer');
-var EventBuffer = /** @class */ (function () {
-    function EventBuffer(config, getAnalyticsClient) {
+const core_1 = require("@aws-amplify/core");
+const logger = new core_1.ConsoleLogger('EventBuffer');
+class EventBuffer {
+    constructor(config, getAnalyticsClient) {
         this.list = [];
         this.config = config;
         this.getAnalyticsClient = getAnalyticsClient;
         this.startEventLoop();
     }
-    EventBuffer.prototype.append = function () {
-        var e_1, _a;
-        var events = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            events[_i] = arguments[_i];
-        }
-        try {
-            for (var events_1 = tslib_1.__values(events), events_1_1 = events_1.next(); !events_1_1.done; events_1_1 = events_1.next()) {
-                var event_1 = events_1_1.value;
-                if (this.list.length + 1 > this.config.bufferSize) {
-                    logger.debug("Exceed ".concat(typeof event_1, " event buffer limits, event dropped"));
-                    continue;
-                }
-                this.list.push(event_1);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (events_1_1 && !events_1_1.done && (_a = events_1.return)) _a.call(events_1);
+    append(...events) {
+        for (const event of events) {
+            if (this.list.length + 1 > this.config.bufferSize) {
+                logger.debug(`Exceed ${typeof event} event buffer limits, event dropped`);
+                continue;
             }
-            finally { if (e_1) throw e_1.error; }
+            this.list.push(event);
         }
-    };
-    EventBuffer.prototype.flushAll = function () {
+    }
+    flushAll() {
         return this.submitEvents(this.list.length);
-    };
-    EventBuffer.prototype.release = function () {
+    }
+    release() {
         this.list = [];
         if (this.timer) {
             clearInterval(this.timer);
         }
-    };
-    Object.defineProperty(EventBuffer.prototype, "length", {
-        get: function () {
-            return this.list.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    EventBuffer.prototype.head = function (count) {
+    }
+    get length() {
+        return this.list.length;
+    }
+    head(count) {
         return this.list.splice(0, count);
-    };
-    EventBuffer.prototype.insertAtBeginning = function () {
-        var _a;
-        var data = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            data[_i] = arguments[_i];
-        }
-        (_a = this.list).unshift.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(data), false));
-    };
-    EventBuffer.prototype.startEventLoop = function () {
-        var _this = this;
+    }
+    insertAtBeginning(...data) {
+        this.list.unshift(...data);
+    }
+    startEventLoop() {
         if (this.timer) {
             clearInterval(this.timer);
         }
-        var _a = this.config, flushSize = _a.flushSize, flushInterval = _a.flushInterval;
-        setInterval(function () {
-            _this.submitEvents(flushSize);
+        const { flushSize, flushInterval } = this.config;
+        setInterval(() => {
+            this.submitEvents(flushSize);
         }, flushInterval);
-    };
-    EventBuffer.prototype.submitEvents = function (count) {
-        var _this = this;
-        var events = this.head(count);
+    }
+    submitEvents(count) {
+        const events = this.head(count);
         if (events.length === 0) {
             return Promise.resolve();
         }
-        return this.getAnalyticsClient()(events).then(function (result) {
+        return this.getAnalyticsClient()(events).then(result => {
             if (result.length > 0) {
-                _this.insertAtBeginning.apply(_this, tslib_1.__spreadArray([], tslib_1.__read(result), false));
+                this.insertAtBeginning(...result);
             }
         });
-    };
-    return EventBuffer;
-}());
+    }
+}
 exports.EventBuffer = EventBuffer;

package/lib/utils/groupBy.js

@@ -3,13 +3,10 @@
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupBy = void 0;
-var tslib_1 = require("tslib");
-var groupBy = function (getGroupId, list) {
-    return list.reduce(function (result, current) {
-        var _a;
-        var _b;
-        var groupId = getGroupId(current);
-        return tslib_1.__assign(tslib_1.__assign({}, result), (_a = {}, _a[groupId] = tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(((_b = result[groupId]) !== null && _b !== void 0 ? _b : [])), false), [current], false), _a));
+const groupBy = (getGroupId, list) => {
+    return list.reduce((result, current) => {
+        const groupId = getGroupId(current);
+        return { ...result, [groupId]: [...(result[groupId] ?? []), current] };
     }, {});
 };
 exports.groupBy = groupBy;

package/lib/utils/resolveCredentials.js

@@ -3,19 +3,11 @@
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveCredentials = void 0;
-var tslib_1 = require("tslib");
-var errors_1 = require("../errors");
-var core_1 = require("@aws-amplify/core");
-var resolveCredentials = function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-    var _a, credentials, identityId;
-    return tslib_1.__generator(this, function (_b) {
-        switch (_b.label) {
-            case 0: return [4 /*yield*/, (0, core_1.fetchAuthSession)()];
-            case 1:
-                _a = _b.sent(), credentials = _a.credentials, identityId = _a.identityId;
-                (0, errors_1.assertValidationError)(!!credentials, errors_1.AnalyticsValidationErrorCode.NoCredentials);
-                return [2 /*return*/, { credentials: credentials, identityId: identityId }];
-        }
-    });
-}); };
+const errors_1 = require("../errors");
+const core_1 = require("@aws-amplify/core");
+const resolveCredentials = async () => {
+    const { credentials, identityId } = await (0, core_1.fetchAuthSession)();
+    (0, errors_1.assertValidationError)(!!credentials, errors_1.AnalyticsValidationErrorCode.NoCredentials);
+    return { credentials, identityId };
+};
 exports.resolveCredentials = resolveCredentials;

package/lib/utils/statusHelpers.js

@@ -3,17 +3,17 @@
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAnalyticsEnabled = exports.disableAnalytics = exports.enableAnalytics = void 0;
-var analyticsEnabled = true;
-var enableAnalytics = function () {
+let analyticsEnabled = true;
+const enableAnalytics = () => {
     analyticsEnabled = true;
 };
 exports.enableAnalytics = enableAnalytics;
-var disableAnalytics = function () {
+const disableAnalytics = () => {
     analyticsEnabled = false;
 };
 exports.disableAnalytics = disableAnalytics;
 /**
  * Returns the current status of the Analytics category.
  */
-var isAnalyticsEnabled = function () { return analyticsEnabled; };
+const isAnalyticsEnabled = () => analyticsEnabled;
 exports.isAnalyticsEnabled = isAnalyticsEnabled;

package/lib/utils/trackerConfigHelpers.js

@@ -3,11 +3,11 @@
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateTrackerConfiguration = void 0;
-var errors_1 = require("../errors");
+const errors_1 = require("../errors");
 /**
  * Validates tracker configuration.
  */
-var validateTrackerConfiguration = function (input) {
+const validateTrackerConfiguration = (input) => {
     (0, errors_1.assertValidationError)(input.type === 'event' ||
         input.type === 'pageView' ||
         input.type === 'session', errors_1.AnalyticsValidationErrorCode.InvalidTracker);

package/lib/utils/trackerConfigHelpers.native.js

@@ -3,11 +3,11 @@
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateTrackerConfiguration = void 0;
-var errors_1 = require("../errors");
+const errors_1 = require("../errors");
 /**
  * Validates tracker configuration.
  */
-var validateTrackerConfiguration = function (input) {
+const validateTrackerConfiguration = (input) => {
     // React Native only supports session tracking
     (0, errors_1.assertValidationError)(input.type === 'session', errors_1.AnalyticsValidationErrorCode.UnsupportedPlatform);
 };

package/lib/utils/trackerHelpers.js

@@ -3,17 +3,17 @@
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateProviderTrackers = void 0;
-var trackers_1 = require("../trackers");
+const trackers_1 = require("../trackers");
 /**
  * Updates a provider's trackers as appropriate for the provided auto-track configuration.
  *
  * @remark
  * This utility will mutate the provider's configured trackers via `providerTrackers`.
  */
-var updateProviderTrackers = function (input, providerEventRecorder, providerTrackers) {
-    var trackerInstance;
-    var trackerType = input.type;
-    var currentTracker = providerTrackers[trackerType];
+const updateProviderTrackers = (input, providerEventRecorder, providerTrackers) => {
+    let trackerInstance;
+    const trackerType = input.type;
+    const currentTracker = providerTrackers[trackerType];
     // Check if the tracker was disabled & should be cleaned up
     if (!input.enable) {
         if (currentTracker) {

package/lib/utils/userAgent.js

@@ -3,18 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAnalyticsUserAgentString = exports.getAnalyticsUserAgent = void 0;
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var utils_1 = require("@aws-amplify/core/internals/utils");
+const utils_1 = require("@aws-amplify/core/internals/utils");
 function getAnalyticsUserAgent(action) {
     return (0, utils_1.getAmplifyUserAgentObject)({
         category: utils_1.Category.Analytics,
-        action: action,
+        action,
     });
 }
 exports.getAnalyticsUserAgent = getAnalyticsUserAgent;
 function getAnalyticsUserAgentString(action) {
     return (0, utils_1.getAmplifyUserAgent)({
         category: utils_1.Category.Analytics,
-        action: action,
+        action,
     });
 }
 exports.getAnalyticsUserAgentString = getAnalyticsUserAgentString;

package/lib-esm/apis/disable.js

@@ -8,4 +8,4 @@ import { disableAnalytics } from '../utils';
  * When Analytics is disabled events will not be buffered or transmitted to your selected service. Any auto-tracking
  * behavior that you have configured via `configureAutoTrack` will not have any effect while Analytics is disabled.
  */
-export var disable = disableAnalytics;
+export const disable = disableAnalytics;

package/lib-esm/apis/enable.js

@@ -7,4 +7,4 @@ import { enableAnalytics } from '../utils';
  * @note
  * Analytics is enabled by default. You do not need to call this API unless you have disabled Analytics.
  */
-export var enable = enableAnalytics;
+export const enable = enableAnalytics;

package/lib-esm/errors/AnalyticsError.js

@@ -1,20 +1,15 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __extends } from "tslib";
 import { AmplifyError, } from '@aws-amplify/core/internals/utils';
 /**
  * @internal
  */
-var AnalyticsError = /** @class */ (function (_super) {
-    __extends(AnalyticsError, _super);
-    function AnalyticsError(params) {
-        var _this = _super.call(this, params) || this;
+export class AnalyticsError extends AmplifyError {
+    constructor(params) {
+        super(params);
         // Hack for making the custom error class work when transpiled to es5
         // TODO: Delete the following 2 lines after we change the build target to >= es2015
-        _this.constructor = AnalyticsError;
-        Object.setPrototypeOf(_this, AnalyticsError.prototype);
-        return _this;
+        this.constructor = AnalyticsError;
+        Object.setPrototypeOf(this, AnalyticsError.prototype);
     }
-    return AnalyticsError;
-}(AmplifyError));
-export { AnalyticsError };
+}

package/lib-esm/errors/assertValidationError.js

@@ -6,12 +6,12 @@ import { validationErrorMap } from './validation';
  * @internal
  */
 export function assertValidationError(assertion, name, message) {
-    var _a = validationErrorMap[name], defaultMessage = _a.message, recoverySuggestion = _a.recoverySuggestion;
+    const { message: defaultMessage, recoverySuggestion } = validationErrorMap[name];
     if (!assertion) {
         throw new AnalyticsError({
-            name: name,
-            message: message !== null && message !== void 0 ? message : defaultMessage,
-            recoverySuggestion: recoverySuggestion,
+            name,
+            message: message ?? defaultMessage,
+            recoverySuggestion,
         });
     }
 }

package/lib-esm/errors/validation.js

@@ -1,6 +1,5 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var _a;
 export var AnalyticsValidationErrorCode;
 (function (AnalyticsValidationErrorCode) {
     AnalyticsValidationErrorCode["NoAppId"] = "NoAppId";
@@ -12,29 +11,29 @@ export var AnalyticsValidationErrorCode;
     AnalyticsValidationErrorCode["NoTrackingId"] = "NoTrackingId";
     AnalyticsValidationErrorCode["InvalidFlushSize"] = "InvalidFlushSize";
 })(AnalyticsValidationErrorCode || (AnalyticsValidationErrorCode = {}));
-export var validationErrorMap = (_a = {},
-    _a[AnalyticsValidationErrorCode.NoAppId] = {
+export const validationErrorMap = {
+    [AnalyticsValidationErrorCode.NoAppId]: {
         message: 'Missing application id.',
     },
-    _a[AnalyticsValidationErrorCode.NoCredentials] = {
+    [AnalyticsValidationErrorCode.NoCredentials]: {
         message: 'Credentials should not be empty.',
     },
-    _a[AnalyticsValidationErrorCode.NoEventName] = {
+    [AnalyticsValidationErrorCode.NoEventName]: {
         message: 'Events must specify a name.',
     },
-    _a[AnalyticsValidationErrorCode.NoRegion] = {
+    [AnalyticsValidationErrorCode.NoRegion]: {
         message: 'Missing region.',
     },
-    _a[AnalyticsValidationErrorCode.InvalidTracker] = {
+    [AnalyticsValidationErrorCode.InvalidTracker]: {
         message: 'Invalid tracker type specified.',
     },
-    _a[AnalyticsValidationErrorCode.UnsupportedPlatform] = {
+    [AnalyticsValidationErrorCode.UnsupportedPlatform]: {
         message: 'Only session tracking is supported on React Native.',
     },
-    _a[AnalyticsValidationErrorCode.InvalidFlushSize] = {
+    [AnalyticsValidationErrorCode.InvalidFlushSize]: {
         message: 'Invalid FlushSize, it should be smaller than BufferSize',
     },
-    _a[AnalyticsValidationErrorCode.NoTrackingId] = {
+    [AnalyticsValidationErrorCode.NoTrackingId]: {
         message: 'A trackingId is required to use Amazon Personalize',
     },
-    _a);
+};

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

@@ -5,7 +5,7 @@ import { getAnalyticsUserAgentString, resolveCredentials, } from '../../../utils
 import { getEventBuffer } from '../utils/getEventBuffer';
 import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
 import { ConsoleLogger } from '@aws-amplify/core';
-var logger = new ConsoleLogger('Kinesis');
+const logger = new ConsoleLogger('Kinesis');
 /**
  * Flushes all buffered Kinesis events to the service.
  *
@@ -13,22 +13,19 @@ var logger = new ConsoleLogger('Kinesis');
  * 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(), region = _a.region, flushSize = _a.flushSize, flushInterval = _a.flushInterval, bufferSize = _a.bufferSize, resendLimit = _a.resendLimit;
+export const flushEvents = () => {
+    const { region, flushSize, flushInterval, bufferSize, resendLimit } = resolveConfig();
     resolveCredentials()
-        .then(function (_a) {
-        var credentials = _a.credentials, identityId = _a.identityId;
-        return getEventBuffer({
-            region: region,
-            flushSize: flushSize,
-            flushInterval: flushInterval,
-            bufferSize: bufferSize,
-            credentials: credentials,
-            identityId: identityId,
-            resendLimit: resendLimit,
-            userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
-        });
-    })
-        .then(function (eventBuffer) { return eventBuffer.flushAll(); })
-        .catch(function (e) { return logger.warn('Failed to flush events.', e); });
+        .then(({ credentials, identityId }) => getEventBuffer({
+        region,
+        flushSize,
+        flushInterval,
+        bufferSize,
+        credentials,
+        identityId,
+        resendLimit,
+        userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
+    }))
+        .then(eventBuffer => eventBuffer.flushAll())
+        .catch(e => logger.warn('Failed to flush events.', e));
 };

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

@@ -6,38 +6,36 @@ import { getAnalyticsUserAgentString, isAnalyticsEnabled, resolveCredentials, }
 import { fromUtf8 } from '@smithy/util-utf8';
 import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
 import { ConsoleLogger } from '@aws-amplify/core';
-var logger = new ConsoleLogger('Kinesis');
-export var record = function (_a) {
-    var streamName = _a.streamName, partitionKey = _a.partitionKey, data = _a.data;
+const logger = new ConsoleLogger('Kinesis');
+export const record = ({ streamName, partitionKey, data, }) => {
     if (!isAnalyticsEnabled()) {
         logger.debug('Analytics is disabled, event will not be recorded.');
         return;
     }
-    var timestamp = Date.now();
-    var _b = resolveConfig(), region = _b.region, bufferSize = _b.bufferSize, flushSize = _b.flushSize, flushInterval = _b.flushInterval, resendLimit = _b.resendLimit;
+    const timestamp = Date.now();
+    const { region, bufferSize, flushSize, flushInterval, resendLimit } = resolveConfig();
     resolveCredentials()
-        .then(function (_a) {
-        var credentials = _a.credentials, identityId = _a.identityId;
-        var buffer = getEventBuffer({
-            region: region,
-            bufferSize: bufferSize,
-            flushSize: flushSize,
-            flushInterval: flushInterval,
-            credentials: credentials,
-            identityId: identityId,
-            resendLimit: resendLimit,
+        .then(({ credentials, identityId }) => {
+        const buffer = getEventBuffer({
+            region,
+            bufferSize,
+            flushSize,
+            flushInterval,
+            credentials,
+            identityId,
+            resendLimit,
             userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
         });
         buffer.append({
-            region: region,
-            streamName: streamName,
-            partitionKey: partitionKey,
+            region,
+            streamName,
+            partitionKey,
             event: ArrayBuffer.isView(data) ? data : fromUtf8(JSON.stringify(data)),
-            timestamp: timestamp,
+            timestamp,
             retryCount: 0,
         });
     })
-        .catch(function (e) {
+        .catch(e => {
         // An error occured while fetching credentials or persisting the event to the buffer
         logger.warn('Failed to record event.', e);
     });

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

@@ -1,6 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export var DEFAULT_KINESIS_CONFIG = {
+export const DEFAULT_KINESIS_CONFIG = {
     bufferSize: 1000,
     flushSize: 100,
     flushInterval: 5000,

package/lib-esm/providers/kinesis/utils/getEventBuffer.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, __read, __values } from "tslib";
 import { EventBuffer, groupBy } from '../../../utils';
 import { KinesisClient, PutRecordsCommand } from '@aws-sdk/client-kinesis';
 /**
@@ -11,88 +10,58 @@ import { KinesisClient, PutRecordsCommand } from '@aws-sdk/client-kinesis';
  * 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 createKinesisPutRecordsCommand = function (streamName, events) {
-    return new PutRecordsCommand({
-        StreamName: streamName,
-        Records: events.map(function (event) { return ({
-            PartitionKey: event.partitionKey,
-            Data: event.event,
-        }); }),
-    });
+const eventBufferMap = {};
+const cachedClients = {};
+const createKinesisPutRecordsCommand = (streamName, events) => new PutRecordsCommand({
+    StreamName: streamName,
+    Records: events.map(event => ({
+        PartitionKey: event.partitionKey,
+        Data: event.event,
+    })),
+});
+const submitEvents = async (events, client, resendLimit) => {
+    const groupedByStreamName = Object.entries(groupBy(event => event.streamName, events));
+    const requests = groupedByStreamName
+        .map(([streamName, events]) => createKinesisPutRecordsCommand(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 __awaiter(void 0, void 0, void 0, function () {
-    var groupedByStreamName, requests, responses, failedEvents;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                groupedByStreamName = Object.entries(groupBy(function (event) { return event.streamName; }, events));
-                requests = groupedByStreamName
-                    .map(function (_a) {
-                    var _b = __read(_a, 2), streamName = _b[0], events = _b[1];
-                    return createKinesisPutRecordsCommand(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 (__assign(__assign({}, event), { retryCount: event.retryCount + 1 })); })
-                            .sort(function (a, b) { return a.timestamp - b.timestamp; })
-                        : []];
-        }
-    });
-}); };
-export var getEventBuffer = function (_a) {
-    var e_1, _b;
-    var region = _a.region, flushInterval = _a.flushInterval, flushSize = _a.flushSize, bufferSize = _a.bufferSize, credentials = _a.credentials, identityId = _a.identityId, resendLimit = _a.resendLimit, userAgentValue = _a.userAgentValue;
-    var sessionToken = credentials.sessionToken;
-    var sessionIdentityKey = [region, sessionToken, identityId]
-        .filter(function (x) { return !!x; })
-        .join('-');
+export const getEventBuffer = ({ region, flushInterval, flushSize, bufferSize, credentials, identityId, resendLimit, userAgentValue, }) => {
+    const sessionIdentityKey = [region, identityId].filter(x => !!x).join('-');
     if (!eventBufferMap[sessionIdentityKey]) {
-        var getKinesisClient = function () {
+        const getKinesisClient = () => {
             if (!cachedClients[sessionIdentityKey]) {
                 cachedClients[sessionIdentityKey] = new KinesisClient({
-                    credentials: credentials,
-                    region: region,
+                    credentials,
+                    region,
                     customUserAgent: userAgentValue,
                 });
             }
-            return function (events) {
-                return submitEvents(events, cachedClients[sessionIdentityKey], resendLimit);
-            };
+            return events => submitEvents(events, cachedClients[sessionIdentityKey], resendLimit);
         };
         // create new session
         eventBufferMap[sessionIdentityKey] = new EventBuffer({
-            flushInterval: flushInterval,
-            flushSize: flushSize,
-            bufferSize: bufferSize,
+            flushInterval,
+            flushSize,
+            bufferSize,
         }, getKinesisClient);
         // release other sessions
-        var releaseSessionKeys = Object.keys(eventBufferMap).filter(function (x) { return x !== 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(x => x !== 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];