@jetbrains/ring-ui 5.0.155 → 5.0.157

package/dist/global/focus-sensor-hoc.js

@@ -1,152 +1,164 @@
-import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { a as _objectSpread2, h as _objectWithoutProperties, j as _inherits, k as _createSuper, b as _classCallCheck, c as _defineProperty, m as _assertThisInitialized, _ as _createClass, i as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import { refObject } from './prop-types.js';
 import composeRefs from './composeRefs.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
 
+var _excluded = ["innerRef", "focused", "onFocusReset", "onFocusRestore"],
+  _excluded2 = ["autofocus", "focused", "onFocus", "onBlur", "innerRef", "scrollOnTableFocus"];
 function extractPropTypes(_ref) {
-  let {
-    propTypes
-  } = _ref;
+  var propTypes = _ref.propTypes;
   if (propTypes == null) {
     return propTypes;
   }
-  const {
-    innerRef,
-    focused,
-    onFocusReset,
-    onFocusRestore,
-    ...restPropTypes
-  } = propTypes;
+  propTypes.innerRef;
+    propTypes.focused;
+    propTypes.onFocusReset;
+    propTypes.onFocusRestore;
+    var restPropTypes = _objectWithoutProperties(propTypes, _excluded);
   return restPropTypes;
 }
 function focusSensorHOC(ComposedComponent) {
-  class FocusSensor extends Component {
-    state = {
-      focused: this.props.focused
-    };
-    componentDidMount() {
-      const {
-        props: {
-          autofocus,
-          scrollOnTableFocus
-        },
-        node
-      } = this;
-      node?.setAttribute('tabindex', '0');
-      if (node != null) {
-        node.style.outline = 'none';
+  var FocusSensor = /*#__PURE__*/function (_Component) {
+    _inherits(FocusSensor, _Component);
+    var _super = _createSuper(FocusSensor);
+    function FocusSensor() {
+      var _this;
+      _classCallCheck(this, FocusSensor);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
       }
-      document.addEventListener('focus', this.onFocusCapture, true);
-      document.addEventListener('blur', this.onBlurCapture, true);
-      if (autofocus) {
-        node?.focus({
-          preventScroll: !scrollOnTableFocus
+      _this = _super.call.apply(_super, [this].concat(args));
+      _defineProperty(_assertThisInitialized(_this), "state", {
+        focused: _this.props.focused
+      });
+      _defineProperty(_assertThisInitialized(_this), "node", void 0);
+      _defineProperty(_assertThisInitialized(_this), "_skipNextCapture", false);
+      _defineProperty(_assertThisInitialized(_this), "onRefUpdate", function (node) {
+        if (node) {
+          _this.node = node;
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onFocusCapture", function (_ref2) {
+        var _this$node;
+        var target = _ref2.target;
+        if (_this._skipNextCapture) {
+          _this._skipNextCapture = false;
+          return;
+        }
+        var focused = target instanceof Node && ((_this$node = _this.node) === null || _this$node === void 0 ? void 0 : _this$node.contains(target));
+        if (focused && !_this.state.focused) {
+          var _this$props$onFocus, _this$props;
+          _this.setState({
+            focused: true
+          });
+          (_this$props$onFocus = (_this$props = _this.props).onFocus) === null || _this$props$onFocus === void 0 ? void 0 : _this$props$onFocus.call(_this$props);
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onBlurCapture", function (_ref3) {
+        var target = _ref3.target;
+        var _assertThisInitialize = _assertThisInitialized(_this),
+          focused = _assertThisInitialize.state.focused,
+          node = _assertThisInitialize.node;
+        if (focused) {
+          setTimeout(function () {
+            var blurred = target instanceof Node && (node === null || node === void 0 ? void 0 : node.contains(target)) && !node.contains(document.activeElement);
+            if (blurred) {
+              var _this$props$onBlur, _this$props2;
+              _this.setState({
+                focused: false
+              });
+              (_this$props$onBlur = (_this$props2 = _this.props).onBlur) === null || _this$props$onBlur === void 0 ? void 0 : _this$props$onBlur.call(_this$props2);
+            }
+          }, 1);
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onFocusRestore", function () {
+        var _this$node2;
+        _this._skipNextCapture = true;
+        (_this$node2 = _this.node) === null || _this$node2 === void 0 ? void 0 : _this$node2.focus({
+          preventScroll: !_this.props.scrollOnTableFocus
         });
-      }
-    }
-    componentDidUpdate(prevProps) {
-      const {
-        focused
-      } = this.props;
-      if (focused && !prevProps.focused) {
-        this.onFocusRestore();
-      } else if (!focused && prevProps.focused) {
-        this.onFocusReset();
-      }
-    }
-    componentWillUnmount() {
-      document.removeEventListener('focus', this.onFocusCapture, true);
-      document.removeEventListener('blur', this.onBlurCapture, true);
+      });
+      _defineProperty(_assertThisInitialized(_this), "onFocusReset", function () {
+        var _this$node3;
+        (_this$node3 = _this.node) === null || _this$node3 === void 0 ? void 0 : _this$node3.blur();
+      });
+      return _this;
     }
-    node;
-    _skipNextCapture = false;
-    onRefUpdate = node => {
-      if (node) {
-        this.node = node;
+    _createClass(FocusSensor, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        var _this$props3 = this.props,
+          autofocus = _this$props3.autofocus,
+          scrollOnTableFocus = _this$props3.scrollOnTableFocus,
+          node = this.node;
+        node === null || node === void 0 ? void 0 : node.setAttribute('tabindex', '0');
+        if (node != null) {
+          node.style.outline = 'none';
+        }
+        document.addEventListener('focus', this.onFocusCapture, true);
+        document.addEventListener('blur', this.onBlurCapture, true);
+        if (autofocus) {
+          node === null || node === void 0 ? void 0 : node.focus({
+            preventScroll: !scrollOnTableFocus
+          });
+        }
       }
-    };
-    onFocusCapture = _ref2 => {
-      let {
-        target
-      } = _ref2;
-      if (this._skipNextCapture) {
-        this._skipNextCapture = false;
-        return;
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        var focused = this.props.focused;
+        if (focused && !prevProps.focused) {
+          this.onFocusRestore();
+        } else if (!focused && prevProps.focused) {
+          this.onFocusReset();
+        }
       }
-      const focused = target instanceof Node && this.node?.contains(target);
-      if (focused && !this.state.focused) {
-        this.setState({
-          focused: true
-        });
-        this.props.onFocus?.();
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        document.removeEventListener('focus', this.onFocusCapture, true);
+        document.removeEventListener('blur', this.onBlurCapture, true);
       }
-    };
-    onBlurCapture = _ref3 => {
-      let {
-        target
-      } = _ref3;
-      const {
-        state: {
-          focused
-        },
-        node
-      } = this;
-      if (focused) {
-        setTimeout(() => {
-          const blurred = target instanceof Node && node?.contains(target) && !node.contains(document.activeElement);
-          if (blurred) {
-            this.setState({
-              focused: false
-            });
-            this.props.onBlur?.();
-          }
-        }, 1);
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props4 = this.props;
+          _this$props4.autofocus;
+          _this$props4.focused;
+          _this$props4.onFocus;
+          _this$props4.onBlur;
+          var innerRef = _this$props4.innerRef;
+          _this$props4.scrollOnTableFocus;
+          var rest = _objectWithoutProperties(_this$props4, _excluded2);
+        return /*#__PURE__*/React.createElement(ComposedComponent, _extends({}, rest, {
+          innerRef: composeRefs(innerRef, this.onRefUpdate),
+          focused: this.state.focused,
+          onFocusReset: this.onFocusReset,
+          onFocusRestore: this.onFocusRestore
+        }));
       }
-    };
-    onFocusRestore = () => {
-      this._skipNextCapture = true;
-      this.node?.focus({
-        preventScroll: !this.props.scrollOnTableFocus
-      });
-    };
-    onFocusReset = () => {
-      this.node?.blur();
-    };
-    render() {
-      const {
-        autofocus,
-        focused,
-        onFocus,
-        onBlur,
-        innerRef,
-        scrollOnTableFocus,
-        ...rest
-      } = this.props;
-      return /*#__PURE__*/React.createElement(ComposedComponent, _extends({}, rest, {
-        innerRef: composeRefs(innerRef, this.onRefUpdate),
-        focused: this.state.focused,
-        onFocusReset: this.onFocusReset,
-        onFocusRestore: this.onFocusRestore
-      }));
-    }
-  }
-  FocusSensor.propTypes = {
-    ...extractPropTypes(ComposedComponent),
+    }]);
+    return FocusSensor;
+  }(Component);
+  FocusSensor.propTypes = _objectSpread2(_objectSpread2({}, extractPropTypes(ComposedComponent)), {}, {
     focused: PropTypes.bool,
     autofocus: PropTypes.bool,
     onFocus: PropTypes.func,
     onBlur: PropTypes.func,
     innerRef: PropTypes.oneOfType([PropTypes.func, refObject(PropTypes.instanceOf(HTMLElement))])
-  };
-  FocusSensor.defaultProps = {
-    ...ComposedComponent.defaultProps,
+  });
+  FocusSensor.defaultProps = _objectSpread2(_objectSpread2({}, ComposedComponent.defaultProps), {}, {
     focused: false,
     autofocus: false,
     scrollOnTableFocus: true,
-    onFocus: () => {},
-    onBlur: () => {}
-  };
+    onFocus: function onFocus() {},
+    onBlur: function onBlur() {}
+  });
   return FocusSensor;
 }
 

package/dist/global/fuzzy-highlight.js

@@ -1,57 +1,71 @@
+import { n as _createForOfIteratorHelper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.regexp.exec.js';
+
 /** https://github.com/bevacqua/fuzzysearch + highlighting with Markdown */
 function fuzzyHighlight(needle, haystack) {
-  let caseSensitive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  const ndl = caseSensitive ? needle : needle.toLowerCase();
-  const hstck = caseSensitive ? haystack : haystack.toLowerCase();
-  const result = function (matched) {
-    let matches = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    let highlight = haystack;
+  var caseSensitive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var ndl = caseSensitive ? needle : needle.toLowerCase();
+  var hstck = caseSensitive ? haystack : haystack.toLowerCase();
+  var result = function result(matched) {
+    var matches = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var highlight = haystack;
     if (matches.length > 0) {
       highlight = '';
-      let prevMatch = {
+      var prevMatch = {
         to: 0
       };
-      for (const match of matches) {
-        highlight += `${haystack.slice(prevMatch.to, match.from)}**${haystack.slice(match.from, match.to)}**`;
-        prevMatch = match;
+      var _iterator = _createForOfIteratorHelper(matches),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var match = _step.value;
+          highlight += "".concat(haystack.slice(prevMatch.to, match.from), "**").concat(haystack.slice(match.from, match.to), "**");
+          prevMatch = match;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
       highlight += haystack.slice(prevMatch.to);
     }
     return {
-      matched,
-      matches,
-      highlight
+      matched: matched,
+      matches: matches,
+      highlight: highlight
     };
   };
-  const hlen = hstck.length;
-  const nlen = ndl.length;
+  var hlen = hstck.length;
+  var nlen = ndl.length;
   if (nlen > hlen) {
     return result(false);
   }
   if (nlen === hlen) {
-    const matched = ndl === hstck;
+    var matched = ndl === hstck;
     return result(matched, matched ? [{
       from: 0,
       to: haystack.length
     }] : []);
   }
-  let on = false;
-  let j = 0;
-  const matches = [];
-  let from = 0;
+  var on = false;
+  var j = 0;
+  var matches = [];
+  var from = 0;
   /* eslint-disable no-labels */
-  outer: for (let i = 0; i < nlen; i++) {
-    const nch = ndl[i];
+  outer: for (var i = 0; i < nlen; i++) {
+    var nch = ndl[i];
     while (j < hlen) {
-      const hch = hstck[j];
-      const match = hch === nch;
+      var hch = hstck[j];
+      var match = hch === nch;
       // Don't turn highlight on for space characters
-      const nextOn = match && /\S/.test(hch);
+      var nextOn = match && /\S/.test(hch);
       if (nextOn && !on) {
         from = j;
       } else if (!nextOn && on) {
         matches.push({
-          from,
+          from: from,
           to: j
         });
       }
@@ -66,7 +80,7 @@ function fuzzyHighlight(needle, haystack) {
   /* eslint-enable */
   if (on) {
     matches.push({
-      from,
+      from: from,
       to: j
     });
   }

package/dist/global/get-event-key.js

@@ -1,4 +1,4 @@
-const normalizeKey = {
+var normalizeKey = {
   Esc: 'Escape',
   Spacebar: ' ',
   Left: 'ArrowLeft',
@@ -12,7 +12,7 @@ const normalizeKey = {
   Scroll: 'ScrollLock',
   MozPrintableKey: 'Unidentified'
 };
-const translateToKey = {
+var translateToKey = {
   8: 'Backspace',
   9: 'Tab',
   12: 'Clear',
@@ -50,11 +50,11 @@ const translateToKey = {
   145: 'ScrollLock',
   224: 'Meta'
 };
-const ENTER = 13;
-const SPACE = 32;
+var ENTER = 13;
+var SPACE = 32;
 function getEventCharCode(nativeEvent) {
-  let charCode;
-  const keyCode = nativeEvent.keyCode;
+  var charCode;
+  var keyCode = nativeEvent.keyCode;
   if ('charCode' in nativeEvent) {
     charCode = nativeEvent.charCode;
     // FF does not set `charCode` for the Enter-key, check against `keyCode`.
@@ -78,14 +78,14 @@ function getEventKey(nativeEvent) {
     // implementations of a working draft specification.
     // FireFox implements `key` but returns `MozPrintableKey` for all
     // printable characters (normalized to `Unidentified`), ignore it.
-    const key = normalizeKey[nativeEvent.key] || nativeEvent.key;
+    var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
     if (key !== 'Unidentified') {
       return key;
     }
   }
   // Browser does not implement `key`, polyfill as much of it as we can.
   if (nativeEvent.type === 'keypress') {
-    const charCode = getEventCharCode(nativeEvent);
+    var charCode = getEventCharCode(nativeEvent);
     // The enter-key is technically both printable and non-printable and can
     // thus be captured by `keypress`, no other non-printable key should.
     return charCode === SPACE ? 'Enter' : String.fromCharCode(charCode);

package/dist/global/get-uid.js

@@ -1,9 +1,13 @@
-const idCounters = {};
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.array.concat.js';
+
+var idCounters = {};
 function generateSalt() {
   // eslint-disable-next-line @typescript-eslint/no-magic-numbers
   return (Date.now() * Math.random()).toString(36).substring(0, 4);
 }
-const salt = generateSalt();
+var salt = generateSalt();
 function getUID(name) {
   if (!name) {
     throw Error('Argument "name" is required in getUID()');
@@ -11,8 +15,8 @@ function getUID(name) {
   if (!idCounters[name]) {
     idCounters[name] = 0;
   }
-  const id = String(idCounters[name]++);
-  return `${name}${id}-${salt}`;
+  var id = String(idCounters[name]++);
+  return "".concat(name).concat(id, "-").concat(salt);
 }
 
 export { getUID as default };

package/dist/global/inject-styles.js

@@ -1,17 +1,22 @@
-const injectStyleSheet = styles => {
-  const styleTag = document.createElement('style');
+import { l as _slicedToArray } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.object.entries.js';
+
+var injectStyleSheet = function injectStyleSheet(styles) {
+  var styleTag = document.createElement('style');
   styleTag.setAttribute('type', 'text/css');
   styleTag.textContent = styles;
   document.head.appendChild(styleTag);
   return styleTag;
 };
-const injectRuleSet = (selector, declarations) => injectStyleSheet(`
-${selector} {
-  ${Object.entries(declarations).map(_ref => {
-  let [property, value] = _ref;
-  return `${property}: ${value};`;
-}).join(`
-  `)}
-}`);
+var injectRuleSet = function injectRuleSet(selector, declarations) {
+  return injectStyleSheet("\n".concat(selector, " {\n  ").concat(Object.entries(declarations).map(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      property = _ref2[0],
+      value = _ref2[1];
+    return "".concat(property, ": ").concat(value, ";");
+  }).join("\n  "), "\n}"));
+};
 
 export { injectRuleSet, injectStyleSheet };

package/dist/global/linear-function.js

@@ -1,9 +1,9 @@
 function linearFunction(x0, y0, a) {
   return {
-    y(x) {
+    y: function y(x) {
       return +y0 + (x - x0) * a;
     },
-    x(y) {
+    x: function x(y) {
       return +x0 + (y - y0) / a;
     }
   };

package/dist/global/listeners.js

@@ -1,33 +1,59 @@
-class Listeners {
-  _all = new Map();
-  trigger() {
-    for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
-      _ref[_key] = arguments[_key];
+import { _ as _createClass, g as _toConsumableArray, b as _classCallCheck, c as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.set.js';
+
+var Listeners = /*#__PURE__*/function () {
+  function Listeners() {
+    _classCallCheck(this, Listeners);
+    _defineProperty(this, "_all", new Map());
+  }
+  _createClass(Listeners, [{
+    key: "trigger",
+    value: function trigger() {
+      for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+        _ref[_key] = arguments[_key];
+      }
+      var event = _ref[0],
+        data = _ref[1];
+      var handlers = this._all.get(event);
+      if (handlers) {
+        return Promise.all(_toConsumableArray(handlers).map(function (fn) {
+          return fn(data);
+        }));
+      }
+      return Promise.resolve([]);
     }
-    let [event, data] = _ref;
-    const handlers = this._all.get(event);
-    if (handlers) {
-      return Promise.all([...handlers].map(fn => fn(data)));
+  }, {
+    key: "add",
+    value: function add(event, handler) {
+      var handlers = this._all.get(event);
+      if (!handlers) {
+        handlers = new Set();
+        this._all.set(event, handlers);
+      }
+      handlers.add(handler);
     }
-    return Promise.resolve([]);
-  }
-  add(event, handler) {
-    let handlers = this._all.get(event);
-    if (!handlers) {
-      handlers = new Set();
-      this._all.set(event, handlers);
+  }, {
+    key: "remove",
+    value: function remove(event, handler) {
+      var handlers = this._all.get(event);
+      if (handlers) {
+        handlers.delete(handler);
+      }
     }
-    handlers.add(handler);
-  }
-  remove(event, handler) {
-    const handlers = this._all.get(event);
-    if (handlers) {
-      handlers.delete(handler);
+  }, {
+    key: "removeAll",
+    value: function removeAll() {
+      this._all = new Map();
     }
-  }
-  removeAll() {
-    this._all = new Map();
-  }
-}
+  }]);
+  return Listeners;
+}();
 
 export { Listeners as default };

package/dist/global/memoize.js

@@ -1,14 +1,21 @@
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+
 function memoize(fn) {
-  const primitiveCache = new Map();
-  const objectCache = new WeakMap();
+  var primitiveCache = new Map();
+  var objectCache = new WeakMap();
   return function memoized(arg) {
-    const key = arg !== null && arg !== void 0 ? arg : '__singleValue__';
-    const cache = key instanceof Object ? objectCache : primitiveCache;
-    const cached = cache.get(key);
+    var key = arg !== null && arg !== void 0 ? arg : '__singleValue__';
+    var cache = key instanceof Object ? objectCache : primitiveCache;
+    var cached = cache.get(key);
     if (cached != null) {
       return cached;
     }
-    const value = fn(arg);
+    var value = fn(arg);
     cache.set(key, value);
     return value;
   };