@jetbrains/ring-ui 4.2.8 → 4.2.11

package/dist/http/http.js

@@ -0,0 +1,224 @@
+import { _ as _defineProperty } 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.string.replace.js';
+
+/**
+ * @name HTTP
+ */
+
+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'
+};
+class HTTPError extends ExtendableError {
+  constructor(response) {
+    let data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super("".concat(response.status, " ").concat(response.statusText || ''));
+    this.data = data;
+    this.status = response.status;
+  }
+
+}
+const CODE = {
+  UNAUTHORIZED: 401
+};
+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, "setAuth", auth => {
+      this.requestToken = () => auth.requestToken();
+
+      this.shouldRefreshToken = auth.constructor.shouldRefreshToken;
+
+      this.forceTokenUpdate = () => auth.forceTokenUpdate();
+    });
+
+    _defineProperty(this, "setBaseUrl", baseUrl => {
+      this.baseUrl = baseUrl;
+    });
+
+    _defineProperty(this, "fetch", 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,
+        body: body ? JSON.stringify(body) : body
+      });
+      return _this._processResponse(response);
+    });
+
+    _defineProperty(this, "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;
+        }
+
+        const shouldRefreshToken = error.data.error !== undefined ? 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;
+      }
+    });
+
+    _defineProperty(this, "getMetaForResponse", response => this._requestsMeta.get(response));
+
+    _defineProperty(this, "get", (url, params) => this.request(url, { ...params,
+      method: 'GET'
+    }));
+
+    _defineProperty(this, "post", (url, params) => this.request(url, { ...params,
+      method: 'POST'
+    }));
+
+    _defineProperty(this, "delete", (url, params) => this.request(url, { ...params,
+      method: 'DELETE'
+    }));
+
+    _defineProperty(this, "put", (url, params) => this.request(url, { ...params,
+      method: 'PUT'
+    }));
+
+    if (_auth) {
+      this.setAuth(_auth);
+    }
+
+    this.setBaseUrl(_baseUrl);
+    const {
+      headers,
+      ...defaultConfig
+    } = defaultFetchConfig;
+    this.fetchConfig = { ...defaultConfig,
+      ..._fetchConfig,
+      headers: { ...headers,
+        ..._fetchConfig.headers
+      }
+    };
+  }
+
+  _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: "".concat(TOKEN_TYPE, " ").concat(token)
+      } : {}),
+      ...headers
+    };
+    Object.keys(combinedHeaders).forEach(key => {
+      if (combinedHeaders[key] === null || combinedHeaders[key] === undefined) {
+        Reflect.deleteProperty(combinedHeaders, key);
+      }
+    });
+    return this._fetch(this._makeRequestUrl(url, query), { ...this.fetchConfig,
+      headers: combinedHeaders,
+      ...fetchConfig,
+      body: body && !sendRawBody ? JSON.stringify(body) : 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 (HTTP._isErrorStatus(response.status)) {
+      let resJson;
+
+      try {
+        resJson = await (isJson ? response.json() : response.text());
+      } catch (err) {// noop
+      }
+
+      throw new HTTPError(response, resJson);
+    }
+
+    try {
+      const parsedResponse = await (isJson ? response.json() : {
+        data: await response.text()
+      });
+
+      this._storeRequestMeta(parsedResponse, response);
+
+      return parsedResponse;
+    } catch (err) {
+      return response;
+    }
+  }
+
+  static _isErrorStatus(status) {
+    return status < STATUS_OK_IF_MORE_THAN || status >= STATUS_BAD_IF_MORE_THAN;
+  }
+
+  async authorizedFetch() {
+    const response = await this._performRequest(...arguments);
+    return this._processResponse(response);
+  }
+
+}
+
+export { CODE, HTTPError, HTTP as default, defaultFetchConfig };

package/dist/http/http.mock.js

