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

package/lib-esm/Cache/Utils/CacheList.d.ts

@@ -0,0 +1,89 @@
+/**
+ * double linked list plus a hash table inside
+ * each key in the cache stored as a node in the list
+ * recently visited node will be rotated to the head
+ * so the Last Recently Visited node will be at the tail
+ *
+ * @member head - dummy head of the linked list
+ * @member tail - dummy tail of the linked list
+ * @member hashtable - the hashtable which maps cache key to list node
+ * @member length - length of the list
+ */
+export default class CacheList {
+    private head;
+    private tail;
+    private hashtable;
+    private length;
+    /**
+     * initialization
+     */
+    constructor();
+    /**
+     * insert node to the head of the list
+     *
+     * @param node
+     */
+    private insertNodeToHead;
+    /**
+     * remove node
+     *
+     * @param node
+     */
+    private removeNode;
+    /**
+     * @return true if list is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * refresh node so it is rotated to the head
+     *
+     * @param key - key of the node
+     */
+    refresh(key: string): void;
+    /**
+     * insert new node to the head and add it in the hashtable
+     *
+     * @param key - the key of the node
+     */
+    insertItem(key: string): void;
+    /**
+     * @return the LAST Recently Visited key
+     */
+    getLastItem(): string;
+    /**
+     * remove the cache key from the list and hashtable
+     * @param key - the key of the node
+     */
+    removeItem(key: string): void;
+    /**
+     * @return length of the list
+     */
+    getSize(): number;
+    /**
+     * @return true if the key is in the hashtable
+     * @param key
+     */
+    containsKey(key: string): boolean;
+    /**
+     * clean up the list and hashtable
+     */
+    clearList(): void;
+    /**
+     * @return all keys in the hashtable
+     */
+    getKeys(): string[];
+    /**
+     * mainly for test
+     *
+     * @param key
+     * @return true if key is the head node
+     */
+    isHeadNode(key: string): boolean;
+    /**
+     * mainly for test
+     *
+     * @param key
+     * @return true if key is the tail node
+     */
+    isTailNode(key: string): boolean;
+}

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

