@jetbrains/ring-ui 4.1.12 → 5.0.0-beta.11

package/components/header/tray.js

@@ -1,30 +1,18 @@
-import React, {Children, Component} from 'react';
+import React, { Children, Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
-
 import styles from './header.css';
-
-const wrapChild = child => child && (
-  <div className={styles.trayItem}>{child}</div>
-);
-
+const wrapChild = (child) => child && (<div className={styles.trayItem}>{child}</div>);
 export default class Tray extends Component {
-  static propTypes = {
-    className: PropTypes.string,
-    children: PropTypes.node
-  };
-
-  render() {
-    const {children, className, ...restProps} = this.props;
-    const classes = classNames(styles.tray, className);
-
-    return (
-      <div
-        {...restProps}
-        className={classes}
-      >
+    static propTypes = {
+        className: PropTypes.string,
+        children: PropTypes.node
+    };
+    render() {
+        const { children, className, ...restProps } = this.props;
+        const classes = classNames(styles.tray, className);
+        return (<div {...restProps} className={classes}>
         {Children.map(children, wrapChild)}
-      </div>
-    );
-  }
+      </div>);
+    }
 }

package/components/heading/heading.css

@@ -13,13 +13,16 @@
     margin-bottom: 8px;
 
     color: var(--ring-heading-color);
+  }
 
