@jetbrains/ring-ui 4.1.1 → 4.1.2

package/dist/header/smart-services.js

@@ -0,0 +1,160 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import '../auth/auth.js';
+import HTTP from '../http/http.js';
+import Services from './services.js';
+import Auth from '../auth/auth__core.js';
+import '../auth/window-flow.js';
+import '../auth/response-parser.js';
+import 'es6-error';
+import '../global/url.js';
+import '../auth/down-notification.js';
+import '../alert-service/alert-service.js';
+import 'react-dom';
+import '../global/get-uid.js';
+import '../alert/alert.js';
+import 'classnames';
+import '@jetbrains/icons/exception';
+import '@jetbrains/icons/checkmark';
+import '@jetbrains/icons/warning';
+import '@jetbrains/icons/close';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import '../global/memoize.js';
+import '../loader-inline/loader-inline.js';
+import '../global/theme.js';
+import '../global/data-tests.js';
+import '../_helpers/inject-styles.js';
+import '../global/conic-gradient.js';
+import 'conic-gradient';
+import '../global/supports-css.js';
+import '../global/inject-styles.js';
+import '../global/radial-gradient-mask.js';
+import '../global/dom.js';
+import '../alert/container.js';
+import '../link/link.js';
+import 'focus-visible';
+import '../link/clickableLink.js';
+import '../_helpers/link.js';
+import '../group/group.js';
+import '../_helpers/group.js';
+import '../global/listeners.js';
+import '../global/promise-with-timeout.js';
+import '../auth/storage.js';
+import '../storage/storage.js';
+import '../storage/storage__local.js';
+import '../storage/storage__fallback.js';
+import 'deep-equal';
+import '../auth/request-builder.js';
+import 'simply-uuid';
+import '../auth/background-flow.js';
+import '../auth/token-validator.js';
+import '@jetbrains/icons/services-20px';
+import '../dropdown/dropdown.js';
+import '../_helpers/anchor.js';
+import '@jetbrains/icons/chevron-10px';
+import '../button/button.js';
+import '../_helpers/button__classes.js';
+import '../popup/popup.js';
+import '../global/schedule-raf.js';
+import '../shortcuts/shortcuts.js';
+import '../shortcuts/core.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../tab-trap/tab-trap.js';
+import '../popup/position.js';
+import '../popup/popup.consts.js';
+import '../popup/popup.target.js';
+import './tray-icon.js';
+import '../_helpers/header.js';
+import '../_helpers/services-link.js';
+
+function noop() {}
+
+class SmartServices extends Component {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "state", {
+      visible: true,
+      loading: false,
+      services: null
+    });
+
+    _defineProperty(this, "stopLoading", () => {
+      this.setState({
+        loading: false
+      });
+    });
+
+    _defineProperty(this, "getServicesContent", () => {
+      this.setState({
+        loading: true
+      });
+      this.getServices(SmartServices.allFields).then(services => {
+        this.setState({
+          services
+        });
+        this.stopLoading();
+      }).catch(this.stopLoading);
+    });
+  }
+
+  componentDidMount() {
+    const {
+      auth
+    } = this.props;
+    this.http = new HTTP(auth, auth.getAPIPath());
+    this.getServices(SmartServices.countFields).then(services => {
+      if (!services.length) {
+        this.setState({
+          visible: false
+        });
+      }
+    }).catch(noop);
+  }
+
+  getServices(fields) {
+    return this.http.get(`services/header?fields=${fields}`);
+  }
+
+  render() {
+    const {
+      services,
+      visible,
+      loading
+    } = this.state;
+    const {
+      auth,
+      ...props
+    } = this.props;
+
+    if (!visible) {
+      return null;
+    }
+
+    return /*#__PURE__*/React.createElement(Services, _extends({}, props, {
+      clientId: auth.config.clientId,
+      initShown: true,
+      loading: loading,
+      onClick: this.getServicesContent,
+      services: services
+    }));
+  }
+
+}
+
+_defineProperty(SmartServices, "propTypes", {
+  auth: PropTypes.instanceOf(Auth).isRequired
+});
+
+_defineProperty(SmartServices, "allFields", 'id,name,applicationName,homeUrl,iconUrl');
+
+_defineProperty(SmartServices, "countFields", 'key');
+
+export { SmartServices as default };

package/dist/header/tray-icon.js

