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

package/lib-esm/StorageHelper/localStorage.js

@@ -0,0 +1,111 @@
+// 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 };
+    }
+};
+import { PlatformNotSupportedError } from '../Errors';
+var LocalStorageClass = /** @class */ (function () {
+    function LocalStorageClass() {
+        if (typeof window !== undefined) {
+            try {
+                this.storage = window === null || window === void 0 ? void 0 : window.localStorage;
+            }
+            catch (error) { }
+        }
+    }
+    /**
+     * 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
+     */
+    LocalStorageClass.prototype.setItem = function (key, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this.storage)
+                    throw PlatformNotSupportedError;
+                this.storage.setItem(key, value);
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * 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
+     */
+    LocalStorageClass.prototype.getItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this.storage)
+                    throw PlatformNotSupportedError;
+                return [2 /*return*/, this.storage.getItem(key)];
+            });
+        });
+    };
+    /**
+     * This is used to remove an item from storage
+     * @param {string} key - the key being set
+     * @returns {string} value - value that was deleted
+     */
+    LocalStorageClass.prototype.removeItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this.storage)
+                    throw PlatformNotSupportedError;
+                this.storage.removeItem(key);
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * This is used to clear the storage
+     * @returns {string} nothing
+     */
+    LocalStorageClass.prototype.clear = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this.storage)
+                    throw PlatformNotSupportedError;
+                this.storage.clear();
+                return [2 /*return*/];
+            });
+        });
+    };
+    return LocalStorageClass;
+}());
+export var LocalStorage = new LocalStorageClass();

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

@@ -1,3 +1,38 @@
+import { KeyValueStorageInterface } from '../types';
+/** @class */
+declare class MemoryStorage {
+    static syncPromise: Promise<void> | null;
+    /**
+     * 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: string): string | null | undefined;
+    /**
+     * 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 | null | 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 | null>;
+    /**
+     * Will sync the MemoryStorage data from AsyncStorage to storageWindow MemoryStorage
+     * @returns {void}
+     */
+    static sync(): Promise<void>;
+}
 export declare class StorageHelper {
     private storageWindow;
     /**
@@ -9,5 +44,40 @@ export declare class StorageHelper {
      * This is used to return the storage
      * @returns {object} the storage
      */
-    getStorage(): any;
+    getStorage(): typeof MemoryStorage;
+}
+declare class AsyncStorageClass implements KeyValueStorageInterface {
+    syncPromise: Promise<void> | null;
+    /**
+     * 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>;
+    /**
+     * Will sync the MemoryStorage data from AsyncStorage to storageWindow MemoryStorage
+     * @returns {void}
+     */
+    sync(): Promise<void>;
 }
+export declare const AsyncStorageKeyValue: AsyncStorageClass;
+export {};

package/lib-esm/StorageHelper/reactnative.js

@@ -1,3 +1,39 @@
+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
 import AsyncStorage from '@react-native-async-storage/async-storage';
@@ -56,20 +92,20 @@ var MemoryStorage = /** @class */ (function () {
         if (!MemoryStorage.syncPromise) {
             MemoryStorage.syncPromise = new Promise(function (res, rej) {
                 AsyncStorage.getAllKeys(function (errKeys, keys) {
+                    var _a;
                     if (errKeys)
                         rej(errKeys);
-                    var memoryKeys = keys.filter(function (key) {
-                        return key.startsWith(MEMORY_KEY_PREFIX);
-                    });
+                    var memoryKeys = (_a = keys === null || keys === void 0 ? void 0 : keys.filter(function (key) { return key.startsWith(MEMORY_KEY_PREFIX); })) !== null && _a !== void 0 ? _a : [];
                     AsyncStorage.multiGet(memoryKeys, function (err, stores) {
                         if (err)
                             rej(err);
-                        stores.map(function (result, index, store) {
-                            var key = store[index][0];
-                            var value = store[index][1];
-                            var memoryKey = key.replace(MEMORY_KEY_PREFIX, '');
-                            dataMemory[memoryKey] = value;
-                        });
+                        stores &&
+                            stores.map(function (result, index, store) {
+                                var key = store[index][0];
+                                var value = store[index][1];
+                                var memoryKey = key.replace(MEMORY_KEY_PREFIX, '');
+                                dataMemory[memoryKey] = value;
+                            });
                         res();
                     });
                 });
@@ -98,3 +134,111 @@ var StorageHelper = /** @class */ (function () {
     return StorageHelper;
 }());
 export { StorageHelper };
+var AsyncStorageClass = /** @class */ (function () {
+    function AsyncStorageClass() {
+        this.syncPromise = null;
+    }
+    /**
+     * 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
+     */
+    AsyncStorageClass.prototype.setItem = function (key, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!value) return [3 /*break*/, 2];
+                        return [4 /*yield*/, AsyncStorage.setItem(MEMORY_KEY_PREFIX + key, value)];
+                    case 1:
+                        _a.sent();
+                        dataMemory[key] = value;
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * 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
+     */
+    AsyncStorageClass.prototype.getItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Object.prototype.hasOwnProperty.call(dataMemory, key)
+                        ? dataMemory[key]
+                        : null];
+            });
+        });
+    };
+    /**
+     * This is used to remove an item from storage
+     * @param {string} key - the key being set
+     * @returns {string} value - value that was deleted
+     */
+    AsyncStorageClass.prototype.removeItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, AsyncStorage.removeItem(MEMORY_KEY_PREFIX + key)];
+                    case 1:
+                        _a.sent();
+                        delete dataMemory[key];
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * This is used to clear the storage
+     * @returns {string} nothing
+     */
+    AsyncStorageClass.prototype.clear = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                dataMemory = {};
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Will sync the MemoryStorage data from AsyncStorage to storageWindow MemoryStorage
+     * @returns {void}
+     */
+    AsyncStorageClass.prototype.sync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this.syncPromise) {
+                    this.syncPromise = new Promise(function (res, rej) {
+                        AsyncStorage.getAllKeys(function (errKeys, keys) {
+                            var _a;
+                            if (errKeys)
+                                rej(errKeys);
+                            var memoryKeys = (_a = keys === null || keys === void 0 ? void 0 : keys.filter(function (key) { return key.startsWith(MEMORY_KEY_PREFIX); })) !== null && _a !== void 0 ? _a : [];
+                            AsyncStorage.multiGet(memoryKeys, function (err, stores) {
+                                if (err)
+                                    rej(err);
+                                stores &&
+                                    stores.map(function (result, index, store) {
+                                        var key = store[index][0];
+                                        var value = store[index][1];
+                                        var memoryKey = key.replace(MEMORY_KEY_PREFIX, '');
+                                        dataMemory[memoryKey] = value;
+                                    });
+                                res();
+                            });
+                        });
+                    });
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return AsyncStorageClass;
+}());
+// TODO: Add this to the react-native Amplify package.
+export var AsyncStorageKeyValue = new AsyncStorageClass();

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

