@jetbrains/ring-ui-built 6.0.1

package/components/popup/position.js

@@ -0,0 +1,271 @@
+import { g as _objectSpread2 } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.array.sort.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.array.concat.js';
+import { getRect, isMounted, getDocumentScrollTop, getDocumentScrollLeft, getWindowHeight } from '../global/dom.js';
+import { MaxHeight, Dimension, MinWidth, Directions } from './popup.consts.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/web.dom-collections.for-each.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.array.iterator.js';
+import 'core-js/modules/es.set.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+function getScrollingCoordinates(container) {
+  if (container !== null) {
+    return {
+      top: container.scrollTop,
+      left: container.scrollLeft
+    };
+  }
+  return {
+    top: getDocumentScrollTop(),
+    left: getDocumentScrollLeft()
+  };
+}
+function getPositionStyles(popup, anchorRect, anchorLeft, anchorTop, offset) {
+  var popupWidth = popup.offsetWidth;
+  var popupHeight = popup.offsetHeight;
+  var anchorBottom = anchorTop + anchorRect.height;
+  var anchorRight = anchorLeft + anchorRect.width;
+  var popupLeft = anchorLeft - popupWidth;
+  var popupTop = anchorTop - popupHeight;
+  var popupRightToLeft = anchorRight - popupWidth;
+  var popupHorizontalCenter = anchorLeft + anchorRect.width / 2 - popupWidth / 2;
+  var popupVerticalCenter = anchorTop + anchorRect.height / 2 - popupHeight / 2;
+  var popupBottomToTop = anchorBottom - popupHeight;
+  return {
+    [Directions.BOTTOM_RIGHT]: {
+      left: anchorLeft,
+      top: anchorBottom + offset
+    },
+    [Directions.BOTTOM_LEFT]: {
+      left: popupRightToLeft,
+      top: anchorBottom + offset
+    },
+    [Directions.BOTTOM_CENTER]: {
+      left: popupHorizontalCenter,
+      top: anchorBottom + offset
+    },
+    [Directions.TOP_RIGHT]: {
+      left: anchorLeft,
+      top: popupTop - offset
+    },
+    [Directions.TOP_LEFT]: {
+      left: popupRightToLeft,
+      top: popupTop - offset
+    },
+    [Directions.TOP_CENTER]: {
+      left: popupHorizontalCenter,
+      top: popupTop - offset
+    },
+    [Directions.LEFT_BOTTOM]: {
+      left: popupLeft - offset,
+      top: anchorTop
+    },
+    [Directions.LEFT_TOP]: {
+      left: popupLeft - offset,
+      top: popupBottomToTop
+    },
+    [Directions.LEFT_CENTER]: {
+      left: popupLeft - offset,
+      top: popupVerticalCenter
+    },
+    [Directions.RIGHT_BOTTOM]: {
+      left: anchorRight + offset,
+      top: anchorTop
+    },
+    [Directions.RIGHT_TOP]: {
+      left: anchorRight + offset,
+      top: popupBottomToTop
+    },
+    [Directions.RIGHT_CENTER]: {
+      left: anchorRight + offset,
+      top: popupVerticalCenter
+    }
+  };
+}
+function verticalOverflow(styles, scrollingCoordinates, attrs) {
+  var containerHeight = attrs.container !== null ? attrs.container.clientHeight : getWindowHeight();
+  var viewportMinX = scrollingCoordinates.top + attrs.sidePadding;
+  var viewportMaxX = scrollingCoordinates.top + containerHeight - attrs.sidePadding;
+  var topOverflow = Math.max(viewportMinX - styles.top, 0);
+  var popupHeight = attrs.popup.clientHeight;
+  var verticalDiff = styles.top + popupHeight - viewportMaxX;
+  var bottomOverflow = Math.max(verticalDiff, 0);
+  return topOverflow + bottomOverflow;
+}
+function horizontalOverflow(styles, scrollingCoordinates, attrs) {
+  var containerWidth = attrs.container !== null ? attrs.container.clientWidth : window.innerWidth;
+  var viewportMinY = scrollingCoordinates.left + attrs.sidePadding;
+  var viewportMaxY = scrollingCoordinates.left + containerWidth - attrs.sidePadding;
+  var leftOverflow = Math.max(viewportMinY - styles.left, 0);
+  var popupWidth = attrs.popup.clientWidth;
+  var horizontalDiff = styles.left + popupWidth - viewportMaxY;
+  var rightOverflow = Math.max(horizontalDiff, 0);
+  return leftOverflow + rightOverflow;
+}
+var positionPropKeys = ['directions', 'autoPositioning', 'autoCorrectTopOverflow', 'sidePadding', 'top', 'left', 'offset', 'maxHeight', 'minWidth'];
+var defaultcontainerRect = {
+  top: 0,
+  left: 0
+};
+function handleTopOffScreen(_ref) {
+  var sidePadding = _ref.sidePadding,
+    styles = _ref.styles,
+    anchorRect = _ref.anchorRect,
+    maxHeight = _ref.maxHeight,
+    popupScrollHeight = _ref.popupScrollHeight,
+    direction = _ref.direction,
+    scroll = _ref.scroll;
+  var BORDER_COMPENSATION = 1;
+  var TOP_LEFT = Directions.TOP_LEFT,
+    TOP_RIGHT = Directions.TOP_RIGHT,
+    TOP_CENTER = Directions.TOP_CENTER,
+    RIGHT_TOP = Directions.RIGHT_TOP,
+    LEFT_TOP = Directions.LEFT_TOP;
+  var openedToTop = direction != null && [TOP_LEFT, TOP_RIGHT, TOP_CENTER, RIGHT_TOP, LEFT_TOP].includes(direction);
+  if (!openedToTop) {
+    return styles;
+  }
+  var isAttachedToAnchorTop = direction != null && [TOP_LEFT, TOP_CENTER, TOP_RIGHT].includes(direction);
+  var attachingPointY = isAttachedToAnchorTop ? anchorRect.top : anchorRect.bottom;
+  var effectiveHeight = maxHeight && typeof maxHeight === 'number' ? Math.min(popupScrollHeight, maxHeight) : popupScrollHeight;
+  var hypotheticalTop = attachingPointY - effectiveHeight;
+  if (hypotheticalTop <= sidePadding) {
+    styles.top = sidePadding + scroll.top;
+    styles.maxHeight = attachingPointY - sidePadding + BORDER_COMPENSATION;
+  }
+  return styles;
+}
+function maxHeightForDirection(direction, anchorNode, containerNode) {
+  var container = containerNode || document.documentElement;
+  var domRect = anchorNode.getBoundingClientRect();
+  var containerRect = container.getBoundingClientRect();
+  var containerTop = domRect.top < 0 ? containerRect.top : Math.max(containerRect.top, 0);
+  var topMaxHeight = Math.max(domRect.top - containerTop, 0);
+  var containerHeight = Math.max(containerRect.height,
+  // XXX
+  // If container is the document element
+  // then we check client height too because we may have situation when
+  // "height" from "getBoundingClientRect" less then "clientHeight".
+  container === document.documentElement ? container.clientHeight : 0);
+  var bottomMaxHeight = Math.max(containerHeight - (topMaxHeight + domRect.height), 0);
+  switch (direction) {
+    case Directions.TOP_LEFT:
+    case Directions.TOP_CENTER:
+    case Directions.TOP_RIGHT:
+      return topMaxHeight;
+    case Directions.BOTTOM_LEFT:
+    case Directions.BOTTOM_CENTER:
+    case Directions.BOTTOM_RIGHT:
+      return bottomMaxHeight;
+    case Directions.LEFT_BOTTOM:
+    case Directions.RIGHT_BOTTOM:
+      return domRect.height + bottomMaxHeight;
+    case Directions.LEFT_TOP:
+    case Directions.RIGHT_TOP:
+      return domRect.height + topMaxHeight;
+    case Directions.RIGHT_CENTER:
+    case Directions.LEFT_CENTER:
+      return domRect.height / 2 + Math.min(bottomMaxHeight / 2, topMaxHeight / 2);
+    default:
+      return null;
+  }
+}
+function position(attrs) {
+  var popup = attrs.popup,
+    anchor = attrs.anchor,
+    container = attrs.container,
+    directions = attrs.directions,
+    autoPositioning = attrs.autoPositioning,
+    sidePadding = attrs.sidePadding,
+    top = attrs.top,
+    left = attrs.left,
+    offset = attrs.offset,
+    maxHeight = attrs.maxHeight,
+    minWidth = attrs.minWidth,
+    _attrs$autoCorrectTop = attrs.autoCorrectTopOverflow,
+    autoCorrectTopOverflow = _attrs$autoCorrectTop === void 0 ? true : _attrs$autoCorrectTop;
+  var styles = {
+    top: 0,
+    left: 0
+  };
+  var chosenDirection = null;
+  var containerRect = container !== null ? getRect(container) : defaultcontainerRect;
+  var defaultAnchor = container !== null ? container : document.body;
+  var anchorRect = getRect(isMounted(anchor) ? anchor : defaultAnchor);
+  var scroll = getScrollingCoordinates(container);
+  var anchorLeft = anchorRect.left + scroll.left + left - containerRect.left;
+  var anchorTop = anchorRect.top + scroll.top + top - containerRect.top;
+  if (popup) {
+    var overflowAttrs = _objectSpread2(_objectSpread2({}, attrs), {}, {
+      popup
+    });
+    var directionsMatrix = getPositionStyles(popup, anchorRect, anchorLeft, anchorTop, offset);
+    if (!autoPositioning || directions.length === 1) {
+      styles = directionsMatrix[directions[0]];
+      chosenDirection = directions[0];
+    } else {
+      var sortedByIncreasingOverflow = directions.
+      // Fall back to the first option
+      concat(directions[0]).filter(function (direction) {
+        return directionsMatrix[direction];
+      }).map(function (direction) {
+        return {
+          styles: directionsMatrix[direction],
+          direction
+        };
+      }).sort(function (_ref2, _ref3) {
+        var stylesA = _ref2.styles;
+        var stylesB = _ref3.styles;
+        var overflowA = verticalOverflow(stylesA, scroll, overflowAttrs) + horizontalOverflow(stylesA, scroll, overflowAttrs);
+        var overflowB = verticalOverflow(stylesB, scroll, overflowAttrs) + horizontalOverflow(stylesB, scroll, overflowAttrs);
+        return overflowA - overflowB;
+      });
+      styles = sortedByIncreasingOverflow[0].styles;
+      chosenDirection = sortedByIncreasingOverflow[0].direction;
+    }
+    // because of the anchor negative margin top and left also may become negative
+    ['left', 'top'].forEach(function (key) {
+      if (styles[key] < 0) {
+        styles[key] = 0;
+      }
+    });
+  }
+  if (maxHeight === MaxHeight.SCREEN || maxHeight === 'screen') {
+    // this feature works properly only when direction is BOTTOM_* or *_BOTTOM
+    styles.maxHeight = window.innerHeight + scroll.top - styles.top - Dimension.MARGIN;
+  } else if (maxHeight) {
+    styles.maxHeight = maxHeight;
+  }
+  if (autoCorrectTopOverflow) {
+    var _popup$scrollHeight;
+    styles = handleTopOffScreen({
+      sidePadding,
+      styles,
+      anchorRect,
+      maxHeight,
+      direction: chosenDirection,
+      popupScrollHeight: (_popup$scrollHeight = popup === null || popup === void 0 ? void 0 : popup.scrollHeight) !== null && _popup$scrollHeight !== void 0 ? _popup$scrollHeight : 0,
+      scroll
+    });
+  }
+  if (minWidth === MinWidth.TARGET || minWidth === 'target') {
+    styles.minWidth = anchorRect.width;
+  } else if (minWidth) {
+    styles.minWidth = anchorRect.width < minWidth ? minWidth : anchorRect.width;
+  }
+  return {
+    styles,
+    direction: chosenDirection
+  };
+}
+
+export { Dimension, Directions, MaxHeight, MinWidth, position as default, maxHeightForDirection, positionPropKeys };

