@jetbrains/ring-ui 5.1.1 → 5.1.3

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 { j 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,37 +1,59 @@
-import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { d as _createClass, m as _toConsumableArray, c as _classCallCheck, _ 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';
 
-class Listeners {
-  constructor() {
+var Listeners = /*#__PURE__*/function () {
+  function Listeners() {
+    _classCallCheck(this, Listeners);
     _defineProperty(this, "_all", new Map());
   }
-  trigger() {
-    for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
-      _ref[_key] = arguments[_key];
+  _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;
   };

package/dist/global/normalize-indent.js

@@ -1,29 +1,61 @@
+import { m as _toConsumableArray, n as _createForOfIteratorHelper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.reverse.js';
+
 function normalizeIndent(string) {
-  const nonemptyRE = /\S/;
-  const indentRE = /^\s*/;
-  const lines = string.split(/\n/g);
-  const linesCopy = [...lines];
+  var nonemptyRE = /\S/;
+  var indentRE = /^\s*/;
+  var lines = string.split(/\n/g);
+  var linesCopy = _toConsumableArray(lines);
   //remove empty lines at the beginning and the end
-  for (const line of linesCopy) {
-    if (nonemptyRE.test(line)) {
-      break;
-    } else {
-      lines.shift();
+  var _iterator = _createForOfIteratorHelper(linesCopy),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var line = _step.value;
+      if (nonemptyRE.test(line)) {
+        break;
+      } else {
+        lines.shift();
+      }
     }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
-  for (const line of linesCopy.reverse()) {
-    if (nonemptyRE.test(line)) {
-      break;
-    } else {
-      lines.pop();
+  var _iterator2 = _createForOfIteratorHelper(linesCopy.reverse()),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _line = _step2.value;
+      if (nonemptyRE.test(_line)) {
+        break;
+      } else {
+        lines.pop();
+      }
     }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
   }
-  const indents = lines.filter(line => nonemptyRE.test(line)).map(line => {
-    var _line$match$0$length;
-    return (_line$match$0$length = line.match(indentRE)?.[0].length) !== null && _line$match$0$length !== void 0 ? _line$match$0$length : 0;
+  var indents = lines.filter(function (line) {
+    return nonemptyRE.test(line);
+  }).map(function (line) {
+    var _line$match$0$length, _line$match;
+    return (_line$match$0$length = (_line$match = line.match(indentRE)) === null || _line$match === void 0 ? void 0 : _line$match[0].length) !== null && _line$match$0$length !== void 0 ? _line$match$0$length : 0;
   });
-  const minIndent = Math.min(...indents);
-  return lines.map(line => line.slice(minIndent)).join('\n');
+  var minIndent = Math.min.apply(Math, _toConsumableArray(indents));
+  return lines.map(function (line) {
+    return line.slice(minIndent);
+  }).join('\n');
 }
 
 export { normalizeIndent as default };

package/dist/global/promise-with-timeout.js

@@ -1,12 +1,14 @@
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.promise.js';
+
 // Useful for using fetch with timeout
 // https://github.com/github/fetch/issues/175#issuecomment-284787564
 function promiseWithTimeout(promise, timeout, _ref) {
-  let {
-    error,
-    onTimeout = () => {}
-  } = _ref;
-  return new Promise((resolve, reject) => {
-    setTimeout(() => {
+  var error = _ref.error,
+    _ref$onTimeout = _ref.onTimeout,
+    onTimeout = _ref$onTimeout === void 0 ? function () {} : _ref$onTimeout;
+  return new Promise(function (resolve, reject) {
+    setTimeout(function () {
       onTimeout();
       reject(error || new Error('Timeout'));
     }, timeout);

package/dist/global/prop-types.js

@@ -1,7 +1,9 @@
 import PropTypes from 'prop-types';
 
-const refObject = value => PropTypes.shape({
-  current: value
-});
+var refObject = function refObject(value) {
+  return PropTypes.shape({
+    current: value
+  });
+};
 
 export { refObject };

package/dist/global/react-dom-renderer.d.ts

@@ -1,16 +1,16 @@
-import { Component } from 'react';
+import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 export interface RendererProps {
     className?: string | undefined;
-    nodes: readonly Node[];
+    nodes: readonly Node[] | NodeList;
 }
 export default class Renderer extends Component<RendererProps> {
     static propTypes: {
         className: PropTypes.Requireable<string>;
-        nodes: PropTypes.Requireable<any[]>;
+        nodes: PropTypes.Requireable<object>;
     };
     componentDidMount(): void;
     node?: HTMLElement | null;
     nodeRef: (node: HTMLElement | null) => void;
-    render(): JSX.Element;
+    render(): React.JSX.Element;
 }

package/dist/global/react-dom-renderer.js

@@ -1,39 +1,55 @@
-import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.array.from.js';
+import 'core-js/modules/es.string.iterator.js';
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 
-class Renderer extends Component {
-  constructor() {
-    super(...arguments);
-    _defineProperty(this, "node", void 0);
-    _defineProperty(this, "nodeRef", node => {
-      this.node = node;
-    });
-  }
-  componentDidMount() {
-    const {
-      nodes
-    } = this.props;
-    if (!this.node || !nodes || !nodes.length) {
-      return;
+var Renderer = /*#__PURE__*/function (_Component) {
+  _inherits(Renderer, _Component);
+  var _super = _createSuper(Renderer);
+  function Renderer() {
+    var _this;
+    _classCallCheck(this, Renderer);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
-    const fragment = document.createDocumentFragment();
-    nodes.forEach(nodeToRender => fragment.appendChild(nodeToRender));
-    this.node.appendChild(fragment);
-  }
-  render() {
-    const {
-      className
-    } = this.props;
-    return /*#__PURE__*/React.createElement("div", {
-      className: className,
-      ref: this.nodeRef
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "node", void 0);
+    _defineProperty(_assertThisInitialized(_this), "nodeRef", function (node) {
+      _this.node = node;
     });
+    return _this;
   }
-}
+  _createClass(Renderer, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var node = this.node;
+      var nodes = this.props.nodes;
+      if (!node || !nodes || !nodes.length) {
+        return;
+      }
+      Array.from(this.props.nodes).forEach(function (nodeToRender) {
+        return node.appendChild(nodeToRender);
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var className = this.props.className;
+      return /*#__PURE__*/React.createElement("div", {
+        className: className,
+        ref: this.nodeRef
+      });
+    }
+  }]);
+  return Renderer;
+}(Component);
 _defineProperty(Renderer, "propTypes", {
   className: PropTypes.string,
-  nodes: PropTypes.array
+  nodes: PropTypes.oneOfType([PropTypes.array, PropTypes.object])
 });
 
 export { Renderer as default };

package/dist/global/react-render-adapter.js

@@ -1,28 +1,34 @@
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import { render as render$1, unmountComponentAtNode as unmountComponentAtNode$1, hydrate as hydrate$1 } from 'react-dom';
 
-/* eslint-disable import/no-mutable-exports */
-let render = render$1;
-let unmountComponentAtNode = unmountComponentAtNode$1;
-let hydrate = hydrate$1;
 /* eslint-enable */
-
+/* eslint-disable import/no-mutable-exports */
+var render = render$1;
+var unmountComponentAtNode = unmountComponentAtNode$1;
+var hydrate = hydrate$1;
+// TODO replace with a noop with warning in 6.0, remove in 7.0
 function setClient(_ref) {
-  let {
-    createRoot,
-    hydrateRoot
-  } = _ref;
-  const roots = new WeakMap();
-  render = (element, container) => {
-    let root = roots.get(container);
+  var createRoot = _ref.createRoot,
+    hydrateRoot = _ref.hydrateRoot;
+  var roots = new WeakMap();
+  render = function render(element, container) {
+    var root = roots.get(container);
     if (root == null) {
       root = createRoot(container);
       roots.set(container, root);
     }
     root.render(element);
   };
-  unmountComponentAtNode = container => roots.get(container)?.unmount();
-  hydrate = (element, container) => {
-    const root = hydrateRoot(container, element);
+  unmountComponentAtNode = function unmountComponentAtNode(container) {
+    var _roots$get;
+    return (_roots$get = roots.get(container)) === null || _roots$get === void 0 ? void 0 : _roots$get.unmount();
+  };
+  hydrate = function hydrate(element, container) {
+    var root = hydrateRoot(container, element);
     roots.set(container, root);
   };
 }