@jetbrains/ring-ui 5.1.23 → 5.1.24

package/components/analytics/analytics.d.ts

@@ -0,0 +1,38 @@
+export type Serializable = string | number | boolean | null | undefined | {
+    [K in string | number]?: Serializable;
+};
+export interface AnalyticsPlugin {
+    /**
+     * @deprecated
+     */
+    serializeAdditionalInfo: boolean;
+    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;
+    /**
+     * @deprecated
+     */
+    track(rawTrackingData: string, additionalData: Record<string, Serializable>): void;
+    /**
+     * @deprecated
+     */
+    trackPageView(path: string): void;
+    trackEvent(category: string, action: string, additionalData?: Record<string, Serializable>): void;
+    /**
+     * @deprecated
+     */
+    trackShortcutEvent(category: string, action: string, additionalData: Record<string, Serializable>): void;
+    /**
+     * @deprecated
+     */
+    trackEntityProperties(entityName: string, entity: Serializable, propertiesNames: readonly string[], additionalData?: Record<string, Serializable>): void;
+}
+declare const _default: Analytics;
+export default _default;

package/components/analytics/analytics.js

@@ -0,0 +1,82 @@
+import deprecate from 'util-deprecate';
+const warnOnDeprecationOfAnalyticsMethod = (methodName) => deprecate(() => { }, `Method analytics::${methodName} is deprecated, use analytics::trackEvent instead`)();
+/**
+ * @name Analytics
+ */
+export class Analytics {
+    _plugins;
+    constructor() {
+        this._plugins = [];
+    }
+    config(plugins) {
+        this._plugins = plugins;
+    }
+    /**
+     * @deprecated
+     */
+    track(rawTrackingData, additionalData) {
+        if (!rawTrackingData) {
+            return;
+        }
+        warnOnDeprecationOfAnalyticsMethod('track');
+        let splitIdx = rawTrackingData.indexOf(':');
+        if (splitIdx < 0) {
+            splitIdx = rawTrackingData.indexOf('_');
+        }
+        if (splitIdx < 0) {
+            splitIdx = rawTrackingData.length;
+        }
+        const category = rawTrackingData.substr(0, splitIdx);
+        const subcategory = rawTrackingData.substr(splitIdx + 1);
+        this.trackEvent(category, subcategory, additionalData);
+    }
+    /**
+     * @deprecated
+     */
+    trackPageView(path) {
+        warnOnDeprecationOfAnalyticsMethod('trackPageView');
+        this._plugins.forEach(plugin => {
+            plugin.trackPageView(path);
+        });
+    }
+    trackEvent(category, action, additionalData) {
+        this._plugins.forEach(plugin => {
+            plugin.trackEvent(category, action, additionalData);
+        });
+    }
+    /**
+     * @deprecated
+     */
+    trackShortcutEvent(category, action, additionalData) {
+        warnOnDeprecationOfAnalyticsMethod('trackShortcutEvent');
+        this.trackEvent(category, action, additionalData);
+    }
+    /**
+     * @deprecated
+     */
+    trackEntityProperties(entityName, entity, propertiesNames, additionalData) {
+        warnOnDeprecationOfAnalyticsMethod('trackEntityProperties');
+        for (let i = 0; i < propertiesNames.length; ++i) {
+            const keys = propertiesNames[i].split('.');
+            let value = entity;
+            if (!keys.length) {
+                continue;
+            }
+            for (let j = 0; j < keys.length; ++j) {
+                if (typeof value === 'object' && value != null && value.hasOwnProperty(keys[j])) {
+                    value = value[keys[j]];
+                }
+                else {
+                    value = 'no-value';
+                    break;
+                }
+            }
+            if (typeof value === 'string') {
+                value = value.toLowerCase().replace(/[._]+/g, '-');
+            }
+            const resultAction = `${keys.join('-')}__${value}`;
+            this.trackEvent(entityName, resultAction, additionalData);
+        }
+    }
+}
+export default new Analytics();

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

@@ -0,0 +1,29 @@
+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;
+    get serializeAdditionalInfo(): boolean;
+}

package/components/analytics/analytics__custom-plugin.js

@@ -0,0 +1,61 @@
+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?.();
+        }
+    }
+    get serializeAdditionalInfo() {
+        return true;
+    }
+}

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

@@ -0,0 +1,52 @@
+import { AnalyticsPlugin } from './analytics';
+export interface AnalyticsFUSPluginGroup {
+    id: string;
+    version: string;
+    baseline: string;
+}
+interface FusraInitParams {
+    recorderCode?: string | undefined;
+    recorderVersion: number | string;
+    productCode?: string | undefined;
+    productBuild?: string | undefined;
+    internal: boolean;
+    eventCountDelay?: number | undefined;
+    reportingFrequency?: number | undefined;
+    groups?: readonly AnalyticsFUSPluginGroup[] | undefined;
+    useForSubdomains?: boolean | undefined;
+}
+interface FusraEventParams {
+    groupId: string;
+    groupVersion?: number | string | undefined;
+    eventData?: Record<string, unknown> | undefined;
+    eventId: string;
+}
+declare global {
+    interface Window {
+        fusra?: {
+            (method: 'init', params: FusraInitParams): void;
+            (method: 'event', params: FusraEventParams): void;
+            query?: ['init' | 'event', FusraInitParams | FusraEventParams][];
+        };
+    }
+}
+/**
+ * @deprecated
+ * @name AnalyticsFUSPlugin
+ */
+declare class AnalyticsFUSPlugin implements AnalyticsPlugin {
+    /**
+     * @deprecated
+     */
+    trackEvent(): void;
+    /**
+     * @deprecated
+     */
+    trackPageView(): void;
+    /**
+     * @deprecated
+     */
+    get serializeAdditionalInfo(): boolean;
+}
+declare const _default: typeof AnalyticsFUSPlugin;
+export default _default;

package/components/analytics/analytics__fus-plugin.js

@@ -0,0 +1,22 @@
+import deprecate from 'util-deprecate';
+/**
+ * @deprecated
+ * @name AnalyticsFUSPlugin
+ */
+class AnalyticsFUSPlugin {
+    /**
+     * @deprecated
+     */
+    trackEvent() { }
+    /**
+     * @deprecated
+     */
+    trackPageView() { }
+    /**
+     * @deprecated
+     */
+    get serializeAdditionalInfo() {
+        return false;
+    }
+}
+export default deprecate(AnalyticsFUSPlugin, 'AnalyticsFUSPlugin is deprecated, use AnalyticsCustomPlugin instead');

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

@@ -0,0 +1,27 @@
+import { AnalyticsPlugin, Serializable } from './analytics';
+declare global {
+    interface Window {
+        'GoogleAnalyticsObject': string;
+    }
+}
+/**
+ * @deprecated
+ * @param {string?} gaId Google Analytics ID (should be undefined in development)
+ * @constructor
+ */
+export default class AnalyticsGAPlugin implements AnalyticsPlugin {
+    constructor(gaId?: string | undefined, isDevelopment?: boolean | undefined, domain?: string, cookielessUserIdentifier?: string | undefined);
+    /**
+     * @deprecated
+     */
+    trackEvent(rawCategory: string, rawAction: string, data?: Record<string, Serializable>): void;
+    /**
+     * @deprecated
+     */
+    trackPageView(path: string): void;
+    /**
+     * @deprecated
+     */
+    get serializeAdditionalInfo(): boolean;
+    private _buildSuffix;
+}

package/components/analytics/analytics__ga-plugin.js