package/components/popup-menu/popup-menu.d.ts

@@ -0,0 +1,80 @@
+import React, { SyntheticEvent } from 'react';
+import Popup, { BasePopupProps } from '../popup/popup';
+import List, { ListProps as ListPropsType } from '../list/list';
+import { ListDataItem } from '../list/consts';
+export interface PopupMenuProps<T = unknown> extends Omit<ListPropsType<T>, 'maxHeight' | 'hidden'>, Omit<BasePopupProps, 'onMouseOut'> {
+    closeOnSelect: boolean;
+}
+/**
+ * @name Popup Menu
+ */
+export default class PopupMenu<T = unknown> extends Popup<PopupMenuProps<T>> {
+    static isItemType: <T_1>(listItemType: import("../list/consts").Type, item: ListDataItem<T_1>) => boolean;
+    static ListProps: {
+        Type: typeof import("../list/consts").Type;
+        Dimension: {
+            ITEM_PADDING: number;
+            ITEM_HEIGHT: number;
+            COMPACT_ITEM_HEIGHT: number;
+            SEPARATOR_HEIGHT: number;
+            SEPARATOR_FIRST_HEIGHT: number;
+            SEPARATOR_TEXT_HEIGHT: number;
+            TITLE_HEIGHT: number;
+            INNER_PADDING: number;
+            MARGIN: number;
+        };
+    };
+    static defaultProps: {
+        renderOptimization: boolean;
+        closeOnSelect: boolean;
+        shortcuts: boolean;
+        hidden: boolean;
+        onOutsideClick(): void;
+        onEscPress(): void;
+        onCloseAttempt(): void;
+        dontCloseOnAnchorClick: boolean;
+        keepMounted: boolean;
+        directions: import("../popup/popup.consts").Directions[];
+        autoPositioning: boolean;
+        autoPositioningOnScroll: boolean;
+        autoCorrectTopOverflow: boolean;
+        left: number;
+        top: number;
+        offset: number;
+        sidePadding: number;
+        attached: boolean;
+        trapFocus: boolean;
+        autoFocusFirst: boolean;
+        legacy: boolean;
+        data: never[];
+        restoreActiveIndex: boolean;
+        activateSingleItem: boolean;
+        activateFirstItem: boolean;
+        onMouseOut: () => void;
+        onSelect: () => void;
+        onScrollToBottom: () => void;
+        onResize: () => void;
+        disableMoveDownOverflow: boolean;
+        ariaLabel: string;
+    };
+    onSelect: (item: ListDataItem<T>, event: Event | SyntheticEvent) => void;
+    list?: List<T> | null;
+    listRef: (el: List<T> | null) => void;
+    /** @override */
+    getInternalContent(): React.JSX.Element;
+}
+export type PopupMenuAttrs<T = unknown> = JSX.LibraryManagedAttributes<typeof PopupMenu, PopupMenuProps<T>>;
+export declare const ListProps: {
+    Type: typeof import("../list/consts").Type;
+    Dimension: {
+        ITEM_PADDING: number;
+        ITEM_HEIGHT: number;
+        COMPACT_ITEM_HEIGHT: number;
+        SEPARATOR_HEIGHT: number;
+        SEPARATOR_FIRST_HEIGHT: number;
+        SEPARATOR_TEXT_HEIGHT: number;
+        TITLE_HEIGHT: number;
+        INNER_PADDING: number;
+        MARGIN: number;
+    };
+};

