@bigbinary/neeto-media-recorder 1.1.4 → 1.2.1

package/core.js

@@ -522,6 +522,113 @@ try {
 
 var _regeneratorRuntime = /*@__PURE__*/getDefaultExportFromCjs(regenerator);
 
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof$1(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized(self);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _isNativeReflectConstruct$1() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct$1()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+  return _wrapNativeSuper(Class);
+}
+
 var TOTAL_RETRIES = 30;
 var INITIAL_RETRY_DELAY = 4000;
 var MAX_RETRY_DELAY = 16000;
@@ -545,6 +652,17 @@ var sleep = function sleep(delay) {
   });
 };
 
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+var RetryError = /*#__PURE__*/function (_Error) {
+  _inherits(RetryError, _Error);
+  var _super = _createSuper(RetryError);
+  function RetryError(message) {
+    _classCallCheck(this, RetryError);
+    return _super.call(this, message);
+  }
+  return _createClass(RetryError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
 var buildRetryableApi = function buildRetryableApi(apiConnector) {
   var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_RETRY_CONFIG,
     _ref$retries = _ref.retries,
@@ -554,48 +672,54 @@ var buildRetryableApi = function buildRetryableApi(apiConnector) {
     retryableStatuses = _ref.retryableStatuses;
   return /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(apiConnectorArgs) {
-      var remainingAttempts, _error$response, isRetryableStatus, isRetryableError;
+      var _config$signal;
+      var _apiConnectorArgs$con, config, remainingAttempts, shouldCancelRetries, _error$response, isRetryableStatus, isRetryableError;
       return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
+            _apiConnectorArgs$con = apiConnectorArgs.config, config = _apiConnectorArgs$con === void 0 ? null : _apiConnectorArgs$con;
             remainingAttempts = retries + 1;
-          case 1:
-            if (!remainingAttempts--) {
-              _context.next = 21;
+            shouldCancelRetries = false;
+            config === null || config === void 0 ? void 0 : (_config$signal = config.signal) === null || _config$signal === void 0 ? void 0 : _config$signal.addEventListener("abort", function () {
+              shouldCancelRetries = true;
+            });
+          case 4:
+            if (!(remainingAttempts-- && !shouldCancelRetries)) {
+              _context.next = 24;
               break;
             }
-            _context.prev = 2;
-            _context.next = 5;
+            _context.prev = 5;
+            _context.next = 8;
             return apiConnector(apiConnectorArgs);
-          case 5:
-            return _context.abrupt("return", _context.sent);
           case 8:
-            _context.prev = 8;
-            _context.t0 = _context["catch"](2);
+            return _context.abrupt("return", _context.sent);
+          case 11:
+            _context.prev = 11;
+            _context.t0 = _context["catch"](5);
             isRetryableStatus = isPresent(retryableStatuses) && retryableStatuses.includes((_error$response = _context.t0.response) === null || _error$response === void 0 ? void 0 : _error$response.status);
             isRetryableError = isRetryableStatus || _context.t0.message === NETWORK_ERROR || _context.t0.code === TIMEOUT_ERROR;
             if (!(isRetryableError && remainingAttempts > 0)) {
-              _context.next = 18;
+              _context.next = 21;
               break;
             }
-            _context.next = 15;
+            _context.next = 18;
             return sleep(retryDelay);
-          case 15:
-            retryDelay = min(retryDelay * 2, MAX_RETRY_DELAY);
-            _context.next = 19;
-            break;
           case 18:
-            throw _context.t0;
-          case 19:
-            _context.next = 1;
+            retryDelay = min(retryDelay * 2, MAX_RETRY_DELAY);
+            _context.next = 22;
             break;
           case 21:
-            return _context.abrupt("return", null);
+            throw _context.t0;
           case 22:
+            _context.next = 4;
+            break;
+          case 24:
+            throw new RetryError("Request cancelled or request retries exhausted");
+          case 25:
           case "end":
             return _context.stop();
         }
-      }, _callee, null, [[2, 8]]);
+      }, _callee, null, [[5, 11]]);
     }));
     return function (_x) {
       return _ref2.apply(this, arguments);
@@ -617,10 +741,11 @@ var abortUploadApi = {
 
 var create$1 = function create(_ref) {
   var recordingId = _ref.recordingId,
-    payload = _ref.payload;
+    payload = _ref.payload,
+    config = _ref.config;
   return axios.post("/api/v1/recordings/".concat(recordingId, "/complete_upload"), {
     completeUpload: payload
-  });
+  }, config);
 };
 var retryableCreate$1 = buildRetryableApi(create$1);
 var completeUploadApi = {
@@ -629,10 +754,11 @@ var completeUploadApi = {
 
 var create = function create(_ref) {
   var recordingId = _ref.recordingId,
-    payload = _ref.payload;
+    payload = _ref.payload,
+    config = _ref.config;
   return axios.post("/api/v1/recordings/".concat(recordingId, "/part_presigned_url"), {
     partPresignedUrl: payload
-  });
+  }, config);
 };
 var retryableCreate = buildRetryableApi(create);
 var partPresignedUrlApi = {
@@ -668,6 +794,14 @@ var prepareStore$1 = function prepareStore() {
   }));
 };
 
+/**
+ * Due to the custom axios interceptor for s3Api,
+ * it'll return false for cancelled requests instead of a cancelled error object.
+ */
+var isNotCancelledRequest = function isNotCancelledRequest(resolvedResponse) {
+  return typeof resolvedResponse !== "boolean";
+};
+
 function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$2(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 function _classPrivateFieldInitSpec$1(obj, privateMap, value) { _checkPrivateRedeclaration$1(obj, privateMap); privateMap.set(obj, value); }
@@ -783,7 +917,7 @@ var MultipartS3Uploader = /*#__PURE__*/function () {
             return Promise.all(_classPrivateFieldGet(_this, _s3PartUploadPromises));
           case 9:
             resolvedS3PartUploadPromises = _context.sent;
-            parts = resolvedS3PartUploadPromises.map(function (resolvedResponse) {
+            parts = resolvedS3PartUploadPromises.filter(isNotCancelledRequest).map(function (resolvedResponse) {
               return {
                 etag: resolvedResponse.headers.etag,
                 partNumber: new URL(resolvedResponse.request.responseURL).searchParams.get("partNumber")
@@ -797,6 +931,9 @@ var MultipartS3Uploader = /*#__PURE__*/function () {
               payload: {
                 parts: parts,
                 uploadId: _classPrivateFieldGet(_this, _uploadId)
+              },
+              config: {
+                signal: _classPrivateFieldGet(_this, _abortController).signal
               }
             });
           case 13:
@@ -908,6 +1045,9 @@ var MultipartS3Uploader = /*#__PURE__*/function () {
                   payload: {
                     partNumber: (_classPrivateFieldSet(_this, _partNumber, (_this$partNumber = _classPrivateFieldGet(_this, _partNumber), _this$partNumber2 = _this$partNumber++, _this$partNumber)), _this$partNumber2),
                     uploadId: _classPrivateFieldGet(_this, _uploadId)
+                  },
+                  config: {
+                    signal: _classPrivateFieldGet(_this, _abortController).signal
                   }
                 });
               case 4: