@aws-amplify/core 4.7.7-unstable.2 → 4.7.7-unstable.7

package/dist/aws-amplify-core.js

@@ -658,8 +658,12 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _whatwgEncodingApi__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./whatwgEncodingApi */ "../../node_modules/@aws-crypto/sha256-browser/node_modules/@aws-sdk/util-utf8-browser/dist-es/whatwgEncodingApi.js");
 
 
-const fromUtf8 = (input) => typeof TextEncoder === "function" ? Object(_whatwgEncodingApi__WEBPACK_IMPORTED_MODULE_1__["fromUtf8"])(input) : Object(_pureJs__WEBPACK_IMPORTED_MODULE_0__["fromUtf8"])(input);
-const toUtf8 = (input) => typeof TextDecoder === "function" ? Object(_whatwgEncodingApi__WEBPACK_IMPORTED_MODULE_1__["toUtf8"])(input) : Object(_pureJs__WEBPACK_IMPORTED_MODULE_0__["toUtf8"])(input);
+var fromUtf8 = function (input) {
+    return typeof TextEncoder === "function" ? Object(_whatwgEncodingApi__WEBPACK_IMPORTED_MODULE_1__["fromUtf8"])(input) : Object(_pureJs__WEBPACK_IMPORTED_MODULE_0__["fromUtf8"])(input);
+};
+var toUtf8 = function (input) {
+    return typeof TextDecoder === "function" ? Object(_whatwgEncodingApi__WEBPACK_IMPORTED_MODULE_1__["toUtf8"])(input) : Object(_pureJs__WEBPACK_IMPORTED_MODULE_0__["toUtf8"])(input);
+};
 
 
 /***/ }),