@@ -0,0 +1,194 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { asserts } from '../../Util/errors/AssertError';
+import { CACHE_LIST_EXCEPTION } from '../../constants';
+var DoubleLinkedNode = /** @class */ (function () {
+    function DoubleLinkedNode(keyVal) {
+        this.key = keyVal ? keyVal : '';
+        this.prevNode = null;
+        this.nextNode = null;
+    }
+    return DoubleLinkedNode;
+}());
+/**
+ * double linked list plus a hash table inside
+ * each key in the cache stored as a node in the list
+ * recently visited node will be rotated to the head
+ * so the Last Recently Visited node will be at the tail
+ *
+ * @member head - dummy head of the linked list
+ * @member tail - dummy tail of the linked list
+ * @member hashtable - the hashtable which maps cache key to list node
+ * @member length - length of the list
+ */
+var CacheList = /** @class */ (function () {
+    /**
+     * initialization
+     */
+    function CacheList() {
+        this.head = new DoubleLinkedNode();
+        this.tail = new DoubleLinkedNode();
+        this.hashtable = {};
+        this.length = 0;
+        this.head.nextNode = this.tail;
+        this.tail.prevNode = this.head;
+    }
+    /**
+     * insert node to the head of the list
+     *
+     * @param node
+     */
+    CacheList.prototype.insertNodeToHead = function (node) {
+        var tmp = this.head.nextNode;
+        this.head.nextNode = node;
+        node.nextNode = tmp;
+        node.prevNode = this.head;
+        asserts(tmp !== null, {
+            name: CACHE_LIST_EXCEPTION,
+            message: 'previous node is null',
+        });
+        tmp.prevNode = node;
+        this.length = this.length + 1;
+    };
+    /**
+     * remove node
+     *
+     * @param node
+     */
+    CacheList.prototype.removeNode = function (node) {
+        asserts(node.prevNode !== null, {
+            name: CACHE_LIST_EXCEPTION,
+            message: 'previous node is null',
+        });
+        asserts(node.nextNode !== null, {
+            name: CACHE_LIST_EXCEPTION,
+            message: 'nextNode node is null',
+        });
+        node.prevNode.nextNode = node.nextNode;
+        node.nextNode.prevNode = node.prevNode;
+        node.prevNode = null;
+        node.nextNode = null;
+        this.length = this.length - 1;
+    };
+    /**
+     * @return true if list is empty
+     */
+    CacheList.prototype.isEmpty = function () {
+        return this.length === 0;
+    };
+    /**
+     * refresh node so it is rotated to the head
+     *
+     * @param key - key of the node
+     */
+    CacheList.prototype.refresh = function (key) {
+        var node = this.hashtable[key];
+        this.removeNode(node);
+        this.insertNodeToHead(node);
+    };
+    /**
+     * insert new node to the head and add it in the hashtable
+     *
+     * @param key - the key of the node
+     */
+    CacheList.prototype.insertItem = function (key) {
+        var node = new DoubleLinkedNode(key);
+        this.hashtable[key] = node;
+        this.insertNodeToHead(node);
+    };
+    /**
+     * @return the LAST Recently Visited key
+     */
+    CacheList.prototype.getLastItem = function () {
+        asserts(this.tail.prevNode !== null, {
+            name: CACHE_LIST_EXCEPTION,
+            message: 'previous node is null',
+        });
+        return this.tail.prevNode.key;
+    };
+    /**
+     * remove the cache key from the list and hashtable
+     * @param key - the key of the node
+     */
+    CacheList.prototype.removeItem = function (key) {
+        var removedItem = this.hashtable[key];
+        this.removeNode(removedItem);
+        delete this.hashtable[key];
+    };
+    /**
+     * @return length of the list
+     */
+    CacheList.prototype.getSize = function () {
+        return this.length;
+    };
+    /**
+     * @return true if the key is in the hashtable
+     * @param key
+     */
+    CacheList.prototype.containsKey = function (key) {
+        return key in this.hashtable;
+    };
+    /**
+     * clean up the list and hashtable
+     */
+    CacheList.prototype.clearList = function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(Object.keys(this.hashtable)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                if (this.hashtable.hasOwnProperty(key)) {
+                    delete this.hashtable[key];
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        this.head.nextNode = this.tail;
+        this.tail.prevNode = this.head;
+        this.length = 0;
+    };
+    /**
+     * @return all keys in the hashtable
+     */
+    CacheList.prototype.getKeys = function () {
+        return Object.keys(this.hashtable);
+    };
+    /**
+     * mainly for test
+     *
+     * @param key
+     * @return true if key is the head node
+     */
+    CacheList.prototype.isHeadNode = function (key) {
+        var node = this.hashtable[key];
+        return node.prevNode === this.head;
+    };
+    /**
+     * mainly for test
+     *
+     * @param key
+     * @return true if key is the tail node
+     */
+    CacheList.prototype.isTailNode = function (key) {
+        var node = this.hashtable[key];
+        return node.nextNode === this.tail;
+    };
+    return CacheList;
+}());
+export default CacheList;

package/lib-esm/Cache/Utils/CacheUtils.d.ts

@@ -0,0 +1,25 @@
+import { CacheConfig } from '../types';
+/**
+ * Default cache config
+ */
+export declare const defaultConfig: CacheConfig;
+/**
+ * return the byte size of the string
+ * @param str
+ */
+export declare function getByteLength(str: string): number;
+/**
+ * get current time
+ */
+export declare function getCurrTime(): number;
+/**
+ * check if passed value is an integer
+ */
+export declare function isInteger(value?: number): boolean;
+export declare class CacheObject {
+    static clear(): void;
+    static getItem(key: string): string | null;
+    static setItem(key: string, value: string): void;
+    static removeItem(key: string): void;
+}
+export declare const getCurrSizeKey: (keyPrefix: string) => string;

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

@@ -0,0 +1,81 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { StorageHelper } from '../../StorageHelper';
+/**
+ * Default cache config
+ */
+export var defaultConfig = {
+    keyPrefix: 'aws-amplify-cache',
+    capacityInBytes: 1048576,
+    itemMaxSize: 210000,
+    defaultTTL: 259200000,
+    defaultPriority: 5,
+    warningThreshold: 0.8,
+    // 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
+ * @param str
+ */
+export function getByteLength(str) {
+    var ret = 0;
+    ret = str.length;
+    for (var i = str.length; i >= 0; i -= 1) {
+        var charCode = str.charCodeAt(i);
+        if (charCode > 0x7f && charCode <= 0x7ff) {
+            ret += 1;
+        }
+        else if (charCode > 0x7ff && charCode <= 0xffff) {
+            ret += 2;
+        }
+        // trail surrogate
+        if (charCode >= 0xdc00 && charCode <= 0xdfff) {
+            i -= 1;
+        }
+    }
+    return ret;
+}
+/**
+ * get current time
+ */
+export function getCurrTime() {
+    var currTime = new Date();
+    return currTime.getTime();
+}
+/**
+ * check if passed value is an integer
+ */
+export function isInteger(value) {
+    if (Number.isInteger) {
+        return Number.isInteger(value);
+    }
+    return _isInteger(value);
+}
+function _isInteger(value) {
+    return (typeof value === 'number' && isFinite(value) && Math.floor(value) === value);
+}
+/**
+ * provide an object as the in-memory cache
+ */
+var store = {};
+var CacheObject = /** @class */ (function () {
+    function CacheObject() {
+    }
+    CacheObject.clear = function () {
+        store = {};
+    };
+    CacheObject.getItem = function (key) {
+        return store[key] || null;
+    };
+    CacheObject.setItem = function (key, value) {
+        store[key] = value;
+    };
+    CacheObject.removeItem = function (key) {
+        delete store[key];
+    };
+    return CacheObject;
+}());
+export { CacheObject };
+export var getCurrSizeKey = function (keyPrefix) { return keyPrefix + 'CurSize'; };

package/lib-esm/Cache/Utils/index.d.ts

@@ -0,0 +1,2 @@
+export { CacheObject, defaultConfig, getByteLength, getCurrTime, isInteger, } from './CacheUtils';
+export { default as CacheList } from './CacheList';

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

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { CacheObject, defaultConfig, getByteLength, getCurrTime, isInteger, } from './CacheUtils';
+export { default as CacheList } from './CacheList';

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

@@ -0,0 +1,3 @@
+import { Cache, AsyncStorageCache } from './AsyncStorageCache';
+export { AsyncStorageCache };
+export { Cache };

package/lib-esm/Cache/reactnative.js

@@ -0,0 +1,6 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Cache, AsyncStorageCache } from './AsyncStorageCache';
+export { AsyncStorageCache };
+// Standard `Cache` export to maintain interoperability with React Native
+export { Cache };

package/lib-esm/Cache/types/Cache.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Cache Interface
+ */
+export interface ICache {
+    /** Put item into cache */
+    setItem(key: string, value: any, options?: CacheItemOptions): void;
+    /** Get item from cache */
+    getItem(key: string, options?: CacheItemOptions): any;
+    /** Remove item from cache */
+    removeItem(key: string): void;
+    /** Remove all items from cache */
+    clear(): void;
+    /** Get all keys form cache */
+    getAllKeys(): string[] | Promise<string[]>;
+    /** Get current size of the cache */
+    getCacheCurSize(): number | Promise<number>;
+    /** create a new instance with customized config */
+    createInstance(config: CacheConfig): ICache;
+    /** change current configuration */
+    configure(config: CacheConfig): CacheConfig;
+}
+/**
+ * Cache instance options
+ */
+export interface CacheConfig {
+    /** Prepend to key to avoid conflicts */
+    keyPrefix: string;
+    /** Cache capacity, in bytes */
+    capacityInBytes: number;
+    /** Max size of one item */
+    itemMaxSize: number;
+    /** Time to live, in milliseconds */
+    defaultTTL: number;
+    /** Warn when over threshold percentage of capacity, maximum 1 */
+    warningThreshold: number;
+    /** default priority number put on cached items */
+    defaultPriority: number;
+    storage?: Storage;
+    Cache?: Cache;
+}
+export interface CacheItem {
+    key: string;
+    data: any;
+    timestamp: number;
+    visitedTime: number;
+    priority: number;
+    expires: number;
+    type: string;
+    byteSize: number;
+}
+export interface CacheItemOptions {
+    priority?: number;
+    expires?: number;
+    callback?: Function;
+}

package/lib-esm/Cache/types/Cache.js

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

package/lib-esm/Cache/types/index.d.ts

@@ -0,0 +1 @@
+export * from './Cache';

package/lib-esm/Cache/types/index.js

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

package/lib-esm/ClientDevice/android.js

@@ -1,5 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+// @ts-ignore: missing type definition
 import { Platform, Dimensions } from 'react-native';
 import { ConsoleLogger as Logger } from '../Logger';
 var logger = new Logger('DeviceInfo');

package/lib-esm/ClientDevice/ios.d.ts

@@ -2,6 +2,6 @@ export declare const clientInfo: () => {
     platform: string;
     version: string;
     appVersion: string;
-    make: string;
-    model: string;
+    make: string | null;
+    model: string | null;
 };

package/lib-esm/ClientDevice/ios.js

@@ -1,5 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+// @ts-ignore: missing type definition
 import { Platform, Dimensions } from 'react-native';
 import { ConsoleLogger as Logger } from '../Logger';
 var logger = new Logger('DeviceInfo');

package/lib-esm/ClientDevice/reactnative.js

@@ -1,5 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+// @ts-ignore: missing type definition
 import { Platform } from 'react-native';
 import { clientInfo as iOSClientInfo } from './ios';
 import { clientInfo as androidClientInfo } from './android';

package/lib-esm/Credentials.d.ts

@@ -9,7 +9,7 @@ export declare class CredentialsClass {
     private _storageSync;
     private _identityId;
     private _nextCredentialsRefresh;
-    Auth: any;
+    Auth: undefined;
     constructor(config: any);
     getModuleName(): string;
     getCredSource(): any;

package/lib-esm/Credentials.js

@@ -45,6 +45,7 @@ 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 };
     }
 };