@@ -0,0 +1,67 @@
+import 'core-js/modules/web.dom-collections.iterator.js';
+import HTTP from './http.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'es6-error';
+import '../global/url.js';
+import 'core-js/modules/es.string.replace.js';
+
+const authMock = {
+  requestToken: () => 'mock token',
+  shouldRefreshToken: () => false,
+  forceTokenUpdate: async () => {}
+};
+class HTTPMock extends HTTP {
+  constructor() {
+    super(authMock);
+    this.defaultResponse = null;
+    this.requests = [];
+    this.responsesByUrlMap = new Map();
+  }
+
+  _fetch(url, params) {
+    this.requests = [...this.requests, {
+      url,
+      params: { ...params,
+        body: params.body ? JSON.parse(params.body) : params.body
+      }
+    }];
+    return {
+      status: 200,
+      headers: new Headers({
+        'content-type': 'application/json'
+      }),
+      json: () => this._getResponseForUrl(url) || this.defaultResponse
+    };
+  }
+
+  respondDefault(response) {
+    this.defaultResponse = response;
+  }
+
+  respondForUrl(url, response) {
+    this.responsesByUrlMap.set(url, response);
+  }
+
+  _getResponseForUrl(urlToMatch) {
+    const urls = this.responsesByUrlMap.keys();
+
+    for (const url of urls) {
+      if (url === urlToMatch) {
+        return this.responsesByUrlMap.get(url);
+      }
+
+      if (url.test && url.test(urlToMatch)) {
+        return this.responsesByUrlMap.get(url);
+      }
+    }
+
+    return null;
+  }
+
+  getRequestsByUrlPart(url) {
+    return this.requests.filter(it => it.url.indexOf(url) !== -1);
+  }
+
+}
+
+export { HTTPMock as default };

package/dist/hub-source/hub-source.js

@@ -0,0 +1,130 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+
+const defaultOptions = {
+  searchMax: 20,
+  searchSideThreshold: 100,
+  queryFormatter: query => "".concat(query, " or ").concat(query, "*")
+};
+/**
+ * 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.
+ */
+
+class HubSource {
+  constructor(auth, relativeUrl, options) {
+    this.http = auth.http;
+    this.relativeUrl = relativeUrl;
+    this.options = Object.assign({}, defaultOptions, options);
+    this.storedData = null;
+    this.isClientSideSearch = null;
+    this.filterFn = null;
+  }
+
+  makeRequest(queryParams) {
+    return this.http.get(this.relativeUrl, {
+      query: queryParams
+    });
+  }
+
+  async makeCachedRequest(params) {
+    if (this.storedData) {
+      return this.storedData;
+    }
+
+    const res = await this.makeRequest(params);
+    this.storedData = res;
+    return res;
+  }
+
+  static mergeParams(params, toMerge) {
+    return Object.assign({}, params, toMerge);
+  }
+
+  checkIsClientSideSearch(res) {
+    return res.total <= this.options.searchSideThreshold;
+  }
+
+  getDefaultFilterFn(query) {
+    if (!query) {
+      return () => true;
+    }
+
+    return it => it.name.toLowerCase().indexOf(query.toLowerCase()) !== -1;
+  }
+
+  formatQuery(query) {
+    return query ? this.options.queryFormatter(query) : '';
+  }
+
+  static validateInputParams(params) {
+    if (params.top) {
+      throw new Error('HubSource: params.top should not be filled, configure "options.searchMax" instead');
+    }
+
+    if (params.query) {
+      throw new Error('HubSource: params.query should not be filled, configure "options.queryFormatter" instead');
+    }
+  }
+
+  processResults(res) {
+    const items = res[this.relativeUrl] || [];
+
+    if (this.isClientSideSearch) {
+      return items.filter(it => this.filterFn(it)).slice(0, this.options.searchMax);
+    }
+
+    return items;
+  }
+
+  async sideDetectionRequest(params, query) {
+    const res = await this.makeCachedRequest(HubSource.mergeParams(params, {
+      $top: this.options.searchSideThreshold
+    }));
+    this.isClientSideSearch = this.checkIsClientSideSearch(res);
+
+    if (!this.isClientSideSearch) {
+      return this.doServerSideSearch(params, query);
+    }
+
+    return res;
+  }
+
+  doClientSideSearch(params) {
+    return this.makeCachedRequest(HubSource.mergeParams(params, {
+      $top: this.constructor.TOP_ALL
+    }));
+  }
+
+  doServerSideSearch(params, query) {
+    return this.makeRequest(HubSource.mergeParams(params, {
+      query: this.formatQuery(query),
+      $top: this.options.searchMax
+    }));
+  }
+
+  getValueFromSuitableSource(query, params) {
+    if (this.isClientSideSearch === null) {
+      return this.sideDetectionRequest(params, query);
+    }
+
+    if (this.isClientSideSearch) {
+      return this.doClientSideSearch(params);
+    }
+
+    return this.doServerSideSearch(params, query);
+  }
+
+  async get(query, params, filterFn) {
+    HubSource.validateInputParams(params);
+    this.filterFn = filterFn || this.getDefaultFilterFn(query);
+    const res = await this.getValueFromSuitableSource(query, params);
+    return this.processResults(res);
+  }
+
+}
+
+_defineProperty(HubSource, "TOP_ALL", -1);
+
+export { HubSource as default };