@@ -675,44 +679,44 @@ const toUtf8 = (input) => typeof TextDecoder === "function" ? Object(_whatwgEnco
 __webpack_require__.r(__webpack_exports__);
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromUtf8", function() { return fromUtf8; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toUtf8", function() { return toUtf8; });
-const fromUtf8 = (input) => {
-    const bytes = [];
-    for (let i = 0, len = input.length; i < len; i++) {
-        const value = input.charCodeAt(i);
+var fromUtf8 = function (input) {
+    var bytes = [];
+    for (var i = 0, len = input.length; i < len; i++) {
+        var value = input.charCodeAt(i);
         if (value < 0x80) {
             bytes.push(value);
         }
         else if (value < 0x800) {
-            bytes.push((value >> 6) | 0b11000000, (value & 0b111111) | 0b10000000);
+            bytes.push((value >> 6) | 192, (value & 63) | 128);
         }
         else if (i + 1 < input.length && (value & 0xfc00) === 0xd800 && (input.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
-            const surrogatePair = 0x10000 + ((value & 0b1111111111) << 10) + (input.charCodeAt(++i) & 0b1111111111);
-            bytes.push((surrogatePair >> 18) | 0b11110000, ((surrogatePair >> 12) & 0b111111) | 0b10000000, ((surrogatePair >> 6) & 0b111111) | 0b10000000, (surrogatePair & 0b111111) | 0b10000000);
+            var surrogatePair = 0x10000 + ((value & 1023) << 10) + (input.charCodeAt(++i) & 1023);
+            bytes.push((surrogatePair >> 18) | 240, ((surrogatePair >> 12) & 63) | 128, ((surrogatePair >> 6) & 63) | 128, (surrogatePair & 63) | 128);
         }
         else {
-            bytes.push((value >> 12) | 0b11100000, ((value >> 6) & 0b111111) | 0b10000000, (value & 0b111111) | 0b10000000);
+            bytes.push((value >> 12) | 224, ((value >> 6) & 63) | 128, (value & 63) | 128);
         }
     }
     return Uint8Array.from(bytes);
 };
-const toUtf8 = (input) => {
-    let decoded = "";
-    for (let i = 0, len = input.length; i < len; i++) {
-        const byte = input[i];
+var toUtf8 = function (input) {
+    var decoded = "";
+    for (var i = 0, len = input.length; i < len; i++) {
+        var byte = input[i];
         if (byte < 0x80) {
             decoded += String.fromCharCode(byte);
         }
-        else if (0b11000000 <= byte && byte < 0b11100000) {
-            const nextByte = input[++i];
-            decoded += String.fromCharCode(((byte & 0b11111) << 6) | (nextByte & 0b111111));
+        else if (192 <= byte && byte < 224) {
+            var nextByte = input[++i];
+            decoded += String.fromCharCode(((byte & 31) << 6) | (nextByte & 63));
         }
-        else if (0b11110000 <= byte && byte < 0b101101101) {
-            const surrogatePair = [byte, input[++i], input[++i], input[++i]];
-            const encoded = "%" + surrogatePair.map((byteValue) => byteValue.toString(16)).join("%");
+        else if (240 <= byte && byte < 365) {
+            var surrogatePair = [byte, input[++i], input[++i], input[++i]];
+            var encoded = "%" + surrogatePair.map(function (byteValue) { return byteValue.toString(16); }).join("%");
             decoded += decodeURIComponent(encoded);
         }
         else {
-            decoded += String.fromCharCode(((byte & 0b1111) << 12) | ((input[++i] & 0b111111) << 6) | (input[++i] & 0b111111));
+            decoded += String.fromCharCode(((byte & 15) << 12) | ((input[++i] & 63) << 6) | (input[++i] & 63));
         }
     }
     return decoded;
@@ -1249,8 +1253,12 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _whatwgEncodingApi__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./whatwgEncodingApi */ "../../node_modules/@aws-crypto/sha256-js/node_modules/@aws-sdk/util-utf8-browser/dist-es/whatwgEncodingApi.js");
 
 
-const fromUtf8 = (input) => typeof TextEncoder === "function" ? Object(_whatwgEncodingApi__WEBPACK_IMPORTED_MODULE_1__["fromUtf8"])(input) : Object(_pureJs__WEBPACK_IMPORTED_MODULE_0__["fromUtf8"])(input);
-const toUtf8 = (input) => typeof TextDecoder === "function" ? Object(_whatwgEncodingApi__WEBPACK_IMPORTED_MODULE_1__["toUtf8"])(input) : Object(_pureJs__WEBPACK_IMPORTED_MODULE_0__["toUtf8"])(input);
+var fromUtf8 = function (input) {
+    return typeof TextEncoder === "function" ? Object(_whatwgEncodingApi__WEBPACK_IMPORTED_MODULE_1__["fromUtf8"])(input) : Object(_pureJs__WEBPACK_IMPORTED_MODULE_0__["fromUtf8"])(input);
+};
+var toUtf8 = function (input) {
+    return typeof TextDecoder === "function" ? Object(_whatwgEncodingApi__WEBPACK_IMPORTED_MODULE_1__["toUtf8"])(input) : Object(_pureJs__WEBPACK_IMPORTED_MODULE_0__["toUtf8"])(input);
+};
 
 
 /***/ }),
@@ -1266,44 +1274,44 @@ const toUtf8 = (input) => typeof TextDecoder === "function" ? Object(_whatwgEnco
 __webpack_require__.r(__webpack_exports__);
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromUtf8", function() { return fromUtf8; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toUtf8", function() { return toUtf8; });
-const fromUtf8 = (input) => {
-    const bytes = [];
-    for (let i = 0, len = input.length; i < len; i++) {
-        const value = input.charCodeAt(i);
+var fromUtf8 = function (input) {
+    var bytes = [];
+    for (var i = 0, len = input.length; i < len; i++) {
+        var value = input.charCodeAt(i);
         if (value < 0x80) {
             bytes.push(value);
         }
         else if (value < 0x800) {
-            bytes.push((value >> 6) | 0b11000000, (value & 0b111111) | 0b10000000);
+            bytes.push((value >> 6) | 192, (value & 63) | 128);
         }
         else if (i + 1 < input.length && (value & 0xfc00) === 0xd800 && (input.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
-            const surrogatePair = 0x10000 + ((value & 0b1111111111) << 10) + (input.charCodeAt(++i) & 0b1111111111);
-            bytes.push((surrogatePair >> 18) | 0b11110000, ((surrogatePair >> 12) & 0b111111) | 0b10000000, ((surrogatePair >> 6) & 0b111111) | 0b10000000, (surrogatePair & 0b111111) | 0b10000000);
+            var surrogatePair = 0x10000 + ((value & 1023) << 10) + (input.charCodeAt(++i) & 1023);
+            bytes.push((surrogatePair >> 18) | 240, ((surrogatePair >> 12) & 63) | 128, ((surrogatePair >> 6) & 63) | 128, (surrogatePair & 63) | 128);
         }
         else {
-            bytes.push((value >> 12) | 0b11100000, ((value >> 6) & 0b111111) | 0b10000000, (value & 0b111111) | 0b10000000);
+            bytes.push((value >> 12) | 224, ((value >> 6) & 63) | 128, (value & 63) | 128);
         }
     }
     return Uint8Array.from(bytes);
 };
-const toUtf8 = (input) => {
-    let decoded = "";
-    for (let i = 0, len = input.length; i < len; i++) {
-        const byte = input[i];
+var toUtf8 = function (input) {
+    var decoded = "";
+    for (var i = 0, len = input.length; i < len; i++) {
+        var byte = input[i];
         if (byte < 0x80) {
             decoded += String.fromCharCode(byte);
         }
-        else if (0b11000000 <= byte && byte < 0b11100000) {
-            const nextByte = input[++i];
-            decoded += String.fromCharCode(((byte & 0b11111) << 6) | (nextByte & 0b111111));
+        else if (192 <= byte && byte < 224) {
+            var nextByte = input[++i];
+            decoded += String.fromCharCode(((byte & 31) << 6) | (nextByte & 63));
         }
-        else if (0b11110000 <= byte && byte < 0b101101101) {
-            const surrogatePair = [byte, input[++i], input[++i], input[++i]];
-            const encoded = "%" + surrogatePair.map((byteValue) => byteValue.toString(16)).join("%");
+        else if (240 <= byte && byte < 365) {
+            var surrogatePair = [byte, input[++i], input[++i], input[++i]];
+            var encoded = "%" + surrogatePair.map(function (byteValue) { return byteValue.toString(16); }).join("%");
             decoded += decodeURIComponent(encoded);
         }
         else {
-            decoded += String.fromCharCode(((byte & 0b1111) << 12) | ((input[++i] & 0b111111) << 6) | (input[++i] & 0b111111));
+            decoded += String.fromCharCode(((byte & 15) << 12) | ((input[++i] & 63) << 6) | (input[++i] & 63));
         }
     }
     return decoded;
@@ -23866,7 +23874,7 @@ function calculateBodyLength(body) {
 "use strict";
 __webpack_require__.r(__webpack_exports__);
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "locateWindow", function() { return locateWindow; });
-const fallbackWindow = {};
+var fallbackWindow = {};
 function locateWindow() {
     if (typeof window !== "undefined") {
         return window;
@@ -35006,6 +35014,578 @@ function () {
 
 
 
+/***/ }),
+
+/***/ "./lib-esm/Util/BackgroundProcessManager.js":
+/*!**************************************************!*\
+  !*** ./lib-esm/Util/BackgroundProcessManager.js ***!
+  \**************************************************/
+/*! exports provided: BackgroundProcessManager, BackgroundProcessManagerState */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BackgroundProcessManager", function() { return BackgroundProcessManager; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BackgroundProcessManagerState", function() { return BackgroundProcessManagerState; });
+var __awaiter = undefined && undefined.__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 = undefined && undefined.__generator || function (thisArg, body) {
+  var _ = {
+    label: 0,
+    sent: function sent() {
+      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 (_) {
+      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 = 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.");
+};
+/**
+ * @private For internal Amplify use.
+ *
+ * Creates a new scope for promises, observables, and other types of work or
+ * processes that may be running in the background. This manager provides
+ * an singular entrypoint to request termination and await completion.
+ *
+ * As work completes on its own prior to close, the manager removes them
+ * from the registry to avoid holding references to completed jobs.
+ */
+
+
+var BackgroundProcessManager =
+/** @class */
+function () {
+  /**
+   * Creates a new manager for promises, observables, and other types
+   * of work that may be running in the background. This manager provides
+   * a centralized mechanism to request termination and await completion.
+   */
+  function BackgroundProcessManager() {
+    /**
+     * A string indicating whether the manager is accepting new work ("Open"),
+     * waiting for work to complete ("Closing"), or fully done with all
+     * submitted work and *not* accepting new jobs ("Closed").
+     */
+    this._state = BackgroundProcessManagerState.Open;
+    /**
+     * The list of outstanding jobs we'll need to wait for upon `close()`
+     */
+
+    this.jobs = new Set();
+  }
+
+  BackgroundProcessManager.prototype.add = function (jobOrDescription, optionalDescription) {
+    var job;
+    var description;
+
+    if (typeof jobOrDescription === 'string') {
+      job = undefined;
+      description = jobOrDescription;
+    } else {
+      job = jobOrDescription;
+      description = optionalDescription;
+    }
+
+    var error = this.closedFailure(description);
+    if (error) return error;
+
+    if (job === undefined) {
+      return this.addHook(description);
+    } else if (typeof job === 'function') {
+      return this.addFunction(job, description);
+    } else if (job instanceof BackgroundProcessManager) {
+      return this.addManager(job, description);
+    } else {
+      throw new Error('If `job` is provided, it must be an Observable, Function, or BackgroundProcessManager.');
+    }
+  };
+  /**
+   * Adds a **cleaner** function that doesn't immediately get executed.
+   * Instead, the caller gets a **terminate** function back. The *cleaner* is
+   * invoked only once the mananger *closes* or the returned **terminate**
+   * function is called.
+   *
+   * @param clean The cleanup function.
+   * @param description Optional description to help identify pending jobs.
+   * @returns A terminate function.
+   */
+
+
+  BackgroundProcessManager.prototype.addCleaner = function (clean, description) {
+    var _this = this;
+
+    var _a = this.addHook(description),
+        resolve = _a.resolve,
+        onTerminate = _a.onTerminate;
+
+    var proxy = function proxy() {
+      return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+          switch (_a.label) {
+            case 0:
+              return [4
+              /*yield*/
+              , clean()];
+
+            case 1:
+              _a.sent();
+
+              resolve();
+              return [2
+              /*return*/
+              ];
+          }
+        });
+      });
+    };
+
+    onTerminate.then(proxy);
+    return proxy;
+  };
+
+  BackgroundProcessManager.prototype.addFunction = function (job, description) {
+    // the function we call when we want to try to terminate this job.
+    var terminate; // the promise the job can opt into listening to for termination.
+
+    var onTerminate = new Promise(function (resolve) {
+      terminate = resolve;
+    }); // finally! start the job.
+
+    var jobResult = job(onTerminate); // depending on what the job gives back, register the result
+    // so we can monitor for completion.
+
+    if (typeof (jobResult === null || jobResult === void 0 ? void 0 : jobResult.then) === 'function') {
+      this.registerPromise(jobResult, terminate, description);
+    } // At the end of the day, or you know, method call, it doesn't matter
+    // what the return value is at all; we just pass it through to the
+    // caller.
+
+
+    return jobResult;
+  };
+
+  BackgroundProcessManager.prototype.addManager = function (manager, description) {
+    var _this = this;
+
+    this.addCleaner(function () {
+      return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+          switch (_a.label) {
+            case 0:
+              return [4
+              /*yield*/
+              , manager.close()];
+
+            case 1:
+              return [2
+              /*return*/
+              , _a.sent()];
+          }
+        });
+      });
+    }, description);
+  };
+  /**
+   * Creates and registers a fabricated job for processes that need to operate
+   * with callbacks/hooks. The returned `resolve` and `reject`
+   * functions can be used to signal the job is done successfully or not.
+   * The returned `onTerminate` is a promise that will resolve when the
+   * manager is requesting the termination of the job.
+   *
+   * @param description Optional description to help identify pending jobs.
+   * @returns `{ resolve, reject, onTerminate }`
+   */
+
+
+  BackgroundProcessManager.prototype.addHook = function (description) {
+    // the resolve/reject functions we'll provide to the caller to signal
+    // the state of the job.
+    var resolve;
+    var reject; // the underlying promise we'll use to manage it, pretty much like
+    // any other promise.
+
+    var promise = new Promise(function (res, rej) {
+      resolve = res;
+      reject = rej;
+    }); // the function we call when we want to try to terminate this job.
+
+    var terminate; // the promise the job can opt into listening to for termination.
+
+    var onTerminate = new Promise(function (resolveTerminate) {
+      terminate = resolveTerminate;
+    });
+    this.registerPromise(promise, terminate, description);
+    return {
+      resolve: resolve,
+      reject: reject,
+      onTerminate: onTerminate
+    };
+  };
+  /**
+   * Adds a Promise based job to the list of jobs for monitoring and listens
+   * for either a success or failure, upon which the job is considered "done"
+   * and removed from the registry.
+   *
+   * @param promise A promise that is on its way to being returned to a
+   * caller, which needs to be tracked as a background job.
+   * @param terminate The termination function to register, which can be
+   * invoked to request the job stop.
+   * @param description Optional description to help identify pending jobs.
+   */
+
+
+  BackgroundProcessManager.prototype.registerPromise = function (promise, terminate, description) {
+    var _this = this;
+
+    var jobEntry = {
+      promise: promise,
+      terminate: terminate,
+      description: description
+    };
+    this.jobs.add(jobEntry); // in all of my testing, it is safe to multi-subscribe to a promise.
+    // so, rather than create another layer of promising, we're just going
+    // to hook into the promise we already have, and when it's done
+    // (successfully or not), we no longer need to wait for it upon close.
+    //
+    // sorry this is a bit hand-wavy:
+    //
+    // i believe we use `.then` and `.catch` instead of `.finally` because
+    // `.finally` is invoked in a different order in the sequence, and this
+    // breaks assumptions throughout and causes failures.
+
+    promise.then(function () {
+      _this.jobs["delete"](jobEntry);
+    })["catch"](function () {
+      _this.jobs["delete"](jobEntry);
+    });
+  };
+
+  Object.defineProperty(BackgroundProcessManager.prototype, "length", {
+    /**
+     * The number of jobs being waited on.
+     *
+     * We don't use this for anything. It's just informational for the caller,
+     * and can be used in logging and testing.
+     *
+     * @returns the number of jobs.
+     */
+    get: function get() {
+      return this.jobs.size;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(BackgroundProcessManager.prototype, "state", {
+    /**
+     * The execution state of the manager. One of:
+     *
+     * 1. "Open" -> Accepting new jobs
+     * 1. "Closing" -> Not accepting new work. Waiting for jobs to complete.
+     * 1. "Closed" -> Not accepting new work. All submitted jobs are complete.
+     */
+    get: function get() {
+      return this._state;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(BackgroundProcessManager.prototype, "pending", {
+    /**
+     * The registered `description` of all still-pending jobs.
+     *
+     * @returns descriptions as an array.
+     */
+    get: function get() {
+      return Array.from(this.jobs).map(function (job) {
+        return job.description;
+      });
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(BackgroundProcessManager.prototype, "isOpen", {
+    /**
+     * Whether the manager is accepting new jobs.
+     */
+    get: function get() {
+      return this._state === BackgroundProcessManagerState.Open;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(BackgroundProcessManager.prototype, "isClosing", {
+    /**
+     * Whether the manager is rejecting new work, but still waiting for
+     * submitted work to complete.
+     */
+    get: function get() {
+      return this._state === BackgroundProcessManagerState.Closing;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(BackgroundProcessManager.prototype, "isClosed", {
+    /**
+     * Whether the manager is rejecting work and done waiting for submitted
+     * work to complete.
+     */
+    get: function get() {
+      return this._state === BackgroundProcessManagerState.Closed;
+    },
+    enumerable: true,
+    configurable: true
+  });
+
+  BackgroundProcessManager.prototype.closedFailure = function (description) {
+    if (!this.isOpen) {
+      return Promise.reject(new Error(['The manager is closing or closed, which occurs after `close()` has been called.', "This error occurred trying to add \"" + description + "\".", "Pending jobs: [\n" + this.pending.map(function (t) {
+        return '    ' + t;
+      }).join(',\n') + "\n]"].join('\n')));
+    }
+  };
+  /**
+   * Signals jobs to stop (for those that accept interruptions) and waits
+   * for confirmation that jobs have stopped.
+   *
+   * This immediately puts the manager into a closing state and just begins
+   * to reject new work. After all work in the manager is complete, the
+   * manager goes into a `Completed` state and `close()` returns.
+   *
+   * @returns The settled results of each job's promise.
+   */
+
+
+  BackgroundProcessManager.prototype.close = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      var _a, _b, job, results;
+
+      var e_1, _c;
+
+      return __generator(this, function (_d) {
+        switch (_d.label) {
+          case 0:
+            // prevents more jobs from being added
+            this._state = BackgroundProcessManagerState.Closing;
+
+            try {
+              for (_a = __values(Array.from(this.jobs)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                job = _b.value;
+
+                try {
+                  job.terminate();
+                } catch (error) {
+                  // Due to potential races with a job's natural completion, it's
+                  // reasonable to expect the termination call to fail. Hence,
+                  // not logging as an error.
+                  console.warn("Failed to send termination signal to job. Error: " + error.message, job);
+                }
+              }
+            } catch (e_1_1) {
+              e_1 = {
+                error: e_1_1
+              };
+            } finally {
+              try {
+                if (_b && !_b.done && (_c = _a["return"])) _c.call(_a);
+              } finally {
+                if (e_1) throw e_1.error;
+              }
+            }
+
+            return [4
+            /*yield*/
+            , Promise.allSettled(Array.from(this.jobs).map(function (j) {
+              return j.promise;
+            }))];
+
+          case 1:
+            results = _d.sent(); // At this point, we're already *not* accepting new work, and all
+            // pending work is done. It's safe to set state to `Closed`. Any
+            // process that's checking this property will be able to safely operate
+            // on this value at this point.
+
+            this._state = BackgroundProcessManagerState.Closed;
+            return [2
+            /*return*/
+            , results];
+        }
+      });
+    });
+  };
+
+  return BackgroundProcessManager;
+}();
+
+
+/**
+ * All possible states a `BackgroundProcessManager` instance can be in.
+ */
+
+var BackgroundProcessManagerState;
+
+(function (BackgroundProcessManagerState) {
+  /**
+   * Accepting new jobs.
+   */
+  BackgroundProcessManagerState["Open"] = "Open";
+  /**
+   * Not accepting new jobs. Waiting for submitted jobs to complete.
+   */
+
+  BackgroundProcessManagerState["Closing"] = "Closing";
+  /**
+   * Not accepting new jobs. All submitted jobs are complete.
+   */
+
+  BackgroundProcessManagerState["Closed"] = "Closed";
+})(BackgroundProcessManagerState || (BackgroundProcessManagerState = {}));
+
 /***/ }),
 
 /***/ "./lib-esm/Util/Constants.js":
@@ -35380,6 +35960,16 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "jitteredBackoff", function() { return jitteredBackoff; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "jitteredExponentialRetry", function() { return jitteredExponentialRetry; });
 /* harmony import */ var _Logger_ConsoleLogger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../Logger/ConsoleLogger */ "./lib-esm/Logger/ConsoleLogger.js");
+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);
+}
+
 var __extends = undefined && undefined.__extends || function () {
   var _extendStatics = function extendStatics(d, b) {
     _extendStatics = Object.setPrototypeOf || {
@@ -35614,80 +36204,142 @@ var isNonRetryableError = function isNonRetryableError(obj) {
  */
 
 
-function retry(functionToRetry, args, delayFn, attempt) {
-  if (attempt === void 0) {
-    attempt = 1;
-  }
-
+function retry(functionToRetry, args, delayFn, onTerminate) {
   return __awaiter(this, void 0, void 0, function () {
-    var err_1, retryIn_1;
+    var _this = this;
+
     return __generator(this, function (_a) {
-      switch (_a.label) {
-        case 0:
-          if (typeof functionToRetry !== 'function') {
-            throw Error('functionToRetry must be a function');
-          }
+      if (typeof functionToRetry !== 'function') {
+        throw Error('functionToRetry must be a function');
+      }
 
-          logger.debug(functionToRetry.name + " attempt #" + attempt + " with this vars: " + JSON.stringify(args));
-          _a.label = 1;
+      return [2
+      /*return*/
+      , new Promise(function (resolve, reject) {
+        return __awaiter(_this, void 0, void 0, function () {
+          var attempt, terminated, timeout, wakeUp, lastError, _loop_1, state_1;
 
-        case 1:
-          _a.trys.push([1, 3,, 8]);
+          return __generator(this, function (_a) {
+            switch (_a.label) {
+              case 0:
+                attempt = 0;
+                terminated = false;
 
-          return [4
-          /*yield*/
-          , functionToRetry.apply(void 0, __spread(args))];
+                wakeUp = function wakeUp() {};
 
-        case 2:
-          return [2
-          /*return*/
-          , _a.sent()];
+                onTerminate && onTerminate.then(function () {
+                  // signal not to try anymore.
+                  terminated = true; // stop sleeping if we're sleeping.
 
-        case 3:
-          err_1 = _a.sent();
-          logger.debug("error on " + functionToRetry.name, err_1);
+                  clearTimeout(timeout);
+                  wakeUp();
+                });
 
-          if (isNonRetryableError(err_1)) {
-            logger.debug(functionToRetry.name + " non retryable error", err_1);
-            throw err_1;
-          }
+                _loop_1 = function _loop_1() {
+                  var _a, _b, err_1, retryIn_1;
 
-          retryIn_1 = delayFn(attempt, args, err_1);
-          logger.debug(functionToRetry.name + " retrying in " + retryIn_1 + " ms");
-          if (!(retryIn_1 !== false)) return [3
-          /*break*/
-          , 6];
-          return [4
-          /*yield*/
-          , new Promise(function (res) {
-            return setTimeout(res, retryIn_1);
-          })];
+                  return __generator(this, function (_c) {
+                    switch (_c.label) {
+                      case 0:
+                        attempt++;
+                        logger.debug(functionToRetry.name + " attempt #" + attempt + " with this vars: " + JSON.stringify(args));
+                        _c.label = 1;
 
-        case 4:
-          _a.sent();
+                      case 1:
+                        _c.trys.push([1, 3,, 7]);
+
+                        _a = {};
+                        _b = resolve;
+                        return [4
+                        /*yield*/
+                        , functionToRetry.apply(void 0, __spread(args))];
+
+                      case 2:
+                        return [2
+                        /*return*/
+                        , (_a.value = _b.apply(void 0, [_c.sent()]), _a)];
+
+                      case 3:
+                        err_1 = _c.sent();
+                        lastError = err_1;
+                        logger.debug("error on " + functionToRetry.name, err_1);
+
+                        if (isNonRetryableError(err_1)) {
+                          logger.debug(functionToRetry.name + " non retryable error", err_1);
+                          return [2
+                          /*return*/
+                          , {
+                            value: reject(err_1)
+                          }];
+                        }
+
+                        retryIn_1 = delayFn(attempt, args, err_1);
+                        logger.debug(functionToRetry.name + " retrying in " + retryIn_1 + " ms");
+                        if (!(retryIn_1 === false || terminated)) return [3
+                        /*break*/
+                        , 4];
+                        return [2
+                        /*return*/
+                        , {
+                          value: reject(err_1)
+                        }];
 
-          return [4
-          /*yield*/
-          , retry(functionToRetry, args, delayFn, attempt + 1)];
+                      case 4:
+                        return [4
+                        /*yield*/
+                        , new Promise(function (r) {
+                          wakeUp = r; // export wakeUp for onTerminate handling
 
-        case 5:
-          return [2
-          /*return*/
-          , _a.sent()];
+                          timeout = setTimeout(wakeUp, retryIn_1);
+                        })];
 
-        case 6:
-          throw err_1;
+                      case 5:
+                        _c.sent();
 
-        case 7:
-          return [3
-          /*break*/
-          , 8];
+                        _c.label = 6;
 
-        case 8:
-          return [2
-          /*return*/
-          ];
-      }
+                      case 6:
+                        return [3
+                        /*break*/
+                        , 7];
+
+                      case 7:
+                        return [2
+                        /*return*/
+                        ];
+                    }
+                  });
+                };
+
+                _a.label = 1;
+
+              case 1:
+                if (!!terminated) return [3
+                /*break*/
+                , 3];
+                return [5
+                /*yield**/
+                , _loop_1()];
+
+              case 2:
+                state_1 = _a.sent();
+                if (_typeof(state_1) === "object") return [2
+                /*return*/
+                , state_1.value];
+                return [3
+                /*break*/
+                , 1];
+
+              case 3:
+                // reached if terminated while waiting for a timer.
+                reject(lastError);
+                return [2
+                /*return*/
+                ];
+            }
+          });
+        });
+      })];
     });
   });
 }
@@ -35714,12 +36366,12 @@ function jitteredBackoff(maxDelayMs) {
  * Internal use of Amplify only
  */
 
-var jitteredExponentialRetry = function jitteredExponentialRetry(functionToRetry, args, maxDelayMs) {
+var jitteredExponentialRetry = function jitteredExponentialRetry(functionToRetry, args, maxDelayMs, onTerminate) {
   if (maxDelayMs === void 0) {
     maxDelayMs = MAX_DELAY_MS;
   }
 
-  return retry(functionToRetry, args, jitteredBackoff(maxDelayMs));
+  return retry(functionToRetry, args, jitteredBackoff(maxDelayMs), onTerminate);
 };
 
 /***/ }),
@@ -35752,7 +36404,7 @@ function urlSafeDecode(hex) {
 /*!*******************************!*\
   !*** ./lib-esm/Util/index.js ***!
   \*******************************/
-/*! exports provided: NonRetryableError, retry, jitteredBackoff, jitteredExponentialRetry, Mutex, Reachability, DateUtils, urlSafeEncode, urlSafeDecode, AWS_CLOUDWATCH_BASE_BUFFER_SIZE, AWS_CLOUDWATCH_CATEGORY, AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE, AWS_CLOUDWATCH_MAX_EVENT_SIZE, AWS_CLOUDWATCH_PROVIDER_NAME, NO_CREDS_ERROR_STRING, RETRY_ERROR_CODES */
+/*! exports provided: NonRetryableError, retry, jitteredBackoff, jitteredExponentialRetry, Mutex, Reachability, DateUtils, urlSafeEncode, urlSafeDecode, AWS_CLOUDWATCH_BASE_BUFFER_SIZE, AWS_CLOUDWATCH_CATEGORY, AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE, AWS_CLOUDWATCH_MAX_EVENT_SIZE, AWS_CLOUDWATCH_PROVIDER_NAME, NO_CREDS_ERROR_STRING, RETRY_ERROR_CODES, BackgroundProcessManager, BackgroundProcessManagerState */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -35795,6 +36447,12 @@ __webpack_require__.r(__webpack_exports__);
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "RETRY_ERROR_CODES", function() { return _Constants__WEBPACK_IMPORTED_MODULE_5__["RETRY_ERROR_CODES"]; });
 
+/* harmony import */ var _BackgroundProcessManager__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./BackgroundProcessManager */ "./lib-esm/Util/BackgroundProcessManager.js");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "BackgroundProcessManager", function() { return _BackgroundProcessManager__WEBPACK_IMPORTED_MODULE_6__["BackgroundProcessManager"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "BackgroundProcessManagerState", function() { return _BackgroundProcessManager__WEBPACK_IMPORTED_MODULE_6__["BackgroundProcessManagerState"]; });
+
+
 
 
 
@@ -35848,7 +36506,7 @@ var USER_AGENT_HEADER = 'x-amz-user-agent';
 /*!**************************!*\
   !*** ./lib-esm/index.js ***!
   \**************************/
-/*! exports provided: AmplifyClass, ClientDevice, ConsoleLogger, Logger, missingConfig, invalidParameter, Hub, I18n, isEmpty, sortByField, objectLessAttributes, filenameToContentType, isTextFile, generateRandomString, makeQuerablePromise, isWebWorker, browserOrNode, transferKeyToLowerCase, transferKeyToUpperCase, isStrictObject, JS, Signer, parseMobileHubConfig, Parser, AWSCloudWatchProvider, FacebookOAuth, GoogleOAuth, Linking, AppState, AsyncStorage, Credentials, CredentialsClass, ServiceWorker, StorageHelper, MemoryStorage, UniversalStorage, Platform, getAmplifyUserAgent, INTERNAL_AWS_APPSYNC_PUBSUB_PROVIDER, INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER, USER_AGENT_HEADER, Constants, NonRetryableError, retry, jitteredBackoff, jitteredExponentialRetry, Mutex, Reachability, DateUtils, urlSafeEncode, urlSafeDecode, AWS_CLOUDWATCH_BASE_BUFFER_SIZE, AWS_CLOUDWATCH_CATEGORY, AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE, AWS_CLOUDWATCH_MAX_EVENT_SIZE, AWS_CLOUDWATCH_PROVIDER_NAME, NO_CREDS_ERROR_STRING, RETRY_ERROR_CODES, Amplify, default */
+/*! exports provided: AmplifyClass, ClientDevice, ConsoleLogger, Logger, missingConfig, invalidParameter, Hub, I18n, isEmpty, sortByField, objectLessAttributes, filenameToContentType, isTextFile, generateRandomString, makeQuerablePromise, isWebWorker, browserOrNode, transferKeyToLowerCase, transferKeyToUpperCase, isStrictObject, JS, Signer, parseMobileHubConfig, Parser, AWSCloudWatchProvider, FacebookOAuth, GoogleOAuth, Linking, AppState, AsyncStorage, Credentials, CredentialsClass, ServiceWorker, StorageHelper, MemoryStorage, UniversalStorage, Platform, getAmplifyUserAgent, INTERNAL_AWS_APPSYNC_PUBSUB_PROVIDER, INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER, USER_AGENT_HEADER, Constants, NonRetryableError, retry, jitteredBackoff, jitteredExponentialRetry, Mutex, Reachability, DateUtils, urlSafeEncode, urlSafeDecode, AWS_CLOUDWATCH_BASE_BUFFER_SIZE, AWS_CLOUDWATCH_CATEGORY, AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE, AWS_CLOUDWATCH_MAX_EVENT_SIZE, AWS_CLOUDWATCH_PROVIDER_NAME, NO_CREDS_ERROR_STRING, RETRY_ERROR_CODES, BackgroundProcessManager, BackgroundProcessManagerState, Amplify, default */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -35989,6 +36647,10 @@ __webpack_require__.r(__webpack_exports__);
 
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "RETRY_ERROR_CODES", function() { return _Util__WEBPACK_IMPORTED_MODULE_18__["RETRY_ERROR_CODES"]; });
 
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "BackgroundProcessManager", function() { return _Util__WEBPACK_IMPORTED_MODULE_18__["BackgroundProcessManager"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "BackgroundProcessManagerState", function() { return _Util__WEBPACK_IMPORTED_MODULE_18__["BackgroundProcessManagerState"]; });
+
 /*
  * Copyright 2017-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *