@jetbrains/ring-ui 4.1.0-beta.9 → 4.1.4

package/dist/pager-ng/pager-ng.js

@@ -0,0 +1,96 @@
+import angularComponentFactory from '../global/angular-component-factory.js';
+import Pager$1 from '../pager/pager.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 '@jetbrains/icons/chevron-left';
+import '@jetbrains/icons/chevron-right';
+import '../button/button.js';
+import 'focus-visible';
+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 '../global/memoize.js';
+import '../global/theme.js';
+import '../link/clickableLink.js';
+import '../_helpers/button__classes.js';
+import '../button-group/button-group.js';
+import '../button-group/caption.js';
+import '../_helpers/button-group.js';
+import '../button-toolbar/button-toolbar.js';
+import '../_helpers/button-toolbar.js';
+import '../select/select.js';
+import '@jetbrains/icons/close';
+import 'deep-equal';
+import '../dropdown/dropdown.js';
+import '../global/data-tests.js';
+import '../_helpers/anchor.js';
+import '../avatar/avatar.js';
+import '../global/url.js';
+import '../global/dom.js';
+import '../avatar/fallback-avatar.js';
+import '../global/get-uid.js';
+import '../popup/popup.js';
+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 '../popup/position.js';
+import '../popup/popup.consts.js';
+import '../popup/popup.target.js';
+import '../list/list.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 'memoize-one';
+import '../global/create-stateful-context.js';
+import '../list/list__link.js';
+import '../link/link.js';
+import '../_helpers/link.js';
+import '../_helpers/list.js';
+import '../list/list__item.js';
+import '../checkbox/checkbox.js';
+import '@jetbrains/icons/checkmark';
+import '@jetbrains/icons/remove-10px';
+import '../_helpers/checkbox.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';
+import '../input/input.js';
+import '../_helpers/input.js';
+import '../global/rerender-hoc.js';
+import '../global/fuzzy-highlight.js';
+import '../select/select__popup.js';
+import '@jetbrains/icons/search';
+import '../loader-inline/loader-inline.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 '../shortcuts/shortcuts-hoc.js';
+import '../tags-list/tags-list.js';
+import '../tag/tag.js';
+import '../caret/caret.js';
+import '../text/text.js';
+import '../_helpers/select__filter.js';
+
+var Pager = angularComponentFactory(Pager$1, 'Pager').name;
+
+export { Pager as default };

package/dist/panel/panel.js

