@jetbrains/ring-ui-built 6.0.30 → 6.0.32

package/components/http/http.js

@@ -1,384 +1,234 @@
-import { a as _inherits, b as _createClass, c as _objectWithoutProperties, d as _objectSpread2, j as _slicedToArray, f as _classCallCheck, g as _callSuper, _ as _defineProperty, h as _asyncToGenerator, i 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 '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"],
-  _excluded2 = ["headers"],
-  _excluded3 = ["headers", "body", "query", "sendRawBody"];
 /**
  * @name HTTP
  */
-var TOKEN_TYPE = 'Bearer';
-var STATUS_OK_IF_MORE_THAN = 200;
-var STATUS_BAD_IF_MORE_THAN = 300;
-var defaultFetchConfig = {
+const TOKEN_TYPE = 'Bearer';
+const STATUS_OK_IF_MORE_THAN = 200;
+const STATUS_BAD_IF_MORE_THAN = 300;
+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 {
+  data;
+  status;
+  constructor(response) {
+    let data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super(`${response.status} ${response.statusText || ''}`);
+    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);
-    _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, "setBaseUrl", function (baseUrl) {
-      _this2.baseUrl = baseUrl;
-    });
-    _defineProperty(this, "fetch", /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(url) {
-        var params,
-          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 = _context2.t0.data.error !== undefined ? (_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'
-      }));
-    });
-    _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'
-      }));
-    });
-    /**
-     * 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();
-          }
-        };
-      };
+class HTTP {
+  baseUrl = null;
+  _requestsMeta = new WeakMap();
+  fetchConfig;
+  requestToken;
+  shouldRefreshToken;
+  forceTokenUpdate;
+  constructor(auth, baseUrl) {
+    let fetchConfig = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    if (auth) {
+      this.setAuth(auth);
+    }
+    this.setBaseUrl(baseUrl);
+    const {
+      headers,
+      ...defaultConfig
+    } = defaultFetchConfig;
+    this.fetchConfig = {
+      ...defaultConfig,
+      ...fetchConfig,
+      headers: {
+        ...headers,
+        ...fetchConfig.headers
+      }
+    };
+  }
+  setAuth = auth => {
+    this.requestToken = () => auth.requestToken();
+    this.shouldRefreshToken = auth.constructor.shouldRefreshToken;
+    this.forceTokenUpdate = () => auth.forceTokenUpdate();
+  };
+  setBaseUrl = baseUrl => {
+    this.baseUrl = baseUrl;
+  };
+  _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,
+      ...fetchConfig
+    } = params;
+    const combinedHeaders = {
+      ...this.fetchConfig.headers,
+      ...(token ? {
+        Authorization: `${TOKEN_TYPE} ${token}`
+      } : {}),
+      ...headers
+    };
+    Object.entries(combinedHeaders).forEach(_ref => {
+      let [key, header] = _ref;
+      if (header === null || header === undefined) {
+        Reflect.deleteProperty(combinedHeaders, key);
+      }
     });
-    if (_auth) {
-      this.setAuth(_auth);
+    let bodyToSend;
+    if (isRawBody(params)) {
+      bodyToSend = params.body;
+    } else {
+      bodyToSend = params.body === null || params.body === undefined || params.body === '' ? params.body : JSON.stringify(body);
     }
-    this.setBaseUrl(_baseUrl);
-    var headers = defaultFetchConfig.headers,
-      defaultConfig = _objectWithoutProperties(defaultFetchConfig, _excluded2);
-    this.fetchConfig = _objectSpread2(_objectSpread2(_objectSpread2({}, defaultConfig), _fetchConfig), {}, {
-      headers: _objectSpread2(_objectSpread2({}, headers), _fetchConfig.headers)
+    return this._fetch(this._makeRequestUrl(url, query), {
+      ...this.fetchConfig,
+      headers: combinedHeaders,
+      ...fetchConfig,
+      body: bodyToSend
     });
   }
-  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);
-    }
-  }, {
-    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);
+  _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.status != null && HTTP._isErrorStatus(response.status)) {
+      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 _response$headers;
-        var contentType, isJson, resJson, _response$json, _response$text, _response$json2, _response$text2, parsedResponse;
-        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              contentType = (_response$headers = response.headers) === null || _response$headers === void 0 ? void 0 : _response$headers.get('content-type');
-              isJson = contentType && contentType.indexOf('application/json') !== -1;
-              if (!(response.status != null && HTTP._isErrorStatus(response.status))) {
-                _context3.next = 12;
-                break;
-              }
-              _context3.prev = 3;
-              _context3.next = 6;
-              return isJson ? (_response$json = response.json) === null || _response$json === void 0 ? void 0 : _response$json.call(response) : (_response$text = response.text) === null || _response$text === void 0 ? void 0 : _response$text.call(response);
-            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$json2 = response.json) === null || _response$json2 === void 0 ? void 0 : _response$json2.call(response);
-              _context3.next = 21;
-              break;
-            case 17:
-              _context3.next = 19;
-              return (_response$text2 = response.text) === null || _response$text2 === void 0 ? void 0 : _response$text2.call(response);
-            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);
+  }
+  static _isErrorStatus(status) {
+    return status < STATUS_OK_IF_MORE_THAN || status >= STATUS_BAD_IF_MORE_THAN;
+  }
+  fetch = (() => {
+    var _this = this;
+    return async function (url) {
+      let params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      const {
+        body,
+        query = {},
+        ...fetchConfig
+      } = params;
+      const response = await _this._fetch(_this._makeRequestUrl(url, query), {
+        ...fetchConfig,
+        headers: fetchConfig.headers,
+        body: body !== null && body !== undefined && body !== '' ? JSON.stringify(body) : body
+      });
+      return _this._processResponse(response);
+    };
+  })();
+  async authorizedFetch() {
+    const response = await this._performRequest(...arguments);
+    return this._processResponse(response);
+  }
+  request = async (url, params) => {
+    let token = await this.requestToken?.();
+    let response = await this._performRequest(url, token, params);
+    try {
+      // Wait for result to catch an HTTP error
+      return await this._processResponse(response);
+    } catch (error) {
+      if (!(error instanceof HTTPError)) {
+        throw error;
       }
-      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);
+      const shouldRefreshToken = typeof error.data.error === 'string' ? this.shouldRefreshToken?.(error.data.error) : false;
+      if (shouldRefreshToken) {
+        token = await this.forceTokenUpdate?.();
+        response = await this._performRequest(url, token, params);
+        return this._processResponse(response);
       }
-      return authorizedFetch;
-    }()
-  }], [{
-    key: "_isErrorStatus",
-    value: function _isErrorStatus(status) {
-      return status < STATUS_OK_IF_MORE_THAN || status >= STATUS_BAD_IF_MORE_THAN;
+      throw error;
     }
-  }]);
-}();
+  };
+  getMetaForResponse = response => this._requestsMeta.get(response);
+  get = (url, params) => this.request(url, {
+    ...params,
+    method: 'GET'
+  });
+  post = (url, params) => this.request(url, {
+    ...params,
+    method: 'POST'
+  });
+  delete = (url, params) => this.request(url, {
+    ...params,
+    method: 'DELETE'
+  });
+  put = (url, params) => this.request(url, {
+    ...params,
+    method: 'PUT'
+  });
+  /**
+   * Usage: const {promise, abort} = http.abortify(http.get<{id: string}>)('http://test.com');
+   * @param method
+   */
+  abortify = method => {
+    var _this2 = this;
+    return function () {
+      for (var _len = arguments.length, _ref2 = new Array(_len), _key = 0; _key < _len; _key++) {
+        _ref2[_key] = arguments[_key];
+      }
+      let [url, params] = _ref2;
+      const ctrl = new AbortController();
+      if (params && !('signal' in params)) {
+        params.signal = ctrl.signal;
+      }
+      return {
+        promise: method.call(_this2, url, params),
+        abort: () => ctrl.abort()
+      };
+    };
+  };
+}
 
 export { CODE, HTTPError, HTTP as default, defaultFetchConfig };