@jetbrains/ring-ui 5.1.23 → 5.1.24

package/dist/docked-panel-ng/docked-panel-ng.js

@@ -0,0 +1,159 @@
+import angular from 'angular';
+import scheduleRAF from '../global/schedule-raf.js';
+import { getDocumentScrollTop, getWindowHeight } from '../global/dom.js';
+import '../_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.array.iterator.js';
+import 'core-js/modules/es.set.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+var modules_655b40c7 = {"unit":"i__const_unit_0","light":"light_rui_2ac4","dockedPanel":"dockedPanel_rui_f45d","fixed":"fixed_rui_f45d"};
+
+var scheduleAction = scheduleRAF();
+
+/**
+ * @name Docked Panel Ng
+ */
+
+var angularModule = angular.module('Ring.docked-panel', []);
+angularModule.directive('rgDockedPanel', ["$parse", function rgDockedPanelDirective($parse) {
+  return {
+    link: function link(scope, element, attrs) {
+      var TOGGLE_GAP = 8;
+      var CSS_CLASS_NAME = modules_655b40c7.dockedPanel;
+      var DOCKED_CSS_CLASS_NAME = modules_655b40c7.fixed;
+      var dockedPanelClass = attrs.rgDockedPanelClass || '';
+      var config = attrs.rgDockedPanelConfig ? $parse(attrs.rgDockedPanelConfig)(scope) : null;
+      var initialPanelPos;
+      var isDocked;
+
+      /**
+       * Container
+       * @type {Element} panel
+       */
+      var panel = element[0];
+      panel.classList.add(CSS_CLASS_NAME);
+      function getYPosition(node) {
+        var clientRect = node.getBoundingClientRect();
+        return clientRect.top + clientRect.height + getScrollContainerScrollTop();
+      }
+
+      /**
+       * Save panel initial rects and left margin and container-node for further use
+       */
+      function saveInitialPos() {
+        initialPanelPos = getYPosition(panel);
+      }
+      function getInitialUndockedPosition() {
+        return (config || {}).container ? getYPosition(config.container) : initialPanelPos;
+      }
+      function getScrollContainerScrollTop() {
+        if (config && config.scrollContainer) {
+          return config.scrollContainer.scrollTop;
+        }
+        return getDocumentScrollTop();
+      }
+      function getScrollContainerHeight() {
+        if (config && config.scrollContainer) {
+          return config.scrollContainer.getBoundingClientRect().height;
+        }
+        return getWindowHeight();
+      }
+      function onBeforeDock() {
+        if (config) {
+          if (config.beforeDock) {
+            scope.$eval(config.beforeDock(element));
+          }
+          if (config.className) {
+            panel.classList.add(config.className);
+          }
+        }
+      }
+      function onBeforeUndock() {
+        if (config) {
+          if (config.beforeUndock) {
+            scope.$eval(config.beforeUndock(element));
+          }
+          if (config.className) {
+            panel.classList.remove(config.className);
+          }
+        }
+      }
+
+      /**
+       * Docks the panel to the bottom of the page
+       */
+      function dock() {
+        onBeforeDock();
+        panel.classList.add(DOCKED_CSS_CLASS_NAME);
+        if (dockedPanelClass) {
+          panel.classList.add(dockedPanelClass);
+        }
+        isDocked = true;
+      }
+      function undock() {
+        onBeforeUndock();
+        panel.classList.remove(DOCKED_CSS_CLASS_NAME);
+        if (dockedPanelClass) {
+          panel.classList.remove(dockedPanelClass);
+        }
+        isDocked = false;
+      }
+      function onResize() {
+        if (config) {
+          if (config && config.onResize) {
+            scope.$eval(config.onResize(element, isDocked));
+          }
+        }
+      }
+
+      /**
+       * Check panel position
+       */
+      function checkPanelPosition() {
+        var currentPanelRect = panel.getBoundingClientRect();
+        if (currentPanelRect.top + currentPanelRect.height > getScrollContainerHeight() && !isDocked) {
+          dock();
+        } else if (isDocked && currentPanelRect.top + currentPanelRect.height + getScrollContainerScrollTop() >= getInitialUndockedPosition() + TOGGLE_GAP) {
+          undock();
+        }
+      }
+      function init() {
+        var _onResize = function _onResize() {
+          checkPanelPosition();
+          onResize();
+        };
+        var scrollListener = function scrollListener() {
+          return scheduleAction(checkPanelPosition);
+        };
+
+        /**
+         * Wait until all content on the page is loaded
+         */
+        scope.$applyAsync(function () {
+          var scrollContainer = (config || {}).scrollContainer || window;
+          scrollContainer.addEventListener('scroll', scrollListener);
+          window.addEventListener('resize', _onResize);
+          scope.$on('$destroy', function () {
+            scrollContainer.removeEventListener('scroll', scrollListener);
+            window.removeEventListener('resize', _onResize);
+          });
+          scheduleAction(function () {
+            saveInitialPos();
+            checkPanelPosition();
+          });
+        });
+      }
+      init();
+    }
+  };
+}]);
+var dockedPanelNg = angularModule.name;
+
+export { dockedPanelNg as default };