+// @ts-nocheck
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { ConsoleLogger as Logger } from './Logger';
@@ -480,7 +481,7 @@ var CredentialsClass = /** @class */ (function () {
                             Logins: logins,
                         })];
                     case 4:
-                        _a = _c.sent(), _b = _a.Credentials, AccessKeyId = _b.AccessKeyId, Expiration = _b.Expiration, SecretKey = _b.SecretKey, SessionToken = _b.SessionToken, primaryIdentityId = _a.IdentityId;
+                        _a = (_c.sent()), _b = _a.Credentials, AccessKeyId = _b.AccessKeyId, Expiration = _b.Expiration, SecretKey = _b.SecretKey, SessionToken = _b.SessionToken, primaryIdentityId = _a.IdentityId;
                         this._identityId = primaryIdentityId;
                         if (!guestIdentityId) return [3 /*break*/, 6];
                         // if guestIdentity is found and used by GetCredentialsForIdentity

package/lib-esm/Errors.d.ts

@@ -1,2 +1,21 @@
+import { ErrorParams } from './types/types';
 export declare function missingConfig(name: string): Error;
 export declare function invalidParameter(name: string): Error;
+export declare enum AmplifyErrorString {
+    UNKNOWN = "UnknownError",
+    PLATFORM_NOT_SUPPORTED_ERROR = "PlatformNotSupportedError"
+}
+export declare class AmplifyError extends Error {
+    underlyingError?: Error | unknown;
+    recoverySuggestion?: string;
+    /**
+     *  Constructs an AmplifyError.
+     *
+     * @param message text that describes the main problem.
+     * @param underlyingError the underlying cause of the error.
+     * @param recoverySuggestion suggestion to recover from the error.
+     *
+     */
+    constructor({ message, name, recoverySuggestion, underlyingError, }: ErrorParams);
+}
+export declare const PlatformNotSupportedError: AmplifyError;

