@jetbrains/ring-ui 4.2.9 → 4.2.10

package/dist/island/content.js

@@ -0,0 +1,160 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import React, { Component, forwardRef } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import createResizeDetector from 'element-resize-detector';
+import scheduleRAF from '../global/schedule-raf.js';
+import { m as modules_e6a056e1 } from '../_helpers/island.js';
+import { ScrollHandlerContext } from './adaptive-island-hoc.js';
+import '../global/linear-function.js';
+
+const scheduleScrollAction = scheduleRAF();
+
+const noop = () => {};
+
+const END_DISTANCE = 16;
+
+class Content extends Component {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "state", {
+      scrolledToTop: true,
+      scrolledToBottom: false
+    });
+
+    _defineProperty(this, "resizeDetector", createResizeDetector({
+      strategy: 'scroll'
+    }));
+
+    _defineProperty(this, "setWrapper", node => {
+      if (!node) {
+        return;
+      }
+
+      this.wrapperNode = node;
+      this.resizeDetector.listenTo(node, this.calculateScrollPosition);
+    });
+
+    _defineProperty(this, "calculateScrollPosition", () => scheduleScrollAction(() => {
+      const {
+        scrollableNode
+      } = this;
+
+      if (!scrollableNode) {
+        return;
+      }
+
+      const {
+        scrollTop,
+        scrollHeight,
+        offsetHeight
+      } = scrollableNode;
+      const scrolledToTop = scrollTop === 0;
+      const scrolledToBottom = offsetHeight + scrollTop >= scrollHeight - END_DISTANCE;
+
+      if (scrolledToBottom) {
+        this.props.onScrollToBottom();
+      }
+
+      this.setState({
+        scrolledToTop,
+        scrolledToBottom
+      });
+    }));
+
+    _defineProperty(this, "onScroll", () => {
+      this.props.onScroll(this.scrollableNode);
+      this.calculateScrollPosition();
+    });
+
+    _defineProperty(this, "setScrollableNodeAndCalculatePosition", node => {
+      if (!node) {
+        return;
+      }
+
+      this.scrollableNode = node;
+      this.calculateScrollPosition();
+    });
+  }
+
+  componentWillUnmount() {
+    this.scrollableNode = null;
+
+    if (!this.wrapperNode) {
+      return;
+    }
+
+    this.resizeDetector.removeAllListeners(this.wrapperNode);
+  }
+
+  render() {
+    const {
+      children,
+      className,
+      bottomBorder,
+      scrollableWrapperClassName,
+      onScroll,
+      onScrollToBottom,
+      fade,
+      ...restProps
+    } = this.props;
+    const {
+      scrolledToTop,
+      scrolledToBottom
+    } = this.state;
+    const classes = classNames(modules_e6a056e1.content, className, {
+      [modules_e6a056e1.contentWithTopFade]: fade && !scrolledToTop,
+      [modules_e6a056e1.contentWithBottomFade]: fade && !scrolledToBottom,
+      [modules_e6a056e1.withTransparentBottomBorder]: bottomBorder,
+      [modules_e6a056e1.withBottomBorder]: bottomBorder && !scrolledToBottom
+    });
+    const scrollableWrapperClasses = classNames(modules_e6a056e1.scrollableWrapper, scrollableWrapperClassName);
+    return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+      "data-test": "ring-island-content",
+      className: classes
+    }), /*#__PURE__*/React.createElement("div", {
+      // it has to be focusable because it can be scrollable
+      // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
+      tabIndex: 0,
+      "data-scrollable-container": true,
+      className: scrollableWrapperClasses,
+      ref: this.setScrollableNodeAndCalculatePosition,
+      onScroll: fade ? this.onScroll : noop
+    }, fade && /*#__PURE__*/React.createElement("div", {
+      ref: this.setWrapper
+    }, children), !fade && children));
+  }
+
+}
+
+_defineProperty(Content, "propTypes", {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  scrollableWrapperClassName: PropTypes.string,
+  fade: PropTypes.bool,
+  bottomBorder: PropTypes.bool,
+  onScroll: PropTypes.func,
+  onScrollToBottom: PropTypes.func
+});
+
+_defineProperty(Content, "defaultProps", {
+  fade: true,
+  bottomBorder: false,
+  onScroll: noop,
+  onScrollToBottom: noop
+});
+
+const ContentWrapper = /*#__PURE__*/forwardRef((props, ref) => /*#__PURE__*/React.createElement(ScrollHandlerContext.Consumer, null, onScroll => {
+  const addProps = onScroll != null ? {
+    onScroll,
+    bottomBorder: true
+  } : {};
+  return /*#__PURE__*/React.createElement(Content, _extends({}, props, addProps, {
+    ref: ref
+  }));
+}));
+ContentWrapper.displayName = 'ContentWrapper';
+
+export { ContentWrapper as default };

