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

package/components/shortcuts/shortcuts.js

@@ -1,56 +1,47 @@
-import {PureComponent} from 'react';
+import { PureComponent } from 'react';
 import PropTypes from 'prop-types';
-
 import shortcuts from './core';
-
 export default class Shortcuts extends PureComponent {
-  static propTypes = {
-    map: PropTypes.object.isRequired,
-    scope: PropTypes.string.isRequired,
-    options: PropTypes.object,
-    disabled: PropTypes.bool,
-    children: PropTypes.node
-  };
-
-  static defaultProps = {
-    options: {}
-  };
-
-  componentDidMount() {
-    if (!this.props.disabled) {
-      this.turnShorcutsOn();
+    static propTypes = {
+        map: PropTypes.object.isRequired,
+        scope: PropTypes.string.isRequired,
+        options: PropTypes.object,
+        disabled: PropTypes.bool,
+        children: PropTypes.node
+    };
+    static defaultProps = {
+        options: {}
+    };
+    componentDidMount() {
+        if (!this.props.disabled) {
+            this.turnShorcutsOn();
+        }
     }
-  }
-
-  componentDidUpdate(prevProps) {
-    const {disabled} = this.props;
-    if (!prevProps.disabled && disabled) {
-      this.turnShorcutsOff();
+    componentDidUpdate(prevProps) {
+        const { disabled } = this.props;
+        if (!prevProps.disabled && disabled) {
+            this.turnShorcutsOff();
+        }
+        if (prevProps.disabled && !disabled) {
+            this.turnShorcutsOn();
+        }
     }
-    if (prevProps.disabled && !disabled) {
-      this.turnShorcutsOn();
+    componentWillUnmount() {
+        if (!this.props.disabled) {
+            this.turnShorcutsOff();
+        }
     }
-  }
-
-  componentWillUnmount() {
-    if (!this.props.disabled) {
-      this.turnShorcutsOff();
+    turnShorcutsOn() {
+        const { map, scope, options } = this.props;
+        shortcuts.bindMap(map, this.props);
+        shortcuts.pushScope(scope, options);
+    }
+    turnShorcutsOff() {
+        const { scope } = this.props;
+        shortcuts.unbindScope(scope);
+        shortcuts.spliceScope(scope);
+    }
+    render() {
+        return this.props.children || null;
     }
-  }
-
-  turnShorcutsOn() {
-    const {map, scope, options} = this.props;
-    shortcuts.bindMap(map, this.props);
-    shortcuts.pushScope(scope, options);
-  }
-
-  turnShorcutsOff() {
-    const {scope} = this.props;
-    shortcuts.unbindScope(scope);
-    shortcuts.spliceScope(scope);
-  }
-
-  render() {
-    return this.props.children || null;
-  }
 }

package/components/shortcuts-hint-ng/shortcuts-hint-ng.examples.js

@@ -2,7 +2,7 @@ import angular from 'angular';
 
 import angularDecorator, {APP_NAME} from '../../.storybook/angular-decorator';
 
-import ShortcutsHintNg from '@jetbrains/ring-ui/components/shortcuts-hint-ng/shortcuts-hint-ng';
+import ShortcutsHintNg from './shortcuts-hint-ng';
 
 export default {
   title: 'Legacy Angular/ShortcutsHint Ng',

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

@@ -2,10 +2,10 @@ import angular from 'angular';
 
 import angularDecorator, {APP_NAME} from '../../.storybook/angular-decorator';
 
-import '@jetbrains/ring-ui/components/link/link__legacy.css';
-import SelectNG from '@jetbrains/ring-ui/components/select-ng/select-ng';
+import '../link/link__legacy.css';
+import SelectNG from '../select-ng/select-ng';
 
-import SidebarNG from '@jetbrains/ring-ui/components/sidebar-ng/sidebar-ng';
+import SidebarNG from './sidebar-ng';
 
 export default {
   title: 'Legacy Angular/Sidebar Ng',

package/components/storage/storage.d.ts

@@ -0,0 +1,18 @@
+export interface StorageConfig {
+    type?: 'local' | 'session' | null | undefined;
+    cookieName?: string | null | undefined;
+    checkDelay?: number | null | undefined;
+}
+export interface StorageInterface {
+    get<T>(name: string): Promise<T | null>;
+    set<T>(name: string, value: T | null): Promise<T | null>;
+    remove(name: string): Promise<void>;
+    each<R>(callback: (item: string, value: unknown) => R | Promise<R>): Promise<R[]>;
+    on<T>(name: string, callback: (value: T | null) => void): () => void;
+}
+export interface StorageClass {
+    new (config?: StorageConfig | undefined): StorageInterface;
+    QUOTA?: number;
+}
+declare const ActualStorage: StorageClass;
+export default ActualStorage;

package/components/storage/storage.js

@@ -1,25 +1,22 @@
 import LocalStorage from './storage__local';
 import FallbackStorage from './storage__fallback';
-
 /**
  * @name Storage
  */
-
 /**
  * @constructor
  * @extends {LocalStorage}
  */
 let Storage = LocalStorage;
-
 // Using try/catch here because of IE10+ protected mode and other browsers' quirks
 // See https://github.com/Modernizr/Modernizr/blob/master/feature-detects/storage/localstorage.js
 try {
-  const temp = 'testStorage';
-  localStorage.setItem(temp, temp);
-  localStorage.removeItem(temp);
-} catch (e) {
-  Storage = FallbackStorage;
+    const temp = 'testStorage';
+    localStorage.setItem(temp, temp);
+    localStorage.removeItem(temp);
+}
+catch (e) {
+    Storage = FallbackStorage;
 }
-
 const ActualStorage = Storage;
 export default ActualStorage;

package/components/storage/storage__fallback.d.ts

@@ -0,0 +1,79 @@
+import { StorageInterface, StorageConfig } from './storage';
+/**
+ * @prop {string} cookieName
+ *
+ * @param {{cookieName: string}} config
+ * @param {{checkDelay: number}} config
+ * @param {{type: string}} config
+ * @return {FallbackStorage}
+ * @constructor
+ */
+export default class FallbackStorage implements StorageInterface {
+    static DEFAULT_COOKIE_NAME: string;
+    static DEFAULT_SESSION_COOKIE_NAME: string;
+    static DEFAULT_CHECK_DELAY: number;
+    static COOKIE_EXPIRES: number;
+    /**
+     * Maximum storage size
+     * @see http://browsercookielimits.squawky.net/
+     * @type {number}
+     */
+    static QUOTA: number;
+    /**
+     * @param {string} name
+     * @param {string} value
+     * @param {number} days
+     * @private
+     */
+    private static _createCookie;
+    /**
+     *
+     * @param {string} name
+     * @return {string}
+     * @private
+     */
+    private static _readCookie;
+    cookieName: string;
+    checkDelay: number;
+    expires: number | null;
+    constructor(config?: StorageConfig);
+    /**
+     * @return {Promise}
+     * @private
+     */
+    private _read;
+    /**
+     * @param data
+     * @return {Promise}
+     * @private
+     */
+    private _write;
+    /**
+     * @param {string} key
+     * @return {Promise}
+     */
+    get(key: string): Promise<any>;
+    /**
+     * @param {string} key
+     * @param {object} value
+     * @return {Promise}
+     */
+    set<T>(key: string, value: T | null): Promise<T | null>;
+    /**
+     * @param {string} key
+     * @return {Promise}
+     */
+    remove(key: string): Promise<void>;
+    /**
+     *
+     * @param {function(string, value)} callback
+     * @return {Promise}
+     */
+    each<R>(callback: (item: string, value: unknown) => R | Promise<R>): Promise<Awaited<R>[]>;
+    /**
+     * @param {string} key
+     * @param {Function} callback
+     * @return {Function}
+     */
+    on<T>(key: string, callback: (value: T | null) => void): () => void;
+}

package/components/storage/storage__fallback.js

@@ -1,11 +1,9 @@
 import deepEqual from 'deep-equal';
-
 const DEFAULT_CHECK_DELAY = 3000;
 const COOKIE_EXPIRES = 365;
 const QUOTA = 4093;
-// eslint-disable-next-line no-magic-numbers
+// eslint-disable-next-line @typescript-eslint/no-magic-numbers
 const SECONDS_IN_DAY = 24 * 60 * 60 * 1000;
-
 /**
  * @prop {string} cookieName
  *
@@ -16,184 +14,168 @@ const SECONDS_IN_DAY = 24 * 60 * 60 * 1000;
  * @constructor
  */
 export default class FallbackStorage {
-  static DEFAULT_COOKIE_NAME = 'localStorage';
-  static DEFAULT_SESSION_COOKIE_NAME = 'sessionStorage';
-  static DEFAULT_CHECK_DELAY = DEFAULT_CHECK_DELAY;
-  static COOKIE_EXPIRES = COOKIE_EXPIRES;
-
-  /**
-   * Maximum storage size
-   * @see http://browsercookielimits.squawky.net/
-   * @type {number}
-   */
-  static QUOTA = QUOTA;
-
-  /**
-   * @param {string} name
-   * @param {string} value
-   * @param {number} days
-   * @private
-   */
-  static _createCookie(name, value, days) {
-    let date;
-    let expires;
-
-    if (days) {
-      date = new Date();
-      date.setTime(date.getTime() + (days * SECONDS_IN_DAY));
-      expires = `; expires=${date.toGMTString()}`;
-    } else {
-      expires = ';';
-    }
-
-    document.cookie = `${name}=${value}${expires}; path=/`;
-  }
-
-  /**
-   *
-   * @param {string} name
-   * @return {string}
-   * @private
-   */
-  static _readCookie(name) {
-    const nameEQ = `${name}=`;
-    const cookies = document.cookie.split(';');
-
-    let cookie;
-    for (let i = 0; i < cookies.length; i++) {
-      cookie = cookies[i];
-      while (cookie.charAt(0) === ' ') {
-        cookie = cookie.substring(1, cookie.length);
-      }
-
-      if (cookie.indexOf(nameEQ) === 0) {
-        return cookie.substring(nameEQ.length, cookie.length);
-      }
-    }
-
-    return undefined;
-  }
-
-  constructor(config = {}) {
-    const session = config.type === 'session';
-
-    this.cookieName = config.cookieName ||
-      (
-        session
-          ? this.constructor.DEFAULT_SESSION_COOKIE_NAME
-          : this.constructor.DEFAULT_COOKIE_NAME
-      );
-    this.checkDelay = config.checkDelay || this.constructor.DEFAULT_CHECK_DELAY;
-    this.expires = session ? this.constructor.COOKIE_EXPIRES : null;
-  }
-
-  /**
-   * @return {Promise}
-   * @private
-   */
-  _read() {
-    return new Promise(resolve => {
-      const rawData = FallbackStorage._readCookie(this.cookieName);
-      resolve(JSON.parse(decodeURIComponent(rawData)));
-    }).catch(() => ({}));
-  }
-
-  /**
-   * @param data
-   * @return {Promise}
-   * @private
-   */
-  _write(data) {
-    return new Promise(resolve => {
-      const stringData = encodeURIComponent(JSON.stringify(data));
-      FallbackStorage.
-        _createCookie(this.cookieName, stringData === '{}' ? '' : stringData, this.expires);
-      return resolve(data);
-    });
-  }
-
-  /**
-   * @param {string} key
-   * @return {Promise}
-   */
-  get(key) {
-    return this._read().then(data => data[key] || null);
-  }
-
-  /**
-   * @param {string} key
-   * @param {object} value
-   * @return {Promise}
-   */
-  set(key, value) {
-    return this._read().then(data => {
-      if (key) {
-        if (value != null) {
-          data[key] = value;
-        } else {
-          Reflect.deleteProperty(data, key);
+    static DEFAULT_COOKIE_NAME = 'localStorage';
+    static DEFAULT_SESSION_COOKIE_NAME = 'sessionStorage';
+    static DEFAULT_CHECK_DELAY = DEFAULT_CHECK_DELAY;
+    static COOKIE_EXPIRES = COOKIE_EXPIRES;
+    /**
+     * Maximum storage size
+     * @see http://browsercookielimits.squawky.net/
+     * @type {number}
+     */
+    static QUOTA = QUOTA;
+    /**
+     * @param {string} name
+     * @param {string} value
+     * @param {number} days
+     * @private
+     */
+    static _createCookie(name, value, days) {
+        let date;
+        let expires;
+        if (days) {
+            date = new Date();
+            date.setTime(date.getTime() + (days * SECONDS_IN_DAY));
+            expires = `; expires=${date.toUTCString()}`;
+        }
+        else {
+            expires = ';';
         }
-      }
-
-      return this._write(data);
-    });
-  }
-
-  /**
-   * @param {string} key
-   * @return {Promise}
-   */
-  remove(key) {
-    return this.set(key, null);
-  }
-
-  /**
-   *
-   * @param {function(string, value)} callback
-   * @return {Promise}
-   */
-  each(callback) {
-    if (typeof callback !== 'function') {
-      return Promise.reject(new Error('Callback is not a function'));
+        document.cookie = `${name}=${value}${expires}; path=/`;
     }
-
-    return this._read().then(data => {
-      const promises = [];
-      for (const key in data) {
-        if (data.hasOwnProperty(key)) {
-          promises.push(callback(key, data[key]));
+    /**
+     *
+     * @param {string} name
+     * @return {string}
+     * @private
+     */
+    static _readCookie(name) {
+        const nameEQ = `${name}=`;
+        const cookies = document.cookie.split(';');
+        let cookie;
+        for (let i = 0; i < cookies.length; i++) {
+            cookie = cookies[i];
+            while (cookie.charAt(0) === ' ') {
+                cookie = cookie.substring(1, cookie.length);
+            }
+            if (cookie.indexOf(nameEQ) === 0) {
+                return cookie.substring(nameEQ.length, cookie.length);
+            }
         }
-      }
-      return Promise.all(promises);
-    });
-  }
-
-  /**
-   * @param {string} key
-   * @param {Function} callback
-   * @return {Function}
-   */
-  on(key, callback) {
-    let stop = false;
-
-    const checkForChange = oldValue => {
-      this.get(key).then(newValue => {
-        if (stop) {
-          return;
+        return undefined;
+    }
+    cookieName;
+    checkDelay;
+    expires;
+    constructor(config = {}) {
+        const session = config.type === 'session';
+        this.cookieName = config.cookieName ||
+            (session
+                ? FallbackStorage.DEFAULT_SESSION_COOKIE_NAME
+                : FallbackStorage.DEFAULT_COOKIE_NAME);
+        this.checkDelay = config.checkDelay || FallbackStorage.DEFAULT_CHECK_DELAY;
+        this.expires = session ? FallbackStorage.COOKIE_EXPIRES : null;
+    }
+    /**
+     * @return {Promise}
+     * @private
+     */
+    _read() {
+        return new Promise((resolve, reject) => {
+            const rawData = FallbackStorage._readCookie(this.cookieName);
+            if (rawData != null) {
+                resolve(JSON.parse(decodeURIComponent(rawData)));
+            }
+            else {
+                reject();
+            }
+        }).catch(() => ({}));
+    }
+    /**
+     * @param data
+     * @return {Promise}
+     * @private
+     */
+    _write(data) {
+        return new Promise(resolve => {
+            const stringData = encodeURIComponent(JSON.stringify(data));
+            FallbackStorage.
+                _createCookie(this.cookieName, stringData === '{}' ? '' : stringData, this.expires);
+            return resolve(data);
+        });
+    }
+    /**
+     * @param {string} key
+     * @return {Promise}
+     */
+    get(key) {
+        return this._read().then(data => data[key] || null);
+    }
+    /**
+     * @param {string} key
+     * @param {object} value
+     * @return {Promise}
+     */
+    async set(key, value) {
+        const data = await this._read();
+        if (key) {
+            if (value != null) {
+                data[key] = value;
+            }
+            else {
+                Reflect.deleteProperty(data, key);
+            }
         }
-
-        if (!deepEqual(oldValue, newValue)) {
-          callback(newValue);
+        await this._write(data);
+        return value;
+    }
+    /**
+     * @param {string} key
+     * @return {Promise}
+     */
+    async remove(key) {
+        await this.set(key, null);
+    }
+    /**
+     *
+     * @param {function(string, value)} callback
+     * @return {Promise}
+     */
+    each(callback) {
+        if (typeof callback !== 'function') {
+            return Promise.reject(new Error('Callback is not a function'));
         }
-
-        window.setTimeout(() => checkForChange(oldValue), this.checkDelay);
-      });
-    };
-
-    this.get(key).then(checkForChange);
-
-    return () => {
-      stop = true;
-    };
-  }
+        return this._read().then(data => {
+            const promises = [];
+            for (const key in data) {
+                if (data.hasOwnProperty(key)) {
+                    promises.push(callback(key, data[key]));
+                }
+            }
+            return Promise.all(promises);
+        });
+    }
+    /**
+     * @param {string} key
+     * @param {Function} callback
+     * @return {Function}
+     */
+    on(key, callback) {
+        let stop = false;
+        const checkForChange = (oldValue) => {
+            this.get(key).then(newValue => {
+                if (stop) {
+                    return;
+                }
+                if (!deepEqual(oldValue, newValue)) {
+                    callback(newValue);
+                }
+                window.setTimeout(() => checkForChange(oldValue), this.checkDelay);
+            });
+        };
+        this.get(key).then(checkForChange);
+        return () => {
+            stop = true;
+        };
+    }
 }

package/components/storage/storage__local.d.ts

@@ -0,0 +1,38 @@
+import { StorageInterface, StorageConfig } from './storage';
+/**
+ * @return {LocalStorage}
+ * @param {{type: string}} config Set to "session" to use sessionStorage
+ * @constructor
+ */
+export default class LocalStorage implements StorageInterface {
+    static safePromise<T>(resolver: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: unknown) => void) => void): Promise<T>;
+    storageType: 'sessionStorage' | 'localStorage';
+    constructor(config?: StorageConfig);
+    /**
+     * @param {string} name
+     * @return {Promise}
+     */
+    get<T>(name: string): Promise<T | null>;
+    /**
+     * @param {string} name
+     * @param {object} value
+     * @return {Promise}
+     */
+    set<T>(name: string, value: T): Promise<T>;
+    /**
+     * @param {string} name
+     * @return {Promise}
+     */
+    remove(name: string): Promise<void>;
+    /**
+     * @param callback
+     * @return {Promise}s
+     */
+    each<R>(callback: (item: string, value: unknown) => R | Promise<R>): Promise<R[]>;
+    /**
+     * @param {string} name
+     * @param {Function} callback
+     * @return {Function}
+     */
+    on<T>(name: string, callback: (value: T | null) => void): () => void;
+}