package/dist/hub-source/hub-source__user.js

@@ -0,0 +1,30 @@
+import HTTP from '../http/http.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'es6-error';
+import '../global/url.js';
+import 'core-js/modules/es.string.replace.js';
+
+const DEFAULT_FIELDS = 'id,name,login,banned,banReason,profile(email/email,avatar/url)';
+function convertUserForCard(hubUser) {
+  let serverUri = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  return {
+    name: hubUser.name,
+    login: hubUser.login,
+    banned: hubUser.banned,
+    banReason: hubUser.banReason,
+    email: hubUser.profile.email && hubUser.profile.email.email,
+    avatarUrl: hubUser.profile.avatar.url,
+    href: "".concat(serverUri, "users/").concat(hubUser.id)
+  };
+}
+function createHubUserCardSource(auth, userId) {
+  let fields = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_FIELDS;
+  const http = new HTTP(auth);
+  return async function getHubUser() {
+    const hubUser = await http.get("".concat(auth.config.serverUri, "api/rest/users/").concat(userId, "?fields=").concat(fields));
+    return convertUserForCard(hubUser, auth.config.serverUri);
+  };
+}
+
+export { convertUserForCard, createHubUserCardSource };

package/dist/hub-source/hub-source__users-groups.js

@@ -0,0 +1,63 @@
+import 'core-js/modules/web.dom-collections.iterator.js';
+import HubSource from './hub-source.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+
+const defaultOptions = {
+  searchMax: 20,
+  searchSideThreshold: 200
+};
+class HubSourceUsersGroups {
+  constructor(auth, options) {
+    this.auth = auth;
+    this.options = Object.assign({}, defaultOptions, options);
+    this.usersSource = new HubSource(auth, 'users', {
+      searchMax: this.options.searchMax,
+      searchSideThreshold: this.options.searchSideThreshold,
+      queryFormatter: query => "nameStartsWith: ".concat(HubSourceUsersGroups.wrapMultiwordQuery(query), " or loginStartsWith: ").concat(HubSourceUsersGroups.wrapMultiwordQuery(query))
+    });
+    this.groupsSource = new HubSource(auth, 'usergroups', {
+      searchMax: this.options.searchMax,
+      searchSideThreshold: this.options.searchSideThreshold
+    });
+  }
+
+  static wrapMultiwordQuery(query) {
+    if (query && query.indexOf(' ') !== -1) {
+      return "{".concat(query, "}");
+    }
+
+    return query;
+  }
+
+  createUsersFilterFn(query) {
+    if (!query) {
+      return () => true;
+    }
+
+    const normalizedQuery = query.toLowerCase();
+    return it => it.name.toLowerCase().indexOf(normalizedQuery) !== -1 || it.login.toLowerCase().indexOf(normalizedQuery) !== -1;
+  }
+
+  getUsers() {
+    let query = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    return this.usersSource.get(query, {
+      fields: 'id,name,login,total,profile/avatar/url',
+      orderBy: 'name'
+    }, this.createUsersFilterFn(query));
+  }
+
+  getGroups() {
+    let query = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    return this.groupsSource.get(query, {
+      fields: 'id,name,total,userCount,iconUrl',
+      orderBy: 'name'
+    });
+  }
+
+  getUserAndGroups(query) {
+    return Promise.all([this.getUsers(query), this.getGroups(query)]);
+  }
+
+}
+
+export { HubSourceUsersGroups as default };

