@aws-amplify/core 5.8.2 → 6.0.1-console-preview.7919075.0

package/lib-esm/Providers/AWSCloudWatchProvider.js

@@ -62,11 +62,13 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { CloudWatchLogsClient, CreateLogGroupCommand, CreateLogStreamCommand, DescribeLogGroupsCommand, DescribeLogStreamsCommand, GetLogEventsCommand, PutLogEventsCommand, } from '@aws-sdk/client-cloudwatch-logs';
-import { Credentials } from '../..';
+import { Credentials } from '../Credentials';
 import { ConsoleLogger as Logger } from '../Logger';
 import { getAmplifyUserAgentObject } from '../Platform';
 import { parseAWSExports } from '../parseAWSExports';
 import { AWS_CLOUDWATCH_BASE_BUFFER_SIZE, AWS_CLOUDWATCH_CATEGORY, AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE, AWS_CLOUDWATCH_MAX_EVENT_SIZE, AWS_CLOUDWATCH_PROVIDER_NAME, NO_CREDS_ERROR_STRING, RETRY_ERROR_CODES, } from '../Util/Constants';
+import { asserts } from '../Util/errors/AssertError';
+import { AWS_CLOUD_WATCH_PROVIDER_OPTIONS_EXCEPTION } from '../constants';
 var logger = new Logger('AWSCloudWatch');
 var AWSCloudWatchProvider = /** @class */ (function () {
     function AWSCloudWatchProvider(config) {
@@ -387,6 +389,7 @@ var AWSCloudWatchProvider = /** @class */ (function () {
         });
     };
     AWSCloudWatchProvider.prototype._initCloudWatchLogs = function () {
+        assertsAWSClouldWatchOptions(this._config);
         return new CloudWatchLogsClient({
             region: this._config.region,
             credentials: this._config.credentials,
@@ -401,6 +404,7 @@ var AWSCloudWatchProvider = /** @class */ (function () {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, Credentials.get()
                             .then(function (credentials) {
+                            assertsAWSClouldWatchOptions(_this._config);
                             if (!credentials)
                                 return false;
                             var cred = Credentials.shear(credentials);
@@ -423,12 +427,21 @@ var AWSCloudWatchProvider = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        assertsAWSClouldWatchOptions(this._config);
                         if (this._nextSequenceToken && this._nextSequenceToken.length > 0) {
                             return [2 /*return*/, this._nextSequenceToken];
                         }
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 4, , 5]);
+                        asserts(this._config.logGroupName !== undefined, {
+                            name: AWS_CLOUD_WATCH_PROVIDER_OPTIONS_EXCEPTION,
+                            message: ' log group name is undefined',
+                        });
+                        asserts(this._config.logStreamName !== undefined, {
+                            name: AWS_CLOUD_WATCH_PROVIDER_OPTIONS_EXCEPTION,
+                            message: ' log stream name is undefined',
+                        });
                         return [4 /*yield*/, this._validateLogGroupExistsAndCreate(this._config.logGroupName)];
                     case 2:
                         _a.sent();
@@ -455,9 +468,12 @@ var AWSCloudWatchProvider = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        return [4 /*yield*/, this._getNextSequenceToken()];
+                        assertsAWSClouldWatchOptions(this._config);
+                        _a.label = 1;
                     case 1:
+                        _a.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, this._getNextSequenceToken()];
+                    case 2:
                         seqToken = _a.sent();
                         logBatch = this._currentLogBatch.length === 0
                             ? this._getBufferedBatchOfLogs()
@@ -470,16 +486,16 @@ var AWSCloudWatchProvider = /** @class */ (function () {
                         };
                         this._dataTracker.eventUploadInProgress = true;
                         return [4 /*yield*/, this._sendLogEvents(putLogsPayload)];
-                    case 2:
+                    case 3:
                         sendLogEventsResponse = _a.sent();
-                        this._nextSequenceToken = sendLogEventsResponse.nextSequenceToken;
+                        this._nextSequenceToken = sendLogEventsResponse === null || sendLogEventsResponse === void 0 ? void 0 : sendLogEventsResponse.nextSequenceToken;
                         this._dataTracker.eventUploadInProgress = false;
                         this._currentLogBatch = [];
                         return [2 /*return*/, sendLogEventsResponse];
-                    case 3:
+                    case 4:
                         err_5 = _a.sent();
                         logger.error("error during _safeUploadLogEvents: ".concat(err_5));
-                        if (RETRY_ERROR_CODES.includes(err_5.name)) {
+                        if (err_5 instanceof Error && RETRY_ERROR_CODES.includes(err_5.name)) {
                             this._getNewSequenceTokenAndSubmit({
                                 logEvents: this._currentLogBatch,
                                 logGroupName: this._config.logGroupName,
@@ -490,13 +506,14 @@ var AWSCloudWatchProvider = /** @class */ (function () {
                             this._dataTracker.eventUploadInProgress = false;
                             throw err_5;
                         }
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
                 }
             });
         });
     };
     AWSCloudWatchProvider.prototype._getBufferedBatchOfLogs = function () {
+        var _a;
         /**
          * CloudWatch has restrictions on the size of the log events that get sent up.
          * We need to track both the size of each event and the total size of the batch
@@ -516,7 +533,7 @@ var AWSCloudWatchProvider = /** @class */ (function () {
             if (eventSize > AWS_CLOUDWATCH_MAX_EVENT_SIZE) {
                 var errString = "Log entry exceeds maximum size for CloudWatch logs. Log size: ".concat(eventSize, ". Truncating log message.");
                 logger.warn(errString);
-                currentEvent.message = currentEvent.message.substring(0, eventSize);
+                currentEvent.message = (_a = currentEvent.message) === null || _a === void 0 ? void 0 : _a.substring(0, eventSize);
             }
             if (totalByteSize + eventSize > AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE)
                 break;
@@ -590,4 +607,10 @@ var AWSCloudWatchProvider = /** @class */ (function () {
     AWSCloudWatchProvider.CATEGORY = AWS_CLOUDWATCH_CATEGORY;
     return AWSCloudWatchProvider;
 }());
+function assertsAWSClouldWatchOptions(options) {
+    return asserts(options !== undefined, {
+        name: AWS_CLOUD_WATCH_PROVIDER_OPTIONS_EXCEPTION,
+        message: 'AWSCloudWatchProviderOptions cannot be undefined',
+    });
+}
 export { AWSCloudWatchProvider };

package/lib-esm/RNComponents/index.d.ts

@@ -1,5 +1,5 @@
 export declare const Linking: {};
 export declare const AppState: {
-    addEventListener: (action: any, handler: any) => any;
+    addEventListener: (action: any, handler: any) => undefined;
 };
 export declare const AsyncStorage: any;

package/lib-esm/RNComponents/reactnative.js

@@ -1,5 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+// @ts-ignore
 import { Linking, AppState } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 export { Linking, AppState, AsyncStorage };

package/lib-esm/ServiceWorker/ServiceWorker.d.ts

@@ -11,10 +11,10 @@
  * events based on the service worker lifecycle.
  */
 export declare class ServiceWorkerClass {
-    private _serviceWorker;
-    private _registration;
-    private _publicKey;
-    private _subscription;
+    private _serviceWorker?;
+    private _registration?;
+    private _publicKey?;
+    private _subscription?;
     private _logger;
     constructor();
     /**

package/lib-esm/ServiceWorker/ServiceWorker.js

@@ -15,6 +15,9 @@
 import { ConsoleLogger as Logger } from '../Logger';
 import { browserOrNode } from '../JS';
 import { Amplify } from '../Amplify';
+import { asserts } from '../Util/errors/AssertError';
+import { AmplifyError } from '../Errors';
+import { SERVICE_WORKER_EXCEPTION } from '../constants';
 /**
  * Provides a means to registering a service worker in the browser
  * and communicating with it via postMessage events.
@@ -37,6 +40,10 @@ var ServiceWorkerClass = /** @class */ (function () {
          * Get the currently active service worker
          */
         get: function () {
+            asserts(this._serviceWorker !== undefined, {
+                name: SERVICE_WORKER_EXCEPTION,
+                message: 'Service Worker instance is undefined',
+            });
             return this._serviceWorker;
         },
         enumerable: false,
@@ -83,11 +90,18 @@ var ServiceWorkerClass = /** @class */ (function () {
                 })
                     .catch(function (error) {
                     _this._logger.debug("Service Worker Registration Failed ".concat(error));
-                    return reject(error);
+                    return reject(new AmplifyError({
+                        name: SERVICE_WORKER_EXCEPTION,
+                        message: 'Service Worker not available',
+                        underlyingError: error,
+                    }));
                 });
             }
             else {
-                return reject(new Error('Service Worker not available'));
+                return reject(new AmplifyError({
+                    name: SERVICE_WORKER_EXCEPTION,
+                    message: 'Service Worker not available',
+                }));
             }
         });
     };
@@ -104,11 +118,17 @@ var ServiceWorkerClass = /** @class */ (function () {
      */
     ServiceWorkerClass.prototype.enablePush = function (publicKey) {
         var _this = this;
-        if (!this._registration)
-            throw new Error('Service Worker not registered');
+        asserts(this._registration !== undefined, {
+            name: SERVICE_WORKER_EXCEPTION,
+            message: 'Service Worker registration is undefined',
+        });
         this._publicKey = publicKey;
         return new Promise(function (resolve, reject) {
             if (browserOrNode().isBrowser) {
+                asserts(_this._registration !== undefined, {
+                    name: SERVICE_WORKER_EXCEPTION,
+                    message: 'Service Worker registration is undefined',
+                });
                 _this._registration.pushManager.getSubscription().then(function (subscription) {
                     if (subscription) {
                         _this._subscription = subscription;
@@ -117,8 +137,7 @@ var ServiceWorkerClass = /** @class */ (function () {
                     }
                     else {
                         _this._logger.debug("User is NOT subscribed to push");
-                        return _this._registration.pushManager
-                            .subscribe({
+                        return _this._registration.pushManager.subscribe({
                             userVisibleOnly: true,
                             applicationServerKey: _this._urlB64ToUint8Array(publicKey),
                         })
@@ -134,7 +153,10 @@ var ServiceWorkerClass = /** @class */ (function () {
                 });
             }
             else {
-                return reject(new Error('Service Worker not available'));
+                return reject(new AmplifyError({
+                    name: SERVICE_WORKER_EXCEPTION,
+                    message: 'Service Worker not available',
+                }));
             }
         });
     };
@@ -173,10 +195,11 @@ var ServiceWorkerClass = /** @class */ (function () {
      **/
     ServiceWorkerClass.prototype._setupListeners = function () {
         var _this = this;
-        this._serviceWorker.addEventListener('statechange', function (event) {
-            var currentState = _this._serviceWorker.state;
+        this.serviceWorker.addEventListener('statechange', function (event) {
+            var currentState = _this.serviceWorker.state;
             _this._logger.debug("ServiceWorker statechange: ".concat(currentState));
-            if (Amplify.Analytics && typeof Amplify.Analytics.record === 'function') {
+            Amplify.Analytics;
+            if (isAmplifyWithAnalytics(Amplify)) {
                 Amplify.Analytics.record({
                     name: 'ServiceWorker',
                     attributes: {
@@ -185,10 +208,13 @@ var ServiceWorkerClass = /** @class */ (function () {
                 });
             }
         });
-        this._serviceWorker.addEventListener('message', function (event) {
+        this.serviceWorker.addEventListener('message', function (event) {
             _this._logger.debug("ServiceWorker message event: ".concat(event));
         });
     };
     return ServiceWorkerClass;
 }());
 export { ServiceWorkerClass };
+function isAmplifyWithAnalytics(amplify) {
+    return amplify.Analytics && typeof amplify.Analytics.record === 'function';
+}

package/lib-esm/Signer.d.ts

@@ -35,7 +35,20 @@ export declare class Signer {
     *
     * @returns {object} Signed HTTP request
     */
-    static sign(request: any, accessInfo: any, serviceInfo: any): any;
+    static sign(request: {
+        headers: any;
+        body?: BodyInit;
+        data?: any;
+        url: string;
+        method: string;
+    }, accessInfo: {
+        access_key: string;
+        secret_key: string;
+        session_token: string;
+    }, serviceInfo: {
+        service: string;
+        region: string;
+    }): any;
     static signUrl(urlToSign: string, accessInfo: any, serviceInfo?: any, expiration?: number): string;
     static signUrl(request: any, accessInfo: any, serviceInfo?: any, expiration?: number): string;
 }

package/lib-esm/StorageHelper/cookieStorage.d.ts

@@ -0,0 +1,13 @@
+import { CookieStorageData, KeyValueStorageInterface, SameSite } from '../types';
+export declare class CookieStorage implements KeyValueStorageInterface {
+    domain?: string;
+    path: string;
+    expires?: number;
+    secure?: boolean;
+    sameSite?: SameSite;
+    constructor(data?: CookieStorageData);
+    setItem(key: string, value: string): Promise<void>;
+    getItem(key: string): Promise<string>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/lib-esm/StorageHelper/cookieStorage.js

@@ -0,0 +1,141 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+// @ts-ignore
+import * as Cookies from 'js-cookie';
+var CookieStorage = /** @class */ (function () {
+    function CookieStorage(data) {
+        if (data === void 0) { data = {}; }
+        if (data.domain) {
+            this.domain = data.domain;
+        }
+        if (data.path) {
+            this.path = data.path;
+        }
+        else {
+            this.path = '/';
+        }
+        if (Object.prototype.hasOwnProperty.call(data, 'expires')) {
+            this.expires = data.expires;
+        }
+        else {
+            this.expires = 365;
+        }
+        if (Object.prototype.hasOwnProperty.call(data, 'secure')) {
+            this.secure = data.secure;
+        }
+        else {
+            this.secure = true;
+        }
+        if (data.hasOwnProperty('sameSite')) {
+            if (!data.sameSite ||
+                !['strict', 'lax', 'none'].includes(data.sameSite)) {
+                throw new Error('The sameSite value of cookieStorage must be "lax", "strict" or "none".');
+            }
+            if (data.sameSite === 'none' && !this.secure) {
+                throw new Error('sameSite = None requires the Secure attribute in latest browser versions.');
+            }
+            this.sameSite = data.sameSite;
+        }
+    }
+    CookieStorage.prototype.setItem = function (key, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var options;
+            return __generator(this, function (_a) {
+                options = {
+                    path: this.path,
+                    expires: this.expires,
+                    domain: this.domain,
+                    secure: this.secure,
+                };
+                if (this.sameSite) {
+                    options.sameSite = this.sameSite;
+                }
+                Cookies.set(key, value, options);
+                return [2 /*return*/, Cookies.get(key)];
+            });
+        });
+    };
+    CookieStorage.prototype.getItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Cookies.get(key)];
+            });
+        });
+    };
+    CookieStorage.prototype.removeItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            var options;
+            return __generator(this, function (_a) {
+                options = {
+                    path: this.path,
+                    expires: this.expires,
+                    domain: this.domain,
+                    secure: this.secure,
+                };
+                if (this.sameSite) {
+                    options.sameSite = this.sameSite;
+                }
+                Cookies.remove(key, options);
+                return [2 /*return*/];
+            });
+        });
+    };
+    CookieStorage.prototype.clear = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var cookies, numKeys, promiseArray, index;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        cookies = Cookies.get();
+                        numKeys = Object.keys(cookies).length;
+                        promiseArray = [];
+                        for (index = 0; index < numKeys; ++index) {
+                            promiseArray.push(this.removeItem(Object.keys(cookies)[index]));
+                        }
+                        return [4 /*yield*/, Promise.all(promiseArray)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return CookieStorage;
+}());
+export { CookieStorage };

package/lib-esm/StorageHelper/inMemoryStorage.d.ts

@@ -0,0 +1,10 @@
+import { KeyValueStorageInterface } from '../types';
+declare class MemoryKeyValueStorageClass implements KeyValueStorageInterface {
+    myStorage: Record<string, string>;
+    setItem(key: string, value: string): Promise<void>;
+    getItem(key: string): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare const MemoryKeyValueStorage: MemoryKeyValueStorageClass;
+export {};

package/lib-esm/StorageHelper/inMemoryStorage.js

@@ -0,0 +1,79 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var MemoryKeyValueStorageClass = /** @class */ (function () {
+    function MemoryKeyValueStorageClass() {
+        this.myStorage = {};
+    }
+    MemoryKeyValueStorageClass.prototype.setItem = function (key, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.myStorage[key] = value;
+                return [2 /*return*/];
+            });
+        });
+    };
+    MemoryKeyValueStorageClass.prototype.getItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.myStorage[key]];
+            });
+        });
+    };
+    MemoryKeyValueStorageClass.prototype.removeItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                delete this.myStorage[key];
+                return [2 /*return*/];
+            });
+        });
+    };
+    MemoryKeyValueStorageClass.prototype.clear = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                Object.keys(this.myStorage).forEach(function (key) {
+                    delete _this.myStorage[key];
+                });
+                return [2 /*return*/];
+            });
+        });
+    };
+    return MemoryKeyValueStorageClass;
+}());
+export var MemoryKeyValueStorage = new MemoryKeyValueStorageClass();