package/dist/dropdown/anchor.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { ButtonAttrs } from '../button/button';
+declare const _default: React.MemoExoticComponent<{
+    ({ children, className, ...restProps }: ButtonAttrs): React.JSX.Element;
+    propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+    };
+}>;
+export default _default;

package/dist/dropdown/anchor.js

@@ -0,0 +1,25 @@
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'react';
+import 'prop-types';
+import '@jetbrains/icons/chevron-10px';
+import 'classnames';
+import '../icon/icon.js';
+import '../button/button.js';
+export { A as default } from '../_helpers/anchor.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.string.starts-with.js';
+import '../global/memoize.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/web.dom-collections.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/es.array.concat.js';
+import '../link/clickableLink.js';
+import '../global/controls-height.js';
+import '../_helpers/button__classes.js';

package/dist/dropdown/dropdown.d.ts

@@ -0,0 +1,87 @@
+import React, { Component, HTMLAttributes, ReactNode, ReactElement } from 'react';
+import PropTypes from 'prop-types';
+import { PopupAttrs } from '../popup/popup';
+import Anchor from './anchor';
+export interface AnchorProps {
+    active: boolean;
+    pinned: boolean;
+}
+export interface DropdownChildProps {
+    hidden: boolean;
+    onCloseAttempt: () => void;
+    onMouseDown?: () => void | undefined;
+    onContextMenu?: () => void | undefined;
+    dontCloseOnAnchorClick: boolean;
+}
+export interface DropdownProps extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+    anchor: ReactElement | readonly ReactElement[] | string | ((props: AnchorProps) => ReactNode);
+    children: ReactElement<PopupAttrs> | ((props: Omit<PopupAttrs, 'children'>) => ReactNode);
+    initShown: boolean;
+    disabled?: boolean | null | undefined;
+    clickMode: boolean;
+    hoverMode: boolean;
+    hoverShowTimeOut: number;
+    hoverHideTimeOut: number;
+    onShow: (() => void);
+    onHide: (() => void);
+    activeClassName?: string | null | undefined;
+    'data-test'?: string | null | undefined;
+}
+interface DropdownState {
+    show: boolean;
+    pinned: boolean;
+}
+/**
+ * @name Dropdown
+ */
+export default class Dropdown extends Component<DropdownProps, DropdownState> {
+    static propTypes: {
+        /**
+         * Can be string, React element, or a function accepting an object with {active, pinned} properties and returning a React element
+         * React element should render some interactive HTML element like `button` or `a`
+         */
+        anchor: PropTypes.Validator<NonNullable<NonNullable<PropTypes.ReactNodeLike | ((...args: any[]) => any)>>>;
+        children: PropTypes.Validator<NonNullable<NonNullable<PropTypes.ReactElementLike | ((...args: any[]) => any) | null | undefined>>>;
+        initShown: PropTypes.Requireable<boolean>;
+        className: PropTypes.Requireable<string>;
+        activeClassName: PropTypes.Requireable<string>;
+        clickMode: PropTypes.Requireable<boolean>;
+        hoverMode: PropTypes.Requireable<boolean>;
+        hoverShowTimeOut: PropTypes.Requireable<number>;
+        hoverHideTimeOut: PropTypes.Requireable<number>;
+        disabled: PropTypes.Requireable<boolean>;
+        onShow: PropTypes.Requireable<(...args: any[]) => any>;
+        onHide: PropTypes.Requireable<(...args: any[]) => any>;
+        onMouseEnter: PropTypes.Requireable<(...args: any[]) => any>;
+        onMouseLeave: PropTypes.Requireable<(...args: any[]) => any>;
+        'data-test': PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        initShown: boolean;
+        clickMode: boolean;
+        hoverMode: boolean;
+        hoverShowTimeOut: number;
+        hoverHideTimeOut: number;
+        disabled: boolean;
+        onShow: () => void;
+        onHide: () => void;
+        onMouseEnter: () => void;
+        onMouseLeave: () => void;
+    };
+    state: {
+        show: boolean;
+        pinned: boolean;
+    };
+    onClick: () => void;
+    onChildCloseAttempt: () => void;
+    hoverTimer?: number | null;
+    onMouseEnter: (event: React.MouseEvent<HTMLElement>) => void;
+    onMouseLeave: (event: React.MouseEvent<HTMLElement>) => void;
+    handlePopupInteraction: () => void;
+    toggle(show?: boolean): void;
+    _toggle(show: boolean, pinned?: boolean): void;
+    _clearTimer(): void;
+    render(): React.JSX.Element;
+}
+export type DropdownAttrs = JSX.LibraryManagedAttributes<typeof Dropdown, DropdownProps>;
+export { Anchor };

