@jetbrains/ring-ui 5.0.155 → 5.0.157

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

@@ -1,77 +1,100 @@
+import { c as _defineProperty, j as _inherits, k as _createSuper, b as _classCallCheck, _ as _createClass } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.keys.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.slice.js';
 import angular from 'angular';
 import React from 'react';
 import { unmountComponentAtNode, render } from './react-render-adapter.js';
 import RingAngularComponent from './ring-angular-component.js';
 import Renderer from './react-dom-renderer.js';
+import 'core-js/modules/es.array.iterator.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/es.array.concat.js';
+import 'core-js/modules/es.array.from.js';
 import 'prop-types';
 
 function getAngularComponentName(name) {
-  return `rg${name}`;
+  return "rg".concat(name);
 }
 function createAngularComponent(Component) {
-  const propKeys = Object.keys(Component.propTypes);
-  const bindings = {};
-  propKeys.forEach(key => {
+  var propKeys = Object.keys(Component.propTypes);
+  var bindings = {};
+  propKeys.forEach(function (key) {
     bindings[key] = '<';
   });
-  class AngularComponent extends RingAngularComponent {
-    static bindings = bindings;
-    static transclude = true;
-    $postLink() {
-      const {
-        $transclude
-      } = this.$inject;
-      $transclude(clone => {
-        this.container = document.createElement('div');
-        for (let i = 0; i < clone.length; i++) {
-          this.container.appendChild(clone[i]);
-        }
-        this.render();
-      });
+  var AngularComponent = /*#__PURE__*/function (_RingAngularComponent) {
+    _inherits(AngularComponent, _RingAngularComponent);
+    var _super = _createSuper(AngularComponent);
+    function AngularComponent() {
+      _classCallCheck(this, AngularComponent);
+      return _super.apply(this, arguments);
     }
-    $onChanges() {
-      if (!this.container) {
-        return;
+    _createClass(AngularComponent, [{
+      key: "$postLink",
+      value: function $postLink() {
+        var _this = this;
+        var $transclude = this.$inject.$transclude;
+        $transclude(function (clone) {
+          _this.container = document.createElement('div');
+          for (var i = 0; i < clone.length; i++) {
+            _this.container.appendChild(clone[i]);
+          }
+          _this.render();
+        });
       }
-      this.render();
-    }
-    $onDestroy() {
-      unmountComponentAtNode(this.$inject.$element[0]);
-    }
-    render() {
-      var _this = this;
-      const {
-        $scope,
-        $element: {
-          0: container
+    }, {
+      key: "$onChanges",
+      value: function $onChanges() {
+        if (!this.container) {
+          return;
         }
-      } = this.$inject;
-      const props = {};
-      propKeys.forEach(key => {
-        if (this[key] !== undefined) {
-          if (typeof this[key] === 'function') {
-            props[key] = function () {
-              const ret = _this[key](...arguments);
-              $scope.$applyAsync();
-              return ret;
-            };
-          } else {
-            props[key] = this[key];
+        this.render();
+      }
+    }, {
+      key: "$onDestroy",
+      value: function $onDestroy() {
+        unmountComponentAtNode(this.$inject.$element[0]);
+      }
+    }, {
+      key: "render",
+      value: function render$1() {
+        var _this2 = this;
+        var _this$$inject = this.$inject,
+          $scope = _this$$inject.$scope,
+          container = _this$$inject.$element[0];
+        var props = {};
+        propKeys.forEach(function (key) {
+          if (_this2[key] !== undefined) {
+            if (typeof _this2[key] === 'function') {
+              props[key] = function () {
+                var ret = _this2[key].apply(_this2, arguments);
+                $scope.$applyAsync();
+                return ret;
+              };
+            } else {
+              props[key] = _this2[key];
+            }
           }
-        }
-      });
-      const hasInnerContent = this.container.hasChildNodes();
-      render( /*#__PURE__*/React.createElement(Component, props, hasInnerContent ? /*#__PURE__*/React.createElement(Renderer, {
-        nodes: this.container.childNodes
-      }) : null), container);
-    }
-  }
+        });
+        var hasInnerContent = this.container.hasChildNodes();
+        render( /*#__PURE__*/React.createElement(Component, props, hasInnerContent ? /*#__PURE__*/React.createElement(Renderer, {
+          nodes: this.container.childNodes
+        }) : null), container);
+      }
+    }]);
+    return AngularComponent;
+  }(RingAngularComponent);
+  _defineProperty(AngularComponent, "bindings", bindings);
+  _defineProperty(AngularComponent, "transclude", true);
   AngularComponent.$inject = ['$scope', '$element', '$transclude'];
   return AngularComponent;
 }
 function angularComponentFactory(Component, name) {
-  const angularModuleName = `Ring.${name[0].toLowerCase() + name.slice(1)}`;
+  var angularModuleName = "Ring.".concat(name[0].toLowerCase() + name.slice(1));
   return angular.module(angularModuleName, []).component(getAngularComponentName(name), createAngularComponent(Component));
 }
 

package/dist/global/compose.js

@@ -1,8 +1,17 @@
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.to-string.js';
+
 function compose() {
   for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
     funcs[_key] = arguments[_key];
   }
-  return funcs.reduce((acc, func) => arg => acc(func(arg)), arg => arg);
+  return funcs.reduce(function (acc, func) {
+    return function (arg) {
+      return acc(func(arg));
+    };
+  }, function (arg) {
+    return arg;
+  });
 }
 
 export { compose as default };

package/dist/global/composeRefs.js

@@ -1,14 +1,19 @@
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+
 var composeRefs = (function () {
   for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
     refs[_key] = arguments[_key];
   }
-  return value => refs.forEach(ref => {
-    if (typeof ref === 'function') {
-      ref(value);
-    } else if (ref != null) {
-      ref.current = value;
-    }
-  });
+  return function (value) {
+    return refs.forEach(function (ref) {
+      if (typeof ref === 'function') {
+        ref(value);
+      } else if (ref != null) {
+        ref.current = value;
+      }
+    });
+  };
 });
 
 export { composeRefs as default };

package/dist/global/controls-height.js

@@ -6,8 +6,8 @@ var ControlsHeight;
   ControlsHeight["M"] = "M";
   ControlsHeight["L"] = "L";
 })(ControlsHeight || (ControlsHeight = {}));
-const ControlsHeightContext = /*#__PURE__*/createContext(ControlsHeight.M);
-let globalControlsHeight = ControlsHeight.M;
+var ControlsHeightContext = /*#__PURE__*/createContext(ControlsHeight.M);
+var globalControlsHeight = ControlsHeight.M;
 // This can be used if React Context is not applicable, for example for alertService or Auth dialog
 function configureGlobalControlsHeight(value) {
   globalControlsHeight = value;

package/dist/global/create-stateful-context.js

@@ -1,15 +1,17 @@
+import { l as _slicedToArray } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { memo, createContext, useState, useContext, useEffect } from 'react';
 import PropTypes from 'prop-types';
 
 function createStatefulContext(initialValue) {
-  let name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  const ValueContext = /*#__PURE__*/createContext(initialValue);
-  const UpdateContext = /*#__PURE__*/createContext(() => {});
+  var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var ValueContext = /*#__PURE__*/createContext(initialValue);
+  var UpdateContext = /*#__PURE__*/createContext(function () {});
   function Provider(_ref) {
-    let {
-      children
-    } = _ref;
-    const [value, update] = useState(initialValue);
+    var children = _ref.children;
+    var _useState = useState(initialValue),
+      _useState2 = _slicedToArray(_useState, 2),
+      value = _useState2[0],
+      update = _useState2[1];
     return /*#__PURE__*/React.createElement(ValueContext.Provider, {
       value: value
     }, /*#__PURE__*/React.createElement(UpdateContext.Provider, {
@@ -19,29 +21,27 @@ function createStatefulContext(initialValue) {
   Provider.propTypes = {
     children: PropTypes.node
   };
-  Provider.displayName = `${name}Provider`;
+  Provider.displayName = "".concat(name, "Provider");
   function useUpdate(value, skipUpdate) {
-    const update = useContext(UpdateContext);
-    useEffect(() => {
+    var update = useContext(UpdateContext);
+    useEffect(function () {
       if (!skipUpdate) {
         update(value);
       }
     }, [update, value, skipUpdate]);
   }
   function Updater(_ref2) {
-    let {
-      value,
-      skipUpdate
-    } = _ref2;
+    var value = _ref2.value,
+      skipUpdate = _ref2.skipUpdate;
     useUpdate(value, skipUpdate);
     return null;
   }
-  Updater.displayName = `${name}Updater`;
+  Updater.displayName = "".concat(name, "Updater");
   return {
-    ValueContext,
-    UpdateContext,
-    Provider,
-    useUpdate,
+    ValueContext: ValueContext,
+    UpdateContext: UpdateContext,
+    Provider: Provider,
+    useUpdate: useUpdate,
     Updater: /*#__PURE__*/memo(Updater)
   };
 }

package/dist/global/data-tests.js

@@ -1,21 +1,29 @@
+import { d as _typeof, g as _toConsumableArray, l as _slicedToArray } from '../_helpers/_rollupPluginBabelHelpers.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';
+
 function expandMap(attrsMap) {
-  return Object.entries(attrsMap).reduce((result, _ref) => {
-    let [key, value] = _ref;
-    return value ? [...result, key] : result;
+  return Object.entries(attrsMap).reduce(function (result, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      value = _ref2[1];
+    return value ? [].concat(_toConsumableArray(result), [key]) : result;
   }, []);
 }
 function joinDataTestAttributes() {
   for (var _len = arguments.length, attrs = new Array(_len), _key = 0; _key < _len; _key++) {
     attrs[_key] = arguments[_key];
   }
-  return attrs.reduce((result, attr) => {
+  return attrs.reduce(function (result, attr) {
     if (!attr) {
       return result;
     }
-    if (typeof attr === 'object') {
-      return [...result, ...expandMap(attr)];
+    if (_typeof(attr) === 'object') {
+      return [].concat(_toConsumableArray(result), _toConsumableArray(expandMap(attr)));
     }
-    return [...result, attr];
+    return [].concat(_toConsumableArray(result), [attr]);
   }, []).join(' ');
 }
 

package/dist/global/dom.js

@@ -1,14 +1,28 @@
+import { l as _slicedToArray, _ as _createClass, b as _classCallCheck, c as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.assign.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.filter.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';
+
 /**
  * @name DOM
  */
-const getStyles = window.getComputedStyle.bind(window);
+var getStyles = window.getComputedStyle.bind(window);
 function isMounted(node) {
   if (node === document) {
     return true;
   }
   return node instanceof Node && document.documentElement.contains(node.parentNode);
 }
-const rectStub = {
+var rectStub = {
   top: 0,
   right: 0,
   bottom: 0,
@@ -18,21 +32,20 @@ const rectStub = {
 };
 function getRect(node) {
   if (node instanceof Range || node != null && isMounted(node)) {
-    const {
-      top,
-      right,
-      bottom,
-      left,
-      width,
-      height
-    } = node.getBoundingClientRect();
+    var _node$getBoundingClie = node.getBoundingClientRect(),
+      top = _node$getBoundingClie.top,
+      right = _node$getBoundingClie.right,
+      bottom = _node$getBoundingClie.bottom,
+      left = _node$getBoundingClie.left,
+      width = _node$getBoundingClie.width,
+      height = _node$getBoundingClie.height;
     return {
-      top,
-      right,
-      bottom,
-      left,
-      width,
-      height
+      top: top,
+      right: right,
+      bottom: bottom,
+      left: left,
+      width: width,
+      height: height
     };
   } else {
     return Object.assign({}, rectStub);
@@ -48,12 +61,11 @@ function getWindowWidth() {
   return window.innerWidth;
 }
 function isNodeInVisiblePartOfPage(node) {
-  const {
-    top,
-    bottom,
-    left,
-    right
-  } = getRect(node);
+  var _getRect = getRect(node),
+    top = _getRect.top,
+    bottom = _getRect.bottom,
+    left = _getRect.left,
+    right = _getRect.right;
   return !(bottom < 0 || right < 0 || getWindowHeight() - top < 0 || getWindowWidth() - left < 0);
 }
 function getDocumentScrollTop() {
@@ -62,45 +74,75 @@ function getDocumentScrollTop() {
 function getDocumentScrollLeft() {
   return document.documentElement && document.documentElement.scrollLeft || document.body.scrollLeft;
 }
-const applyMethodToClasses = method => function (classList) {
-  let classes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  classes.split(/\s+/g).filter(className => !!className).forEach(className => classList[method](className));
+var applyMethodToClasses = function applyMethodToClasses(method) {
+  return function (classList) {
+    var classes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    classes.split(/\s+/g).filter(function (className) {
+      return !!className;
+    }).forEach(function (className) {
+      return classList[method](className);
+    });
+  };
+};
+var addClasses = applyMethodToClasses('add');
+var removeClasses = applyMethodToClasses('remove');
+var toggleClasses = function toggleClasses(classList, classes) {
+  return Object.entries(classes).forEach(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      className = _ref2[0],
+      on = _ref2[1];
+    return classList.toggle(className, on);
+  });
 };
-const addClasses = applyMethodToClasses('add');
-const removeClasses = applyMethodToClasses('remove');
-const toggleClasses = (classList, classes) => Object.entries(classes).forEach(_ref => {
-  let [className, on] = _ref;
-  return classList.toggle(className, on);
-});
 function setRootStyleProperties() {
-  let properties = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  const rootStyle = document.documentElement.style;
-  Object.entries(properties).forEach(_ref2 => {
-    let [key, value] = _ref2;
+  var properties = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var rootStyle = document.documentElement.style;
+  Object.entries(properties).forEach(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+      key = _ref4[0],
+      value = _ref4[1];
     rootStyle.setProperty(key, value);
   });
 }
 function resetRootStyleProperties() {
-  let properties = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  const rootStyle = document.documentElement.style;
-  Object.keys(properties).forEach(key => rootStyle.removeProperty(key));
+  var properties = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var rootStyle = document.documentElement.style;
+  Object.keys(properties).forEach(function (key) {
+    return rootStyle.removeProperty(key);
+  });
 }
-class Listeners {
-  _all = new Set();
-  add(el, event, handler, options) {
-    el.addEventListener(event, handler, options);
-    const dispatchFn = () => el.removeEventListener(event, handler, options);
-    this._all.add(dispatchFn);
-    return dispatchFn;
+var Listeners = /*#__PURE__*/function () {
+  function Listeners() {
+    _classCallCheck(this, Listeners);
+    _defineProperty(this, "_all", new Set());
   }
-  remove(fn) {
-    fn();
-    this._all.delete(fn);
-  }
-  removeAll() {
-    this._all.forEach(fn => this.remove(fn));
-  }
-}
+  _createClass(Listeners, [{
+    key: "add",
+    value: function add(el, event, handler, options) {
+      el.addEventListener(event, handler, options);
+      var dispatchFn = function dispatchFn() {
+        return el.removeEventListener(event, handler, options);
+      };
+      this._all.add(dispatchFn);
+      return dispatchFn;
+    }
+  }, {
+    key: "remove",
+    value: function remove(fn) {
+      fn();
+      this._all.delete(fn);
+    }
+  }, {
+    key: "removeAll",
+    value: function removeAll() {
+      var _this = this;
+      this._all.forEach(function (fn) {
+        return _this.remove(fn);
+      });
+    }
+  }]);
+  return Listeners;
+}();
 // Synthetic events from Combokeys#trigger are plain objects
 function preventDefault(e) {
   if (e.preventDefault) {