@jetbrains/ring-ui-built 7.0.0-beta.2 → 7.0.0-beta.3

package/components/heading/heading.js

@@ -1,4 +1,4 @@
-import { d as _objectSpread2, c as _objectWithoutProperties } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { b as _objectSpread2, a as _objectWithoutProperties } from '../_helpers/_rollupPluginBabelHelpers.js';
 import { memo } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
@@ -6,7 +6,7 @@ import deprecate from 'util-deprecate';
 import { m as modules_901b77ec } from '../_helpers/heading.js';
 import { jsx } from 'react/jsx-runtime';
 
-var _excluded = ["children", "className", "level"],
+const _excluded = ["children", "className", "level"],
   _excluded2 = ["className", "bold"];
 var Levels;
 (function (Levels) {
@@ -15,49 +15,50 @@ var Levels;
   Levels[Levels["H3"] = 3] = "H3";
   Levels[Levels["H4"] = 4] = "H4";
 })(Levels || (Levels = {}));
-var fallbackHeading = deprecate(function () {
-  return 'h3';
-}, 'Headings of level 5 and higher are replaced with h3');
-var HeadingMemo = /*#__PURE__*/memo(function Heading(_ref) {
-  var children = _ref.children,
-    className = _ref.className,
-    _ref$level = _ref.level,
-    level = _ref$level === void 0 ? Levels.H1 : _ref$level,
+const fallbackHeading = deprecate(() => 'h3', 'Headings of level 5 and higher are replaced with h3');
+const HeadingMemo = /*#__PURE__*/memo(function Heading(_ref) {
+  let {
+      children,
+      className,
+      level = Levels.H1
+    } = _ref,
     restProps = _objectWithoutProperties(_ref, _excluded);
-  var classes = classNames(modules_901b77ec.heading, className);
-  var Tag = level <= Levels.H4 ? "h".concat(level) : fallbackHeading();
+  const classes = classNames(modules_901b77ec.heading, className);
+  const Tag = level <= Levels.H4 ? "h".concat(level) : fallbackHeading();
   return /*#__PURE__*/jsx(Tag, _objectSpread2(_objectSpread2({}, restProps), {}, {
     className: classes,
     children: children
   }));
 });
-var Heading = HeadingMemo;
+const Heading = HeadingMemo;
 Heading.propTypes = {
   children: PropTypes.node,
   className: PropTypes.string,
   level: PropTypes.oneOf([Levels.H1, Levels.H2, Levels.H3, Levels.H4])
 };
 Heading.Levels = Levels;
-var H1 = /*#__PURE__*/memo(function H1(props) {
+const H1 = /*#__PURE__*/memo(function H1(props) {
   return /*#__PURE__*/jsx(Heading, _objectSpread2(_objectSpread2({}, props), {}, {
     level: Levels.H1
   }));
 });
-var H2 = /*#__PURE__*/memo(function H2(props) {
+const H2 = /*#__PURE__*/memo(function H2(props) {
   return /*#__PURE__*/jsx(Heading, _objectSpread2(_objectSpread2({}, props), {}, {
     level: Levels.H2
   }));
 });
-var H3 = /*#__PURE__*/memo(function H3(props) {
+const H3 = /*#__PURE__*/memo(function H3(props) {
   return /*#__PURE__*/jsx(Heading, _objectSpread2(_objectSpread2({}, props), {}, {
     level: Levels.H3
   }));
 });
-var H4 = /*#__PURE__*/memo(function H4(_ref2) {
-  var className = _ref2.className,
-    bold = _ref2.bold,
+const H4 = /*#__PURE__*/memo(function H4(_ref2) {
+  let {
+      className,
+      bold
+    } = _ref2,
     restProps = _objectWithoutProperties(_ref2, _excluded2);
-  var classes = classNames(className, {
+  const classes = classNames(className, {
     [modules_901b77ec.bold]: bold
   });
   return /*#__PURE__*/jsx(Heading, _objectSpread2(_objectSpread2({}, restProps), {}, {

package/components/http/http.js

@@ -1,376 +1,219 @@
-import { a as _inherits, b as _createClass, c as _objectWithoutProperties, d as _objectSpread2, i as _slicedToArray, e as _classCallCheck, f as _callSuper, _ as _defineProperty, g as _asyncToGenerator, h as _regeneratorRuntime } from '../_helpers/_rollupPluginBabelHelpers.js';
-import 'core-js/modules/es.array.concat.js';
-import 'core-js/modules/es.array.index-of.js';
-import 'core-js/modules/es.array.iterator.js';
-import 'core-js/modules/es.object.entries.js';
-import 'core-js/modules/es.object.to-string.js';
-import 'core-js/modules/es.promise.js';
-import 'core-js/modules/es.reflect.delete-property.js';
-import 'core-js/modules/es.weak-map.js';
-import 'core-js/modules/web.dom-collections.for-each.js';
+import { _ as _defineProperty, a as _objectWithoutProperties, b as _objectSpread2 } from '../_helpers/_rollupPluginBabelHelpers.js';
 import 'core-js/modules/web.dom-collections.iterator.js';
 import ExtendableError from 'es6-error';
 import { encodeURL, joinBaseURLAndPath } from '../global/url.js';
 import 'core-js/modules/es.regexp.exec.js';
-import 'core-js/modules/es.string.match.js';
 import 'core-js/modules/es.string.replace.js';
 
-var _excluded = ["body", "query"],
+const _excluded = ["body", "query"],
   _excluded2 = ["headers"],
   _excluded3 = ["headers", "body", "query", "sendRawBody"];
 /**
  * @name HTTP
  */
-var TOKEN_TYPE = 'Bearer';
-var defaultFetchConfig = {
+const TOKEN_TYPE = 'Bearer';
+const defaultFetchConfig = {
   headers: {
     'Content-Type': 'application/json',
     Accept: 'application/json'
   },
   credentials: 'same-origin'
 };
-var HTTPError = /*#__PURE__*/function (_ExtendableError) {
-  function HTTPError(response) {
-    var _this;
-    var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    _classCallCheck(this, HTTPError);
-    _this = _callSuper(this, HTTPError, ["".concat(response.status, " ").concat(response.statusText || '')]);
-    _defineProperty(_this, "data", void 0);
-    _defineProperty(_this, "status", void 0);
-    _this.data = data;
-    _this.status = response.status;
-    return _this;
+class HTTPError extends ExtendableError {
+  constructor(response) {
+    let data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super("".concat(response.status, " ").concat(response.statusText || ''));
+    _defineProperty(this, "data", void 0);
+    _defineProperty(this, "status", void 0);
+    this.data = data;
+    this.status = response.status;
   }
-  _inherits(HTTPError, _ExtendableError);
-  return _createClass(HTTPError);
-}(ExtendableError);
-var CODE = {
+}
+const CODE = {
   UNAUTHORIZED: 401
 };
 function isRawBody(params) {
   return params.sendRawBody === true;
 }
-var HTTP = /*#__PURE__*/function () {
-  function HTTP(_auth, _baseUrl) {
-    var _this2 = this;
-    var _fetchConfig = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    _classCallCheck(this, HTTP);
+class HTTP {
+  constructor(_auth, _baseUrl) {
+    var _this = this;
+    let _fetchConfig = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
     _defineProperty(this, "baseUrl", null);
     _defineProperty(this, "_requestsMeta", new WeakMap());
     _defineProperty(this, "fetchConfig", void 0);
     _defineProperty(this, "requestToken", void 0);
     _defineProperty(this, "shouldRefreshToken", void 0);
     _defineProperty(this, "forceTokenUpdate", void 0);
-    _defineProperty(this, "setAuth", function (auth) {
-      _this2.requestToken = function () {
-        return auth.requestToken();
-      };
-      _this2.shouldRefreshToken = auth.constructor.shouldRefreshToken;
-      _this2.forceTokenUpdate = function () {
-        return auth.forceTokenUpdate();
-      };
+    _defineProperty(this, "setAuth", auth => {
+      this.requestToken = () => auth.requestToken();
+      this.shouldRefreshToken = auth.constructor.shouldRefreshToken;
+      this.forceTokenUpdate = () => auth.forceTokenUpdate();
     });
-    _defineProperty(this, "setBaseUrl", function (baseUrl) {
-      _this2.baseUrl = baseUrl;
+    _defineProperty(this, "setBaseUrl", baseUrl => {
+      this.baseUrl = baseUrl;
     });
-    _defineProperty(this, "fetch", /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(url) {
-        var params,
+    _defineProperty(this, "fetch", async function (url) {
+      let params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      const {
           body,
-          _params$query,
-          query,
-          fetchConfig,
-          response,
-          _args = arguments;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              params = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
-              body = params.body, _params$query = params.query, query = _params$query === void 0 ? {} : _params$query, fetchConfig = _objectWithoutProperties(params, _excluded);
-              _context.next = 4;
-              return _this2._fetch(_this2._makeRequestUrl(url, query), _objectSpread2(_objectSpread2({}, fetchConfig), {}, {
-                headers: fetchConfig.headers,
-                body: body !== null && body !== undefined && body !== '' ? JSON.stringify(body) : body
-              }));
-            case 4:
-              response = _context.sent;
-              return _context.abrupt("return", _this2._processResponse(response));
-            case 6:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee);
-      }));
-      return function (_x) {
-        return _ref.apply(this, arguments);
-      };
-    }());
-    _defineProperty(this, "request", /*#__PURE__*/function () {
-      var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(url, params) {
-        var _this2$requestToken;
-        var token, response, _this2$shouldRefreshT, shouldRefreshToken, _this2$forceTokenUpda;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              _context2.next = 2;
-              return (_this2$requestToken = _this2.requestToken) === null || _this2$requestToken === void 0 ? void 0 : _this2$requestToken.call(_this2);
-            case 2:
-              token = _context2.sent;
-              _context2.next = 5;
-              return _this2._performRequest(url, token, params);
-            case 5:
-              response = _context2.sent;
-              _context2.prev = 6;
-              _context2.next = 9;
-              return _this2._processResponse(response);
-            case 9:
-              return _context2.abrupt("return", _context2.sent);
-            case 12:
-              _context2.prev = 12;
-              _context2.t0 = _context2["catch"](6);
-              if (_context2.t0 instanceof HTTPError) {
-                _context2.next = 16;
-                break;
-              }
-              throw _context2.t0;
-            case 16:
-              shouldRefreshToken = typeof _context2.t0.data.error === 'string' ? (_this2$shouldRefreshT = _this2.shouldRefreshToken) === null || _this2$shouldRefreshT === void 0 ? void 0 : _this2$shouldRefreshT.call(_this2, _context2.t0.data.error) : false;
-              if (!shouldRefreshToken) {
-                _context2.next = 25;
-                break;
-              }
-              _context2.next = 20;
-              return (_this2$forceTokenUpda = _this2.forceTokenUpdate) === null || _this2$forceTokenUpda === void 0 ? void 0 : _this2$forceTokenUpda.call(_this2);
-            case 20:
-              token = _context2.sent;
-              _context2.next = 23;
-              return _this2._performRequest(url, token, params);
-            case 23:
-              response = _context2.sent;
-              return _context2.abrupt("return", _this2._processResponse(response));
-            case 25:
-              throw _context2.t0;
-            case 26:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, null, [[6, 12]]);
-      }));
-      return function (_x2, _x3) {
-        return _ref2.apply(this, arguments);
-      };
-    }());
-    _defineProperty(this, "getMetaForResponse", function (response) {
-      return _this2._requestsMeta.get(response);
-    });
-    _defineProperty(this, "get", function (url, params) {
-      return _this2.request(url, _objectSpread2(_objectSpread2({}, params), {}, {
-        method: 'GET'
-      }));
-    });
-    _defineProperty(this, "post", function (url, params) {
-      return _this2.request(url, _objectSpread2(_objectSpread2({}, params), {}, {
-        method: 'POST'
+          query = {}
+        } = params,
+        fetchConfig = _objectWithoutProperties(params, _excluded);
+      const response = await _this._fetch(_this._makeRequestUrl(url, query), _objectSpread2(_objectSpread2({}, fetchConfig), {}, {
+        headers: fetchConfig.headers,
+        body: body !== null && body !== undefined && body !== '' ? JSON.stringify(body) : body
       }));
+      return _this._processResponse(response);
     });
-    _defineProperty(this, "delete", function (url, params) {
-      return _this2.request(url, _objectSpread2(_objectSpread2({}, params), {}, {
-        method: 'DELETE'
-      }));
-    });
-    _defineProperty(this, "put", function (url, params) {
-      return _this2.request(url, _objectSpread2(_objectSpread2({}, params), {}, {
-        method: 'PUT'
-      }));
+    _defineProperty(this, "request", async (url, params) => {
+      var _this$requestToken;
+      let token = await ((_this$requestToken = this.requestToken) === null || _this$requestToken === void 0 ? void 0 : _this$requestToken.call(this));
+      let response = await this._performRequest(url, token, params);
+      try {
+        // Wait for result to catch an HTTP error
+        return await this._processResponse(response);
+      } catch (error) {
+        var _this$shouldRefreshTo;
+        if (!(error instanceof HTTPError)) {
+          throw error;
+        }
+        const shouldRefreshToken = typeof error.data.error === 'string' ? (_this$shouldRefreshTo = this.shouldRefreshToken) === null || _this$shouldRefreshTo === void 0 ? void 0 : _this$shouldRefreshTo.call(this, error.data.error) : false;
+        if (shouldRefreshToken) {
+          var _this$forceTokenUpdat;
+          token = await ((_this$forceTokenUpdat = this.forceTokenUpdate) === null || _this$forceTokenUpdat === void 0 ? void 0 : _this$forceTokenUpdat.call(this));
+          response = await this._performRequest(url, token, params);
+          return this._processResponse(response);
+        }
+        throw error;
+      }
     });
+    _defineProperty(this, "getMetaForResponse", response => this._requestsMeta.get(response));
+    _defineProperty(this, "get", (url, params) => this.request(url, _objectSpread2(_objectSpread2({}, params), {}, {
+      method: 'GET'
+    })));
+    _defineProperty(this, "post", (url, params) => this.request(url, _objectSpread2(_objectSpread2({}, params), {}, {
+      method: 'POST'
+    })));
+    _defineProperty(this, "delete", (url, params) => this.request(url, _objectSpread2(_objectSpread2({}, params), {}, {
+      method: 'DELETE'
+    })));
+    _defineProperty(this, "put", (url, params) => this.request(url, _objectSpread2(_objectSpread2({}, params), {}, {
+      method: 'PUT'
+    })));
     /**
      * Usage: const {promise, abort} = http.abortify(http.get<{id: string}>)('http://test.com');
      * @param method
      */
-    _defineProperty(this, "abortify", function (method) {
-      return function () {
-        for (var _len = arguments.length, _ref3 = new Array(_len), _key = 0; _key < _len; _key++) {
-          _ref3[_key] = arguments[_key];
-        }
-        var url = _ref3[0],
-          params = _ref3[1];
-        var ctrl = new AbortController();
-        if (params && !('signal' in params)) {
-          params.signal = ctrl.signal;
-        }
-        return {
-          promise: method.call(_this2, url, params),
-          abort: function abort() {
-            return ctrl.abort();
-          }
-        };
+    _defineProperty(this, "abortify", method => function () {
+      for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+        _ref[_key] = arguments[_key];
+      }
+      let [url, params] = _ref;
+      const ctrl = new AbortController();
+      if (params && !('signal' in params)) {
+        params.signal = ctrl.signal;
+      }
+      return {
+        promise: method.call(_this, url, params),
+        abort: () => ctrl.abort()
       };
     });
     if (_auth) {
       this.setAuth(_auth);
     }
     this.setBaseUrl(_baseUrl);
-    var headers = defaultFetchConfig.headers,
+    const {
+        headers
+      } = defaultFetchConfig,
       defaultConfig = _objectWithoutProperties(defaultFetchConfig, _excluded2);
     this.fetchConfig = _objectSpread2(_objectSpread2(_objectSpread2({}, defaultConfig), _fetchConfig), {}, {
       headers: _objectSpread2(_objectSpread2({}, headers), _fetchConfig.headers)
     });
   }
-  return _createClass(HTTP, [{
-    key: "_fetch",
-    value: function _fetch() {
-      return fetch.apply(void 0, arguments);
-    }
-  }, {
-    key: "_makeRequestUrl",
-    value: function _makeRequestUrl(url, queryObject) {
-      var urlWithQuery = encodeURL(url, queryObject);
-      return joinBaseURLAndPath(this.baseUrl, urlWithQuery);
+  _fetch() {
+    return fetch(...arguments);
+  }
+  _makeRequestUrl(url, queryObject) {
+    const urlWithQuery = encodeURL(url, queryObject);
+    return joinBaseURLAndPath(this.baseUrl, urlWithQuery);
+  }
+  _performRequest(url, token) {
+    let params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const {
+        headers,
+        body,
+        query = {},
+        sendRawBody
+      } = params,
+      fetchConfig = _objectWithoutProperties(params, _excluded3);
+    const combinedHeaders = _objectSpread2(_objectSpread2(_objectSpread2({}, this.fetchConfig.headers), token ? {
+      Authorization: "".concat(TOKEN_TYPE, " ").concat(token)
+    } : {}), headers);
+    Object.entries(combinedHeaders).forEach(_ref2 => {
+      let [key, header] = _ref2;
+      if (header === null || header === undefined) {
+        Reflect.deleteProperty(combinedHeaders, key);
+      }
+    });
+    let bodyToSend;
+    if (isRawBody(params)) {
+      bodyToSend = params.body;
+    } else {
+      bodyToSend = params.body === null || params.body === undefined || params.body === '' ? params.body : JSON.stringify(body);
     }
-  }, {
-    key: "_performRequest",
-    value: function _performRequest(url, token) {
-      var params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      var headers = params.headers,
-        body = params.body,
-        _params$query2 = params.query,
-        query = _params$query2 === void 0 ? {} : _params$query2;
-        params.sendRawBody;
-        var fetchConfig = _objectWithoutProperties(params, _excluded3);
-      var combinedHeaders = _objectSpread2(_objectSpread2(_objectSpread2({}, this.fetchConfig.headers), token ? {
-        Authorization: "".concat(TOKEN_TYPE, " ").concat(token)
-      } : {}), headers);
-      Object.entries(combinedHeaders).forEach(function (_ref4) {
-        var _ref5 = _slicedToArray(_ref4, 2),
-          key = _ref5[0],
-          header = _ref5[1];
-        if (header === null || header === undefined) {
-          Reflect.deleteProperty(combinedHeaders, key);
-        }
-      });
-      var bodyToSend;
-      if (isRawBody(params)) {
-        bodyToSend = params.body;
-      } else {
-        bodyToSend = params.body === null || params.body === undefined || params.body === '' ? params.body : JSON.stringify(body);
+    return this._fetch(this._makeRequestUrl(url, query), _objectSpread2(_objectSpread2(_objectSpread2({}, this.fetchConfig), {}, {
+      headers: combinedHeaders
+    }, fetchConfig), {}, {
+      body: bodyToSend
+    }));
+  }
+  _storeRequestMeta(parsedResponse, rawResponse) {
+    const {
+      headers,
+      ok,
+      redirected,
+      status,
+      statusText,
+      type,
+      url
+    } = rawResponse;
+    this._requestsMeta.set(parsedResponse, {
+      headers,
+      ok,
+      redirected,
+      status,
+      statusText,
+      type,
+      url
+    });
+  }
+  async _processResponse(response) {
+    const contentType = response.headers.get('content-type');
+    const isJson = contentType && contentType.indexOf('application/json') !== -1;
+    if (!response.ok) {
+      let resJson;
+      try {
+        resJson = await (isJson ? response.json() : response.text());
+      } catch (err) {
+        // noop
       }
-      return this._fetch(this._makeRequestUrl(url, query), _objectSpread2(_objectSpread2(_objectSpread2({}, this.fetchConfig), {}, {
-        headers: combinedHeaders
-      }, fetchConfig), {}, {
-        body: bodyToSend
-      }));
+      throw new HTTPError(response, resJson);
     }
-  }, {
-    key: "_storeRequestMeta",
-    value: function _storeRequestMeta(parsedResponse, rawResponse) {
-      var headers = rawResponse.headers,
-        ok = rawResponse.ok,
-        redirected = rawResponse.redirected,
-        status = rawResponse.status,
-        statusText = rawResponse.statusText,
-        type = rawResponse.type,
-        url = rawResponse.url;
-      this._requestsMeta.set(parsedResponse, {
-        headers,
-        ok,
-        redirected,
-        status,
-        statusText,
-        type,
-        url
+    try {
+      const parsedResponse = await (isJson ? response.json() : {
+        data: await response.text()
       });
+      this._storeRequestMeta(parsedResponse, response);
+      return parsedResponse;
+    } catch (err) {
+      return response;
     }
-  }, {
-    key: "_processResponse",
-    value: function () {
-      var _processResponse2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(response) {
-        var contentType, isJson, resJson, parsedResponse;
-        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              contentType = response.headers.get('content-type');
-              isJson = contentType && contentType.indexOf('application/json') !== -1;
-              if (response.ok) {
-                _context3.next = 12;
-                break;
-              }
-              _context3.prev = 3;
-              _context3.next = 6;
-              return isJson ? response.json() : response.text();
-            case 6:
-              resJson = _context3.sent;
-              _context3.next = 11;
-              break;
-            case 9:
-              _context3.prev = 9;
-              _context3.t0 = _context3["catch"](3);
-            case 11:
-              throw new HTTPError(response, resJson);
-            case 12:
-              _context3.prev = 12;
-              if (!isJson) {
-                _context3.next = 17;
-                break;
-              }
-              _context3.t1 = response.json();
-              _context3.next = 21;
-              break;
-            case 17:
-              _context3.next = 19;
-              return response.text();
-            case 19:
-              _context3.t2 = _context3.sent;
-              _context3.t1 = {
-                data: _context3.t2
-              };
-            case 21:
-              _context3.next = 23;
-              return _context3.t1;
-            case 23:
-              parsedResponse = _context3.sent;
-              this._storeRequestMeta(parsedResponse, response);
-              return _context3.abrupt("return", parsedResponse);
-            case 28:
-              _context3.prev = 28;
-              _context3.t3 = _context3["catch"](12);
-              return _context3.abrupt("return", response);
-            case 31:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this, [[3, 9], [12, 28]]);
-      }));
-      function _processResponse(_x4) {
-        return _processResponse2.apply(this, arguments);
-      }
-      return _processResponse;
-    }()
-  }, {
-    key: "authorizedFetch",
-    value: function () {
-      var _authorizedFetch = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
-        var response,
-          _args4 = arguments;
-        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              _context4.next = 2;
-              return this._performRequest.apply(this, _args4);
-            case 2:
-              response = _context4.sent;
-              return _context4.abrupt("return", this._processResponse(response));
-            case 4:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4, this);
-      }));
-      function authorizedFetch() {
-        return _authorizedFetch.apply(this, arguments);
-      }
-      return authorizedFetch;
-    }()
-  }]);
-}();
+  }
+  async authorizedFetch() {
+    const response = await this._performRequest(...arguments);
+    return this._processResponse(response);
+  }
+}
 
 export { CODE, HTTPError, HTTP as default, defaultFetchConfig };