package/dist/island/header.js

@@ -0,0 +1,84 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { interpolateLinear } from '../global/linear-function.js';
+import { m as modules_e6a056e1 } from '../_helpers/island.js';
+import { PhaseContext } from './adaptive-island-hoc.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+const Start = {
+  FONT_SIZE: 24,
+  LINE_HEIGHT: 28,
+  PADDING: 16
+};
+const End = {
+  FONT_SIZE: 13,
+  LINE_HEIGHT: 28,
+  // Compensation
+  X: 0.4,
+  Y: 0.1,
+  SPACING: 1.09
+};
+const BORDER_APPEAR_PHASE = 0.5;
+
+class Header extends Component {
+  style(name) {
+    return interpolateLinear(Start[name] || 0, End[name] || 0, this.props.phase);
+  }
+
+  render() {
+    const {
+      children,
+      className,
+      wrapWithTitle,
+      border,
+      phase,
+      ...restProps
+    } = this.props;
+    const classes = classNames(modules_e6a056e1.header, className, {
+      [modules_e6a056e1.withBottomBorder]: border || phase >= BORDER_APPEAR_PHASE
+    });
+    const headerStyle = phase != null ? {
+      lineHeight: "".concat(this.style('LINE_HEIGHT'), "px"),
+      // need to append px because number is a valid line-height value
+      paddingTop: this.style('PADDING')
+    } : null;
+    const scaleFont = phase != null && this.style('FONT_SIZE') / Start.FONT_SIZE;
+    const titleStyle = phase != null && phase < 1 ? {
+      fontSize: Start.FONT_SIZE,
+      transform: "translate(".concat(this.style('X'), "px, ").concat(this.style('Y'), "px) scale(").concat(scaleFont, ")"),
+      letterSpacing: this.style('SPACING')
+    } : null;
+    return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+      "data-test": "ring-island-header",
+      className: classes,
+      style: headerStyle
+    }), wrapWithTitle && /*#__PURE__*/React.createElement("h2", {
+      className: modules_e6a056e1.title,
+      style: titleStyle
+    }, children), !wrapWithTitle && children);
+  }
+
+}
+
+_defineProperty(Header, "propTypes", {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  border: PropTypes.bool,
+  wrapWithTitle: PropTypes.bool,
+  phase: PropTypes.number
+});
+
+_defineProperty(Header, "defaultProps", {
+  wrapWithTitle: true
+});
+
+const HeaderWrapper = props => /*#__PURE__*/React.createElement(PhaseContext.Consumer, null, phase => {
+  const addProps = phase != null ? {
+    phase
+  } : {};
+  return /*#__PURE__*/React.createElement(Header, _extends({}, props, addProps));
+});
+
+export { HeaderWrapper as default };

package/dist/island/island.js

@@ -0,0 +1,51 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import joinDataTestAttributes from '../global/data-tests.js';
+import adaptiveIslandHOC from './adaptive-island-hoc.js';
+import { m as modules_e6a056e1 } from '../_helpers/island.js';
+export { default as Header } from './header.js';
+export { default as Content } from './content.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import '../global/linear-function.js';
+import 'element-resize-detector';
+import '../global/schedule-raf.js';
+
+/**
+ * @name Island
+ */
+
+class Island extends Component {
+  render() {
+    const {
+      children,
+      className,
+      narrow,
+      withoutPaddings,
+      'data-test': dataTest,
+      ...restProps
+    } = this.props;
+    const classes = classNames(modules_e6a056e1.island, className, {
+      [modules_e6a056e1.narrowIsland]: narrow,
+      [modules_e6a056e1.withoutPaddings]: withoutPaddings
+    });
+    return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+      className: classes,
+      "data-test": joinDataTestAttributes('ring-island', dataTest)
+    }), children);
+  }
+
+}
+
+_defineProperty(Island, "propTypes", {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  narrow: PropTypes.bool,
+  withoutPaddings: PropTypes.bool,
+  'data-test': PropTypes.string
+});
+
+const AdaptiveIsland = adaptiveIslandHOC(Island);
+
+export { AdaptiveIsland, Island as default };

