@jetbrains/ring-ui 4.1.3 → 5.0.0-beta.0

package/dist/auth/background-flow.d.ts

@@ -0,0 +1,31 @@
+import AuthRequestBuilder from './request-builder';
+import AuthStorage from './storage';
+export declare const HUB_AUTH_PAGE_OPENED = "HUB_AUTH_PAGE_OPENED";
+export default class BackgroundFlow {
+    _requestBuilder: AuthRequestBuilder;
+    _storage: AuthStorage;
+    _timeout: number;
+    private _promise?;
+    constructor(requestBuilder: AuthRequestBuilder, storage: AuthStorage, timeout: number);
+    /**
+     * Creates a hidden iframe
+     * @return {HTMLIFrameElement}
+     * @private
+     */
+    private _createHiddenFrame;
+    /**
+     * Redirects the given iframe to the given URL
+     * @param {HTMLIFrameElement} iframe
+     * @param {string} url
+     * @private
+     */
+    _redirectFrame(iframe: HTMLIFrameElement, url: string): void;
+    /**
+     * Refreshes the access token in an iframe.
+     *
+     * @return {Promise.<string>} promise that is resolved to access the token when it is loaded in a background iframe. The
+     * promise is rejected if no token was received after {@link BackgroundToken.BACKGROUND_TIMEOUT} ms.
+     */
+    private _load;
+    authorize(): Promise<string>;
+}

package/dist/auth/background-flow.js

@@ -1,11 +1,19 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
 import AuthResponseParser from './response-parser.js';
