@jetbrains/ring-ui 4.1.5 → 5.0.0-beta.2

package/components/auth/token-validator.js

@@ -1,181 +1,169 @@
 import ExtendableError from 'es6-error';
-
-import {CODE} from '../http/http';
-
-export default class TokenValidator {
-  constructor(config, getUser, storage) {
-    this._getUser = getUser;
-    this._config = config;
-    this._storage = storage;
-  }
-
-  /**
-   * Returns epoch - seconds since 1970.
-   * Used for calculation of expire times.
-   * @return {number} epoch, seconds since 1970
-   * @private
-   */
-  static _epoch() {
-    const milliseconds = 1000.0;
-    return Math.round(Date.now() / milliseconds);
-  }
-
-  /**
-   * @const {number}
-   */
-  // eslint-disable-next-line no-magic-numbers
-  static DEFAULT_REFRESH_BEFORE = 10 * 60; // 20 min in s
-
-  /**
-   * Error class for auth token validation
-   *
-   * @param {string} message Error message
-   * @param {Error=} cause Error that caused this error
-   */
-  static TokenValidationError = class TokenValidationError extends ExtendableError {
+import { CODE } from '../http/http';
+export class TokenValidationError extends ExtendableError {
+    cause;
+    authRedirect;
     constructor(message, cause) {
-      super(message);
-      this.cause = cause;
-      this.authRedirect = true;
+        super(message);
+        this.cause = cause;
+        this.authRedirect = true;
+    }
+}
+export default class TokenValidator {
+    _getUser;
+    _config;
+    _storage;
+    constructor(config, getUser, storage) {
+        this._getUser = getUser;
+        this._config = config;
+        this._storage = storage;
+    }
+    /**
+     * Returns epoch - seconds since 1970.
+     * Used for calculation of expire times.
+     * @return {number} epoch, seconds since 1970
+     * @private
+     */
+    static _epoch() {
+        const milliseconds = 1000.0;
+        return Math.round(Date.now() / milliseconds);
+    }
+    /**
+     * @const {number}
+     */
+    // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+    static DEFAULT_REFRESH_BEFORE = 10 * 60; // 20 min in s
+    /**
+     * Error class for auth token validation
+     *
+     * @param {string} message Error message
+     * @param {Error=} cause Error that caused this error
+     */
+    static TokenValidationError = TokenValidationError;
+    /**
+     * Check token validity against all conditions.
+     * @returns {Promise.<string>}
+     */
+    validateTokenLocally() {
+        return this._getValidatedToken([
+            TokenValidator._validateExistence,
+            TokenValidator._validateExpiration,
+            this._validateScopes.bind(this)
+        ]);
+    }
+    /**
+     * Check token validity against all conditions.
+     * @returns {Promise.<string>}
+     */
+    validateToken() {
+        return this._getValidatedToken([
+            TokenValidator._validateExistence,
+            TokenValidator._validateExpiration,
+            this._validateScopes.bind(this),
+            this._validateAgainstUser.bind(this)
+        ]);
+    }
+    /**
+     * Check if there is a token
+     * @param {StoredToken} storedToken
+     * @return {Promise.<StoredToken>}
+     * @private
+     */
+    static _validateExistence(storedToken) {
+        if (!storedToken || !storedToken.accessToken) {
+            throw new TokenValidator.TokenValidationError('Token not found');
+        }
     }
-  };
-
-  /**
-   * Check token validity against all conditions.
-   * @returns {Promise.<string>}
-   */
-  validateTokenLocally() {
-    return this._getValidatedToken([
-      TokenValidator._validateExistence,
-      TokenValidator._validateExpiration,
-      this._validateScopes.bind(this)
-    ]);
-  }
-
-  /**
-   * Check token validity against all conditions.
-   * @returns {Promise.<string>}
-   */
-  validateToken() {
-    return this._getValidatedToken([
-      TokenValidator._validateExistence,
-      TokenValidator._validateExpiration,
-      this._validateScopes.bind(this),
-      this._validateAgainstUser.bind(this)
-    ]);
-  }
-
-
-  /**
-   * Check if there is a token
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-  static _validateExistence(storedToken) {
-    if (!storedToken || !storedToken.accessToken) {
-      throw new TokenValidator.TokenValidationError('Token not found');
+    /**
+     * Check expiration
+     * @param {StoredToken} storedToken
+     * @return {Promise.<StoredToken>}
+     * @private
+     */
+    static _validateExpiration({ expires, lifeTime }) {
+        const REFRESH_BEFORE_RATIO = 6;
+        const refreshBefore = lifeTime
+            ? Math.ceil(lifeTime / REFRESH_BEFORE_RATIO)
+            : TokenValidator.DEFAULT_REFRESH_BEFORE;
+        if (expires && expires < (TokenValidator._epoch() + refreshBefore)) {
+            throw new TokenValidator.TokenValidationError('Token expired');
+        }
     }
-  }
-
-  /**
-   * Check expiration
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-  static _validateExpiration({expires, lifeTime}) {
-    const REFRESH_BEFORE_RATIO = 6;
-    const refreshBefore = lifeTime
-      ? Math.ceil(lifeTime / REFRESH_BEFORE_RATIO)
-      : TokenValidator.DEFAULT_REFRESH_BEFORE;
-
-    if (expires && expires < (TokenValidator._epoch() + refreshBefore)) {
-      throw new TokenValidator.TokenValidationError('Token expired');
+    /**
+     * Check scopes
+     * @param {StoredToken} storedToken
+     * @return {Promise.<StoredToken>}
+     * @private
+     */
+    _validateScopes(storedToken) {
+        const { scope, optionalScopes } = this._config;
+        const requiredScopes = optionalScopes
+            ? scope.filter(scopeId => !optionalScopes.includes(scopeId))
+            : scope;
+        const hasAllScopes = requiredScopes.every(scopeId => storedToken.scopes?.includes(scopeId));
+        if (!hasAllScopes) {
+            throw new TokenValidator.TokenValidationError('Token doesn\'t match required scopes');
+        }
     }
-  }
-
-  /**
-   * Check scopes
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-  _validateScopes(storedToken) {
-    const {scope, optionalScopes} = this._config;
-    const requiredScopes = optionalScopes
-      ? scope.filter(scopeId => !optionalScopes.includes(scopeId))
-      : scope;
-
-    const hasAllScopes = requiredScopes.every(scopeId => storedToken.scopes.includes(scopeId));
-    if (!hasAllScopes) {
-      throw new TokenValidator.TokenValidationError('Token doesn\'t match required scopes');
+    /**
+     * Check by error code if token should be refreshed
+     * @param {string} error
+     * @return {boolean}
+     */
+    static shouldRefreshToken(error) {
+        return error === 'invalid_grant' ||
+            error === 'invalid_request' ||
+            error === 'invalid_token';
     }
