@jetbrains/ring-ui 6.0.6-beta.0 → 6.0.6

package/components/analytics/analytics.d.ts

@@ -0,0 +1,18 @@
+export type Serializable = string | number | boolean | null | undefined | {
+    [K in string | number]?: Serializable;
+};
+export interface AnalyticsPlugin {
+    trackEvent(category: string, action: string, additionalData?: Record<string, Serializable>): void;
+    trackPageView(path: string): void;
+}
+/**
+ * @name Analytics
+ */
+export declare class Analytics {
+    private _plugins;
+    constructor();
+    config(plugins: readonly AnalyticsPlugin[]): void;
+    trackEvent(category: string, action: string, additionalData?: Record<string, Serializable>): void;
+}
+declare const _default: Analytics;
+export default _default;

package/components/analytics/analytics.js

@@ -0,0 +1,18 @@
+/**
+ * @name Analytics
+ */
+export class Analytics {
+    _plugins;
+    constructor() {
+        this._plugins = [];
+    }
+    config(plugins) {
+        this._plugins = plugins;
+    }
+    trackEvent(category, action, additionalData) {
+        this._plugins.forEach(plugin => {
+            plugin.trackEvent(category, action, additionalData);
+        });
+    }
+}
+export default new Analytics();

package/components/analytics/analytics__custom-plugin.d.ts

@@ -0,0 +1,28 @@
+import { AnalyticsPlugin, Serializable } from './analytics';
+export interface AnalyticsCustomPluginData {
+    category: string;
+    action: string;
+    data?: Record<string, Serializable>;
+    timestamp: number;
+}
+export interface AnalyticsCustomPluginConfig {
+    send: (data: AnalyticsCustomPluginData[]) => void;
+    isDevelopment?: boolean | undefined;
+    flushInterval?: number | undefined;
+    flushMaxPackSize?: number | undefined;
+}
+export default class AnalyticsCustomPlugin implements AnalyticsPlugin {
+    _data: AnalyticsCustomPluginData[];
+    private _flush?;
+    private _isDevelopment?;
+    private _flushInterval?;
+    private _flushMaxPackSize?;
+    private _hasSendSchedule?;
+    constructor(send: AnalyticsCustomPluginConfig['send'], isDevelopment?: AnalyticsCustomPluginConfig['isDevelopment'], flushInterval?: AnalyticsCustomPluginConfig['flushInterval']);
+    config(config: AnalyticsCustomPluginConfig): void;
+    trackEvent(category: string, action: string, additionalData?: Record<string, Serializable>): void;
+    trackPageView(path: string, data?: Record<string, Serializable>): void;
+    private _initSendSchedule;
+    private _processEvent;
+    private _addDataToFlushingPack;
+}

package/components/analytics/analytics__custom-plugin.js

@@ -0,0 +1,58 @@
+const DEFAULT_FLUSH_INTERVAL = 10000;
+const DEFAULT_FLUSH_MAX_PACK_SIZE = 100;
+export default class AnalyticsCustomPlugin {
+    _data;
+    _flush;
+    _isDevelopment;
+    _flushInterval;
+    _flushMaxPackSize;
+    _hasSendSchedule;
+    constructor(send, isDevelopment, flushInterval) {
+        this._data = [];
+        this.config({
+            send,
+            isDevelopment,
+            flushInterval
+        });
+    }
+    config(config) {
+        this._flush = () => {
+            if (this._data.length > 0) {
+                config.send(this._data);
+                this._data = [];
+            }
+        };
+        this._isDevelopment = config.isDevelopment;
+        this._flushInterval = config.flushInterval || DEFAULT_FLUSH_INTERVAL;
+        this._flushMaxPackSize = config.flushMaxPackSize || DEFAULT_FLUSH_MAX_PACK_SIZE;
+    }
+    trackEvent(category, action, additionalData) {
+        this._processEvent(category, action, additionalData);
+    }
+    trackPageView(path, data) {
+        this._processEvent('page', 'view', data);
+    }
+    _initSendSchedule() {
+        window.addEventListener('beforeunload', () => this._flush?.());
+        if (this._flush != null) {
+            setInterval(this._flush, this._flushInterval);
+        }
+        this._hasSendSchedule = true;
+    }
+    _processEvent(category, action, data) {
+        if (!this._hasSendSchedule && this._flush) {
+            this._initSendSchedule();
+        }
+        if (this._isDevelopment) {
+            console.log('TRACKING DATA = ', category, action, data); // eslint-disable-line no-console
+        }
+        const baseSendingData = { category, action, timestamp: Date.now() };
+        this._addDataToFlushingPack(data ? { ...baseSendingData, data } : baseSendingData);
+    }
+    _addDataToFlushingPack(sendingData) {
+        this._data.push(sendingData);
+        if (this._flushMaxPackSize != null && this._data.length >= this._flushMaxPackSize) {
+            this._flush?.();
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+import WindowFlow from './window-flow';
+import defaultOnBackendDown from './down-notification';
+import Auth from './auth__core';
+/**
+ * @name Auth
+ *
+ * @prop {object} config
+ * @prop {string} config.serverUri
+ * @prop {string} config.redirectUri
+ * @prop {string} config.clientId
+ * @prop {boolean=false} config.redirect — use redirects instead of loading the token in the background.
+ * @prop {string[]} config.scope
+ * @prop {string[]} config.optionalScopes
+ * @prop {boolean} config.cleanHash - whether or not location.hash will be cleaned after authorization is completed.
+ * Should be set to false in angular > 1.2.26 apps to prevent infinite redirect in Firefox
+ * @prop {User?} user
+ * @prop {string[]} config.userFields List of user data fields to be returned by auth.requestUser (default list is used in Header.HeaderHelper)
+ * @prop {string[]} config.fetchCredentials
+ *
+ * @param {{
+ *   serverUri: string,
+ *   redirectUri: string?,
+ *   requestCredentials: string?,
+ *   clientId: string?,
+ *   scope: string[]?,
+ *   optionalScopes: string[]?,
+ *   cleanHash: boolean?,
+ *   fetchCredentials: string?,
+ *   userFields: string[]?
+ * }} config
+ *
+ */
+/**
+ * Extend Auth config with non-required and not pure-JS stuff
+ */
+Auth.DEFAULT_CONFIG = {
+    ...Auth.DEFAULT_CONFIG,
+    EmbeddedLoginFlow: WindowFlow,
+    onBackendDown: defaultOnBackendDown
+};
+export * from './auth__core';
+export default Auth;

package/components/auth/auth__core.d.ts

@@ -0,0 +1,236 @@
+import Listeners, { Handler } from '../global/listeners';
+import HTTP, { HTTPAuth, RequestParams } from '../http/http';
+import AuthDialogService from '../auth-dialog-service/auth-dialog-service';
+import AuthStorage, { AuthState } from './storage';
+import { AuthError, AuthResponse } 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: 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;
+    tryAgainLabel: 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 | null | undefined;
+    userParams?: RequestParams | undefined;
+    waitForRedirectTimeout: number;
+}
+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;
+    onTryAgain?: () => Promise<void>;
+}
+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, onTryAgain }?: 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>;
+    _makeStateFromResponse(authResponse: AuthResponse): AuthState;
+    /**
+     * 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 {};