@jetbrains/ring-ui 4.1.1 → 4.1.5

package/dist/storage/storage__fallback.js

@@ -0,0 +1,214 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import deepEqual from 'deep-equal';
+
+const DEFAULT_CHECK_DELAY = 3000;
+const COOKIE_EXPIRES = 365;
+const QUOTA = 4093; // eslint-disable-next-line no-magic-numbers
+
+const SECONDS_IN_DAY = 24 * 60 * 60 * 1000;
+/**
+ * @prop {string} cookieName
+ *
+ * @param {{cookieName: string}} config
+ * @param {{checkDelay: number}} config
+ * @param {{type: string}} config
+ * @return {FallbackStorage}
+ * @constructor
+ */
+
+class FallbackStorage {
+  /**
+   * Maximum storage size
+   * @see http://browsercookielimits.squawky.net/
+   * @type {number}
+   */
+
+  /**
+   * @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() {
+    let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    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);
+        }
+      }
+
+      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'));
+    }
+
+    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;
+    };
+  }
+
+}
+
+_defineProperty(FallbackStorage, "DEFAULT_COOKIE_NAME", 'localStorage');
+
+_defineProperty(FallbackStorage, "DEFAULT_SESSION_COOKIE_NAME", 'sessionStorage');
+
+_defineProperty(FallbackStorage, "DEFAULT_CHECK_DELAY", DEFAULT_CHECK_DELAY);
+
+_defineProperty(FallbackStorage, "COOKIE_EXPIRES", COOKIE_EXPIRES);
+
+_defineProperty(FallbackStorage, "QUOTA", QUOTA);
+
+export { FallbackStorage as default };

package/dist/storage/storage__local.js

@@ -0,0 +1,151 @@
+import alertService from '../alert-service/alert-service.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'react';
+import 'react-dom';
+import '../global/get-uid.js';
+import '../alert/alert.js';
+import 'classnames';
+import 'prop-types';
+import '@jetbrains/icons/exception';
+import '@jetbrains/icons/checkmark';
+import '@jetbrains/icons/warning';
+import '@jetbrains/icons/close';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import '../global/memoize.js';
+import '../loader-inline/loader-inline.js';
+import '../global/theme.js';
+import '../global/data-tests.js';
+import '../_helpers/inject-styles.js';
+import '../global/conic-gradient.js';
+import 'conic-gradient';
+import '../global/supports-css.js';
+import '../global/inject-styles.js';
+import '../global/radial-gradient-mask.js';
+import '../global/dom.js';
+import '../alert/container.js';
+
+/**
+ * @return {LocalStorage}
+ * @param {{type: string}} config Set to "session" to use sessionStorage
+ * @constructor
+ */
+
+class LocalStorage {
+  static async safePromise(resolver) {
+    try {
+      return await new Promise(resolver);
+    } catch (e) {
+      if (e && e.name === 'NS_ERROR_FILE_CORRUPTED') {
+        alertService.error('Sorry, it looks like your browser storage is corrupted. ' + 'Please clear your storage by going to Tools -> Clear Recent History -> Cookies' + ' and setting time range to "Everything". This will remove the corrupted browser storage across all sites.');
+      }
+
+      throw e;
+    }
+  }
+
+  constructor() {
+    let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    this.storageType = config.type === 'session' ? 'sessionStorage' : 'localStorage';
+  }
+  /**
+   * @param {string} name
+   * @return {Promise}
+   */
+
+
+  get(name) {
+    return this.constructor.safePromise(resolve => {
+      const value = window[this.storageType].getItem(name);
+
+      try {
+        resolve(JSON.parse(value));
+      } catch (e) {
+        resolve(value);
+      }
+    });
+  }
+  /**
+   * @param {string} name
+   * @param {object} value
+   * @return {Promise}
+   */
+
+
+  set(name, value) {
+    return this.constructor.safePromise(resolve => {
+      window[this.storageType].setItem(name, JSON.stringify(value));
+      resolve(value);
+    });
+  }
+  /**
+   * @param {string} name
+   * @return {Promise}
+   */
+
+
+  remove(name) {
+    const storageType = this.storageType;
+    return this.constructor.safePromise(resolve => {
+      if (window[storageType].hasOwnProperty(name)) {
+        window[storageType].removeItem(name);
+      }
+
+      resolve();
+    });
+  }
+  /**
+   * @param callback
+   * @return {Promise}
+   */
+
+
+  each(callback) {
+    const storageType = this.storageType;
+    return this.constructor.safePromise(resolve => {
+      const promises = [];
+
+      for (const item in window[storageType]) {
+        if (window[storageType].hasOwnProperty(item)) {
+          let value = window[storageType].getItem(item);
+
+          try {
+            value = JSON.parse(value);
+          } catch (e) {// Do nothing
+          }
+
+          promises.push(Promise.resolve(callback(item, value)));
+        }
+      }
+
+      resolve(Promise.all(promises));
+    });
+  }
+  /**
+   * @param {string} name
+   * @param {Function} callback
+   * @return {Function}
+   */
+
+
+  on(name, callback) {
+    function handleStorage(e) {
+      if (e.key === name) {
+        try {
+          callback(JSON.parse(e.newValue));
+        } catch (err) {
+          callback(e.newValue);
+        }
+      }
+    }
+
+    window.addEventListener('storage', handleStorage, false);
+    return () => window.removeEventListener('storage', handleStorage, false);
+  }
+
+}
+
+export { LocalStorage as default };