@jetbrains/ring-ui-built 6.0.1

package/components/http/http.js

@@ -0,0 +1,386 @@
+import { a as _inherits, b as _createSuper, c as _classCallCheck, _ as _defineProperty, k as _assertThisInitialized, d as _createClass, e as _objectWithoutProperties, g as _objectSpread2, j as _slicedToArray, h as _asyncToGenerator, i as _regeneratorRuntime } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.reflect.delete-property.js';
+import 'core-js/modules/es.array.index-of.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 = {
+  headers: {
+    'Content-Type': 'application/json',
+    Accept: 'application/json'
+  },
+  credentials: 'same-origin'
+};
+var HTTPError = /*#__PURE__*/function (_ExtendableError) {
+  _inherits(HTTPError, _ExtendableError);
+  var _super = _createSuper(HTTPError);
+  function HTTPError(response) {
+    var _this;
+    var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, HTTPError);
+    _this = _super.call(this, "".concat(response.status, " ").concat(response.statusText || ''));
+    _defineProperty(_assertThisInitialized(_this), "data", void 0);
+    _defineProperty(_assertThisInitialized(_this), "status", void 0);
+    _this.data = data;
+    _this.status = response.status;
+    return _this;
+  }
+  return _createClass(HTTPError);
+}(ExtendableError);
+var 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();
+          }
+        };
+      };
+    });
+    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)
+    });
+  }
+  _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);
+      }
+      return this._fetch(this._makeRequestUrl(url, query), _objectSpread2(_objectSpread2(_objectSpread2({}, this.fetchConfig), {}, {
+        headers: combinedHeaders
+      }, fetchConfig), {}, {
+        body: bodyToSend
+      }));
+    }
+  }, {
+    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 _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);
+      }
+      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;
+    }()
+  }], [{
+    key: "_isErrorStatus",
+    value: function _isErrorStatus(status) {
+      return status < STATUS_OK_IF_MORE_THAN || status >= STATUS_BAD_IF_MORE_THAN;
+    }
+  }]);
+  return HTTP;
+}();
+
+export { CODE, HTTPError, HTTP as default, defaultFetchConfig };

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

@@ -0,0 +1,20 @@
+import HTTP, { FetchParams } from './http';
+export interface HTTPMockRequest {
+    url: string;
+    params: FetchParams;
+}
+export default class HTTPMock extends HTTP {
+    defaultResponse: unknown;
+    requests: HTTPMockRequest[];
+    responsesByUrlMap: Map<string | RegExp, unknown>;
+    constructor();
+    _fetch(url: string, params: RequestInit): {
+        status: number;
+        headers: Headers;
+        json: () => Promise<unknown>;
+    };
+    respondDefault(response: unknown): void;
+    respondForUrl(url: string | RegExp, response: unknown): void;
+    _getResponseForUrl(urlToMatch: string): unknown;
+    getRequestsByUrlPart(url: string): HTTPMockRequest[];
+}

package/components/http/http.mock.js

