@instructure/quiz-core 22.14.1 → 22.15.1

package/es/common/util/Fetcher.js

@@ -1,10 +1,170 @@
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 import { decamelizeKeys } from 'humps';
 import queryString from 'query-string';
 import fetch from 'isomorphic-fetch';
@@ -15,362 +175,348 @@ import store from '../../reduxStore';
 import { callbacksCompleteForCall, errorCallFor, startCallFor, successCallFor } from './callHelpers';
 import { addError, addSuccess } from '../actions/alerts';
 import { HTTP_STATUS_CODE_UNAUTHORIZED } from '@instructure/quiz-common';
-
 /*
 Note that this error extends the Error prototype in the old way because babel doesn't support extending from built-in
 classes using the ES6 class syntax. Follows pattern from here:
 https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Custom_Error_Types
-*/
-function FetcherError(response) {
-  this.message = response.statusText;
-  this.response = response;
+*/ function FetcherError(response) {
+    this.message = response.statusText;
+    this.response = response;
 }
 FetcherError.prototype = Object.create(Error.prototype);
 FetcherError.prototype.constructor = FetcherError;
-export var Fetcher = /*#__PURE__*/function () {
-  function Fetcher() {
-    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-      callType = _ref.callType,
-      headers = _ref.headers,
-      successMessage = _ref.successMessage,
-      onError = _ref.onError,
-      cloneResponseForError = _ref.cloneResponseForError,
-      asyncResponseHandler = _ref.asyncResponseHandler,
-      injectMissingUserToken = _ref.injectMissingUserToken;
-    _classCallCheck(this, Fetcher);
-    // A Response body can only be read once, and is read in the onError handler
-    // When cloneResponseForError is true, the response is cloned so that the
-    // body can be consumed again from the error thrown by Fetcher
-    this.cloneResponseForError = cloneResponseForError || false;
-    this.callType = callType;
-    this.headers = headers;
-    this.injectMissingUserToken = injectMissingUserToken || false;
-    this.successMessage = successMessage;
-    this.onError = onError;
-    this.asyncResponseHandler = asyncResponseHandler || jsonify;
-  }
-  return _createClass(Fetcher, [{
-    key: "markCallbacksComplete",
-    value: function markCallbacksComplete() {
-      if (this.callType) {
-        this.dispatch(callbacksCompleteForCall(this.callType));
-      }
-    }
-  }, {
-    key: "getFetchLib",
-    value: function getFetchLib() {
-      if (Fetcher.usingFakes) {
-        return Fetcher.fakeFetch;
-      }
-      if (window.fetch) {
-        return window.fetch;
-      }
-      console.warn('Relying on isomorphic-fetch is deprecated and will be removed in a future release. Please use a fetch polyfill instead (i.e. whatwg-fetch).');
-      return fetch;
-    }
-  }, {
-    key: "dispatch",
-    value: function dispatch(args) {
-      if (Fetcher.usingFakes) {
-        Fetcher.fakeDispatch(args);
-      } else {
-        store.dispatch(args);
-      }
-    }
-  }, {
-    key: "getState",
-    value: function getState() {
-      return Fetcher.usingFakes ? Fetcher.fakeGetState() : store.getAppState();
+export var Fetcher = /*#__PURE__*/ function() {
+    "use strict";
+    function Fetcher() {
+        var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, callType = _ref.callType, headers = _ref.headers, successMessage = _ref.successMessage, onError = _ref.onError, cloneResponseForError = _ref.cloneResponseForError, asyncResponseHandler = _ref.asyncResponseHandler, injectMissingUserToken = _ref.injectMissingUserToken;
+        _class_call_check(this, Fetcher);
+        // A Response body can only be read once, and is read in the onError handler
+        // When cloneResponseForError is true, the response is cloned so that the
+        // body can be consumed again from the error thrown by Fetcher
+        this.cloneResponseForError = cloneResponseForError || false;
+        this.callType = callType;
+        this.headers = headers;
+        this.injectMissingUserToken = injectMissingUserToken || false;
+        this.successMessage = successMessage;
+        this.onError = onError;
+        this.asyncResponseHandler = asyncResponseHandler || jsonify;
     }
-  }, {
-    key: "endpoint",
-    value: function endpoint() {
-      return this.getState().getIn(['config', 'apiEndpoint']) || '';
-    }
-  }, {
-    key: "callHeaders",
-    value: function callHeaders() {
-      if (!this.headers) {
-        return httpHeaders(this.getState().getIn(['config', 'userToken']));
-      }
-      if (!this.injectMissingUserToken) {
-        return this.headers;
-      }
-      var userToken = this.getState().getIn(['config', 'userToken']);
-      return _objectSpread(_objectSpread({}, jwtHeader(userToken)), this.headers);
-    }
-  }, {
-    key: "handleSuccess",
-    value: function handleSuccess(response) {
-      if (this.successMessage) {
-        this.dispatch(addSuccess(this.successMessage));
-      }
-      if (this.callType) {
-        this.dispatch(successCallFor(this.callType));
-      }
-      return Promise.resolve(response);
-    }
-  }, {
-    key: "handleError",
-    value: function handleError(error, friendlyMessage) {
-      var errorToReturn = this.cloneResponseForError ? new FetcherError(error.response.clone()) : error;
-      if (this.onError) {
-        // Custom error handler
-        var errorAction = this.onError(error);
-        if (errorAction) {
-          this.dispatch(errorAction);
+    _create_class(Fetcher, [
+        {
+            key: "markCallbacksComplete",
+            value: function markCallbacksComplete() {
+                if (this.callType) {
+                    this.dispatch(callbacksCompleteForCall(this.callType));
+                }
+            }
+        },
+        {
+            key: "getFetchLib",
+            value: function getFetchLib() {
+                if (Fetcher.usingFakes) {
+                    return Fetcher.fakeFetch;
+                }
+                if (window.fetch) {
+                    return window.fetch;
+                }
+                console.warn('Relying on isomorphic-fetch is deprecated and will be removed in a future release. Please use a fetch polyfill instead (i.e. whatwg-fetch).');
+                return fetch;
+            }
+        },
+        {
+            key: "dispatch",
+            value: function dispatch(args) {
+                if (Fetcher.usingFakes) {
+                    Fetcher.fakeDispatch(args);
+                } else {
+                    store.dispatch(args);
+                }
+            }
+        },
+        {
+            key: "getState",
+            value: function getState() {
+                return Fetcher.usingFakes ? Fetcher.fakeGetState() : store.getAppState();
+            }
+        },
+        {
+            key: "endpoint",
+            value: function endpoint() {
+                return this.getState().getIn([
+                    'config',
+                    'apiEndpoint'
+                ]) || '';
+            }
+        },
+        {
+            key: "callHeaders",
+            value: function callHeaders() {
+                if (!this.headers) {
+                    return httpHeaders(this.getState().getIn([
+                        'config',
+                        'userToken'
+                    ]));
+                }
+                if (!this.injectMissingUserToken) {
+                    return this.headers;
+                }
+                var userToken = this.getState().getIn([
+                    'config',
+                    'userToken'
+                ]);
+                return _object_spread({}, jwtHeader(userToken), this.headers);
+            }
+        },
+        {
+            key: "handleSuccess",
+            value: function handleSuccess(response) {
+                if (this.successMessage) {
+                    this.dispatch(addSuccess(this.successMessage));
+                }
+                if (this.callType) {
+                    this.dispatch(successCallFor(this.callType));
+                }
+                return Promise.resolve(response);
+            }
+        },
+        {
+            key: "handleError",
+            value: function handleError(error, friendlyMessage) {
+                var errorToReturn = this.cloneResponseForError ? new FetcherError(error.response.clone()) : error;
+                if (this.onError) {
+                    // Custom error handler
+                    var errorAction = this.onError(error);
+                    if (errorAction) {
+                        this.dispatch(errorAction);
+                    }
+                } else if (friendlyMessage) {
+                    this.dispatch(addError(friendlyMessage));
+                }
+                if (this.callType) {
+                    this.dispatch(errorCallFor(this.callType));
+                }
+                return Promise.reject(errorToReturn);
+            }
+        },
+        {
+            key: "handleResponse",
+            value: function handleResponse(response) {
+                return _async_to_generator(function() {
+                    var isSuccessful, friendlyMessage;
+                    return _ts_generator(this, function(_state) {
+                        isSuccessful = response && response.status >= 200 && response.status < 300;
+                        if (isSuccessful) return [
+                            2,
+                            this.handleSuccess(response)
+                        ];
+                        if (response.status === HTTP_STATUS_CODE_UNAUTHORIZED) {
+                            friendlyMessage = t('Sorry, the request was unauthorized.');
+                        } else {
+                            friendlyMessage = t('Sorry, there was a {status} Error.', {
+                                status: response.status
+                            });
+                        }
+                        return [
+                            2,
+                            this.handleError(new FetcherError(response), friendlyMessage)
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "appendQueryParams",
+            value: function appendQueryParams(url) {
+                var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+                if (!Object.keys(params).length) return url;
+                return "".concat(url, "?").concat(queryString.stringify(decamelizeKeys(params), {
+                    arrayFormat: 'bracket'
+                }));
+            }
+        },
+        {
+            key: "get",
+            value: function get(_0) {
+                return _async_to_generator(function(url) {
+                    var _this, additionalParams, params;
+                    var _arguments = arguments;
+                    return _ts_generator(this, function(_state) {
+                        _this = this;
+                        additionalParams = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+                        params = {
+                            method: 'GET',
+                            headers: this.callHeaders()
+                        };
+                        return [
+                            2,
+                            this.fetch(this.appendQueryParams(url, additionalParams), params).then(function(response) {
+                                return _this.asyncResponseHandler(response, Object.assign(params, additionalParams));
+                            })
+                        ];
+                    });
+                }).apply(this, arguments);
+            }
+        },
+        {
+            key: "post",
+            value: function post(_0) {
+                return _async_to_generator(function(url) {
+                    var _this, additionalParams, params;
+                    var _arguments = arguments;
+                    return _ts_generator(this, function(_state) {
+                        _this = this;
+                        additionalParams = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+                        params = Object.assign({
+                            method: 'POST',
+                            headers: this.callHeaders()
+                        }, additionalParams);
+                        return [
+                            2,
+                            this.fetch(url, params).then(function(response) {
+                                return _this.asyncResponseHandler(response, params);
+                            })
+                        ];
+                    });
+                }).apply(this, arguments);
+            }
+        },
+        {
+            key: "patch",
+            value: function patch(_0) {
+                return _async_to_generator(function(url) {
+                    var _this, additionalParams, params;
+                    var _arguments = arguments;
+                    return _ts_generator(this, function(_state) {
+                        _this = this;
+                        additionalParams = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+                        params = Object.assign({
+                            method: 'PATCH',
+                            headers: this.callHeaders()
+                        }, additionalParams);
+                        return [
+                            2,
+                            this.fetch(url, params).then(function(response) {
+                                return _this.asyncResponseHandler(response, params);
+                            })
+                        ];
+                    });
+                }).apply(this, arguments);
+            }
+        },
+        {
+            key: "put",
+            value: function put(_0) {
+                return _async_to_generator(function(url) {
+                    var _this, additionalParams, params;
+                    var _arguments = arguments;
+                    return _ts_generator(this, function(_state) {
+                        _this = this;
+                        additionalParams = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+                        params = Object.assign({
+                            method: 'PUT',
+                            headers: this.callHeaders()
+                        }, additionalParams);
+                        return [
+                            2,
+                            this.fetch(url, params).then(function(response) {
+                                return _this.asyncResponseHandler(response, params);
+                            })
+                        ];
+                    });
+                }).apply(this, arguments);
+            }
+        },
+        {
+            key: "delete",
+            value: function _delete(_0) {
+                return _async_to_generator(function(url) {
+                    var additionalParams, params;
+                    var _arguments = arguments;
+                    return _ts_generator(this, function(_state) {
+                        additionalParams = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+                        params = Object.assign({
+                            method: 'DELETE',
+                            headers: this.callHeaders()
+                        }, additionalParams);
+                        return [
+                            2,
+                            this.fetch(url, params)
+                        ];
+                    });
+                }).apply(this, arguments);
+            }
+        },
+        {
+            key: "fetch",
+            value: function fetch(url, params) {
+                return _async_to_generator(function() {
+                    var fetchLib, response, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                fetchLib = this.getFetchLib();
+                                if (this.callType) {
+                                    this.dispatch(startCallFor(this.callType));
+                                }
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    6,
+                                    ,
+                                    7
+                                ]);
+                                if (!/^https?:\/\//.test(url)) return [
+                                    3,
+                                    3
+                                ];
+                                return [
+                                    4,
+                                    fetchLib(url, params)
+                                ];
+                            case 2:
+                                response = _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 3:
+                                return [
+                                    4,
+                                    fetchLib(this.endpoint() + url, params)
+                                ];
+                            case 4:
+                                response = _state.sent();
+                                _state.label = 5;
+                            case 5:
+                                return [
+                                    3,
+                                    7
+                                ];
+                            case 6:
+                                error = _state.sent();
+                                return [
+                                    2,
+                                    this.handleError(error, error.message)
+                                ];
+                            case 7:
+                                return [
+                                    2,
+                                    this.handleResponse(response)
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
         }
-      } else if (friendlyMessage) {
-        this.dispatch(addError(friendlyMessage));
-      }
-      if (this.callType) {
-        this.dispatch(errorCallFor(this.callType));
-      }
-      return Promise.reject(errorToReturn);
-    }
-  }, {
-    key: "handleResponse",
-    value: function () {
-      var _handleResponse = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(response) {
-        var isSuccessful, friendlyMessage;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              isSuccessful = response && response.status >= 200 && response.status < 300;
-              if (!isSuccessful) {
-                _context.next = 3;
-                break;
-              }
-              return _context.abrupt("return", this.handleSuccess(response));
-            case 3:
-              if (response.status === HTTP_STATUS_CODE_UNAUTHORIZED) {
-                friendlyMessage = t('Sorry, the request was unauthorized.');
-              } else {
-                friendlyMessage = t('Sorry, there was a {status} Error.', {
-                  status: response.status
-                });
-              }
-              return _context.abrupt("return", this.handleError(new FetcherError(response), friendlyMessage));
-            case 5:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function handleResponse(_x) {
-        return _handleResponse.apply(this, arguments);
-      }
-      return handleResponse;
-    }()
-  }, {
-    key: "appendQueryParams",
-    value: function appendQueryParams(url) {
-      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      if (!Object.keys(params).length) return url;
-      return "".concat(url, "?").concat(queryString.stringify(decamelizeKeys(params), {
-        arrayFormat: 'bracket'
-      }));
-    }
-  }, {
-    key: "get",
-    value: function () {
-      var _get = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(url) {
-        var _this = this;
-        var additionalParams,
-          params,
-          _args2 = arguments;
-        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              additionalParams = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
-              params = {
-                method: 'GET',
-                headers: this.callHeaders()
-              };
-              return _context2.abrupt("return", this.fetch(this.appendQueryParams(url, additionalParams), params).then(function (response) {
-                return _this.asyncResponseHandler(response, Object.assign(params, additionalParams));
-              }));
-            case 3:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function get(_x2) {
-        return _get.apply(this, arguments);
-      }
-      return get;
-    }()
-  }, {
-    key: "post",
-    value: function () {
-      var _post = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(url) {
-        var _this2 = this;
-        var additionalParams,
-          params,
-          _args3 = arguments;
-        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              additionalParams = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : {};
-              params = Object.assign({
-                method: 'POST',
-                headers: this.callHeaders()
-              }, additionalParams);
-              return _context3.abrupt("return", this.fetch(url, params).then(function (response) {
-                return _this2.asyncResponseHandler(response, params);
-              }));
-            case 3:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this);
-      }));
-      function post(_x3) {
-        return _post.apply(this, arguments);
-      }
-      return post;
-    }()
-  }, {
-    key: "patch",
-    value: function () {
-      var _patch = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(url) {
-        var _this3 = this;
-        var additionalParams,
-          params,
-          _args4 = arguments;
-        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              additionalParams = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : {};
-              params = Object.assign({
-                method: 'PATCH',
-                headers: this.callHeaders()
-              }, additionalParams);
-              return _context4.abrupt("return", this.fetch(url, params).then(function (response) {
-                return _this3.asyncResponseHandler(response, params);
-              }));
-            case 3:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4, this);
-      }));
-      function patch(_x4) {
-        return _patch.apply(this, arguments);
-      }
-      return patch;
-    }()
-  }, {
-    key: "put",
-    value: function () {
-      var _put = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(url) {
-        var _this4 = this;
-        var additionalParams,
-          params,
-          _args5 = arguments;
-        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
-            case 0:
-              additionalParams = _args5.length > 1 && _args5[1] !== undefined ? _args5[1] : {};
-              params = Object.assign({
-                method: 'PUT',
-                headers: this.callHeaders()
-              }, additionalParams);
-              return _context5.abrupt("return", this.fetch(url, params).then(function (response) {
-                return _this4.asyncResponseHandler(response, params);
-              }));
-            case 3:
-            case "end":
-              return _context5.stop();
-          }
-        }, _callee5, this);
-      }));
-      function put(_x5) {
-        return _put.apply(this, arguments);
-      }
-      return put;
-    }()
-  }, {
-    key: "delete",
-    value: function () {
-      var _delete2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6(url) {
-        var additionalParams,
-          params,
-          _args6 = arguments;
-        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
-            case 0:
-              additionalParams = _args6.length > 1 && _args6[1] !== undefined ? _args6[1] : {};
-              params = Object.assign({
-                method: 'DELETE',
-                headers: this.callHeaders()
-              }, additionalParams);
-              return _context6.abrupt("return", this.fetch(url, params));
-            case 3:
-            case "end":
-              return _context6.stop();
-          }
-        }, _callee6, this);
-      }));
-      function _delete(_x6) {
-        return _delete2.apply(this, arguments);
-      }
-      return _delete;
-    }()
-  }, {
-    key: "fetch",
-    value: function () {
-      var _fetch = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7(url, params) {
-        var fetchLib, response;
-        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
-          while (1) switch (_context7.prev = _context7.next) {
-            case 0:
-              fetchLib = this.getFetchLib();
-              if (this.callType) {
-                this.dispatch(startCallFor(this.callType));
-              }
-              _context7.prev = 2;
-              if (!/^https?:\/\//.test(url)) {
-                _context7.next = 9;
-                break;
-              }
-              _context7.next = 6;
-              return fetchLib(url, params);
-            case 6:
-              response = _context7.sent;
-              _context7.next = 12;
-              break;
-            case 9:
-              _context7.next = 11;
-              return fetchLib(this.endpoint() + url, params);
-            case 11:
-              response = _context7.sent;
-            case 12:
-              _context7.next = 17;
-              break;
-            case 14:
-              _context7.prev = 14;
-              _context7.t0 = _context7["catch"](2);
-              return _context7.abrupt("return", this.handleError(_context7.t0, _context7.t0.message));
-            case 17:
-              return _context7.abrupt("return", this.handleResponse(response));
-            case 18:
-            case "end":
-              return _context7.stop();
-          }
-        }, _callee7, this, [[2, 14]]);
-      }));
-      function fetch(_x7, _x8) {
-        return _fetch.apply(this, arguments);
-      }
-      return fetch;
-    }()
-  }], [{
-    key: "useFakes",
-    value: function useFakes(useFake) {
-      Fetcher.usingFakes = useFake;
-    }
-  }]);
+    ], [
+        {
+            key: "useFakes",
+            value: function useFakes(useFake) {
+                Fetcher.usingFakes = useFake;
+            }
+        }
+    ]);
+    return Fetcher;
 }();
-export default Fetcher;
+export default Fetcher;