@jetbrains/ring-ui-built 6.0.32 → 6.0.34

package/components/http/http.js

@@ -1,234 +1,376 @@
+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
  */
-const TOKEN_TYPE = 'Bearer';
-const STATUS_OK_IF_MORE_THAN = 200;
-const STATUS_BAD_IF_MORE_THAN = 300;
-const defaultFetchConfig = {
+var TOKEN_TYPE = 'Bearer';
+var defaultFetchConfig = {
   headers: {
     'Content-Type': 'application/json',
     Accept: 'application/json'
   },
   credentials: 'same-origin'
 };
-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;
+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;
   }
-}
-const CODE = {
+  _inherits(HTTPError, _ExtendableError);
+  return _createClass(HTTPError);
+}(ExtendableError);
+var CODE = {
   UNAUTHORIZED: 401
 };
 function isRawBody(params) {
   return params.sendRawBody === true;
 }
-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);
-      }
+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();
+      };
     });
-    let 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), {
-      ...this.fetchConfig,
-      headers: combinedHeaders,
-      ...fetchConfig,
-      body: bodyToSend
+    _defineProperty(this, "setBaseUrl", function (baseUrl) {
+      _this2.baseUrl = baseUrl;
     });
-  }
-  _storeRequestMeta(parsedResponse, rawResponse) {
-    const {
-      headers,
-      ok,
-      redirected,
-      status,
-      statusText,
-      type,
-      url
-    } = rawResponse;
-    this._requestsMeta.set(parsedResponse, {
-      headers,
-      ok,
-      redirected,
-      status,
-      statusText,
-      type,
-      url
+    _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 = 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'
+      }));
+    });
+    _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();
+          }
+        };
+      };
+    });
+    if (_auth) {
+      this.setAuth(_auth);
+    }
+    this.setBaseUrl(_baseUrl);
+    var headers = defaultFetchConfig.headers,
+      defaultConfig = _objectWithoutProperties(defaultFetchConfig, _excluded2);
+    this.fetchConfig = _objectSpread2(_objectSpread2(_objectSpread2({}, defaultConfig), _fetchConfig), {}, {
+      headers: _objectSpread2(_objectSpread2({}, headers), _fetchConfig.headers)
     });
   }
-  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
-      }
-      throw new HTTPError(response, resJson);
+  return _createClass(HTTP, [{
+    key: "_fetch",
+    value: function _fetch() {
+      return fetch.apply(void 0, arguments);
     }
-    try {
-      const parsedResponse = await (isJson ? response.json?.() : {
-        data: await response.text?.()
-      });
-      this._storeRequestMeta(parsedResponse, response);
-      return parsedResponse;
-    } catch (err) {
-      return response;
+  }, {
+    key: "_makeRequestUrl",
+    value: function _makeRequestUrl(url, queryObject) {
+      var urlWithQuery = encodeURL(url, queryObject);
+      return joinBaseURLAndPath(this.baseUrl, urlWithQuery);
     }
-  }
-  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
+  }, {
+    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);
+        }
       });
-      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;
+      var bodyToSend;
+      if (isRawBody(params)) {
+        bodyToSend = params.body;
+      } else {
+        bodyToSend = params.body === null || params.body === undefined || params.body === '' ? params.body : JSON.stringify(body);
       }
-      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);
-      }
-      throw error;
+      return this._fetch(this._makeRequestUrl(url, query), _objectSpread2(_objectSpread2(_objectSpread2({}, this.fetchConfig), {}, {
+        headers: combinedHeaders
+      }, fetchConfig), {}, {
+        body: bodyToSend
+      }));
     }
-  };
-  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];
+  }, {
+    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
+      });
+    }
+  }, {
+    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);
       }
-      let [url, params] = _ref2;
-      const ctrl = new AbortController();
-      if (params && !('signal' in params)) {
-        params.signal = ctrl.signal;
+      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 {
-        promise: method.call(_this2, url, params),
-        abort: () => ctrl.abort()
-      };
-    };
-  };
-}
+      return authorizedFetch;
+    }()
+  }]);
+}();
 
 export { CODE, HTTPError, HTTP as default, defaultFetchConfig };

package/components/http/http.mock.d.ts

@@ -8,11 +8,7 @@ export default class HTTPMock extends HTTP {
     requests: HTTPMockRequest[];
     responsesByUrlMap: Map<string | RegExp, unknown>;
     constructor();
-    _fetch(url: string, params: RequestInit): {
-        status: number;
-        headers: Headers;
-        json: () => Promise<unknown>;
-    };
+    _fetch(url: string, params: RequestInit): Promise<Response>;
     respondDefault(response: unknown): void;
     respondForUrl(url: string | RegExp, response: unknown): void;
     _getResponseForUrl(urlToMatch: string): unknown;