@aws-amplify/core 6.0.1-api-v6-models.ce6e561.0 → 6.0.1-api-v6-models.572a7b5.0

package/lib-esm/Cache/StorageCache.js

@@ -1,118 +1,113 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { getCurrTime, getByteLength, defaultConfig } from './Utils';
+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 __());
+    };
+})();
+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 { ConsoleLogger as Logger } from '../Logger';
-var logger = new Logger('StorageCache');
+import { KeyValueStorage } from '../storage/KeyValueStorage';
+import { getLocalStorageWithFallback } from '../storage/utils';
+import { defaultConfig } from './constants';
+import { StorageCacheCommon } from './StorageCacheCommon';
+import { getCurrentSizeKey, getCurrentTime } from './utils';
+var logger = new Logger('Cache');
 /**
- * Initialization of the cache
- *
+ * Customized storage based on the SessionStorage or LocalStorage with LRU implemented
  */
-var StorageCache = /** @class */ (function () {
+var StorageCache = /** @class */ (function (_super) {
+    __extends(StorageCache, _super);
     /**
-     * Initialize the cache
-     *
-     * @param config - Custom configuration for this instance.
+     * initialize the cache
+     * @param config - the configuration of the cache
      */
     function StorageCache(config) {
-        if (config) {
-            // A configuration was specified for this specific instance
-            this.instanceConfig = config;
-        }
-        this.sanitizeConfig();
+        var _this = this;
+        var storage = getLocalStorageWithFallback();
+        _this = _super.call(this, { config: config, keyValueStorage: new KeyValueStorage(storage) }) || this;
+        _this.storage = storage;
+        _this.getItem = _this.getItem.bind(_this);
+        _this.setItem = _this.setItem.bind(_this);
+        _this.removeItem = _this.removeItem.bind(_this);
+        return _this;
     }
-    StorageCache.prototype.getModuleName = function () {
-        return 'Cache';
-    };
-    StorageCache.prototype.sanitizeConfig = function () {
-        var tempInstanceConfig = this.instanceConfig || {};
-        if (this.cacheConfig.itemMaxSize > this.cacheConfig.capacityInBytes) {
-            logger.error('Invalid parameter: itemMaxSize. It should be smaller than capacityInBytes. Setting back to default.');
-            tempInstanceConfig.itemMaxSize = defaultConfig.itemMaxSize;
-        }
-        if (this.cacheConfig.defaultPriority > 5 ||
-            this.cacheConfig.defaultPriority < 1) {
-            logger.error('Invalid parameter: defaultPriority. It should be between 1 and 5. Setting back to default.');
-            tempInstanceConfig.defaultPriority = defaultConfig.defaultPriority;
-        }
-        if (Number(this.cacheConfig.warningThreshold) > 1 ||
-            Number(this.cacheConfig.warningThreshold) < 0) {
-            logger.error('Invalid parameter: warningThreshold. It should be between 0 and 1. Setting back to default.');
-            tempInstanceConfig.warningThreshold = defaultConfig.warningThreshold;
-        }
-        // Set 5MB limit
-        var cacheLimit = 5 * 1024 * 1024;
-        if (this.cacheConfig.capacityInBytes > cacheLimit) {
-            logger.error('Cache Capacity should be less than 5MB. Setting back to default. Setting back to default.');
-            tempInstanceConfig.capacityInBytes = defaultConfig.capacityInBytes;
-        }
-        // Apply sanitized values to the instance config
-        if (Object.keys(tempInstanceConfig).length > 0) {
-            this.instanceConfig = tempInstanceConfig;
-        }
-    };
-    /**
-     * produce a JSON object with meta-data and data value
-     * @param value - the value of the item
-     * @param options - optional, the specified meta-data
-     *
-     * @return - the item which has the meta-data and the value
-     */
-    StorageCache.prototype.fillCacheItem = function (key, value, options) {
-        var _a, _b;
-        var ret = {
-            key: key,
-            data: value,
-            timestamp: getCurrTime(),
-            visitedTime: getCurrTime(),
-            priority: (_a = options.priority) !== null && _a !== void 0 ? _a : 0,
-            expires: (_b = options.expires) !== null && _b !== void 0 ? _b : 0,
-            type: typeof value,
-            byteSize: 0,
-        };
-        ret.byteSize = getByteLength(JSON.stringify(ret));
-        // for accurate size
-        ret.byteSize = getByteLength(JSON.stringify(ret));
-        return ret;
+    StorageCache.prototype.getAllCacheKeys = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var omitSizeKey, keys, i, key;
+            return __generator(this, function (_a) {
+                omitSizeKey = (options !== null && options !== void 0 ? options : {}).omitSizeKey;
+                keys = [];
+                for (i = 0; i < this.storage.length; i++) {
+                    key = this.storage.key(i);
+                    if (omitSizeKey && key === getCurrentSizeKey(this.config.keyPrefix)) {
+                        continue;
+                    }
+                    if (key === null || key === void 0 ? void 0 : key.startsWith(this.config.keyPrefix)) {
+                        keys.push(key.substring(this.config.keyPrefix.length));
+                    }
+                }
+                return [2 /*return*/, keys];
+            });
+        });
     };
     /**
-     * Set custom configuration for the cache instance.
-     *
-     * @param config - customized configuration (without keyPrefix, which can't be changed)
-     *
-     * @return - the current configuration
+     * Return a new instance of cache with customized configuration.
+     * @param {Object} config - the customized configuration
+     * @return {Object} - the new instance of Cache
      */
-    StorageCache.prototype.configure = function (config) {
-        if (config) {
-            if (config.keyPrefix) {
-                logger.warn('keyPrefix can not be re-configured on an existing Cache instance.');
-            }
-            this.instanceConfig = this.instanceConfig
-                ? Object.assign({}, this.instanceConfig, config)
-                : config;
+    StorageCache.prototype.createInstance = function (config) {
+        if (!config.keyPrefix || config.keyPrefix === defaultConfig.keyPrefix) {
+            logger.error('invalid keyPrefix, setting keyPrefix with timeStamp');
+            config.keyPrefix = getCurrentTime.toString();
         }
-        this.sanitizeConfig();
-        return this.cacheConfig;
+        return new StorageCache(config);
     };
-    Object.defineProperty(StorageCache.prototype, "cacheConfig", {
-        /**
-         * Returns an appropriate configuration for the Cache instance. Will apply any custom configuration for this
-         * instance on top of the global configuration. Default configuration will be applied in all cases.
-         *
-         * @internal
-         */
-        get: function () {
-            // const globalCacheConfig = Amplify.getConfig().Cache || {};
-            var globalCacheConfig = {};
-            if (this.instanceConfig) {
-                return Object.assign({}, defaultConfig, globalCacheConfig, this.instanceConfig);
-            }
-            else {
-                return Object.assign({}, defaultConfig, globalCacheConfig);
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
     return StorageCache;
-}());
+}(StorageCacheCommon));
 export { StorageCache };

package/lib-esm/Cache/StorageCache.native.d.ts

@@ -0,0 +1,19 @@
+import { StorageCacheCommon } from './StorageCacheCommon';
+import { Cache, CacheConfig } from './types';
+export declare class StorageCache extends StorageCacheCommon implements Cache {
+    /**
+     * initialize the cache
+     * @param config - the configuration of the cache
+     */
+    constructor(config?: CacheConfig);
+    protected getAllCacheKeys(options?: {
+        omitSizeKey?: boolean;
+    }): Promise<string[]>;
+    protected getAllStorageKeys(): Promise<readonly string[]>;
+    /**
+     * Return a new instance of cache with customized configuration.
+     * @param {Object} config - the customized configuration
+     * @return {Object} - the new instance of Cache
+     */
+    createInstance(config: CacheConfig): Cache;
+}

package/lib-esm/Cache/StorageCache.native.js

@@ -0,0 +1,161 @@
+// 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 __());
+    };
+})();
+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 __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 { loadAsyncStorage } from '@aws-amplify/react-native';
+import { ConsoleLogger as Logger } from '../Logger';
+import { defaultConfig } from './constants';
+import { StorageCacheCommon } from './StorageCacheCommon';
+import { getCurrentSizeKey, getCurrentTime } from './utils';
+var logger = new Logger('StorageCache');
+var AsyncStorage = loadAsyncStorage();
+/*
+ * Customized cache which based on the AsyncStorage with LRU implemented
+ */
+var StorageCache = /** @class */ (function (_super) {
+    __extends(StorageCache, _super);
+    /**
+     * initialize the cache
+     * @param config - the configuration of the cache
+     */
+    function StorageCache(config) {
+        var _this = _super.call(this, { config: config, keyValueStorage: AsyncStorage }) || this;
+        _this.getItem = _this.getItem.bind(_this);
+        _this.setItem = _this.setItem.bind(_this);
+        _this.removeItem = _this.removeItem.bind(_this);
+        return _this;
+    }
+    StorageCache.prototype.getAllCacheKeys = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var omitSizeKey, keys, _a, _b, key, e_1_1;
+            var e_1, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        omitSizeKey = (options !== null && options !== void 0 ? options : {}).omitSizeKey;
+                        keys = [];
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        return [4 /*yield*/, AsyncStorage.getAllKeys()];
+                    case 2:
+                        _a = __values.apply(void 0, [_d.sent()]), _b = _a.next();
+                        _d.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        key = _b.value;
+                        if (omitSizeKey && key === getCurrentSizeKey(this.config.keyPrefix)) {
+                            return [3 /*break*/, 4];
+                        }
+                        if (key === null || key === void 0 ? void 0 : key.startsWith(this.config.keyPrefix)) {
+                            keys.push(key.substring(this.config.keyPrefix.length));
+                        }
+                        _d.label = 4;
+                    case 4:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/, keys];
+                }
+            });
+        });
+    };
+    StorageCache.prototype.getAllStorageKeys = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                try {
+                    return [2 /*return*/, AsyncStorage.getAllKeys()];
+                }
+                catch (e) {
+                    logger.warn("getAllKeys failed! ".concat(e));
+                    return [2 /*return*/, []];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Return a new instance of cache with customized configuration.
+     * @param {Object} config - the customized configuration
+     * @return {Object} - the new instance of Cache
+     */
+    StorageCache.prototype.createInstance = function (config) {
+        if (!config.keyPrefix || config.keyPrefix === defaultConfig.keyPrefix) {
+            logger.error('invalid keyPrefix, setting keyPrefix with timeStamp');
+            config.keyPrefix = getCurrentTime.toString();
+        }
+        return new StorageCache(config);
+    };
+    return StorageCache;
+}(StorageCacheCommon));
+export { StorageCache };