package/components/popup-menu/popup-menu.js

@@ -0,0 +1,141 @@
+import { e as _objectWithoutProperties, _ as _defineProperty, g as _objectSpread2, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import React from 'react';
+import PropTypes from 'prop-types';
+import Popup from '../popup/popup.js';
+import List from '../list/list.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 'react-dom';
+import 'classnames';
+import '../global/get-uid.js';
+import '../global/schedule-raf.js';
+import '../global/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.array.iterator.js';
+import 'core-js/modules/es.set.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 '../global/sniffer.js';
+import 'sniffr';
+import '../global/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';
+import '../popup/popup.target.js';
+import 'core-js/modules/es.symbol.js';
+import 'core-js/modules/es.symbol.description.js';
+import 'core-js/modules/es.array.find.js';
+import 'react-virtualized/dist/es/List';
+import 'react-virtualized/dist/es/AutoSizer';
+import 'react-virtualized/dist/es/WindowScroller';
+import 'react-virtualized/dist/es/CellMeasurer';
+import 'util-deprecate';
+import 'memoize-one';
+import '../global/memoize.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.weak-map.js';
+import '../global/create-stateful-context.js';
+import '../list/list__link.js';
+import '../link/link.js';
+import '../link/clickableLink.js';
+import '../_helpers/link.js';
+import '../_helpers/list.js';
+import '../list/list__item.js';
+import 'core-js/modules/es.array.index-of.js';
+import '../avatar/avatar.js';
+import '../global/url.js';
+import '../avatar/fallback-avatar.js';
+import 'core-js/modules/es.array.from.js';
+import '../checkbox/checkbox.js';
+import '@jetbrains/icons/checkmark-14px';
+import '@jetbrains/icons/remove-14px';
+import '../icon/icon.js';
+import '../icon/icon__constants.js';
+import '../_helpers/icon__svg.js';
+import 'core-js/modules/es.string.starts-with.js';
+import '../global/prop-types.js';
+import '../global/composeRefs.js';
+import '../list/list__custom.js';
+import '../global/get-event-key.js';
+import '../list/list__title.js';
+import '../list/list__separator.js';
+import '../list/list__hint.js';
+import '../list/consts.js';
+
+var _excluded = ["className"];
+var _ref = Popup.propTypes || {};
+  _ref.children;
+  var popupPropTypes = _objectWithoutProperties(_ref, ["children"]);
+/**
+ * @name Popup Menu
+ */
+var PopupMenu = /*#__PURE__*/function (_Popup) {
+  _inherits(PopupMenu, _Popup);
+  var _super = _createSuper(PopupMenu);
+  function PopupMenu() {
+    var _this;
+    _classCallCheck(this, PopupMenu);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "onSelect", function (item, event) {
+      if (_this.props.closeOnSelect) {
+        _this._onCloseAttempt(event);
+      }
+      _this.props.onSelect(item, event);
+    });
+    _defineProperty(_assertThisInitialized(_this), "list", void 0);
+    _defineProperty(_assertThisInitialized(_this), "listRef", function (el) {
+      _this.list = el;
+    });
+    return _this;
+  }
+  _createClass(PopupMenu, [{
+    key: "getInternalContent",
+    value: /** @override */
+    function getInternalContent() {
+      var _this$props = this.props;
+        _this$props.className;
+        var props = _objectWithoutProperties(_this$props, _excluded);
+      return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(List, _extends({
+        ref: this.listRef
+      }, props, {
+        maxHeight: this.popup && parseFloat(this.popup.style.maxHeight),
+        shortcuts: this.shouldUseShortcuts(),
+        onSelect: this.onSelect
+      })));
+    }
+  }]);
+  return PopupMenu;
+}(Popup);
+_defineProperty(PopupMenu, "isItemType", List.isItemType);
+_defineProperty(PopupMenu, "ListProps", List.ListProps);
+_defineProperty(PopupMenu, "defaultProps", _objectSpread2(_objectSpread2(_objectSpread2({}, List.defaultProps), Popup.defaultProps), {}, {
+  renderOptimization: false,
+  closeOnSelect: false
+}));
+PopupMenu.propTypes = _objectSpread2(_objectSpread2(_objectSpread2({}, popupPropTypes), List.propTypes), {}, {
+  closeOnSelect: PropTypes.bool
+});
+var ListProps = List.ListProps;
+
+export { ListProps, PopupMenu as default };