package/dist/dropdown/dropdown.js

@@ -0,0 +1,248 @@
+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, { cloneElement, Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import joinDataTestAttributes from '../global/data-tests.js';
+import { isArray } from '../global/typescript-utils.js';
+import { m as modules_d9414203, A as Anchor } from '../_helpers/anchor.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 '@jetbrains/icons/chevron-10px';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.string.starts-with.js';
+import '../global/memoize.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import '../button/button.js';
+import '../link/clickableLink.js';
+import '../global/controls-height.js';
+import '../_helpers/button__classes.js';
+
+var _excluded = ["initShown", "onShow", "onHide", "hoverShowTimeOut", "hoverHideTimeOut", "children", "anchor", "className", "activeClassName", "hoverMode", "clickMode", "data-test", "disabled"];
+/**
+ * @name Dropdown
+ */
+var Dropdown = /*#__PURE__*/function (_Component) {
+  _inherits(Dropdown, _Component);
+  var _super = _createSuper(Dropdown);
+  function Dropdown() {
+    var _this;
+    _classCallCheck(this, Dropdown);
+    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), "state", {
+      show: _this.props.initShown,
+      pinned: false
+    });
+    _defineProperty(_assertThisInitialized(_this), "onClick", function () {
+      if (_this.props.disabled) {
+        return;
+      }
+      var _this$state = _this.state,
+        show = _this$state.show,
+        pinned = _this$state.pinned;
+      var nextPinned = pinned;
+      if (_this.props.hoverMode) {
+        if (!pinned) {
+          nextPinned = true;
+          if (show) {
+            _this.setState({
+              pinned: true
+            });
+            return;
+          }
+        } else {
+          nextPinned = false;
+        }
+      }
+      _this._toggle(!show, nextPinned);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onChildCloseAttempt", function () {
+      var nextPinned = _this.state.pinned;
+      if (_this.props.hoverMode) {
+        nextPinned = false;
+      }
+      _this._toggle(false, nextPinned);
+    });
+    _defineProperty(_assertThisInitialized(_this), "hoverTimer", void 0);
+    _defineProperty(_assertThisInitialized(_this), "onMouseEnter", function (event) {
+      var _this$props$onMouseEn, _this$props;
+      if (_this.props.disabled) {
+        return;
+      }
+      _this._clearTimer();
+      (_this$props$onMouseEn = (_this$props = _this.props).onMouseEnter) === null || _this$props$onMouseEn === void 0 || _this$props$onMouseEn.call(_this$props, event);
+      _this.hoverTimer = window.setTimeout(function () {
+        if (!_this.state.show) {
+          _this._toggle(true);
+        }
+      }, _this.props.hoverShowTimeOut);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onMouseLeave", function (event) {
+      var _this$props$onMouseLe, _this$props2;
+      if (_this.props.disabled) {
+        return;
+      }
+      (_this$props$onMouseLe = (_this$props2 = _this.props).onMouseLeave) === null || _this$props$onMouseLe === void 0 || _this$props$onMouseLe.call(_this$props2, event);
+      if (_this.state.pinned) {
+        return;
+      }
+      _this._clearTimer();
+      _this.hoverTimer = window.setTimeout(function () {
+        if (_this.state.show) {
+          _this._toggle(false);
+        }
+      }, _this.props.hoverHideTimeOut);
+    });
+    _defineProperty(_assertThisInitialized(_this), "handlePopupInteraction", function () {
+      _this.setState(function (_ref) {
+        var pinned = _ref.pinned;
+        return pinned ? null : {
+          pinned: true
+        };
+      });
+    });
+    return _this;
+  }
+  _createClass(Dropdown, [{
+    key: "toggle",
+    value: function toggle() {
+      var show = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : !this.state.show;
+      this._toggle(show);
+    }
+  }, {
+    key: "_toggle",
+    value: function _toggle(show) {
+      var _this2 = this;
+      var pinned = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state.pinned;
+      this.setState({
+        show,
+        pinned
+      }, function () {
+        return show ? _this2.props.onShow() : _this2.props.onHide();
+      });
+    }
+  }, {
+    key: "_clearTimer",
+    value: function _clearTimer() {
+      if (this.hoverTimer) {
+        clearTimeout(this.hoverTimer);
+        this.hoverTimer = null;
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$state2 = this.state,
+        show = _this$state2.show,
+        pinned = _this$state2.pinned;
+      var _this$props3 = this.props;
+        _this$props3.initShown;
+        _this$props3.onShow;
+        _this$props3.onHide;
+        _this$props3.hoverShowTimeOut;
+        _this$props3.hoverHideTimeOut;
+        var children = _this$props3.children,
+        anchor = _this$props3.anchor,
+        className = _this$props3.className,
+        activeClassName = _this$props3.activeClassName,
+        hoverMode = _this$props3.hoverMode,
+        clickMode = _this$props3.clickMode,
+        dataTest = _this$props3['data-test'];
+        _this$props3.disabled;
+        var restProps = _objectWithoutProperties(_this$props3, _excluded);
+      var classes = classNames(modules_d9414203.dropdown, className, {
+        [activeClassName !== null && activeClassName !== void 0 ? activeClassName : '']: activeClassName != null && show
+      });
+      var anchorElement;
+      var active = hoverMode ? pinned : show;
+      switch (typeof anchor) {
+        case 'string':
+          anchorElement = /*#__PURE__*/React.createElement(Anchor, {
+            active: active
+          }, anchor);
+          break;
+        case 'function':
+          anchorElement = anchor({
+            active: show,
+            pinned
+          });
+          break;
+        default:
+          if (isArray(anchor) || typeof anchor.type === 'string') {
+            anchorElement = anchor;
+          } else {
+            anchorElement = /*#__PURE__*/cloneElement(anchor, {
+              active
+            });
+          }
+      }
+      var childProps = {
+        hidden: !show,
+        onCloseAttempt: this.onChildCloseAttempt,
+        onMouseDown: hoverMode ? this.handlePopupInteraction : undefined,
+        onContextMenu: hoverMode ? this.handlePopupInteraction : undefined,
+        dontCloseOnAnchorClick: true
+      };
+      return /*#__PURE__*/React.createElement("div", _extends({
+        "data-test": joinDataTestAttributes('ring-dropdown', dataTest)
+      }, restProps, {
+        onClick: clickMode ? this.onClick : undefined
+        // anchorElement should be a `button` or an `a`
+        ,
+        role: "presentation",
+        onMouseEnter: hoverMode ? this.onMouseEnter : undefined,
+        onMouseLeave: hoverMode ? this.onMouseLeave : undefined,
+        className: classes
+      }), anchorElement, typeof children === 'function' ? children(childProps) : /*#__PURE__*/cloneElement(children, childProps));
+    }
+  }]);
+  return Dropdown;
+}(Component);
+_defineProperty(Dropdown, "propTypes", {
+  /**
+   * Can be string, React element, or a function accepting an object with {active, pinned} properties and returning a React element
+   * React element should render some interactive HTML element like `button` or `a`
+   */
+  anchor: PropTypes.oneOfType([PropTypes.node, PropTypes.func]).isRequired,
+  children: PropTypes.oneOfType([PropTypes.element, PropTypes.func]).isRequired,
+  initShown: PropTypes.bool,
+  className: PropTypes.string,
+  activeClassName: PropTypes.string,
+  clickMode: PropTypes.bool,
+  hoverMode: PropTypes.bool,
+  hoverShowTimeOut: PropTypes.number,
+  hoverHideTimeOut: PropTypes.number,
+  disabled: PropTypes.bool,
+  onShow: PropTypes.func,
+  onHide: PropTypes.func,
+  onMouseEnter: PropTypes.func,
+  onMouseLeave: PropTypes.func,
+  'data-test': PropTypes.string
+});
+_defineProperty(Dropdown, "defaultProps", {
+  initShown: false,
+  clickMode: true,
+  hoverMode: false,
+  hoverShowTimeOut: 300,
+  hoverHideTimeOut: 600,
+  disabled: false,
+  onShow: function onShow() {},
+  onHide: function onHide() {},
+  onMouseEnter: function onMouseEnter() {},
+  onMouseLeave: function onMouseLeave() {}
+});
+
+export { Anchor, Dropdown as default };