package/{lib/Cache/AsyncStorageCache.d.ts → lib-esm/Cache/StorageCacheCommon.d.ts}

@@ -1,89 +1,38 @@
-import { StorageCache } from './StorageCache';
-import { CacheConfig, CacheItem, CacheItemOptions, ICache } from './types';
-declare const AsyncStorage: import("@react-native-async-storage/async-storage").AsyncStorageStatic;
-export declare class AsyncStorageCache extends StorageCache implements ICache {
-    /**
-     * initialize the cache
+import { KeyValueStorageInterface } from '../types';
+import { CacheConfig, CacheItem, CacheItemOptions } from './types';
+/**
+ * Initialization of the cache
+ *
+ */
+export declare abstract class StorageCacheCommon {
+    protected config: CacheConfig;
+    protected keyValueStorage: KeyValueStorageInterface;
+    /**
+     * Initialize the cache
      *
-     * @param {Object} config - the configuration of the cache
-     */
-    constructor(config?: CacheConfig);
-    /**
-     * decrease current size of the cache
-     * @private
-     * @param amount - the amount of the cache size which needs to be decreased
-     */
-    _decreaseCurSizeInBytes(amount: number): Promise<void>;
-    /**
-     * increase current size of the cache
-     * @private
-     * @param amount - the amount of the cache szie which need to be increased
-     */
-    _increaseCurSizeInBytes(amount: number): Promise<void>;
-    /**
-     * update the visited time if item has been visited
-     * @private
-     * @param item - the item which need to be refreshed
-     * @param prefixedKey - the key of the item
+     * @param config - Custom configuration for this instance.
+     */
+    constructor({ config, keyValueStorage, }: {
+        config?: CacheConfig;
+        keyValueStorage: KeyValueStorageInterface;
+    });
+    protected abstract getAllCacheKeys(options?: {
+        omitSizeKey?: boolean;
+    }): Promise<string[]>;
+    getModuleName(): string;
+    /**
+     * Set custom configuration for the cache instance.
      *
-     * @return the refreshed item
-     */
-    _refreshItem(item: CacheItem, prefixedKey: string): Promise<CacheItem>;
-    /**
-     * check wether item is expired
-     * @private
-     * @param key - the key of the item
+     * @param config - customized configuration (without keyPrefix, which can't be changed)
      *
-     * @return true if the item is expired.
-     */
-    _isExpired(key: string): Promise<boolean>;
-    /**
-     * delete item from cache
-     * @private
-     * @param prefixedKey - the key of the item
-     * @param size - optional, the byte size of the item
-     */
-    _removeItem(prefixedKey: string, size?: number): Promise<void>;
-    /**
-     * put item into cache
-     * @private
-     * @param prefixedKey - the key of the item
-     * @param itemData - the value of the item
-     * @param itemSizeInBytes - the byte size of the item
+     * @return - the current configuration
      */
-    _setItem(prefixedKey: string, item: any): Promise<void>;
+    configure(config?: Omit<CacheConfig, 'keyPrefix'>): CacheConfig;
     /**
-     * total space needed when poping out items
-     * @private
-     * @param itemSize
-     *
-     * @return total space needed
-     */
-    _sizeToPop(itemSize: number): Promise<number>;
-    /**
-     * see whether cache is full
-     * @private
-     * @param itemSize
-     *
-     * @return true if cache is full
-     */
-    _isCacheFull(itemSize: number): Promise<boolean>;
-    /**
-     * scan the storage and find out all the keys owned by this cache
-     * also clean the expired keys while scanning
-     * @private
-     * @return array of keys
-     */
-    _findValidKeys(): Promise<string[]>;
-    /**
-     * get all the items we have, sort them by their priority,
-     * if priority is same, sort them by their last visited time
-     * pop out items from the low priority (5 is the lowest)
-     * @private
-     * @param keys - all the keys in this cache
-     * @param sizeToPop - the total size of the items which needed to be poped out
+     * return the current size of the cache
+     * @return {Promise}
      */
-    _popOutItems(keys: string[], sizeToPop: number): Promise<void>;
+    getCurrentCacheSize(): Promise<number>;
     /**
      * Set item into cache. You can put number, string, boolean or object.
      * The cache will first check whether has the same key.
@@ -99,9 +48,10 @@ export declare class AsyncStorageCache extends StorageCache implements ICache {
      * @param {String} key - the key of the item
      * @param {Object} value - the value of the item
      * @param {Object} [options] - optional, the specified meta-data
+     *
      * @return {Promise}
      */
-    setItem(key: string, value: any, options: Record<string, any>): Promise<void>;
+    setItem(key: string, value: any, options?: Record<string, any>): Promise<void>;
     /**
      * Get item from cache. It will return null if item doesn’t exist or it has been expired.
      * If you specified callback function in the options,
@@ -114,9 +64,10 @@ export declare class AsyncStorageCache extends StorageCache implements ICache {
      *
      * @param {String} key - the key of the item
      * @param {Object} [options] - the options of callback function
+     *
      * @return {Promise} - return a promise resolves to be the value of the item
      */
-    getItem(key: string, options: CacheItemOptions): Promise<any>;
+    getItem(key: string, options?: CacheItemOptions): Promise<CacheItem['data']>;
     /**
      * remove item from the cache
      * The cache will abort output a warning:
@@ -126,29 +77,103 @@ export declare class AsyncStorageCache extends StorageCache implements ICache {
      */
     removeItem(key: string): Promise<void>;
     /**
-     * clear the entire cache
-     * The cache will abort output a warning:
-     * If error happened with AsyncStorage
+     * Return all the keys owned by this cache.
+     * Will return an empty array if error occurred.
+     *
      * @return {Promise}
      */
-    clear(): Promise<void>;
+    getAllKeys(): Promise<string[]>;
+    protected getStorage(): KeyValueStorageInterface;
     /**
-     * return the current size of the cache
-     * @return {Promise}
+     * check whether item is expired
+     *
+     * @param key - the key of the item
+     *
+     * @return true if the item is expired.
      */
-    getCacheCurSize(): Promise<number>;
+    protected isExpired(key: string): Promise<boolean>;
     /**
-     * Return all the keys in the cache.
-     * Will return an empty array if error happend.
-     * @return {Promise}
+     * delete item from cache
+     *
+     * @param prefixedKey - the key of the item
+     * @param size - optional, the byte size of the item
      */
-    getAllKeys(): Promise<string[]>;
+    protected removeCacheItem(prefixedKey: string, size?: number): Promise<void>;
+    /**
+     * produce a JSON object with meta-data and data value
+     * @param value - the value of the item
+     * @param options - optional, the specified meta-data
+     *
+     * @return - the item which has the meta-data and the value
+     */
+    protected fillCacheItem(key: string, value: object | number | string | boolean, options: CacheItemOptions): CacheItem;
+    private sanitizeConfig;
+    /**
+     * increase current size of the cache
+     *
+     * @param amount - the amount of the cache szie which need to be increased
+     */
+    private increaseCurrentSizeInBytes;
+    /**
+     * decrease current size of the cache
+     *
+     * @param amount - the amount of the cache size which needs to be decreased
+     */
+    private decreaseCurrentSizeInBytes;
+    /**
+     * update the visited time if item has been visited
+     *
+     * @param item - the item which need to be updated
+     * @param prefixedKey - the key of the item
+     *
+     * @return the updated item
+     */
+    private updateVisitedTime;
+    /**
+     * put item into cache
+     *
+     * @param prefixedKey - the key of the item
+     * @param itemData - the value of the item
+     * @param itemSizeInBytes - the byte size of the item
+     */
+    private setCacheItem;
     /**
-     * Return a new instance of cache with customized configuration.
-     * @param {Object} config - the customized configuration
-     * @return {Object} - the new instance of Cache
+     * total space needed when poping out items
+     *
+     * @param itemSize
+     *
+     * @return total space needed
+     */
+    private sizeToPop;
+    /**
+     * see whether cache is full
+     *
+     * @param itemSize
+     *
+     * @return true if cache is full
      */
-    createInstance(config: CacheConfig): ICache;
+    private isCacheFull;
+    /**
+     * get all the items we have, sort them by their priority,
+     * if priority is same, sort them by their last visited time
+     * pop out items from the low priority (5 is the lowest)
+     * @private
+     * @param keys - all the keys in this cache
+     * @param sizeToPop - the total size of the items which needed to be poped out
+     */
+    private popOutItems;
+    /**
+     * Scan the storage and combine the following operations for efficiency
+     *   1. Clear out all expired keys owned by this cache, not including the size key.
+     *   2. Return the remaining keys.
+     *
+     * @return The remaining valid keys
+     */
+    private clearInvalidAndGetRemainingKeys;
+    /**
+     * clear the entire cache
+     * The cache will abort and output a warning if error occurs
+     * @return {Promise}
+     */
+    clear(): Promise<void>;
 }
-declare const instance: ICache;
-export { AsyncStorage, instance as Cache };