@@ -0,0 +1,32 @@
+import { KeyValueStorageInterface } from '../types';
+declare class SessionStorageClass 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 SessionStorage: SessionStorageClass;
+export {};

package/lib-esm/StorageHelper/sessionStorage.js

@@ -0,0 +1,111 @@
+// 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 };
+    }
+};
+import { PlatformNotSupportedError } from '../Errors';
+var SessionStorageClass = /** @class */ (function () {
+    function SessionStorageClass() {
+        if (typeof window !== undefined) {
+            try {
+                this.storage = window === null || window === void 0 ? void 0 : window.sessionStorage;
+            }
+            catch (error) { }
+        }
+    }
+    /**
+     * 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
+     */
+    SessionStorageClass.prototype.setItem = function (key, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this.storage)
+                    throw PlatformNotSupportedError;
+                this.storage.setItem(key, value);
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * 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
+     */
+    SessionStorageClass.prototype.getItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this.storage)
+                    throw PlatformNotSupportedError;
+                return [2 /*return*/, this.storage.getItem(key)];
+            });
+        });
+    };
+    /**
+     * This is used to remove an item from storage
+     * @param {string} key - the key being set
+     * @returns {string} value - value that was deleted
+     */
+    SessionStorageClass.prototype.removeItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this.storage)
+                    throw PlatformNotSupportedError;
+                this.storage.removeItem(key);
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * This is used to clear the storage
+     * @returns {string} nothing
+     */
+    SessionStorageClass.prototype.clear = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this.storage)
+                    throw PlatformNotSupportedError;
+                this.storage.clear();
+                return [2 /*return*/];
+            });
+        });
+    };
+    return SessionStorageClass;
+}());
+export var SessionStorage = new SessionStorageClass();

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

@@ -9,8 +9,8 @@ export declare class UniversalStorage implements Storage {
     constructor(context?: Context);
     get length(): number;
     clear(): void;
-    getItem(key: keyof Store): string;
-    protected getLocalItem(key: keyof Store): string;
+    getItem(key: keyof Store): string | null;
+    protected getLocalItem(key: keyof Store): string | null;
     protected getUniversalItem(key: keyof Store): any;
     key(index: number): string;
     removeItem(key: string): void;

package/lib-esm/Util/BackgroundProcessManager.d.ts

@@ -73,7 +73,7 @@ export declare class BackgroundProcessManager {
      * @param job The inner job manager to await.
      * @param description Optional description to help identify pending jobs.
      */
-    add(job: BackgroundProcessManager, description?: string): any;
+    add<T>(job: BackgroundProcessManager, description?: string): Promise<T>;
     /**
      * Adds a **cleaner** function that doesn't immediately get executed.
      * Instead, the caller gets a **terminate** function back. The *cleaner* is
@@ -132,7 +132,7 @@ export declare class BackgroundProcessManager {
      *
      * @returns descriptions as an array.
      */
-    get pending(): string[];
+    get pending(): (string | undefined)[];
     /**
      * Whether the manager is accepting new jobs.
      */

package/lib-esm/Util/BackgroundProcessManager.js

@@ -443,3 +443,4 @@ export var BackgroundProcessManagerState;
      */
     BackgroundProcessManagerState["Closed"] = "Closed";
 })(BackgroundProcessManagerState || (BackgroundProcessManagerState = {}));