package/lib-esm/Errors.js

@@ -1,8 +1,57 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 export function missingConfig(name) {
     return new Error('Missing config value of ' + name);
 }
 export function invalidParameter(name) {
     return new Error('Invalid parameter value of ' + name);
 }
+export var AmplifyErrorString;
+(function (AmplifyErrorString) {
+    AmplifyErrorString["UNKNOWN"] = "UnknownError";
+    AmplifyErrorString["PLATFORM_NOT_SUPPORTED_ERROR"] = "PlatformNotSupportedError";
+})(AmplifyErrorString || (AmplifyErrorString = {}));
+var AmplifyError = /** @class */ (function (_super) {
+    __extends(AmplifyError, _super);
+    /**
+     *  Constructs an AmplifyError.
+     *
+     * @param message text that describes the main problem.
+     * @param underlyingError the underlying cause of the error.
+     * @param recoverySuggestion suggestion to recover from the error.
+     *
+     */
+    function AmplifyError(_a) {
+        var message = _a.message, name = _a.name, recoverySuggestion = _a.recoverySuggestion, underlyingError = _a.underlyingError;
+        var _this = _super.call(this, message) || this;
+        _this.name = name;
+        _this.underlyingError = underlyingError;
+        _this.recoverySuggestion = recoverySuggestion;
+        // 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 = AmplifyError;
+        Object.setPrototypeOf(_this, AmplifyError.prototype);
+        return _this;
+    }
+    return AmplifyError;
+}(Error));
+export { AmplifyError };
+export var PlatformNotSupportedError = new AmplifyError({
+    name: AmplifyErrorString.PLATFORM_NOT_SUPPORTED_ERROR,
+    message: 'Function not supported on current platform',
+});

package/lib-esm/Hub.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 var __assign = (this && this.__assign) || function () {