@jetbrains/ring-ui 5.0.156 → 5.0.157

package/dist/global/normalize-indent.js

@@ -1,29 +1,61 @@
+import { g 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.js

@@ -1,36 +1,55 @@
+import { c as _defineProperty, j as _inherits, k as _createSuper, b as _classCallCheck, m as _assertThisInitialized, _ 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 {
-  static propTypes = {
-    className: PropTypes.string,
-    nodes: PropTypes.oneOfType([PropTypes.array, PropTypes.object])
-  };
-  componentDidMount() {
-    const {
-      node
-    } = this;
-    const {
-      nodes
-    } = this.props;
-    if (!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];
     }
-    Array.from(this.props.nodes).forEach(nodeToRender => node.appendChild(nodeToRender));
-  }
-  node;
-  nodeRef = node => {
-    this.node = node;
-  };
-  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.oneOfType([PropTypes.array, PropTypes.object])
+});
 
 export { Renderer as default };

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

@@ -1,26 +1,32 @@
+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;
+var render = render$1;
+var unmountComponentAtNode = unmountComponentAtNode$1;
+var hydrate = hydrate$1;
 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);
   };
 }

package/dist/global/rerender-hoc.js

@@ -1,7 +1,16 @@
+import { j as _inherits, k as _createSuper, _ as _createClass, b as _classCallCheck, c as _defineProperty, m as _assertThisInitialized } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.object.assign.js';
 import { createElement } from 'react';
 import { render } from './react-render-adapter.js';
 import composeRefs from './composeRefs.js';