@@ -0,0 +1,113 @@
+import { a as _inherits, b as _createSuper, c as _classCallCheck, _ as _defineProperty, k as _assertThisInitialized, d as _createClass, l as _toConsumableArray, g as _objectSpread2, m as _createForOfIteratorHelper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.regexp.constructor.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.array.index-of.js';
+import HTTP from './http.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.reflect.delete-property.js';
+import 'es6-error';
+import '../global/url.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.string.replace.js';
+
+var authMock = {
+  requestToken: function requestToken() {
+    return 'mock token';
+  },
+  shouldRefreshToken: function shouldRefreshToken() {
+    return false;
+  },
+  forceTokenUpdate: function forceTokenUpdate() {
+    return Promise.resolve(null);
+  }
+};
+var HTTPMock = /*#__PURE__*/function (_HTTP) {
+  _inherits(HTTPMock, _HTTP);
+  var _super = _createSuper(HTTPMock);
+  function HTTPMock() {
+    var _this;
+    _classCallCheck(this, HTTPMock);
+    _this = _super.call(this, authMock);
+    _defineProperty(_assertThisInitialized(_this), "defaultResponse", void 0);
+    _defineProperty(_assertThisInitialized(_this), "requests", void 0);
+    _defineProperty(_assertThisInitialized(_this), "responsesByUrlMap", void 0);
+    _this.defaultResponse = null;
+    _this.requests = [];
+    _this.responsesByUrlMap = new Map();
+    return _this;
+  }
+  _createClass(HTTPMock, [{
+    key: "_fetch",
+    value: function _fetch(url, params) {
+      var _this2 = this;
+      this.requests = [].concat(_toConsumableArray(this.requests), [{
+        url,
+        params: _objectSpread2(_objectSpread2({}, params), {}, {
+          body: typeof params.body === 'string' ? JSON.parse(params.body) : params.body
+        })
+      }]);
+      return {
+        status: 200,
+        headers: new Headers({
+          'content-type': 'application/json'
+        }),
+        json: function json() {
+          return Promise.resolve(_this2._getResponseForUrl(url) || _this2.defaultResponse);
+        }
+      };
+    }
+  }, {
+    key: "respondDefault",
+    value: function respondDefault(response) {
+      this.defaultResponse = response;
+    }
+  }, {
+    key: "respondForUrl",
+    value: function respondForUrl(url, response) {
+      this.responsesByUrlMap.set(url, response);
+    }
+  }, {
+    key: "_getResponseForUrl",
+    value: function _getResponseForUrl(urlToMatch) {
+      var urls = this.responsesByUrlMap.keys();
+      var _iterator = _createForOfIteratorHelper(urls),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var url = _step.value;
+          if (url === urlToMatch) {
+            return this.responsesByUrlMap.get(url);
+          }
+          if (url instanceof RegExp && url.test(urlToMatch)) {
+            return this.responsesByUrlMap.get(url);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return null;
+    }
+  }, {
+    key: "getRequestsByUrlPart",
+    value: function getRequestsByUrlPart(url) {
+      return this.requests.filter(function (it) {
+        return it.url.indexOf(url) !== -1;
+      });
+    }
+  }]);
+  return HTTPMock;
+}(HTTP);
+
+export { HTTPMock as default };

package/components/hub-source/hub-source.d.ts

@@ -0,0 +1,44 @@
+import Auth from '../auth/auth';
+import HTTP from '../http/http';
+export interface Item {
+    name: string;
+}
+export type Response<I extends Item, U extends string> = Partial<Record<U, I[]>> & {
+    total: number;
+};
+export interface HubSourceOptions {
+    searchMax: number;
+    searchSideThreshold: number;
+    queryFormatter: (query: string) => string;
+}
+/**
+ * HubSource is designed to speed up search requests for small installations.
+ * If there are less than "searchSideThreshold" items, it uses client-side filtering
+ * of cached results to greatly increase search speed. Useful for completion and
+ * select data source.
+ */
+export default class HubSource<I extends Item, U extends string> {
+    static TOP_ALL: number;
+    http: HTTP;
+    relativeUrl: U;
+    options: HubSourceOptions;
+    storedData: Response<I, U> | null;
+    isClientSideSearch: boolean | null;
+    filterFn: (item: I) => boolean;
+    constructor(auth: Auth, relativeUrl: U, options?: Partial<HubSourceOptions>);
+    makeRequest<T = unknown>(queryParams?: Record<string, unknown>): Promise<T>;
+    makeCachedRequest(params?: Record<string, unknown>): Promise<Response<I, U>>;
+    static mergeParams(params?: Record<string, unknown>, toMerge?: Record<string, unknown>): Record<string, unknown>;
+    checkIsClientSideSearch(res: Response<I, U>): boolean;
+    getDefaultFilterFn(query?: string): (it: I) => boolean;
+    formatQuery(query?: string): string;
+    static validateInputParams(params: Record<string, unknown>): void;
+    processResults(res: Response<I, U>): I[];
+    sideDetectionRequest(params?: Record<string, unknown>, query?: string): Promise<unknown>;
+    doClientSideSearch(params?: Record<string, unknown>): Promise<Response<I, U>>;
+    doServerSideSearch(params?: Record<string, unknown>, query?: string): Promise<unknown>;
+    getValueFromSuitableSource(query?: string, params?: Record<string, unknown>): Promise<Partial<Record<U, I[]>> & {
+        total: number;
+    }>;
+    get(query: string, params: Record<string, unknown>, filterFn?: (item: I) => boolean): Promise<I[]>;
+}