+  @nest h1& {
     font-size: 24px;
     line-height: 28px;
   }
 
   @nest h2& {
-    font-weight: 200;
+    font-size: 20px;
+    line-height: 24px;
   }
 
   @nest h3& {

package/components/heading/heading.d.ts

@@ -0,0 +1,25 @@
+import React, { HTMLAttributes } from 'react';
+/**
+ * @name Heading
+ */
+export declare enum Levels {
+    H1 = 1,
+    H2 = 2,
+    H3 = 3,
+    H4 = 4
+}
+export interface HeadingProps extends HTMLAttributes<HTMLHeadingElement> {
+    level?: Levels | undefined;
+}
+declare const Heading: React.ComponentType<HeadingProps> & {
+    Levels: typeof Levels;
+};
+export default Heading;
+export interface H1Props extends HTMLAttributes<HTMLHeadingElement> {
+    caps?: boolean | null | undefined;
+}
+declare const H1: React.ComponentType<H1Props>;
+declare const H2: React.ComponentType<React.HTMLAttributes<HTMLHeadingElement>>;
+declare const H3: React.ComponentType<React.HTMLAttributes<HTMLHeadingElement>>;
+declare const H4: React.ComponentType<React.HTMLAttributes<HTMLHeadingElement>>;
+export { H1, H2, H3, H4 };

package/components/heading/heading.js

@@ -1,82 +1,52 @@
-import React, {memo} from 'react';
+import React, { memo } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import deprecate from 'util-deprecate';
-
 import styles from './heading.css';
-
 /**
  * @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 = memo(function Heading({children, className, level, ...restProps}) {
-  const classes = classNames(styles.heading, className);
-
-  const Tag = level <= Levels.H4 ? `h${level}` : fallbackHeading();
-
-  return (
-    <Tag
-      {...restProps}
-      className={classes}
-    >
-      {children}
-    </Tag>
-  );
+export var Levels;
+(function (Levels) {
+    Levels[Levels["H1"] = 1] = "H1";
+    Levels[Levels["H2"] = 2] = "H2";
+    Levels[Levels["H3"] = 3] = "H3";
+    Levels[Levels["H4"] = 4] = "H4";
+})(Levels || (Levels = {}));
+const fallbackHeading = deprecate(() => 'h3', 'Headings of level 5 and higher are replaced with h3');
+const HeadingMemo = memo(function Heading({ children, className, level = Levels.H1, ...restProps }) {
+    const classes = classNames(styles.heading, className);
+    const Tag = level <= Levels.H4 ? `h${level}` : fallbackHeading();
+    return (<Tag {...restProps} className={classes}>
+        {children}
+      </Tag>);
 });
-
+const Heading = HeadingMemo;
 Heading.propTypes = {
-  children: PropTypes.node,
-  className: PropTypes.string,
-  level: PropTypes.number
-};
-
-Heading.defaultProps = {
-  level: Levels.H1
+    children: PropTypes.node,
+    className: PropTypes.string,
+    level: PropTypes.oneOf([Levels.H1, Levels.H2, Levels.H3, Levels.H4])
 };
-
 Heading.Levels = Levels;
-
 export default Heading;
-
 function makeHeading(level, useCaps) {
-  const H = memo(({className, caps, ...restProps}) => {
-    const classes = classNames(className, {
-      [styles.caps]: useCaps && caps
+    const H = memo(({ className, caps, ...restProps }) => {
+        const classes = classNames(className, {
+            [styles.caps]: useCaps && caps
+        });
+        return (<Heading {...restProps} level={level} className={classes}/>);
     });
-
-    return (
-      <Heading
-        {...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;
+    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};
+export { H1, H2, H3, H4 };

package/components/http/http.d.ts

@@ -0,0 +1,49 @@
+import ExtendableError from 'es6-error';
+export declare const defaultFetchConfig: RequestInit;
+export interface HTTPErrorData {
+    error?: string;
+}
+export declare class HTTPError extends ExtendableError {
+    data: HTTPErrorData;
+    status: number | undefined;
+    constructor(response: Partial<Response>, data?: HTTPErrorData);
+}
+export declare const CODE: {
+    UNAUTHORIZED: number;
+};
+export interface FetchParams<T = unknown> extends Omit<RequestInit, 'body'> {
+    body?: T;
+    query?: Record<string, unknown> | undefined;
+}
+export declare type RequestParams = FetchParams & {
+    sendRawBody?: false;
+} | FetchParams<BodyInit | null> & {
+    sendRawBody: true;
+};
+export interface HTTPAuth {
+    requestToken(): Promise<string | null> | string | null;
+    forceTokenUpdate(): Promise<string | null>;
+}
+export default class HTTP implements Partial<HTTPAuth> {
+    baseUrl: string | null | undefined;
+    _requestsMeta: WeakMap<object, Partial<Response>>;
+    fetchConfig: RequestInit;
+    requestToken?: () => Promise<string | null> | string | null;
+    shouldRefreshToken?: (error: string) => boolean;
+    forceTokenUpdate?: () => Promise<string | null>;
+    constructor(auth?: HTTPAuth, baseUrl?: string | null | undefined, fetchConfig?: RequestInit);
+    setAuth: (auth: HTTPAuth) => void;
+    setBaseUrl: (baseUrl: string | null | undefined) => void;
+    _fetch(...args: Parameters<typeof fetch>): Promise<Response> | Partial<Response>;
+    private _makeRequestUrl;
+    private _performRequest;
+    private _storeRequestMeta;
+    private _processResponse;
+    private static _isErrorStatus;
+    fetch: (url: string, params?: FetchParams) => Promise<any>;
+    authorizedFetch(...args: Parameters<HTTP['_performRequest']>): Promise<any>;
+    request: (url: string, params?: RequestParams | undefined) => Promise<any>;
+    getMetaForResponse: (response: object) => Partial<Response> | undefined;
+    get: (url: string, params?: RequestParams | undefined) => Promise<any>;
+    post: (url: string, params?: RequestParams | undefined) => Promise<any>;
+}

package/components/http/http.js

@@ -1,196 +1,166 @@
 import ExtendableError from 'es6-error';
-
-import {encodeURL, joinBaseURLAndPath} from '../global/url';
-
+import { encodeURL, joinBaseURLAndPath } from '../global/url';
 /**
  * @name HTTP
  */
-
 const TOKEN_TYPE = 'Bearer';
 const STATUS_OK_IF_MORE_THAN = 200;
 const STATUS_BAD_IF_MORE_THAN = 300;
-
 export const defaultFetchConfig = {
-  headers: {
-    'Content-Type': 'application/json',
-    Accept: 'application/json'
-  },
-  credentials: 'same-origin'
+    headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+    },
+    credentials: 'same-origin'
 };
-
 export class HTTPError extends ExtendableError {
-  constructor(response, data = {}) {
-    super(`${response.status} ${response.statusText || ''}`);
-    this.data = data;
-    this.status = response.status;
-  }
+    data;
+    status;
+    constructor(response, data = {}) {
+        super(`${response.status} ${response.statusText || ''}`);
+        this.data = data;
+        this.status = response.status;
+    }
 }
-
 export const CODE = {
-  UNAUTHORIZED: 401
+    UNAUTHORIZED: 401
 };
