@jetbrains/ring-ui 4.1.0-beta.13 → 4.1.0-beta.17

package/dist/title-ng/title-ng.js

@@ -0,0 +1,114 @@
+import angular from 'angular';
+
+const angularModule = angular.module('Ring.title', []);
+angularModule.directive('rgPageTitle', function rgPageTitleDirective() {
+  return {
+    scope: {
+      rgPageTitle: '@?',
+      noTitle: '@?',
+      delimiter: '@'
+    },
+    controller: ["$rootScope", "$scope", "$element", "$attrs", "pageTitle", "$injector", function controller($rootScope, $scope, $element, $attrs, pageTitle, $injector) {
+      const element = $element[0]; // Get title prefix from title element
+
+      const elementText = element.textContent;
+      let offScopeWatch = angular.noop; // Set page title on route change
+
+      const offRouteWatch = $rootScope.$on('$routeChangeSuccess', (event, current) => {
+        //Do nothing if we're being redirected
+        if (current.$$route && current.$$route.redirectTo) {
+          // eslint-disable-line angular/no-private-call
+          return;
+        }
+
+        let routeTitle = current.$$route && current.$$route.title; // eslint-disable-line angular/no-private-call
+
+        pageTitle.setCurrent($scope.rgPageTitle || elementText); // Use title: false to prevent title change on route
+
+        if (routeTitle !== false) {
+          if (angular.isArray(routeTitle) || angular.isFunction(routeTitle)) {
+            //Invoke injector
+            routeTitle = $injector.invoke(routeTitle);
+          }
+
+          pageTitle.addElement(routeTitle || $scope.noTitle);
+        }
+      });
+      $scope.$on('$destroy', () => {
+        offRouteWatch();
+        offScopeWatch();
+      });
+
+      this.$onInit = () => {
+        pageTitle.setDelimiter($scope.delimiter);
+
+        if ($attrs.rgPageTitle) {
+          offScopeWatch = $scope.$watch('rgPageTitle', newBaseTitle => {
+            pageTitle.setRootElement(newBaseTitle);
+          });
+        }
+      };
+    }]
+  };
+});
+angularModule.service('pageTitle', ["$interpolate", "$document", function service($interpolate, $document) {
+  let delimiter = ' | ';
+  let current = $document[0].title;
+
+  function setTitle(text) {
+    current = text && $interpolate(text)();
+    updateDocumentTitle(current);
+  }
+
+  function updateDocumentTitle(text) {
+    $document[0].title = text;
+  }
+
+  function prepend(element) {
+    setTitle(current ? element + delimiter + current : element);
+  }
+
+  function replacePart(element) {
+    let replaceIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    const titleElements = current.split(delimiter);
+    titleElements[replaceIndex === -1 ? titleElements.length - 1 : replaceIndex] = element;
+    setTitle(titleElements.join(delimiter));
+  }
+
+  this.setDelimiter = newDelimiter => {
+    delimiter = newDelimiter || delimiter;
+  };
+
+  this.setCurrent = newBase => {
+    current = newBase;
+  };
+
+  this.setText = text => updateDocumentTitle(text);
+
+  this.addElement = (element, fieldName) => {
+    if (element.$promise) {
+      element.$promise.then(Data => {
+        this.addElement(Data[fieldName || 'name']);
+      });
+    } else {
+      prepend(fieldName ? element[fieldName] : element);
+    }
+  };
+
+  this.updateElement = (element, fieldName) => {
+    if (element.$promise) {
+      element.$promise.then(Data => {
+        this.updateElement(Data[fieldName || 'name']);
+      });
+    } else {
+      replacePart(fieldName ? element[fieldName] : element);
+    }
+  };
+
+  this.setRootElement = element => {
+    replacePart(element, -1);
+  };
+}]);
+var titleNg = angularModule.name;
+
+export { titleNg as default };

package/dist/toggle/toggle.js

@@ -72,7 +72,6 @@ _defineProperty(Toggle, "propTypes", {
   'data-test': PropTypes.string
 });
 
-var toggle = withTheme()(Toggle);
+var Toggle$1 = withTheme()(Toggle);
 
-export default toggle;
-export { Size };
+export { Size, Toggle$1 as default };

package/dist/toggle-ng/toggle-ng.js