package/components/progress-bar/progress-bar.d.ts

@@ -0,0 +1,64 @@
+import React, { HTMLAttributes, PureComponent } from 'react';
+import PropTypes from 'prop-types';
+export interface ProgressBarProps extends HTMLAttributes<HTMLElement> {
+    max: number;
+    value: number;
+    label: string;
+    global?: boolean | null | undefined;
+    staticColor?: boolean;
+}
+/**
+ * @name Progress Bar
+ */
+export default class ProgressBar extends PureComponent<ProgressBarProps> {
+    /**
+     * @param {number} value The progress task value
+     * @param {number} max The maximum value
+     * @return {number} The progress task value in percents
+     * @private
+     */
+    static toPercent(value: number, max: number): number;
+    static propTypes: {
+        label: PropTypes.Requireable<string>;
+        /**
+         * Sets the ring-progress-bar_global class to position the progress bar on top of the screen.
+         * Should be placed directly inside body, will be positioned right below .ring-header
+         * if placed adjacent to it.
+         * @type {boolean}
+         */
+        global: PropTypes.Requireable<boolean>;
+        /**
+         * Custom class
+         * @type {string}
+         */
+        className: PropTypes.Requireable<string>;
+        style: PropTypes.Requireable<object>;
+        /**
+         * A floating point number that specifies minimum completion rate for a task to be considered
+         * complete. Default value is 1.0.
+         * @type {number}
+         */
+        max: PropTypes.Requireable<number>;
+        /**
+         * A floating point number that specifies current task completion rate.
+         * @type {number}
+         */
+        value: PropTypes.Requireable<number>;
+        /**
+         * Disables Disabled progress bar color animation and sets it to static color.
+         * @type {boolean}
+         */
+        staticColor: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        max: number;
+        value: number;
+        label: string;
+    };
+    progressbarWrapper?: (HTMLElement | null);
+    progressbarWrapperRef: (el: HTMLElement | null) => void;
+    progressbar?: (HTMLElement | null);
+    progressbarRef: (el: HTMLElement | null) => void;
+    render(): React.JSX.Element;
+}
+export type ProgressBarAttrs = JSX.LibraryManagedAttributes<typeof ProgressBar, ProgressBarProps>;