@@ -0,0 +1,45 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import Button from '../button/button.js';
+import { m as modules_47759f5e } from '../_helpers/header.js';
+import 'focus-visible';
+import '@jetbrains/icons/chevron-10px';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import '../global/memoize.js';
+import '../global/theme.js';
+import '../link/clickableLink.js';
+import '../_helpers/button__classes.js';
+
+class TrayIcon extends Component {
+  render() {
+    const {
+      className,
+      rotatable: rotatable,
+      ...restProps
+    } = this.props;
+    const classes = classNames(modules_47759f5e.icon, className, {
+      [modules_47759f5e.rotatable]: rotatable,
+      [modules_47759f5e.rotated]: rotatable && restProps.active
+    });
+    return /*#__PURE__*/React.createElement(Button, _extends({}, restProps, {
+      className: classes
+    }));
+  }
+
+}
+
+_defineProperty(TrayIcon, "propTypes", { ...Button.propTypes,
+  icon: PropTypes.oneOfType([PropTypes.string, PropTypes.elementType]).isRequired,
+  rotatable: PropTypes.bool
+});
+
+_defineProperty(TrayIcon, "defaultProps", { ...Button.defaultProps
+});
+
+export { TrayIcon as default };

package/dist/header/tray.js

@@ -0,0 +1,31 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { Component, Children } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { m as modules_47759f5e } from '../_helpers/header.js';
+
+const wrapChild = child => child && /*#__PURE__*/React.createElement("div", {
+  className: modules_47759f5e.trayItem
+}, child);
+
+class Tray extends Component {
+  render() {
+    const {
+      children,
+      className,
+      ...restProps
+    } = this.props;
+    const classes = classNames(modules_47759f5e.tray, className);
+    return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+      className: classes
+    }), Children.map(children, wrapChild));
+  }
+
+}
+
+_defineProperty(Tray, "propTypes", {
+  className: PropTypes.string,
+  children: PropTypes.node
+});
+
+export { Tray as default };

package/dist/heading/heading.js

@@ -0,0 +1,73 @@
+import { a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { memo } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import deprecate from 'util-deprecate';
+
+var modules_901b77ec = {"heading":"heading_rui_5ab5 font_rui_750f","caps":"caps_rui_5ab5"};
+
+/**
+ * @name Heading
+ */
+
+const Levels = {
+  H1: 1,
+  H2: 2,
+  H3: 3,
+  H4: 4
+};
+const fallbackHeading = deprecate(() => 'h3', 'Headings of level 5 and higher are replaced with h3');
+const Heading = /*#__PURE__*/memo(function Heading(_ref) {
+  let {
+    children,
+    className,
+    level,
+    ...restProps
+  } = _ref;
+  const classes = classNames(modules_901b77ec.heading, className);
+  const Tag = level <= Levels.H4 ? `h${level}` : fallbackHeading();
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, restProps, {
+    className: classes
+  }), children);
+});
+Heading.propTypes = {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  level: PropTypes.number
+};
+Heading.defaultProps = {
+  level: Levels.H1
+};
+Heading.Levels = Levels;
+
+function makeHeading(level, useCaps) {
+  const H = /*#__PURE__*/memo(_ref2 => {
+    let {
+      className,
+      caps,
+      ...restProps
+    } = _ref2;
+    const classes = classNames(className, {
+      [modules_901b77ec.caps]: useCaps && caps
+    });
+    return /*#__PURE__*/React.createElement(Heading, _extends({}, restProps, {
+      level: level,
+      className: classes
+    }));
+  });
+  H.displayName = `H${level}`;
+  H.propTypes = {
+    children: PropTypes.node,
+    className: PropTypes.string,
+    // use only for short h1 headers, no longer than three words
+    caps: PropTypes.bool
+  };
+  return H;
+}
+
+const H1 = makeHeading(Levels.H1, true);
+const H2 = makeHeading(Levels.H2);
+const H3 = makeHeading(Levels.H3);
+const H4 = makeHeading(Levels.H4);
+
+export { H1, H2, H3, H4, Heading as default };

package/dist/http/http.js

@@ -0,0 +1,216 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import ExtendableError from 'es6-error';
+import { encodeURL, joinBaseURLAndPath } from '../global/url.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(`${response.status} ${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, {
+      method: 'GET',
+      ...params
+    }));
+
+    _defineProperty(this, "post", (url, params) => this.request(url, {
+      method: 'POST',
+      ...params
+    }));
+
+    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: `${TOKEN_TYPE} ${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,65 @@
+import HTTP from './http.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'es6-error';
+import '../global/url.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 };