@aws-amplify/cache 4.0.64-unstable.4 → 4.0.65

package/dist/aws-amplify-cache.js

@@ -0,0 +1,1480 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("aws_amplify_core"));
+	else if(typeof define === 'function' && define.amd)
+		define("aws_amplify_cache", ["aws_amplify_core"], factory);
+	else if(typeof exports === 'object')
+		exports["aws_amplify_cache"] = factory(require("aws_amplify_core"));
+	else
+		root["aws_amplify_cache"] = factory(root["aws_amplify_core"]);
+})(this, function(__WEBPACK_EXTERNAL_MODULE__aws_amplify_core__) {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = "./lib-esm/index.js");
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "./lib-esm/BrowserStorageCache.js":
+/*!****************************************!*\
+  !*** ./lib-esm/BrowserStorageCache.js ***!
+  \****************************************/
+/*! exports provided: BrowserStorageCacheClass, BrowserStorageCache, default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BrowserStorageCacheClass", function() { return BrowserStorageCacheClass; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BrowserStorageCache", function() { return BrowserStorageCache; });
+/* harmony import */ var _Utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Utils */ "./lib-esm/Utils/index.js");
+/* harmony import */ var _StorageCache__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./StorageCache */ "./lib-esm/StorageCache.js");
+/* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @aws-amplify/core */ "@aws-amplify/core");
+/* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_2__);
+/*
+ * Copyright 2017-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
+ * the License. A copy of the License is located at
+ *
+ *     http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ */
+var __extends = undefined && undefined.__extends || function () {
+  var _extendStatics = function extendStatics(d, b) {
+    _extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function (d, b) {
+      d.__proto__ = b;
+    } || function (d, b) {
+      for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    };
+    return _extendStatics(d, b);
+  };
+  return function (d, b) {
+    _extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+
+
+
+var logger = new _aws_amplify_core__WEBPACK_IMPORTED_MODULE_2__["ConsoleLogger"]('Cache');
+/**
+ * Customized storage based on the SessionStorage or LocalStorage with LRU implemented
+ */
+var BrowserStorageCacheClass = /** @class */function (_super) {
+  __extends(BrowserStorageCacheClass, _super);
+  /**
+   * initialize the cache
+   * @param config - the configuration of the cache
+   */
+  function BrowserStorageCacheClass(config) {
+    var _this = this;
+    var cacheConfig = config ? Object.assign({}, _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"], config) : _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"];
+    _this = _super.call(this, cacheConfig) || this;
+    _this.config.storage = cacheConfig.storage;
+    _this.getItem = _this.getItem.bind(_this);
+    _this.setItem = _this.setItem.bind(_this);
+    _this.removeItem = _this.removeItem.bind(_this);
+    return _this;
+  }
+  /**
+   * decrease current size of the cache
+   *
+   * @private
+   * @param amount - the amount of the cache size which needs to be decreased
+   */
+  BrowserStorageCacheClass.prototype._decreaseCurSizeInBytes = function (amount) {
+    var curSize = this.getCacheCurSize();
+    this.config.storage.setItem(this.cacheCurSizeKey, (curSize - amount).toString());
+  };
+  /**
+   * increase current size of the cache
+   *
+   * @private
+   * @param amount - the amount of the cache szie which need to be increased
+   */
+  BrowserStorageCacheClass.prototype._increaseCurSizeInBytes = function (amount) {
+    var curSize = this.getCacheCurSize();
+    this.config.storage.setItem(this.cacheCurSizeKey, (curSize + amount).toString());
+  };
+  /**
+   * 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
+   *
+   * @return the refreshed item
+   */
+  BrowserStorageCacheClass.prototype._refreshItem = function (item, prefixedKey) {
+    item.visitedTime = Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["getCurrTime"])();
+    this.config.storage.setItem(prefixedKey, JSON.stringify(item));
+    return item;
+  };
+  /**
+   * check wether item is expired
+   *
+   * @private
+   * @param key - the key of the item
+   *
+   * @return true if the item is expired.
+   */
+  BrowserStorageCacheClass.prototype._isExpired = function (key) {
+    var text = this.config.storage.getItem(key);
+    var item = JSON.parse(text);
+    if (Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["getCurrTime"])() >= item.expires) {
+      return true;
+    }
+    return false;
+  };
+  /**
+   * delete item from cache
+   *
+   * @private
+   * @param prefixedKey - the key of the item
+   * @param size - optional, the byte size of the item
+   */
+  BrowserStorageCacheClass.prototype._removeItem = function (prefixedKey, size) {
+    var itemSize = size ? size : JSON.parse(this.config.storage.getItem(prefixedKey)).byteSize;
+    this._decreaseCurSizeInBytes(itemSize);
+    // remove the cache item
+    this.config.storage.removeItem(prefixedKey);
+  };
+  /**
+   * 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
+   */
+  BrowserStorageCacheClass.prototype._setItem = function (prefixedKey, item) {
+    // update the cache size
+    this._increaseCurSizeInBytes(item.byteSize);
+    try {
+      this.config.storage.setItem(prefixedKey, JSON.stringify(item));
+    } catch (setItemErr) {
+      // if failed, we need to rollback the cache size
+      this._decreaseCurSizeInBytes(item.byteSize);
+      logger.error("Failed to set item " + setItemErr);
+    }
+  };
+  /**
+   * total space needed when poping out items
+   *
+   * @private
+   * @param itemSize
+   *
+   * @return total space needed
+   */
+  BrowserStorageCacheClass.prototype._sizeToPop = function (itemSize) {
+    var spaceItemNeed = this.getCacheCurSize() + itemSize - this.config.capacityInBytes;
+    var cacheThresholdSpace = (1 - this.config.warningThreshold) * this.config.capacityInBytes;
+    return spaceItemNeed > cacheThresholdSpace ? spaceItemNeed : cacheThresholdSpace;
+  };
+  /**
+   * see whether cache is full
+   *
+   * @private
+   * @param itemSize
+   *
+   * @return true if cache is full
+   */
+  BrowserStorageCacheClass.prototype._isCacheFull = function (itemSize) {
+    return itemSize + this.getCacheCurSize() > this.config.capacityInBytes;
+  };
+  /**
+   * 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
+   */
+  BrowserStorageCacheClass.prototype._findValidKeys = function () {
+    var keys = [];
+    var keyInCache = [];
+    // get all keys in Storage
+    for (var i = 0; i < this.config.storage.length; i += 1) {
+      keyInCache.push(this.config.storage.key(i));
+    }
+    // find those items which belong to our cache and also clean those expired items
+    for (var i = 0; i < keyInCache.length; i += 1) {
+      var key = keyInCache[i];
+      if (key.indexOf(this.config.keyPrefix) === 0 && key !== this.cacheCurSizeKey) {
+        if (this._isExpired(key)) {
+          this._removeItem(key);
+        } else {
+          keys.push(key);
+        }
+      }
+    }
+    return keys;
+  };
+  /**
+   * 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
+   */
+  BrowserStorageCacheClass.prototype._popOutItems = function (keys, sizeToPop) {
+    var items = [];
+    var remainedSize = sizeToPop;
+    // get the items from Storage
+    for (var i = 0; i < keys.length; i += 1) {
+      var val = this.config.storage.getItem(keys[i]);
+      if (val != null) {
+        var item = JSON.parse(val);
+        items.push(item);
+      }
+    }
+    // first compare priority
+    // then compare visited time
+    items.sort(function (a, b) {
+      if (a.priority > b.priority) {
+        return -1;
+      } else if (a.priority < b.priority) {
+        return 1;
+      } else {
+        if (a.visitedTime < b.visitedTime) {
+          return -1;
+        } else return 1;
+      }
+    });
+    for (var i = 0; i < items.length; i += 1) {
+      // pop out items until we have enough room for new item
+      this._removeItem(items[i].key, items[i].byteSize);
+      remainedSize -= items[i].byteSize;
+      if (remainedSize <= 0) {
+        return;
+      }
+    }
+  };
+  /**
+   * Set item into cache. You can put number, string, boolean or object.
+   * The cache will first check whether has the same key.
+   * If it has, it will delete the old item and then put the new item in
+   * The cache will pop out items if it is full
+   * You can specify the cache item options. The cache will abort and output a warning:
+   * If the key is invalid
+   * If the size of the item exceeds itemMaxSize.
+   * If the value is undefined
+   * If incorrect cache item configuration
+   * If error happened with browser storage
+   *
+   * @param key - the key of the item
+   * @param value - the value of the item
+   * @param {Object} [options] - optional, the specified meta-data
+   */
+  BrowserStorageCacheClass.prototype.setItem = function (key, value, options) {
+    logger.log("Set item: key is " + key + ", value is " + value + " with options: " + options);
+    var prefixedKey = this.config.keyPrefix + key;
+    // invalid keys
+    if (prefixedKey === this.config.keyPrefix || prefixedKey === this.cacheCurSizeKey) {
+      logger.warn("Invalid key: should not be empty or 'CurSize'");
+      return;
+    }
+    if (typeof value === 'undefined') {
+      logger.warn("The value of item should not be undefined!");
+      return;
+    }
+    var cacheItemOptions = {
+      priority: options && options.priority !== undefined ? options.priority : this.config.defaultPriority,
+      expires: options && options.expires !== undefined ? options.expires : this.config.defaultTTL + Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["getCurrTime"])()
+    };
+    if (cacheItemOptions.priority < 1 || cacheItemOptions.priority > 5) {
+      logger.warn("Invalid parameter: priority due to out or range. It should be within 1 and 5.");
+      return;
+    }
+    var item = this.fillCacheItem(prefixedKey, value, cacheItemOptions);
+    // check wether this item is too big;
+    if (item.byteSize > this.config.itemMaxSize) {
+      logger.warn("Item with key: " + key + " you are trying to put into is too big!");
+      return;
+    }
+    try {
+      // first look into the storage, if it exists, delete it.
+      var val = this.config.storage.getItem(prefixedKey);
+      if (val) {
+        this._removeItem(prefixedKey, JSON.parse(val).byteSize);
+      }
+      // check whether the cache is full
+      if (this._isCacheFull(item.byteSize)) {
+        var validKeys = this._findValidKeys();
+        // check again and then pop out items
+        if (this._isCacheFull(item.byteSize)) {
+          var sizeToPop = this._sizeToPop(item.byteSize);
+          this._popOutItems(validKeys, sizeToPop);
+        }
+      }
+      // put item in the cache
+      // may failed due to storage full
+      this._setItem(prefixedKey, item);
+    } catch (e) {
+      logger.warn("setItem failed! " + e);
+    }
+  };
+  /**
+   * 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,
+   * then the function will be executed if no such item in the cache
+   * and finally put the return value into cache.
+   * Please make sure the callback function will return the value you want to put into the cache.
+   * The cache will abort output a warning:
+   * If the key is invalid
+   * If error happened with browser storage
+   *
+   * @param key - the key of the item
+   * @param {Object} [options] - the options of callback function
+   *
+   * @return - return the value of the item
+   */
+  BrowserStorageCacheClass.prototype.getItem = function (key, options) {
+    logger.log("Get item: key is " + key + " with options " + options);
+    var ret = null;
+    var prefixedKey = this.config.keyPrefix + key;
+    if (prefixedKey === this.config.keyPrefix || prefixedKey === this.cacheCurSizeKey) {
+      logger.warn("Invalid key: should not be empty or 'CurSize'");
+      return null;
+    }
+    try {
+      ret = this.config.storage.getItem(prefixedKey);
+      if (ret != null) {
+        if (this._isExpired(prefixedKey)) {
+          // if expired, remove that item and return null
+          this._removeItem(prefixedKey, JSON.parse(ret).byteSize);
+          ret = null;
+        } else {
+          // if not expired, great, return the value and refresh it
+          var item = JSON.parse(ret);
+          item = this._refreshItem(item, prefixedKey);
+          return item.data;
+        }
+      }
+      if (options && options.callback !== undefined) {
+        var val = options.callback();
+        if (val !== null) {
+          this.setItem(key, val, options);
+        }
+        return val;
+      }
+      return null;
+    } catch (e) {
+      logger.warn("getItem failed! " + e);
+      return null;
+    }
+  };
+  /**
+   * remove item from the cache
+   * The cache will abort output a warning:
+   * If error happened with browser storage
+   * @param key - the key of the item
+   */
+  BrowserStorageCacheClass.prototype.removeItem = function (key) {
+    logger.log("Remove item: key is " + key);
+    var prefixedKey = this.config.keyPrefix + key;
+    if (prefixedKey === this.config.keyPrefix || prefixedKey === this.cacheCurSizeKey) {
+      return;
+    }
+    try {
+      var val = this.config.storage.getItem(prefixedKey);
+      if (val) {
+        this._removeItem(prefixedKey, JSON.parse(val).byteSize);
+      }
+    } catch (e) {
+      logger.warn("removeItem failed! " + e);
+    }
+  };
+  /**
+   * clear the entire cache
+   * The cache will abort output a warning:
+   * If error happened with browser storage
+   */
+  BrowserStorageCacheClass.prototype.clear = function () {
+    logger.log("Clear Cache");
+    var keysToRemove = [];
+    for (var i = 0; i < this.config.storage.length; i += 1) {
+      var key = this.config.storage.key(i);
+      if (key.indexOf(this.config.keyPrefix) === 0) {
+        keysToRemove.push(key);
+      }
+    }
+    try {
+      for (var i = 0; i < keysToRemove.length; i += 1) {
+        this.config.storage.removeItem(keysToRemove[i]);
+      }
+    } catch (e) {
+      logger.warn("clear failed! " + e);
+    }
+  };
+  /**
+   * Return all the keys in the cache.
+   *
+   * @return - all keys in the cache
+   */
+  BrowserStorageCacheClass.prototype.getAllKeys = function () {
+    var keys = [];
+    for (var i = 0; i < this.config.storage.length; i += 1) {
+      var key = this.config.storage.key(i);
+      if (key.indexOf(this.config.keyPrefix) === 0 && key !== this.cacheCurSizeKey) {
+        keys.push(key.substring(this.config.keyPrefix.length));
+      }
+    }
+    return keys;
+  };
+  /**
+   * return the current size of the cache
+   *
+   * @return - current size of the cache
+   */
+  BrowserStorageCacheClass.prototype.getCacheCurSize = function () {
+    var ret = this.config.storage.getItem(this.cacheCurSizeKey);
+    if (!ret) {
+      this.config.storage.setItem(this.cacheCurSizeKey, '0');
+      ret = '0';
+    }
+    return Number(ret);
+  };
+  /**
+   * Return a new instance of cache with customized configuration.
+   * @param config - the customized configuration
+   *
+   * @return - new instance of Cache
+   */
+  BrowserStorageCacheClass.prototype.createInstance = function (config) {
+    if (!config.keyPrefix || config.keyPrefix === _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"].keyPrefix) {
+      logger.error('invalid keyPrefix, setting keyPrefix with timeStamp');
+      config.keyPrefix = _Utils__WEBPACK_IMPORTED_MODULE_0__["getCurrTime"].toString();
+    }
+    return new BrowserStorageCacheClass(config);
+  };
+  return BrowserStorageCacheClass;
+}(_StorageCache__WEBPACK_IMPORTED_MODULE_1__["StorageCache"]);
+
+var BrowserStorageCache = new BrowserStorageCacheClass();
+/**
+ * @deprecated use named import
+ */
+/* harmony default export */ __webpack_exports__["default"] = (BrowserStorageCache);
+
+/***/ }),
+
+/***/ "./lib-esm/InMemoryCache.js":
+/*!**********************************!*\
+  !*** ./lib-esm/InMemoryCache.js ***!
+  \**********************************/
+/*! exports provided: InMemoryCacheClass, InMemoryCache, default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "InMemoryCacheClass", function() { return InMemoryCacheClass; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "InMemoryCache", function() { return InMemoryCache; });
+/* harmony import */ var _Utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Utils */ "./lib-esm/Utils/index.js");
+/* harmony import */ var _StorageCache__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./StorageCache */ "./lib-esm/StorageCache.js");
+/* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @aws-amplify/core */ "@aws-amplify/core");
+/* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_2__);
+/*
+ * Copyright 2017-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
+ * the License. A copy of the License is located at
+ *
+ *     http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ */
+var __extends = undefined && undefined.__extends || function () {
+  var _extendStatics = function extendStatics(d, b) {
+    _extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function (d, b) {
+      d.__proto__ = b;
+    } || function (d, b) {
+      for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    };
+    return _extendStatics(d, b);
+  };
+  return function (d, b) {
+    _extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var __values = undefined && undefined.__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 next() {
+      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.");
+};
+
+
+
+var logger = new _aws_amplify_core__WEBPACK_IMPORTED_MODULE_2__["ConsoleLogger"]('InMemoryCache');
+/**
+ * Customized in-memory cache with LRU implemented
+ * @member cacheObj - object which store items
+ * @member cacheList - list of keys in the cache with LRU
+ * @member curSizeInBytes - current size of the cache
+ * @member maxPriority - max of the priority
+ * @member cacheSizeLimit - the limit of cache size
+ */
+var InMemoryCacheClass = /** @class */function (_super) {
+  __extends(InMemoryCacheClass, _super);
+  /**
+   * initialize the cache
+   *
+   * @param config - the configuration of the cache
+   */
+  function InMemoryCacheClass(config) {
+    var _this = this;
+    var cacheConfig = config ? Object.assign({}, _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"], config) : _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"];
+    _this = _super.call(this, cacheConfig) || this;
+    logger.debug('now we start!');
+    _this.cacheList = [];
+    _this.curSizeInBytes = 0;
+    _this.maxPriority = 5;
+    _this.getItem = _this.getItem.bind(_this);
+    _this.setItem = _this.setItem.bind(_this);
+    _this.removeItem = _this.removeItem.bind(_this);
+    // initialize list for every priority
+    for (var i = 0; i < _this.maxPriority; i += 1) {
+      _this.cacheList[i] = new _Utils__WEBPACK_IMPORTED_MODULE_0__["CacheList"]();
+    }
+    return _this;
+  }
+  /**
+   * decrease current size of the cache
+   *
+   * @param amount - the amount of the cache size which needs to be decreased
+   */
+  InMemoryCacheClass.prototype._decreaseCurSizeInBytes = function (amount) {
+    this.curSizeInBytes -= amount;
+  };
+  /**
+   * increase current size of the cache
+   *
+   * @param amount - the amount of the cache szie which need to be increased
+   */
+  InMemoryCacheClass.prototype._increaseCurSizeInBytes = function (amount) {
+    this.curSizeInBytes += amount;
+  };
+  /**
+   * check whether item is expired
+   *
+   * @param key - the key of the item
+   *
+   * @return true if the item is expired.
+   */
+  InMemoryCacheClass.prototype._isExpired = function (key) {
+    var text = _Utils__WEBPACK_IMPORTED_MODULE_0__["CacheObject"].getItem(key);
+    var item = JSON.parse(text);
+    if (Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["getCurrTime"])() >= item.expires) {
+      return true;
+    }
+    return false;
+  };
+  /**
+   * delete item from cache
+   *
+   * @param prefixedKey - the key of the item
+   * @param listIdx - indicates which cache list the key belongs to
+   */
+  InMemoryCacheClass.prototype._removeItem = function (prefixedKey, listIdx) {
+    // delete the key from the list
+    this.cacheList[listIdx].removeItem(prefixedKey);
+    // decrease the current size of the cache
+    this._decreaseCurSizeInBytes(JSON.parse(_Utils__WEBPACK_IMPORTED_MODULE_0__["CacheObject"].getItem(prefixedKey)).byteSize);
+    // finally remove the item from memory
+    _Utils__WEBPACK_IMPORTED_MODULE_0__["CacheObject"].removeItem(prefixedKey);
+  };
+  /**
+   * 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
+   * @param listIdx - indicates which cache list the key belongs to
+   */
+  InMemoryCacheClass.prototype._setItem = function (prefixedKey, item, listIdx) {
+    // insert the key into the list
+    this.cacheList[listIdx].insertItem(prefixedKey);
+    // increase the current size of the cache
+    this._increaseCurSizeInBytes(item.byteSize);
+    // finally add the item into memory
+    _Utils__WEBPACK_IMPORTED_MODULE_0__["CacheObject"].setItem(prefixedKey, JSON.stringify(item));
+  };
+  /**
+   * see whether cache is full
+   *
+   * @param itemSize
+   *
+   * @return true if cache is full
+   */
+  InMemoryCacheClass.prototype._isCacheFull = function (itemSize) {
+    return this.curSizeInBytes + itemSize > this.config.capacityInBytes;
+  };
+  /**
+   * check whether the cache contains the key
+   *
+   * @param key
+   */
+  InMemoryCacheClass.prototype.containsKey = function (key) {
+    var prefixedKey = this.config.keyPrefix + key;
+    for (var i = 0; i < this.maxPriority; i += 1) {
+      if (this.cacheList[i].containsKey(prefixedKey)) {
+        return i + 1;
+      }
+    }
+    return -1;
+  };
+  /**
+   * * Set item into cache. You can put number, string, boolean or object.
+   * The cache will first check whether has the same key.
+   * If it has, it will delete the old item and then put the new item in
+   * The cache will pop out items if it is full
+   * You can specify the cache item options. The cache will abort and output a warning:
+   * If the key is invalid
+   * If the size of the item exceeds itemMaxSize.
+   * If the value is undefined
+   * If incorrect cache item configuration
+   * If error happened with browser storage
+   *
+   * @param key - the key of the item
+   * @param value - the value of the item
+   * @param options - optional, the specified meta-data
+   *
+   * @throws if the item is too big which exceeds the limit of single item size
+   * @throws if the key is invalid
+   */
+  InMemoryCacheClass.prototype.setItem = function (key, value, options) {
+    var prefixedKey = this.config.keyPrefix + key;
+    // invalid keys
+    if (prefixedKey === this.config.keyPrefix || prefixedKey === this.cacheCurSizeKey) {
+      logger.warn("Invalid key: should not be empty or 'CurSize'");
+      return;
+    }
+    if (typeof value === 'undefined') {
+      logger.warn("The value of item should not be undefined!");
+      return;
+    }
+    var cacheItemOptions = {
+      priority: options && options.priority !== undefined ? options.priority : this.config.defaultPriority,
+      expires: options && options.expires !== undefined ? options.expires : this.config.defaultTTL + Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["getCurrTime"])()
+    };
+    if (cacheItemOptions.priority < 1 || cacheItemOptions.priority > 5) {
+      logger.warn("Invalid parameter: priority due to out or range. It should be within 1 and 5.");
+      return;
+    }
+    var item = this.fillCacheItem(prefixedKey, value, cacheItemOptions);
+    // check wether this item is too big;
+    if (item.byteSize > this.config.itemMaxSize) {
+      logger.warn("Item with key: " + key + " you are trying to put into is too big!");
+      return;
+    }
+    // if key already in the cache, then delete it.
+    var presentKeyPrio = this.containsKey(key);
+    if (presentKeyPrio !== -1) {
+      this._removeItem(prefixedKey, presentKeyPrio - 1);
+    }
+    // pop out items in the cache when cache is full based on LRU
+    // first start from lowest priority cache list
+    var cacheListIdx = this.maxPriority - 1;
+    while (this._isCacheFull(item.byteSize) && cacheListIdx >= 0) {
+      if (!this.cacheList[cacheListIdx].isEmpty()) {
+        var popedItemKey = this.cacheList[cacheListIdx].getLastItem();
+        this._removeItem(popedItemKey, cacheListIdx);
+      } else {
+        cacheListIdx -= 1;
+      }
+    }
+    this._setItem(prefixedKey, item, Number(item.priority) - 1);
+  };
+  /**
+   * 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,
+   * then the function will be executed if no such item in the cache
+   * and finally put the return value into cache.
+   * Please make sure the callback function will return the value you want to put into the cache.
+   * The cache will abort output a warning:
+   * If the key is invalid
+   *
+   * @param key - the key of the item
+   * @param options - the options of callback function
+   */
+  InMemoryCacheClass.prototype.getItem = function (key, options) {
+    var ret = null;
+    var prefixedKey = this.config.keyPrefix + key;
+    if (prefixedKey === this.config.keyPrefix || prefixedKey === this.cacheCurSizeKey) {
+      logger.warn("Invalid key: should not be empty or 'CurSize'");
+      return null;
+    }
+    // check whether it's in the cachelist
+    var presentKeyPrio = this.containsKey(key);
+    if (presentKeyPrio !== -1) {
+      if (this._isExpired(prefixedKey)) {
+        // if expired, remove that item and return null
+        this._removeItem(prefixedKey, presentKeyPrio - 1);
+      } else {
+        // if not expired, great, return the value and refresh it
+        ret = _Utils__WEBPACK_IMPORTED_MODULE_0__["CacheObject"].getItem(prefixedKey);
+        var item = JSON.parse(ret);
+        this.cacheList[item.priority - 1].refresh(prefixedKey);
+        return item.data;
+      }
+    }
+    if (options && options.callback !== undefined) {
+      var val = options.callback();
+      if (val !== null) {
+        this.setItem(key, val, options);
+      }
+      return val;
+    }
+    return null;
+  };
+  /**
+   * remove item from the cache
+   *
+   * @param key - the key of the item
+   */
+  InMemoryCacheClass.prototype.removeItem = function (key) {
+    var prefixedKey = this.config.keyPrefix + key;
+    // check if the key is in the cache
+    var presentKeyPrio = this.containsKey(key);
+    if (presentKeyPrio !== -1) {
+      this._removeItem(prefixedKey, presentKeyPrio - 1);
+    }
+  };
+  /**
+   * clear the entire cache
+   */
+  InMemoryCacheClass.prototype.clear = function () {
+    var e_1, _a;
+    for (var i = 0; i < this.maxPriority; i += 1) {
+      try {
+        for (var _b = (e_1 = void 0, __values(this.cacheList[i].getKeys())), _c = _b.next(); !_c.done; _c = _b.next()) {
+          var key = _c.value;
+          this._removeItem(key, i);
+        }
+      } 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;
+        }
+      }
+    }
+  };
+  /**
+   * Return all the keys in the cache.
+   */
+  InMemoryCacheClass.prototype.getAllKeys = function () {
+    var e_2, _a;
+    var keys = [];
+    for (var i = 0; i < this.maxPriority; i += 1) {
+      try {
+        for (var _b = (e_2 = void 0, __values(this.cacheList[i].getKeys())), _c = _b.next(); !_c.done; _c = _b.next()) {
+          var key = _c.value;
+          keys.push(key.substring(this.config.keyPrefix.length));
+        }
+      } catch (e_2_1) {
+        e_2 = {
+          error: e_2_1
+        };
+      } finally {
+        try {
+          if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+        } finally {
+          if (e_2) throw e_2.error;
+        }
+      }
+    }
+    return keys;
+  };
+  /**
+   * return the current size of the cache
+   *
+   * @return the current size of the cache
+   */
+  InMemoryCacheClass.prototype.getCacheCurSize = function () {
+    return this.curSizeInBytes;
+  };
+  /**
+   * Return a new instance of cache with customized configuration.
+   * @param config - the customized configuration
+   */
+  InMemoryCacheClass.prototype.createInstance = function (config) {
+    return new InMemoryCacheClass(config);
+  };
+  return InMemoryCacheClass;
+}(_StorageCache__WEBPACK_IMPORTED_MODULE_1__["StorageCache"]);
+
+var InMemoryCache = new InMemoryCacheClass();
+/**
+ * @deprecated use named import
+ */
+/* harmony default export */ __webpack_exports__["default"] = (InMemoryCache);
+
+/***/ }),
+
+/***/ "./lib-esm/StorageCache.js":
+/*!*********************************!*\
+  !*** ./lib-esm/StorageCache.js ***!
+  \*********************************/
+/*! exports provided: StorageCache, default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "StorageCache", function() { return StorageCache; });
+/* harmony import */ var _Utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Utils */ "./lib-esm/Utils/index.js");
+/* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @aws-amplify/core */ "@aws-amplify/core");
+/* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__);
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+/*
+ * Copyright 2017-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
+ * the License. A copy of the License is located at
+ *
+ *     http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ */
+
+
+var logger = new _aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__["ConsoleLogger"]('StorageCache');
+/**
+ * Initialization of the cache
+ *
+ */
+var StorageCache = /** @class */function () {
+  /**
+   * Initialize the cache
+   * @param config - the configuration of the cache
+   */
+  function StorageCache(config) {
+    this.config = Object.assign({}, config);
+    this.cacheCurSizeKey = this.config.keyPrefix + 'CurSize';
+    this.checkConfig();
+  }
+  StorageCache.prototype.getModuleName = function () {
+    return 'Cache';
+  };
+  StorageCache.prototype.checkConfig = function () {
+    // check configuration
+    if (!Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["isInteger"])(this.config.capacityInBytes)) {
+      logger.error('Invalid parameter: capacityInBytes. It should be an Integer. Setting back to default.');
+      this.config.capacityInBytes = _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"].capacityInBytes;
+    }
+    if (!Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["isInteger"])(this.config.itemMaxSize)) {
+      logger.error('Invalid parameter: itemMaxSize. It should be an Integer. Setting back to default.');
+      this.config.itemMaxSize = _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"].itemMaxSize;
+    }
+    if (!Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["isInteger"])(this.config.defaultTTL)) {
+      logger.error('Invalid parameter: defaultTTL. It should be an Integer. Setting back to default.');
+      this.config.defaultTTL = _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"].defaultTTL;
+    }
+    if (!Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["isInteger"])(this.config.defaultPriority)) {
+      logger.error('Invalid parameter: defaultPriority. It should be an Integer. Setting back to default.');
+      this.config.defaultPriority = _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"].defaultPriority;
+    }
+    if (this.config.itemMaxSize > this.config.capacityInBytes) {
+      logger.error('Invalid parameter: itemMaxSize. It should be smaller than capacityInBytes. Setting back to default.');
+      this.config.itemMaxSize = _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"].itemMaxSize;
+    }
+    if (this.config.defaultPriority > 5 || this.config.defaultPriority < 1) {
+      logger.error('Invalid parameter: defaultPriority. It should be between 1 and 5. Setting back to default.');
+      this.config.defaultPriority = _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"].defaultPriority;
+    }
+    if (Number(this.config.warningThreshold) > 1 || Number(this.config.warningThreshold) < 0) {
+      logger.error('Invalid parameter: warningThreshold. It should be between 0 and 1. Setting back to default.');
+      this.config.warningThreshold = _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"].warningThreshold;
+    }
+    // set 5MB limit
+    var cacheLimit = 5 * 1024 * 1024;
+    if (this.config.capacityInBytes > cacheLimit) {
+      logger.error('Cache Capacity should be less than 5MB. Setting back to default. Setting back to default.');
+      this.config.capacityInBytes = _Utils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"].capacityInBytes;
+    }
+  };
+  /**
+   * 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 ret = {
+      key: key,
+      data: value,
+      timestamp: Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["getCurrTime"])(),
+      visitedTime: Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["getCurrTime"])(),
+      priority: options.priority,
+      expires: options.expires,
+      type: _typeof(value),
+      byteSize: 0
+    };
+    ret.byteSize = Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["getByteLength"])(JSON.stringify(ret));
+    // for accurate size
+    ret.byteSize = Object(_Utils__WEBPACK_IMPORTED_MODULE_0__["getByteLength"])(JSON.stringify(ret));
+    return ret;
+  };
+  /**
+   * set cache with customized configuration
+   * @param config - customized configuration
+   *
+   * @return - the current configuration
+   */
+  StorageCache.prototype.configure = function (config) {
+    if (!config) {
+      return this.config;
+    }
+    if (config.keyPrefix) {
+      logger.warn("Don't try to configure keyPrefix!");
+    }
+    this.config = Object.assign({}, this.config, config, config.Cache);
+    this.checkConfig();
+    return this.config;
+  };
+  return StorageCache;
+}();
+
+/**
+ * @deprecated use named import
+ */
+/* harmony default export */ __webpack_exports__["default"] = (StorageCache);
+
+/***/ }),
+
+/***/ "./lib-esm/Utils/CacheList.js":
+/*!************************************!*\
+  !*** ./lib-esm/Utils/CacheList.js ***!
+  \************************************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/*
+ * Copyright 2017-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
+ * the License. A copy of the License is located at
+ *
+ *     http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ */
+var __values = undefined && undefined.__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 next() {
+      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.");
+};
+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;
+    tmp.prevNode = node;
+    this.length = this.length + 1;
+  };
+  /**
+   * remove node
+   *
+   * @param node
+   */
+  CacheList.prototype.removeNode = function (node) {
+    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 () {
+    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;
+}();
+/* harmony default export */ __webpack_exports__["default"] = (CacheList);
+
+/***/ }),
+
+/***/ "./lib-esm/Utils/CacheUtils.js":
+/*!*************************************!*\
+  !*** ./lib-esm/Utils/CacheUtils.js ***!
+  \*************************************/
+/*! exports provided: defaultConfig, getByteLength, getCurrTime, isInteger, CacheObject */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "defaultConfig", function() { return defaultConfig; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getByteLength", function() { return getByteLength; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getCurrTime", function() { return getCurrTime; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isInteger", function() { return isInteger; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CacheObject", function() { return CacheObject; });
+/* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @aws-amplify/core */ "@aws-amplify/core");
+/* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__);
+/*
+ * Copyright 2017-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
+ * the License. A copy of the License is located at
+ *
+ *     http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ */
+
+/**
+ * Default cache config
+ */
+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 _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__["StorageHelper"]().getStorage()
+};
+/**
+ * return the byte size of the string
+ * @param str
+ */
+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
+ */
+function getCurrTime() {
+  var currTime = new Date();
+  return currTime.getTime();
+}
+/**
+ * check if passed value is an integer
+ */
+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;
+}();
+
+
+/***/ }),
+
+/***/ "./lib-esm/Utils/index.js":
+/*!********************************!*\
+  !*** ./lib-esm/Utils/index.js ***!
+  \********************************/
+/*! exports provided: defaultConfig, getByteLength, getCurrTime, isInteger, CacheObject, CacheList */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _CacheUtils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./CacheUtils */ "./lib-esm/Utils/CacheUtils.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "defaultConfig", function() { return _CacheUtils__WEBPACK_IMPORTED_MODULE_0__["defaultConfig"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "getByteLength", function() { return _CacheUtils__WEBPACK_IMPORTED_MODULE_0__["getByteLength"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "getCurrTime", function() { return _CacheUtils__WEBPACK_IMPORTED_MODULE_0__["getCurrTime"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "isInteger", function() { return _CacheUtils__WEBPACK_IMPORTED_MODULE_0__["isInteger"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "CacheObject", function() { return _CacheUtils__WEBPACK_IMPORTED_MODULE_0__["CacheObject"]; });
+
+/* harmony import */ var _CacheList__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./CacheList */ "./lib-esm/Utils/CacheList.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "CacheList", function() { return _CacheList__WEBPACK_IMPORTED_MODULE_1__["default"]; });
+
+/*
+ * Copyright 2017-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
+ * the License. A copy of the License is located at
+ *
+ *     http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ */
+
+
+
+/***/ }),
+
+/***/ "./lib-esm/index.js":
+/*!**************************!*\
+  !*** ./lib-esm/index.js ***!
+  \**************************/
+/*! exports provided: BrowserStorageCache, InMemoryCache, Cache, default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @aws-amplify/core */ "@aws-amplify/core");
+/* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _BrowserStorageCache__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./BrowserStorageCache */ "./lib-esm/BrowserStorageCache.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "BrowserStorageCache", function() { return _BrowserStorageCache__WEBPACK_IMPORTED_MODULE_1__["BrowserStorageCache"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Cache", function() { return _BrowserStorageCache__WEBPACK_IMPORTED_MODULE_1__["BrowserStorageCache"]; });
+
+/* harmony import */ var _InMemoryCache__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./InMemoryCache */ "./lib-esm/InMemoryCache.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "InMemoryCache", function() { return _InMemoryCache__WEBPACK_IMPORTED_MODULE_2__["InMemoryCache"]; });
+
+/*
+ * Copyright 2017-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
+ * the License. A copy of the License is located at
+ *
+ *     http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+ * and limitations under the License.
+ */
+
+
+
+
+
+/**
+ * @deprecated use named import
+ */
+/* harmony default export */ __webpack_exports__["default"] = (_BrowserStorageCache__WEBPACK_IMPORTED_MODULE_1__["BrowserStorageCache"]);
+_aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__["Amplify"].register(_BrowserStorageCache__WEBPACK_IMPORTED_MODULE_1__["BrowserStorageCache"]);
+
+/***/ }),
+
+/***/ "@aws-amplify/core":
+/*!***********************************!*\
+  !*** external "aws_amplify_core" ***!
+  \***********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__aws_amplify_core__;
+
+/***/ })
+
+/******/ });
+});
+//# sourceMappingURL=aws-amplify-cache.js.map