+var process = new BackgroundProcessManager();

package/lib-esm/Util/DateUtils.d.ts

@@ -4,4 +4,15 @@
  *
  * @see https://github.com/aws/aws-sdk-js/blob/6edf586dcc1de7fe8fbfbbd9a0d2b1847921e6e1/lib/util.js#L262
  */
-export declare const DateUtils: any;
+type DateUtils = {
+    clockOffset: number;
+    getDateWithClockOffset: () => Date;
+    getClockOffset: () => number;
+    getHeaderStringFromDate: (date: Date) => string;
+    getDateFromHeaderString: (header: string) => Date;
+    isClockSkewed: (serverDate: Date) => boolean;
+    isClockSkewError: (error: any) => boolean;
+    setClockOffset: (offset: number) => void;
+};
+export declare const DateUtils: DateUtils;
+export {};

package/lib-esm/Util/Reachability.js

@@ -11,8 +11,8 @@ var __values = (this && this.__values) || function(o) {
 };
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { browserOrNode, isWebWorker } from '@aws-amplify/core';
 import Observable from 'zen-observable-ts';
+import { browserOrNode, isWebWorker } from '../JS';
 var ReachabilityNavigator = /** @class */ (function () {
     function ReachabilityNavigator() {
     }
@@ -31,7 +31,8 @@ var ReachabilityNavigator = /** @class */ (function () {
             return function () {
                 globalObj.removeEventListener('online', notifyOnline);
                 globalObj.removeEventListener('offline', notifyOffline);
-                ReachabilityNavigator._observers = ReachabilityNavigator._observers.filter(function (_observer) { return _observer !== observer; });
+                ReachabilityNavigator._observers =
+                    ReachabilityNavigator._observers.filter(function (_observer) { return _observer !== observer; });
             };
         });
     };
@@ -40,7 +41,8 @@ var ReachabilityNavigator = /** @class */ (function () {
         var e_1, _a;
         var _loop_1 = function (observer) {
             if (observer.closed) {
-                ReachabilityNavigator._observers = ReachabilityNavigator._observers.filter(function (_observer) { return _observer !== observer; });
+                ReachabilityNavigator._observers =
+                    ReachabilityNavigator._observers.filter(function (_observer) { return _observer !== observer; });
                 return "continue";
             }
             observer.next(status);

package/lib-esm/Util/Reachability.native.d.ts

@@ -1,11 +1,12 @@
 import Observable from 'zen-observable-ts';
+import type NetInfo from '@react-native-community/netinfo';
 type NetworkStatus = {
     online: boolean;
 };
 export default class ReachabilityNavigator implements Reachability {
-    networkMonitor(netInfo?: any): Observable<NetworkStatus>;
+    networkMonitor(netInfo?: typeof NetInfo): Observable<NetworkStatus>;
 }
 interface Reachability {
-    networkMonitor(netInfo?: any): Observable<NetworkStatus>;
+    networkMonitor(netInfo?: typeof NetInfo): Observable<NetworkStatus>;
 }
 export {};

package/lib-esm/Util/StringUtils.js

@@ -3,17 +3,10 @@
 export function urlSafeEncode(str) {
     return str
         .split('')
-        .map(function (char) {
-        return char
-            .charCodeAt(0)
-            .toString(16)
-            .padStart(2, '0');
-    })
+        .map(function (char) { return char.charCodeAt(0).toString(16).padStart(2, '0'); })
         .join('');
 }
 export function urlSafeDecode(hex) {
-    return hex
-        .match(/.{2}/g)
-        .map(function (char) { return String.fromCharCode(parseInt(char, 16)); })
-        .join('');
+    var matchArr = hex.match(/.{2}/g) || [];
+    return matchArr.map(function (char) { return String.fromCharCode(parseInt(char, 16)); }).join('');
 }

package/lib-esm/Util/errors/AssertError.d.ts

@@ -0,0 +1,2 @@
+import { ErrorParams } from '../../types';
+export declare function asserts(assertion: boolean, errorParams: ErrorParams): asserts assertion;

package/lib-esm/Util/errors/AssertError.js

@@ -0,0 +1,7 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AmplifyError } from '../../Errors';
+export function asserts(assertion, errorParams) {
+    if (!assertion)
+        throw new AmplifyError(errorParams);
+}

package/lib-esm/clients/middleware/retry/defaultRetryDecider.d.ts

@@ -3,4 +3,4 @@ import { HttpResponse, ErrorParser } from '../../types';
  * Get retry decider function
  * @param errorParser Function to load JavaScript error from HTTP response
  */
-export declare const getRetryDecider: (errorParser: ErrorParser) => (response?: HttpResponse, error?: Error) => Promise<boolean>;
+export declare const getRetryDecider: (errorParser: ErrorParser) => (response?: HttpResponse, error?: unknown) => Promise<boolean>;