@jetbrains/ring-ui 5.0.156 → 5.0.157

package/dist/storage/storage__local.js

@@ -1,10 +1,21 @@
+import { _ as _createClass, b as _classCallCheck, c as _defineProperty, e as _asyncToGenerator, f as _regeneratorRuntime } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import alertService from '../alert-service/alert-service.js';
-import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.array.concat.js';
 import 'react';
 import '../global/react-render-adapter.js';
+import 'core-js/modules/es.weak-map.js';
 import 'react-dom';
 import '../global/get-uid.js';
+import 'core-js/modules/es.regexp.to-string.js';
 import '../alert/alert.js';
+import 'core-js/modules/es.object.values.js';
 import 'classnames';
 import 'prop-types';
 import '@jetbrains/icons/exception';
@@ -16,11 +27,22 @@ import 'util-deprecate';
 import '../icon/icon__constants.js';
 import '../_helpers/icon.js';
 import '../icon/icon__svg.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.string.starts-with.js';
 import '../global/memoize.js';
+import 'core-js/modules/es.map.js';
 import '../loader-inline/loader-inline.js';
 import '../global/data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.entries.js';
 import '../_helpers/loader-inline.js';
 import '../global/dom.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.object.keys.js';
+import 'core-js/modules/es.set.js';
 import '../button/button.js';
 import '@jetbrains/icons/chevron-10px';
 import '../link/clickableLink.js';
@@ -32,11 +54,18 @@ import '../popup/popup.js';
 import '../global/schedule-raf.js';
 import '../shortcuts/shortcuts.js';
 import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.find-index.js';
 import 'combokeys';
 import '../global/sniffer.js';
 import 'sniffr';
 import '../tab-trap/tab-trap.js';
 import '../popup/position.js';
+import 'core-js/modules/es.array.sort.js';
 import '../popup/popup.consts.js';
 import '../alert/container.js';
 
@@ -45,111 +74,148 @@ import '../alert/container.js';
  * @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 instanceof Error && 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;
-    }
-  }
-  storageType;
-  constructor() {
-    let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+var LocalStorage = /*#__PURE__*/function () {
+  function LocalStorage() {
+    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, LocalStorage);
+    _defineProperty(this, "storageType", void 0);
     this.storageType = config.type === 'session' ? 'sessionStorage' : 'localStorage';
   }
   /**
    * @param {string} name
    * @return {Promise}
    */
-  get(name) {
-    return LocalStorage.safePromise(resolve => {
-      const value = window[this.storageType].getItem(name);
-      if (value != null) {
-        try {
-          resolve(JSON.parse(value));
-        } catch (e) {
+  _createClass(LocalStorage, [{
+    key: "get",
+    value: function get(name) {
+      var _this = this;
+      return LocalStorage.safePromise(function (resolve) {
+        var value = window[_this.storageType].getItem(name);
+        if (value != null) {
+          try {
+            resolve(JSON.parse(value));
+          } catch (e) {
+            resolve(value);
+          }
+        } else {
           resolve(value);
         }
-      } else {
+      });
+    }
+    /**
+     * @param {string} name
+     * @param {object} value
+     * @return {Promise}
+     */
+  }, {
+    key: "set",
+    value: function set(name, value) {
+      var _this2 = this;
+      return LocalStorage.safePromise(function (resolve) {
+        window[_this2.storageType].setItem(name, JSON.stringify(value));
         resolve(value);
-      }
-    });
-  }
-  /**
-   * @param {string} name
-   * @param {object} value
-   * @return {Promise}
-   */
-  set(name, value) {
-    return LocalStorage.safePromise(resolve => {
-      window[this.storageType].setItem(name, JSON.stringify(value));
-      resolve(value);
-    });
-  }
-  /**
-   * @param {string} name
-   * @return {Promise}
-   */
-  remove(name) {
-    const storageType = this.storageType;
-    return LocalStorage.safePromise(resolve => {
-      if (window[storageType].hasOwnProperty(name)) {
-        window[storageType].removeItem(name);
-      }
-      resolve();
-    });
-  }
-  /**
-   * @param callback
-   * @return {Promise}s
-   */
-  each(callback) {
-    const storageType = this.storageType;
-    return LocalStorage.safePromise(resolve => {
-      const promises = [];
-      for (const item in window[storageType]) {
-        if (window[storageType].hasOwnProperty(item)) {
-          const value = window[storageType].getItem(item);
-          let resolvedValue = null;
-          if (value != null) {
-            try {
-              resolvedValue = JSON.parse(value);
-            } catch (e) {
-              resolvedValue = value;
+      });
+    }
+    /**
+     * @param {string} name
+     * @return {Promise}
+     */
+  }, {
+    key: "remove",
+    value: function remove(name) {
+      var storageType = this.storageType;
+      return LocalStorage.safePromise(function (resolve) {
+        if (window[storageType].hasOwnProperty(name)) {
+          window[storageType].removeItem(name);
+        }
+        resolve();
+      });
+    }
+    /**
+     * @param callback
+     * @return {Promise}s
+     */
+  }, {
+    key: "each",
+    value: function each(callback) {
+      var storageType = this.storageType;
+      return LocalStorage.safePromise(function (resolve) {
+        var promises = [];
+        for (var item in window[storageType]) {
+          if (window[storageType].hasOwnProperty(item)) {
+            var value = window[storageType].getItem(item);
+            var resolvedValue = null;
+            if (value != null) {
+              try {
+                resolvedValue = JSON.parse(value);
+              } catch (e) {
+                resolvedValue = value;
+              }
             }
+            promises.push(Promise.resolve(callback(item, resolvedValue)));
           }
-          promises.push(Promise.resolve(callback(item, resolvedValue)));
         }
-      }
-      resolve(Promise.all(promises));
-    });
-  }
-  /**
-   * @param {string} name
-   * @param {Function} callback
-   * @return {Function}
-   */
-  on(name, callback) {
-    function handleStorage(e) {
-      if (e.key === name) {
-        if (e.newValue != null) {
-          try {
-            callback(JSON.parse(e.newValue));
-          } catch (err) {
+        resolve(Promise.all(promises));
+      });
+    }
+    /**
+     * @param {string} name
+     * @param {Function} callback
+     * @return {Function}
+     */
+  }, {
+    key: "on",
+    value: function on(name, callback) {
+      function handleStorage(e) {
+        if (e.key === name) {
+          if (e.newValue != null) {
+            try {
+              callback(JSON.parse(e.newValue));
+            } catch (err) {
+              callback(e.newValue);
+            }
+          } else {
             callback(e.newValue);
           }
-        } else {
-          callback(e.newValue);
         }
       }
+      window.addEventListener('storage', handleStorage, false);
+      return function () {
+        return window.removeEventListener('storage', handleStorage, false);
+      };
     }
-    window.addEventListener('storage', handleStorage, false);
-    return () => window.removeEventListener('storage', handleStorage, false);
-  }
-}
+  }], [{
+    key: "safePromise",
+    value: function () {
+      var _safePromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(resolver) {
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              _context.next = 3;
+              return new Promise(resolver);
+            case 3:
+              return _context.abrupt("return", _context.sent);
+            case 6:
+              _context.prev = 6;
+              _context.t0 = _context["catch"](0);
+              if (_context.t0 instanceof Error && _context.t0.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 _context.t0;
+            case 10:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[0, 6]]);
+      }));
+      function safePromise(_x) {
+        return _safePromise.apply(this, arguments);
+      }
+      return safePromise;
+    }()
+  }]);
+  return LocalStorage;
+}();
 
 export { LocalStorage as default };

package/dist/tab-trap/tab-trap.js

@@ -1,147 +1,182 @@
-import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { c as _defineProperty, j as _inherits, k as _createSuper, b as _classCallCheck, m as _assertThisInitialized, g as _toConsumableArray, _ as _createClass, h as _objectWithoutProperties, i as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.object.to-string.js';
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import { isNodeInVisiblePartOfPage } from '../global/dom.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.object.keys.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.set.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
 
 var modules_6dce58ae = {"light":"light_rui_2ac4","trapButton":"trapButton_rui_3588"};
 
-const FOCUSABLE_ELEMENTS = 'input, button, select, textarea, a[href], *[tabindex]:not([data-trap-button]):not([data-scrollable-container])';
+var _excluded = ["children", "trapDisabled", "autoFocusFirst", "focusBackOnClose", "focusBackOnExit"];
+var FOCUSABLE_ELEMENTS = 'input, button, select, textarea, a[href], *[tabindex]:not([data-trap-button]):not([data-scrollable-container])';
 /**
  * @name TabTrap
  */
-class TabTrap extends Component {
-  static propTypes = {
-    children: PropTypes.node.isRequired,
-    trapDisabled: PropTypes.bool,
-    autoFocusFirst: PropTypes.bool,
-    focusBackOnClose: PropTypes.bool,
-    focusBackOnExit: PropTypes.bool
-  };
-  static defaultProps = {
-    trapDisabled: false,
-    autoFocusFirst: true,
-    focusBackOnClose: true,
-    focusBackOnExit: false
-  };
-  componentDidMount() {
-    this.previousFocusedNode = document.activeElement;
-    if (this.props.autoFocusFirst) {
-      this.focusFirst();
-    } else if (!this.props.trapDisabled && (!this.node || !this.node.contains(this.previousFocusedNode))) {
-      this.trapWithoutFocus = true;
-      this.trapButtonNode?.focus();
+var TabTrap = /*#__PURE__*/function (_Component) {
+  _inherits(TabTrap, _Component);
+  var _super = _createSuper(TabTrap);
+  function TabTrap() {
+    var _this;
+    _classCallCheck(this, TabTrap);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
-  }
-  componentWillUnmount() {
-    if (this.props.focusBackOnClose) {
-      this.restoreFocus();
-    }
-  }
-  previousFocusedNode;
-  trapWithoutFocus;
-  restoreFocus = () => {
-    const {
-      previousFocusedNode
-    } = this;
-    if (previousFocusedNode instanceof HTMLElement && previousFocusedNode.focus && isNodeInVisiblePartOfPage(previousFocusedNode)) {
-      previousFocusedNode.focus({
-        preventScroll: true
-      });
-    }
-  };
-  node;
-  containerRef = node => {
-    if (!node) {
-      return;
-    }
-    this.node = node;
-  };
-  focusElement = (() => {
-    var _this = this;
-    return function () {
-      let first = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      const {
-        node
-      } = _this;
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "previousFocusedNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "trapWithoutFocus", void 0);
+    _defineProperty(_assertThisInitialized(_this), "restoreFocus", function () {
+      var _assertThisInitialize = _assertThisInitialized(_this),
+        previousFocusedNode = _assertThisInitialize.previousFocusedNode;
+      if (previousFocusedNode instanceof HTMLElement && previousFocusedNode.focus && isNodeInVisiblePartOfPage(previousFocusedNode)) {
+        previousFocusedNode.focus({
+          preventScroll: true
+        });
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "node", void 0);
+    _defineProperty(_assertThisInitialized(_this), "containerRef", function (node) {
+      if (!node) {
+        return;
+      }
+      _this.node = node;
+    });
+    _defineProperty(_assertThisInitialized(_this), "focusElement", function () {
+      var first = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      var _assertThisInitialize2 = _assertThisInitialized(_this),
+        node = _assertThisInitialize2.node;
       if (!node) {
         return;
       }
-      const tabables = [...node.querySelectorAll(FOCUSABLE_ELEMENTS)].filter(item => item.tabIndex >= 0);
-      const toBeFocused = first ? tabables[0] : tabables[tabables.length - 1];
+      var tabables = _toConsumableArray(node.querySelectorAll(FOCUSABLE_ELEMENTS)).filter(function (item) {
+        return item.tabIndex >= 0;
+      });
+      var toBeFocused = first ? tabables[0] : tabables[tabables.length - 1];
       if (toBeFocused) {
         toBeFocused.focus();
       }
-    };
-  })();
-  focusFirst = () => this.focusElement(true);
-  focusLast = () => this.focusElement(false);
-  focusLastIfEnabled = event => {
-    if (this.trapWithoutFocus) {
-      return;
+    });
+    _defineProperty(_assertThisInitialized(_this), "focusFirst", function () {
+      return _this.focusElement(true);
+    });
+    _defineProperty(_assertThisInitialized(_this), "focusLast", function () {
+      return _this.focusElement(false);
+    });
+    _defineProperty(_assertThisInitialized(_this), "focusLastIfEnabled", function (event) {
+      if (_this.trapWithoutFocus) {
+        return;
+      }
+      if (_this.props.focusBackOnExit) {
+        var prevFocused = event.nativeEvent.relatedTarget;
+        if (prevFocused != null && _this.node != null && prevFocused instanceof Element && _this.node.contains(prevFocused)) {
+          _this.restoreFocus();
+        }
+      } else {
+        _this.focusLast();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleBlurIfWithoutFocus", function (event) {
+      var _this$node;
+      if (!_this.trapWithoutFocus) {
+        return;
+      }
+      _this.trapWithoutFocus = false;
+      var newFocused = event.nativeEvent.relatedTarget;
+      if (!newFocused) {
+        return;
+      }
+      if (newFocused instanceof Element && (_this$node = _this.node) !== null && _this$node !== void 0 && _this$node.contains(newFocused)) {
+        return;
+      }
+      _this.focusLast();
+    });
+    _defineProperty(_assertThisInitialized(_this), "trapButtonNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "trapButtonRef", function (node) {
+      if (!node) {
+        return;
+      }
+      _this.trapButtonNode = node;
+    });
+    return _this;
+  }
+  _createClass(TabTrap, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.previousFocusedNode = document.activeElement;
+      if (this.props.autoFocusFirst) {
+        this.focusFirst();
+      } else if (!this.props.trapDisabled && (!this.node || !this.node.contains(this.previousFocusedNode))) {
+        var _this$trapButtonNode;
+        this.trapWithoutFocus = true;
+        (_this$trapButtonNode = this.trapButtonNode) === null || _this$trapButtonNode === void 0 ? void 0 : _this$trapButtonNode.focus();
+      }
     }
-    if (this.props.focusBackOnExit) {
-      const prevFocused = event.nativeEvent.relatedTarget;
-      if (prevFocused != null && this.node != null && prevFocused instanceof Element && this.node.contains(prevFocused)) {
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.props.focusBackOnClose) {
         this.restoreFocus();
       }
-    } else {
-      this.focusLast();
-    }
-  };
-  handleBlurIfWithoutFocus = event => {
-    if (!this.trapWithoutFocus) {
-      return;
-    }
-    this.trapWithoutFocus = false;
-    const newFocused = event.nativeEvent.relatedTarget;
-    if (!newFocused) {
-      return;
-    }
-    if (newFocused instanceof Element && this.node?.contains(newFocused)) {
-      return;
     }
-    this.focusLast();
-  };
-  trapButtonNode;
-  trapButtonRef = node => {
-    if (!node) {
-      return;
-    }
-    this.trapButtonNode = node;
-  };
-  render() {
-    const {
-      children,
-      trapDisabled,
-      autoFocusFirst,
-      focusBackOnClose,
-      focusBackOnExit,
-      ...restProps
-    } = this.props;
-    if (trapDisabled) {
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        trapDisabled = _this$props.trapDisabled;
+        _this$props.autoFocusFirst;
+        _this$props.focusBackOnClose;
+        var focusBackOnExit = _this$props.focusBackOnExit,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      if (trapDisabled) {
+        return /*#__PURE__*/React.createElement("div", _extends({
+          ref: this.containerRef
+        }, restProps), children);
+      }
       return /*#__PURE__*/React.createElement("div", _extends({
         ref: this.containerRef
-      }, restProps), children);
+      }, restProps), /*#__PURE__*/React.createElement("div", {
+        // It never actually stays focused
+        // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
+        tabIndex: 0,
+        ref: this.trapButtonRef,
+        className: modules_6dce58ae.trapButton,
+        onFocus: this.focusLastIfEnabled,
+        onBlur: this.handleBlurIfWithoutFocus,
+        "data-trap-button": true
+      }), children, /*#__PURE__*/React.createElement("div", {
+        // It never actually stays focused
+        // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
+        tabIndex: 0,
+        onFocus: focusBackOnExit ? this.restoreFocus : this.focusFirst,
+        "data-trap-button": true
+      }));
     }
-    return /*#__PURE__*/React.createElement("div", _extends({
-      ref: this.containerRef
-    }, restProps), /*#__PURE__*/React.createElement("div", {
-      // It never actually stays focused
-      // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
-      tabIndex: 0,
-      ref: this.trapButtonRef,
-      className: modules_6dce58ae.trapButton,
-      onFocus: this.focusLastIfEnabled,
-      onBlur: this.handleBlurIfWithoutFocus,
-      "data-trap-button": true
-    }), children, /*#__PURE__*/React.createElement("div", {
-      // It never actually stays focused
-      // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
-      tabIndex: 0,
-      onFocus: focusBackOnExit ? this.restoreFocus : this.focusFirst,
-      "data-trap-button": true
-    }));
-  }
-}
+  }]);
+  return TabTrap;
+}(Component);
+_defineProperty(TabTrap, "propTypes", {
+  children: PropTypes.node.isRequired,
+  trapDisabled: PropTypes.bool,
+  autoFocusFirst: PropTypes.bool,
+  focusBackOnClose: PropTypes.bool,
+  focusBackOnExit: PropTypes.bool
+});
+_defineProperty(TabTrap, "defaultProps", {
+  trapDisabled: false,
+  autoFocusFirst: true,
+  focusBackOnClose: true,
+  focusBackOnExit: false
+});
 
 export { FOCUSABLE_ELEMENTS, TabTrap as default };

package/dist/table/cell.js

@@ -1,23 +1,37 @@
-import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { c as _defineProperty, j as _inherits, k as _createSuper, b as _classCallCheck, _ as _createClass, i as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import joinDataTestAttributes from '../global/data-tests.js';
 import { m as modules_1db4bbca } from '../_helpers/table.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.array.concat.js';
 
-class Cell extends PureComponent {
-  static propTypes = {
-    children: PropTypes.any,
-    className: PropTypes.string,
-    'data-test': PropTypes.string
-  };
-  render() {
-    const classes = classNames(modules_1db4bbca.cell, this.props.className);
-    return /*#__PURE__*/React.createElement("td", _extends({}, this.props, {
-      className: classes,
-      "data-test": joinDataTestAttributes('ring-table-cell', this.props['data-test'])
-    }), this.props.children);
+var Cell = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Cell, _PureComponent);
+  var _super = _createSuper(Cell);
+  function Cell() {
+    _classCallCheck(this, Cell);
+    return _super.apply(this, arguments);
   }
-}
+  _createClass(Cell, [{
+    key: "render",
+    value: function render() {
+      var classes = classNames(modules_1db4bbca.cell, this.props.className);
+      return /*#__PURE__*/React.createElement("td", _extends({}, this.props, {
+        className: classes,
+        "data-test": joinDataTestAttributes('ring-table-cell', this.props['data-test'])
+      }), this.props.children);
+    }
+  }]);
+  return Cell;
+}(PureComponent);
+_defineProperty(Cell, "propTypes", {
+  children: PropTypes.any,
+  className: PropTypes.string,
+  'data-test': PropTypes.string
+});
 
 export { Cell as default };