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

package/components/http/http.mock.js

@@ -1,62 +1,52 @@
-
 import HTTP from './http';
-
 const authMock = {
-  requestToken: () => 'mock token',
-  shouldRefreshToken: () => false,
-  forceTokenUpdate: async () => {}
+    requestToken: () => 'mock token',
+    shouldRefreshToken: () => false,
+    forceTokenUpdate: () => Promise.resolve(null)
 };
-
 export default 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);
-      }
+    defaultResponse;
+    requests;
+    responsesByUrlMap;
+    constructor() {
+        super(authMock);
+        this.defaultResponse = null;
+        this.requests = [];
+        this.responsesByUrlMap = new Map();
+    }
+    _fetch(url, params) {
+        this.requests = [...this.requests, {
+                url,
+                params: {
+                    ...params,
+                    body: typeof params.body === 'string' ? JSON.parse(params.body) : params.body
+                }
+            }];
+        return {
+            status: 200,
+            headers: new Headers({ 'content-type': 'application/json' }),
+            json: () => Promise.resolve((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 instanceof RegExp && url.test(urlToMatch)) {
+                return this.responsesByUrlMap.get(url);
+            }
+        }
+        return null;
+    }
+    getRequestsByUrlPart(url) {
+        return this.requests.filter(it => it.url.indexOf(url) !== -1);
     }
-
-    return null;
-  }
-
-  getRequestsByUrlPart(url) {
-    return this.requests.filter(it => it.url.indexOf(url) !== -1);
-  }
 }

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

@@ -0,0 +1,42 @@
+import Auth from '../auth/auth';
+import HTTP from '../http/http';
+export interface Item {
+    name: string;
+}
+export declare 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(queryParams?: Record<string, unknown>): Promise<any>;
+    makeCachedRequest(params?: Record<string, unknown>): Promise<any>;
+    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<any>;
+    doClientSideSearch(params?: Record<string, unknown>): Promise<any>;
+    doServerSideSearch(params?: Record<string, unknown>, query?: string): Promise<any>;
+    getValueFromSuitableSource(query?: string, params?: Record<string, unknown>): Promise<any>;
+    get(query: string, params: Record<string, unknown>, filterFn?: (item: I) => boolean): Promise<I[]>;
+}

package/components/hub-source/hub-source.js

@@ -1,9 +1,8 @@
 const defaultOptions = {
-  searchMax: 20,
-  searchSideThreshold: 100,
-  queryFormatter: query => `${query} or ${query}*`
+    searchMax: 20,
+    searchSideThreshold: 100,
+    queryFormatter: query => `${query} or ${query}*`
 };
-
 /**
  * HubSource is designed to speed up search requests for small installations.
  * If there are less than "searchSideThreshold" items, it uses client-side filtering
@@ -11,113 +10,98 @@ const defaultOptions = {
  * select data source.
  */
 export default class HubSource {
-  static TOP_ALL = -1;
-
-  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;
+    static TOP_ALL = -1;
+    http;
+    relativeUrl;
+    options;
+    storedData;
+    isClientSideSearch;
+    filterFn;
+    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 = () => true;
     }
-    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;
+    makeRequest(queryParams) {
+        return this.http.get(this.relativeUrl, { query: queryParams });
     }
-    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');
+    async makeCachedRequest(params) {
+        if (this.storedData) {
+            return this.storedData;
+        }
+        const res = await this.makeRequest(params);
+        this.storedData = res;
+        return res;
     }
-    if (params.query) {
-      throw new Error('HubSource: params.query should not be filled, configure "options.queryFormatter" instead');
+    static mergeParams(params, toMerge) {
+        return Object.assign({}, params, toMerge);
     }
-  }
-
-  processResults(res) {
-    const items = res[this.relativeUrl] || [];
-
-    if (this.isClientSideSearch) {
-      return items.
-        filter(it => this.filterFn(it)).
-        slice(0, this.options.searchMax);
+    checkIsClientSideSearch(res) {
+        return res.total <= this.options.searchSideThreshold;
     }
-    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);
+    getDefaultFilterFn(query) {
+        if (!query) {
+            return () => true;
+        }
+        return (it) => it.name.toLowerCase().indexOf(query.toLowerCase()) !== -1;
     }
-
-    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);
+    formatQuery(query) {
+        return query ? this.options.queryFormatter(query) : '';
     }
-
-    if (this.isClientSideSearch) {
-      return this.doClientSideSearch(params);
+    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);
     }
-
-    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);
-  }
 }

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

@@ -0,0 +1,4 @@
+import Auth, { AuthUser } from '../auth/auth';
+import { UserCardUser } from '../user-card/card';
+export declare function convertUserForCard(hubUser: AuthUser, serverUri?: string): UserCardUser;
+export declare function createHubUserCardSource(auth: Auth, userId: string | number, fields?: string): () => Promise<UserCardUser>;

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

@@ -1,27 +1,20 @@
 import HTTP from '../http/http';
-
 const DEFAULT_FIELDS = 'id,name,login,banned,banReason,profile(email/email,avatar/url)';
-
 export function convertUserForCard(hubUser, serverUri = '') {
-  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: `${serverUri}users/${hubUser.id}`
-  };
+    return {
+        name: hubUser.name,
+        login: hubUser.login,
+        banned: hubUser.banned,
+        banReason: hubUser.banReason,
+        email: hubUser.profile?.email?.email,
+        avatarUrl: hubUser.profile?.avatar?.url,
+        href: `${serverUri}users/${hubUser.id}`
+    };
 }