-  }
-
-  /**
-   * Check by error code if token should be refreshed
-   * @param {string} error
-   * @return {boolean}
-   */
-  static shouldRefreshToken(error) {
-    return error === 'invalid_grant' ||
-      error === 'invalid_request' ||
-      error === 'invalid_token';
-  }
-
-  /**
-   * Check scopes
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-  async _validateAgainstUser(storedToken) {
-    try {
-      return await this._getUser(storedToken.accessToken);
-    } catch (errorResponse) {
-
-      let response = {};
-      try {
-        response = await errorResponse.response.json();
-      } catch (e) {
-        // Skip JSON parsing errors
-      }
-
-      if (
-        errorResponse.status === CODE.UNAUTHORIZED ||
-        TokenValidator.shouldRefreshToken(response.error)
-      ) {
-        // Token expired
-        throw new TokenValidator.TokenValidationError(response.error || errorResponse.message);
-      }
-
-      // Request unexpectedly failed
-      throw errorResponse;
+    /**
+     * Check scopes
+     * @param {StoredToken} storedToken
+     * @return {Promise.<StoredToken>}
+     * @private
+     */
+    async _validateAgainstUser(storedToken) {
+        try {
+            return await this._getUser(storedToken.accessToken);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (errorResponse) {
+            let response = {};
+            try {
+                response = await errorResponse.response.json();
+            }
+            catch (e) {
+                // Skip JSON parsing errors
+            }
+            if (errorResponse.status === CODE.UNAUTHORIZED ||
+                TokenValidator.shouldRefreshToken(response.error)) {
+                // Token expired
+                throw new TokenValidator.TokenValidationError(response.error || errorResponse.message);
+            }
+            // Request unexpectedly failed
+            throw errorResponse;
+        }
     }
-  }
-
-  /**
-   * Token Validator function
-   * @typedef {(function(StoredToken): Promise<StoredToken>)} TokenValidator
-   */
-
-  /**
-   * Gets stored token and applies provided validators
-   * @param {TokenValidator[]} validators An array of validation
-   * functions to check the stored token against.
-   * @return {Promise.<string>} promise that is resolved to access token if the stored token is valid. If it is
-   * invalid then the promise is rejected. If invalid token should be re-requested then rejection object will
-   * have {authRedirect: true}.
-   * @private
-   */
-  async _getValidatedToken(validators) {
-    const storedToken = await this._storage.getToken();
-
-    for (let i = 0; i < validators.length; i++) {
-      await validators[i](storedToken);
+    /**
+     * Token Validator function
+     * @typedef {(function(StoredToken): Promise<StoredToken>)} TokenValidator
+     */
+    /**
+     * Gets stored token and applies provided validators
+     * @param {TokenValidator[]} validators An array of validation
+     * functions to check the stored token against.
+     * @return {Promise.<string>} promise that is resolved to access token if the stored token is valid. If it is
+     * invalid then the promise is rejected. If invalid token should be re-requested then rejection object will
+     * have {authRedirect: true}.
+     * @private
+     */
+    async _getValidatedToken(validators) {
+        const storedToken = await this._storage.getToken();
+        if (storedToken == null) {
+            throw new TokenValidator.TokenValidationError('Token not found');
+        }
+        for (let i = 0; i < validators.length; i++) {
+            await validators[i](storedToken);
+        }
+        return storedToken.accessToken;
     }
-
-    return storedToken.accessToken;
-  }
 }