package/dist/island-legacy/content-legacy.js

@@ -0,0 +1,26 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+
+class Content extends PureComponent {
+  render() {
+    const {
+      children,
+      className,
+      ...restProps
+    } = this.props;
+    const classes = classNames('ring-island__content', className);
+    return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+      className: classes
+    }), children);
+  }
+
+}
+
+_defineProperty(Content, "propTypes", {
+  className: PropTypes.string,
+  children: PropTypes.node
+});
+
+export { Content as default };

package/dist/island-legacy/header-legacy.js

@@ -0,0 +1,28 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+
+class Header extends PureComponent {
+  render() {
+    const {
+      children,
+      className,
+      ...restProps
+    } = this.props;
+    const classes = classNames('ring-island__header', className);
+    return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+      className: classes
+    }), /*#__PURE__*/React.createElement("div", {
+      className: "ring-island__title"
+    }, children));
+  }
+
+}
+
+_defineProperty(Header, "propTypes", {
+  className: PropTypes.string,
+  children: PropTypes.node
+});
+
+export { Header as default };

package/dist/island-legacy/island-legacy.js

@@ -0,0 +1,28 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+export { default as Header } from './header-legacy.js';
+export { default as Content } from './content-legacy.js';
+
+class Island extends PureComponent {
+  render() {
+    const {
+      children,
+      className,
+      ...restProps
+    } = this.props;
+    const classes = classNames('ring-island', className);
+    return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+      className: classes
+    }), children);
+  }
+
+}
+
+_defineProperty(Island, "propTypes", {
+  className: PropTypes.string,
+  children: PropTypes.node
+});
+
+export { Island as default };

package/dist/island-ng/island-content-ng.js

@@ -0,0 +1,42 @@
+import angular from 'angular';
+import { m as modules_e6a056e1 } from '../_helpers/island.js';
+import scheduleRAF from '../global/schedule-raf.js';
+import compile from './island-ng-class-fixer.js';
+import 'core-js/modules/es.string.replace.js';
+
+const scheduleScroll = scheduleRAF();
+const angularModule = angular.module('Ring.island-ng.header', []);
+angularModule.directive('rgIslandContent', function islandContentDirective() {
+  return {
+    transclude: true,
+    replace: true,
+    bindToController: {
+      fade: '=?',
+      onScroll: '&?'
+    },
+    compile,
+    template: "\n<div\n  data-test=\"ring-island-content\"\n  class=".concat(modules_e6a056e1.content, "\n  ng-class=\"{\n    '").concat(modules_e6a056e1.contentWithTopFade, "': contentCtrl.fade,\n    '").concat(modules_e6a056e1.contentWithBottomFade, "': contentCtrl.fade\n  }\"\n>\n  <div\n    tabindex=\"0\"\n    class=\"").concat(modules_e6a056e1.scrollableWrapper, " js-scrollable-wrapper\"\n    ng-transclude\n  ></div>\n</div>\n"),
+    controllerAs: 'contentCtrl',
+    controller: ["$scope", "$element", function controller($scope, $element) {
+      const el = $element[0];
+
+      if (this.onScroll) {
+        const scrollable = el.querySelector('.js-scrollable-wrapper');
+
+        const scrollCallback = evt => {
+          const $scrollTop = scrollable.scrollTop;
+          this.onScroll({
+            $event: evt,
+            $scrollTop
+          });
+          $scope.$apply();
+        };
+
+        scrollable.addEventListener('scroll', () => scheduleScroll(scrollCallback));
+      }
+    }]
+  };
+});
+var IslandContent = angularModule.name;
+
+export { IslandContent as default };

package/dist/island-ng/island-header-ng.js