-
 export function createHubUserCardSource(auth, userId, fields = DEFAULT_FIELDS) {
-  const http = new HTTP(auth);
-
-  return async function getHubUser() {
-    const hubUser = await http.get(
-      `${auth.config.serverUri}api/rest/users/${userId}?fields=${fields}`
-    );
-
-    return convertUserForCard(hubUser, auth.config.serverUri);
-  };
+    const http = new HTTP(auth);
+    return async function getHubUser() {
+        const hubUser = await http.get(`${auth.config.serverUri}api/rest/users/${userId}?fields=${fields}`);
+        return convertUserForCard(hubUser, auth.config.serverUri);
+    };
 }

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

@@ -0,0 +1,24 @@
+import Auth, { AuthUser } from '../auth/auth';
+import HubSource, { Item } from './hub-source';
+export interface HubSourceUsersGroupsOptions {
+    searchMax: number;
+    searchSideThreshold: number;
+}
+export interface UserGroup extends Item {
+    id: number;
+    total?: number;
+    userCount: number;
+    iconUrl?: string;
+}
+export default class HubSourceUsersGroups {
+    auth: Auth;
+    options: HubSourceUsersGroupsOptions;
+    usersSource: HubSource<AuthUser, 'users'>;
+    groupsSource: HubSource<UserGroup, 'usergroups'>;
+    constructor(auth: Auth, options?: Partial<HubSourceUsersGroupsOptions>);
+    static wrapMultiwordQuery(query?: string): string | undefined;
+    createUsersFilterFn(query?: string): (it: AuthUser) => boolean;
+    getUsers(query?: string): Promise<AuthUser[]>;
+    getGroups(query?: string): Promise<UserGroup[]>;
+    getUserAndGroups(query?: string): Promise<[AuthUser[], UserGroup[]]>;
+}

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

@@ -1,60 +1,53 @@
 import HubSource from './hub-source';
-
 const defaultOptions = {
-  searchMax: 20,
-  searchSideThreshold: 200
+    searchMax: 20,
+    searchSideThreshold: 200
 };
-
 export default 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: ${HubSourceUsersGroups.wrapMultiwordQuery(query)} or loginStartsWith: ${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 `{${query}}`;
+    auth;
+    options;
+    usersSource;
+    groupsSource;
+    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: ${HubSourceUsersGroups.wrapMultiwordQuery(query)} or loginStartsWith: ${HubSourceUsersGroups.wrapMultiwordQuery(query)}`
+        });
+        this.groupsSource = new HubSource(auth, 'usergroups', {
+            searchMax: this.options.searchMax,
+            searchSideThreshold: this.options.searchSideThreshold
+        });
     }
-    return query;
-  }
-
-  createUsersFilterFn(query) {
-    if (!query) {
-      return () => true;
+    static wrapMultiwordQuery(query) {
+        if (query && query.indexOf(' ') !== -1) {
+            return `{${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(query = '') {
+        return this.usersSource.get(query, {
+            fields: 'id,name,login,total,profile/avatar/url',
+            orderBy: 'name'
+        }, this.createUsersFilterFn(query));
+    }
+    getGroups(query = '') {
+        return this.groupsSource.get(query, {
+            fields: 'id,name,total,userCount,iconUrl',
+            orderBy: 'name'
+        });
+    }
+    getUserAndGroups(query) {
+        return Promise.all([this.getUsers(query), this.getGroups(query)]);
     }
-    const normalizedQuery = query.toLowerCase();
-
-    return it => (
-      it.name.toLowerCase().indexOf(normalizedQuery) !== -1 ||
-      it.login.toLowerCase().indexOf(normalizedQuery) !== -1
-    );
-  }
-
-  getUsers(query = '') {
-    return this.usersSource.get(query, {
-      fields: 'id,name,login,total,profile/avatar/url',
-      orderBy: 'name'
-    }, this.createUsersFilterFn(query));
-  }
-
-  getGroups(query = '') {
-    return this.groupsSource.get(query, {
-      fields: 'id,name,total,userCount,iconUrl',
-      orderBy: 'name'
-    });
-  }
-
-  getUserAndGroups(query) {
-    return Promise.all([this.getUsers(query), this.getGroups(query)]);
-  }
 }

package/components/icon/icon.css

@@ -76,7 +76,7 @@
 }
 
 .white {
-  color: var(--ring-dark-text-color);
+  color: var(--ring-white-text-color);
 }
 
 .loading {

package/components/icon/icon.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @name Icon
+ */
+import { PureComponent, ComponentType, SVGAttributes, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+import { Color, Size } from './icon__constants';
+export declare type IconType = ComponentType<SVGAttributes<SVGSVGElement>>;
+export interface IconProps extends HTMLAttributes<HTMLElement> {
+    color: Color;
+    glyph: string | IconType | null;
+    height?: number | undefined;
+    size?: Size | null | undefined;
+    width?: number | undefined;
+    loading?: boolean | null | undefined;
+    suppressSizeWarning?: boolean | null | undefined;
+}
+export default class Icon extends PureComponent<IconProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        color: PropTypes.Requireable<string>;
+        glyph: PropTypes.Validator<PropTypes.ReactComponentLike>;
+        height: PropTypes.Requireable<number>;
+        size: PropTypes.Requireable<number>;
+        width: PropTypes.Requireable<number>;
+        loading: PropTypes.Requireable<boolean>;
+        suppressSizeWarning: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        className: string;
+        color: Color;
+        glyph: string;
+    };
+    static Color: typeof Color;
+    static Size: typeof Size;
+    warnSize(): void;
+    getStyle(): {
+        width: number | undefined;
+        height: number | undefined;
+    } | undefined;
+    render(): JSX.Element | null;
+}
+export declare type IconAttrs = JSX.LibraryManagedAttributes<typeof Icon, IconProps>;
+export { Color, Size };