-import '../_helpers/_rollupPluginBabelHelpers.js';
 import 'es6-error';
 import '../global/url.js';
 
 const HUB_AUTH_PAGE_OPENED = 'HUB_AUTH_PAGE_OPENED';
 class BackgroundFlow {
   constructor(requestBuilder, storage, timeout) {
+    _defineProperty(this, "_requestBuilder", void 0);
+
+    _defineProperty(this, "_storage", void 0);
+
+    _defineProperty(this, "_timeout", void 0);
+
+    _defineProperty(this, "_promise", void 0);
+
     this._requestBuilder = requestBuilder;
     this._storage = storage;
     this._timeout = timeout;

package/dist/auth/down-notification.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+export interface BackendDownTranslations {
+    backendIsNotAvailable: string;
+    checkAgain: string;
+    errorMessage: string;
+}
+export interface BackendDownMessageProps {
+    translations: BackendDownTranslations;
+    onCheckAgain: (e: React.MouseEvent) => void;
+}
+export interface OnBackendDownParams {
+    translations: BackendDownTranslations;
+    onCheckAgain: () => void;
+}
+export default function onBackendDown({ onCheckAgain, translations }: OnBackendDownParams): () => void;

package/dist/auth/iframe-flow.d.ts

@@ -0,0 +1,20 @@
+import { AuthTranslations, LoginFlow } from './auth__core';
+import AuthRequestBuilder from './request-builder';
+import AuthStorage from './storage';
+export default class IFrameFlow implements LoginFlow {
+    hideDialog: (() => void) | null;
+    private _requestBuilder;
+    private _storage;
+    private _translations;
+    reject?: (reason: unknown) => void;
+    private _promise?;
+    private _loginWindow?;
+    constructor(requestBuilder: AuthRequestBuilder, storage: AuthStorage, translations: AuthTranslations);
+    /**
+     * Initiates authorization in window
+     */
+    private _load;
+    _reset: () => void;
+    stop(): void;
+    authorize(): Promise<string>;
+}

package/dist/auth/iframe-flow.js

@@ -54,6 +54,18 @@ class IFrameFlow {
   constructor(requestBuilder, storage, translations) {
     _defineProperty(this, "hideDialog", null);
 
+    _defineProperty(this, "_requestBuilder", void 0);
+
+    _defineProperty(this, "_storage", void 0);
+
+    _defineProperty(this, "_translations", void 0);
+
+    _defineProperty(this, "reject", void 0);
+
+    _defineProperty(this, "_promise", void 0);
+
+    _defineProperty(this, "_loginWindow", void 0);
+
     _defineProperty(this, "_reset", () => {
       this._promise = null;
       this.hideDialog = null;
@@ -89,7 +101,7 @@ class IFrameFlow {
         url: authRequest.url,
         loader: true,
         onCancel: () => {
-          // eslint-disable-next-line no-use-before-define
+          // eslint-disable-next-line @typescript-eslint/no-use-before-define
           cleanUp();
           this.stop();
         },
@@ -99,7 +111,7 @@ class IFrameFlow {
 
       const removeTokenListener = this._storage.onTokenChange(token => {
         if (token) {
-          // eslint-disable-next-line no-use-before-define
+          // eslint-disable-next-line @typescript-eslint/no-use-before-define
           cleanUp();
           resolve(token.accessToken);
         }
@@ -107,14 +119,16 @@ class IFrameFlow {
 
       const removeStateListener = this._storage.onStateChange(authRequest.stateId, state => {
         if (state && state.error) {
-          // eslint-disable-next-line no-use-before-define
+          // eslint-disable-next-line @typescript-eslint/no-use-before-define
           cleanUp();
           reject(new AuthResponseParser.AuthError(state));
         }
       });
 
       const cleanUp = () => {
-        this.hideDialog();
+        var _this$hideDialog;
+
+        (_this$hideDialog = this.hideDialog) === null || _this$hideDialog === void 0 ? void 0 : _this$hideDialog.call(this);
         removeStateListener();
         removeTokenListener();
       };
@@ -134,7 +148,7 @@ class IFrameFlow {
   }
 
   authorize() {
-    if (this._promise !== null && this._loginWindow !== null && this._loginWindow.closed !== true) {
+    if (this._promise != null && this._loginWindow != null && !this._loginWindow.closed) {
       return this._promise;
     }
 

package/dist/auth/landing-entry.d.ts

@@ -0,0 +1,3 @@
+import '!!file-loader?publicPath=../../&name=auth-landing.html!extricate-loader!interpolate-loader!./landing.html';
+declare const _default: "auth-landing.html";
+export default _default;

package/dist/auth/landing.d.ts

@@ -0,0 +1,2 @@
+import Auth from './auth';
+export default function parseAndStoreResponse(this: Auth, clientId: string): Promise<void>;

package/dist/auth/landing.js

@@ -54,8 +54,11 @@ import 'simply-uuid';
 import './background-flow.js';
 
 const parser = new AuthResponseParser();
-const authResponse = parser.getAuthResponseFromURL();
+const authResponse = parser.getAuthResponseFromURL(); // eslint-disable-next-line consistent-this
+
 async function parseAndStoreResponse(clientId) {
+  var _this$_storage;
+
   const storage = new AuthStorage({
     messagePrefix: `${clientId}-message-`,
     stateKeyPrefix: `${clientId}-states-`,
@@ -73,15 +76,18 @@ async function parseAndStoreResponse(clientId) {
     expiresIn,
     accessToken
   } = authResponse;
-  const newState = (await (stateId && this._storage.getState(stateId))) || {};
+  const newState = (await (stateId && ((_this$_storage = this._storage) === null || _this$_storage === void 0 ? void 0 : _this$_storage.getState(stateId)))) || {};
   const scopes = scope ? scope.split(' ') : newState.scopes || [];
   const effectiveExpiresIn = expiresIn ? parseInt(expiresIn, 10) : DEFAULT_EXPIRES_TIMEOUT;
   const expires = TokenValidator._epoch() + effectiveExpiresIn;
-  await storage.saveToken({
-    accessToken,
-    scopes,
-    expires
-  });
+
+  if (accessToken != null) {
+    await storage.saveToken({
+      accessToken,
+      scopes,
+      expires
+    });
+  }
 }
 
 export { parseAndStoreResponse as default };

package/dist/auth/request-builder.d.ts

@@ -0,0 +1,47 @@
+import uuid from 'simply-uuid';
+import AuthStorage, { AuthState } from './storage';
+export interface AuthRequestBuilderConfig {
+    authorization: string;
+    redirectUri?: string | null | undefined;
+    requestCredentials?: string | null | undefined;
+    clientId?: string | null | undefined;
+    scopes: readonly string[];
+    redirect?: boolean | null | undefined;
+}
+export default class AuthRequestBuilder {
+    config: AuthRequestBuilderConfig;
+    storage: AuthStorage | undefined;
+    /**
+     * @param {{
+     *   authorization: string,
+     *   redirectUri: string?,
+     *   requestCredentials: string?,
+     *   clientId: string?,
+     *   scopes: string[]
+     * }} config
+     * @param {AuthStorage} storage
+     */
+    constructor(config: AuthRequestBuilderConfig, storage?: AuthStorage);
+    /**
+     * @return {string} random string used for state
+     */
+    static _uuid: typeof uuid.generate;
+    /**
+     * Save state and build an auth server redirect URL.
+     *
+     * @param {object=} extraParams additional query parameters for auth request
+     * @param {object=} extraState additional state parameters to save
+     * @return {Promise.<string>} promise that is resolved to authURL
+     */
+    prepareAuthRequest(extraParams?: Record<string, unknown> | null | undefined, extraState?: Partial<AuthState>): Promise<{
+        url: string;
+        stateId: string;
+    }>;
+    /**
+     * @param {string} id
+     * @param {StoredState} storedState
+     * @return {Promise}
+     * @private
+     */
+    _saveState(id: string, storedState: AuthState): Promise<void> | undefined;
+}

package/dist/auth/request-builder.js

@@ -14,6 +14,10 @@ class AuthRequestBuilder {
    * @param {AuthStorage} storage
    */
   constructor(config, storage) {
+    _defineProperty(this, "config", void 0);
+
+    _defineProperty(this, "storage", void 0);
+
     this.config = config;
     this.storage = storage;
   }
@@ -65,7 +69,9 @@ class AuthRequestBuilder {
 
 
   _saveState(id, storedState) {
-    return this.storage.saveState(id, storedState);
+    var _this$storage;
+
+    return (_this$storage = this.storage) === null || _this$storage === void 0 ? void 0 : _this$storage.saveState(id, storedState);
   }
 
 }

package/dist/auth/response-parser.d.ts

@@ -0,0 +1,70 @@
+import ExtendableError from 'es6-error';
+export interface AuthResponse {
+    accessToken?: string;
+    state?: string;
+    token_type?: string;
+    expiresIn?: string;
+    scope?: string;
+    error?: string | Error;
+    errorDescription?: string;
+    errorUri?: string;
+    restoreAuthState?: string;
+}
+export declare class AuthError extends ExtendableError {
+    code: string | Error | AuthError | undefined;
+    uri: string | undefined;
+    stateId: string | undefined;
+    constructor(authResponse?: AuthResponse);
+}
+/**
+ * @typedef {Object} AuthResponse
+ * @property {?string} accessToken
+ * @property {?string} state
+ * @property {?string} token_type
+ * @property {?string} expiresIn
+ * @property {?string} scope
+ * @property {?string} error
+ */
+export default class AuthResponseParser {
+    readonly _authResponse: AuthResponse;
+    constructor();
+    static AuthError: typeof AuthError;
+    static convertKey(key: string): string;
+    /**
+     * Check if the hash contains an access token.
+     * If it does, return auth response. Otherwise return undefined.
+     * Always clears the hash part of the URL.
+     *
+     * @throws {Error} if the auth server returned an error
+     * @return {?AuthResponse}
+     */
+    getAuthResponseFromURL(): AuthResponse | null;
+    /**
+     * Validates given authResponse.
+     * If it contains a token - returns the token, if an error is found - throws the error,
+     * otherwise - null
+     * Always clears the hash part of the URL.
+     *
+     * @param authResponse {AuthResponse} parsed authResponse
+     * @throws {Error} if the auth server returned an error
+     * @return {?AuthResponse}
+     */
+    validateAuthResponse(authResponse: AuthResponse): AuthResponse | null;
+    /**
+     * Reads the current accessToken from the URL.
+     * Doesn't modify URL
+     *
+     * @return {AuthResponse}
+     */
+    readAuthResponseFromURL(): AuthResponse;
+    /**
+     * @return {string} part of the URL after # sign.
+     * @private
+     */
+    getHash(): string | null;
+    /**
+     * Current page location.
+     * @return {string}
+     */
+    getLocation(): string | null;
+}

package/dist/auth/response-parser.js

@@ -2,6 +2,24 @@ import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
 import ExtendableError from 'es6-error';
 import { parseQueryString } from '../global/url.js';
 
+class AuthError extends ExtendableError {
+  // Supports weird IE 11 failing test issue
+  constructor() {
+    let authResponse = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    super(authResponse.errorDescription);
+
+    _defineProperty(this, "code", void 0);
+
+    _defineProperty(this, "uri", void 0);
+
+    _defineProperty(this, "stateId", void 0);
+
+    this.code = authResponse.error;
+    this.uri = authResponse.errorUri;
+    this.stateId = authResponse.state;
+  }
+
+}
 /**
  * @typedef {Object} AuthResponse
  * @property {?string} accessToken
@@ -14,6 +32,8 @@ import { parseQueryString } from '../global/url.js';
 
 class AuthResponseParser {
   constructor() {
+    _defineProperty(this, "_authResponse", void 0);
+
     this._authResponse = this.readAuthResponseFromURL();
   }
 
@@ -56,7 +76,9 @@ class AuthResponseParser {
       return null;
     }
 
-    return authResponse;
+    return { ...authResponse,
+      accessToken: authResponse.accessToken
+    };
   }
   /**
    * Reads the current accessToken from the URL.
@@ -102,16 +124,6 @@ class AuthResponseParser {
 
 }
 
-_defineProperty(AuthResponseParser, "AuthError", class AuthError extends ExtendableError {
-  // Supports weird IE 11 failing test issue
-  constructor() {
-    let authResponse = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    super(authResponse.errorDescription);
-    this.code = authResponse.error;
-    this.uri = authResponse.errorUri;
-    this.stateId = authResponse.state;
-  }
-
-});
+_defineProperty(AuthResponseParser, "AuthError", AuthError);
 
-export { AuthResponseParser as default };
+export { AuthError, AuthResponseParser as default };

package/dist/auth/storage.d.ts

@@ -0,0 +1,112 @@
+import { StorageClass, StorageInterface } from '../storage/storage';
+import { AuthUser } from './auth__core';
+import { AuthResponse } from './response-parser';
+export interface StoredToken {
+    accessToken: string;
+    scopes?: string[];
+    expires?: number;
+    lifeTime?: number;
+    waitForRedirectTimeout?: number;
+}
+export interface AuthState extends AuthResponse {
+    restoreLocation?: string;
+    scopes?: string[];
+    nonRedirect?: boolean | null | undefined;
+    created?: number;
+}
+export interface AuthStorageConfig {
+    stateKeyPrefix?: string | null | undefined;
+    tokenKey?: string | null | undefined;
+    messagePrefix?: string | null | undefined;
+    userKey?: string | null | undefined;
+    stateTTL?: number | null | undefined;
+    storage?: StorageClass | null | undefined;
+    stateQuota?: number | null | undefined;
+}
+export default class AuthStorage<M = unknown> {
+    messagePrefix: string;
+    stateKeyPrefix: string;
+    tokenKey: string;
+    userKey: string;
+    stateTTL: number;
+    stateQuota: number;
+    private _lastMessage;
+    _stateStorage: StorageInterface;
+    _tokenStorage: StorageInterface;
+    _messagesStorage: StorageInterface;
+    private _currentUserStorage;
+    /**
+     * Custom storage for Auth
+     * @param {{stateKeyPrefix: string, tokenKey: string, onTokenRemove: Function}} config
+     */
+    constructor(config: AuthStorageConfig);
+    /**
+     * Add token change listener
+     * @param {function(string)} fn Token change listener
+     * @return {function()} remove listener function
+     */
+    onTokenChange(fn: (token: StoredToken | null) => void): () => void;
+    /**
+     * Add state change listener
+     * @param {string} stateKey State key
+     * @param {function(string)} fn State change listener
+     * @return {function()} remove listener function
+     */
+    onStateChange(stateKey: string, fn: (state: AuthState | null) => void): () => void;
+    /**
+     * Add state change listener
+     * @param {string} key State key
+     * @param {function(string)} fn State change listener
+     * @return {function()} remove listener function
+     */
+    onMessage(key: string, fn: (message: M | null) => void): () => void;
+    sendMessage(key: string, message?: M | null): void;
+    /**
+     * Save authentication request state.
+     *
+     * @param {string} id Unique state identifier
+     * @param {StoredState} state State to store
+     * @param {boolean=} dontCleanAndRetryOnFail If falsy then remove all stored states and try again to save state
+     */
+    saveState(id: string, state: AuthState, dontCleanAndRetryOnFail?: boolean): Promise<void>;
+    /**
+     * Remove all stored states
+     *
+     * @return {Promise} promise that is resolved when OLD states [and some selected] are removed
+     */
+    cleanStates(removeStateId?: string): Promise<0 | void[] | undefined>;
+    /**
+     * Get state by id and remove stored states from the storage.
+     *
+     * @param {string} id unique state identifier
+     * @return {Promise.<StoredState>}
+     */
+    getState(id: string): Promise<AuthState | null>;
+    /**
+     * @param {StoredToken} token
+     * @return {Promise} promise that is resolved when the token is saved
+     */
+    saveToken(token: StoredToken): Promise<StoredToken | null>;
+    /**
+     * @return {Promise.<StoredToken>} promise that is resolved to the stored token
+     */
+    getToken(): Promise<StoredToken | null>;
+    /**
+     * Remove stored token if any.
+     * @return {Promise} promise that is resolved when the token is wiped.
+     */
+    wipeToken(): Promise<void>;
+    /**
+     * @param {function} loadUser user loader
+     * @return {Promise.<object>>} promise that is resolved to stored current user
+     */
+    getCachedUser(loadUser: () => Promise<AuthUser | null>): Promise<AuthUser | null>;
+    /**
+     * Remove cached user if any
+     */
+    wipeCachedCurrentUser(): Promise<void>;
+    /**
+     * Wipes cache if user has changed
+     */
+    onUserChanged(): void;
+}

package/dist/auth/storage.js

@@ -1,7 +1,7 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
 import ActualStorage from '../storage/storage.js';
 import '../storage/storage__local.js';
 import '../alert-service/alert-service.js';
-import '../_helpers/_rollupPluginBabelHelpers.js';
 import 'react';
 import 'react-dom';
 import '../global/get-uid.js';
@@ -47,7 +47,7 @@ import 'deep-equal';
  */
 
 const DEFAULT_STATE_QUOTA = 102400; // 100 kb ~~ 200 tabs with a large list of scopes
-// eslint-disable-next-line no-magic-numbers
+// eslint-disable-next-line @typescript-eslint/no-magic-numbers
 
 const DEFAULT_STATE_TTL = 1000 * 60 * 60 * 24; // nobody will need auth state after a day
 
@@ -58,9 +58,31 @@ class AuthStorage {
    * @param {{stateKeyPrefix: string, tokenKey: string, onTokenRemove: Function}} config
    */
   constructor(config) {
+    _defineProperty(this, "messagePrefix", void 0);
+
+    _defineProperty(this, "stateKeyPrefix", void 0);
+
+    _defineProperty(this, "tokenKey", void 0);
+
+    _defineProperty(this, "userKey", void 0);
+
+    _defineProperty(this, "stateTTL", void 0);
+
+    _defineProperty(this, "stateQuota", void 0);
+
+    _defineProperty(this, "_lastMessage", void 0);
+
+    _defineProperty(this, "_stateStorage", void 0);
+
+    _defineProperty(this, "_tokenStorage", void 0);
+
+    _defineProperty(this, "_messagesStorage", void 0);
+
+    _defineProperty(this, "_currentUserStorage", void 0);
+
     this.messagePrefix = config.messagePrefix || '';
-    this.stateKeyPrefix = config.stateKeyPrefix;
-    this.tokenKey = config.tokenKey;
+    this.stateKeyPrefix = config.stateKeyPrefix || '';
+    this.tokenKey = config.tokenKey || '';
     this.userKey = config.userKey || 'user-key';
     this.stateTTL = config.stateTTL || DEFAULT_STATE_TTL;
     this._lastMessage = null;
@@ -152,33 +174,42 @@ class AuthStorage {
 
   async cleanStates(removeStateId) {
     const now = Date.now();
-    const removalResult = await this._stateStorage.each((key, state) => {
-      // Remove requested state
+    const removalResult = await this._stateStorage.each((key, value) => {
+      if (value == null) {
+        return undefined;
+      } // Remove requested state
+
+
       if (key === this.stateKeyPrefix + removeStateId) {
         return this._stateStorage.remove(key);
       }
 
       if (key.indexOf(this.stateKeyPrefix) === 0) {
+        var _state$created;
+
         // Clean old states
-        if (state.created + this.stateTTL < now) {
+        const state = value;
+        const created = (_state$created = state.created) !== null && _state$created !== void 0 ? _state$created : Date.now();
+
+        if (created + this.stateTTL < now) {
           return this._stateStorage.remove(key);
         } // Data to clean up due quota
 
 
         return {
           key,
-          created: state.created,
+          created,
           size: JSON.stringify(state).length
         };
       }
 
       return undefined;
     });
-    const currentStates = removalResult.filter(state => state);
+    const currentStates = removalResult.filter(state => state != null);
     let stateStorageSize = currentStates.reduce((overallSize, state) => state.size + overallSize, 0);
 
     if (stateStorageSize > this.stateQuota) {
-      currentStates.sort((a, b) => a.created > b.created);
+      currentStates.sort((a, b) => a.created - b.created);
       const removalPromises = currentStates.filter(state => {
         if (stateStorageSize > this.stateQuota) {
           stateStorageSize -= state.size;