@@ -0,0 +1,89 @@
+import AnalyticsPluginUtils from './analytics__plugin-utils';
+/**
+ * @deprecated
+ * @param {string?} gaId Google Analytics ID (should be undefined in development)
+ * @constructor
+ */
+export default class AnalyticsGAPlugin {
+    constructor(gaId, isDevelopment, domain, cookielessUserIdentifier) {
+        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 */
+        if (cookielessUserIdentifier) {
+            ga('create', key, {
+                storage: 'none',
+                clientId: cookielessUserIdentifier
+            });
+        }
+        else {
+            const gaCookieParams = domain ? { cookieDomain: domain } : {};
+            ga('create', key, (!gaId ? { cookieDomain: 'none' } : gaCookieParams));
+        }
+        ga('set', 'anonymizeIp', true);
+        ga('set', 'location', domain || '/');
+        ga('set', 'allowAdFeatures', false);
+    }
+    /**
+     * @deprecated
+     */
+    trackEvent(rawCategory, rawAction, data) {
+        if (window.ga != null) {
+            const category = AnalyticsPluginUtils.reformatString(rawCategory, true);
+            const action = AnalyticsPluginUtils.reformatString(rawAction);
+            ga('send', 'event', {
+                eventCategory: category,
+                eventAction: action
+            });
+            if (data) {
+                ga('send', 'event', {
+                    eventCategory: category,
+                    eventAction: action + this._buildSuffix(data)
+                });
+            }
+        }
+    }
+    /**
+     * @deprecated
+     */
+    trackPageView(path) {
+        if (window.ga != null) {
+            ga('send', 'pageview', path);
+        }
+    }
+    /**
+     * @deprecated
+     */
+    get serializeAdditionalInfo() {
+        return true;
+    }
+    _buildSuffix(additionalData) {
+        if (!additionalData) {
+            return '';
+        }
+        let suffix = '';
+        let key;
+        for (key in additionalData) {
+            if (additionalData.hasOwnProperty(key)) {
+                suffix += `__${key}$${additionalData[key]}`;
+            }
+        }
+        return suffix;
+    }
+}

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

@@ -0,0 +1,31 @@
+declare const AnalyticsPluginUtils: {
+    /**
+     * @deprecated
+     * 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) => string;
+    /**
+     * @deprecated
+     */
+    getPageViewDurationPresentation: (durationMs?: number) => string;
+    /**
+     * @deprecated
+     */
+    getScreenWidthPresentation: () => string;
+    /**
+     * @deprecated
+     */
+    npeSaveLowerCase: (val: string | null | undefined) => string;
+    /**
+     * @deprecated
+     */
+    getUserAgentPresentation: () => string;
+    /**
+     * @deprecated
+     */
+    getDevicePixelRatioPresentation: () => string;
+};
+export default AnalyticsPluginUtils;

package/components/analytics/analytics__plugin-utils.js

@@ -0,0 +1,92 @@
+import deprecate from 'util-deprecate';
+import sniffer from '../global/sniffer';
+const warnOnDeprecationOfAnalyticsUtilsMethod = (methodName) => deprecate(() => { }, `Method AnalyticsPluginUtils::${methodName} is deprecated and will be removed soon`)();
+const SECOND = 1000;
+const HOUR = 3600;
+const AnalyticsPluginUtils = {
+    /**
+     * @deprecated
+     * 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, '_');
+    },
+    /**
+     * @deprecated
+     */
+    getPageViewDurationPresentation: (durationMs) => {
+        warnOnDeprecationOfAnalyticsUtilsMethod('getPageViewDurationPresentation');
+        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`;
+    },
+    /**
+     * @deprecated
+     */
+    getScreenWidthPresentation: () => {
+        warnOnDeprecationOfAnalyticsUtilsMethod('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)';
+    },
+    /**
+     * @deprecated
+     */
+    npeSaveLowerCase: (val) => {
+        warnOnDeprecationOfAnalyticsUtilsMethod('npeSaveLowerCase');
+        return (val || 'unknown').toLowerCase();
+    },
+    /**
+     * @deprecated
+     */
+    getUserAgentPresentation: () => {
+        warnOnDeprecationOfAnalyticsUtilsMethod('getUserAgentPresentation');
+        const name = AnalyticsPluginUtils.npeSaveLowerCase(sniffer.browser.name || 'unknown');
+        const majorVersion = sniffer.browser.version[0];
+        const version = majorVersion || 'unknown';
+        return `${name}$${version}`;
+    },
+    /**
+     * @deprecated
+     */
+    getDevicePixelRatioPresentation: () => {
+        warnOnDeprecationOfAnalyticsUtilsMethod('getDevicePixelRatioPresentation');
+        if (!window.devicePixelRatio || !window.devicePixelRatio.toFixed) {
+            return 'unknown';
+        }
+        return String(window.devicePixelRatio.toFixed(1));
+    }
+};
+export default AnalyticsPluginUtils;

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;