@@ -0,0 +1,26 @@
+import angular from 'angular';
+import { m as modules_e6a056e1 } from '../_helpers/island.js';
+import compile from './island-ng-class-fixer.js';
+import 'core-js/modules/es.string.replace.js';
+
+const angularModule = angular.module('Ring.island-ng.content', []);
+angularModule.directive('rgIslandHeader', function islandHeaderDirective() {
+  return {
+    transclude: true,
+    replace: true,
+    bindToController: {
+      border: '=?'
+    },
+    compile,
+    template: "\n<div\n  data-test=\"ring-island-header\"\n  class=\"".concat(modules_e6a056e1.header, "\"\n  ng-class=\"{'").concat(modules_e6a056e1.withBottomBorder, "': headerCtrl.border}\" \n  ng-transclude\n></div>\n"),
+    controllerAs: 'headerCtrl',
+    controller: function controller() {
+      this.$onInit = () => {
+        this.wrapWithTitle = this.wrapWithTitle !== undefined ? this.wrapWithTitle : true;
+      };
+    }
+  };
+});
+var IslandHeader = angularModule.name;
+
+export { IslandHeader as default };

package/dist/island-ng/island-ng-class-fixer.js

@@ -0,0 +1,11 @@
+import 'core-js/modules/es.string.replace.js';
+
+// Workaround fo Angular bug with ng-class & replace: true support
+// See https://github.com/angular/angular.js/issues/5695#issuecomment-31898355
+function compile(tElement, tAttrs) {
+  if (tAttrs.ngClass) {
+    tAttrs.ngClass = tAttrs.ngClass.replace(/}\s*{/g, ', ');
+  }
+}
+
+export { compile as default };

package/dist/island-ng/island-ng.js

@@ -0,0 +1,25 @@
+import angular from 'angular';
+import { m as modules_e6a056e1 } from '../_helpers/island.js';
+import IslandHeader from './island-header-ng.js';
+import IslandContent from './island-content-ng.js';
+import compile from './island-ng-class-fixer.js';
+import 'core-js/modules/es.string.replace.js';
+import '../global/schedule-raf.js';
+
+const angularModule = angular.module('Ring.island-ng', [IslandHeader, IslandContent]);
+angularModule.directive('rgIsland', function islandDirective() {
+  return {
+    transclude: true,
+    replace: true,
+    bindToController: {
+      narrow: '='
+    },
+    compile,
+    template: "\n<div \n  data-test=\"ring-island\"\n  class=\"".concat(modules_e6a056e1.island, "\" \n  ng-class=\"{'").concat(modules_e6a056e1.narrowIsland, "': islandCtrl.narrow}\" \n  ng-transclude\n></div>\n"),
+    controllerAs: 'islandCtrl',
+    controller: angular.noop
+  };
+});
+var islandNg = angularModule.name;
+
+export { islandNg as default };

package/dist/link/clickableLink.js

@@ -0,0 +1,64 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+
+const LEFT_BUTTON = 0; // Cmd/Ctrl/Shift/Alt + Click should trigger default browser behaviour. Same applies to non-left clicks
+
+const isPlainLeftClick = e => e.button === LEFT_BUTTON && !e.altKey && !e.ctrlKey && !e.metaKey && !e.shiftKey;
+
+class ClickableLink extends PureComponent {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "onClick", e => {
+      const {
+        onClick,
+        onConditionalClick,
+        onPlainLeftClick
+      } = this.props;
+      const isPlainLeft = isPlainLeftClick(e);
+
+      if (onClick) {
+        onClick(e);
+      }
+
+      if (onConditionalClick) {
+        onConditionalClick(isPlainLeft, e);
+      }
+
+      if (onPlainLeftClick && isPlainLeft) {
+        e.preventDefault();
+        onPlainLeftClick(e);
+      }
+    });
+  }
+
+  render() {
+    const {
+      onConditionalClick,
+      onPlainLeftClick,
+      activeClassName,
+      href,
+      children,
+      ...restProps
+    } = this.props;
+    return /*#__PURE__*/React.createElement("a", _extends({
+      href: href
+    }, restProps, {
+      onClick: this.onClick
+    }), children);
+  }
+
+}
+
+_defineProperty(ClickableLink, "propTypes", {
+  onClick: PropTypes.func,
+  onPlainLeftClick: PropTypes.func,
+  onConditionalClick: PropTypes.func,
+  activeClassName: PropTypes.string,
+  href: PropTypes.string.isRequired,
+  children: PropTypes.node.isRequired
+});
+
+export { ClickableLink as default };

package/dist/link/link.js