package/components/progress-bar/progress-bar.js

@@ -0,0 +1,120 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+
+var modules_fb7af416 = {"dark":"dark_rui_eb55","light":"light_rui_2ac4","progressBar":"progressBar_rui_5875","globalMode":"globalMode_rui_5875","line":"line_rui_5875","progress-bar":"progress-bar_rui_5875","staticLineColor":"staticLineColor_rui_5875"};
+
+var _excluded = ["className", "global", "max", "value", "label", "staticColor"];
+/**
+ * @name Progress Bar
+ */
+var ProgressBar = /*#__PURE__*/function (_PureComponent) {
+  _inherits(ProgressBar, _PureComponent);
+  var _super = _createSuper(ProgressBar);
+  function ProgressBar() {
+    var _this;
+    _classCallCheck(this, ProgressBar);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "progressbarWrapper", void 0);
+    _defineProperty(_assertThisInitialized(_this), "progressbarWrapperRef", function (el) {
+      _this.progressbarWrapper = el;
+    });
+    _defineProperty(_assertThisInitialized(_this), "progressbar", void 0);
+    _defineProperty(_assertThisInitialized(_this), "progressbarRef", function (el) {
+      _this.progressbar = el;
+    });
+    return _this;
+  }
+  _createClass(ProgressBar, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        className = _this$props.className,
+        global = _this$props.global,
+        max = _this$props.max,
+        value = _this$props.value,
+        label = _this$props.label,
+        staticColor = _this$props.staticColor,
+        otherProps = _objectWithoutProperties(_this$props, _excluded);
+      var width = value ? "".concat(ProgressBar.toPercent(value, max), "%") : undefined;
+      var classes = classNames(modules_fb7af416.progressBar, className, {
+        [modules_fb7af416.globalMode]: global,
+        [modules_fb7af416.staticLineColor]: staticColor
+      });
+      return /*#__PURE__*/React.createElement("div", _extends({}, otherProps, {
+        className: classes,
+        ref: this.progressbarWrapperRef
+      }), /*#__PURE__*/React.createElement("div", {
+        className: modules_fb7af416.line,
+        ref: this.progressbarRef,
+        role: "progressbar",
+        "aria-label": label,
+        "aria-valuenow": value,
+        "aria-valuemin": 0,
+        "aria-valuemax": max,
+        style: {
+          width
+        }
+      }));
+    }
+  }], [{
+    key: "toPercent",
+    value:
+    /**
+     * @param {number} value The progress task value
+     * @param {number} max The maximum value
+     * @return {number} The progress task value in percents
+     * @private
+     */
+    function toPercent(value, max) {
+      var HUNDRED_PERCENT = 100;
+      var percents = value * HUNDRED_PERCENT / max;
+      return percents > HUNDRED_PERCENT ? HUNDRED_PERCENT : percents;
+    }
+  }]);
+  return ProgressBar;
+}(PureComponent);
+_defineProperty(ProgressBar, "propTypes", {
+  label: PropTypes.string,
+  /**
+   * Sets the ring-progress-bar_global class to position the progress bar on top of the screen.
+   * Should be placed directly inside body, will be positioned right below .ring-header
+   * if placed adjacent to it.
+   * @type {boolean}
+   */
+  global: PropTypes.bool,
+  /**
+   * Custom class
+   * @type {string}
+   */
+  className: PropTypes.string,
+  style: PropTypes.object,
+  /**
+   * A floating point number that specifies minimum completion rate for a task to be considered
+   * complete. Default value is 1.0.
+   * @type {number}
+   */
+  max: PropTypes.number,
+  /**
+   * A floating point number that specifies current task completion rate.
+   * @type {number}
+   */
+  value: PropTypes.number,
+  /**
+   * Disables Disabled progress bar color animation and sets it to static color.
+   * @type {boolean}
+   */
+  staticColor: PropTypes.bool
+});
+_defineProperty(ProgressBar, "defaultProps", {
+  max: 1.0,
+  value: 0,
+  label: 'Progress'
+});
+
+export { ProgressBar as default };