package/components/auth/window-flow.d.ts

@@ -0,0 +1,26 @@
+import { LoginFlow } from './auth__core';
+import AuthRequestBuilder from './request-builder';
+import AuthStorage from './storage';
+export default class WindowFlow implements LoginFlow {
+    private _timeoutId;
+    private _requestBuilder;
+    private _storage;
+    reject?: (reason: unknown) => void;
+    private _loginWindow?;
+    private _promise?;
+    constructor(requestBuilder: AuthRequestBuilder, storage: AuthStorage);
+    /**
+     * Opens window with the given URL
+     * @param {string} url
+     * @private
+     */
+    private _openWindow;
+    /**
+     * Initiates authorization in window
+     */
+    private _load;
+    checkIsClosed: () => void;
+    _reset: () => void;
+    stop(): void;
+    authorize(): Promise<string>;
+}

package/components/auth/window-flow.js

@@ -1,123 +1,102 @@
 import AuthResponseParser from './response-parser';
-
 const NAVBAR_HEIGHT = 50;
 const CLOSED_CHECK_INTERVAL = 200;
-
 export default class WindowFlow {
-  _timeoutId = null;
-
-  constructor(requestBuilder, storage) {
-    this._requestBuilder = requestBuilder;
-    this._storage = storage;
-    this._reset();
-  }
-
-  /**
-   * Opens window with the given URL
-   * @param {string} url
-   * @private
-   */
-  _openWindow(url) {
-    const height = 700;
-    const width = 750;
-    const screenHalves = 2;
-    const top = (window.screen.height - height - NAVBAR_HEIGHT) / screenHalves;
-    const left = (window.screen.width - width) / screenHalves;
-
-    return window.open(
-      url,
-      'HubLoginWindow',
-      `height=${height}, width=${width}, left=${left}, top=${top}`
-    );
-  }
-
-  /**
-   * Initiates authorization in window
-   */
-  async _load() {
-    const authRequest = await this._requestBuilder.prepareAuthRequest(
-      // eslint-disable-next-line camelcase
-      {request_credentials: 'required', auth_mode: 'bypass_to_login'},
-      {nonRedirect: true}
-    );
-
-    return new Promise((resolve, reject) => {
-      this.reject = reject;
-      let cleanRun;
-
-      const cleanUp = () => {
-        if (cleanRun) {
-          return;
+    _timeoutId = undefined;
+    _requestBuilder;
+    _storage;
+    reject;
+    _loginWindow;
+    _promise;
+    constructor(requestBuilder, storage) {
+        this._requestBuilder = requestBuilder;
+        this._storage = storage;
+        this._reset();
+    }
+    /**
+     * Opens window with the given URL
+     * @param {string} url
+     * @private
+     */
+    _openWindow(url) {
+        const height = 700;
+        const width = 750;
+        const screenHalves = 2;
+        const top = (window.screen.height - height - NAVBAR_HEIGHT) / screenHalves;
+        const left = (window.screen.width - width) / screenHalves;
+        return window.open(url, 'HubLoginWindow', `height=${height}, width=${width}, left=${left}, top=${top}`);
+    }
+    /**
+     * Initiates authorization in window
+     */
+    async _load() {
+        const authRequest = await this._requestBuilder.prepareAuthRequest(
+        // eslint-disable-next-line camelcase
+        { request_credentials: 'required', auth_mode: 'bypass_to_login' }, { nonRedirect: true });
+        return new Promise((resolve, reject) => {
+            this.reject = reject;
+            let cleanRun;
+            const cleanUp = () => {
+                if (cleanRun) {
+                    return;
+                }
+                cleanRun = true;
+                /* eslint-disable @typescript-eslint/no-use-before-define */
+                removeStateListener();
+                removeTokenListener();
+                /* eslint-enable @typescript-eslint/no-use-before-define */
+                this._loginWindow?.close();
+                clearTimeout(this._timeoutId);
+            };
+            const removeTokenListener = this._storage.onTokenChange(token => {
+                if (token) {
+                    cleanUp();
+                    resolve(token.accessToken);
+                }
+            });
+            const removeStateListener = this._storage.onStateChange(authRequest.stateId, state => {
+                if (state && state.error) {
+                    cleanUp();
+                    reject(new AuthResponseParser.AuthError(state));
+                }
+            });
+            if (this._loginWindow == null || this._loginWindow.closed) {
+                this._loginWindow = this._openWindow(authRequest.url);
+            }
+            else {
+                this._loginWindow.location.href = authRequest.url;
+            }
+            this.checkIsClosed();
+        });
+    }
+    checkIsClosed = () => {
+        if (this._loginWindow?.closed) {
+            this.stop();
+            return;
         }
-        cleanRun = true;
-        /* eslint-disable no-use-before-define */
-        removeStateListener();
-        removeTokenListener();
-        /* eslint-enable no-use-before-define */
-
-        this._loginWindow.close();
+        this._timeoutId = window.setTimeout(this.checkIsClosed, CLOSED_CHECK_INTERVAL);
+    };
+    _reset = () => {
+        this._promise = null;
+        this._loginWindow = null;
         clearTimeout(this._timeoutId);
-      };
-
-      const removeTokenListener = this._storage.onTokenChange(token => {
-        if (token) {
-          cleanUp();
-          resolve(token.accessToken);
+    };
+    stop() {
+        if (this._loginWindow != null) {
+            this._loginWindow.close();
         }
-      });
-
-      const removeStateListener = this._storage.onStateChange(authRequest.stateId, state => {
-        if (state && state.error) {
-          cleanUp();
-          reject(new AuthResponseParser.AuthError(state));
+        if (this.reject) {
+            this.reject('Authorization window closed');
         }
-      });
-
-      if (this._loginWindow === null || this._loginWindow.closed === true) {
-        this._loginWindow = this._openWindow(authRequest.url);
-      } else {
-        this._loginWindow.location = authRequest.url;
-      }
-
-      this.checkIsClosed();
-    });
-  }
-
-  checkIsClosed = () => {
-    if (this._loginWindow.closed) {
-      this.stop();
-      return;
+        this._reset();
     }
-    this._timeoutId = setTimeout(this.checkIsClosed, CLOSED_CHECK_INTERVAL);
-  };
-
-  _reset = () => {
-    this._promise = null;
-    this._loginWindow = null;
-    clearTimeout(this._timeoutId);
-  };
-
-  stop() {
-    if (this._loginWindow !== null) {
-      this._loginWindow.close();
-    }
-    if (this.reject) {
-      this.reject('Authorization window closed');
-    }
-    this._reset();
-  }
-
-  authorize() {
-    if (this._promise !== null && this._loginWindow !== null && this._loginWindow.closed !== true) {
-      this._loginWindow.focus();
-
-      return this._promise;
+    authorize() {
+        if (this._promise != null && this._loginWindow != null && !this._loginWindow.closed) {
+            this._loginWindow.focus();
+            return this._promise;
+        }
+        this._promise = this._load();
+        this._promise.then(this._reset, this._reset);
+        return this._promise;
     }
-
-    this._promise = this._load();
-
-    this._promise.then(this._reset, this._reset);
-
-    return this._promise;
-  }
 }

package/components/auth-dialog/auth-dialog.d.ts

@@ -0,0 +1,49 @@
+import { Component } from 'react';
+import PropTypes from 'prop-types';
+/**
+ * @name Auth Dialog
+ */
+export interface AuthDialogProps {
+    className?: string | undefined;
+    title?: string | null | undefined;
+    errorMessage?: string | null | undefined;
+    serviceImage?: string | null | undefined;
+    serviceName?: string | null | undefined;
+    loginCaption: string;
+    loginToCaption: string;
+    show: boolean;
+    cancelOnEsc: boolean;
+    confirmLabel: string;
+    cancelLabel: string;
+    onConfirm: () => void;
+    onCancel: () => void;
+}
+export default class AuthDialog extends Component<AuthDialogProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        title: PropTypes.Requireable<string>;
+        errorMessage: PropTypes.Requireable<string>;
+        serviceImage: PropTypes.Requireable<string>;
+        serviceName: PropTypes.Requireable<string>;
+        loginCaption: PropTypes.Requireable<string>;
+        loginToCaption: PropTypes.Requireable<string>;
+        show: PropTypes.Requireable<boolean>;
+        cancelOnEsc: PropTypes.Requireable<boolean>;
+        confirmLabel: PropTypes.Requireable<string>;
+        cancelLabel: PropTypes.Requireable<string>;
+        onConfirm: PropTypes.Requireable<(...args: any[]) => any>;
+        onCancel: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        loginCaption: string;
+        loginToCaption: string;
+        show: boolean;
+        cancelOnEsc: boolean;
+        confirmLabel: string;
+        cancelLabel: string;
+        onConfirm: () => void;
+        onCancel: () => void;
+    };
+    onEscPress: () => void;
+    render(): JSX.Element;
+}