@jetbrains/ring-ui 5.1.1 → 6.0.2-beta.0

package/dist/loader/loader__core.js

@@ -1,17 +1,30 @@
-import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, d as _createClass, c as _classCallCheck } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.fill.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.regexp.exec.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 { getPixelRatio } from '../global/dom.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_00b5ad26 = {"unit":"8px","light":"light_rui_47a4","canvas":"canvas_rui_47a4","animate":"animate_rui_47a4","rotation-keyframes":"rotation-keyframes_rui_47a4","text":"text_rui_47a4"};
+var modules_00b5ad26 = {"unit":"i__const_unit_0","light":"light_rui_2ac4","canvas":"canvas_rui_47a4","animate":"animate_rui_47a4","rotation-keyframes":"rotation-keyframes_rui_47a4","text":"text_rui_47a4"};
 
-const INITIAL_TICKS = 100;
-class Particle {
-  constructor(_ref) {
-    let {
-      x,
-      y,
-      radius,
-      color
-    } = _ref;
+var INITIAL_TICKS = 100;
+var Particle = /*#__PURE__*/function () {
+  function Particle(_ref) {
+    var x = _ref.x,
+      y = _ref.y,
+      radius = _ref.radius,
+      color = _ref.color;
+    _classCallCheck(this, Particle);
     _defineProperty(this, "radius", void 0);
     _defineProperty(this, "x", void 0);
     _defineProperty(this, "y", void 0);
@@ -25,34 +38,36 @@ class Particle {
     this.decay = 0.01;
     this.life = 1;
   }
-  step() {
-    this.life -= this.decay;
-  }
-  isAlive() {
-    return this.life >= 0;
-  }
-  draw(ctx) {
-    const alpha = this.life >= 0 ? this.life : 0;
-    ctx.fillStyle = `rgba(${this.color.r}, ${this.color.g}, ${this.color.b}, ${alpha})`;
-    ctx.beginPath();
-    ctx.arc(this.x + this.radius, this.y + this.radius, this.radius, 0, Math.PI * 2);
-    ctx.fill();
-  }
-}
-const DETERMINISTIC_VALUE = 0.5;
+  _createClass(Particle, [{
+    key: "step",
+    value: function step() {
+      this.life -= this.decay;
+    }
+  }, {
+    key: "isAlive",
+    value: function isAlive() {
+      return this.life >= 0;
+    }
+  }, {
+    key: "draw",
+    value: function draw(ctx) {
+      var alpha = this.life >= 0 ? this.life : 0;
+      ctx.fillStyle = "rgba(".concat(this.color.r, ", ").concat(this.color.g, ", ").concat(this.color.b, ", ").concat(alpha, ")");
+      ctx.beginPath();
+      ctx.arc(this.x + this.radius, this.y + this.radius, this.radius, 0, Math.PI * 2);
+      ctx.fill();
+    }
+  }]);
+  return Particle;
+}();
+var DETERMINISTIC_VALUE = 0.5;
 function deterministic() {
   return DETERMINISTIC_VALUE;
 }
-class LoaderCore {
-  static calculateGradient(startColor, stopColor, position) {
-    const calculateChannelValue = (a, b) => a + Math.round((b - a) * position);
-    return {
-      r: calculateChannelValue(startColor.r, stopColor.r),
-      g: calculateChannelValue(startColor.g, stopColor.g),
-      b: calculateChannelValue(startColor.b, stopColor.b)
-    };
-  }
-  constructor(containerNode, props) {
+var LoaderCore = /*#__PURE__*/function () {
+  function LoaderCore(containerNode, props) {
+    var _this$ctx;
+    _classCallCheck(this, LoaderCore);
     _defineProperty(this, "props", void 0);
     _defineProperty(this, "canvas", void 0);
     _defineProperty(this, "textNode", void 0);
@@ -83,15 +98,15 @@ class LoaderCore {
     this.textNode.textContent = this.props.message ? this.props.message : '';
     containerNode.appendChild(this.canvas);
     containerNode.appendChild(this.textNode);
-    const pixelRatio = LoaderCore.getPixelRatio();
-    const canvasSize = this.props.size * pixelRatio;
+    var pixelRatio = LoaderCore.getPixelRatio();
+    var canvasSize = this.props.size * pixelRatio;
     this.canvas.width = canvasSize;
     this.canvas.height = canvasSize;
     //Fixate canvas physical size to avoid real size scaling
-    this.canvas.style.width = `${this.props.size}px`;
-    this.canvas.style.height = `${this.props.size}px`;
+    this.canvas.style.width = "".concat(this.props.size, "px");
+    this.canvas.style.height = "".concat(this.props.size, "px");
     this.ctx = this.canvas.getContext('2d');
-    this.ctx?.scale(pixelRatio, pixelRatio);
+    (_this$ctx = this.ctx) === null || _this$ctx === void 0 ? void 0 : _this$ctx.scale(pixelRatio, pixelRatio);
     this.height = this.props.size;
     this.width = this.props.size;
     this.particles = [];
@@ -117,99 +132,152 @@ class LoaderCore {
       this.draw();
     }
   }
-  static getPixelRatio() {
-    return getPixelRatio();
-  }
-  prepareInitialState(ticks) {
-    for (let i = 0; i < ticks; i++) {
-      this.step();
+  _createClass(LoaderCore, [{
+    key: "prepareInitialState",
+    value: function prepareInitialState(ticks) {
+      for (var i = 0; i < ticks; i++) {
+        this.step();
+      }
     }
-  }
-  handleLimits(coord, radius, speed, limit) {
-    const randomFunc = this.props.deterministic ? deterministic : Math.random;
-    const randomizedSpeedChange = randomFunc() - this.baseSpeed / 2;
-    if (coord + radius * 2 + this.baseSpeed >= limit) {
-      return -(this.baseSpeed + randomizedSpeedChange);
-    } else if (coord <= this.baseSpeed) {
-      return this.baseSpeed + randomizedSpeedChange;
-    }
-    return speed;
-  }
-  calculateNextCoordinates() {
-    this.x += this.hSpeed;
-    this.y += this.vSpeed;
-    this.hSpeed = this.handleLimits(this.x, this.radius, this.hSpeed, this.width);
-    this.vSpeed = this.handleLimits(this.y, this.radius, this.vSpeed, this.height);
-  }
-  calculateNextRadius() {
-    this.radius += this.radiusSpeed;
-    if (this.radius > this.maxRadius || this.radius < this.minRadius) {
-      this.radiusSpeed = -this.radiusSpeed;
+  }, {
+    key: "handleLimits",
+    value: function handleLimits(coord, radius, speed, limit) {
+      var randomFunc = this.props.deterministic ? deterministic : Math.random;
+      var randomizedSpeedChange = randomFunc() - this.baseSpeed / 2;
+      if (coord + radius * 2 + this.baseSpeed >= limit) {
+        return -(this.baseSpeed + randomizedSpeedChange);
+      } else if (coord <= this.baseSpeed) {
+        return this.baseSpeed + randomizedSpeedChange;
+      }
+      return speed;
     }
-  }
-  getNextColor() {
-    const colors = this.props.colors;
-    const currentColor = colors[this.colorIndex];
-    const nextColor = colors[this.colorIndex + 1] || colors[0];
-    return LoaderCore.calculateGradient(currentColor, nextColor, this.tick / this.colorChangeTick);
-  }
-  nextTick() {
-    this.tick++;
-    if (this.tick > this.colorChangeTick) {
-      this.tick = 0;
-      this.colorIndex++;
-      if (this.colorIndex > this.props.colors.length - 1) {
-        this.colorIndex = 0;
+  }, {
+    key: "calculateNextCoordinates",
+    value: function calculateNextCoordinates() {
+      this.x += this.hSpeed;
+      this.y += this.vSpeed;
+      this.hSpeed = this.handleLimits(this.x, this.radius, this.hSpeed, this.width);
+      this.vSpeed = this.handleLimits(this.y, this.radius, this.vSpeed, this.height);
+    }
+  }, {
+    key: "calculateNextRadius",
+    value: function calculateNextRadius() {
+      this.radius += this.radiusSpeed;
+      if (this.radius > this.maxRadius || this.radius < this.minRadius) {
+        this.radiusSpeed = -this.radiusSpeed;
       }
     }
-  }
-  step() {
-    this.nextTick();
-    this.calculateNextCoordinates();
-    this.calculateNextRadius();
-    this.particles.forEach(particle => particle.step());
-    this.particles.push(new Particle({
-      x: this.x,
-      y: this.y,
-      radius: this.radius,
-      color: this.getNextColor()
-    }));
-  }
-  removeDeadParticles() {
-    this.particles = this.particles.filter(it => it.isAlive());
-  }
-  draw() {
-    const ctx = this.ctx;
-    if (ctx == null) {
-      return;
-    }
-    ctx.clearRect(0, 0, this.width, this.height);
-    this.removeDeadParticles();
-    this.particles.forEach(particle => particle.draw(ctx));
-  }
-  loop() {
-    this.step();
-    this.draw();
-    if (this.isRunning) {
-      window.requestAnimationFrame(() => this.loop());
+  }, {
+    key: "getNextColor",
+    value: function getNextColor() {
+      var colors = this.props.colors;
+      var currentColor = colors[this.colorIndex];
+      var nextColor = colors[this.colorIndex + 1] || colors[0];
+      return LoaderCore.calculateGradient(currentColor, nextColor, this.tick / this.colorChangeTick);
     }
-  }
-  updateMessage(text) {
-    this.textNode.textContent = text || '';
-  }
-  stopAnimation() {
-    this.isRunning = false;
-    this.canvas.classList.remove(modules_00b5ad26.animate);
-  }
-  startAnimation() {
-    this.isRunning = true;
-    this.canvas.classList.add(modules_00b5ad26.animate);
-    this.loop();
-  }
-  destroy() {
-    this.isRunning = false;
-  }
-}
+  }, {
+    key: "nextTick",
+    value: function nextTick() {
+      this.tick++;
+      if (this.tick > this.colorChangeTick) {
+        this.tick = 0;
+        this.colorIndex++;
+        if (this.colorIndex > this.props.colors.length - 1) {
+          this.colorIndex = 0;
+        }
+      }
+    }
+  }, {
+    key: "step",
+    value: function step() {
+      this.nextTick();
+      this.calculateNextCoordinates();
+      this.calculateNextRadius();
+      this.particles.forEach(function (particle) {
+        return particle.step();
+      });
+      this.particles.push(new Particle({
+        x: this.x,
+        y: this.y,
+        radius: this.radius,
+        color: this.getNextColor()
+      }));
+    }
+  }, {
+    key: "removeDeadParticles",
+    value: function removeDeadParticles() {
+      this.particles = this.particles.filter(function (it) {
+        return it.isAlive();
+      });
+    }
+  }, {
+    key: "draw",
+    value: function draw() {
+      var ctx = this.ctx;
+      if (ctx == null) {
+        return;
+      }
+      ctx.clearRect(0, 0, this.width, this.height);
+      this.removeDeadParticles();
+      this.particles.forEach(function (particle) {
+        return particle.draw(ctx);
+      });
+    }
+  }, {
+    key: "loop",
+    value: function loop() {
+      var _this = this;
+      this.step();
+      this.draw();
+      if (this.isRunning) {
+        window.requestAnimationFrame(function () {
+          return _this.loop();
+        });
+      }
+    }
+  }, {
+    key: "updateMessage",
+    value: function updateMessage(text) {
+      this.textNode.textContent = text || '';
+    }
+  }, {
+    key: "stopAnimation",
+    value: function stopAnimation() {
+      this.isRunning = false;
+      this.canvas.classList.remove(modules_00b5ad26.animate);
+    }
+  }, {
+    key: "startAnimation",
+    value: function startAnimation() {
+      this.isRunning = true;
+      this.canvas.classList.add(modules_00b5ad26.animate);
+      this.loop();
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.isRunning = false;
+    }
+  }], [{
+    key: "calculateGradient",
+    value: function calculateGradient(startColor, stopColor, position) {
+      var calculateChannelValue = function calculateChannelValue(a, b) {
+        return a + Math.round((b - a) * position);
+      };
+      return {
+        r: calculateChannelValue(startColor.r, stopColor.r),
+        g: calculateChannelValue(startColor.g, stopColor.g),
+        b: calculateChannelValue(startColor.b, stopColor.b)
+      };
+    }
+  }, {
+    key: "getPixelRatio",
+    value: function getPixelRatio$1() {
+      return getPixelRatio();
+    }
+  }]);
+  return LoaderCore;
+}();
 _defineProperty(LoaderCore, "defaultProps", {
   size: 64,
   stop: false,

package/dist/loader-inline/loader-inline.d.ts

@@ -1,4 +1,4 @@
-import { HTMLAttributes, PureComponent } from 'react';
+import React, { HTMLAttributes, PureComponent } from 'react';
 import PropTypes from 'prop-types';
 export interface LoaderInlineProps extends HTMLAttributes<HTMLDivElement> {
     'data-test'?: string | null | undefined;
@@ -12,7 +12,7 @@ declare class LoaderInline extends PureComponent<LoaderInlineProps> {
         'data-test': PropTypes.Requireable<string>;
         children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
     };
-    render(): JSX.Element;
+    render(): React.JSX.Element;
 }
 export type LoaderInlineAtrrs = JSX.LibraryManagedAttributes<typeof LoaderInline, LoaderInlineProps>;
 export default LoaderInline;

package/dist/loader-inline/loader-inline.js

@@ -1,31 +1,46 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import classNames from 'classnames';
 import PropTypes from 'prop-types';
 import joinDataTestAttributes from '../global/data-tests.js';
-import { m as modules_e49a3529 } from '../_helpers/loader-inline.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';
 
+var modules_e49a3529 = {"dark":"dark_rui_eb55","unit":"i__const_unit_1","light":"light_rui_2ac4","loader":"loader_rui_e6f2","spin":"spin_rui_e6f2","pulse":"pulse_rui_e6f2","children":"children_rui_e6f2"};
+
+var _excluded = ["className", "data-test", "children"];
 /**
  * @name Loader Inline
  */
-class LoaderInline extends PureComponent {
-  render() {
-    const {
-      className,
-      'data-test': dataTest,
-      children,
-      ...restProps
-    } = this.props;
-    const classes = classNames(modules_e49a3529.loader, className);
-    const loader = /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
-      "data-test": joinDataTestAttributes('ring-loader-inline', dataTest),
-      className: classes
-    }));
-    return children ? /*#__PURE__*/React.createElement(React.Fragment, null, loader, /*#__PURE__*/React.createElement("span", {
-      className: modules_e49a3529.children
-    }, children)) : loader;
+var LoaderInline = /*#__PURE__*/function (_PureComponent) {
+  _inherits(LoaderInline, _PureComponent);
+  var _super = _createSuper(LoaderInline);
+  function LoaderInline() {
+    _classCallCheck(this, LoaderInline);
+    return _super.apply(this, arguments);
   }
-}
+  _createClass(LoaderInline, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        className = _this$props.className,
+        dataTest = _this$props['data-test'],
+        children = _this$props.children,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      var classes = classNames(modules_e49a3529.loader, className);
+      var loader = /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+        "data-test": joinDataTestAttributes('ring-loader-inline', dataTest),
+        className: classes
+      }));
+      return children ? /*#__PURE__*/React.createElement(React.Fragment, null, loader, /*#__PURE__*/React.createElement("span", {
+        className: modules_e49a3529.children
+      }, children)) : loader;
+    }
+  }]);
+  return LoaderInline;
+}(PureComponent);
 _defineProperty(LoaderInline, "propTypes", {
   className: PropTypes.string,
   'data-test': PropTypes.string,

package/dist/loader-screen/loader-screen.d.ts

@@ -1,4 +1,4 @@
-import { PureComponent } from 'react';
+import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import { LoaderProps } from '../loader/loader';
 export interface LoaderScreenProps extends LoaderProps {
@@ -13,5 +13,5 @@ export default class LoaderScreen extends PureComponent<LoaderScreenProps> {
         containerClassName: PropTypes.Requireable<string>;
         message: PropTypes.Requireable<string>;
     };
-    render(): JSX.Element;
+    render(): React.JSX.Element;
 }

package/dist/loader-screen/loader-screen.js

@@ -1,36 +1,60 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import classNames from 'classnames';
 import PropTypes from 'prop-types';
 import Loader from '../loader/loader.js';
-import { m as modules_122a82e9 } from '../_helpers/loader-screen.js';
+import 'core-js/modules/es.array.concat.js';
 import '../global/data-tests.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 '../loader/loader__core.js';
+import 'core-js/modules/es.array.fill.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.array.filter.js';
 import '../global/dom.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';
 
+var modules_122a82e9 = {"light":"light_rui_2ac4","loaderScreen":"loaderScreen_rui_c963","loader":"loader_rui_c963","loaderWithoutSpacing":"loaderWithoutSpacing_rui_c963"};
+
+var _excluded = ["message", "className", "containerClassName"];
 /**
  * @name Loader Screen
  */
-class LoaderScreen extends PureComponent {
-  render() {
-    const {
-      message,
-      className,
-      containerClassName,
-      ...restProps
-    } = this.props;
-    const containerClasses = classNames(containerClassName, modules_122a82e9.loaderScreen);
-    const loaderClasses = classNames(className, modules_122a82e9.loader, {
-      [modules_122a82e9.loaderWithoutSpacing]: !message
-    });
-    return /*#__PURE__*/React.createElement("div", {
-      className: containerClasses
-    }, /*#__PURE__*/React.createElement(Loader, _extends({}, restProps, {
-      message: message,
-      className: loaderClasses
-    })));
+var LoaderScreen = /*#__PURE__*/function (_PureComponent) {
+  _inherits(LoaderScreen, _PureComponent);
+  var _super = _createSuper(LoaderScreen);
+  function LoaderScreen() {
+    _classCallCheck(this, LoaderScreen);
+    return _super.apply(this, arguments);
   }
-}
+  _createClass(LoaderScreen, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        message = _this$props.message,
+        className = _this$props.className,
+        containerClassName = _this$props.containerClassName,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      var containerClasses = classNames(containerClassName, modules_122a82e9.loaderScreen);
+      var loaderClasses = classNames(className, modules_122a82e9.loader, _defineProperty({}, modules_122a82e9.loaderWithoutSpacing, !message));
+      return /*#__PURE__*/React.createElement("div", {
+        className: containerClasses
+      }, /*#__PURE__*/React.createElement(Loader, _extends({}, restProps, {
+        message: message,
+        className: loaderClasses
+      })));
+    }
+  }]);
+  return LoaderScreen;
+}(PureComponent);
 _defineProperty(LoaderScreen, "propTypes", {
   className: PropTypes.string,
   containerClassName: PropTypes.string,

package/dist/login-dialog/login-dialog.d.ts

@@ -1,4 +1,4 @@
-import { Component, ReactNode } from 'react';
+import React, { Component, ReactNode } from 'react';
 import PropTypes from 'prop-types';
 export interface LoginDialogProps {
     onCancel: () => void;
@@ -42,6 +42,6 @@ export default class LoginDialog extends Component<LoginDialogProps> {
     showFallbackTimout?: number;
     startFallbackCountdown(): void;
     onMessage: (event: MessageEvent) => void;
-    render(): JSX.Element;
+    render(): React.JSX.Element;
 }
 export type LoginDialogAttrs = JSX.LibraryManagedAttributes<typeof LoginDialog, LoginDialogProps>;