package/dist/dropdown-menu/dropdown-menu.d.ts

@@ -0,0 +1,26 @@
+import React, { ReactElement, ReactNodeArray, HTMLAttributes, SyntheticEvent } from 'react';
+import { SelectHandlerParams } from '../list/list';
+import { AnchorProps, DropdownAttrs } from '../dropdown/dropdown';
+import PopupMenu, { PopupMenuAttrs } from '../popup-menu/popup-menu';
+import { ListDataItem } from '../list/consts';
+export interface DropdownAnchorWrapperProps extends AnchorProps {
+    anchor: ReactElement | ReactNodeArray | string | ((props: AnchorProps, ariaProps: HTMLAttributes<HTMLElement>) => ReactElement | null);
+    activeListItemId?: string | null | undefined;
+    listId?: string | undefined;
+}
+export interface DropdownMenuProps<T = unknown> extends Omit<DropdownAttrs, 'anchor' | 'onSelect' | 'children'> {
+    anchor: ReactElement | ReactNodeArray | string | ((props: AnchorProps, ariaProps: HTMLAttributes<HTMLElement>) => ReactElement | null);
+    data?: readonly ListDataItem<T>[] | undefined;
+    ariaLabel?: string | null | undefined;
+    onSelect?: ((item: ListDataItem<T>, event: Event | SyntheticEvent, params?: SelectHandlerParams) => void) | undefined;
+    menuProps?: PopupMenuAttrs<T> | null | undefined;
+}
+declare const _default: (<T = unknown>(props: DropdownMenuProps<T> & {
+    ref?: React.Ref<PopupMenu<unknown>> | undefined;
+}) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null) & {
+    ListProps: {
+        Type: typeof import("../list/consts").Type;
+        Dimension: typeof import("../list/consts").Dimension;
+    };
+};
+export default _default;