+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 'react-dom';
+import 'core-js/modules/web.dom-collections.for-each.js';
 
 /**
  * Wraps a component to add a "rerender" method
@@ -10,24 +19,40 @@ import 'react-dom';
  * @returns {Rerenderer}
  */
 function rerenderHOC(ComposedComponent) {
-  return class Rerenderer extends ComposedComponent {
-    _propsCache = this.props;
-    rerender() {
-      let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      let callback = arguments.length > 1 ? arguments[1] : undefined;
-      let container;
-      try {
-        container = this.node?.parentNode;
-      } finally {
-        if (!container || !(container instanceof Element)) {
-          throw new Error(`${this.constructor.name} component isn't mounted`);
-        }
+  return /*#__PURE__*/function (_ComposedComponent) {
+    _inherits(Rerenderer, _ComposedComponent);
+    var _super = _createSuper(Rerenderer);
+    function Rerenderer() {
+      var _this;
+      _classCallCheck(this, Rerenderer);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
       }
-      this._propsCache = Object.assign({}, this.props, this._propsCache, props);
-      this._propsCache.ref = composeRefs(this._propsCache.ref, callback);
-      render( /*#__PURE__*/createElement(this.constructor, this._propsCache), container);
+      _this = _super.call.apply(_super, [this].concat(args));
+      _defineProperty(_assertThisInitialized(_this), "_propsCache", _this.props);
+      return _this;
     }
-  };
+    _createClass(Rerenderer, [{
+      key: "rerender",
+      value: function rerender() {
+        var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        var callback = arguments.length > 1 ? arguments[1] : undefined;
+        var container;
+        try {
+          var _this$node;
+          container = (_this$node = this.node) === null || _this$node === void 0 ? void 0 : _this$node.parentNode;
+        } finally {
+          if (!container || !(container instanceof Element)) {
+            throw new Error("".concat(this.constructor.name, " component isn't mounted"));
+          }
+        }
+        this._propsCache = Object.assign({}, this.props, this._propsCache, props);
+        this._propsCache.ref = composeRefs(this._propsCache.ref, callback);
+        render( /*#__PURE__*/createElement(this.constructor, this._propsCache), container);
+      }
+    }]);
+    return Rerenderer;
+  }(ComposedComponent);
 }
 
 export { rerenderHOC as default };

package/dist/global/ring-angular-component.js

@@ -1,17 +1,27 @@
-class RingAngularComponent {
-  static get controller() {
-    return this;
-  }
-  $inject = {};
-  constructor() {
-    var _this$constructor$$in;
+import { _ as _createClass, b as _classCallCheck, c as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+
+var RingAngularComponent = /*#__PURE__*/function () {
+  function RingAngularComponent() {
+    var _this$constructor$$in,
+      _this = this;
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    ((_this$constructor$$in = this.constructor.$inject) !== null && _this$constructor$$in !== void 0 ? _this$constructor$$in : []).forEach((injectName, i) => {
-      this.$inject[injectName] = args[i];
+    _classCallCheck(this, RingAngularComponent);
+    _defineProperty(this, "$inject", {});
+    ((_this$constructor$$in = this.constructor.$inject) !== null && _this$constructor$$in !== void 0 ? _this$constructor$$in : []).forEach(function (injectName, i) {
+      _this.$inject[injectName] = args[i];
     });
   }
-}
+  _createClass(RingAngularComponent, null, [{
+    key: "controller",
+    get: function get() {
+      return this;
+    }
+  }]);
+  return RingAngularComponent;
+}();
 
 export { RingAngularComponent as default };

package/dist/global/schedule-raf.js

@@ -1,10 +1,11 @@
 function scheduleRAF(trailingCall) {
-  let scheduledCb;
-  let RAF;
-  let trailingCallScheduled = false;
+  var scheduledCb;
+  var RAF;
+  var trailingCallScheduled = false;
   function doSchedule() {
-    RAF = window.requestAnimationFrame(() => {
-      scheduledCb?.();
+    RAF = window.requestAnimationFrame(function () {
+      var _scheduledCb;
+      (_scheduledCb = scheduledCb) === null || _scheduledCb === void 0 ? void 0 : _scheduledCb();
       if (trailingCallScheduled) {
         trailingCallScheduled = false;
         doSchedule();

package/dist/global/sniffer.js

@@ -1,6 +1,6 @@
 import Sniffr from 'sniffr';
 
-const sniffr = new Sniffr();
+var sniffr = new Sniffr();
 sniffr.sniff();
 
 export { sniffr as default };

package/dist/global/theme.js

@@ -7,14 +7,38 @@ import '../popup/popup.js';
 export { a as ThemeProvider, W as WithThemeClasses, c as applyTheme, T as default, u as useTheme, b as useThemeClasses } from '../_helpers/theme.js';
 import './get-uid.js';
 import 'prop-types';
+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.object.entries.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
 import './schedule-raf.js';
 import './dom.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.string.split.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';
 import '../shortcuts/shortcuts.js';
+import 'core-js/modules/es.array.map.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 './sniffer.js';
 import 'sniffr';
 import './data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
 import '../tab-trap/tab-trap.js';
 import '../popup/position.js';
+import 'core-js/modules/es.array.sort.js';
 import '../popup/popup.consts.js';

package/dist/global/trivial-template-tag.js

@@ -1,12 +1,19 @@
-const TWO = 2;
+import { g as _toConsumableArray } from '../_helpers/_rollupPluginBabelHelpers.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.splice.js';
+
+var TWO = 2;
 function trivialTemplateTag(f) {
   return function (strings) {
-    const chunks = [...strings];
+    var chunks = _toConsumableArray(strings);
     // insert the interpolations where they belong to
     for (var _len = arguments.length, interpolations = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
       interpolations[_key - 1] = arguments[_key];
     }
-    interpolations.forEach((value, i) => chunks.splice(TWO * i + 1, 0, value));
+    interpolations.forEach(function (value, i) {
+      return chunks.splice(TWO * i + 1, 0, value);
+    });
     return f(chunks.join(''));
   };
 }

package/dist/global/typescript-utils.js

@@ -1,4 +1,8 @@
-const isArray = arg => Array.isArray(arg);
-const isTruthy = arg => Boolean(arg);
+var isArray = function isArray(arg) {
+  return Array.isArray(arg);
+};
+var isTruthy = function isTruthy(arg) {
+  return Boolean(arg);
+};
 
 export { isArray, isTruthy };

package/dist/global/url.js

@@ -1,24 +1,30 @@
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.index-of.js';
+import 'core-js/modules/es.string.replace.js';
+
 /**
  * @description Provides a set of utilities for URL manipulation.
  */
 /**
  * @const {RegExp}
  */
-const ORIGIN_PATTERN = /^[a-z]+:\/\/[^/]+/i;
+var ORIGIN_PATTERN = /^[a-z]+:\/\/[^/]+/i;
 /**
  * @const {RegExp}
  */
-const ABSOLUTE_URL_PATTERN = /^[a-z]+:\/\//i;
+var ABSOLUTE_URL_PATTERN = /^[a-z]+:\/\//i;
 /**
  * @const {RegExp}
  */
-const ENDING_SLASH_PATTERN = /\/$/;
+var ENDING_SLASH_PATTERN = /\/$/;
 /**
  * Get URI from the <base> tag
  * @return {string|undefined} base URI
  */
 function getBaseURI() {
-  const baseElement = document.getElementsByTagName('base')[0];
+  var baseElement = document.getElementsByTagName('base')[0];
   return baseElement ? baseElement.href : undefined;
 }
 /**
@@ -26,9 +32,9 @@ function getBaseURI() {
  * @return {string} absolute base URI
  */
 function getAbsoluteBaseURL() {
-  const baseUrl = getBaseURI();
-  const host = `${window.location.protocol}//${window.location.host}`;
-  let uri;
+  var baseUrl = getBaseURI();
+  var host = "".concat(window.location.protocol, "//").concat(window.location.host);
+  var uri;
   if (baseUrl) {
     uri = ABSOLUTE_URL_PATTERN.test(baseUrl) ? baseUrl : host + baseUrl;
   } else {
@@ -42,7 +48,7 @@ function getAbsoluteBaseURL() {
  * @returns {string|undefined} origin
  */
 function getOrigin(url) {
-  const matches = url.match(ORIGIN_PATTERN);
+  var matches = url.match(ORIGIN_PATTERN);
   if (matches) {
     return matches[0];
   }
@@ -64,9 +70,9 @@ function getAbsoluteURL() {
  * @return {string} fixed URL
  */
 function fixUrl(url) {
-  let baseURIGetter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getBaseURI;
+  var baseURIGetter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getBaseURI;
   if (url.indexOf('http://') === -1 && url.indexOf('https://') === -1 && url.indexOf('/') !== 0) {
-    const baseUrl = baseURIGetter();
+    var baseUrl = baseURIGetter();
     if (baseUrl) {
       return baseUrl + url;
     }
@@ -92,21 +98,21 @@ function parseQueryString(queryString) {
   if (queryString == null) {
     return {};
   }
-  const queryParameterPairRE = /([^&;=]+)=?([^&;]*)/g;
-  const FIRST_PAIR_ELEMENT = 1;
-  const SECOND_PAIR_ELEMENT = 2;
-  const urlParams = {};
+  var queryParameterPairRE = /([^&;=]+)=?([^&;]*)/g;
+  var FIRST_PAIR_ELEMENT = 1;
+  var SECOND_PAIR_ELEMENT = 2;
+  var urlParams = {};
   function decode(s) {
     return decodeURIComponent(s.replace(/\+/g, ' '));
   }
-  let matchedQueryPair;
+  var matchedQueryPair;
   while ((matchedQueryPair = queryParameterPairRE.exec(queryString)) != null) {
     urlParams[decode(matchedQueryPair[FIRST_PAIR_ELEMENT])] = decode(matchedQueryPair[SECOND_PAIR_ELEMENT]);
   }
   return urlParams;
 }
 function customEncodeURIComponent(str) {
-  const commaRE = /%2C/g;
+  var commaRE = /%2C/g;
   return encodeURIComponent(String(str)).replace(commaRE, ',');
 }
 /**
@@ -117,11 +123,11 @@ function customEncodeURIComponent(str) {
  * @returns {string} encoded URL
  */
 function encodeURL(url, params) {
-  const equalsSign = '=';
-  const firstSeparator = url.indexOf('?') === -1 ? '?' : '&';
-  let res = url;
-  let k;
-  let i = 0;
+  var equalsSign = '=';
+  var firstSeparator = url.indexOf('?') === -1 ? '?' : '&';
+  var res = url;
+  var k;
+  var i = 0;
   for (k in params) {
     if (params.hasOwnProperty(k) && params[k] != null) {
       res += (i++ === 0 ? firstSeparator : '&') + customEncodeURIComponent(k) + equalsSign + customEncodeURIComponent(params[k]);

package/dist/global/use-event-callback.js

@@ -1,18 +1,16 @@
 import { useRef, useLayoutEffect, useCallback } from 'react';
 
 function useEventCallback(fn) {
-  const ref = useRef();
-  useLayoutEffect(() => {
+  var ref = useRef();
+  useLayoutEffect(function () {
     ref.current = fn;
   });
   return useCallback(function () {
-    const {
-      current
-    } = ref;
+    var current = ref.current;
     if (current == null) {
       throw new Error('callback created in useEventCallback can only be called from event handlers');
     }
-    return current(...arguments);
+    return current.apply(void 0, arguments);
   }, []);
 }