@@ -0,0 +1,115 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'focus-visible';
+import React, { Component, memo } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import memoize from '../global/memoize.js';
+import joinDataTestAttributes from '../global/data-tests.js';
+import ClickableLink from './clickableLink.js';
+import { m as modules_607b0772 } from '../_helpers/link.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+/**
+ * @name Link
+ */
+
+let isCompatibilityMode = false;
+function setCompatibilityMode(isEnabled) {
+  isCompatibilityMode = isEnabled;
+}
+const makeWrapText = memoize(innerClassName => {
+  const WrapText = /*#__PURE__*/memo(function WrapText(_ref) {
+    let {
+      className,
+      children
+    } = _ref;
+    const classes = classNames(modules_607b0772.inner, className, innerClassName);
+    return /*#__PURE__*/React.createElement("span", {
+      className: classes
+    }, children);
+  });
+  WrapText.propTypes = {
+    className: PropTypes.string,
+    children: PropTypes.node
+  };
+  return WrapText;
+});
+function linkHOC(ComposedComponent) {
+  var _class;
+
+  const isCustom = typeof ComposedComponent !== 'string' && ComposedComponent !== ClickableLink;
+  return _class = class Link extends Component {
+    getChildren() {
+      const {
+        children,
+        innerClassName
+      } = this.props;
+      const WrapText = makeWrapText(innerClassName);
+      return typeof children === 'function' ? children(WrapText) : /*#__PURE__*/React.createElement(WrapText, null, children);
+    }
+
+    render() {
+      const {
+        active,
+        inherit,
+        pseudo,
+        hover,
+        className,
+        'data-test': dataTest,
+        href,
+        innerClassName,
+        children,
+        onPlainLeftClick,
+        onClick,
+        ...props
+      } = this.props;
+      const useButton = pseudo || !isCustom && href == null;
+      const classes = classNames(modules_607b0772.link, className, {
+        [modules_607b0772.active]: active,
+        [modules_607b0772.inherit]: inherit,
+        [modules_607b0772.hover]: hover,
+        [modules_607b0772.compatibilityUnderlineMode]: isCompatibilityMode,
+        [modules_607b0772.pseudo]: useButton,
+        [modules_607b0772.text]: typeof children !== 'function'
+      });
+
+      if (isCustom && !props.activeClassName) {
+        props.activeClassName = modules_607b0772.active;
+      }
+
+      if (useButton) {
+        return /*#__PURE__*/React.createElement("button", _extends({
+          type: "button"
+        }, props, {
+          className: classes,
+          onClick: onClick || onPlainLeftClick,
+          "data-test": joinDataTestAttributes('ring-link', dataTest)
+        }), this.getChildren());
+      }
+
+      return /*#__PURE__*/React.createElement(ComposedComponent, _extends({}, props, {
+        href: href,
+        className: classes,
+        onClick: onClick,
+        onPlainLeftClick: onPlainLeftClick,
+        "data-test": joinDataTestAttributes('ring-link', dataTest)
+      }), this.getChildren());
+    }
+
+  }, _defineProperty(_class, "propTypes", {
+    className: PropTypes.string,
+    innerClassName: PropTypes.string,
+    active: PropTypes.bool,
+    inherit: PropTypes.bool,
+    pseudo: PropTypes.bool,
+    hover: PropTypes.bool,
+    children: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
+    'data-test': PropTypes.string,
+    href: PropTypes.string,
+    onPlainLeftClick: PropTypes.func,
+    onClick: PropTypes.func
+  }), _class;
+}
+var Link = linkHOC(ClickableLink);
+
+export { Link as default, linkHOC, setCompatibilityMode };

package/dist/link-ng/link-ng.js

@@ -0,0 +1,22 @@
+import angular from 'angular';
+import { m as modules_607b0772 } from '../_helpers/link.js';
+
+/**
+ * @name Link Ng
+ */
+
+const angularModule = angular.module('Ring.link', []);
+
+function rgLinkDirective() {
+  return {
+    restrict: 'E',
+    transclude: true,
+    replace: true,
+    template: "\n<a class=\"".concat(modules_607b0772.link, " ").concat(modules_607b0772.compatibilityUnderlineMode, "\"\n><span class=\"").concat(modules_607b0772.inner, "\" ng-transclude></span></a>\n    ")
+  };
+}
+
+angularModule.directive('rgLink', rgLinkDirective);
+var LinkNG = angularModule.name;
+
+export { LinkNG as default };