@jetbrains/ring-ui 4.1.4 → 5.0.0-beta.1

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

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