@@ -1,9 +1,8 @@
-import { a as _objectWithoutProperties, b as _extends, _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
-
-var modules_cf670408 = {"unit":"8px","panel":"panel_panel__559bc5c3 dialog_panel__16e57f84"};
+import { m as modules_cf670408 } from '../_helpers/panel.js';
 
 /**
  * @name Panel
@@ -11,13 +10,11 @@ var modules_cf670408 = {"unit":"8px","panel":"panel_panel__559bc5c3 dialog_panel
 
 class Panel extends PureComponent {
   render() {
-    const _this$props = this.props,
-          {
+    const {
       className,
-      children
-    } = _this$props,
-          props = _objectWithoutProperties(_this$props, ["className", "children"]);
-
+      children,
+      ...props
+    } = this.props;
     const classes = classNames(modules_cf670408.panel, className);
     return /*#__PURE__*/React.createElement("div", _extends({}, props, {
       className: classes
@@ -31,4 +28,4 @@ _defineProperty(Panel, "propTypes", {
   children: PropTypes.node
 });
 
-export default Panel;
+export { Panel as default };

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

@@ -0,0 +1,16 @@
+import angular from 'angular';
+import { m as modules_cf670408 } from '../_helpers/panel.js';
+import { addClasses } from '../global/dom.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+
+const angularModule = angular.module('Ring.panel', []);
+angularModule.directive('rgPanel', function rgEqualValueDirective() {
+  return {
+    link: function link(scope, iElement) {
+      addClasses(iElement[0].classList, modules_cf670408.panel);
+    }
+  };
+});
+var panelNg = angularModule.name;
+
+export { panelNg as default };

package/dist/permissions/permissions.js

@@ -197,4 +197,4 @@ class Permissions {
 
 _defineProperty(Permissions, "API_PERMISSION_CACHE_PATH", 'permissions/cache');
 
-export default Permissions;
+export { Permissions as default };

package/dist/permissions/permissions__cache.js

@@ -269,4 +269,4 @@ class PermissionCache {
 
 _defineProperty(PermissionCache, "GLOBAL_PROJECT_ID", 'global');
 
-export default PermissionCache;
+export { PermissionCache as default };

package/dist/permissions-ng/permissions-ng.js

@@ -0,0 +1,274 @@
+import angular from 'angular';
+import '../auth-ng/auth-ng.js';
+import Permissions from '../permissions/permissions.js';
+import PermissionCache from '../permissions/permissions__cache.js';
+import '../auth/auth.js';
+import '../auth/window-flow.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import '../auth/response-parser.js';
+import 'es6-error';
+import '../global/url.js';
+import '../auth/down-notification.js';
+import 'react';
+import 'prop-types';
+import '../alert-service/alert-service.js';
+import 'react-dom';
+import '../global/get-uid.js';
+import '../alert/alert.js';
+import 'classnames';
+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 '../link/link.js';
+import 'focus-visible';
+import '../link/clickableLink.js';
+import '../_helpers/link.js';
+import '../group/group.js';
+import '../_helpers/group.js';
+import '../auth/auth__core.js';
+import '../global/listeners.js';
+import '../http/http.js';
+import '../global/promise-with-timeout.js';
+import '../auth/storage.js';
+import '../storage/storage.js';
+import '../storage/storage__local.js';
+import '../storage/storage__fallback.js';
+import 'deep-equal';
+import '../auth/request-builder.js';
+import 'simply-uuid';
+import '../auth/background-flow.js';
+import '../auth/token-validator.js';
+
+function registerPermission(element) {
+  const somePermissionsCtrl = element.controller('rgSomePermissions');
+  return somePermissionsCtrl && somePermissionsCtrl.registerPermission() || angular.noop;
+}
+
+const angularModule = angular.module('Ring.permissions', ['Ring.auth']);
+/**
+ * @ngdoc object
+ * @name userPermissions
+ *
+ * @description
+ * Configured instance of Permissions object.
+ */
+
+/**
+ * @typedef {Object} permissionsNgConfig
+ * @property {?string} serviceId
+ * @property {?string} prefix
+ */
+
+angularModule.provider('userPermissions', function provider() {
+  /**
+   * @type {permissionsNgConfig}
+   */
+  let _config = {};
+  /**
+   * @param {permissionsNgConfig} config
+   */
+
+  this.config = config => {
+    _config = config;
+  };
+
+  this.$get = ["auth", "$q", "$http", (auth, $q, $http) => {
+    const apiUri = auth.auth.getAPIPath() + Permissions.API_PERMISSION_CACHE_PATH;
+
+    async function datasource(query) {
+      const {
+        data
+      } = await $http.get(apiUri, {
+        params: {
+          fields: 'permission/key,global,projects(id)',
+          query
+        }
+      });
+      return data;
+    }
+
+    _config.datasource = _config.datasource || datasource;
+    const permissions = new Permissions(auth.auth, _config); // Override load to execute in $digest
+
+    permissions.load = function load() {
+      return $q.when(Permissions.prototype.load.call(this));
+    };
+
+    return permissions;
+  }];
+});
+/**
+ * @ngdoc directive
+ * @name permission
+ *
+ * @description
+ * The `permission` directive show or hide a portion of the DOM tree (HTML) depending
+ * on the logged in user permissions. If the user has listed permissions then the DOM tree
+ * is shown, otherwise it is hidden.
+ *
+ * @restrict A
+ * @element ANY
+ * @requires userPermissions
+ */
+
+angularModule.directive('rgPermission', ["userPermissions", "$interpolate", function rgPermissionDirective(userPermissions, $interpolate) {
+  return {
+    controller: ["$scope", "$element", "$attrs", function controller($scope, $element, $attrs) {
+      const element = $element[0]; //noinspection JSPotentiallyInvalidUsageOfThis
+
+      this.permitted = false;
+      element.classList.add('ring-permission-hide');
+      const permission = $interpolate($attrs.rgPermission)($scope);
+      const projectId = $attrs.hasOwnProperty('inGlobal') ? PermissionCache.GLOBAL_PROJECT_ID : $scope.$eval($attrs.inProject);
+      userPermissions.check(permission, projectId).then(permitted => {
+        this.permitted = permitted;
+
+        if (permitted) {
+          element.classList.remove('ring-permission-hide');
+        }
+
+        return permitted;
+      }).then(registerPermission($element));
+    }]
+  };
+}]);
+/**
+ * @ngdoc directive
+ * @name permissionIf
+ *
+ * @description
+ * The `permission` directive transcludes or not a portion of the DOM tree (HTML) depending
+ * on the logged in user permissions. If the user has listed permissions then the DOM tree
+ * is transcluded, otherwise it is not.
+ * @example
+ <example name="rgPermissionIf directive">
+ <file name="index.html">
+ <div rg-permission-if="project-read" in-project="0-0-0-0-0">
+ Is transcluded if user has permission 'read-project' in project 0-0-0-0-0.
+ </div>
+ <div rg-permission-if="project-read">
+ Is transcluded if user has permission 'read-project' at least in one project.
+ </div>
+ <div rg-permission-if="project-read" in-global>
+ Is transcluded if user has permission 'read-project' at project "global".
+ </div>
+ </file>
+ </example>
+ *
+ * @restrict A
+ * @element ANY
+ * @requires $animate
+ * @requires userPermissions
+ */
+
+angularModule.directive('rgPermissionIf', ["$animate", "userPermissions", "$interpolate", function rgPermissionIfDirective($animate, userPermissions, $interpolate) {
+  return {
+    transclude: 'element',
+    priority: 600,
+    terminal: true,
+    restrict: 'A',
+    // disable error about multiple transclude like in ngIf
+    $$tlb: true,
+    // eslint-disable-line angular/no-private-call
+    require: '^?rgSomePermissions',
+    link: function link(scope, iElement, iAttrs, somePermittedCtrl, $transclude) {
+      let block;
+      let childScope;
+      const projectId = iAttrs.hasOwnProperty('inGlobal') ? PermissionCache.GLOBAL_PROJECT_ID : scope.$eval(iAttrs.inProject);
+      const permission = $interpolate(iAttrs.rgPermissionIf)(scope);
+      userPermissions.check(permission, projectId).then(permitted => {
+        if (permitted) {
+          if (!childScope) {
+            childScope = scope.$new();
+            $transclude(childScope, clone => {
+              block = {
+                startNode: clone[0],
+                endNode: clone[clone.length++] = document.createComment(` end rgPermissionIf: ${iAttrs.rgPermissionIf} `)
+              };
+              $animate.enter(clone, iElement.parent(), iElement);
+            });
+          }
+        } else {
+          if (childScope) {
+            childScope.$destroy();
+            childScope = null;
+          }
+
+          if (block) {
+            /* global getBlockElements: false */
+            $animate.leave(getBlockElements(block));
+            block = null;
+          }
+        }
+      }).then(registerPermission(iElement));
+    }
+  };
+}]);
+/**
+ * @ngdoc directive
+ * @name rgSomePermissions
+ *
+ * @description
+ * Binds left-value expression with a boolean value that is true when at least one permission of
+ * nested {@link permission} or {@link rgPermissionIf} directive is obtained by the logged in user.
+ *
+ * @scope
+ * @restrict A
+ * @element ANY
+ */
+
+angularModule.directive('rgSomePermissions', function rgSomePermissionsDirective() {
+  return {
+    scope: {
+      rgSomePermissions: '='
+    },
+    controller: ["$scope", function controller($scope) {
+      const permissions = [];
+      $scope.rgSomePermissions = false;
+
+      function checkPermissions() {
+        for (let i = permissions.length - 1; i >= 0; i--) {
+          if (permissions[i].permitted) {
+            $scope.rgSomePermissions = true;
+            return;
+          }
+        }
+
+        $scope.rgSomePermissions = false;
+      } //noinspection JSPotentiallyInvalidUsageOfThis
+
+
+      this.registerPermission = () => {
+        const permission = {
+          permitted: false
+        };
+        permissions.push(permission);
+        return permitted => {
+          permission.permitted = permitted;
+          checkPermissions();
+        };
+      };
+    }]
+  };
+});
+var permissionsNg = angularModule.name;
+
+export { permissionsNg as default };

package/dist/place-under-ng/place-under-ng.js

@@ -0,0 +1,157 @@
+import angular from 'angular';
+import debounce from 'just-debounce-it';
+import createResizeDetector from 'element-resize-detector';
+import { getDocumentScrollTop } from '../global/dom.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+
+const resizeDetector = createResizeDetector();
+const angularModule = angular.module('Ring.place-under', []);
+angularModule.directive('rgPlaceUnder', // eslint-disable-next-line angular/di-unused
+["$window", "getClosestElementWithCommonParent", "rgPlaceUnderHelper", function rgPlaceUnderDirective($window, getClosestElementWithCommonParent, rgPlaceUnderHelper) {
+  return {
+    restrict: 'A',
+    link: function link(scope, iElement, iAttrs) {
+      const element = iElement[0];
+      const synchronizer = rgPlaceUnderHelper.createPositionSynchronizer(element, iAttrs, scope);
+
+      function startSyncing(placeUnderSelector) {
+        if (placeUnderSelector) {
+          scope.$evalAsync(() => {
+            const syncWith = getClosestElementWithCommonParent(element, placeUnderSelector);
+
+            if (syncWith) {
+              synchronizer.syncPositionWith(syncWith);
+            } else {
+              throw new Error('rgPlaceUnder cannot find element to sync with.');
+            }
+          });
+        }
+      }
+
+      iAttrs.$observe('rgPlaceUnder', startSyncing);
+    }
+  };
+}]);
+angularModule.factory('getClosestElementWithCommonParent', function getClosestElementWithCommonParentFactory() {
+  return function getClosestElementWithCommonParent(currentElement, selector) {
+    const parent = currentElement.parentNode;
+
+    if (parent) {
+      return parent.querySelector(selector) || getClosestElementWithCommonParent(parent, selector);
+    } else {
+      return null;
+    }
+  };
+});
+angularModule.factory('rgPlaceUnderHelper', ["$window", $window => {
+  const DEBOUNCE_INTERVAL = 10;
+  const AFTER_SCROLL_RECHECK_INTERVAL = 50;
+  const HEIGHT_CHECK_INTERVAL = 50;
+  return {
+    DEBOUNCE_INTERVAL,
+    AFTER_SCROLL_RECHECK_INTERVAL,
+    HEIGHT_CHECK_INTERVAL,
+    createPositionSynchronizer: (element, iAttrs, scope) => {
+      const topOffset = parseInt(iAttrs.placeTopOffset, 10) || 0;
+      const syncHeight = iAttrs.syncHeight;
+      let syncBottom = [];
+      let removeScrollListener = [];
+
+      if (iAttrs.syncBottom) {
+        syncBottom = iAttrs.syncBottom.split(',');
+      }
+
+      function waitForNonZeroHeight(elementToCheck) {
+        return new Promise(resolve => {
+          function checkElementHeight() {
+            if (elementToCheck.offsetHeight === 0) {
+              $window.setTimeout(checkElementHeight, HEIGHT_CHECK_INTERVAL);
+            } else {
+              resolve();
+            }
+          }
+
+          checkElementHeight();
+        });
+      }
+
+      function onScroll(syncElement) {
+        const documentScrollTop = getDocumentScrollTop();
+        const documentOffsetHeight = $window.document.documentElement && $window.document.documentElement.offsetHeight || $window.document.body.offsetHeight;
+        const syncedElementHeight = syncElement.offsetHeight;
+        const syncedElementOffsetTop = syncElement.getBoundingClientRect().top + documentScrollTop;
+        const bottom = syncedElementOffsetTop + syncedElementHeight;
+        const margin = Math.max(bottom - documentScrollTop, syncedElementHeight);
+        element.style.marginTop = `${margin + topOffset}px`;
+
+        if (syncHeight) {
+          /**
+           * Decrease height by margin value to make scroll work properly
+           */
+          let bottomOffset = 0;
+
+          if (syncBottom.length) {
+            for (let i = 0; i < syncBottom.length; i++) {
+              const syncBottomParams = syncBottom[i].split(';');
+              const elem = $window.document.querySelector(syncBottomParams[0]);
+              const extraMargin = syncBottomParams[1] ? parseInt(syncBottomParams[1], 10) : 0;
+
+              if (elem) {
+                const boundingRect = elem.getBoundingClientRect();
+
+                if (boundingRect.top === 0) {
+                  continue;
+                }
+
+                const marginTop = parseInt($window.getComputedStyle(elem).getPropertyValue('margin-top'), 10);
+                bottomOffset = documentOffsetHeight - boundingRect.top + marginTop + extraMargin;
+
+                if (bottomOffset < 0) {
+                  bottomOffset = 0;
+                }
+
+                break;
+              }
+            }
+          }
+
+          element.style.height = `calc(100% - ${parseInt(element.style.marginTop, 10) + bottomOffset}px)`;
+        }
+      }
+
+      function removeScrollListeners() {
+        removeScrollListener.map(cb => cb());
+        removeScrollListener = [];
+      }
+
+      function syncPositionWith(syncElement) {
+        removeScrollListeners();
+        const afterScrollFinishRecheck = debounce(() => this.onScroll(syncElement), AFTER_SCROLL_RECHECK_INTERVAL);
+        const sidebarScrollListener = debounce(() => {
+          this.onScroll(syncElement);
+          afterScrollFinishRecheck();
+        }, DEBOUNCE_INTERVAL);
+        this.waitForNonZeroHeight(syncElement).then(sidebarScrollListener);
+        $window.addEventListener('scroll', sidebarScrollListener);
+        removeScrollListener.push(() => {
+          $window.removeEventListener('scroll', sidebarScrollListener);
+        });
+        removeScrollListener.push(scope.$watch('show', sidebarScrollListener));
+        removeScrollListener.push(scope.$on('rgPlaceUnder:sync', sidebarScrollListener));
+        const elementToHeightListening = iAttrs.listenToHeightChange ? $window.document.querySelector(iAttrs.listenToHeightChange) : $window.document.body;
+        resizeDetector.listenTo(elementToHeightListening, sidebarScrollListener);
+        removeScrollListener.push(() => resizeDetector.removeAllListeners(elementToHeightListening));
+      }
+
+      scope.$on('$destroy', removeScrollListeners);
+      return {
+        waitForNonZeroHeight,
+        onScroll,
+        syncPositionWith
+      };
+    }
+  };
+}]);
+var PlaceUnder = angularModule.name;
+
+export { PlaceUnder as default };

package/dist/popup/popup.js

@@ -1,4 +1,4 @@
-import { _ as _defineProperty, c as _objectSpread2 } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import { createPortal } from 'react-dom';
 import PropTypes from 'prop-types';
@@ -18,7 +18,7 @@ import 'combokeys';
 import '../global/sniffer.js';
 import 'sniffr';
 
-var modules_2f69e2e2 = {"popup":"popup_popup__d157c5ca global_font__0f8f4370","hidden":"popup_hidden__d157c5ca","showing":"popup_showing__d157c5ca","attached":"popup_attached__d157c5ca"};
+var modules_2f69e2e2 = {"popup":"popup_rui_d157 font_rui_750f","hidden":"hidden_rui_d157","showing":"showing_rui_d157","attached":"attached_rui_d157"};
 
 const stop = e => e.stopPropagation();
 
@@ -43,7 +43,7 @@ class Popup extends PureComponent {
 
     _defineProperty(this, "uid", getUID('popup-'));
 
-    _defineProperty(this, "calculateDisplay", prevState => _objectSpread2(_objectSpread2({}, prevState), {}, {
+    _defineProperty(this, "calculateDisplay", prevState => ({ ...prevState,
       display: this.props.hidden ? Display.SHOWING : Display.SHOWN
     }));
 
@@ -189,11 +189,12 @@ class Popup extends PureComponent {
       return acc;
     }, {});
     const container = this.getContainer();
-    return position(_objectSpread2({
+    return position({
       popup: this.popup,
       container: container && getStyles(container).position !== 'static' ? container : null,
-      anchor: this._getAnchor()
-    }, positionProps));
+      anchor: this._getAnchor(),
+      ...positionProps
+    });
   }
 
   _getAnchor() {
@@ -385,5 +386,4 @@ _defineProperty(Popup, "PopupProps", {
   MaxHeight
 });
 
-export default Popup;
-export { getPopupContainer };
+export { Popup as default, getPopupContainer };

package/dist/popup/popup.target.js

@@ -1,4 +1,4 @@
-import { a as _objectWithoutProperties, b as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { createContext, forwardRef } from 'react';
 import PropTypes from 'prop-types';
 
@@ -6,10 +6,9 @@ const PopupTargetContext = /*#__PURE__*/createContext();
 const PopupTarget = /*#__PURE__*/forwardRef(function PopupTarget(_ref, ref) {
   let {
     id,
-    children
-  } = _ref,
-      restProps = _objectWithoutProperties(_ref, ["id", "children"]);
-
+    children,
+    ...restProps
+  } = _ref;
   const isFunctionChild = typeof children === 'function';
   const target = /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
     "data-portaltarget": id,

package/dist/popup/position.js

@@ -276,5 +276,4 @@ function position(attrs) {
   };
 }
 
-export default position;
-export { maxHeightForDirection, positionPropKeys };
+export { position as default, maxHeightForDirection, positionPropKeys };