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

package/components/analytics/analytics__ga-plugin.js

@@ -4,50 +4,47 @@
  * @constructor
  */
 export default class AnalyticsGAPlugin {
-  constructor(gaId, isDevelopment, domain) {
-    if (!gaId && !isDevelopment) {
-      return;
+    constructor(gaId, isDevelopment, domain) {
+        if (!gaId && !isDevelopment) {
+            return;
+        }
+        ((i, s, o, g, r) => {
+            i.GoogleAnalyticsObject = r;
+            i[r] = i[r] || function addArgumentsToQueueForWaitingTheScriptLoading(...args) {
+                (i[r].q = i[r].q || []).push(args);
+            };
+            i[r].l = Number(new Date());
+            const a = s.createElement(o);
+            const m = s.getElementsByTagName(o)[0];
+            a.async = true;
+            a.src = g;
+            m.parentNode?.insertBefore(a, m);
+        })(window, document, 'script', '//www.google-analytics.com/analytics.js', 'ga');
+        /**
+         * UA-57284711-1 - ga key for development purpose
+         */
+        const key = gaId || 'UA-57284711-1';
+        /* global ga */
+        const gaCookieParams = domain ? { cookieDomain: domain } : {};
+        ga('create', key, (!gaId ? { cookieDomain: 'none' } : gaCookieParams));
+        ga('set', 'anonymizeIp', true);
+        ga('set', 'allowAdFeatures', false);
     }
-    ((i, s, o, g, r) => {
-      i.GoogleAnalyticsObject = r;
-      i[r] = i[r] || function addArgumentsToQueueForWaitingTheScriptLoading() {
-        (i[r].q = i[r].q || []).push(arguments);
-      };
-      i[r].l = 1 * new Date();
-      const a = s.createElement(o);
-      const m = s.getElementsByTagName(o)[0];
-      a.async = 1;
-      a.src = g;
-      m.parentNode.insertBefore(a, m);
-    })(window, document, 'script', '//www.google-analytics.com/analytics.js', 'ga');
-    /**
-     * UA-57284711-1 - ga key for development purpose
-     */
-    const key = gaId || 'UA-57284711-1';
-    /* global ga */
-    const gaCookieParams = domain ? {cookieDomain: domain} : {};
-    ga('create', key, (!gaId ? {cookieDomain: 'none'} : gaCookieParams));
-    ga('set', 'anonymizeIp', true);
-    ga('set', 'allowAdFeatures', false);
-  }
-
-  trackEvent(category, action) {
-    if (window.ga) {
-      const eventOptions = {
-        eventCategory: category,
-        eventAction: action
-      };
-      ga('send', 'event', eventOptions);
+    trackEvent(category, action) {
+        if (window.ga != null) {
+            const eventOptions = {
+                eventCategory: category,
+                eventAction: action
+            };
+            ga('send', 'event', eventOptions);
+        }
     }
-  }
-
-  trackPageView(path) {
-    if (window.ga) {
-      ga('send', 'pageview', path);
+    trackPageView(path) {
+        if (window.ga != null) {
+            ga('send', 'pageview', path);
+        }
+    }
+    get serializeAdditionalInfo() {
+        return true;
     }
-  }
-
-  get serializeAdditionalInfo() {
-    return true;
-  }
 }

package/components/analytics/analytics__plugin-utils.d.ts

@@ -0,0 +1,15 @@
+declare const AnalyticsPluginUtils: {
+    /**
+     * Statistics server does not accept undefined values and strings containing certain symbols
+     * @param value
+     * @param isCategory
+     * @returns string, where forbidden symbols are replaced with '_'
+     */
+    reformatString: (value: unknown, isCategory?: boolean | undefined) => string;
+    getPageViewDurationPresentation: (durationMs?: number | undefined) => string;
+    getScreenWidthPresentation: () => string;
+    npeSaveLowerCase: (val: string | null | undefined) => string;
+    getUserAgentPresentation: () => string;
+    getDevicePixelRatioPresentation: () => string;
+};
+export default AnalyticsPluginUtils;

package/components/analytics/analytics__plugin-utils.js

@@ -1,74 +1,67 @@
 import sniffer from '../global/sniffer';
-
-const AnalyticsPluginUtils = {};
 const SECOND = 1000;
 const HOUR = 3600;
-
-/**
- * Statistics server does not accept undefined values and strings containing certain symbols
- * @param value
- * @param isCategory
- * @returns string, where forbidden symbols are replaced with '_'
- */
-AnalyticsPluginUtils.reformatString = (value, isCategory) => {
-  const str = String(value);
-  /**
-   * Category also cannot contain the '/' character (but an action can)
-   */
-  const regexp = isCategory ? /[.:;!@#^&*(){}\[\]?,%=+\\\/]+/g : /[.:;!@#^&*(){}\[\]?,%=+\\]+/g;
-  return str.replace(regexp, '_');
-};
-
-AnalyticsPluginUtils.getPageViewDurationPresentation = durationMs => {
-  const duration = durationMs / SECOND;
-  if (duration > HOUR) {
-    return 'more-than-hour';
-  }
-
-  /**
-   * rounded duration possible values:
-   * less than 1 second: [0, 1)
-   * less than 2 seconds: [1, 2)
-   * less than 4 seconds: [2, 4)
-   * less than 16 seconds: [4, 16)
-   * ....
-   * n - less than 2^(n + 1) seconds
-   */
-  let roundedDuration = Math.floor(Math.pow(2, Math.floor(Math.log2(duration)) + 1));
-  roundedDuration = (roundedDuration > 0) ? roundedDuration : 1;
-
-  return `less-than-${roundedDuration}-sec`;
-};
-
-AnalyticsPluginUtils.getScreenWidthPresentation = () => {
-  /**
-   * Sizes were taken from bootstrap's grid (xs, sm, md, lg)
-   */
-  // eslint-disable-next-line no-magic-numbers
-  const sizes = [0, 768, 992, 1200];
-  for (let i = 1; i < sizes.length; ++i) {
-    if (window.innerWidth < sizes[i]) {
-      return `[${sizes[i - 1]}px;${sizes[i]}px)`;
+const AnalyticsPluginUtils = {
+    /**
+     * Statistics server does not accept undefined values and strings containing certain symbols
+     * @param value
+     * @param isCategory
+     * @returns string, where forbidden symbols are replaced with '_'
+     */
+    reformatString: (value, isCategory) => {
+        const str = String(value);
+        /**
+         * Category also cannot contain the '/' character (but an action can)
+         */
+        const regexp = isCategory ? /[.:;!@#^&*(){}\[\]?,%=+\\\/]+/g : /[.:;!@#^&*(){}\[\]?,%=+\\]+/g;
+        return str.replace(regexp, '_');
+    },
+    getPageViewDurationPresentation: (durationMs) => {
+        if (durationMs == null) {
+            return 'less-than-1-sec';
+        }
+        const duration = durationMs / SECOND;
+        if (duration > HOUR) {
+            return 'more-than-hour';
+        }
+        /**
+         * rounded duration possible values:
+         * less than 1 second: [0, 1)
+         * less than 2 seconds: [1, 2)
+         * less than 4 seconds: [2, 4)
+         * less than 16 seconds: [4, 16)
+         * ....
+         * n - less than 2^(n + 1) seconds
+         */
+        let roundedDuration = Math.floor(Math.pow(2, Math.floor(Math.log2(duration)) + 1));
+        roundedDuration = (roundedDuration > 0) ? roundedDuration : 1;
+        return `less-than-${roundedDuration}-sec`;
+    },
+    getScreenWidthPresentation: () => {
+        /**
+         * Sizes were taken from bootstrap's grid (xs, sm, md, lg)
+         */
+        // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+        const sizes = [0, 768, 992, 1200];
+        for (let i = 1; i < sizes.length; ++i) {
+            if (window.innerWidth < sizes[i]) {
+                return `[${sizes[i - 1]}px;${sizes[i]}px)`;
+            }
+        }
+        return '[1200px;inf)';
+    },
+    npeSaveLowerCase: (val) => (val || 'unknown').toLowerCase(),
+    getUserAgentPresentation: () => {
+        const name = AnalyticsPluginUtils.npeSaveLowerCase(sniffer.browser.name || 'unknown');
+        const majorVersion = sniffer.browser.version[0];
+        const version = majorVersion || 'unknown';
+        return `${name}$${version}`;
+    },
+    getDevicePixelRatioPresentation: () => {
+        if (!window.devicePixelRatio || !window.devicePixelRatio.toFixed) {
+            return 'unknown';
+        }
+        return String(window.devicePixelRatio.toFixed(1));
     }
-  }
-  return '[1200px;inf)';
-};
-
-AnalyticsPluginUtils.npeSaveLowerCase = val => (val || 'unknown').toLowerCase();
-
-AnalyticsPluginUtils.getUserAgentPresentation = () => {
-  const name = AnalyticsPluginUtils.npeSaveLowerCase(sniffer.browser.name || 'unknown');
-  const majorVersion = sniffer.browser.version[0];
-  const version = majorVersion || 'unknown';
-
-  return `${name}$${version}`;
-};
-
-AnalyticsPluginUtils.getDevicePixelRatioPresentation = () => {
-  if (!window.devicePixelRatio || !window.devicePixelRatio.toFixed) {
-    return 'unknown';
-  }
-  return String(window.devicePixelRatio.toFixed(1));
 };
-
 export default AnalyticsPluginUtils;

package/components/analytics-ng/analytics-ng.examples.js

@@ -2,9 +2,9 @@ import angular from 'angular';
 
 import angularDecorator, {APP_NAME} from '../../.storybook/angular-decorator';
 
-import LinkNG from '@jetbrains/ring-ui/components/link-ng/link-ng';
+import LinkNG from '../link-ng/link-ng';
 
-import AnalyticsNG from '@jetbrains/ring-ui/components/analytics-ng/analytics-ng';
+import AnalyticsNG from './analytics-ng';
 
 export default {
   title: 'Legacy Angular/Analytics Ng',

package/components/auth/auth.d.ts

@@ -0,0 +1,3 @@
+import Auth from './auth__core';
+export * from './auth__core';
+export default Auth;

package/components/auth/auth.js

@@ -1,7 +1,6 @@
 import WindowFlow from './window-flow';
 import defaultOnBackendDown from './down-notification';
 import Auth from './auth__core';
-
 /**
  * @name Auth
  *
@@ -31,15 +30,13 @@ import Auth from './auth__core';
  * }} config
  *
  */
-
 /**
  * Extend Auth config with non-required and not pure-JS stuff
  */
 Auth.DEFAULT_CONFIG = {
-  ...Auth.DEFAULT_CONFIG,
-  EmbeddedLoginFlow: WindowFlow,
-  onBackendDown: defaultOnBackendDown
+    ...Auth.DEFAULT_CONFIG,
+    EmbeddedLoginFlow: WindowFlow,
+    onBackendDown: defaultOnBackendDown
 };
-
 export * from './auth__core';
 export default Auth;

package/components/auth/auth__core.d.ts

@@ -0,0 +1,233 @@
+import Listeners, { Handler } from '../global/listeners';
+import HTTP, { HTTPAuth, RequestParams } from '../http/http';
+import AuthDialogService from '../auth-dialog-service/auth-dialog-service';
+import AuthStorage from './storage';
+import { AuthError } from './response-parser';
+import AuthRequestBuilder from './request-builder';
+import BackgroundFlow from './background-flow';
+import TokenValidator, { TokenValidationError, TokenValidatorConfig } from './token-validator';
+export declare const DEFAULT_EXPIRES_TIMEOUT: number;
+export declare const DEFAULT_BACKGROUND_TIMEOUT: number;
+export declare const USER_CHANGED_EVENT = "userChange";
+export declare const DOMAIN_USER_CHANGED_EVENT = "domainUser";
+export declare const LOGOUT_EVENT = "logout";
+export declare const LOGOUT_POSTPONED_EVENT = "logoutPostponed";
+export declare const USER_CHANGE_POSTPONED_EVENT = "changePostponed";
+export interface AuthUser {
+    guest?: boolean;
+    id: number | string;
+    name: string;
+    login: string;
+    banned?: boolean;
+    banReason?: string;
+    profile?: {
+        avatar?: {
+            url?: string;
+        };
+        email?: {
+            email?: string;
+        };
+    };
+}
+export interface AuthTranslations {
+    login: string;
+    loginTo: string;
+    cancel: string;
+    postpone: string;
+    youHaveLoggedInAs: string;
+    applyChange: string;
+    backendIsNotAvailable: string;
+    checkAgain: string;
+    nothingHappensLink: string;
+    errorMessage: string;
+}
+export interface LoginFlow {
+    stop(): void;
+    authorize(): Promise<unknown>;
+}
+export interface LoginFlowClass {
+    new (requestBuilder: AuthRequestBuilder, storage: AuthStorage, translations: AuthTranslations): LoginFlow;
+}
+export interface BackendDownParams {
+    onCheckAgain(): Promise<void>;
+    onPostpone(): void;
+    backendError: Error;
+    translations: AuthTranslations;
+}
+export interface AuthConfig extends TokenValidatorConfig {
+    serverUri: string;
+    redirectUri: string;
+    requestCredentials: string;
+    clientId: string;
+    redirect: boolean;
+    cleanHash: boolean;
+    userFields: readonly string[];
+    fetchCredentials?: RequestCredentials | null | undefined;
+    cacheCurrentUser: boolean;
+    reloadOnUserChange: boolean;
+    embeddedLogin: boolean;
+    EmbeddedLoginFlow?: LoginFlowClass | null | undefined;
+    backgroundRefreshTimeout?: number | null | undefined;
+    onLogout?: (() => void) | null | undefined;
+    onPostponeChangedUser: (prevUser: AuthUser | null, nextUser: AuthUser | null) => void;
+    onPostponeLogout: () => void;
+    enableBackendStatusCheck: boolean;
+    backendCheckTimeout: number;
+    checkBackendIsUp: () => Promise<unknown>;
+    onBackendDown: (params: BackendDownParams) => () => void;
+    defaultExpiresIn: number;
+    translations: AuthTranslations;
+    userParams?: RequestParams | undefined;
+    waitForRedirectTimeout: number;
+}
+declare type AuthPayloadMap = {
+    userChange: [AuthUser | undefined | void, void];
+    logout: [void, void];
+    logoutPostponed: [void, void];
+    changePostponed: [void, void];
+};
+export interface AuthService {
+    serviceName: string;
+    serviceImage: string;
+}
+interface Deferred<T> {
+    promise?: Promise<T>;
+    resolve?: (value: T) => void;
+    reject?: (reason: unknown) => void;
+}
+interface AuthDialogParams {
+    nonInteractive?: boolean;
+    error?: Error;
+    canCancel?: boolean;
+}
+interface UserChange {
+    userID: number | string | null | undefined;
+    serviceID: string;
+}
+interface UserChangedDialogParams {
+    newUser: AuthUser;
+    onApply: () => void;
+    onPostpone: () => void;
+}
+declare global {
+    interface HTMLLinkElement {
+        pr?: string;
+    }
+}
+export default class Auth implements HTTPAuth {
+    static DEFAULT_CONFIG: Omit<AuthConfig, "serverUri">;
+    static API_PATH: string;
+    static API_AUTH_PATH: string;
+    static API_PROFILE_PATH: string;
+    static CLOSE_BACKEND_DOWN_MESSAGE: string;
+    static CLOSE_WINDOW_MESSAGE: string;
+    static shouldRefreshToken: typeof TokenValidator.shouldRefreshToken;
+    static storageIsUnavailable: boolean;
+    config: AuthConfig;
+    listeners: Listeners<AuthPayloadMap>;
+    http: HTTP;
+    private _service;
+    readonly _storage: AuthStorage<number> | null;
+    private _responseParser;
+    private readonly _requestBuilder;
+    _backgroundFlow: BackgroundFlow | null;
+    private _embeddedFlow;
+    _tokenValidator: TokenValidator | null;
+    private _postponed;
+    private _backendCheckPromise;
+    private _authDialogService;
+    _domainStorage: AuthStorage<UserChange>;
+    user: AuthUser | null;
+    _initDeferred?: Deferred<string | void>;
+    private _isLoginWindowOpen?;
+    constructor(config: Partial<AuthConfig> & Pick<AuthConfig, 'serverUri'>);
+    private _setPostponed;
+    private _updateDomainUser;
+    addListener<E extends keyof AuthPayloadMap>(event: E, handler: Handler<AuthPayloadMap, E>): void;
+    removeListener<E extends keyof AuthPayloadMap>(event: E, handler: Handler<AuthPayloadMap, E>): void;
+    setAuthDialogService(authDialogService: typeof AuthDialogService): void;
+    setCurrentService(service: AuthService): void;
+    private _createInitDeferred;
+    /**
+     * @return {Promise.<string>} absolute URL promise that is resolved to a URL
+     * that should be restored after returning back from auth server.
+     */
+    init(): Promise<string | null | undefined>;
+    sendRedirect(error: Error): Promise<undefined>;
+    handleInitError(error: Error | AuthError): Promise<undefined>;
+    handleInitValidationError(error: Error | TokenValidationError): Promise<undefined>;
+    /**
+     * Get token from local storage or request it if necessary.
+     * Can redirect to login page.
+     * @return {Promise.<string>}
+     */
+    requestToken(): Promise<string | null>;
+    /**
+     * Get new token in the background or redirect to the login page.
+     * @return {Promise.<string>}
+     */
+    forceTokenUpdate(): Promise<string | null>;
+    loadCurrentService(): Promise<void>;
+    getAPIPath(): string;
+    /**
+     * @return {Promise.<object>}
+     */
+    getUser(accessToken?: string | null | undefined): Promise<any> | undefined;
+    /**
+     * @return {Promise.<object>}
+     */
+    requestUser(): Promise<any>;
+    updateUser(): Promise<void>;
+    _detectUserChange(accessToken: string): Promise<void>;
+    _beforeLogout(params?: AuthDialogParams): void;
+    _showAuthDialog({ nonInteractive, error, canCancel }?: AuthDialogParams): void;
+    _showUserChangedDialog({ newUser, onApply, onPostpone }: UserChangedDialogParams): void;
+    private _extractErrorMessage;
+    private _showBackendDownDialog;
+    /**
+     * Wipe accessToken and redirect to auth page with required authorization
+     */
+    logout(extraParams?: Record<string, unknown>): Promise<void>;
+    private _runEmbeddedLogin;
+    /**
+     * Wipe accessToken and redirect to auth page to obtain authorization data
+     * if user is logged in or log her in otherwise
+     */
+    login(): Promise<void>;
+    switchUser(): Promise<void>;
+    /**
+     * Check if the hash contains an access token.
+     * If it does, extract the state, compare with
+     * config, and store the auth response for later use.
+     *
+     * @return {Promise} promise that is resolved to restoreLocation URL, or rejected
+     * @private
+     */
+    private _checkForAuthResponse;
+    private _checkForStateRestoration;
+    _checkBackendsAreUp(): Promise<[unknown, unknown]>;
+    private _checkBackendsStatusesIfEnabled;
+    /**
+     * Adds preconnect tag to help browser to establish connection to URL.
+     * See https://w3c.github.io/resource-hints/
+     * @param url Url to preconnect to.
+     */
+    setUpPreconnect(url: string): void;
+    /**
+     * Redirects current page to the given URL
+     * @param {string} url
+     * @private
+     */
+    _redirectCurrentPage(url: string): void;
+    /**
+     * Reloads current page
+     */
+    private _reloadCurrentPage;
+    _canShowDialogs(): false | typeof AuthDialogService | undefined;
+    /**
+     * Sets the location hash
+     * @param {string} hash
+     */
+    setHash(hash: string): void;
+}
+export {};