@aws-amplify/core 6.0.1-console-preview.7739091.0 → 6.0.1-preview-testing.64b45b1.0

package/lib/types/storage.d.ts

@@ -8,9 +8,6 @@ export type SameSite = 'strict' | 'lax' | 'none';
 export type CookieStorageData = {
     domain?: string;
     path?: string;
-    /**
-     * Expiration in days
-     */
     expires?: number;
     secure?: boolean;
     sameSite?: SameSite;

package/lib-esm/AwsClients/CognitoIdentity/base.d.ts

@@ -1,16 +1,24 @@
-import { Endpoint, Headers, HttpRequest, HttpResponse } from '../../clients';
-import { DefaultConfigOptions } from '../../clients/types';
+import { Endpoint, EndpointResolverOptions, Headers, HttpRequest, HttpResponse } from '../../clients';
 /**
  * A Cognito Identity-specific transfer handler that does NOT sign requests, and
  * disables caching.
  *
  * @internal
  */
-export declare const cognitoIdentityTransferHandler: (request: HttpRequest, options: import("../../clients").UserAgentOptions & import("../../clients").RetryOptions<HttpResponse>) => Promise<HttpResponse>;
+export declare const cognitoIdentityTransferHandler: (request: HttpRequest, options: import("../../clients").UserAgentOptions & import("../../clients").RetryOptions<HttpResponse> & import("../../clients").HttpTransferOptions) => Promise<HttpResponse>;
 /**
  * @internal
  */
-export declare const defaultConfig: DefaultConfigOptions;
+export declare const defaultConfig: {
+    service: string;
+    endpointResolver: ({ region }: EndpointResolverOptions) => {
+        url: URL;
+    };
+    retryDecider: (response?: HttpResponse | undefined, error?: unknown) => Promise<boolean>;
+    computeDelay: (attempt: number) => number;
+    userAgentValue: string;
+    cache: string;
+};
 /**
  * @internal
  */

package/lib-esm/AwsClients/CognitoIdentity/base.js

@@ -83,6 +83,7 @@ export var defaultConfig = {
     retryDecider: getRetryDecider(parseJsonError),
     computeDelay: jitteredBackoff,
     userAgentValue: getAmplifyUserAgent(),
+    cache: 'no-store',
 };
 observeFrameworkChanges(function () {
     defaultConfig.userAgentValue = getAmplifyUserAgent();

package/lib-esm/AwsClients/CognitoIdentity/getCredentialsForIdentity.d.ts

@@ -1,9 +1,21 @@
-import { HttpResponse } from '../../clients';
+import { Endpoint, HttpResponse } from '../../clients';
 import type { GetCredentialsForIdentityCommandInput as GetCredentialsForIdentityInput, GetCredentialsForIdentityCommandOutput as GetCredentialsForIdentityOutput } from './types';
 export type { GetCredentialsForIdentityInput, GetCredentialsForIdentityOutput };
 /**
  * @internal
  */
-export declare const getCredentialsForIdentity: (config: Omit<import("../../clients").UserAgentOptions & import("../../clients").RetryOptions<HttpResponse> & import("../../clients").ServiceClientOptions & Partial<Record<string, unknown> & import("../../clients").ServiceClientOptions> & import("../../clients").EndpointResolverOptions, string> & {
-    [x: string]: unknown;
+export declare const getCredentialsForIdentity: (config: {
+    service?: string | undefined;
+    endpointResolver?: (((options: import("../../clients").EndpointResolverOptions, input?: any) => Endpoint) & (({ region }: import("../../clients").EndpointResolverOptions) => {
+        url: URL;
+    })) | undefined;
+    retryDecider?: (((response?: HttpResponse | undefined, error?: unknown) => Promise<boolean>) & ((response?: HttpResponse | undefined, error?: unknown) => Promise<boolean>)) | undefined;
+    computeDelay?: ((attempt: number) => number) | undefined;
+    userAgentValue?: string | undefined;
+    cache?: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
+} & {
+    region: string;
+    abortSignal?: AbortSignal | undefined;
+    maxAttempts?: number | undefined;
+    userAgentHeader?: string | undefined;
 }, input: GetCredentialsForIdentityInput) => Promise<GetCredentialsForIdentityOutput>;

package/lib-esm/AwsClients/CognitoIdentity/getId.d.ts

@@ -1,9 +1,21 @@
-import { HttpResponse } from '../../clients';
+import { Endpoint, HttpResponse } from '../../clients';
 import { GetIdCommandInput as GetIdInput, GetIdCommandOutput as GetIdOutput } from './types';
 export type { GetIdInput, GetIdOutput };
 /**
  * @internal
  */
-export declare const getId: (config: Omit<import("../../clients").UserAgentOptions & import("../../clients").RetryOptions<HttpResponse> & import("../../clients").ServiceClientOptions & Partial<Record<string, unknown> & import("../../clients").ServiceClientOptions> & import("../../clients").EndpointResolverOptions, string> & {
-    [x: string]: unknown;
+export declare const getId: (config: {
+    service?: string | undefined;
+    endpointResolver?: (((options: import("../../clients").EndpointResolverOptions, input?: any) => Endpoint) & (({ region }: import("../../clients").EndpointResolverOptions) => {
+        url: URL;
+    })) | undefined;
+    retryDecider?: (((response?: HttpResponse | undefined, error?: unknown) => Promise<boolean>) & ((response?: HttpResponse | undefined, error?: unknown) => Promise<boolean>)) | undefined;
+    computeDelay?: ((attempt: number) => number) | undefined;
+    userAgentValue?: string | undefined;
+    cache?: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload" | undefined;
+} & {
+    region: string;
+    abortSignal?: AbortSignal | undefined;
+    maxAttempts?: number | undefined;
+    userAgentHeader?: string | undefined;
 }, input: GetIdInput) => Promise<GetIdOutput>;

package/lib-esm/AwsClients/Pinpoint/base.d.ts

@@ -1,8 +1,16 @@
-import type { DefaultConfigOptions, Headers } from '../../clients/types';
+import type { EndpointResolverOptions, Headers } from '../../clients/types';
 /**
  * @internal
  */
-export declare const defaultConfig: DefaultConfigOptions;
+export declare const defaultConfig: {
+    service: string;
+    endpointResolver: ({ region }: EndpointResolverOptions) => {
+        url: URL;
+    };
+    retryDecider: (response?: import("../../clients/types").HttpResponse | undefined, error?: unknown) => Promise<boolean>;
+    computeDelay: (attempt: number) => number;
+    userAgentValue: string;
+};
 /**
  * @internal
  */

package/lib-esm/AwsClients/Pinpoint/getInAppMessages.d.ts

@@ -1,9 +1,23 @@
-import { HttpResponse } from '../../clients/types';
+import { Endpoint, HttpResponse } from '../../clients/types';
 import type { GetInAppMessagesCommandInput as GetInAppMessagesInput, GetInAppMessagesCommandOutput as GetInAppMessagesOutput } from './types';
 export type { GetInAppMessagesInput, GetInAppMessagesOutput };
 /**
  * @internal
  */
-export declare const getInAppMessages: (config: Omit<import("../../clients").UserAgentOptions & import("../../clients").RetryOptions<HttpResponse> & import("../../clients").SigningOptions & import("../../clients/types").ServiceClientOptions & Partial<Record<string, unknown> & import("../../clients/types").ServiceClientOptions> & import("../../clients/types").EndpointResolverOptions, string> & {
-    [x: string]: unknown;
+export declare const getInAppMessages: (config: {
+    service?: string | undefined;
+    endpointResolver?: (((options: import("../../clients/types").EndpointResolverOptions, input?: any) => Endpoint) & (({ region }: import("../../clients/types").EndpointResolverOptions) => {
+        url: URL;
+    })) | undefined;
+    retryDecider?: (((response?: HttpResponse | undefined, error?: unknown) => Promise<boolean>) & ((response?: HttpResponse | undefined, error?: unknown) => Promise<boolean>)) | undefined;
+    computeDelay?: ((attempt: number) => number) | undefined;
+    userAgentValue?: string | undefined;
+} & {
+    uriEscapePath?: boolean | undefined;
+    credentials: import("@aws-sdk/types/dist-types/credentials").Credentials | (() => Promise<import("@aws-sdk/types/dist-types/credentials").Credentials>);
+    region: string;
+    abortSignal?: AbortSignal | undefined;
+    cache?: RequestCache | undefined;
+    maxAttempts?: number | undefined;
+    userAgentHeader?: string | undefined;
 }, input: GetInAppMessagesInput) => Promise<GetInAppMessagesOutput>;

package/lib-esm/AwsClients/Pinpoint/putEvents.d.ts

@@ -1,9 +1,23 @@
-import { HttpResponse } from '../../clients/types';
+import { Endpoint, HttpResponse } from '../../clients/types';
 import type { PutEventsCommandInput as PutEventsInput, PutEventsCommandOutput as PutEventsOutput } from './types';
 export type { PutEventsInput, PutEventsOutput };
 /**
  * @internal
  */
-export declare const putEvents: (config: Omit<import("../../clients").UserAgentOptions & import("../../clients").RetryOptions<HttpResponse> & import("../../clients").SigningOptions & import("../../clients/types").ServiceClientOptions & Partial<Record<string, unknown> & import("../../clients/types").ServiceClientOptions> & import("../../clients/types").EndpointResolverOptions, string> & {
-    [x: string]: unknown;
+export declare const putEvents: (config: {
+    service?: string | undefined;
+    endpointResolver?: (((options: import("../../clients/types").EndpointResolverOptions, input?: any) => Endpoint) & (({ region }: import("../../clients/types").EndpointResolverOptions) => {
+        url: URL;
+    })) | undefined;
+    retryDecider?: (((response?: HttpResponse | undefined, error?: unknown) => Promise<boolean>) & ((response?: HttpResponse | undefined, error?: unknown) => Promise<boolean>)) | undefined;
+    computeDelay?: ((attempt: number) => number) | undefined;
+    userAgentValue?: string | undefined;
+} & {
+    uriEscapePath?: boolean | undefined;
+    credentials: import("@aws-sdk/types/dist-types/credentials").Credentials | (() => Promise<import("@aws-sdk/types/dist-types/credentials").Credentials>);
+    region: string;
+    abortSignal?: AbortSignal | undefined;
+    cache?: RequestCache | undefined;
+    maxAttempts?: number | undefined;
+    userAgentHeader?: string | undefined;
 }, input: PutEventsInput) => Promise<PutEventsOutput>;

package/lib-esm/AwsClients/Pinpoint/updateEndpoint.d.ts

@@ -1,9 +1,23 @@
-import { HttpResponse } from '../../clients/types';
+import { Endpoint, HttpResponse } from '../../clients/types';
 import type { UpdateEndpointCommandInput as UpdateEndpointInput, UpdateEndpointCommandOutput as UpdateEndpointOutput } from './types';
 export type { UpdateEndpointInput, UpdateEndpointOutput };
 /**
  * @internal
  */
-export declare const updateEndpoint: (config: Omit<import("../../clients").UserAgentOptions & import("../../clients").RetryOptions<HttpResponse> & import("../../clients").SigningOptions & import("../../clients/types").ServiceClientOptions & Partial<Record<string, unknown> & import("../../clients/types").ServiceClientOptions> & import("../../clients/types").EndpointResolverOptions, string> & {
-    [x: string]: unknown;
+export declare const updateEndpoint: (config: {
+    service?: string | undefined;
+    endpointResolver?: (((options: import("../../clients/types").EndpointResolverOptions, input?: any) => Endpoint) & (({ region }: import("../../clients/types").EndpointResolverOptions) => {
+        url: URL;
+    })) | undefined;
+    retryDecider?: (((response?: HttpResponse | undefined, error?: unknown) => Promise<boolean>) & ((response?: HttpResponse | undefined, error?: unknown) => Promise<boolean>)) | undefined;
+    computeDelay?: ((attempt: number) => number) | undefined;
+    userAgentValue?: string | undefined;
+} & {
+    uriEscapePath?: boolean | undefined;
+    credentials: import("@aws-sdk/types/dist-types/credentials").Credentials | (() => Promise<import("@aws-sdk/types/dist-types/credentials").Credentials>);
+    region: string;
+    abortSignal?: AbortSignal | undefined;
+    cache?: RequestCache | undefined;
+    maxAttempts?: number | undefined;
+    userAgentHeader?: string | undefined;
 }, input: UpdateEndpointInput) => Promise<UpdateEndpointOutput>;

package/lib-esm/Cache/Utils/CacheUtils.js

@@ -1,6 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { getDefaultStorageWithFallback } from '../../storage/utils';
+import { StorageHelper } from '../../StorageHelper';
 /**
  * Default cache config
  */
@@ -11,7 +11,9 @@ export var defaultConfig = {
     defaultTTL: 259200000,
     defaultPriority: 5,
     warningThreshold: 0.8,
-    storage: getDefaultStorageWithFallback(),
+    // the storage helper will check if localStorage exists,
+    // if not, will use a in-memory object instead
+    storage: new StorageHelper().getStorage(),
 };
 /**
  * return the byte size of the string

package/lib-esm/Platform/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.0.1-console-preview.7739091.0+7739091";
+export declare const version = "6.0.1-preview-testing.64b45b1.0+64b45b1";

package/lib-esm/Platform/version.js

@@ -1,2 +1,2 @@
 // generated by genversion
-export var version = '6.0.1-console-preview.7739091.0+7739091';
+export var version = '6.0.1-preview-testing.64b45b1.0+64b45b1';

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

@@ -3,4 +3,4 @@ export declare const AppState: {
     addEventListener: (action: any, handler: any) => undefined;
     currentState: string;
 };
-export declare const AsyncStorage: Storage | undefined;
+export declare const AsyncStorage: any;

package/lib-esm/RNComponents/index.js

@@ -1,7 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { getDefaultStorageWithFallback } from '../storage/utils';
 import { isBrowser } from '../Util/JS';
+import { StorageHelper } from '../StorageHelper';
 export var Linking = {};
 export var AppState = {
     addEventListener: function (action, handler) { return undefined; },
@@ -9,5 +9,5 @@ export var AppState = {
 };
 // if not in react native, just use local storage
 export var AsyncStorage = isBrowser()
-    ? getDefaultStorageWithFallback()
+    ? new StorageHelper().getStorage()
     : undefined;

package/{lib/storage/CookieStorage.d.ts → lib-esm/StorageHelper/cookieStorage.d.ts}

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

package/lib-esm/{storage/CookieStorage.js → StorageHelper/cookieStorage.js}

@@ -1,16 +1,3 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 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) {
@@ -47,60 +34,101 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-import { get as getJsCookie, remove as removeJsCookie, set as setJsCookie, } from 'js-cookie';
+// 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 = {}; }
-        var path = data.path, domain = data.domain, expires = data.expires, sameSite = data.sameSite, secure = data.secure;
-        this.domain = domain;
-        this.path = path ? path : '/';
-        this.expires = data.hasOwnProperty('expires') ? expires : 365;
-        this.secure = data.hasOwnProperty('secure') ? secure : true;
+        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 (!sameSite || !['strict', 'lax', 'none'].includes(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 (sameSite === 'none' && !this.secure) {
+            if (data.sameSite === 'none' && !this.secure) {
                 throw new Error('sameSite = None requires the Secure attribute in latest browser versions.');
             }
-            this.sameSite = sameSite;
+            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) {
-                setJsCookie(key, value, this.getData());
-                return [2 /*return*/];
+                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 () {
-            var item;
             return __generator(this, function (_a) {
-                item = getJsCookie(key);
-                return [2 /*return*/, item !== null && item !== void 0 ? item : null];
+                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) {
-                removeJsCookie(key, this.getData());
+                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 cookie, promises;
-            var _this = this;
+            var cookies, numKeys, promiseArray, index;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        cookie = getJsCookie();
-                        promises = Object.keys(cookie).map(function (key) { return _this.removeItem(key); });
-                        return [4 /*yield*/, Promise.all(promises)];
+                        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*/];
@@ -108,9 +136,6 @@ var CookieStorage = /** @class */ (function () {
             });
         });
     };
-    CookieStorage.prototype.getData = function () {
-        return __assign({ path: this.path, expires: this.expires, domain: this.domain, secure: this.secure }, (this.sameSite && { sameSite: this.sameSite }));
-    };
     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

@@ -0,0 +1,45 @@
+/** @class */
+export declare class MemoryStorage {
+    /**
+     * 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
+     */
+    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): string | undefined;
+    /**
+     * This is used to remove an item from storage
+     * @param {string} key - the key being set
+     * @returns {string} value - value that was deleted
+     */
+    static removeItem(key: string): boolean;
+    /**
+     * This is used to clear the storage
+     * @returns {string} nothing
+     */
+    static clear(): Record<string, string>;
+}
+export declare class StorageHelper {
+    private storageWindow;
+    /**
+     * This is used to get a storage object
+     * @returns {object} the storage
+     */
+    constructor();
+    /**
+     * This is used to return the storage
+     * @returns {object} the storage
+     */
+    getStorage(): any;
+}
+export { SessionStorage } from './sessionStorage';
+export { LocalStorage } from './localStorage';
+export { MemoryKeyValueStorage } from './inMemoryStorage';
+export { CookieStorage } from './cookieStorage';

package/lib-esm/StorageHelper/index.js

@@ -0,0 +1,76 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+var dataMemory = {};
+/** @class */
+var MemoryStorage = /** @class */ (function () {
+    function MemoryStorage() {
+    }
+    /**
+     * 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
+     */
+    MemoryStorage.setItem = function (key, value) {
+        dataMemory[key] = value;
+        return dataMemory[key];
+    };
+    /**
+     * 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
+     */
+    MemoryStorage.getItem = function (key) {
+        return Object.prototype.hasOwnProperty.call(dataMemory, key)
+            ? dataMemory[key]
+            : undefined;
+    };
+    /**
+     * This is used to remove an item from storage
+     * @param {string} key - the key being set
+     * @returns {string} value - value that was deleted
+     */
+    MemoryStorage.removeItem = function (key) {
+        return delete dataMemory[key];
+    };
+    /**
+     * This is used to clear the storage
+     * @returns {string} nothing
+     */
+    MemoryStorage.clear = function () {
+        dataMemory = {};
+        return dataMemory;
+    };
+    return MemoryStorage;
+}());
+export { MemoryStorage };
+var StorageHelper = /** @class */ (function () {
+    /**
+     * This is used to get a storage object
+     * @returns {object} the storage
+     */
+    function StorageHelper() {
+        try {
+            this.storageWindow = window.localStorage;
+            this.storageWindow.setItem('aws.amplify.test-ls', 1);
+            this.storageWindow.removeItem('aws.amplify.test-ls');
+        }
+        catch (exception) {
+            this.storageWindow = MemoryStorage;
+        }
+    }
+    /**
+     * This is used to return the storage
+     * @returns {object} the storage
+     */
+    StorageHelper.prototype.getStorage = function () {
+        return this.storageWindow;
+    };
+    return StorageHelper;
+}());
+export { StorageHelper };
+export { SessionStorage } from './sessionStorage';
+export { LocalStorage } from './localStorage';
+export { MemoryKeyValueStorage } from './inMemoryStorage';
+export { CookieStorage } from './cookieStorage';