-
 export default class HTTP {
-  baseUrl = null;
-  _requestsMeta = new WeakMap();
-
-  constructor(auth, baseUrl, fetchConfig = {}) {
-    if (auth) {
-      this.setAuth(auth);
+    baseUrl = null;
+    _requestsMeta = new WeakMap();
+    fetchConfig;
+    requestToken;
+    shouldRefreshToken;
+    forceTokenUpdate;
+    constructor(auth, baseUrl, fetchConfig = {}) {
+        if (auth) {
+            this.setAuth(auth);
+        }
+        this.setBaseUrl(baseUrl);
+        const { headers, ...defaultConfig } = defaultFetchConfig;
+        this.fetchConfig = {
+            ...defaultConfig,
+            ...fetchConfig,
+            headers: {
+                ...headers,
+                ...fetchConfig.headers
+            }
+        };
     }
-    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();
     };
-  }
-
-  setAuth = auth => {
-    this.requestToken = () => auth.requestToken();
-    this.shouldRefreshToken = auth.constructor.shouldRefreshToken;
-    this.forceTokenUpdate = () => auth.forceTokenUpdate();
-  };
-
-  setBaseUrl = baseUrl => {
-    this.baseUrl = baseUrl;
-  };
-
-  _fetch(...args) {
-    return fetch(...args);
-  }
-
-  _makeRequestUrl(url, queryObject) {
-    const urlWithQuery = encodeURL(url, queryObject);
-    return joinBaseURLAndPath(this.baseUrl, urlWithQuery);
-  }
-
-  _performRequest(url, token, params = {}) {
-    const {headers, body, query = {}, sendRawBody, ...fetchConfig} = params;
-
-    const combinedHeaders = {
-      ...this.fetchConfig.headers,
-      ...(token ? {Authorization: `${TOKEN_TYPE} ${token}`} : {}),
-      ...headers
+    setBaseUrl = (baseUrl) => {
+        this.baseUrl = baseUrl;
     };
-
-    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);
+    _fetch(...args) {
+        return fetch(...args);
+    }
+    _makeRequestUrl(url, queryObject) {
+        const urlWithQuery = encodeURL(url, queryObject);
+        return joinBaseURLAndPath(this.baseUrl, urlWithQuery);
+    }
+    _performRequest(url, token, params = {}) {
+        const { headers, body, query = {}, sendRawBody, ...fetchConfig } = params;
+        const combinedHeaders = {
+            ...this.fetchConfig.headers,
+            ...(token ? { Authorization: `${TOKEN_TYPE} ${token}` } : {}),
+            ...headers
+        };
+        Object.entries(combinedHeaders).forEach(([key, header]) => {
+            if (header === null || header === undefined) {
+                Reflect.deleteProperty(combinedHeaders, key);
+            }
+        });
+        let bodyToSend;
+        if (params.sendRawBody) {
+            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
+        });
+    }
+    _storeRequestMeta(parsedResponse, rawResponse) {
+        const { headers, ok, redirected, status, statusText, type, url } = rawResponse;
+        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;
+    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);
+        }
+        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;
-  }
-
-  fetch = async (url, params = {}) => {
-    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);
-  };
-
-  async authorizedFetch(...args) {
-    const response = await this._performRequest(...args);
-
-    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;
-      }
-
-      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);
-
+    static _isErrorStatus(status) {
+        return status < STATUS_OK_IF_MORE_THAN || status >= STATUS_BAD_IF_MORE_THAN;
+    }
+    fetch = async (url, params = {}) => {
+        const { body, query = {}, ...fetchConfig } = params;
+        const response = await this._fetch(this._makeRequestUrl(url, query), {
+            ...fetchConfig,
+            body: body !== null && body !== undefined && body !== '' ? JSON.stringify(body) : body
+        });
+        return this._processResponse(response);
+    };
+    async authorizedFetch(...args) {
+        const response = await this._performRequest(...args);
         return this._processResponse(response);
-      }
-
-      throw error;
     }
-  };
-
-  getMetaForResponse = response => this._requestsMeta.get(response);
-
-  get = (url, params) => (
-    this.request(url, {
-      method: 'GET',
-      ...params
-    })
-  );
-
-  post = (url, params) => (
-    this.request(url, {
-      method: 'POST',
-      ...params
-    })
-  );
+    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;
+        }
+    };
+    getMetaForResponse = (response) => this._requestsMeta.get(response);
+    get = (url, params) => (this.request(url, {
+        method: 'GET',
+        ...params
+    }));
+    post = (url, params) => (this.request(url, {
+        method: 'POST',
+        ...params
+    }));
 }

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[];
+}