@@ -0,0 +1,16 @@
+import angularComponentFactory from '../global/angular-component-factory.js';
+import Toggle from '../toggle/toggle.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'angular';
+import 'react';
+import 'react-dom';
+import '../global/ring-angular-component.js';
+import '../global/react-dom-renderer.js';
+import 'prop-types';
+import 'classnames';
+import '../global/theme.js';
+import '../global/data-tests.js';
+
+var toggleNg = angularComponentFactory(Toggle, 'Toggle').name;
+
+export { toggleNg as default };

package/dist/tooltip/tooltip.js

@@ -153,6 +153,10 @@ class Tooltip extends Component {
       popupProps,
       ...restProps
     } = this.props;
+    const ariaProps = typeof title === 'string' && !!title ? {
+      'aria-label': title,
+      role: 'tooltip'
+    } : {};
     const {
       onNestedTooltipShow,
       onNestedTooltipHide
@@ -162,10 +166,10 @@ class Tooltip extends Component {
         onNestedTooltipShow,
         onNestedTooltipHide
       }
-    }, /*#__PURE__*/React.createElement("span", _extends({}, restProps, {
+    }, /*#__PURE__*/React.createElement("span", _extends({}, ariaProps, restProps, {
       ref: this.containerRef,
       "data-test": joinDataTestAttributes('ring-tooltip', dataTest),
-      "data-test-title": title
+      "data-test-title": typeof title === 'string' ? title : undefined
     }), children, /*#__PURE__*/React.createElement(Popup, _extends({
       trapFocus: false,
       hidden: !this.state.showPopup || this.state.showNestedPopup,
@@ -185,7 +189,7 @@ _defineProperty(Tooltip, "propTypes", {
   delay: PropTypes.number,
   selfOverflowOnly: PropTypes.bool,
   popupProps: PropTypes.object,
-  title: PropTypes.oneOfType([PropTypes.string, PropTypes.element]),
+  title: PropTypes.node,
   children: PropTypes.node,
   'data-test': PropTypes.string
 });
@@ -200,4 +204,4 @@ _defineProperty(Tooltip, "PopupProps", Popup.PopupProps);
 
 _defineProperty(Tooltip, "contextType", TooltipContext);
 
-export default Tooltip;
+export { Tooltip as default };

package/dist/tooltip-ng/tooltip-ng.js

@@ -0,0 +1,98 @@
+import angular from 'angular';
+import { createElement } from 'react';
+import { render } from 'react-dom';
+import classNames from 'classnames';
+import Popup from '../popup/popup.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'prop-types';
+import '../global/get-uid.js';
+import '../global/schedule-raf.js';
+import '../global/dom.js';
+import '../shortcuts/shortcuts.js';
+import '../shortcuts/core.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../global/data-tests.js';
+import '../tab-trap/tab-trap.js';
+import '../popup/position.js';
+import '../popup/popup.consts.js';
+import '../popup/popup.target.js';
+
+/**
+ * @name Tooltip Ng
+*/
+
+const OPEN_CLASS = 'ring-tooltip-ng_open';
+const name = angular.module('Ring.tooltip', []);
+name.directive('rgTooltip', ["RgTooltipPopup", function rgTooltipDirective(RgTooltipPopup) {
+  return {
+    restrict: 'A',
+    link: function link(scope, iElement, iAttrs) {
+      const element = iElement[0];
+
+      const getTooltipText = () => {
+        try {
+          return scope.$eval(iAttrs.rgTooltip);
+        } catch (err) {
+          return iAttrs.rgTooltip;
+        }
+      };
+
+      const popupWrapper = new RgTooltipPopup(element, getTooltipText);
+      element.addEventListener('mouseover', () => {
+        popupWrapper.displayTooltip(iAttrs.rgTooltipClass);
+        element.classList.add(OPEN_CLASS);
+      });
+      element.addEventListener('mouseout', () => {
+        popupWrapper.hideTooltip();
+        element.classList.remove(OPEN_CLASS);
+      });
+    }
+  };
+}]);
+name.factory('RgTooltipPopup', function RgTooltipPopupDirective() {
+  // eslint-disable-next-line func-names
+  return function (anchorElement, textGetter) {
+    this.wrapperElement = document.createElement('span');
+    this.defaultProps = {
+      anchorElement,
+      maxHeight: 400,
+      attached: false,
+      dontCloseOnAnchorClick: true,
+      trapFocus: false
+    };
+
+    this.renderPopup = props => {
+      this.popup = render( /*#__PURE__*/createElement(Popup, { ...this.defaultProps,
+        ...props
+      }, this.text), this.wrapperElement);
+    };
+
+    this.displayTooltip = customClass => {
+      const text = textGetter();
+
+      if (!text) {
+        return;
+      }
+
+      this.text = text;
+      const className = classNames({
+        'ring-tooltip-ng': true
+      }, customClass);
+      this.renderPopup({
+        hidden: false,
+        className
+      });
+    };
+
+    this.hideTooltip = () => {
+      this.renderPopup({
+        hidden: true
+      });
+    };
+  };
+});
+var tooltipNg = name.name;
+
+export { tooltipNg as default };

package/dist/user-agreement/service.js

@@ -0,0 +1,409 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React from 'react';
+import { render, unmountComponentAtNode } from 'react-dom';
+import ActualStorage from '../storage/storage.js';
+import alertService from '../alert-service/alert-service.js';
+import Link from '../link/link.js';
+import Alert from '../alert/alert.js';
+import Group from '../group/group.js';
+import UserAgreement from './user-agreement.js';
+import '../storage/storage__local.js';
+import '../global/get-uid.js';
+import 'classnames';
+import 'prop-types';
+import '@jetbrains/icons/exception';
+import '@jetbrains/icons/checkmark';
+import '@jetbrains/icons/warning';
+import '@jetbrains/icons/close';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import '../global/memoize.js';
+import '../loader-inline/loader-inline.js';
+import '../global/theme.js';
+import '../global/data-tests.js';
+import '../_helpers/inject-styles.js';
+import '../global/conic-gradient.js';
+import 'conic-gradient';
+import '../global/supports-css.js';
+import '../global/inject-styles.js';
+import '../global/radial-gradient-mask.js';
+import '../global/dom.js';
+import '../alert/container.js';
+import '../storage/storage__fallback.js';
+import 'deep-equal';
+import 'focus-visible';
+import '../link/clickableLink.js';
+import '../_helpers/link.js';
+import '../_helpers/group.js';
+import '../dialog/dialog.js';
+import '../island/island.js';
+import '../island/adaptive-island-hoc.js';
+import '../global/linear-function.js';
+import '../_helpers/island.js';
+import '../island/header.js';
+import '../island/content.js';
+import 'element-resize-detector';
+import '../global/schedule-raf.js';
+import '../shortcuts/shortcuts.js';
+import '../shortcuts/core.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../tab-trap/tab-trap.js';
+import '../button/button.js';
+import '@jetbrains/icons/chevron-10px';
+import '../_helpers/button__classes.js';
+import '../popup/popup.target.js';
+import '../_helpers/dialog__body-scroll-preventer.js';
+import 'scrollbar-width';
+import '../panel/panel.js';
+import '../_helpers/panel.js';
+import '../markdown/markdown.js';
+import 'react-markdown';
+import 'remark-breaks';
+import 'remark-gfm';
+import '../global/normalize-indent.js';
+import '../global/trivial-template-tag.js';
+import '../markdown/code.js';
+import '../code/code.js';
+import 'highlight.js/lib/core';
+import '../markdown/link.js';
+import '../markdown/heading.js';
+import '../heading/heading.js';
+
+const GUEST_SESSION_KEY = 'end-user-agreement-consent';
+const ONE_HOUR = 60 * 60 * 1000; // eslint-disable-line no-magic-numbers
+
+const storageKey = 'userAgreementKey';
+const showMessage = 'userAgreementShow';
+const hideMessage = 'userAgreementHide';
+const DEFAULT_CONSENT = {
+  accepted: false,
+  majorVersion: 0,
+  minorVersion: 0
+};
+const DEFAULT_AGREEMENT = {
+  enabled: false,
+  majorVersion: 0,
+  minorVersion: 0,
+  requiredForREST: false,
+  text: ''
+};
+class UserAgreementService {
+  constructor() {
+    var _this = this;
+
+    let config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _defineProperty(this, "_dialogPromise", null);
+
+    _defineProperty(this, "_alertPromise", null);
+
+    _defineProperty(this, "tabId", Math.random());
+
+    _defineProperty(this, "interval", ONE_HOUR);
+
+    _defineProperty(this, "container", document.createElement('div'));
+
+    _defineProperty(this, "storage", new ActualStorage());
+
+    _defineProperty(this, "checkingPromise", null);
+
+    _defineProperty(this, "guest", false);
+
+    _defineProperty(this, "userAgreement", DEFAULT_AGREEMENT);
+
+    _defineProperty(this, "userConsent", DEFAULT_CONSENT);
+
+    _defineProperty(this, "startChecking", () => {
+      this.intervalId = setInterval(this.checkConsentAndShowDialog, this.interval);
+      window.addEventListener('storage', this.onStorageEvent);
+      this.checkConsentAndShowDialog();
+    });
+
+    _defineProperty(this, "stopChecking", () => {
+      clearInterval(this.intervalId);
+      window.removeEventListener('storage', this.onStorageEvent);
+      this.hideDialog();
+    });
+
+    _defineProperty(this, "onStorageEvent", event => {
+      if (event.key === storageKey) {
+        const {
+          tabId,
+          command
+        } = JSON.parse(event.newValue);
+
+        if (tabId !== this.tabId) {
+          if (command === showMessage) {
+            this.checkConsentAndShowDialog(true);
+          } else if (command === hideMessage) {
+            this.hideDialogAndAlert(true);
+          }
+        }
+      }
+    });
+
+    _defineProperty(this, "_notifyAboutShowing", () => {
+      localStorage.setItem(storageKey, JSON.stringify({
+        command: showMessage,
+        tabId: this.tabId
+      }));
+    });
+
+    _defineProperty(this, "_notifyAboutHiding", () => {
+      localStorage.setItem(storageKey, JSON.stringify({
+        command: hideMessage,
+        tabId: this.tabId
+      }));
+    });
+
+    _defineProperty(this, "getUserAgreement", async () => {
+      this.userAgreement = (await this.config.getUserAgreement()) || DEFAULT_AGREEMENT;
+      return this.userAgreement;
+    });
+
+    _defineProperty(this, "getUserConsent", async () => {
+      const {
+        guest,
+        endUserAgreementConsent
+      } = await this.config.getUserConsent();
+      this.guest = guest;
+
+      if (guest) {
+        this.userConsent = (await this.storage.get(GUEST_SESSION_KEY)) || this.userConsent;
+      } else {
+        this.userConsent = endUserAgreementConsent || this.userConsent;
+      }
+
+      return this.userConsent;
+    });
+
+    _defineProperty(this, "checkConsentAndShowDialog", async withoutNotifications => {
+      if (await this.checkConsent()) {
+        return this.hideDialogAndAlert(withoutNotifications);
+      } else {
+        return this.showDialogOrAlert(withoutNotifications);
+      }
+    });
+
+    _defineProperty(this, "checkConsent", async () => {
+      if (!this.checkingPromise) {
+        this.checkingPromise = Promise.all([this.getUserAgreement(), this.getUserConsent()]);
+      }
+
+      const [userAgreement, userConsent] = await this.checkingPromise;
+      this.checkingPromise = null;
+      const {
+        enabled,
+        majorVersion: actualVersion
+      } = userAgreement;
+      const {
+        accepted,
+        majorVersion: acceptedVersion
+      } = userConsent;
+      return !enabled || accepted && actualVersion === acceptedVersion;
+    });
+
+    _defineProperty(this, "showAlert", withoutNotifications => {
+      if (this._alertPromise) {
+        return this._alertPromise;
+      }
+
+      this._alertPromise = new Promise((resolve, reject) => {
+        const {
+          userAgreement,
+          reviewNow,
+          remindLater
+        } = this.config.translations || {};
+
+        const onRemind = () => {
+          this.hideDialogAndAlert(withoutNotifications);
+          reject('Postponed');
+        };
+
+        const onReview = async () => {
+          await this.showDialog(true, false, {
+            onRemindLater: onRemind
+          });
+          this.hideAlert(withoutNotifications);
+          resolve();
+        };
+
+        const message = /*#__PURE__*/React.createElement(Group, null, /*#__PURE__*/React.createElement("span", null, userAgreement || 'User Agreement'), /*#__PURE__*/React.createElement(Link, {
+          onClick: onReview,
+          "data-test": "review"
+        }, reviewNow || 'Review now'), /*#__PURE__*/React.createElement(Link, {
+          onClick: onRemind,
+          "data-test": "later"
+        }, remindLater || 'Remind me later'));
+        this.alertKey = alertService.addAlert(message, Alert.Type.WARNING, 0, {
+          closeable: false
+        });
+      });
+
+      if (!withoutNotifications) {
+        this._notifyAboutShowing();
+      }
+
+      return this._alertPromise;
+    });
+
+    _defineProperty(this, "hideAlert", withoutNotifications => {
+      const {
+        onRemindLater
+      } = this.config;
+      alertService.remove(this.alertKey);
+      this.alertKey = null;
+      this._alertPromise = null;
+
+      if (onRemindLater) {
+        onRemindLater();
+      }
+
+      if (!withoutNotifications) {
+        this._notifyAboutHiding();
+      }
+    });
+
+    _defineProperty(this, "showDialog", function (withoutNotifications) {
+      let preview = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      let restOptions = arguments.length > 2 ? arguments[2] : undefined;
+      const {
+        translations,
+        onDialogShow
+      } = _this.config;
+      const {
+        text
+      } = _this.userAgreement;
+      const show = true;
+
+      if (!_this._dialogPromise) {
+        _this._dialogPromise = new Promise((resolve, reject) => {
+          const onAccept = async () => {
+            await _this.onAccept();
+            resolve();
+          };
+
+          const onDecline = async () => {
+            await _this.onDecline();
+            reject();
+          };
+
+          const onClose = _this.hideDialogAndAlert;
+          const props = {
+            text,
+            show,
+            onAccept,
+            onDecline,
+            onClose,
+            translations,
+            preview,
+            ...restOptions
+          };
+          render( /*#__PURE__*/React.createElement(UserAgreement, props), _this.container);
+
+          if (onDialogShow) {
+            onDialogShow();
+          }
+        });
+
+        if (!withoutNotifications) {
+          _this._notifyAboutShowing();
+        }
+      }
+
+      return _this._dialogPromise;
+    });
+
+    _defineProperty(this, "hideDialog", withoutNotifications => {
+      const {
+        onDialogHide
+      } = this.config;
+      unmountComponentAtNode(this.container);
+
+      if (onDialogHide) {
+        onDialogHide();
+        this._dialogPromise = null;
+
+        if (!withoutNotifications) {
+          this._notifyAboutHiding();
+        }
+      }
+    });
+
+    _defineProperty(this, "showDialogOrAlert", function () {
+      if (_this.guest && !_this.userAgreement.requiredForREST) {
+        return _this.showAlert(...arguments);
+      }
+
+      return _this.showDialog(...arguments);
+    });
+
+    _defineProperty(this, "hideDialogAndAlert", function () {
+      _this.hideAlert(...arguments);
+
+      _this.hideDialog(...arguments);
+    });
+
+    _defineProperty(this, "onAccept", async () => {
+      const {
+        setUserConsent,
+        onAccept
+      } = this.config;
+
+      if (this.guest) {
+        const {
+          majorVersion,
+          minorVersion
+        } = this.userAgreement;
+        this.userConsent = {
+          majorVersion,
+          minorVersion,
+          accepted: true
+        };
+        await this.storage.set(GUEST_SESSION_KEY, this.userConsent);
+      } else {
+        this.userConsent = await setUserConsent();
+      }
+
+      this.hideDialog();
+
+      if (onAccept) {
+        onAccept();
+      }
+    });
+
+    _defineProperty(this, "onDecline", () => {
+      const {
+        onDecline
+      } = this.config;
+      this.hideDialog();
+
+      if (onDecline) {
+        onDecline();
+      }
+    });
+
+    if (!config.getUserAgreement) {
+      throw new Error('Please pass a "getUserAgreement" option to UserAgreementService');
+    }
+
+    if (!config.getUserConsent) {
+      throw new Error('Please pass a "getUserConsent" option to UserAgreementService');
+    }
+
+    if (!config.setUserConsent) {
+      throw new Error('Please pass a "setUserConsent" option to UserAgreementService');
+    }
+
+    this.config = config;
+    this.interval = config.interval || this.interval;
+  }
+
+}
+
+export { UserAgreementService as default, hideMessage, showMessage };