package/lib-esm/StorageHelper/index.d.ts

@@ -6,14 +6,14 @@ export declare class MemoryStorage {
      * @param {object} value - the value
      * @returns {string} value that was set
      */
-    static setItem(key: string, value: any): any;
+    static setItem(key: string, value: any): string;
     /**
      * This is used to get a specific key from storage
      * @param {string} key - the key for the item
      * This is used to clear the storage
      * @returns {string} the data item
      */
-    static getItem(key: string): any;
+    static getItem(key: string): string | undefined;
     /**
      * This is used to remove an item from storage
      * @param {string} key - the key being set
@@ -24,7 +24,7 @@ export declare class MemoryStorage {
      * This is used to clear the storage
      * @returns {string} nothing
      */
-    static clear(): {};
+    static clear(): Record<string, string>;
 }
 export declare class StorageHelper {
     private storageWindow;
@@ -39,3 +39,7 @@ export declare class StorageHelper {
      */
     getStorage(): any;
 }
+export { SessionStorage } from './sessionStorage';
+export { LocalStorage } from './localStorage';
+export { MemoryKeyValueStorage } from './inMemoryStorage';
+export { CookieStorage } from './cookieStorage';

package/lib-esm/StorageHelper/index.js

@@ -70,3 +70,7 @@ var StorageHelper = /** @class */ (function () {
     return StorageHelper;
 }());
 export { StorageHelper };
+export { SessionStorage } from './sessionStorage';
+export { LocalStorage } from './localStorage';
+export { MemoryKeyValueStorage } from './inMemoryStorage';
+export { CookieStorage } from './cookieStorage';

package/lib-esm/StorageHelper/localStorage.d.ts

@@ -0,0 +1,32 @@
+import { KeyValueStorageInterface } from "../types";
+declare class LocalStorageClass implements KeyValueStorageInterface {
+    storage?: Storage;
+    constructor();
+    /**
+     * This is used to set a specific item in storage
+     * @param {string} key - the key for the item
+     * @param {object} value - the value
+     * @returns {string} value that was set
+     */
+    setItem(key: string, value: string): Promise<void>;
+    /**
+     * This is used to get a specific key from storage
+     * @param {string} key - the key for the item
+     * This is used to clear the storage
+     * @returns {string} the data item
+     */
+    getItem(key: string): Promise<string | null>;
+    /**
+     * This is used to remove an item from storage
+     * @param {string} key - the key being set
+     * @returns {string} value - value that was deleted
+     */
+    removeItem(key: string): Promise<void>;
+    /**
+     * This is used to clear the storage
+     * @returns {string} nothing
+     */
+    clear(): Promise<void>;
+}
+export declare const LocalStorage: LocalStorageClass;
+export {};