package/dist/icon/icon.js

@@ -0,0 +1,105 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import deprecate from 'util-deprecate';
+import { Color, Size } from './icon__constants.js';
+export { Size } from './icon__constants.js';
+import { m as modules_29747b80 } from '../_helpers/icon.js';
+import IconSVG from './icon__svg.js';
+import 'core-js/modules/es.string.replace.js';
+import '../global/memoize.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+const warnSize = deprecate(() => {}, "`size`, `width` and `height` props are not recommended to use in Ring UI `Icon` component. The intrinsic sizes of SVG icon (`width` and `height` SVG attributes) are used instead.\n\nWe strongly recommend to use icons handcrafted for particular sizes. If your icon doesn't exist in the desired size, please ask your designer to draw one. \"Responsive\" checkmark should be unchecked when exporting icon.'");
+class Icon extends PureComponent {
+  warnSize() {
+    if (this.props.suppressSizeWarning) {
+      return;
+    }
+
+    warnSize();
+  }
+
+  getStyle() {
+    const {
+      size,
+      width,
+      height
+    } = this.props;
+
+    if (width || height) {
+      this.warnSize();
+      return {
+        width,
+        height
+      };
+    }
+
+    if (size) {
+      this.warnSize();
+      return {
+        width: size,
+        height: size
+      };
+    }
+
+    return null;
+  }
+
+  render() {
+    const {
+      className,
+      size,
+      color,
+      loading,
+      glyph: Glyph,
+      width,
+      height,
+      suppressSizeWarning,
+      ...restProps
+    } = this.props;
+
+    if (!Glyph) {
+      return null;
+    }
+
+    const classes = classNames(modules_29747b80.icon, {
+      [modules_29747b80[color]]: !!color,
+      [modules_29747b80.loading]: loading
+    }, className);
+    return /*#__PURE__*/React.createElement("span", _extends({}, restProps, {
+      className: classes
+    }), typeof Glyph === 'string' ? /*#__PURE__*/React.createElement(IconSVG, {
+      src: Glyph,
+      style: this.getStyle()
+    }) : /*#__PURE__*/React.createElement(Glyph, {
+      className: modules_29747b80.glyph,
+      style: this.getStyle()
+    }));
+  }
+
+}
+
+_defineProperty(Icon, "propTypes", {
+  className: PropTypes.string,
+  color: PropTypes.string,
+  glyph: PropTypes.oneOfType([PropTypes.string, PropTypes.elementType]).isRequired,
+  height: PropTypes.number,
+  size: PropTypes.number,
+  width: PropTypes.number,
+  loading: PropTypes.bool,
+  suppressSizeWarning: PropTypes.bool
+});
+
+_defineProperty(Icon, "defaultProps", {
+  className: '',
+  color: Color.DEFAULT,
+  glyph: ''
+});
+
+_defineProperty(Icon, "Color", Color);
+
+_defineProperty(Icon, "Size", Size);
+
+export { Icon as default };

package/dist/icon/icon__constants.js

@@ -0,0 +1,33 @@
+/**
+ * Commonly used icon colors.
+ * @enum {string}
+ */
+const Color = {
+  BLUE: 'blue',
+  DEFAULT: '',
+  GRAY: 'gray',
+  GREEN: 'green',
+  MAGENTA: 'magenta',
+  RED: 'red',
+  WHITE: 'white'
+};
+/**
+ * @enum {number}
+ */
+
+const Size = {
+  Size12: 12,
+  Size14: 14,
+  Size16: 16,
+  Size18: 18,
+  Size20: 20,
+  Size24: 24,
+  Size32: 32,
+  Size40: 40,
+  Size48: 48,
+  Size64: 64,
+  Size96: 96,
+  Size128: 128
+};
+
+export { Color, Size };